@fps-games/editor 0.2.1-beta.3 → 0.2.1-beta.4

package/node_modules/@fps-games/editor-playable-sdk/dist/vite/project-editor-service.js

@@ -0,0 +1,863 @@
+import { randomUUID } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { createEditorAuthoringHost, createEditorCommandObservabilityStore, createEditorSession, } from '@fps-games/editor-core';
+import { EDITOR_COMMAND_BUILT_IN_METADATA, EDITOR_COMMAND_BUILT_IN_PRESENTATION, EDITOR_COMMAND_BUILT_IN_TARGETS, EDITOR_COMMAND_ID, EDITOR_COMMAND_SCHEMAS, EDITOR_COMMAND_SCHEMA_VERSION, } from '@fps-games/editor-protocol';
+import { createEditorScenePrefabGroupNode, createEditorScenePrefabNodeFromAsset, createEditorScenePrefabPrimitiveNode, deleteEditorScenePrefabNode, findEditorScenePrefabAsset, findEditorScenePrefabNode, readEditorScenePrefabNodes, readEditorScenePrefabRootNodeId, renameEditorScenePrefabAsset, renameEditorScenePrefabNode, reparentEditorScenePrefabNode, setEditorScenePrefabNodeTransform, } from '../document/index.js';
+import { registerFpsGameEditorStandardAuthoringCommands } from '../product/standard-authoring-commands.js';
+import { getFpsGameEditorProjectAuthoringBackend } from './project-authoring-backend.js';
+export async function createFpsGameEditorProjectServiceAuthority(options) {
+    const document = await loadInitialDocument(options);
+    const session = createEditorSession({
+        persistedDocument: document,
+        reduceDocument(current, command) {
+            if (command.type === 'document.replace')
+                return command.document;
+            return command.patch?.kind === 'replace' ? command.patch.document : current;
+        },
+        isDocumentStructureChange: command => command.type === 'document.replace'
+            || command.type === 'document.patch',
+    });
+    const observability = createEditorCommandObservabilityStore();
+    let browserCommandForwarder = null;
+    const host = createEditorAuthoringHost({
+        serviceInstanceId: options.serviceInstanceId,
+        session,
+        commandSystemOptions: {
+            onOperationSettled: event => observability.recordOperation(event),
+        },
+    });
+    const disposeCommands = [];
+    const preparedExports = new Map();
+    try {
+        disposeCommands.push(registerFpsGameEditorStandardAuthoringCommands({
+            host,
+            listAssets: async () => listProjectAssets(options.server, host.getSnapshot().document),
+            sceneAssembly: createGenericSceneAssembly(),
+        }));
+        disposeCommands.push(registerProjectPrefabAuthoringCommands(host));
+        disposeCommands.push(registerProjectViewCommands(host, (context, target) => (browserCommandForwarder
+            ? browserCommandForwarder(context, target)
+            : Promise.resolve(commandFailure(target === 'renderer' ? 'renderer.sessionUnavailable' : 'view.sessionUnavailable', `Command requires a Browser attachment: ${context.commandId}`)))));
+        disposeCommands.push(registerProjectDocumentCommands(host, options.server, preparedExports));
+    }
+    catch (error) {
+        for (const dispose of disposeCommands.splice(0).reverse())
+            dispose();
+        host.dispose();
+        await host.drain();
+        throw error;
+    }
+    return Object.freeze({
+        host,
+        readTraces: observability.read,
+        recordOperation: observability.recordOperation,
+        readDocumentExport(transactionId) {
+            const prepared = preparedExports.get(transactionId);
+            return prepared ? structuredClone(prepared) : null;
+        },
+        bindBrowserCommandForwarder(forwarder) {
+            if (browserCommandForwarder)
+                throw new Error('Browser command forwarder is already bound.');
+            browserCommandForwarder = forwarder;
+            let active = true;
+            return () => {
+                if (!active)
+                    return;
+                active = false;
+                if (browserCommandForwarder === forwarder)
+                    browserCommandForwarder = null;
+            };
+        },
+        async dispose() {
+            browserCommandForwarder = null;
+            preparedExports.clear();
+            for (const dispose of disposeCommands.splice(0).reverse())
+                dispose();
+            host.dispose();
+            await host.drain();
+            observability.clear();
+        },
+    });
+}
+async function loadInitialDocument(options) {
+    const backend = getFpsGameEditorProjectAuthoringBackend(options.server);
+    if (backend)
+        return normalizeDocument(await backend.loadEditorScene());
+    const configuredPath = options.project?.source.editorScene ?? 'src/config/editor-scene.json';
+    try {
+        const source = await readFile(path.resolve(options.projectRoot, configuredPath), 'utf8');
+        return normalizeDocument(JSON.parse(source));
+    }
+    catch (error) {
+        if (options.project)
+            throw error;
+        return normalizeDocument({ schemaVersion: 1, assets: [], scene: { gameObjects: [] } });
+    }
+}
+function normalizeDocument(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Project Editor Service expected the editor scene to be a JSON object.');
+    }
+    const document = structuredClone(value);
+    const scene = document.scene;
+    if (!scene || typeof scene !== 'object' || Array.isArray(scene)) {
+        throw new Error('Project Editor Service expected scene.gameObjects.');
+    }
+    const gameObjects = scene.gameObjects;
+    if (!Array.isArray(gameObjects))
+        throw new Error('Project Editor Service expected scene.gameObjects to be an array.');
+    if (!Array.isArray(document.assets))
+        document.assets = [];
+    return document;
+}
+async function listProjectAssets(server, document) {
+    const backend = getFpsGameEditorProjectAuthoringBackend(server);
+    const values = backend ? await backend.listEditorAssets() : document.assets;
+    return (Array.isArray(values) ? values : [])
+        .map((value, index) => normalizeAsset(value, index))
+        .filter((value) => value !== null);
+}
+function normalizeAsset(value, index) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    const assetId = readString(record.assetId) ?? readString(record.id);
+    if (!assetId)
+        return null;
+    return {
+        ...record,
+        id: readString(record.id) ?? assetId,
+        assetId,
+        type: readString(record.type) ?? 'glb',
+        kind: readString(record.kind) ?? 'model',
+        displayName: readString(record.displayName) ?? readString(record.label) ?? assetId,
+        origin: readString(record.origin) ?? 'project',
+        dedupeKey: readString(record.dedupeKey) ?? `project:${assetId}:${index}`,
+        placeable: record.placeable !== false,
+    };
+}
+function createGenericSceneAssembly() {
+    return {
+        getHierarchyItems(document) {
+            return document.scene.gameObjects.map(object => ({
+                id: object.id,
+                label: object.name ?? object.id,
+                ...(object.parentId ? { parentId: object.parentId } : {}),
+            }));
+        },
+        createCreatePrimitivePatch(document, input) {
+            const next = structuredClone(document);
+            const id = uniqueObjectId(next, `primitive_${input.shape}`);
+            const created = createBaseObject(id, input.name ?? titleCase(input.shape), input.parentId);
+            created.kind = 'primitive';
+            created.primitive = { shape: input.shape };
+            next.scene.gameObjects.push(created);
+            return {
+                patch: { kind: 'replace', document: next },
+                label: `Create ${input.shape}`,
+                changedIds: [id],
+                createdId: id,
+                selectId: id,
+            };
+        },
+        createDeleteSubtreePatch(document, input) {
+            const protectedIds = new Set(['root', 'main_camera', 'environment_light', 'sun_light']);
+            const roots = new Set(input.ids.filter(id => !protectedIds.has(id)));
+            if (roots.size === 0)
+                return null;
+            const deleted = new Set(roots);
+            let changed = true;
+            while (changed) {
+                changed = false;
+                for (const object of document.scene.gameObjects) {
+                    if (object.parentId && deleted.has(object.parentId) && !deleted.has(object.id)) {
+                        deleted.add(object.id);
+                        changed = true;
+                    }
+                }
+            }
+            const next = structuredClone(document);
+            next.scene.gameObjects = next.scene.gameObjects.filter(object => !deleted.has(object.id));
+            return {
+                patch: { kind: 'replace', document: next },
+                label: `Delete ${deleted.size} object(s)`,
+                changedIds: [...deleted],
+                deletedIds: [...deleted],
+            };
+        },
+        patchGameObjectField(document, id, field, value) {
+            const next = structuredClone(document);
+            const target = next.scene.gameObjects.find(object => object.id === id);
+            if (!target)
+                return document;
+            const transform = getTransform(target);
+            const key = field.slice('transform.'.length);
+            if (!transform || !['position', 'rotation', 'scale'].includes(key))
+                return document;
+            transform[key] = structuredClone(value);
+            return next;
+        },
+        addAssetLibraryItemToDocument(document, asset, transform) {
+            const next = structuredClone(document);
+            const id = uniqueObjectId(next, slug(asset.displayName ?? asset.assetId));
+            const created = createBaseObject(id, asset.displayName ?? asset.assetId);
+            const component = getTransform(created);
+            if (transform) {
+                component.position = structuredClone(transform.position);
+                component.rotation = structuredClone(transform.rotation);
+                component.scale = structuredClone(transform.scale);
+            }
+            created.kind = asset.kind === 'prefab' ? 'instance' : 'transform';
+            created.components.push({
+                type: 'ModelRenderer',
+                assetId: asset.assetId,
+            });
+            next.scene.gameObjects.push(created);
+            return { document: next, gameObject: created };
+        },
+    };
+}
+function registerProjectPrefabAuthoringCommands(host) {
+    const unregister = [];
+    const register = (commandId, handler) => unregister.push(host.registerCommand({
+        manifest: builtInCommandManifest(commandId),
+        handler,
+    }));
+    try {
+        register(EDITOR_COMMAND_ID.PREFAB_RESOLVE, (input, context) => {
+            const prefabs = context.session.getWorkingDocument().assets
+                .filter(asset => asset.type === 'prefab' && asset.prefab)
+                .map(toPrefabSummary);
+            const query = readString(input.assetId)
+                ?? readString(input.name)
+                ?? readString(input.query);
+            const matches = !query
+                ? prefabs
+                : prefabs.filter((prefab) => {
+                    const assetId = typeof prefab.assetId === 'string' ? prefab.assetId : '';
+                    const displayName = typeof prefab.displayName === 'string' ? prefab.displayName : '';
+                    return assetId === query
+                        || displayName.toLocaleLowerCase() === query.toLocaleLowerCase()
+                        || displayName.toLocaleLowerCase().includes(query.toLocaleLowerCase());
+                });
+            return { ok: true, output: {
+                    prefabs,
+                    resolvedPrefab: matches.length === 1 ? matches[0] : null,
+                    ambiguous: matches.length > 1,
+                } };
+        });
+        register(EDITOR_COMMAND_ID.PREFAB_ASSET_RENAME, (input, context) => {
+            const assetId = readString(input.assetId);
+            if (!assetId)
+                return commandFailure('prefab.assetIdRequired', 'Headless prefab rename requires assetId.');
+            const document = context.session.getWorkingDocument();
+            const previous = findEditorScenePrefabAsset(document, assetId);
+            if (!previous)
+                return commandFailure('prefab.notFound', `Prefab asset was not found: ${assetId}`);
+            const result = renameEditorScenePrefabAsset(document, assetId, input.displayName);
+            const failure = prefabMutationFailure(result);
+            if (failure)
+                return failure;
+            commitPrefabMutation(context, document, result, `Rename prefab ${assetId}`);
+            return { ok: true, output: {
+                    assetId,
+                    previousDisplayName: previous.displayName ?? previous.id,
+                    displayName: result.prefabAsset.displayName ?? result.prefabAsset.id,
+                    stageActive: false,
+                    renamed: result.changed,
+                } };
+        });
+        register(EDITOR_COMMAND_ID.PREFAB_SCENE_GET, (input, context) => {
+            const document = context.session.getWorkingDocument();
+            const prefab = resolveHeadlessPrefab(document, input);
+            if (!prefab)
+                return commandFailure('prefab.assetIdRequired', 'Headless prefab scene reads require an unambiguous assetId.');
+            return { ok: true, output: createPrefabSceneOutput(prefab, context.session.getState({ cloneDocuments: false }).dirty) };
+        });
+        register(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_FROM_ASSET, (input, context) => {
+            const document = context.session.getWorkingDocument();
+            const prefab = resolveHeadlessPrefab(document, { assetId: input.prefabAssetId });
+            const assetId = readString(input.assetId);
+            const asset = assetId ? document.assets.find(candidate => candidate.id === assetId) : null;
+            if (!prefab || !asset) {
+                return commandFailure('prefab.assetNotFound', 'Headless prefab node creation requires prefabAssetId and a valid assetId.');
+            }
+            return finishPrefabNodeMutation(context, document, prefab.id, createEditorScenePrefabNodeFromAsset(prefab, asset, {
+                ...(readString(input.parentNodeId) ? { parentId: readString(input.parentNodeId) } : {}),
+                ...(readString(input.name) ? { name: readString(input.name) } : {}),
+                ...(readString(input.sourceNodePath) ? { sourceNodePath: readString(input.sourceNodePath) } : {}),
+                ...(readTransform(input) ? { transform: readTransform(input) } : {}),
+            }), 'Create prefab node from asset');
+        });
+        register(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_GROUP, (input, context) => {
+            const document = context.session.getWorkingDocument();
+            const prefab = resolveHeadlessPrefab(document, { assetId: input.prefabAssetId });
+            if (!prefab)
+                return commandFailure('prefab.assetIdRequired', 'Headless prefab group creation requires prefabAssetId.');
+            return finishPrefabNodeMutation(context, document, prefab.id, createEditorScenePrefabGroupNode(prefab, {
+                ...(readString(input.parentNodeId) ? { parentId: readString(input.parentNodeId) } : {}),
+                ...(readString(input.name) ? { name: readString(input.name) } : {}),
+                ...(readTransform(input) ? { transform: readTransform(input) } : {}),
+            }), 'Create prefab group');
+        });
+        register(EDITOR_COMMAND_ID.PREFAB_NODE_CREATE_PRIMITIVE, (input, context) => {
+            const document = context.session.getWorkingDocument();
+            const prefab = resolveHeadlessPrefab(document, { assetId: input.prefabAssetId });
+            const shape = readString(input.shape);
+            if (!prefab || !shape) {
+                return commandFailure('prefab.invalidInput', 'Headless prefab primitive creation requires prefabAssetId and shape.');
+            }
+            return finishPrefabNodeMutation(context, document, prefab.id, createEditorScenePrefabPrimitiveNode(prefab, {
+                shape,
+                ...(readString(input.parentNodeId) ? { parentId: readString(input.parentNodeId) } : {}),
+                ...(readString(input.name) ? { name: readString(input.name) } : {}),
+                ...(readTransform(input) ? { transform: readTransform(input) } : {}),
+            }), 'Create prefab primitive');
+        });
+        register(EDITOR_COMMAND_ID.PREFAB_NODE_SET_TRANSFORM, (input, context) => {
+            const resolved = resolvePrefabNodeMutation(context.session.getWorkingDocument(), input);
+            if (!resolved.ok)
+                return resolved.failure;
+            const current = resolved.node.transform && resolved.node.transform.mode !== 'matrix'
+                ? resolved.node.transform
+                : identityTransform();
+            const transform = {
+                type: 'Transform',
+                position: readVec3(input.position) ?? current.position,
+                rotation: readVec3(input.rotation) ?? current.rotation,
+                scale: readVec3(input.scale) ?? current.scale ?? { x: 1, y: 1, z: 1 },
+            };
+            return finishPrefabNodeMutation(context, resolved.document, resolved.prefab.id, setEditorScenePrefabNodeTransform(resolved.prefab, resolved.node.id, transform), 'Set prefab node transform');
+        });
+        register(EDITOR_COMMAND_ID.PREFAB_NODE_REPARENT, (input, context) => {
+            const resolved = resolvePrefabNodeMutation(context.session.getWorkingDocument(), input);
+            const parentNodeId = readString(input.parentNodeId);
+            if (!resolved.ok)
+                return resolved.failure;
+            if (!parentNodeId)
+                return commandFailure('prefab.parentNotFound', 'Prefab parentNodeId is required.');
+            return finishPrefabNodeMutation(context, resolved.document, resolved.prefab.id, reparentEditorScenePrefabNode(resolved.prefab, resolved.node.id, parentNodeId), 'Reparent prefab node');
+        });
+        register(EDITOR_COMMAND_ID.PREFAB_NODE_RENAME, (input, context) => {
+            const resolved = resolvePrefabNodeMutation(context.session.getWorkingDocument(), input);
+            if (!resolved.ok)
+                return resolved.failure;
+            const previousName = resolved.node.name ?? resolved.node.id;
+            const result = renameEditorScenePrefabNode(resolved.prefab, resolved.node.id, input.name);
+            const failure = prefabMutationFailure(result);
+            if (failure)
+                return failure;
+            commitPrefabMutation(context, resolved.document, result, 'Rename prefab node');
+            return { ok: true, output: {
+                    nodeId: resolved.node.id,
+                    previousName,
+                    name: result.node?.name ?? previousName,
+                    selectedNodeId: result.selectedNodeId ?? resolved.node.id,
+                    nodes: readEditorScenePrefabNodes(result.prefabAsset).map(toCommandPrefabNode),
+                } };
+        });
+        register(EDITOR_COMMAND_ID.PREFAB_NODE_DELETE, (input, context) => {
+            const resolved = resolvePrefabNodeMutation(context.session.getWorkingDocument(), input);
+            if (!resolved.ok)
+                return resolved.failure;
+            return finishPrefabNodeMutation(context, resolved.document, resolved.prefab.id, deleteEditorScenePrefabNode(resolved.prefab, resolved.node.id), 'Delete prefab node');
+        });
+    }
+    catch (error) {
+        for (const dispose of unregister.splice(0).reverse())
+            dispose();
+        throw error;
+    }
+    return () => { for (const dispose of unregister.splice(0).reverse())
+        dispose(); };
+}
+function builtInCommandManifest(id) {
+    const metadata = EDITOR_COMMAND_BUILT_IN_METADATA[id];
+    const schema = EDITOR_COMMAND_SCHEMAS[id];
+    const presentation = EDITOR_COMMAND_BUILT_IN_PRESENTATION[id];
+    if (!metadata || !schema)
+        throw new Error(`Built-in Editor command contract is missing: ${id}`);
+    return {
+        schemaVersion: EDITOR_COMMAND_SCHEMA_VERSION,
+        id,
+        version: 1,
+        title: metadata.title,
+        target: metadata.target,
+        access: metadata.access,
+        stability: metadata.stability,
+        inputSchema: schema.inputSchema,
+        outputSchema: schema.outputSchema,
+        requires: { editorReady: true },
+        effects: {
+            persistence: metadata.access === 'write' ? 'authoring' : 'none',
+            undoable: metadata.access === 'write',
+            idempotent: metadata.access === 'read',
+        },
+        presentation: {
+            category: metadata.category,
+            inputMode: Array.isArray(schema.inputSchema.required) && schema.inputSchema.required.length
+                ? 'schema-form'
+                : 'none',
+            ...(presentation?.aliases ? { aliases: presentation.aliases } : {}),
+            ...(presentation?.keywords ? { keywords: presentation.keywords } : {}),
+            ...(presentation?.examples ? { examples: presentation.examples } : {}),
+            ...(presentation?.shortcut ? { shortcut: presentation.shortcut } : {}),
+            ...(presentation?.menu ? { menu: presentation.menu } : {}),
+        },
+    };
+}
+function resolveHeadlessPrefab(document, input) {
+    const assetId = readString(input.assetId);
+    return assetId ? findEditorScenePrefabAsset(document, assetId) : null;
+}
+function resolvePrefabNodeMutation(document, input) {
+    const prefab = resolveHeadlessPrefab(document, input);
+    if (!prefab)
+        return { ok: false, failure: commandFailure('prefab.assetIdRequired', 'Headless prefab node mutation requires assetId.') };
+    const nodeId = readString(input.nodeId);
+    const node = nodeId ? findEditorScenePrefabNode(prefab, nodeId) : null;
+    if (!node)
+        return { ok: false, failure: commandFailure('prefab.nodeNotFound', `Prefab node was not found: ${nodeId ?? ''}`) };
+    return { ok: true, document, prefab, node };
+}
+function finishPrefabNodeMutation(context, document, assetId, result, label) {
+    const failure = prefabMutationFailure(result);
+    if (failure)
+        return failure;
+    commitPrefabMutation(context, document, result, label);
+    return { ok: true, output: {
+            stage: toHeadlessPrefabStage(result.prefabAsset, context.session.getState({ cloneDocuments: false }).dirty),
+            changed: result.changed,
+            ...(result.createdNodeId ? { createdNodeId: result.createdNodeId } : {}),
+            ...(result.node?.id ? { changedNodeId: result.node.id } : {}),
+            ...(result.deletedNodeIds?.length ? { deletedNodeIds: result.deletedNodeIds } : {}),
+            selectedNodeId: result.selectedNodeId ?? result.node?.id ?? null,
+            node: result.node ? toCommandPrefabNode(result.node) : null,
+            rootNodeId: readEditorScenePrefabRootNodeId(result.prefabAsset) ?? 'prefab-root',
+            nodes: readEditorScenePrefabNodes(result.prefabAsset).map(toCommandPrefabNode),
+            status: result.changed ? label : `${label}: unchanged`,
+        } };
+}
+function commitPrefabMutation(context, document, result, label) {
+    if (!result.changed)
+        return;
+    const next = structuredClone(document);
+    const index = next.assets.findIndex(asset => asset.id === result.prefabAsset.id);
+    if (index < 0)
+        throw new Error(`Prefab asset disappeared during mutation: ${result.prefabAsset.id}`);
+    next.assets[index] = result.prefabAsset;
+    context.dispatch({ type: 'document.replace', document: next, label });
+}
+function prefabMutationFailure(result) {
+    const error = result.diagnostics.find(diagnostic => diagnostic.severity === 'error');
+    return error ? commandFailure(error.code, error.message) : null;
+}
+function createPrefabSceneOutput(prefab, dirty) {
+    const nodes = readEditorScenePrefabNodes(prefab);
+    return {
+        stage: toHeadlessPrefabStage(prefab, dirty),
+        rootNodeId: readEditorScenePrefabRootNodeId(prefab) ?? 'prefab-root',
+        selectedNodeId: null,
+        nodes: nodes.map(toCommandPrefabNode),
+        diagnostics: [],
+    };
+}
+function toPrefabSummary(asset) {
+    return {
+        assetId: asset.id,
+        displayName: asset.displayName ?? asset.id,
+        ...(asset.prefab?.sourceAssetId ? { sourceAssetId: asset.prefab.sourceAssetId } : {}),
+        ...(asset.prefab?.sourceAssetGuid ? { sourceAssetGuid: asset.prefab.sourceAssetGuid } : {}),
+        placeable: true,
+        readonly: false,
+        status: 'available',
+    };
+}
+function toHeadlessPrefabStage(asset, dirty) {
+    return {
+        assetId: asset.id,
+        label: asset.displayName ?? asset.id,
+        ...(asset.prefab?.sourceAssetId ? { sourceAssetId: asset.prefab.sourceAssetId } : {}),
+        ...(asset.prefab?.sourceAssetGuid ? { sourceAssetGuid: asset.prefab.sourceAssetGuid } : {}),
+        selectedItemId: null,
+        readonly: false,
+        dirty,
+        documentDirty: dirty,
+        canSave: dirty,
+        canDiscard: dirty,
+    };
+}
+function toCommandPrefabNode(node) {
+    return {
+        nodeId: node.id,
+        ...(node.guid ? { guid: node.guid } : {}),
+        ...(node.name ? { name: node.name } : {}),
+        parentNodeId: node.parentId ?? null,
+        kind: node.kind,
+        ...(node.transform && node.transform.mode !== 'matrix' ? { transform: {
+                position: { ...node.transform.position },
+                rotation: { ...node.transform.rotation },
+                scale: { ...(node.transform.scale ?? { x: 1, y: 1, z: 1 }) },
+            } } : {}),
+        ...(node.sourceAssetId ? { sourceAssetId: node.sourceAssetId } : {}),
+        ...(node.sourceNodePath ? { sourceNodePath: node.sourceNodePath } : {}),
+        ...(node.childPrefabId ? { childPrefabId: node.childPrefabId } : {}),
+        ...(node.primitive ? { primitive: node.primitive } : {}),
+        ...(node.marker ? { marker: node.marker } : {}),
+        ...(node.defaults ? { defaults: node.defaults } : {}),
+        ...(node.overrides ? { overrides: node.overrides } : {}),
+        readonly: false,
+        diagnostics: [],
+    };
+}
+function readTransform(input) {
+    const position = readVec3(input.position);
+    const rotation = readVec3(input.rotation);
+    const scale = readVec3(input.scale);
+    if (!position && !rotation && !scale)
+        return null;
+    return {
+        type: 'Transform',
+        position: position ?? { x: 0, y: 0, z: 0 },
+        rotation: rotation ?? { x: 0, y: 0, z: 0 },
+        scale: scale ?? { x: 1, y: 1, z: 1 },
+    };
+}
+function readVec3(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const vector = value;
+    return typeof vector.x === 'number' && typeof vector.y === 'number' && typeof vector.z === 'number'
+        ? { x: vector.x, y: vector.y, z: vector.z }
+        : null;
+}
+function identityTransform() {
+    return {
+        type: 'Transform',
+        position: { x: 0, y: 0, z: 0 },
+        rotation: { x: 0, y: 0, z: 0 },
+        scale: { x: 1, y: 1, z: 1 },
+    };
+}
+function registerProjectDocumentCommands(host, server, preparedExports) {
+    const unregister = [];
+    let authoringSourceCursor = readProjectAuthoringSourceCursor(host.getSnapshot().document);
+    const register = (manifest, handler, expectedRevisionPolicy) => unregister.push(host.registerCommand({
+        manifest,
+        handler,
+        ...(expectedRevisionPolicy ? { expectedRevisionPolicy } : {}),
+    }));
+    try {
+        register({
+            schemaVersion: EDITOR_COMMAND_SCHEMA_VERSION,
+            id: 'authoring.proposal.commit',
+            version: 1,
+            title: 'Commit Browser Authoring Proposal',
+            description: 'Commits a Browser-composed document through the project Authoring Host while preserving the originating command identity.',
+            target: 'authoring',
+            access: 'write',
+            stability: 'experimental',
+            requires: { viewAttached: true },
+            inputSchema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['commandId', 'inputFingerprint', 'document'],
+                properties: {
+                    commandId: { type: 'string', minLength: 1 },
+                    inputFingerprint: { type: 'string' },
+                    document: { type: 'object' },
+                },
+            },
+            outputSchema: { type: 'object' },
+            effects: { persistence: 'authoring', undoable: true, idempotent: false },
+            presentation: { category: 'Authoring', inputMode: 'schema-form' },
+        }, (input, context) => {
+            if (context.source !== 'browser-ui' || context.principal.type !== 'human' || !context.clientId) {
+                return commandFailure('authoring.proposal.browserRequired', 'Authoring proposals are accepted only from the authenticated Browser UI.');
+            }
+            if (context.intentCommandId !== input.commandId) {
+                return commandFailure('authoring.proposal.identityMismatch', 'Browser authoring proposal identity does not match the invocation intent.');
+            }
+            const document = normalizeDocument(input.document);
+            context.dispatch({ type: 'document.replace', document, label: input.commandId });
+            const state = context.session.getState({ cloneDocuments: false });
+            return { ok: true, output: {
+                    intentCommandId: input.commandId,
+                    inputFingerprint: input.inputFingerprint,
+                    documentRevision: state.documentRevision,
+                    dirty: state.dirty,
+                } };
+        });
+        register(documentManifest('document.save', 'Save Project Document'), async (_input, context) => {
+            const backend = getFpsGameEditorProjectAuthoringBackend(server);
+            if (!backend)
+                return commandFailure('document.persistenceUnavailable', 'Project authoring persistence is unavailable.');
+            const document = rebaseProjectAuthoringSourceRevision(context.session.getWorkingDocument(), authoringSourceCursor);
+            const result = await backend.saveEditorScene({
+                saveMode: 'local-commit-save',
+                rawEditorScene: document,
+                body: createExpectedAuthoringSourceRevisionBody(authoringSourceCursor),
+            });
+            const savedDocument = readPreparedProjectDocument(result);
+            authoringSourceCursor = readProjectAuthoringSourceCursor(savedDocument)
+                ?? authoringSourceCursor;
+            context.session.markSaved(savedDocument);
+            const state = context.session.getState({ cloneDocuments: false });
+            return { ok: true, output: summarizeSaveResult(result, state.documentRevision) };
+        });
+        register(documentManifest('document.export', 'Prepare Project Export'), async (_input, context) => {
+            const backend = getFpsGameEditorProjectAuthoringBackend(server);
+            if (!backend)
+                return commandFailure('document.persistenceUnavailable', 'Project authoring persistence is unavailable.');
+            const state = context.session.getState({ cloneDocuments: false });
+            const document = rebaseProjectAuthoringSourceRevision(state.workingDocument, authoringSourceCursor);
+            const result = await backend.saveEditorScene({
+                saveMode: 'prepare-platform-save',
+                rawEditorScene: document,
+                body: createExpectedAuthoringSourceRevisionBody(authoringSourceCursor),
+            });
+            const preparedDocument = readPreparedProjectDocument(result);
+            authoringSourceCursor = readProjectAuthoringSourceCursor(preparedDocument)
+                ?? authoringSourceCursor;
+            const transactionId = randomUUID();
+            preparedExports.set(transactionId, {
+                transactionId,
+                documentRevision: state.documentRevision,
+                document: preparedDocument,
+                sceneJsonText: readRequiredSceneJsonText(result),
+                ...(typeof result.expectedVersion === 'number'
+                    ? { expectedVersion: result.expectedVersion }
+                    : {}),
+            });
+            while (preparedExports.size > 32)
+                preparedExports.delete(preparedExports.keys().next().value);
+            return { ok: true, output: { ...summarizeSaveResult(result, state.documentRevision), transactionId } };
+        });
+        register(documentManifest('document.commit', 'Commit Saved Checkpoint', {
+            type: 'object',
+            additionalProperties: false,
+            required: ['transactionId'],
+            properties: { transactionId: { type: 'string', minLength: 1 } },
+        }), (input, context) => {
+            const prepared = preparedExports.get(input.transactionId);
+            if (!prepared)
+                return commandFailure('document.commitUnavailable', 'Prepared export transaction is missing, stale, or already committed.');
+            if (context.expectedRevision?.document !== prepared.documentRevision) {
+                return commandFailure('document.commitRevisionMismatch', `Prepared export revision ${prepared.documentRevision} does not match expected revision ${String(context.expectedRevision?.document)}.`);
+            }
+            const currentState = context.session.getState({ cloneDocuments: false });
+            if (currentState.documentRevision === prepared.documentRevision) {
+                context.session.markSaved(prepared.document);
+            }
+            else {
+                context.session.markPersistedCheckpoint(prepared.document);
+            }
+            preparedExports.delete(input.transactionId);
+            const state = context.session.getState({ cloneDocuments: false });
+            return { ok: true, output: {
+                    transactionId: input.transactionId,
+                    preparedRevision: prepared.documentRevision,
+                    documentRevision: state.documentRevision,
+                    dirty: state.dirty,
+                } };
+        }, 'handler-validated');
+    }
+    catch (error) {
+        for (const dispose of unregister.splice(0).reverse())
+            dispose();
+        throw error;
+    }
+    return () => { for (const dispose of unregister.splice(0).reverse())
+        dispose(); };
+}
+function readProjectAuthoringSourceCursor(document) {
+    const record = document && typeof document === 'object' && !Array.isArray(document)
+        ? document
+        : null;
+    const meta = record?.meta && typeof record.meta === 'object' && !Array.isArray(record.meta)
+        ? record.meta
+        : null;
+    const source = meta?.authoringSource
+        && typeof meta.authoringSource === 'object'
+        && !Array.isArray(meta.authoringSource)
+        ? meta.authoringSource
+        : null;
+    return typeof source?.sourceId === 'string' && source.sourceId.trim()
+        && typeof source.sourceType === 'string' && source.sourceType.trim()
+        && typeof source.revision === 'number' && Number.isFinite(source.revision)
+        ? {
+            sourceId: source.sourceId,
+            sourceType: source.sourceType,
+            revision: source.revision,
+        }
+        : null;
+}
+function rebaseProjectAuthoringSourceRevision(document, cursor) {
+    const clone = structuredClone(document);
+    if (cursor === null)
+        return clone;
+    const current = readProjectAuthoringSourceCursor(clone);
+    if (current?.sourceId === cursor.sourceId
+        && current.sourceType === cursor.sourceType
+        && current.revision === cursor.revision)
+        return clone;
+    const meta = clone.meta && typeof clone.meta === 'object' && !Array.isArray(clone.meta)
+        ? clone.meta
+        : {};
+    meta.authoringSource = { ...cursor };
+    clone.meta = meta;
+    return clone;
+}
+function createExpectedAuthoringSourceRevisionBody(cursor) {
+    return cursor === null ? {} : { expectedAuthoringSourceRevision: cursor.revision };
+}
+function readPreparedProjectDocument(result) {
+    if (!result.editorScene) {
+        throw new Error('Project authoring backend did not return the prepared editor scene.');
+    }
+    return normalizeDocument(result.editorScene);
+}
+function readRequiredSceneJsonText(result) {
+    if (typeof result.sceneJsonText === 'string' && result.sceneJsonText.trim()) {
+        return result.sceneJsonText;
+    }
+    throw new Error('Project authoring backend did not return the prepared runtime scene artifact.');
+}
+function registerProjectViewCommands(host, forward) {
+    const unregister = [];
+    const register = (manifest) => unregister.push(host.registerCommand({
+        manifest,
+        handler: (_input, context) => forward(context, manifest.target),
+    }));
+    try {
+        for (const commandId of Object.keys(EDITOR_COMMAND_BUILT_IN_METADATA)) {
+            const target = EDITOR_COMMAND_BUILT_IN_TARGETS[commandId];
+            if (target !== 'view' && target !== 'renderer')
+                continue;
+            register(browserCommandManifest(commandId, target));
+        }
+    }
+    catch (error) {
+        for (const dispose of unregister.splice(0).reverse())
+            dispose();
+        throw error;
+    }
+    return () => { for (const dispose of unregister.splice(0).reverse())
+        dispose(); };
+}
+function browserCommandManifest(id, target) {
+    const schema = EDITOR_COMMAND_SCHEMAS[id];
+    const metadata = EDITOR_COMMAND_BUILT_IN_METADATA[id];
+    if (!metadata)
+        throw new Error(`Editor command metadata is missing: ${id}`);
+    const access = metadata.access;
+    const presentation = EDITOR_COMMAND_BUILT_IN_PRESENTATION[id];
+    return {
+        schemaVersion: EDITOR_COMMAND_SCHEMA_VERSION,
+        id,
+        version: 1,
+        title: metadata.title,
+        target,
+        access,
+        stability: metadata.stability,
+        inputSchema: schema?.inputSchema ?? { type: 'object' },
+        outputSchema: schema?.outputSchema ?? { type: 'object' },
+        requires: {
+            editorReady: true,
+            ...(target === 'view' ? { viewAttached: true } : { rendererAttached: true }),
+        },
+        effects: {
+            persistence: access === 'read' ? 'none' : 'view',
+            undoable: false,
+            idempotent: access === 'read',
+        },
+        presentation: {
+            category: metadata.category,
+            inputMode: Array.isArray(schema?.inputSchema.required) && schema.inputSchema.required.length
+                ? 'schema-form'
+                : 'none',
+            ...(presentation?.aliases ? { aliases: presentation.aliases } : {}),
+            ...(presentation?.keywords ? { keywords: presentation.keywords } : {}),
+            ...(presentation?.examples ? { examples: presentation.examples } : {}),
+            ...(presentation?.shortcut ? { shortcut: presentation.shortcut } : {}),
+            ...(presentation?.menu ? { menu: presentation.menu } : {}),
+        },
+    };
+}
+function documentManifest(id, title, inputSchema = { type: 'object', additionalProperties: false }) {
+    return {
+        schemaVersion: EDITOR_COMMAND_SCHEMA_VERSION,
+        id,
+        version: 1,
+        title,
+        target: 'authoring',
+        access: 'write',
+        stability: 'stable',
+        inputSchema,
+        outputSchema: { type: 'object' },
+        effects: { persistence: 'filesystem', undoable: false, idempotent: false },
+        presentation: {
+            category: 'Document',
+            inputMode: Array.isArray(inputSchema.required) && inputSchema.required.length ? 'schema-form' : 'none',
+            ...(id === 'document.save' ? {
+                shortcut: 'Mod+S',
+                menu: { path: ['File', 'Save'] },
+            } : {}),
+        },
+    };
+}
+function summarizeSaveResult(result, documentRevision) {
+    const sceneJsonText = typeof result.sceneJsonText === 'string' ? result.sceneJsonText : undefined;
+    return {
+        documentRevision,
+        ...(typeof result.expectedVersion === 'number' ? { expectedVersion: result.expectedVersion } : {}),
+        ...(sceneJsonText ? { sceneJsonBytes: Buffer.byteLength(sceneJsonText) } : {}),
+        prepared: true,
+    };
+}
+function commandFailure(code, message) {
+    return { ok: false, diagnostics: [{ severity: 'error', source: 'adapter', code, message }] };
+}
+function createBaseObject(id, name, parentId) {
+    return {
+        id,
+        guid: `go_${randomUUID()}`,
+        name,
+        active: true,
+        ...(parentId ? { parentId } : {}),
+        components: [{
+                type: 'Transform',
+                position: { x: 0, y: 0, z: 0 },
+                rotation: { x: 0, y: 0, z: 0 },
+                scale: { x: 1, y: 1, z: 1 },
+            }],
+    };
+}
+function getTransform(object) {
+    const components = Array.isArray(object.components) ? object.components : [];
+    return components.find(component => component && typeof component === 'object'
+        && component.type === 'Transform') ?? null;
+}
+function uniqueObjectId(document, prefix) {
+    const safePrefix = slug(prefix) || 'object';
+    const ids = new Set(document.scene.gameObjects.map(object => object.id));
+    if (!ids.has(safePrefix))
+        return safePrefix;
+    for (let sequence = 2; sequence < 10000; sequence += 1) {
+        const candidate = `${safePrefix}_${sequence}`;
+        if (!ids.has(candidate))
+            return candidate;
+    }
+    return `${safePrefix}_${randomUUID()}`;
+}
+function slug(value) {
+    return value.trim().toLocaleLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+}
+function titleCase(value) {
+    return value ? `${value[0].toLocaleUpperCase()}${value.slice(1)}` : 'Object';
+}
+function readString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+//# sourceMappingURL=project-editor-service.js.map