场景流送的激活屏障：加载完成不等于可以切换

// .tmp/daily-labs/2026-07-24-1930/scene-transition.js
// symbols: TransitionState, SceneTransition
export const TransitionState = Object.freeze({
  IDLE: "idle",
  LOADING: "loading",
  READY: "ready",
  ACTIVE: "active",
  ROLLED_BACK: "rolled_back",
});

export class SceneTransition {
  constructor(loader) {
    this.loader = loader;
    this.state = TransitionState.IDLE;
    this.loaded = new Map();
    this.activeScene = null;
  }
}

// .tmp/daily-labs/2026-07-24-1930/scene-transition.js
// symbol: SceneTransition.enter
async enter(scene) {
  if (this.state === TransitionState.LOADING) {
    throw new Error("transition already loading");
  }
  this.state = TransitionState.LOADING;
  const required = [...scene.requiredChunks];
  try {
    const results = await Promise.allSettled(
      required.map(async (id) => ({
        id,
        handle: await this.loader.load(id),
      })),
    );
    for (const result of results) {
      if (result.status === "fulfilled") {
        this.loaded.set(result.value.id, result.value.handle);
      }
    }
    const failed = results.find((r) => r.status === "rejected");
    if (failed) throw failed.reason;
    if (this.loaded.size !== required.length) {
      throw new Error("activation barrier incomplete");
    }
    this.state = TransitionState.READY;
    this.activeScene = scene.id;
    this.state = TransitionState.ACTIVE;
    return { scene: scene.id, chunks: [...this.loaded.keys()] };
  } catch (error) {
    await this.rollback();
    throw error;
  }
}

// .tmp/daily-labs/2026-07-24-1930/scene-transition.js
// symbol: SceneTransition.rollback
async rollback() {
  for (const handle of [...this.loaded.values()].reverse()) {
    await this.loader.release(handle);
  }
  this.loaded.clear();
  this.activeScene = null;
  this.state = TransitionState.ROLLED_BACK;
}

// .tmp/daily-labs/2026-07-24-1930/scene-transition.test.js
// symbols: failed chunk..., concurrent transition...
test("failed chunk rolls back loaded handles and blocks activation", async () => {
  const resources = loader("lighting");
  const transition = new SceneTransition(resources);
  await assert.rejects(
    transition.enter({
      id: "dungeon",
      requiredChunks: ["terrain", "lighting", "gameplay"],
    }),
    /load failed: lighting/,
  );
  assert.equal(transition.state, TransitionState.ROLLED_BACK);
  assert.equal(transition.activeScene, null);
  assert.equal(transition.loaded.size, 0);
  assert.deepEqual(resources.released, [
    "handle:gameplay",
    "handle:terrain",
  ]);
});

test("a concurrent transition cannot steal state ownership", async () => {
  const first = transition.enter({
    id: "a", requiredChunks: ["terrain"],
  });
  await assert.rejects(
    transition.enter({ id: "b", requiredChunks: ["terrain"] }),
    /already loading/,
  );
  resume();
  await first;
  assert.equal(transition.activeScene, "a");
});

$ cd $WORK_DIR/.tmp/daily-labs/2026-07-24-1930
$ npm test
✔ activates only after every required chunk is ready (1.36825ms)
✔ failed chunk rolls back loaded handles and blocks activation (0.307ms)
✔ a concurrent transition cannot steal state ownership (0.669042ms)
tests 3
pass 3
fail 0
skipped 0
duration_ms 48.203583
exit_code=0
real 0.18

$ npm run probe
{"input":{"scene":"dungeon","required":3},
"output":{"scene":"dungeon","chunks":["terrain","lighting","gameplay"]},
"state":"active",
"events":["load:terrain","load:lighting","load:gameplay"]}
exit_code=0