narraeon 0.4.0 → 0.5.1

package/dist/node/runtime/V1Runtime.js

@@ -1,26 +1,36 @@
+import { PackageScriptPermissions } from "./extension/PackageScriptPermissions.js";
+import { comparePromptPrefixes } from "./prompt/WorldPromptDiagnostics.js";
 import { join } from "node:path";
 import { maxPortableContentArchiveBase64Characters, maxPortableContentArchiveBytes, } from "../protocol/contentTree.js";
 import { V1ProtocolError, v1Protocol, } from "../protocol/v1.js";
 import { defaultAppLocale, } from "../protocol/appPreferences.js";
 import { ContentPackageImportError, ContentWorkspace, InvalidContentTreeError, } from "./content/ContentWorkspace.js";
+import { contentTreeFingerprint } from "./content/ContentTreeFingerprint.js";
 import { inspectContentPackageCurrentTree } from "./content/FileNativeContentTree.js";
-import { FileNativeModelHost, FileNativeSettingAuthorProvider, } from "./model/FileNativeModelAdapters.js";
-import {} from "./model/ModelHost.js";
+import { FileNativeModelHost } from "./model/FileNativeModelAdapters.js";
+import { equalModelHostBinding, } from "./model/ModelHost.js";
 import { ModelConnectionStore } from "./model/ModelConnectionStore.js";
 import { FileNativeContinuityCorrection } from "./play/FileNativeContinuityCorrection.js";
+import { fingerprintControl } from "./play/PlayDocumentTools.js";
 import { PlayCallChain, PlayCallChainError, } from "./play/PlayCallChain.js";
-import { FileNativePlayPresetError, FileNativePlayPresetStore, presetHostBinding, settingImprovementPromptForBinding, } from "./play/FileNativePlayPresetStore.js";
+import { FileNativePlayPresetError, FileNativePlayPresetStore, presetHostBinding, } from "./play/FileNativePlayPresetStore.js";
 import { buildPlayPresetWorkbenchSnapshot } from "./play/PlayPresetWorkbench.js";
 import { FileNativeArtifactStore } from "./artifact/FileNativeArtifactStore.js";
 import { projectArtifactForFrontend, projectDebugArtifactForFrontend, } from "./extension/FrontendExtensionBundle.js";
 import { projectPlayerViewPanels, } from "./extension/PlayerViewPanelProjector.js";
 import { FileNativePromptCompiler } from "./prompt/FileNativePromptCompiler.js";
-import { DocumentCandidateSettingImprovement } from "./setting/DocumentCandidateSettingImprovement.js";
+import { FileNativeSettingImprovementStore } from "./setting/FileNativeSettingImprovementStore.js";
+import { SettingImprovementRollbackError, SettingImprovementSession, } from "./setting/SettingImprovementSession.js";
 import { FileNativeWorldStore } from "./world/FileNativeWorldStore.js";
 import { WorldDocumentStore } from "./world/WorldDocumentStore.js";
 import { FileNativeAiFailureLog } from "./model/AiFailureLog.js";
 import { AppPreferencesStore } from "./config/AppPreferencesStore.js";
+import { FileNativeWorldRevisionStore } from "./world-revision/FileNativeWorldRevisionStore.js";
+import { WorldRevisionSession } from "./world-revision/WorldRevisionSession.js";
+import { WorldRevisionWorkspace, WorldRevisionWorkspaceError, } from "./world-revision/WorldRevisionWorkspace.js";
+import { ConversationChanges } from "./ConversationChanges.js";
 export class V1Runtime {
+    #conversationChanges = new ConversationChanges();
     #content;
     #playPresets;
     #worlds;
@@ -30,7 +40,8 @@ export class V1Runtime {
     #playCallChains;
     #failureLog;
     #preferences;
-    #settingImprovements = new Map();
+    #settingImprovements;
+    #worldRevisions;
     #compiler = new FileNativePromptCompiler();
     #locale = defaultAppLocale;
     constructor(input) {
@@ -47,9 +58,75 @@ export class V1Runtime {
             input.logRoot === undefined
                 ? undefined
                 : new FileNativeAiFailureLog(join(input.logRoot, "ai-failures"));
-        this.#playCallChains = new PlayCallChain(this.#worlds, this.#compiler, this.#artifacts, this.#failureLog);
+        this.#playCallChains = new PlayCallChain(this.#worlds, this.#compiler, this.#artifacts, this.#failureLog, (id) => this.#conversationChanges.publish(`play:${id}`));
         this.#models = new ModelConnectionStore(input.configRoot);
-        this.#corrections = new FileNativeContinuityCorrection(this.#worlds);
+        this.#corrections = new FileNativeContinuityCorrection(this.#worlds, {
+            compiler: this.#compiler,
+        });
+        this.#settingImprovements = new SettingImprovementSession({
+            changed: (id, durable) => this.#conversationChanges.publish(`setting:${id}`, durable),
+            store: new FileNativeSettingImprovementStore(input.dataRoot, {
+                content: this.#content,
+            }),
+            content: this.#content,
+            compiler: this.#compiler,
+            locale: () => this.#locale,
+            bindModelHost: () => this.#modelHost(),
+            bindExistingModelHost: (binding) => this.#matchingModelHost(binding),
+            bindPlayPreset: () => this.#playPresets.freeze(),
+            preview: (snapshot, modelBinding, playPreset) => this.#compiler.preview({
+                endpoint: { id: "setting-authoring", commit: "current-tree" },
+                hostBinding: playPreset === undefined
+                    ? {
+                        hostPresetId: "legacy-setting-authoring",
+                        files: defaultSettingPreviewHost(),
+                    }
+                    : presetHostBinding(playPreset),
+                world: previewWorld(snapshot, "setting-authoring.message.genesis.narrator", "setting-authoring"),
+                playerInputPlacement: "append",
+                playerInput: this.#locale === "zh-CN"
+                    ? "检查内容包当前树。"
+                    : "Inspect the content package current tree.",
+                modelBinding,
+            }, playPreset),
+        });
+        const worldRevisionStore = new FileNativeWorldRevisionStore(input.dataRoot);
+        const worldRevisionWorkspace = new WorldRevisionWorkspace({
+            store: worldRevisionStore,
+            worlds: this.#worlds,
+        });
+        this.#worldRevisions = new WorldRevisionSession({
+            changed: (id, durable) => this.#conversationChanges.publish(`revision:${id}`, durable),
+            store: worldRevisionStore,
+            workspace: worldRevisionWorkspace,
+            worlds: this.#worlds,
+            compiler: this.#compiler,
+            locale: () => this.#locale,
+            bindModelHost: () => this.#modelHost(),
+            bindExistingModelHost: (binding) => this.#matchingModelHost(binding),
+            bindPlayPreset: () => this.#playPresets.freeze(),
+            preview: ({ snapshot, modelBinding, playPreset, binding, epoch, maintenance, }) => this.#compiler.preview({
+                endpoint: {
+                    id: `${epoch.worldId}:${epoch.baseHead}:revision`,
+                    commit: `worktree:${contentTreeFingerprint(snapshot.files)}`,
+                    operationId: epoch.epochId,
+                },
+                hostBinding: presetHostBinding(playPreset),
+                world: {
+                    controlFingerprint: fingerprintControl(Object.fromEntries(snapshot.files.map(({ path, contents }) => [path, contents]))),
+                    documentSnapshot: snapshot,
+                    history: structuredClone(binding.history),
+                    narrativeCheckpoint: binding.narrativeCheckpoint,
+                    ...maintenance,
+                    additionalMaterials: structuredClone(binding.additionalMaterials),
+                },
+                playerInputPlacement: "append",
+                playerInput: this.#locale === "zh-CN"
+                    ? "检查世界修订工作树。"
+                    : "Inspect the world-revision worktree.",
+                modelBinding,
+            }, playPreset),
+        });
     }
     async initialize() {
         this.#locale = (await this.#preferences.view()).locale;
@@ -57,8 +134,58 @@ export class V1Runtime {
         await this.#playPresets.initialize();
     }
     async handle(request, playCallChainObserver) {
-        const result = await this.#dispatch(request, playCallChainObserver);
-        return { protocol: v1Protocol, result };
+        try {
+            const result = await this.#dispatch(request, playCallChainObserver);
+            return { protocol: v1Protocol, result };
+        }
+        finally {
+            // Explicit commands may partially settle before failing. Readers recover
+            // through the same Runtime projection, never infer success from this signal.
+            if (!/\.(read|status|overview|inspect|page|detail|list|preview)$/.test(request.type)) {
+                if ("packageId" in request)
+                    this.#conversationChanges.publish(`setting:${request.packageId}`);
+                if ("worldId" in request) {
+                    this.#conversationChanges.publish(`play:${request.worldId}`);
+                    this.#conversationChanges.publish(`revision:${request.worldId}`);
+                }
+            }
+        }
+    }
+    subscribeConversation(target, changed) {
+        return this.#conversationChanges.subscribe(`${target.kind}:${target.id}`, changed);
+    }
+    async readConversation(target, previous) {
+        switch (target.kind) {
+            case "play":
+                return {
+                    kind: "play",
+                    value: await this.#playCallChains.observeWorld(target.id),
+                    extensionsRevision: await this.#worlds.extensionControlsRevision(target.id),
+                };
+            case "setting": {
+                if (previous?.kind === "setting")
+                    return {
+                        kind: "setting",
+                        value: this.#settingImprovements.observeProgress(previous.value),
+                    };
+                const status = await this.#settingImprovements.status(target.id, target.sessionId);
+                const content = await this.#content.readCurrentTreeContentPackage(target.id);
+                return {
+                    kind: "setting",
+                    value: {
+                        ...status,
+                        revision: `${status.revision}:${contentTreeFingerprint(content.files)}`,
+                    },
+                };
+            }
+            case "revision":
+                return {
+                    kind: "revision",
+                    value: previous?.kind === "revision"
+                        ? this.#worldRevisions.observeProgress(previous.value)
+                        : await this.#worldRevisions.status(target.id, target.sessionId),
+                };
+        }
     }
     async #dispatch(request, playCallChainObserver) {
         switch (request.type) {
@@ -74,7 +201,12 @@ export class V1Runtime {
             case "preferences.read":
                 return this.#preferences.view();
             case "preferences.save": {
-                const preferences = await this.#preferences.save(request.locale);
+                const preferences = await this.#preferences.save({
+                    ...(request.locale === undefined ? {} : { locale: request.locale }),
+                    ...(request.reading === undefined
+                        ? {}
+                        : { reading: request.reading }),
+                });
                 this.#locale = preferences.locale;
                 this.#compiler.setLocale(this.#locale);
                 await this.#playPresets.syncBuiltinDefaultLocale();
@@ -94,6 +226,14 @@ export class V1Runtime {
                 return this.#models.listModels(request);
             case "content.create":
                 return this.#content.createCurrentTreeContentPackage();
+            case "content.scripts.read":
+                return this.#content.packageScriptPermissions(request.packageId);
+            case "content.scripts.set":
+                return this.#content.packageScriptPermissions(request.packageId, request.enabled);
+            case "world.package-scripts.read":
+                return this.#worlds.packageScriptPermissions(request.worldId);
+            case "world.package-scripts.set":
+                return this.#worlds.packageScriptPermissions(request.worldId, request.enabled);
             case "content.read":
                 return this.#content.readCurrentTreeContentPackage(request.packageId);
             case "content.replace":
@@ -108,7 +248,7 @@ export class V1Runtime {
             case "content.import": {
                 const archive = decodePortableContentArchive(request.archiveBase64);
                 try {
-                    return await this.#content.importPortableContentPackageArchive(archive);
+                    return await this.#content.importPortableContentPackageArchive(archive, request.title === undefined ? {} : { title: request.title });
                 }
                 catch (error) {
                     if (error instanceof ContentPackageImportError ||
@@ -126,82 +266,33 @@ export class V1Runtime {
                     base64: exported.archive.toString("base64"),
                 };
             }
-            case "setting-improvement.start": {
-                if (this.#settingImprovements.has(request.improvementId))
-                    throw new Error("Setting-improvement ID already exists");
-                const [package_, connection, preset] = await Promise.all([
-                    this.#content.readCurrentTreeContentPackage(request.packageId),
-                    this.#models.bind(),
-                    this.#playPresets.bindCurrent(),
-                ]);
-                const improvement = new DocumentCandidateSettingImprovement({
-                    files: package_.files,
-                    adapter: new FileNativeSettingAuthorProvider(connection, fetch, {
-                        ...(this.#failureLog === undefined
-                            ? {}
-                            : { failureLog: this.#failureLog }),
-                        operationId: request.improvementId,
-                        locale: this.#locale,
-                    }),
-                    authorPrompt: settingImprovementPromptForBinding(preset, this.#locale),
-                    locale: this.#locale,
-                    ...(this.#failureLog === undefined
-                        ? {}
-                        : { failureLog: this.#failureLog }),
-                    preview: (snapshot) => this.#compiler.preview({
-                        endpoint: { id: "setting-candidate", commit: "candidate" },
-                        hostBinding: {
-                            hostPresetId: "setting-candidate",
-                            files: defaultSettingPreviewHost(),
-                        },
-                        world: previewWorld(snapshot, "setting-candidate.message.genesis.narrator", "setting-candidate"),
-                        playerInputPlacement: "bootstrap",
-                        playerInput: this.#locale === "zh-CN"
-                            ? "预览设定候选。"
-                            : "Preview the setting candidate.",
-                        modelBinding: new FileNativeModelHost(connection).binding(),
-                    }),
-                });
-                if (this.#settingImprovements.has(request.improvementId))
-                    throw new Error("Setting-improvement ID already exists");
-                this.#settingImprovements.set(request.improvementId, {
-                    packageId: request.packageId,
-                    improvement,
-                });
+            case "setting-improvement.preview":
+                return this.#settingImprovements.preview(request.packageId, request.sessionId);
+            case "setting-improvement.read":
+                return this.#settingImprovements.read(request.packageId);
+            case "setting-improvement.status":
+                return this.#settingImprovements.status(request.packageId, request.sessionId);
+            case "setting-improvement.overview":
+                return this.#settingImprovements.overview(request.packageId);
+            case "setting-improvement.session.read":
+                return this.#settingImprovements.readSession(request.packageId, request.sessionId);
+            case "setting-improvement.session.delete":
+                return this.#settingImprovements.deleteSession(request.packageId, request.sessionId);
+            case "setting-improvement.rollback":
                 try {
-                    return await improvement.start({
-                        goal: request.goal,
-                        contextPaths: request.contextPaths,
-                        mode: request.mode,
-                    });
+                    return await this.#settingImprovements.rollback(request);
                 }
                 catch (error) {
-                    this.#settingImprovements.delete(request.improvementId);
+                    if (error instanceof SettingImprovementRollbackError)
+                        throw new V1ProtocolError("invalid_request", error.message, {
+                            cause: error,
+                        });
                     throw error;
                 }
-            }
-            case "setting-improvement.confirm":
-                return this.#settingImprovement(request.improvementId).improvement.confirmPlan();
-            // Answers while start/confirm is still awaiting the provider: those calls
-            // yield the event loop, so this read observes the run in flight.
-            case "setting-improvement.progress":
-                return this.#settingImprovement(request.improvementId).improvement.progress();
-            case "setting-improvement.revise-plan":
-                return this.#settingImprovement(request.improvementId).improvement.revisePlan(request.feedback);
-            case "setting-improvement.revise-candidate":
-                return this.#settingImprovement(request.improvementId).improvement.reviseCandidate(request.feedback);
-            case "setting-improvement.apply": {
-                const active = this.#settingImprovement(request.improvementId);
-                await active.improvement.apply(async (files) => {
-                    await this.#content.replaceCurrentTreeContentPackage(active.packageId, files);
-                });
-                this.#settingImprovements.delete(request.improvementId);
-                return { applied: true };
-            }
-            case "setting-improvement.discard":
-                this.#settingImprovement(request.improvementId).improvement.discard();
-                this.#settingImprovements.delete(request.improvementId);
-                return { discarded: true };
+            case "setting-improvement.message":
+                return this.#settingImprovements.send(request);
+            case "setting-improvement.cancel":
+                return this.#settingImprovements.cancel(request.sessionId);
             case "play.read":
                 return this.#playPresets.list();
             case "play.create":
@@ -230,7 +321,11 @@ export class V1Runtime {
                 const binding = request.presetId === undefined
                     ? await this.#playPresets.bindCurrent()
                     : await this.#playPresets.bindRevision(request.presetId, request.revision);
-                return buildPlayPresetWorkbenchSnapshot(binding);
+                if (request.worldId === undefined)
+                    return buildPlayPresetWorkbenchSnapshot(binding, undefined, request.draft);
+                const head = await this.#worlds.currentHead(request.worldId);
+                const playerViews = await this.#worlds.renderPlayerViewsAtHead(request.worldId, head);
+                return buildPlayPresetWorkbenchSnapshot(binding, { worldId: request.worldId, head, playerViews }, request.draft);
             }
             case "prompt.preview": {
                 const [package_, connection, playPreset] = await Promise.all([
@@ -268,6 +363,9 @@ export class V1Runtime {
                         appended: preview.initialAppend === undefined
                             ? []
                             : [
+                                ...(preview.initialAppend.beforePlayer === undefined
+                                    ? []
+                                    : [preview.initialAppend.beforePlayer.logical]),
                                 {
                                     kind: "player",
                                     text: preview.initialAppend.logical.text,
@@ -290,6 +388,8 @@ export class V1Runtime {
                 return this.#worlds.createFromContentPackage({
                     operationId: request.operationId,
                     sourcePackageId: request.packageId,
+                    sourcePackageTitle: package_.title,
+                    packageScriptGrants: await this.#content.readPackageScriptGrants(request.packageId),
                     packageFiles: package_.files,
                     prompt: {
                         hostBinding: presetHostBinding(preset),
@@ -303,15 +403,18 @@ export class V1Runtime {
                 return this.#worlds.renameWorld(request.worldId, request.name);
             case "world.delete":
                 return playCall(async () => {
+                    await this.#worlds.assertWorldRevisionUnlocked(request.worldId);
                     this.#playCallChains.forgetWorld(request.worldId);
                     return this.#worlds.deleteWorld(request.worldId);
                 });
             case "world.read": {
                 const head = await this.#worlds.currentHead(request.worldId);
                 const playerViews = await this.#worlds.renderPlayerViewsAtHead(request.worldId, head);
-                const [playerViewPanels, playTimeline] = await Promise.all([
-                    this.#frontendPlayerViewPanels(request.worldId, head, playerViews),
+                const extensionControls = await this.#currentExtensionControls(request.worldId);
+                const [playerViewPanels, playTimeline, revisionEpoch] = await Promise.all([
+                    this.#frontendPlayerViewPanels(request.worldId, head, playerViews, extensionControls),
                     this.#worlds.playTimeline.readPage(request.worldId, 40),
+                    this.#worldRevisions.activeEpoch(request.worldId),
                 ]);
                 return {
                     worldId: request.worldId,
@@ -325,27 +428,54 @@ export class V1Runtime {
                     artifacts: [],
                     extensions: [],
                     playerViewPanels,
+                    extensionControls,
+                    suppressedPlayerViewIds: await this.#suppressedPlayerViewIds(extensionControls),
                     artifactDebug: [],
                     playCallChain: null,
                     playTimeline,
+                    worldRevision: revisionEpoch,
                 };
             }
             case "world.surface.read":
                 return request.surface === "runtime"
                     ? this.#worlds.readSurface(request.worldId, "runtime")
                     : this.#worlds.readSurface(request.worldId, request.surface);
+            case "world.extensions.read":
+                return this.#worlds.extensionControls(request.worldId, await this.#playPresets.bindCurrent(), this.#locale);
+            case "world.extensions.set": {
+                const result = await this.#worlds.extensionControls(request.worldId, await this.#playPresets.bindCurrent(), this.#locale, request);
+                return result;
+            }
             case "world.play-decorations.read": {
-                const head = await this.#reconcileArtifacts(request.worldId);
-                const [artifacts, extensions, artifactDebug] = await Promise.all([
-                    this.#frontendProjection(request.worldId),
-                    this.#artifacts.readExtensionSummaries(request.worldId),
-                    this.#frontendDebug(request.worldId),
-                ]);
-                return { head, artifacts, extensions, artifactDebug };
+                for (;;) {
+                    const extensionControls = await this.#currentExtensionControls(request.worldId);
+                    const head = await this.#reconcileArtifacts(request.worldId);
+                    const [projection, artifactDebug] = await Promise.all([
+                        this.#frontendDecorations(request.worldId),
+                        this.#frontendDebug(request.worldId),
+                    ]);
+                    const playerViews = await this.#worlds.renderPlayerViewsAtHead(request.worldId, head);
+                    const playerViewPanels = await this.#frontendPlayerViewPanels(request.worldId, head, playerViews, extensionControls);
+                    const suppressedPlayerViewIds = await this.#suppressedPlayerViewIds(extensionControls);
+                    // Never attach a newer controls revision to a projection read before
+                    // that choice was accepted. Concurrent toggles restart this read.
+                    if ((await this.#worlds.extensionControlsRevision(request.worldId)) !==
+                        extensionControls.revision)
+                        continue;
+                    return {
+                        head,
+                        ...projection,
+                        artifactDebug,
+                        playerViews,
+                        playerViewPanels,
+                        extensionControls,
+                        suppressedPlayerViewIds,
+                    };
+                }
             }
             case "artifacts.read":
                 await this.#reconcileArtifacts(request.worldId);
-                return this.#frontendProjection(request.worldId, request.channel);
+                return (await this.#frontendDecorations(request.worldId, request.channel)).artifacts;
             case "artifacts.debug":
                 await this.#reconcileArtifacts(request.worldId);
                 return this.#frontendDebug(request.worldId, request.operationId);
@@ -355,6 +485,7 @@ export class V1Runtime {
                 return result;
             }
             case "world.control-draft.save":
+                await this.#worlds.assertWorldRevisionUnlocked(request.worldId);
                 return this.#worlds.saveControlDraft(request.worldId, request.files);
             case "world.control-draft.preview": {
                 const prompt = {
@@ -374,6 +505,33 @@ export class V1Runtime {
                 };
                 return this.#worlds.applyControlDraft(request.worldId, prompt);
             }
+            case "world.revision.open":
+                return this.#worldRevisionCall(() => this.#worldRevisions.open(request.worldId));
+            case "world.revision.overview":
+                return this.#worldRevisionCall(() => this.#worldRevisions.overview(request.worldId));
+            case "world.revision.preview":
+                return this.#worldRevisions.preview(request.worldId, request.sessionId);
+            case "world.revision.status":
+                return this.#worldRevisionCall(() => this.#worldRevisions.status(request.worldId, request.sessionId));
+            case "world.revision.session.read":
+                return this.#worldRevisionCall(() => this.#worldRevisions.readSession(request.worldId, request.sessionId));
+            case "world.revision.session.delete":
+                return this.#worldRevisionCall(() => this.#worldRevisions.deleteSession(request.worldId, request.sessionId));
+            case "world.revision.message":
+                return this.#worldRevisionCall(() => this.#worldRevisions.send(request));
+            case "world.revision.cancel":
+                return this.#worldRevisionCall(() => this.#worldRevisions.cancel(request.sessionId));
+            case "world.revision.files.replace":
+                return this.#worldRevisionCall(() => this.#worldRevisions.replaceFiles(request));
+            case "world.revision.rollback":
+                return this.#worldRevisionCall(() => this.#worldRevisions.rollback(request));
+            case "world.revision.apply": {
+                const result = await this.#worldRevisionCall(() => this.#worldRevisions.apply(request));
+                await this.#reconcileArtifacts(request.worldId);
+                return result;
+            }
+            case "world.revision.discard":
+                return this.#worldRevisionCall(() => this.#worldRevisions.discard(request));
             case "world.derive": {
                 const preset = await this.#playPresets.bindCurrent();
                 const result = await this.#playCallChains.deriveWorld({
@@ -386,18 +544,33 @@ export class V1Runtime {
                 return result;
             }
             case "play.chain.revise-player": {
-                const result = await playCall(() => this.#playCallChains.revisePlayer({
+                const base = {
                     operationId: request.operationId,
                     worldId: request.worldId,
                     chainId: request.chainId,
                     eventId: request.eventId,
                     replacementExchangeId: request.replacementExchangeId,
                     replacementText: request.replacementText,
-                }));
+                };
+                const result = await playCall(async () => {
+                    await this.#worlds.assertWorldRevisionUnlocked(request.worldId);
+                    if (request.continuation === "continue_context")
+                        return this.#playCallChains.revisePlayer({
+                            ...base,
+                            continuation: request.continuation,
+                        });
+                    const { hostBinding, playPreset, modelBinding } = await this.#continuousBinding();
+                    return this.#playCallChains.revisePlayer({
+                        ...base,
+                        continuation: request.continuation,
+                        freshContext: { hostBinding, playPreset, modelBinding },
+                    });
+                });
                 await this.#reconcileArtifacts(request.worldId);
                 return result;
             }
             case "play.chain.start": {
+                await this.#worlds.assertWorldRevisionUnlocked(request.worldId);
                 const { modelHost, hostBinding, playPreset, modelBinding } = await this.#continuousBinding();
                 return playCall(() => this.#playCallChains.start({
                     worldId: request.worldId,
@@ -414,16 +587,20 @@ export class V1Runtime {
                 }));
             }
             case "play.chain.append":
-                return playCall(async () => this.#playCallChains.append({
-                    worldId: request.worldId,
-                    chainId: request.chainId,
-                    exchangeId: request.exchangeId,
-                    playerText: request.playerText,
-                    modelHost: await this.#modelHost(),
-                    ...(playCallChainObserver === undefined
-                        ? {}
-                        : { observer: playCallChainObserver }),
-                }));
+                return playCall(async () => {
+                    await this.#worlds.assertWorldRevisionUnlocked(request.worldId);
+                    return this.#playCallChains.append({
+                        worldId: request.worldId,
+                        chainId: request.chainId,
+                        exchangeId: request.exchangeId,
+                        playerText: request.playerText,
+                        modelHost: await this.#modelHost(),
+                        resolvePrompt: () => this.#continuousBinding(),
+                        ...(playCallChainObserver === undefined
+                            ? {}
+                            : { observer: playCallChainObserver }),
+                    });
+                });
             case "play.chain.cancel":
                 return playCall(() => this.#playCallChains.cancel({
                     worldId: request.worldId,
@@ -438,6 +615,88 @@ export class V1Runtime {
             case "play.timeline.detail":
                 await this.#worlds.ensureCurrentStorage(request.worldId);
                 return this.#worlds.playTimeline.readDetail(request.worldId, request.chainId, request.eventId);
+            case "world.play-context.read": {
+                const binding = await this.#worlds.bindPlayCallChain(request.worldId);
+                const currentContext = await this.#playCallChains.inspectReading(request.worldId, binding.parentHead);
+                const model = await this.#models.view();
+                if (!model.configured)
+                    return {
+                        worldId: request.worldId,
+                        worldHead: binding.parentHead,
+                        currentContext,
+                        nextFreshContext: null,
+                    };
+                const { modelHost, hostBinding, playPreset, modelBinding } = await this.#continuousBinding();
+                const persisted = currentContext === null
+                    ? null
+                    : await this.#worlds.playTimeline.readCurrent(request.worldId);
+                const frozenBinding = persisted?.value.modelBinding;
+                const continueContext = currentContext !== null &&
+                    !currentContext.stale &&
+                    frozenBinding !== undefined &&
+                    equalModelHostBinding(frozenBinding, modelBinding);
+                const baseline = continueContext
+                    ? await this.#worlds.bindPlayCallChainAt(request.worldId, currentContext.baselineHead)
+                    : binding;
+                const preview = this.#compiler.preview({
+                    extensionControls: await this.#worlds.extensionControls(request.worldId, playPreset, this.#locale),
+                    endpoint: {
+                        id: `${request.worldId}:${binding.parentHead}`,
+                        commit: binding.parentHead,
+                    },
+                    hostBinding,
+                    world: {
+                        controlFingerprint: fingerprintControl(binding.files),
+                        documentSnapshot: WorldDocumentStore.open({
+                            layout: "world_state",
+                            files: Object.entries(binding.files).map(([path, contents]) => ({ path, contents })),
+                        }),
+                        additionalMaterials: structuredClone(binding.additionalMaterials),
+                        history: structuredClone(binding.history),
+                        narrativeCheckpoint: baseline.narrativeCheckpoint,
+                        historyAlreadyAppended: Object.keys(binding.history).filter((key) => !(key in baseline.history)),
+                        ...(await this.#worlds.inspectDocumentMaintenance(request.worldId, binding.parentHead)),
+                    },
+                    playerInputPlacement: "append",
+                    playerInput: "",
+                    modelBinding,
+                }, playPreset);
+                const tools = preview.compilation.toolUniverse;
+                const nextEncoding = modelHost.previewRequest({
+                    bootstrap: preview.compilation,
+                    tools,
+                    toolUniverse: tools,
+                    allowedTools: tools.map(({ name }) => name),
+                    toolStrategy: preview.compilation.toolStrategy,
+                    appended: continueContext ? (persisted?.value.transcript ?? []) : [],
+                    operationId: continueContext
+                        ? currentContext.chainId
+                        : "next-fresh-context-preview",
+                    maxOutputTokens: modelBinding.maxOutputTokens,
+                });
+                const currentEncoding = currentContext === null
+                    ? null
+                    : await this.#worlds.playTimeline
+                        .readInitialEncoding(request.worldId, currentContext.chainId, currentContext.requestExchange)
+                        .catch(() => null);
+                const prefixDiagnostics = comparePromptPrefixes(currentContext === null
+                    ? null
+                    : {
+                        bootstrap: currentContext.bootstrap,
+                        encoding: currentEncoding,
+                    }, { bootstrap: preview.compilation, encoding: nextEncoding });
+                return {
+                    worldId: request.worldId,
+                    worldHead: binding.parentHead,
+                    currentContext,
+                    nextFreshContext: {
+                        contextMode: continueContext ? "append" : "fresh",
+                        head: binding.parentHead,
+                        preview,
+                        prefixDiagnostics,
+                    },
+                };
+            }
             case "correction.begin":
                 return this.#corrections.begin({
                     worldId: request.worldId,
@@ -450,12 +709,14 @@ export class V1Runtime {
                 return this.#corrections.patchDocument(request);
             case "correction.replace":
                 return this.#corrections.replaceDocument(request);
-            case "correction.preview":
+            case "correction.preview": {
+                const { hostBinding, modelBinding, playPreset } = await this.#continuousBinding();
                 return this.#corrections.preview({
                     candidateId: request.candidateId,
                     expectedVersion: request.expectedVersion,
-                    prompt: await this.#promptBinding(),
+                    prompt: { hostBinding, modelBinding, playPreset },
                 });
+            }
             case "correction.apply": {
                 const result = await this.#corrections.apply(request);
                 await this.#reconcileResultArtifacts(result);
@@ -469,6 +730,21 @@ export class V1Runtime {
     async #modelHost() {
         return new FileNativeModelHost(await this.#models.bind(), fetch, this.#failureLog);
     }
+    async #worldRevisionCall(operation) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (error instanceof WorldRevisionWorkspaceError)
+                throw new V1ProtocolError("invalid_request", error.message, {
+                    cause: error,
+                });
+            throw error;
+        }
+    }
+    async #matchingModelHost(binding) {
+        return new FileNativeModelHost(await this.#models.bindMatching(binding), fetch, this.#failureLog);
+    }
     async #reconcileArtifacts(worldId) {
         const [head, currentOperationId] = await Promise.all([
             this.#worlds.currentHead(worldId),
@@ -477,19 +753,71 @@ export class V1Runtime {
         await this.#artifacts.reconcileHead(worldId, head, currentOperationId ?? undefined);
         return head;
     }
-    async #frontendProjection(worldId, channel) {
-        const artifacts = await this.#artifacts.readActiveProjection(worldId, channel);
-        return Promise.all(artifacts.map(async (artifact) => {
+    async #frontendDecorations(worldId, channel) {
+        await this.#currentExtensionControls(worldId);
+        const summaries = await this.#artifacts.readExtensionSummaries(worldId);
+        const targets = await this.#worlds.playTimeline.resolveReplies(worldId, summaries.flatMap((item) => item.attachment === undefined ? [] : [item.attachment]));
+        const matches = (attachment) => targets.find((target) => target.contextId === attachment.contextId &&
+            target.eventId === attachment.eventId &&
+            target.head === attachment.head);
+        const extensions = summaries
+            .filter((item) => item.attachment === undefined ||
+            matches(item.attachment) !== undefined)
+            .sort((left, right) => Number(left.head?.replace("commit:", "") ?? 0) -
+            Number(right.head?.replace("commit:", "") ?? 0));
+        const artifacts = await this.#artifacts.readActiveProjection(worldId, channel, targets);
+        const projected = (await Promise.all(artifacts.map(async (artifact) => {
             const { renderer, ...safeArtifact } = artifact;
             void renderer;
             const resolved = await this.#frontendBinding(artifact.playPresetId, artifact.playPresetRevision);
             return {
                 ...safeArtifact,
-                frontend: projectArtifactForFrontend(artifact, resolved.binding, resolved.failure),
+                ...(artifact.attachment === undefined
+                    ? {}
+                    : {
+                        reply: matches(artifact.attachment),
+                    }),
+                frontend: projectArtifactForFrontend(artifact, resolved.binding, resolved.failure, artifact.requestId.startsWith("package:") &&
+                    artifact.frozenPresentation !== undefined &&
+                    (await this.#worlds.readPackageScriptGrants(worldId)).includes(PackageScriptPermissions.fingerprint(artifact.frozenPresentation.files))),
             };
-        }));
+        }))).filter((artifact) => artifact.frontend.mount !== "story" || artifact.reply !== undefined);
+        return { artifacts: projected, extensions };
+    }
+    async #currentExtensionControls(worldId) {
+        try {
+            return await this.#worlds.extensionControls(worldId, await this.#playPresets.bindCurrent(), this.#locale);
+        }
+        catch (error) {
+            if (!(error instanceof FileNativePlayPresetError))
+                throw error;
+            return {
+                revision: await this.#worlds.extensionControlsRevision(worldId),
+                items: [],
+            };
+        }
+    }
+    async #suppressedPlayerViewIds(controls) {
+        let binding;
+        try {
+            binding = await this.#playPresets.bindCurrent();
+        }
+        catch (error) {
+            if (error instanceof FileNativePlayPresetError)
+                return [];
+            throw error;
+        }
+        // Every declared panel owns its view's fallback even while hidden.
+        return [
+            ...new Set([
+                ...binding.definition.playerViewPanels.map((panel) => panel.source.view),
+                ...controls.items
+                    .filter((item) => item.kind === "view" && !item.enabled)
+                    .map((item) => item.id),
+            ]),
+        ];
     }
-    async #frontendPlayerViewPanels(worldId, head, playerViews) {
+    async #frontendPlayerViewPanels(worldId, head, playerViews, controls) {
         try {
             const binding = await this.#playPresets.bindCurrent();
             return projectPlayerViewPanels({
@@ -497,7 +825,7 @@ export class V1Runtime {
                 head,
                 playerViews,
                 binding,
-            });
+            }).filter((panel) => controls.items.some((item) => item.kind === "panel" && item.id === panel.panelId && item.enabled));
         }
         catch (error) {
             // Panels are decoration on top of a world read. Any unusable preset —
@@ -516,7 +844,9 @@ export class V1Runtime {
             const resolved = await this.#frontendBinding(record.playPresetId, record.playPresetRevision);
             return {
                 ...safeRecord,
-                frontend: projectDebugArtifactForFrontend(record, resolved.binding, resolved.failure),
+                frontend: projectDebugArtifactForFrontend(record, resolved.binding, resolved.failure, record.requestId.startsWith("package:") &&
+                    record.frozenPresentation !== undefined &&
+                    (await this.#worlds.readPackageScriptGrants(worldId)).includes(PackageScriptPermissions.fingerprint(record.frozenPresentation.files))),
             };
         }));
     }
@@ -556,12 +886,6 @@ export class V1Runtime {
             return;
         await this.#reconcileArtifacts(worldId);
     }
-    #settingImprovement(improvementId) {
-        const active = this.#settingImprovements.get(improvementId);
-        if (active === undefined)
-            throw new Error("Setting-improvement session does not exist");
-        return active;
-    }
     async #promptBinding() {
         const [preset, connection] = await Promise.all([
             this.#playPresets.bindCurrent(),