@skenora/sdk 0.1.2

package/dist/scene-plan/executor.js

@@ -0,0 +1,928 @@
+import { EditorRuntimeProjectionError, } from "@skenora/babylon-editor";
+import { createSceneDocumentRevisionHash, EditorRevisionConflictError, } from "@skenora/editor";
+import { compileSceneBlueprint, compileScenePatch, createDiagnostic, } from "@skenora/scene-plan";
+import { createResourceBindingScope, createResourceBindingTable, ResourceBindingValidationError, } from "@skenora/resources";
+import { findUnavailableSceneCapabilities, SceneCapabilityUnavailableError, } from "@skenora/contracts";
+import { materializeScenePatch } from "./apply-patch.js";
+export class ScenePlanExecutor {
+    editor;
+    bridge;
+    resources;
+    sessionEpoch;
+    capabilities;
+    context;
+    #initialCapabilityAvailability;
+    #getCapabilityAvailability;
+    #controller = new AbortController();
+    #operations = new Map();
+    #idempotency = new Map();
+    #abortListener;
+    #queue = Promise.resolve();
+    #disposed = false;
+    constructor(options) {
+        if (options.bridge.editor !== options.editor) {
+            throw new Error("ScenePlanExecutor bridge and editor must be the same session");
+        }
+        if (options.bridge.resources !== options.resources) {
+            throw new Error("ScenePlanExecutor bridge and resources must use the same resolver");
+        }
+        this.editor = options.editor;
+        this.bridge = options.bridge;
+        this.resources = options.resources;
+        this.sessionEpoch = options.sessionEpoch ?? createSessionEpoch();
+        this.capabilities = cloneFrozenCapabilities(options.capabilities ?? []);
+        const observedAvailability = options.context?.capabilityAvailability;
+        this.#initialCapabilityAvailability = observedAvailability
+            ? cloneFrozenAvailability(observedAvailability)
+            : undefined;
+        this.#getCapabilityAvailability = options.getCapabilityAvailability;
+        this.context = {
+            ...options.context,
+            ...(observedAvailability === undefined
+                ? {}
+                : {
+                    capabilityAvailability: this.#initialCapabilityAvailability,
+                }),
+        };
+        if (options.signal) {
+            const listener = () => this.#controller.abort();
+            this.#abortListener = listener;
+            if (options.signal.aborted)
+                this.#controller.abort();
+            else
+                options.signal.addEventListener("abort", listener, { once: true });
+        }
+        else {
+            this.#abortListener = null;
+        }
+    }
+    get revisionToken() {
+        this.#assertActive();
+        return this.#createRevisionToken();
+    }
+    inspectScene(options = {}) {
+        this.#assertActive();
+        const document = this.editor.snapshot;
+        const capabilityAvailability = this.#readCapabilityAvailability();
+        const revisionToken = this.#createRevisionToken();
+        return Object.freeze({
+            sceneId: document.id,
+            sceneName: document.name,
+            revisionToken,
+            counts: Object.freeze({
+                assets: Object.keys(document.assets).length,
+                entities: Object.keys(document.entities).length,
+                materials: Object.keys(document.materials).length,
+                materialBindings: Object.keys(document.materialBindings).length,
+                textureAnimations: Object.keys(document.textureAnimations).length,
+                cameraPaths: Object.keys(document.cameraPaths).length,
+                lights: document.lights.length,
+                flows: Object.keys(document.flows).length,
+            }),
+            capabilities: cloneFrozenCapabilities(this.capabilities),
+            outline: createSceneOutlinePage(document, revisionToken, options),
+            ...(capabilityAvailability === undefined
+                ? {}
+                : { capabilityAvailability }),
+        });
+    }
+    validateBlueprint(input, options = {}) {
+        this.#assertActive();
+        try {
+            const prepared = this.#prepareBindings(options);
+            const result = compileSceneBlueprint(input, prepared.context);
+            return {
+                valid: result.ok,
+                planKind: "blueprint",
+                ...(result.planHash === undefined ? {} : { planHash: result.planHash }),
+                sourceMappings: result.sourceMappings,
+                diagnostics: result.diagnostics,
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                planKind: "blueprint",
+                diagnostics: [validationSetupDiagnostic(error)],
+            };
+        }
+    }
+    validatePatch(input, options = {}) {
+        this.#assertActive();
+        try {
+            const prepared = this.#prepareBindings(options);
+            const document = this.editor.snapshot;
+            const context = {
+                ...prepared.context,
+                document,
+                documentRevision: this.editor.revision,
+                documentHash: createSceneDocumentRevisionHash(document),
+            };
+            const result = compileScenePatch(input, context);
+            return {
+                valid: result.ok,
+                planKind: "patch",
+                ...(result.planHash === undefined ? {} : { planHash: result.planHash }),
+                diagnostics: result.diagnostics,
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                planKind: "patch",
+                diagnostics: [validationSetupDiagnostic(error)],
+            };
+        }
+    }
+    validatePlan(input, options = {}) {
+        return detectPlanKind(input) === "patch"
+            ? this.validatePatch(input, options)
+            : this.validateBlueprint(input, options);
+    }
+    applyPlan(input, options = {}) {
+        this.#assertActive();
+        const kind = detectPlanKind(input);
+        if (kind === "patch")
+            return this.applyPatch(input, options);
+        if (kind === "blueprint")
+            return this.applyBlueprint(input, options);
+        const operationId = resolveOperationId(options.operationId);
+        return Promise.resolve(this.#result(operationId, options, "rejected", undefined, [
+            diagnostic("invalid-input", "Plan must be a SceneBlueprint or ScenePatch"),
+        ]));
+    }
+    applyBlueprint(input, options = {}) {
+        this.#assertActive();
+        const operationId = resolveOperationId(options.operationId);
+        const fingerprint = createOperationFingerprint("blueprint", input, options);
+        const existing = this.#findExisting(operationId, options.idempotencyKey, options.operationNamespace, fingerprint);
+        if (existing)
+            return existing;
+        return this.#schedule(operationId, options, fingerprint, () => this.#runBlueprint(operationId, input, options));
+    }
+    applyPatch(input, options = {}) {
+        this.#assertActive();
+        const operationId = resolveOperationId(options.operationId);
+        const fingerprint = createOperationFingerprint("patch", input, options);
+        const existing = this.#findExisting(operationId, options.idempotencyKey, options.operationNamespace, fingerprint);
+        if (existing)
+            return existing;
+        return this.#schedule(operationId, options, fingerprint, () => this.#runPatch(operationId, input, options));
+    }
+    waitOperation(operationId, options = {}) {
+        return (this.#operations.get(operationMapKey(options.operationNamespace, operationId))?.result ?? null);
+    }
+    dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        this.#controller.abort();
+        this.#operations.clear();
+        this.#idempotency.clear();
+    }
+    #schedule(operationId, options, fingerprint, work) {
+        const run = this.#queue.then(() => work(), () => work());
+        const result = run.catch((error) => this.#result(operationId, options, "failed", undefined, [
+            executionDiagnostic(error),
+        ]));
+        this.#queue = result.then(() => undefined, () => undefined);
+        const record = Object.freeze({ fingerprint, result });
+        this.#operations.set(operationMapKey(options.operationNamespace, operationId), record);
+        if (options.idempotencyKey) {
+            this.#idempotency.set(operationMapKey(options.operationNamespace, options.idempotencyKey), record);
+        }
+        return result;
+    }
+    async #runBlueprint(operationId, input, options) {
+        const before = structuredClone(this.editor.snapshot);
+        const operationSignal = linkSignals(this.#controller.signal, options.signal);
+        const acquisition = {};
+        try {
+            this.#assertNotAborted(operationSignal.signal);
+            const expected = this.#resolveExpected(options);
+            this.#assertCurrentExpected(expected);
+            const prepared = this.#prepareBindings(options);
+            const compiled = compileSceneBlueprint(input, prepared.context);
+            if (!compiled.ok || !compiled.document) {
+                return this.#result(operationId, options, "rejected", "blueprint", compiled.diagnostics, compiled.planHash);
+            }
+            this.#assertCurrentExpected(expected);
+            const requiredResources = compiled.sourceMappings
+                .filter((mapping) => mapping.kind === "resource")
+                .map((mapping) => mapping.id);
+            const resourceSummary = await this.#acquireResources(prepared.table, requiredResources, operationSignal.signal, (scope) => {
+                acquisition.scope = scope;
+            });
+            this.#assertNotAborted(operationSignal.signal);
+            this.#assertCurrentCapabilities(compiled.document);
+            this.#assertCurrentExpected(expected);
+            const commit = this.editor.commitCandidateAtRevision(compiled.document, {
+                expectedRevision: expected.revision,
+                ...(expected.documentHash === undefined
+                    ? {}
+                    : { expectedDocumentHash: expected.documentHash }),
+                label: options.label ?? "Apply SceneBlueprint",
+            });
+            const projection = await this.#project(operationId, commit.revision, commit.changeId, options.modelLoadPolicy);
+            const diagnostics = projection.diagnostics;
+            return this.#result(operationId, options, "committed", "blueprint", diagnostics, compiled.planHash, commit, diffDocuments(before, this.editor.snapshot), resourceSummary, projection.summary);
+        }
+        catch (error) {
+            return this.#result(operationId, options, isAbortError(error) ? "cancelled" : "rejected", "blueprint", [executionDiagnostic(error)]);
+        }
+        finally {
+            acquisition.scope?.dispose();
+            operationSignal.dispose();
+        }
+    }
+    async #runPatch(operationId, input, options) {
+        const before = structuredClone(this.editor.snapshot);
+        const operationSignal = linkSignals(this.#controller.signal, options.signal);
+        const acquisition = {};
+        try {
+            this.#assertNotAborted(operationSignal.signal);
+            const expected = this.#resolveExpected(options);
+            this.#assertCurrentExpected(expected);
+            const prepared = this.#prepareBindings(options);
+            const currentDocument = this.editor.snapshot;
+            const currentHash = createSceneDocumentRevisionHash(currentDocument);
+            const context = {
+                ...prepared.context,
+                document: currentDocument,
+                documentRevision: this.editor.revision,
+                documentHash: currentHash,
+            };
+            const compiled = compileScenePatch(input, context);
+            if (!compiled.ok || !compiled.candidate || !compiled.patch) {
+                return this.#result(operationId, options, "rejected", "patch", compiled.diagnostics, compiled.planHash);
+            }
+            if (compiled.patch.target.expectedRevision !== expected.revision) {
+                return this.#result(operationId, options, "rejected", "patch", [
+                    diagnostic("revision-conflict", "Patch target revision does not match the executor precondition"),
+                ], compiled.planHash);
+            }
+            const candidate = materializeScenePatch(currentDocument, compiled.candidate, prepared.table);
+            this.#assertCurrentExpected(expected);
+            const requiredResources = unique(compiled.candidate.operations
+                .filter((operation) => operation.target.kind === "resource" && operation.op !== "remove")
+                .map((operation) => operation.target.id));
+            const resourceSummary = await this.#acquireResources(prepared.table, requiredResources, operationSignal.signal, (scope) => {
+                acquisition.scope = scope;
+            });
+            this.#assertNotAborted(operationSignal.signal);
+            this.#assertCurrentCapabilities(candidate);
+            this.#assertCurrentExpected(expected);
+            const expectedDocumentHash = compiled.patch.target.expectedDocumentHash ?? expected.documentHash;
+            const commit = this.editor.commitCandidateAtRevision(candidate, {
+                expectedRevision: compiled.patch.target.expectedRevision,
+                ...(expectedDocumentHash === undefined ? {} : { expectedDocumentHash }),
+                label: options.label ?? "Apply ScenePatch",
+            });
+            const projection = await this.#project(operationId, commit.revision, commit.changeId, options.modelLoadPolicy);
+            return this.#result(operationId, options, "committed", "patch", projection.diagnostics, compiled.planHash, commit, diffDocuments(before, this.editor.snapshot), resourceSummary, projection.summary);
+        }
+        catch (error) {
+            return this.#result(operationId, options, isAbortError(error) ? "cancelled" : "rejected", "patch", [executionDiagnostic(error)]);
+        }
+        finally {
+            acquisition.scope?.dispose();
+            operationSignal.dispose();
+        }
+    }
+    async #project(operationId, revision, changeId, modelLoadPolicy) {
+        let result;
+        try {
+            result = await this.bridge.flushProjection({
+                operationId,
+                sourceRevision: revision,
+                changeId,
+                ...(modelLoadPolicy === undefined ? {} : { modelLoadPolicy }),
+            });
+            if (!result) {
+                result = await this.bridge.projectCurrentDocument({
+                    operationId,
+                    sourceRevision: revision,
+                    changeId,
+                    ...(modelLoadPolicy === undefined ? {} : { modelLoadPolicy }),
+                });
+            }
+        }
+        catch (error) {
+            return {
+                summary: {
+                    status: "failed",
+                    operationId,
+                    modelFailureEntityIds: [],
+                },
+                diagnostics: [projectionDiagnostic(error)],
+            };
+        }
+        if (!result) {
+            return {
+                summary: {
+                    status: "skipped",
+                    operationId,
+                    modelFailureEntityIds: [],
+                },
+                diagnostics: [
+                    diagnostic("projection-unavailable", "EditorRuntimeBridge did not create a projection operation", "warning"),
+                ],
+            };
+        }
+        const summary = projectionSummary(result);
+        if (result.status === "partial") {
+            return {
+                summary,
+                diagnostics: [
+                    diagnostic("runtime-projection-partial", "Scene committed, but one or more models failed during projection", "warning"),
+                ],
+            };
+        }
+        if (result.status === "failed" || result.status === "cancelled") {
+            return {
+                summary,
+                diagnostics: [projectionDiagnostic(result.error)],
+            };
+        }
+        return { summary, diagnostics: [] };
+    }
+    async #acquireResources(table, assetRefs, signal, onScope) {
+        if (assetRefs.length === 0) {
+            return {
+                required: Object.freeze([...assetRefs]),
+                acquired: Object.freeze([]),
+                failed: Object.freeze([]),
+            };
+        }
+        if (!table) {
+            throw new Error("ScenePlan resource operations require host-created resource bindings");
+        }
+        const scope = createResourceBindingScope(this.resources, table, { signal });
+        onScope(scope);
+        const leases = scope.acquireAll(assetRefs);
+        const acquired = [];
+        const failed = [];
+        for (const lease of leases) {
+            try {
+                await lease.resource;
+                acquired.push(lease.assetRef);
+            }
+            catch {
+                failed.push(lease.assetRef);
+            }
+        }
+        this.#assertNotAborted(signal);
+        if (failed.length > 0) {
+            throw new Error("Resource acquisition failed: " + failed.join(", "));
+        }
+        return {
+            required: Object.freeze([...assetRefs]),
+            acquired: Object.freeze(acquired),
+            failed: Object.freeze(failed),
+        };
+    }
+    #prepareBindings(options) {
+        const allowVariables = options.allowVariables ?? this.context.allowVariables;
+        const capabilityAvailability = this.#readCapabilityAvailability();
+        const context = {
+            ...this.context,
+            ...(capabilityAvailability === undefined
+                ? {}
+                : { capabilityAvailability }),
+            ...(this.capabilities.length === 0
+                ? {}
+                : { capabilities: this.capabilities }),
+            ...(allowVariables === undefined ? {} : { allowVariables }),
+        };
+        if (options.resourceBindings === undefined &&
+            options.resourceRequirements === undefined) {
+            return { context };
+        }
+        const table = createResourceBindingTable(options.resourceBindings ?? [], options.resourceRequirements ?? [], { allowAdditionalBindings: true });
+        const resourceBindings = {};
+        for (const binding of table.bindings) {
+            resourceBindings[binding.assetRef] = structuredClone(binding.asset);
+        }
+        return {
+            table,
+            context: {
+                ...context,
+                resourceBindings,
+            },
+        };
+    }
+    #readCapabilityAvailability() {
+        try {
+            const observed = this.#getCapabilityAvailability
+                ? this.#getCapabilityAvailability()
+                : this.#initialCapabilityAvailability;
+            return observed === undefined
+                ? undefined
+                : cloneFrozenAvailability(observed);
+        }
+        catch {
+            throw new CapabilityAvailabilityReadError();
+        }
+    }
+    #assertCurrentCapabilities(document) {
+        const availability = this.#readCapabilityAvailability();
+        if (availability === undefined)
+            return;
+        const unavailable = findUnavailableSceneCapabilities(document, availability)[0];
+        if (unavailable)
+            throw new SceneCapabilityUnavailableError(unavailable);
+    }
+    #resolveExpected(options) {
+        const token = options.expectedRevisionToken;
+        if (token) {
+            if (token.sceneId !== this.editor.snapshot.id) {
+                throw new Error("Revision token sceneId does not match the active scene");
+            }
+            if (token.sessionEpoch !== this.sessionEpoch) {
+                throw new Error("Revision token belongs to another executor session");
+            }
+            return {
+                revision: token.revision,
+                documentHash: token.documentHash,
+            };
+        }
+        return {
+            revision: options.expectedRevision ?? this.editor.revision,
+            ...(options.expectedDocumentHash === undefined
+                ? {}
+                : { documentHash: options.expectedDocumentHash }),
+        };
+    }
+    #assertCurrentExpected(expected) {
+        const actualRevision = this.editor.revision;
+        const actualHash = createSceneDocumentRevisionHash(this.editor.snapshot);
+        if (actualRevision !== expected.revision) {
+            throw new EditorRevisionConflictError({
+                reason: "revision",
+                expectedRevision: expected.revision,
+                actualRevision,
+                expectedDocumentHash: expected.documentHash ?? null,
+                actualDocumentHash: actualHash,
+            });
+        }
+        if (expected.documentHash !== undefined &&
+            actualHash !== expected.documentHash) {
+            throw new EditorRevisionConflictError({
+                reason: "document-hash",
+                expectedRevision: expected.revision,
+                actualRevision,
+                expectedDocumentHash: expected.documentHash,
+                actualDocumentHash: actualHash,
+            });
+        }
+    }
+    #createRevisionToken() {
+        const document = this.editor.snapshot;
+        return Object.freeze({
+            sceneId: document.id,
+            sessionEpoch: this.sessionEpoch,
+            revision: this.editor.revision,
+            documentHash: createSceneDocumentRevisionHash(document),
+        });
+    }
+    #findExisting(operationId, idempotencyKey, operationNamespace, fingerprint) {
+        const existing = this.#operations.get(operationMapKey(operationNamespace, operationId)) ??
+            (idempotencyKey
+                ? this.#idempotency.get(operationMapKey(operationNamespace, idempotencyKey))
+                : undefined);
+        if (!existing)
+            return null;
+        if (existing.fingerprint !== fingerprint) {
+            throw new Error("ScenePlan operation or idempotency key was already used for a different request");
+        }
+        return existing.result;
+    }
+    #result(operationId, options, status, planKind, diagnostics, planHash, commit, changes, resources, projection) {
+        const result = {
+            operationId,
+            ...(options.idempotencyKey === undefined
+                ? {}
+                : { idempotencyKey: options.idempotencyKey }),
+            sceneId: this.editor.snapshot.id,
+            status,
+            ...(planKind === undefined ? {} : { planKind }),
+            ...(planHash === undefined ? {} : { planHash }),
+            ...(commit === undefined
+                ? {}
+                : {
+                    baseRevision: commit.baseRevision,
+                    revision: commit.revision,
+                    changeId: commit.changeId,
+                    revisionToken: this.#createRevisionToken(),
+                }),
+            ...(changes === undefined ? {} : { changes }),
+            ...(resources === undefined ? {} : { resources }),
+            ...(projection === undefined ? {} : { projection }),
+            diagnostics: Object.freeze([...diagnostics]),
+        };
+        return Object.freeze(result);
+    }
+    #assertActive() {
+        if (this.#disposed)
+            throw new Error("ScenePlanExecutor has been disposed");
+        this.#assertNotAborted(this.#controller.signal);
+    }
+    #assertNotAborted(signal) {
+        if (!signal.aborted)
+            return;
+        throw createAbortError();
+    }
+}
+function linkSignals(first, second) {
+    const controller = new AbortController();
+    const listeners = [];
+    const forward = () => controller.abort();
+    for (const signal of [first, second]) {
+        if (!signal)
+            continue;
+        if (signal.aborted)
+            controller.abort();
+        else {
+            signal.addEventListener("abort", forward, { once: true });
+            listeners.push(() => signal.removeEventListener("abort", forward));
+        }
+    }
+    return {
+        signal: controller.signal,
+        dispose() {
+            for (const remove of listeners)
+                remove();
+        },
+    };
+}
+function projectionSummary(result) {
+    return {
+        status: result.status,
+        operationId: result.operationId,
+        projectionId: result.projectionId,
+        sourceRevision: result.sourceRevision,
+        changeId: result.changeId,
+        modelFailureEntityIds: Object.freeze(result.modelFailures.map((failure) => failure.entityId)),
+    };
+}
+function diffDocuments(before, after) {
+    const beforeIds = {
+        ...recordIds(before.assets),
+        ...recordIds(before.entities),
+        ...recordIds(before.materials),
+        ...recordIds(before.materialBindings),
+        ...recordIds(before.textureAnimations),
+        ...recordIds(before.cameraPaths),
+        ...recordIds(before.flows),
+    };
+    const afterIds = {
+        ...recordIds(after.assets),
+        ...recordIds(after.entities),
+        ...recordIds(after.materials),
+        ...recordIds(after.materialBindings),
+        ...recordIds(after.textureAnimations),
+        ...recordIds(after.cameraPaths),
+        ...recordIds(after.flows),
+    };
+    const created = [];
+    const updated = [];
+    const removed = [];
+    for (const id of Object.keys(afterIds)) {
+        if (!beforeIds[id])
+            created.push(id);
+        else if (JSON.stringify(beforeIds[id]) !== JSON.stringify(afterIds[id])) {
+            updated.push(id);
+        }
+    }
+    for (const id of Object.keys(beforeIds)) {
+        if (!afterIds[id])
+            removed.push(id);
+    }
+    return {
+        created: Object.freeze(created.sort()),
+        updated: Object.freeze(updated.sort()),
+        removed: Object.freeze(removed.sort()),
+    };
+}
+function recordIds(record) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, value]));
+}
+function detectPlanKind(input) {
+    let value = input;
+    if (typeof input === "string") {
+        try {
+            value = JSON.parse(input);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!value || typeof value !== "object")
+        return undefined;
+    const schema = value.schema;
+    if (schema === "skenora.scene.blueprint")
+        return "blueprint";
+    if (schema === "skenora.scene.patch")
+        return "patch";
+    return undefined;
+}
+function createSceneOutlinePage(document, revisionToken, options) {
+    const limit = options.limit ?? 100;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 500) {
+        throw new Error("ScenePlan outline limit must be an integer in 1..500");
+    }
+    const cursorPrefix = `scene-plan-outline:${encodeURIComponent(revisionToken.sessionEpoch)}:${revisionToken.revision}:${revisionToken.documentHash}:`;
+    const offset = parseSceneOutlineOffset(options.cursor, cursorPrefix);
+    const roots = new Set(document.rootEntityIds);
+    const byId = (left, right) => left.id.localeCompare(right.id);
+    const items = [
+        ...Object.values(document.assets)
+            .sort(byId)
+            .map((asset) => Object.freeze({
+            kind: "asset",
+            id: asset.id,
+            resourceKind: asset.kind,
+            ...(asset.label === undefined ? {} : { label: asset.label }),
+        })),
+        ...Object.values(document.entities)
+            .sort(byId)
+            .map((entity) => Object.freeze({
+            kind: "entity",
+            id: entity.id,
+            name: entity.name,
+            entityType: entity.type,
+            parentId: entity.parentId,
+            root: roots.has(entity.id),
+            enabled: entity.enabled,
+            visible: entity.visible,
+            transform: structuredClone(entity.transform),
+            ...(entity.assetId === undefined ? {} : { assetId: entity.assetId }),
+        })),
+        ...Object.entries(document.materials)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([id, material]) => Object.freeze({
+            kind: "material",
+            id,
+            ...(material.workflow === undefined
+                ? {}
+                : { workflow: material.workflow }),
+        })),
+        ...Object.values(document.materialBindings)
+            .sort(byId)
+            .map((binding) => Object.freeze({
+            kind: "materialBinding",
+            id: binding.id,
+            materialId: binding.materialId,
+            entityId: binding.entityId,
+            ...(binding.targetName === undefined
+                ? {}
+                : { targetName: binding.targetName }),
+        })),
+        ...Object.values(document.textureAnimations)
+            .sort(byId)
+            .map((animation) => Object.freeze({
+            kind: "textureAnimation",
+            id: animation.id,
+            materialId: animation.materialId,
+            slot: animation.slot,
+            property: animation.property,
+        })),
+        ...Object.values(document.cameraPaths)
+            .sort(byId)
+            .map((path) => Object.freeze({
+            kind: "cameraPath",
+            id: path.id,
+            name: path.name,
+            durationMs: path.durationMs,
+            loop: path.loop,
+            keyframeCount: path.keyframes.length,
+        })),
+        ...[...document.lights].sort(byId).map((light) => Object.freeze({
+            kind: "light",
+            id: light.id,
+            lightType: light.type,
+            enabled: light.enabled,
+            intensity: light.intensity,
+        })),
+        ...Object.values(document.flows)
+            .sort(byId)
+            .map((flow) => Object.freeze({
+            kind: "flow",
+            id: flow.id,
+            name: flow.name,
+            enabled: flow.enabled,
+            nodeCount: flow.nodes.length,
+            edgeCount: flow.edges.length,
+        })),
+    ];
+    if (offset > items.length) {
+        throw new Error("ScenePlan outline cursor is outside the current scene");
+    }
+    const end = Math.min(offset + limit, items.length);
+    return Object.freeze({
+        items: Object.freeze(items.slice(offset, end)),
+        ...(end < items.length ? { nextCursor: cursorPrefix + end } : {}),
+    });
+}
+function parseSceneOutlineOffset(cursor, expectedPrefix) {
+    if (cursor === undefined)
+        return 0;
+    if (!cursor.startsWith(expectedPrefix)) {
+        throw new Error("ScenePlan outline cursor is invalid or stale");
+    }
+    const offset = Number(cursor.slice(expectedPrefix.length));
+    if (!Number.isSafeInteger(offset) || offset < 0) {
+        throw new Error("ScenePlan outline cursor is invalid");
+    }
+    return offset;
+}
+function createOperationFingerprint(kind, input, options) {
+    const plan = parsePlanFingerprintInput(input);
+    const canonical = JSON.stringify(canonicalizeOperationValue({
+        kind,
+        plan,
+        expectedRevision: options.expectedRevision,
+        expectedRevisionToken: options.expectedRevisionToken,
+        expectedDocumentHash: options.expectedDocumentHash,
+        label: options.label,
+        modelLoadPolicy: options.modelLoadPolicy,
+        allowVariables: options.allowVariables,
+    }));
+    if (canonical === undefined) {
+        throw new Error("ScenePlan requests must be JSON-compatible values");
+    }
+    let hash = 0xcbf29ce484222325n;
+    for (const character of canonical) {
+        hash ^= BigInt(character.charCodeAt(0));
+        hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+    }
+    return "fnv1a64:" + hash.toString(16).padStart(16, "0");
+}
+function parsePlanFingerprintInput(input) {
+    if (typeof input !== "string")
+        return input;
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return input;
+    }
+}
+function canonicalizeOperationValue(value, ancestors = new Set()) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error("ScenePlan requests must contain finite JSON numbers");
+        }
+        return Object.is(value, -0) ? 0 : value;
+    }
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "object") {
+        throw new Error("ScenePlan requests must be JSON-compatible values");
+    }
+    if (ancestors.has(value)) {
+        throw new Error("ScenePlan requests must not contain circular references");
+    }
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return value.map((item) => canonicalizeOperationValue(item, ancestors));
+        }
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, child]) => child !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, child]) => [
+            key,
+            canonicalizeOperationValue(child, ancestors),
+        ]));
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+function operationMapKey(operationNamespace, value) {
+    if (operationNamespace !== undefined &&
+        (!operationNamespace || operationNamespace !== operationNamespace.trim())) {
+        throw new Error("ScenePlan operationNamespace must be normalized and non-empty");
+    }
+    return JSON.stringify([operationNamespace ?? null, value]);
+}
+function resolveOperationId(value) {
+    if (value !== undefined) {
+        if (!value.trim())
+            throw new Error("ScenePlan operationId must be non-empty");
+        return value;
+    }
+    operationSequence += 1;
+    return "scene-plan-operation-" + Date.now() + "-" + operationSequence;
+}
+function createSessionEpoch() {
+    if (typeof globalThis.crypto?.randomUUID === "function") {
+        return "scene-plan-session-" + globalThis.crypto.randomUUID();
+    }
+    sessionSequence += 1;
+    return "scene-plan-session-" + Date.now() + "-" + sessionSequence;
+}
+function unique(values) {
+    return Object.freeze([...new Set(values)]);
+}
+function cloneFrozenAvailability(availability) {
+    if (!Array.isArray(availability)) {
+        throw new TypeError("Capability availability must be an array");
+    }
+    const clone = structuredClone(availability);
+    const ids = new Set();
+    for (const item of clone) {
+        if (ids.has(item.id)) {
+            throw new TypeError("Capability availability IDs must be unique");
+        }
+        ids.add(item.id);
+        deepFreezeObject(item);
+    }
+    return Object.freeze(clone);
+}
+function cloneFrozenCapabilities(capabilities) {
+    const clone = structuredClone(capabilities);
+    for (const item of clone)
+        deepFreezeObject(item);
+    return Object.freeze(clone);
+}
+function deepFreezeObject(value) {
+    for (const child of Object.values(value)) {
+        if (child && typeof child === "object" && !Object.isFrozen(child)) {
+            deepFreezeObject(child);
+        }
+    }
+    Object.freeze(value);
+}
+class CapabilityAvailabilityReadError extends Error {
+    constructor() {
+        super("Runtime capability availability could not be observed");
+        this.name = "CapabilityAvailabilityReadError";
+    }
+}
+function diagnostic(code, message, severity = "error") {
+    return createDiagnostic({
+        code,
+        stage: "compile",
+        path: [],
+        message,
+        severity,
+        recoverable: severity !== "error",
+    });
+}
+function executionDiagnostic(error) {
+    if (error instanceof EditorRevisionConflictError) {
+        return diagnostic("editor-revision-conflict", error.message);
+    }
+    if (isAbortError(error)) {
+        return diagnostic("operation-cancelled", "ScenePlan operation was cancelled", "warning");
+    }
+    if (error instanceof CapabilityAvailabilityReadError) {
+        return capabilityAvailabilityDiagnostic();
+    }
+    if (error instanceof SceneCapabilityUnavailableError) {
+        return createDiagnostic({
+            code: error.code,
+            stage: "compile",
+            path: error.usage.path,
+            message: error.message,
+            recoverable: true,
+        });
+    }
+    return diagnostic("scene-plan-execution-failed", error instanceof Error ? error.message : "ScenePlan operation failed");
+}
+function validationSetupDiagnostic(error) {
+    return error instanceof CapabilityAvailabilityReadError
+        ? capabilityAvailabilityDiagnostic()
+        : bindingDiagnostic(error);
+}
+function capabilityAvailabilityDiagnostic() {
+    return diagnostic("capability-availability-failed", "Runtime capability availability could not be observed");
+}
+function projectionDiagnostic(error) {
+    if (error instanceof EditorRuntimeProjectionError) {
+        return diagnostic("runtime-projection-failed", error.message);
+    }
+    return diagnostic("runtime-projection-failed", error instanceof Error ? error.message : "Runtime projection failed");
+}
+function bindingDiagnostic(error) {
+    if (error instanceof ResourceBindingValidationError) {
+        return diagnostic("resource-binding-invalid", error.message);
+    }
+    return diagnostic("resource-binding-invalid", error instanceof Error ? error.message : "Resource bindings are invalid");
+}
+function isAbortError(error) {
+    return error instanceof DOMException && error.name === "AbortError";
+}
+function createAbortError() {
+    return new DOMException("ScenePlan operation was cancelled", "AbortError");
+}
+let operationSequence = 0;
+let sessionSequence = 0;
+//# sourceMappingURL=executor.js.map