@jgengine/editor 0.18.1 → 0.21.0

package/dist/ClipPreviewLayer.d.ts

@@ -2,9 +2,8 @@ import type { EditorHostApi } from "./session.js";
 import type { EditorUiStore } from "./uiStore.js";
 /**
  * Viewport layer that renders the active clip-preview asset playing the selected clip, mounted by
- * `EditorApp` inside the editor's R3F scene + GameContext. Reuses the shell's shared GLTF loader,
- * scene clone, and `useModelAnimation` mixer — the same driver `EntityModel` runs at play time — so
- * the preview IS the runtime playback. Reads the live session from the editor UI store and publishes
+ * `EditorApp` inside the editor's R3F scene + GameContext. Reuses the shell's model instance,
+ * bind placement and animation lifecycle. Reads the live session from the editor UI store and publishes
  * the selected clip's measured duration back so the dock scrubber can normalize.
  *
  * @internal — not a game-author entry point.

package/dist/ClipPreviewLayer.js

@@ -1,19 +1,17 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Suspense, useEffect, useMemo } from "react";
 import { useLoader } from "@react-three/fiber";
-import * as THREE from "three";
 import { sharedGltfLoader } from "@jgengine/shell/render/modelLoad";
-import { cloneModelScene, disposeClonedMaterials } from "@jgengine/shell/render/modelRender";
-import { useModelAnimation } from "@jgengine/shell/render/useModelAnimation";
+import { createGraphPose } from "@jgengine/shell/render/useModelAnimation";
+import { useModelInstance } from "@jgengine/shell/render/useModelInstance";
 import { previewAnimationConfig } from "./shell/clipPreview.js";
 import { useStoreSelector } from "./useStoreSelector.js";
 /** World-unit height the previewed model is normalized to, so tiny/huge rigs are both framed. */
 const PREVIEW_TARGET_HEIGHT = 2;
 /**
  * Viewport layer that renders the active clip-preview asset playing the selected clip, mounted by
- * `EditorApp` inside the editor's R3F scene + GameContext. Reuses the shell's shared GLTF loader,
- * scene clone, and `useModelAnimation` mixer — the same driver `EntityModel` runs at play time — so
- * the preview IS the runtime playback. Reads the live session from the editor UI store and publishes
+ * `EditorApp` inside the editor's R3F scene + GameContext. Reuses the shell's model instance,
+ * bind placement and animation lifecycle. Reads the live session from the editor UI store and publishes
  * the selected clip's measured duration back so the dock scrubber can normalize.
  *
  * @internal — not a game-author entry point.
@@ -27,24 +25,25 @@ export function ClipPreviewLayer({ api, ui }) {
 function ClipPreviewModel({ session, api, ui, }) {
     const { source, driver } = session;
     const gltf = useLoader(sharedGltfLoader, source.url);
-    const scene = useMemo(() => cloneModelScene(gltf.scene), [gltf]);
-    useEffect(() => () => disposeClonedMaterials(scene), [scene]);
-    // Normalize height and center/ground so any rig frames nicely at the camera focus point.
-    const placement = useMemo(() => {
-        const box = new THREE.Box3().setFromObject(scene);
-        const height = box.max.y - box.min.y;
-        if (!Number.isFinite(height) || height <= 0)
-            return { scale: 1, minY: 0, centerX: 0, centerZ: 0 };
-        return {
-            scale: PREVIEW_TARGET_HEIGHT / height,
-            minY: box.min.y,
-            centerX: (box.min.x + box.max.x) / 2,
-            centerZ: (box.min.z + box.max.z) / 2,
-        };
-    }, [scene]);
-    const config = useMemo(() => previewAnimationConfig(driver), [driver]);
-    useModelAnimation(scene, gltf.animations, config, undefined);
-    // Publish the selected clip's duration once loaded so the dock scrubber can span it (0 = unknown).
+    const graphPose = session.graphPose;
+    const posedByGraph = graphPose !== undefined;
+    const config = useMemo(() => (posedByGraph ? undefined : previewAnimationConfig(driver)), [driver, posedByGraph]);
+    const { content, scene, scale, position } = useModelInstance({ url: source.url, targetHeight: PREVIEW_TARGET_HEIGHT, animation: config });
+    const graph = graphPose?.graph;
+    const pose = useMemo(() => (graph === undefined ? null : createGraphPose(content, graph, gltf.animations)), [content, graph, gltf]);
+    useEffect(() => () => pose?.dispose(), [pose]);
+    const graphClips = graphPose?.clips;
+    const rootMotion = graphPose?.rootMotion;
+    useEffect(() => {
+        if (pose !== null && graphClips !== undefined)
+            pose.apply(graphClips, rootMotion === true);
+    }, [pose, graphClips, rootMotion]);
+    useEffect(() => {
+        const current = ui.getState().clipPreview;
+        if (current === null || current.source.assetId !== source.assetId || current.clipDurations !== undefined)
+            return;
+        ui.patch({ clipPreview: { ...current, clipDurations: Object.fromEntries(gltf.animations.map((clip) => [clip.name, clip.duration])) } });
+    }, [gltf, ui, source.assetId]);
     const clipName = driver.clipName;
     useEffect(() => {
         const clip = clipName === null ? undefined : gltf.animations.find((entry) => entry.name === clipName);
@@ -55,6 +54,5 @@ function ClipPreviewModel({ session, api, ui, }) {
         }
     }, [gltf, clipName, ui, source.assetId]);
     const focus = api.getFocusTarget() ?? { x: 0, y: 0, z: 0 };
-    const s = placement.scale;
-    return (_jsx("group", { position: [focus.x, focus.y, focus.z], children: _jsx("primitive", { object: scene, scale: s, position: [-s * placement.centerX, -s * placement.minY, -s * placement.centerZ] }) }));
+    return (_jsx("group", { position: [focus.x, focus.y, focus.z], children: _jsx("primitive", { object: scene, scale: scale, position: position }) }));
 }

package/dist/CreatorApp.d.ts

@@ -0,0 +1,12 @@
+import { type CreatorConfig as CoreCreatorConfig } from "@jgengine/core/editor/creatorStorage";
+import type { PlayableGame } from "@jgengine/shell/registry";
+/** Game-owned creator policy, durable storage and document-to-runtime composition. */
+export type CreatorConfig = CoreCreatorConfig<PlayableGame>;
+/** Production creator catalog and embedded editor, reached through the game's menu.
+ * @capability player-creator create, edit, save, playtest and reopen bounded player scenes through the production editor
+ */
+export declare function CreatorApp({ gameId, config, onExit }: {
+    gameId: string;
+    config: CreatorConfig;
+    onExit: () => void;
+}): import("react").JSX.Element;

package/dist/CreatorApp.js

@@ -0,0 +1,107 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { importCreatorDocument, validateCreatorDocument } from "@jgengine/core/editor/creatorStorage";
+import { EditorApp } from "./EditorApp.js";
+/** Production creator catalog and embedded editor, reached through the game's menu.
+ * @capability player-creator create, edit, save, playtest and reopen bounded player scenes through the production editor
+ */
+export function CreatorApp({ gameId, config, onExit }) {
+    const [documents, setDocuments] = useState([]);
+    const [selected, setSelected] = useState(null);
+    const [name, setName] = useState("");
+    const [error, setError] = useState(null);
+    const [busy, setBusy] = useState(false);
+    const revision = useRef(null);
+    const pending = useRef(false);
+    const generation = useRef(0);
+    const refresh = useCallback(async () => {
+        try {
+            const values = await config.storage.list();
+            if (values.length > config.policy.maxDocuments)
+                throw new Error("Creator catalog exceeds document budget");
+            setDocuments(values);
+        }
+        catch (failure) {
+            setError(failure instanceof Error ? failure.message : String(failure));
+        }
+    }, [config]);
+    useEffect(() => { void refresh(); return () => { generation.current += 1; }; }, [refresh]);
+    const validate = useCallback((document) => { validateCreatorDocument(document, config.policy); }, [config]);
+    const playable = useMemo(() => selected === null ? null : config.createPlayable(selected.document), [selected, config]);
+    const save = useCallback(async (json) => {
+        if (selected === null || pending.current)
+            return { ok: false, error: "A save is already in progress" };
+        pending.current = true;
+        const currentGeneration = generation.current;
+        try {
+            const document = importCreatorDocument(json, config.policy);
+            const next = await config.storage.save({ ...selected, document }, revision.current);
+            if (generation.current === currentGeneration) {
+                revision.current = next.revision;
+                setError(null);
+            }
+            return { ok: true, path: next.name };
+        }
+        catch (failure) {
+            return { ok: false, error: failure instanceof Error ? failure.message : String(failure) };
+        }
+        finally {
+            pending.current = false;
+        }
+    }, [selected, config]);
+    const run = async (action) => {
+        if (busy)
+            return;
+        setBusy(true);
+        setError(null);
+        try {
+            await action();
+        }
+        catch (failure) {
+            setError(failure instanceof Error ? failure.message : String(failure));
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    const create = () => run(async () => {
+        if (documents.length >= config.policy.maxDocuments)
+            throw new Error("Creator catalog is full");
+        const document = validateCreatorDocument(config.initialDocument(), config.policy);
+        const value = await config.storage.save({ version: 1, id: config.createId?.() ?? crypto.randomUUID(), name: name.trim(), revision: 0, document }, null);
+        revision.current = value.revision;
+        setSelected(value);
+    });
+    const importFile = (file) => run(async () => {
+        if (documents.length >= config.policy.maxDocuments)
+            throw new Error("Creator catalog is full");
+        if (file.size > config.policy.maxBytes)
+            throw new Error("Scene exceeds byte budget");
+        const document = importCreatorDocument(await file.text(), config.policy);
+        const value = await config.storage.save({ version: 1, id: config.createId?.() ?? crypto.randomUUID(), name: name.trim(), revision: 0, document }, null);
+        revision.current = value.revision;
+        setSelected(value);
+    });
+    const reopen = (id) => run(async () => {
+        const value = await config.storage.load(id);
+        if (value === null)
+            throw new Error("Scene no longer exists");
+        validate(value.document);
+        revision.current = value.revision;
+        setSelected(value);
+    });
+    const returnToCatalog = () => {
+        generation.current += 1;
+        setSelected(null);
+        void refresh();
+    };
+    if (selected !== null && playable !== null) {
+        return _jsx(EditorApp, { gameId: `${gameId}:${selected.id}`, playable: playable, layers: selected.document, catalogs: playable.editorCatalogs, save: save, createPlaytest: config.createPlayable, validateDocument: validate, playerCreator: true, allowedAssets: config.policy.allowedAssets, allowedKinds: config.policy.allowedKinds, maxImportBytes: config.policy.maxBytes, creatorPolicy: config.policy, onExitEditor: returnToCatalog });
+    }
+    return (_jsxs("section", { "aria-label": "Scene creator", style: { padding: 24, color: "#eef2ff", background: "#111827", minHeight: "100%", fontFamily: "sans-serif" }, children: [_jsx("h1", { children: "Create and edit" }), _jsx("button", { type: "button", onClick: onExit, children: "Return to game" }), _jsxs("form", { onSubmit: (event) => { event.preventDefault(); void create(); }, style: { marginBlock: 24 }, children: [_jsxs("label", { children: ["Scene name ", _jsx("input", { value: name, maxLength: 80, onChange: (event) => setName(event.target.value) })] }), " ", _jsx("button", { type: "submit", disabled: busy || name.trim().length === 0 || documents.length >= config.policy.maxDocuments, children: "Create scene" })] }), _jsxs("label", { children: ["Import scene JSON ", _jsx("input", { type: "file", accept: "application/json,.json", "aria-label": "Import scene JSON", disabled: busy || name.trim().length === 0 || documents.length >= config.policy.maxDocuments, onChange: (event) => {
+                            const file = event.target.files?.[0];
+                            if (file !== undefined)
+                                void importFile(file);
+                            event.target.value = "";
+                        } })] }), _jsxs("p", { children: [documents.length, " / ", config.policy.maxDocuments, " saved scenes"] }), error === null ? null : _jsx("p", { role: "alert", children: error }), _jsx("ul", { children: documents.map((value) => _jsxs("li", { children: [value.name, " ", _jsxs("button", { type: "button", disabled: busy, onClick: () => void reopen(value.id), children: ["Edit ", value.name] })] }, value.id)) })] }));
+}

package/dist/DebugDraw.js

@@ -2,6 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Html } from "@react-three/drei";
 import { memo, useEffect, useMemo } from "react";
 import * as THREE from "three";
+import { markerCatalogId } from "@jgengine/core/world/authoredObjects";
 const DEFAULT_COLORS = {
     player_spawn: "#22d3ee",
     boss: "#f43f5e",
@@ -103,10 +104,11 @@ const MarkerMesh = memo(function MarkerMesh({ marker, selected, hovered, onSelec
     const scale = selected ? 1.28 : hovered ? 1.12 : 1;
     const baseY = groundHeightAt !== undefined ? groundHeightAt(marker.position.x, marker.position.z) : marker.position.y;
     const fill = emphasisColor(selected, hovered, color);
+    const modelBacked = markerCatalogId(marker) !== null;
     return (_jsxs("group", { position: [marker.position.x, baseY + 1.2, marker.position.z], "rotation-y": marker.rotationY ?? 0, scale: scale, userData: { jgEditorId: marker.id }, onClick: (event) => {
             event.stopPropagation();
             onSelect(marker.id);
-        }, children: [_jsx("mesh", { geometry: sharedSphere, children: _jsx("meshBasicMaterial", { color: fill, transparent: true, opacity: selected ? 1 : hovered ? 0.9 : 1 }) }), selected || hovered ? (_jsx("mesh", { geometry: sharedSphere, scale: 1.18, children: _jsx("meshBasicMaterial", { color: fill, transparent: true, opacity: selected ? 0.28 : 0.18, depthWrite: false }) })) : null, _jsx("mesh", { position: [0, 1.35, 0], geometry: sharedCone, children: _jsx("meshBasicMaterial", { color: selected || hovered ? fill : color }) })] }));
+        }, children: [_jsx("mesh", { geometry: sharedSphere, children: _jsx("meshBasicMaterial", { color: fill, transparent: true, opacity: selected ? 1 : hovered ? 0.9 : 1, wireframe: modelBacked, depthWrite: !modelBacked }) }), selected || hovered ? (_jsx("mesh", { geometry: sharedSphere, scale: 1.18, children: _jsx("meshBasicMaterial", { color: fill, transparent: true, opacity: selected ? 0.28 : 0.18, wireframe: modelBacked, depthWrite: false }) })) : null, _jsx("mesh", { position: [0, 1.35, 0], geometry: sharedCone, children: _jsx("meshBasicMaterial", { color: selected || hovered ? fill : color }) })] }));
 });
 /** Shape-true wireframe — ground ring plus vertical profile for spheres, cylinders, and boxes. */
 const VolumeShapeLines = memo(function VolumeShapeLines({ volume, selected, hovered, onSelect, }) {

package/dist/EditorApp.d.ts

@@ -1,8 +1,9 @@
 import { type ComponentType } from "react";
-import type { EditorCatalogDefinition, EditorLayersInput } from "@jgengine/core/editor/index";
+import type { EditorCatalogDefinition, EditorDocument, EditorLayersInput } from "@jgengine/core/editor/index";
 import type { PlayableGame } from "@jgengine/shell/registry";
 import { type EditorNetworkPresenceInput } from "./networkSnapshot.js";
 import { type EditorRunMode } from "./session.js";
+import type { CreatorPolicy } from "@jgengine/core/editor/creatorStorage";
 /** Props for mounting the scene editor over a playable game. */
 export interface EditorAppProps {
     gameId: string;
@@ -29,6 +30,17 @@ export interface EditorAppProps {
      * standalone editor, which has no game to return to.
      */
     onExitEditor?: () => void;
+    /** Build a fresh playable from a captured document for each isolated playtest. */
+    createPlaytest?: (document: EditorDocument) => PlayableGame;
+    /** Reject document edits before they enter history, live sync, or saves. */
+    validateDocument?: (document: EditorDocument) => void;
+    /** Disable developer host publication and recovery drafts for a player creator. */
+    playerCreator?: boolean;
+    /** Catalog entries the player creator may place. */
+    allowedAssets?: readonly string[];
+    allowedKinds?: readonly string[];
+    maxImportBytes?: number;
+    creatorPolicy?: CreatorPolicy;
 }
 /** Persists an exported document JSON; resolves with where it landed or why it failed. */
 export type EditorSaveFn = (json: string) => Promise<{
@@ -37,4 +49,4 @@ export type EditorSaveFn = (json: string) => Promise<{
     error?: string;
 }>;
 /** Top-level scene editor: author spawns/zones/paths/notes visually over edit, walk, or play modes. */
-export declare function EditorApp({ gameId, playable, layers, catalogs, save, modeChip, networkPresence, onExitEditor }: EditorAppProps): import("react").JSX.Element;
+export declare function EditorApp({ gameId, playable, layers, catalogs, save, modeChip, networkPresence, onExitEditor, createPlaytest, validateDocument, playerCreator, allowedAssets, allowedKinds, maxImportBytes, creatorPolicy }: EditorAppProps): import("react").JSX.Element;

package/dist/EditorApp.js

@@ -27,6 +27,8 @@ import { createEditorHost } from "./session.js";
 import { createEditorUiStore, } from "./uiStore.js";
 import { useF2Chord } from "./useF2Chord.js";
 import { shallowArrayEqual, useStoreSelector } from "./useStoreSelector.js";
+import { EditorDocumentSaveContext, useDocumentSave } from "./useDocumentSave.js";
+import { PlayModeBar } from "./shell/PlayModeBar.js";
 function endpointSaver(gameId) {
     const endpoint = getSaveEndpoint();
     if (endpoint === null)
@@ -245,7 +247,7 @@ function resolveEditorCamera(document) {
     };
 }
 /** Top-level scene editor: author spawns/zones/paths/notes visually over edit, walk, or play modes. */
-export function EditorApp({ gameId, playable, layers, catalogs, save, modeChip, networkPresence, onExitEditor }) {
+export function EditorApp({ gameId, playable, layers, catalogs, save, modeChip, networkPresence, onExitEditor, createPlaytest, validateDocument, playerCreator, allowedAssets, allowedKinds, maxImportBytes, creatorPolicy }) {
     const resolvedModeChip = modeChip === undefined ? EditorModeChip : modeChip;
     const saveFn = useMemo(() => save ?? endpointSaver(gameId), [save, gameId]);
     const networkSnapshot = useMemo(() => buildEditorNetworkSnapshot({
@@ -263,13 +265,13 @@ export function EditorApp({ gameId, playable, layers, catalogs, save, modeChip,
     const readout = readoutStoreRef.current;
     const catalogAssets = useMemo(() => {
         try {
-            const ids = playable.game.assets.ids();
+            const ids = playable.game.assets.ids().filter((id) => allowedAssets === undefined || allowedAssets.includes(id));
             return assetsFromCatalog(ids, (id) => playable.game.assets.resolve(id));
         }
         catch {
             return [];
         }
-    }, [playable]);
+    }, [playable, allowedAssets]);
     const resolvedLayers = layers ?? playable.editorLayers;
     const host = useMemo(() => {
         const created = createEditorHost({
@@ -277,18 +279,25 @@ export function EditorApp({ gameId, playable, layers, catalogs, save, modeChip,
             layers: resolvedLayers,
             catalogs,
             assets: catalogAssets,
+            validateDocument,
+            isolatedPlaytest: createPlaytest !== undefined,
+            publishGlobal: playerCreator !== true,
+            persistAssetUrls: playerCreator !== true,
         });
         return {
             ...created,
             baselineJson: created.session.exportJson(true),
             baselineDocument: created.session.getState().document,
         };
-    }, [gameId, resolvedLayers, catalogs, catalogAssets]);
+    }, [gameId, resolvedLayers, catalogs, catalogAssets, createPlaytest, validateDocument, playerCreator]);
     useEffect(() => host.dispose, [host]);
+    const documentSave = useDocumentSave(host.session, saveFn);
     const modeStore = useMemo(() => ({ getState: host.api.getMode, subscribe: host.api.subscribeMode }), [host]);
     const mode = useStoreSelector(modeStore, (m) => m);
     const [pendingDraft, setPendingDraft] = useState(null);
     useEffect(() => {
+        if (playerCreator)
+            return;
         const draft = readDraft(gameId);
         if (draft !== null && draft !== host.baselineJson)
             setPendingDraft(draft);
@@ -306,7 +315,7 @@ export function EditorApp({ gameId, playable, layers, catalogs, save, modeChip,
                 clearTimeout(timer);
             unsubscribe();
         };
-    }, [gameId, host]);
+    }, [gameId, host, playerCreator]);
     const restoreDraft = () => {
         if (pendingDraft === null)
             return;
@@ -385,6 +394,10 @@ export function EditorApp({ gameId, playable, layers, catalogs, save, modeChip,
     }, [gameId]);
     const initialCamera = useMemo(() => resolveEditorCamera(host.session.getState().document), [host]);
     const cameraProjection = useStoreSelector(ui, (state) => state.cameraProjection);
+    const playtestPlayable = useMemo(() => {
+        const snapshot = host.api.getPlayDocument();
+        return mode === "play" && createPlaytest !== undefined && snapshot !== null ? createPlaytest(snapshot) : playable;
+    }, [mode, host, createPlaytest, playable]);
     const editorPlayable = useMemo(() => {
         const frozenLoop = {
             onInit: playable.loop.onInit,
@@ -444,15 +457,16 @@ export function EditorApp({ gameId, playable, layers, catalogs, save, modeChip,
             };
         }
         if (mode === "play") {
-            const BaseUI = playable.GameUI;
-            const BaseOverlay = playable.WorldOverlay;
+            const playtest = playtestPlayable;
+            const BaseUI = playtest.GameUI;
+            const BaseOverlay = playtest.WorldOverlay;
             const useBuiltinPlayChrome = resolvedModeChip === EditorModeChip;
             return {
-                ...playable,
+                ...playtest,
                 GameUI: function EditorPlayUi() {
                     const onExit = useCallback(() => host.api.setMode("edit"), []);
                     useF2Chord("KeyE", onExit);
-                    return (_jsxs(_Fragment, { children: [BaseUI !== undefined ? _jsx(BaseUI, {}) : null, useBuiltinPlayChrome ? (_jsx(RuntimePlayInspectorChrome, { gameId: gameId, api: host.api, onExit: onExit })) : (_jsx(EditorModeChipHost, { api: host.api, mode: "play", chip: resolvedModeChip }))] }));
+                    return (_jsxs(_Fragment, { children: [BaseUI !== undefined ? _jsx(BaseUI, {}) : null, playerCreator ? (_jsx(PlayModeBar, { gameId: gameId, api: host.api, onExit: onExit, exitLabel: "Return to editor" })) : useBuiltinPlayChrome ? (_jsx(RuntimePlayInspectorChrome, { gameId: gameId, api: host.api, onExit: onExit })) : (_jsx(EditorModeChipHost, { api: host.api, mode: "play", chip: resolvedModeChip }))] }));
                 },
                 WorldOverlay: function EditorPlayOverlay({ ctx }) {
                     return (_jsxs(_Fragment, { children: [BaseOverlay !== undefined ? _jsx(BaseOverlay, { ctx: ctx }) : null, _jsx(PerfProbe, { api: host.api }), _jsx(RuntimePlayPublisher, { api: host.api })] }));
@@ -472,8 +486,9 @@ export function EditorApp({ gameId, playable, layers, catalogs, save, modeChip,
                 loop: frozenLoop,
             };
         }
-        const WorldOverlay = function EditorOverlay() {
-            return _jsx(EditorWorldOverlay, { api: host.api, ui: ui, world: playable.game.world, readout: readout });
+        const BaseOverlay = playable.WorldOverlay;
+        const WorldOverlay = function EditorOverlay({ ctx }) {
+            return _jsxs(_Fragment, { children: [BaseOverlay !== undefined ? _jsx(BaseOverlay, { ctx: ctx }) : null, _jsx(EditorWorldOverlay, { api: host.api, ui: ui, world: playable.game.world, readout: readout })] });
         };
         const registerImportedAsset = (id, url) => {
             try {
@@ -484,7 +499,7 @@ export function EditorApp({ gameId, playable, layers, catalogs, save, modeChip,
             }
         };
         const GameUI = function EditorUi() {
-            return (_jsx(EditorChrome, { gameId: gameId, session: host.api.getSession(), api: host.api, assets: catalogAssets, ui: ui, baselineDocument: host.baselineDocument, save: saveFn, networkSnapshot: networkSnapshot, onRegisterAsset: registerImportedAsset, onExitEditor: onExitEditor }));
+            return (_jsx(EditorChrome, { gameId: gameId, session: host.api.getSession(), api: host.api, assets: catalogAssets, ui: ui, baselineDocument: host.baselineDocument, save: saveFn, networkSnapshot: networkSnapshot, onRegisterAsset: registerImportedAsset, onExitEditor: onExitEditor, allowedKinds: allowedKinds, exitLabel: playerCreator ? "Return to saved scenes" : undefined, maxImportBytes: maxImportBytes, draftAutosave: playerCreator !== true, creatorPolicy: creatorPolicy, ...(playerCreator ? { importAsset: async () => { throw new Error("Choose an asset from the approved catalog"); } } : {}) }));
         };
         return {
             ...playable,
@@ -496,10 +511,10 @@ export function EditorApp({ gameId, playable, layers, catalogs, save, modeChip,
             // WorldOverlay above is the editor layers, not PandoraViewmodel.
             camera: inspectionCamera,
         };
-    }, [playable, host, gameId, initialCamera, cameraProjection, catalogAssets, ui, readout, mode, saveFn, resolvedModeChip, networkSnapshot, onExitEditor]);
+    }, [playable, host, gameId, initialCamera, cameraProjection, catalogAssets, ui, readout, mode, saveFn, resolvedModeChip, networkSnapshot, onExitEditor, playtestPlayable, allowedKinds, playerCreator, maxImportBytes, creatorPolicy]);
     const showElevation = useStoreSelector(ui, (s) => s.showElevation);
     const onPanelCommit = useCallback((id, panel) => {
         host.session.dispatch({ type: "setUiPanel", id, patch: panel });
     }, [host]);
-    return (_jsxs("div", { className: "relative h-full w-full bg-neutral-950", "data-jg-editor": "1", "data-jg-editor-game": gameId, children: [_jsx(HudLayoutPersistProvider, { onPanelCommit: onPanelCommit, children: _jsx(GamePlayerShell, { playable: editorPlayable }) }), mode === "edit" && showElevation ? _jsx(TerrainReadoutHud, { readout: readout }) : null, pendingDraft !== null && mode === "edit" ? (_jsxs("div", { className: "absolute left-1/2 top-14 z-[60] flex -translate-x-1/2 items-center gap-3 rounded-xl border border-amber-400/30 bg-amber-950/90 px-4 py-2 text-xs text-amber-100 shadow-2xl shadow-black/50 backdrop-blur-md", children: [_jsx("span", { children: "Unsaved edits from a previous session found." }), _jsx("button", { type: "button", className: "rounded-md bg-gradient-to-b from-amber-500 to-amber-600 px-2.5 py-1 font-semibold text-white shadow-md shadow-amber-950/50 transition-colors hover:from-amber-400 hover:to-amber-500", onClick: restoreDraft, children: "Restore" }), _jsx("button", { type: "button", className: "rounded-md bg-white/[0.07] px-2.5 py-1 ring-1 ring-inset ring-white/[0.06] transition-colors hover:bg-white/15", onClick: discardDraft, children: "Discard" })] })) : null] }));
+    return (_jsxs("div", { className: "relative h-full w-full bg-neutral-950", "data-jg-editor": "1", "data-jg-editor-game": gameId, children: [_jsx(HudLayoutPersistProvider, { onPanelCommit: onPanelCommit, children: _jsx(EditorDocumentSaveContext.Provider, { value: documentSave, children: _jsx(GamePlayerShell, { playable: editorPlayable }, mode) }) }), mode === "edit" && showElevation ? _jsx(TerrainReadoutHud, { readout: readout }) : null, pendingDraft !== null && mode === "edit" ? (_jsxs("div", { className: "absolute left-1/2 top-14 z-[60] flex -translate-x-1/2 items-center gap-3 rounded-xl border border-amber-400/30 bg-amber-950/90 px-4 py-2 text-xs text-amber-100 shadow-2xl shadow-black/50 backdrop-blur-md", children: [_jsx("span", { children: "Unsaved edits from a previous session found." }), _jsx("button", { type: "button", className: "rounded-md bg-gradient-to-b from-amber-500 to-amber-600 px-2.5 py-1 font-semibold text-white shadow-md shadow-amber-950/50 transition-colors hover:from-amber-400 hover:to-amber-500", onClick: restoreDraft, children: "Restore" }), _jsx("button", { type: "button", className: "rounded-md bg-white/[0.07] px-2.5 py-1 ring-1 ring-inset ring-white/[0.06] transition-colors hover:bg-white/15", onClick: discardDraft, children: "Discard" })] })) : null] }));
 }

package/dist/EditorChrome.d.ts

@@ -4,13 +4,15 @@ import type { EditorHostApi } from "./session.js";
 import { type AssetImporter } from "./assetImport.js";
 import { type EditorUiStore } from "./uiStore.js";
 import type { EditorNetworkSnapshot } from "./networkSnapshot.js";
+import { type EditorDocumentSave } from "./useDocumentSave.js";
+import type { CreatorPolicy } from "@jgengine/core/editor/creatorStorage";
 /**
  * The full editor UI shell — global app bar, contextual scene toolbar, workspace rail, resizable
  * hierarchy/inspector docks, tabbed bottom dock (content browser, console, profiler, AI
  * assistant), viewport overlays, and status bar — wired to the session, UI store, layout store,
  * and host RPC. Mounted by `EditorApp`; not a game-author entry point.
  */
-export declare function EditorChrome({ gameId, session, api, assets, ui, baselineDocument, save, networkSnapshot, importAsset, onRegisterAsset, onExitEditor, }: {
+export declare function EditorChrome({ gameId, session, api, assets, ui, baselineDocument, save, networkSnapshot, importAsset, onRegisterAsset, onExitEditor, allowedKinds, exitLabel, maxImportBytes, documentSave, draftAutosave, creatorPolicy, }: {
     gameId: string;
     session: EditorSession;
     api: EditorHostApi;
@@ -25,6 +27,12 @@ export declare function EditorChrome({ gameId, session, api, assets, ui, baselin
     }>;
     /** Closes the editor and returns to the game; set only when summoned over a game. Shows "Exit to game". */
     onExitEditor?: () => void;
+    allowedKinds?: readonly string[];
+    exitLabel?: string;
+    maxImportBytes?: number;
+    documentSave?: EditorDocumentSave;
+    draftAutosave?: boolean;
+    creatorPolicy?: CreatorPolicy;
     /**
      * Network workspace inspection payload (adapter config + optional host presence).
      * Built by `EditorApp` from the game definition; live presence rows only when the host injects them.