@fps-games/editor 0.1.8-beta.4 → 0.2.0-beta.1

package/dist/playable-local-editor-host.js

@@ -1,9 +1,12 @@
 import { createEditorAgentInteractionController, createProjectAuthoringHost, } from '@fps-games/editor-core';
+import { getFpsEditorPluginLifecycleScopeHost, resolveFpsEditorLifecycleParticipants, } from '@fps-games/editor-core/plugin-host';
 import { createForgePlayAgentTransport, } from '@fps-games/editor-forge-play';
-import { createPlayableLocalEditorHostController, createPlayableLocalEditorLoadingOverlay, } from '@fps-games/editor-playable-sdk';
+import { createPlayableLocalEditorLoadingOverlay, formatPlayableEditorDoctorReport, inspectPlayableEditorHostCompatibilityReport, } from '@fps-games/editor-playable-sdk';
+import { createPlayableLocalEditorHostController, PLAYABLE_LOCAL_EDITOR_APPLICATION_SCOPE_ID, } from '@fps-games/editor-playable-sdk/internal/local-harness';
 import { createLocalEditorHarness, } from './local-editor-harness.js';
+import { getLocalEditorHarnessLifecycleOperations, } from './internal/local-editor-lifecycle-operations.js';
 import { createLocalEditorAgentHierarchyContextActions } from './local-editor-agent-actions.js';
-export const PLAYABLE_LOCAL_EDITOR_HOST_MANIFEST_VERSION = 1;
+export const PLAYABLE_LOCAL_EDITOR_HOST_MANIFEST_VERSION = 2;
 /**
  * Frozen required contract for playable local editor host manifests.
  *
@@ -19,7 +22,6 @@ export const PLAYABLE_LOCAL_EDITOR_HOST_MANIFEST_VERSION = 1;
 export const PLAYABLE_LOCAL_EDITOR_HOST_REQUIRED_CONTRACT = Object.freeze({
     document: Object.freeze([
         'reduceDocument',
-        'getSerializedObject',
         'getHierarchyItems',
         'getProjectionNodes',
         'getProjectionNode',
@@ -33,15 +35,61 @@ export const PLAYABLE_LOCAL_EDITOR_HOST_REQUIRED_CONTRACT = Object.freeze({
     world: Object.freeze({
         direct: Object.freeze([
             'getCanvas',
-        ]),
-        methodPairs: Object.freeze([
-            Object.freeze({ neutralName: 'disposeWorld', legacyName: 'disposeGameWorld' }),
-            Object.freeze({ neutralName: 'loadPreviewEngine', legacyName: 'loadBabylon' }),
-            Object.freeze({ neutralName: 'createPreviewEngine', legacyName: 'createEngine' }),
-            Object.freeze({ neutralName: 'importPreviewAsset', legacyName: 'importProjectionModel' }),
+            'disposeWorld',
+            'loadPreviewEngine',
+            'createPreviewEngine',
+            'importPreviewAsset',
         ]),
     }),
 });
+export function createFpsGameEditorLocalEditorHost(options) {
+    const manifest = createFpsGameEditorLocalEditorHostManifest(options);
+    const host = createPlayableLocalEditorHost(manifest);
+    const compatibilityReport = host.getCompatibilityReport();
+    if (options.logCompatibilityReport !== false) {
+        logPlayableLocalEditorHostCompatibilityReport(compatibilityReport, options.logger);
+    }
+    return {
+        host,
+        manifest,
+        compatibilityReport,
+    };
+}
+export function createFpsGameEditorLocalEditorHostManifest(options) {
+    const { project, compatibilityTag, agentBridgeSessionMetadata, agentBridge: configuredAgentBridge, logCompatibilityReport: _logCompatibilityReport, logger: _logger, ...manifestOptions } = options;
+    const agentBridge = agentBridgeSessionMetadata
+        ? {
+            ...(configuredAgentBridge ?? {}),
+            sessionMetadata: {
+                ...configuredAgentBridge?.sessionMetadata,
+                ...agentBridgeSessionMetadata,
+            },
+        }
+        : configuredAgentBridge;
+    return {
+        ...manifestOptions,
+        metadata: {
+            manifestVersion: PLAYABLE_LOCAL_EDITOR_HOST_MANIFEST_VERSION,
+            projectId: project.projectId,
+            projectName: project.projectName,
+            ...(compatibilityTag ? { compatibilityTag } : {}),
+        },
+        ...(agentBridge ? { agentBridge } : {}),
+    };
+}
+function logPlayableLocalEditorHostCompatibilityReport(report, logger = console) {
+    const visibleDiagnostics = report.diagnostics.filter(diagnostic => diagnostic.severity === 'warning' || diagnostic.severity === 'error');
+    if (visibleDiagnostics.length === 0)
+        return;
+    const doctorReport = inspectPlayableEditorHostCompatibilityReport({
+        diagnostics: visibleDiagnostics,
+    });
+    const formatted = formatPlayableEditorDoctorReport(doctorReport);
+    if (doctorReport.ok)
+        logger.warn(formatted);
+    else
+        logger.error(formatted);
+}
 export function inspectPlayableLocalEditorHostManifest(manifest) {
     const diagnostics = [];
     const report = {
@@ -61,7 +109,7 @@ export function inspectPlayableLocalEditorHostManifest(manifest) {
     inspectLifecycle(manifest.lifecycle, diagnostics);
     inspectForgePlay(manifest.forgePlay, diagnostics);
     inspectAuthoring(manifest.authoring, diagnostics);
-    inspectCapabilities(manifest.capabilities, manifest.documentAdapter, diagnostics);
+    inspectCapabilities(manifest.capabilities, diagnostics);
     report.ok = !diagnostics.some(diagnostic => diagnostic.severity === 'error');
     return report;
 }
@@ -81,55 +129,17 @@ export function formatPlayableLocalEditorHostCompatibilityReport(report) {
 function createHarnessDocumentAdapter(documentCapability, capabilities) {
     return {
         ...documentCapability,
-        cloneDocument: capabilities?.documentLifecycle?.cloneDocument ?? documentCapability.cloneDocument,
-        compareDocuments: capabilities?.documentLifecycle?.compareDocuments ?? documentCapability.compareDocuments,
-        prepareDocument: capabilities?.documentLifecycle?.prepareDocument ?? documentCapability.prepareDocument,
-        summarize: capabilities?.documentLifecycle?.summarize ?? documentCapability.summarize,
-        isSelectable: capabilities?.selection?.isSelectable ?? documentCapability.isSelectable,
-        isLocked: capabilities?.selection?.isLocked ?? documentCapability.isLocked,
-        getSerializedObject: capabilities?.inspector?.getSerializedObject ?? documentCapability.getSerializedObject,
-        getSerializedMultiObject: capabilities?.inspector?.getSerializedMultiObject ?? documentCapability.getSerializedMultiObject,
-        getInspectorObject: capabilities?.inspector?.getInspectorObject ?? documentCapability.getInspectorObject,
-        getInspectorMultiObject: capabilities?.inspector?.getInspectorMultiObject ?? documentCapability.getInspectorMultiObject,
-        getRuntimeInspectorSections: capabilities?.inspector?.getRuntimeInspectorSections ?? documentCapability.getRuntimeInspectorSections,
-        getMarkerGraph: capabilities?.markerGraph?.getMarkerGraph ?? documentCapability.getMarkerGraph,
-        getMarkerTypeCatalog: capabilities?.markerGraph?.getMarkerTypeCatalog ?? documentCapability.getMarkerTypeCatalog,
-        getRelationTypeCatalog: capabilities?.markerGraph?.getRelationTypeCatalog ?? documentCapability.getRelationTypeCatalog,
-        getBrowserAssetItems: capabilities?.assetBrowser?.getBrowserAssetItems ?? documentCapability.getBrowserAssetItems,
-        createPatchFromAsset: capabilities?.assetActions?.createPatchFromAsset ?? documentCapability.createPatchFromAsset,
-        createAssetActionPatch: capabilities?.assetActions?.createAssetActionPatch ?? documentCapability.createAssetActionPatch,
-        createPlacedAssetPatch: capabilities?.assetActions?.createPlacedAssetPatch ?? documentCapability.createPlacedAssetPatch,
-        findCreatedId: capabilities?.assetActions?.findCreatedId ?? documentCapability.findCreatedId,
-        canCreateSerializedMultiPropertyPatch: capabilities?.transformCommands?.canCreateSerializedMultiPropertyPatch
-            ?? documentCapability.canCreateSerializedMultiPropertyPatch,
-        createSerializedMultiPropertyPatch: capabilities?.transformCommands?.createSerializedMultiPropertyPatch ?? documentCapability.createSerializedMultiPropertyPatch,
-        createMarkerGraphPatch: capabilities?.markerGraph?.createMarkerGraphPatch ?? documentCapability.createMarkerGraphPatch,
-        createTransformInspectorPreview: capabilities?.transformCommands?.createTransformInspectorPreview ?? documentCapability.createTransformInspectorPreview,
-        createTransformPatch: capabilities?.transformCommands?.createTransformPatch ?? documentCapability.createTransformPatch,
-        createTransformBatchPatch: capabilities?.transformCommands?.createTransformBatchPatch ?? documentCapability.createTransformBatchPatch,
-        createDuplicateSelectionPatch: capabilities?.transformCommands?.createDuplicateSelectionPatch ?? documentCapability.createDuplicateSelectionPatch,
-        validateSceneGraphDrop: capabilities?.sceneGraph?.validateSceneGraphDrop ?? documentCapability.validateSceneGraphDrop,
-        createSceneGraphRenamePatch: capabilities?.sceneGraph?.createSceneGraphRenamePatch ?? documentCapability.createSceneGraphRenamePatch,
-        createSceneGraphCreateGroupPatch: capabilities?.sceneGraph?.createSceneGraphCreateGroupPatch ?? documentCapability.createSceneGraphCreateGroupPatch,
-        createSceneGraphCreatePrimitivePatch: capabilities?.sceneGraph?.createSceneGraphCreatePrimitivePatch ?? documentCapability.createSceneGraphCreatePrimitivePatch,
-        createSceneGraphDeletePatch: capabilities?.sceneGraph?.createSceneGraphDeletePatch ?? documentCapability.createSceneGraphDeletePatch,
-        createSceneGraphDropPatch: capabilities?.sceneGraph?.createSceneGraphDropPatch ?? documentCapability.createSceneGraphDropPatch,
-        validateSceneGraphMove: capabilities?.sceneGraph?.validateSceneGraphMove ?? documentCapability.validateSceneGraphMove,
-        createSceneGraphMovePatch: capabilities?.sceneGraph?.createSceneGraphMovePatch ?? documentCapability.createSceneGraphMovePatch,
-        validateSceneGraphGroupSelection: capabilities?.sceneGraph?.validateSceneGraphGroupSelection ?? documentCapability.validateSceneGraphGroupSelection,
-        createSceneGraphGroupSelectionPatch: capabilities?.sceneGraph?.createSceneGraphGroupSelectionPatch ?? documentCapability.createSceneGraphGroupSelectionPatch,
-        getSceneCameraPreviewRig: capabilities?.worldPreview?.getSceneCameraPreviewRig ?? documentCapability.getSceneCameraPreviewRig,
-        getWorldAppearance: capabilities?.worldPreview?.getWorldAppearance ?? documentCapability.getWorldAppearance,
-        getWorldRendering: capabilities?.rendering?.getWorldRendering ?? documentCapability.getWorldRendering,
-        getPrefabStageDescriptor: capabilities?.prefabStage?.getPrefabStageDescriptor ?? documentCapability.getPrefabStageDescriptor,
-        getPrefabStageProjectionNodes: capabilities?.prefabStage?.getPrefabStageProjectionNodes ?? documentCapability.getPrefabStageProjectionNodes,
-        getPrefabStageStructure: capabilities?.prefabStage?.getPrefabStageStructure ?? documentCapability.getPrefabStageStructure,
-        getPrefabStageInspectorObject: capabilities?.prefabStage?.getPrefabStageInspectorObject ?? documentCapability.getPrefabStageInspectorObject,
-        resolvePrefabStagePreviewTarget: capabilities?.prefabStage?.resolvePrefabStagePreviewTarget ?? documentCapability.resolvePrefabStagePreviewTarget,
-        getPrefabStageProjectionNodeId: capabilities?.prefabStage?.getPrefabStageProjectionNodeId ?? documentCapability.getPrefabStageProjectionNodeId,
-        getRenderingPanelState: capabilities?.rendering?.getRenderingPanelState ?? documentCapability.getRenderingPanelState,
-        onRenderingAction: capabilities?.rendering?.onRenderingAction ?? documentCapability.onRenderingAction,
-        onRenderingPropertyChange: capabilities?.rendering?.onRenderingPropertyChange ?? documentCapability.onRenderingPropertyChange,
+        ...capabilities?.documentLifecycle,
+        ...capabilities?.selection,
+        ...capabilities?.inspector,
+        ...capabilities?.markerGraph,
+        ...capabilities?.assetBrowser,
+        ...capabilities?.assetActions,
+        ...capabilities?.transformCommands,
+        ...capabilities?.sceneGraph,
+        ...capabilities?.worldPreview,
+        ...capabilities?.rendering,
+        ...capabilities?.prefabStage,
     };
 }
 function createHarnessHierarchyOptions(manifest) {
@@ -137,22 +147,15 @@ function createHarnessHierarchyOptions(manifest) {
     const agentController = createEditorAgentInteractionController({
         transport: createForgePlayAgentTransport({
             window: manifest.forgePlay?.window,
-            agentContextDelivery: manifest.forgePlay?.agentContextDelivery,
         }),
     });
     const agentActions = createLocalEditorAgentHierarchyContextActions({
         sendContext: context => agentController.sendContext(context),
         getHierarchyItems: document => manifest.documentAdapter.getHierarchyItems(document),
         getProjectionNode: (document, id) => manifest.documentAdapter.getProjectionNode(document, id),
-        getMarkerGraph: document => capabilities?.markerGraph?.getMarkerGraph?.(document)
-            ?? manifest.documentAdapter.getMarkerGraph?.(document)
-            ?? null,
-        getMarkerTypeCatalog: document => capabilities?.markerGraph?.getMarkerTypeCatalog?.(document)
-            ?? manifest.documentAdapter.getMarkerTypeCatalog?.(document)
-            ?? [],
-        getRelationTypeCatalog: document => capabilities?.markerGraph?.getRelationTypeCatalog?.(document)
-            ?? manifest.documentAdapter.getRelationTypeCatalog?.(document)
-            ?? [],
+        getMarkerGraph: document => capabilities?.markerGraph?.getMarkerGraph?.(document) ?? null,
+        getMarkerTypeCatalog: document => capabilities?.markerGraph?.getMarkerTypeCatalog?.(document) ?? [],
+        getRelationTypeCatalog: document => capabilities?.markerGraph?.getRelationTypeCatalog?.(document) ?? [],
         describeSceneObject: manifest.capabilities?.agentContext?.describeSceneObject,
         describeSceneObjectSet: manifest.capabilities?.agentContext?.describeSceneObjectSet,
         describeRegionBinding: manifest.capabilities?.agentContext?.describeRegionBinding,
@@ -182,6 +185,7 @@ export function createPlayableLocalEditorHost(manifest) {
     const harnessOptions = {
         root: manifest.root,
         localTestActions: manifest.localTestActions,
+        pluginHost: manifest.pluginHost,
         authoringHost,
         documentAdapter: createHarnessDocumentAdapter(manifest.documentAdapter, manifest.capabilities),
         persistenceAdapter: manifest.persistenceAdapter,
@@ -193,12 +197,21 @@ export function createPlayableLocalEditorHost(manifest) {
         hierarchy: createHarnessHierarchyOptions(manifest),
     };
     const harness = createLocalEditorHarness(harnessOptions);
+    const lifecycleOperations = getLocalEditorHarnessLifecycleOperations(harness);
     const root = manifest.root ?? document.body;
     const loadingOverlay = createPlayableLocalEditorLoadingOverlay(root);
     const interactions = composePlayableLocalEditorInteractionPolicy(manifest.lifecycle.interactions, harness.getDefaultInteractionPolicy?.(), createNativePlayableLocalEditorInteractionPolicy(root));
     const uninstallBeforeUnloadGuard = installPlayableLocalEditorBeforeUnloadGuard(root, harness);
     const controller = createPlayableLocalEditorHostController({
         harness,
+        lifecycleOperations,
+        lifecycleScopeHost: manifest.pluginHost
+            ? getFpsEditorPluginLifecycleScopeHost(manifest.pluginHost)
+            : undefined,
+        eventPublisher: manifest.pluginHost?.eventPublisher,
+        reportDiagnostic: manifest.pluginHost
+            ? diagnostic => manifest.pluginHost?.reportDiagnostic(diagnostic)
+            : undefined,
         loadingOverlay,
         loadingContent: manifest.lifecycle.loadingContent,
         interactions,
@@ -218,34 +231,68 @@ export function createPlayableLocalEditorHost(manifest) {
             : undefined,
     });
     const hostHarness = controller.harness;
-    patchHarnessLifecycle(harness, controller);
-    let disposed = false;
+    bindHarnessLifecycle(lifecycleOperations, controller);
+    const lifecycleParticipantDisposers = manifest.pluginHost
+        ? resolveFpsEditorLifecycleParticipants(manifest.pluginHost.contributions)
+            .map(participant => controller.lifecycle.registerParticipant(participant))
+        : [];
+    if (lifecycleParticipantDisposers.length > 0) {
+        controller.lifecycle.addScopeResource(PLAYABLE_LOCAL_EDITOR_APPLICATION_SCOPE_ID, () => {
+            for (const dispose of [...lifecycleParticipantDisposers].reverse())
+                dispose();
+        });
+    }
+    let disposal = null;
+    let harnessDisposed = false;
     return {
         harness: hostHarness,
+        lifecycle: controller.lifecycle.lifecycle,
         enterEditor: controller.enterEditor,
         saveScene: controller.saveScene,
         saveAndRunGame: controller.saveAndRunGame,
-        discardAndRunGame: controller.discardAndRunGame,
+        discardAndRunGame: async () => {
+            await controller.discardAndRunGame();
+        },
         runWithAssetLoadingOverlay: controller.runWithAssetLoadingOverlay,
         getBridge: controller.getBridge,
         getCompatibilityReport() {
             return cloneCompatibilityReport(compatibilityReport);
         },
-        dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            uninstallBeforeUnloadGuard();
-            controller.dispose();
-            harness.dispose();
+        async dispose() {
+            if (disposal)
+                return disposal;
+            const pending = (async () => {
+                await controller.dispose();
+                uninstallBeforeUnloadGuard();
+                if (!harnessDisposed) {
+                    await harness.dispose();
+                    harnessDisposed = true;
+                }
+            })();
+            disposal = pending;
+            void pending.catch(() => {
+                if (disposal === pending)
+                    disposal = null;
+            });
+            return pending;
         },
     };
 }
-function patchHarnessLifecycle(harness, controller) {
-    harness.enterEditor = controller.enterEditor;
-    harness.saveScene = controller.saveScene;
-    harness.saveAndRunGame = controller.saveAndRunGame;
-    harness.discardAndRunGame = controller.discardAndRunGame;
+function bindHarnessLifecycle(lifecycleOperations, controller) {
+    lifecycleOperations.setLifecycleController({
+        enterEditor: controller.enterEditor,
+        saveScene: controller.saveScene,
+        saveAndRunGame: controller.saveAndRunGame,
+        discardAndRunGame: controller.discardAndRunGame,
+        prepareSaveAndRunGame: controller.prepareSaveAndRunGame,
+        prepareDiscardAndRunGame: controller.prepareDiscardAndRunGame,
+        lifecycle: controller.lifecycle.lifecycle,
+        synchronizeDocumentState: controller.lifecycle.synchronizeDocumentState,
+        registerParticipant: controller.lifecycle.registerParticipant,
+        openScope: controller.lifecycle.openScope,
+        addScopeResource: controller.lifecycle.addScopeResource,
+        closeScope: controller.lifecycle.closeScope,
+    });
 }
 function createNativePlayableLocalEditorInteractionPolicy(root) {
     const browserWindow = resolvePlayableLocalEditorWindow(root);
@@ -315,18 +362,18 @@ function stringifyPlayableLocalEditorError(error) {
 }
 function inspectMetadata(metadata, report, diagnostics) {
     if (metadata === undefined) {
-        diagnostics.push(createDiagnostic('warning', 'metadata.missing', 'Manifest metadata is missing; add metadata to make package upgrade compatibility explicit.', 'metadata'));
+        diagnostics.push(createDiagnostic('error', 'metadata.missing', 'Manifest metadata is required for the host compatibility contract.', 'metadata'));
         return;
     }
     if (!isRecord(metadata)) {
-        diagnostics.push(createDiagnostic('warning', 'metadata.invalid', 'Manifest metadata should be an object. Runtime can continue, but compatibility reporting is incomplete.', 'metadata'));
+        diagnostics.push(createDiagnostic('error', 'metadata.invalid', 'Manifest metadata must be an object.', 'metadata'));
         return;
     }
     report.manifestVersion = metadata.manifestVersion;
     report.projectId = readOptionalString(metadata.projectId);
     report.projectName = readOptionalString(metadata.projectName);
     report.compatibilityTag = readOptionalString(metadata.compatibilityTag);
-    if (metadata.manifestVersion !== undefined && metadata.manifestVersion !== PLAYABLE_LOCAL_EDITOR_HOST_MANIFEST_VERSION) {
+    if (metadata.manifestVersion !== PLAYABLE_LOCAL_EDITOR_HOST_MANIFEST_VERSION) {
         diagnostics.push(createDiagnostic('error', 'metadata.manifest-version.unsupported', `Manifest version ${String(metadata.manifestVersion)} is incompatible with supported version ${PLAYABLE_LOCAL_EDITOR_HOST_MANIFEST_VERSION}. Upgrade the manifest or use a compatible editor package version.`, 'metadata.manifestVersion'));
     }
 }
@@ -360,8 +407,11 @@ function validateFunctionSignature(fn, functionName, capabilityName, diagnostics
     if (expectedArity === undefined)
         return; // No validation defined for this function
     const actualArity = fn.length;
-    if (actualArity > 0 && actualArity < expectedArity.min) {
-        diagnostics.push(createDiagnostic('warning', `${capabilityName}.${functionName}.arity-mismatch`, `${capabilityName}.${functionName} declares ${actualArity} parameter(s), but SDK expects at least ${expectedArity.min}. Verify the function signature matches the SDK contract.`, `${capabilityName}.${functionName}`));
+    const arityMismatch = actualArity < expectedArity.min
+        || (expectedArity.max !== undefined && actualArity > expectedArity.max);
+    if (arityMismatch) {
+        const severity = capabilityName === 'worldCapability' ? 'error' : 'warning';
+        diagnostics.push(createDiagnostic(severity, `${capabilityName}.${functionName}.arity-mismatch`, `${capabilityName}.${functionName} declares ${actualArity} parameter(s), but SDK expects ${expectedArity.min}${expectedArity.max !== undefined && expectedArity.max !== expectedArity.min ? `-${expectedArity.max}` : ''}. Verify the function signature matches the SDK contract.`, `${capabilityName}.${functionName}`));
     }
 }
 /**
@@ -374,7 +424,6 @@ function getExpectedFunctionArity(capabilityName, functionName) {
     if (capabilityName === 'documentCapability') {
         switch (functionName) {
             case 'reduceDocument': return { min: 2, max: 2 }; // (document, command)
-            case 'getSerializedObject': return { min: 2, max: 2 }; // (document, activeId)
             case 'getHierarchyItems': return { min: 1, max: 1 }; // (document)
             case 'getProjectionNodes': return { min: 1, max: 1 }; // (document)
             case 'getProjectionNode': return { min: 2, max: 2 }; // (document, id)
@@ -386,7 +435,7 @@ function getExpectedFunctionArity(capabilityName, functionName) {
     if (capabilityName === 'persistenceCapability') {
         switch (functionName) {
             case 'loadAssets': return { min: 1, max: 1 }; // (document)
-            case 'runGame': return { min: 0, max: 0 }; // ()
+            case 'runGame': return { min: 0, max: 1 }; // (context?)
         }
     }
     // World capability function signatures
@@ -394,13 +443,9 @@ function getExpectedFunctionArity(capabilityName, functionName) {
         switch (functionName) {
             case 'getCanvas': return { min: 0, max: 0 }; // ()
             case 'disposeWorld': return { min: 0, max: 0 }; // ()
-            case 'disposeGameWorld': return { min: 0, max: 0 }; // ()
             case 'loadPreviewEngine': return { min: 0, max: 0 }; // ()
-            case 'loadBabylon': return { min: 0, max: 0 }; // ()
-            case 'createPreviewEngine': return { min: 1, max: 1 }; // (canvas)
-            case 'createEngine': return { min: 1, max: 1 }; // (canvas)
+            case 'createPreviewEngine': return { min: 2, max: 2 }; // (engineModule, canvas)
             case 'importPreviewAsset': return { min: 1, max: 1 }; // (context)
-            case 'importProjectionModel': return { min: 1, max: 1 }; // (context)
         }
     }
     return undefined;
@@ -419,49 +464,23 @@ function inspectWorldCapability(worldCapability, diagnostics) {
             validateFunctionSignature(fn, functionName, 'worldCapability', diagnostics);
         }
     }
-    for (const pair of PLAYABLE_LOCAL_EDITOR_HOST_REQUIRED_CONTRACT.world.methodPairs) {
-        inspectWorldMethodPair(worldCapability, diagnostics, pair);
-    }
-}
-function inspectWorldMethodPair(worldCapability, diagnostics, pair) {
-    const neutralFn = worldCapability[pair.neutralName];
-    const legacyFn = worldCapability[pair.legacyName];
-    const hasNeutral = typeof neutralFn === 'function';
-    const hasLegacy = typeof legacyFn === 'function';
-    if (!hasNeutral && !hasLegacy) {
-        diagnostics.push(createDiagnostic('error', `worldCapability.${pair.neutralName}.missing`, `worldCapability.${pair.neutralName} must be a function.`, `worldCapability.${pair.neutralName}`));
-        return;
-    }
-    if (!hasNeutral && hasLegacy) {
-        diagnostics.push(createDiagnostic('warning', `worldCapability.${pair.legacyName}.legacy`, `worldCapability.${pair.legacyName} is supported for compatibility; prefer ${pair.neutralName} for new host manifests.`, `worldCapability.${pair.legacyName}`));
-        // Validate legacy function signature
-        validateFunctionSignature(legacyFn, pair.legacyName, 'worldCapability', diagnostics);
-    }
-    else if (hasNeutral) {
-        // Validate neutral function signature
-        validateFunctionSignature(neutralFn, pair.neutralName, 'worldCapability', diagnostics);
-    }
 }
 function createHarnessWorldAdapter(worldCapability) {
     const adapter = {
         disposeGameWorld() {
-            const disposeWorld = worldCapability.disposeWorld ?? worldCapability.disposeGameWorld;
-            return disposeWorld?.();
+            return worldCapability.disposeWorld?.();
         },
         getCanvas() {
             return worldCapability.getCanvas();
         },
         loadBabylon() {
-            const loadPreviewEngine = worldCapability.loadPreviewEngine ?? worldCapability.loadBabylon;
-            return loadPreviewEngine?.();
+            return worldCapability.loadPreviewEngine?.();
         },
         createEngine(engineModule, canvas) {
-            const createPreviewEngine = worldCapability.createPreviewEngine ?? worldCapability.createEngine;
-            return createPreviewEngine?.(engineModule, canvas);
+            return worldCapability.createPreviewEngine?.(engineModule, canvas);
         },
         importProjectionModel(context) {
-            const importPreviewAsset = worldCapability.importPreviewAsset ?? worldCapability.importProjectionModel;
-            return importPreviewAsset?.(context);
+            return worldCapability.importPreviewAsset?.(context);
         },
     };
     if (worldCapability.toBrowserAssetItem) {
@@ -499,107 +518,18 @@ function inspectAuthoring(authoring, diagnostics) {
         diagnostics.push(createDiagnostic('info', 'authoring.host-overrides-drivers', 'authoring.host and authoring.drivers are both present; the provided host will be used.', 'authoring'));
     }
 }
-const PLAYABLE_LOCAL_EDITOR_CAPABILITY_LEGACY_FIELDS = [
-    {
-        namespace: 'documentLifecycle',
-        fields: ['cloneDocument', 'compareDocuments', 'prepareDocument', 'summarize'],
-    },
-    {
-        namespace: 'selection',
-        fields: ['isSelectable', 'isLocked'],
-    },
-    {
-        namespace: 'inspector',
-        fields: [
-            'getSerializedObject',
-            'getSerializedMultiObject',
-            'getInspectorObject',
-            'getInspectorMultiObject',
-            'getRuntimeInspectorSections',
-        ],
-    },
-    {
-        namespace: 'assetBrowser',
-        fields: ['getBrowserAssetItems'],
-    },
-    {
-        namespace: 'assetActions',
-        fields: ['createPatchFromAsset', 'createAssetActionPatch', 'createPlacedAssetPatch', 'findCreatedId'],
-    },
-    {
-        namespace: 'transformCommands',
-        fields: [
-            'canCreateSerializedMultiPropertyPatch',
-            'createSerializedMultiPropertyPatch',
-            'createTransformInspectorPreview',
-            'createTransformPatch',
-            'createTransformBatchPatch',
-            'createDuplicateSelectionPatch',
-        ],
-    },
-    {
-        namespace: 'sceneGraph',
-        fields: [
-            'validateSceneGraphDrop',
-            'createSceneGraphRenamePatch',
-            'createSceneGraphCreateGroupPatch',
-            'createSceneGraphCreatePrimitivePatch',
-            'createSceneGraphDeletePatch',
-            'createSceneGraphDropPatch',
-            'validateSceneGraphMove',
-            'createSceneGraphMovePatch',
-            'validateSceneGraphGroupSelection',
-            'createSceneGraphGroupSelectionPatch',
-        ],
-    },
-    {
-        namespace: 'markerGraph',
-        fields: ['getMarkerGraph', 'getMarkerTypeCatalog', 'getRelationTypeCatalog', 'createMarkerGraphPatch'],
-    },
-    {
-        namespace: 'worldPreview',
-        fields: ['getSceneCameraPreviewRig', 'getWorldAppearance'],
-    },
-    {
-        namespace: 'rendering',
-        fields: ['getWorldRendering', 'getRenderingPanelState', 'onRenderingAction', 'onRenderingPropertyChange'],
-    },
-    {
-        namespace: 'hierarchyActions',
-        fields: ['contextActions'],
-    },
-    {
-        namespace: 'agentContext',
-        fields: ['describeSceneObject', 'describeSceneObjectSet', 'describeRegionBinding'],
-    },
-];
-function inspectCapabilities(capabilities, documentCapability, diagnostics) {
+function inspectCapabilities(capabilities, diagnostics) {
     if (capabilities === undefined)
         return;
     if (!isRecord(capabilities)) {
-        diagnostics.push(createDiagnostic('warning', 'capabilities.invalid', 'capabilities should be an object. Legacy documentAdapter optional fields will still be used.', 'capabilities'));
+        diagnostics.push(createDiagnostic('warning', 'capabilities.invalid', 'capabilities must be an object when provided.', 'capabilities'));
         return;
     }
-    const legacy = isRecord(documentCapability) ? documentCapability : {};
-    for (const entry of PLAYABLE_LOCAL_EDITOR_CAPABILITY_LEGACY_FIELDS) {
-        const namespace = capabilities[entry.namespace];
-        if (namespace === undefined)
-            continue;
-        if (!isRecord(namespace)) {
-            diagnostics.push(createDiagnostic('warning', `capabilities.${entry.namespace}.invalid`, `capabilities.${entry.namespace} should be an object. Legacy documentAdapter optional fields will still be used for this capability group.`, `capabilities.${entry.namespace}`));
-            continue;
-        }
-        for (const field of entry.fields) {
-            if (field === 'contextActions') {
-                if (namespace[field] !== undefined && !Array.isArray(namespace[field])) {
-                    diagnostics.push(createDiagnostic('warning', `capabilities.${entry.namespace}.${field}.invalid`, `capabilities.${entry.namespace}.${field} should be an array of hierarchy action registrations.`, `capabilities.${entry.namespace}.${field}`));
-                }
-                continue;
-            }
-            if (typeof namespace[field] === 'function' && typeof legacy[field] === 'function') {
-                diagnostics.push(createDiagnostic('info', `capabilities.${entry.namespace}.${field}.overrides-documentAdapter`, `capabilities.${entry.namespace}.${field} overrides legacy documentAdapter.${field}.`, `capabilities.${entry.namespace}.${field}`));
-            }
-        }
+    const hierarchyActions = capabilities.hierarchyActions;
+    if (isRecord(hierarchyActions)
+        && hierarchyActions.contextActions !== undefined
+        && !Array.isArray(hierarchyActions.contextActions)) {
+        diagnostics.push(createDiagnostic('warning', 'capabilities.hierarchyActions.contextActions.invalid', 'capabilities.hierarchyActions.contextActions should be an array of hierarchy action registrations.', 'capabilities.hierarchyActions.contextActions'));
     }
 }
 function createDiagnostic(severity, code, message, path) {