@konitif/workbench 0.284.1

package/dist/infrastructure/temporal/InMemoryTemporalDialectRegistry.js

@@ -0,0 +1,38 @@
+export class InMemoryTemporalDialectRegistry {
+    entries = new Map();
+    register(definition) {
+        this.entries.set(definition.id, cloneTemporalDialectDefinition(definition));
+    }
+    getDefinition(dialectId) {
+        const definition = this.entries.get(dialectId);
+        return definition ? cloneTemporalDialectDefinition(definition) : undefined;
+    }
+    list() {
+        return [...this.entries.values()]
+            .map(cloneTemporalDialectDefinition)
+            .sort(compareTemporalDialects);
+    }
+    listCompatible(input) {
+        return this.list().filter((definition) => isCompatibleTemporalDialect(definition, input));
+    }
+}
+function isCompatibleTemporalDialect(definition, input) {
+    const requiredCapabilities = input.requiredCapabilities ?? [];
+    const projectionKinds = definition.projectionKinds ?? [];
+    return ((!input.dialect || definition.id === input.dialect) &&
+        (!input.unit || definition.unit === input.unit) &&
+        (!input.projectionKind || projectionKinds.includes(input.projectionKind)) &&
+        requiredCapabilities.every((capability) => definition.capabilities.includes(capability)));
+}
+function compareTemporalDialects(left, right) {
+    const titleDelta = left.title.localeCompare(right.title);
+    return titleDelta !== 0 ? titleDelta : left.id.localeCompare(right.id);
+}
+function cloneTemporalDialectDefinition(definition) {
+    return {
+        ...definition,
+        itemKinds: [...definition.itemKinds],
+        capabilities: [...definition.capabilities],
+        projectionKinds: definition.projectionKinds ? [...definition.projectionKinds] : undefined
+    };
+}

package/dist/infrastructure/tools/InMemoryToolRegistry.d.ts

@@ -0,0 +1,46 @@
+import type { ToolCatalogPort, ToolDefinition } from "../../domain/tool/model.js";
+export type RegisteredToolComponent = unknown;
+export type RegisteredToolComponentModule = {
+    default: RegisteredToolComponent;
+};
+export type RegisteredToolComponentLoader = () => Promise<RegisteredToolComponent | RegisteredToolComponentModule>;
+export interface RegisteredTool {
+    definition: ToolDefinition;
+    component?: RegisteredToolComponent;
+    loadComponent?: RegisteredToolComponentLoader;
+    configComponent?: RegisteredToolComponent;
+    loadConfigComponent?: RegisteredToolComponentLoader;
+}
+export type ToolRegistryDuplicateResolutionPolicy = 'first-registration-wins';
+export interface ToolRegistryEntryMetadata {
+    id: string;
+    title: string;
+    panelTitle: string;
+    description: string;
+    componentMode: 'component' | 'loader' | 'component-and-loader';
+}
+export interface ToolRegistryDuplicateDiagnostic {
+    kind: 'duplicate-id';
+    registryKind: 'tool';
+    duplicateId: string;
+    existing: ToolRegistryEntryMetadata;
+    incoming: ToolRegistryEntryMetadata;
+    existingRegistrationOrder: number;
+    incomingRegistrationOrder: number;
+    resolutionPolicy: ToolRegistryDuplicateResolutionPolicy;
+}
+export declare class InMemoryToolRegistry implements ToolCatalogPort {
+    private readonly entries;
+    private readonly registrationOrders;
+    private readonly duplicateDiagnostics;
+    private nextRegistrationOrder;
+    private revision;
+    private readonly revisionListeners;
+    /** Observe admitted registrations, not duplicate diagnostics or direct object mutations. */
+    subscribeRevision(listener: (revision: number) => void): () => void;
+    register(entry: RegisteredTool): void;
+    get(toolId: string): RegisteredTool | undefined;
+    getDefinition(toolId: string): ToolDefinition | undefined;
+    list(): RegisteredTool[];
+    listDiagnostics(): ToolRegistryDuplicateDiagnostic[];
+}

package/dist/infrastructure/tools/InMemoryToolRegistry.js

@@ -0,0 +1,82 @@
+export class InMemoryToolRegistry {
+    entries = new Map();
+    registrationOrders = new Map();
+    duplicateDiagnostics = [];
+    nextRegistrationOrder = 0;
+    revision = 0;
+    revisionListeners = new Set();
+    /** Observe admitted registrations, not duplicate diagnostics or direct object mutations. */
+    subscribeRevision(listener) {
+        const subscriber = (revision) => listener(revision);
+        this.revisionListeners.add(subscriber);
+        try {
+            subscriber(this.revision);
+        }
+        catch (error) {
+            this.revisionListeners.delete(subscriber);
+            throw error;
+        }
+        return () => { this.revisionListeners.delete(subscriber); };
+    }
+    register(entry) {
+        if (!entry.component && !entry.loadComponent) {
+            throw new Error(`Tool "${entry.definition.id}" must register a component or component loader.`);
+        }
+        const incomingRegistrationOrder = ++this.nextRegistrationOrder;
+        const existingEntry = this.entries.get(entry.definition.id);
+        if (existingEntry) {
+            this.duplicateDiagnostics.push({
+                kind: 'duplicate-id',
+                registryKind: 'tool',
+                duplicateId: entry.definition.id,
+                existing: createToolRegistryEntryMetadata(existingEntry),
+                incoming: createToolRegistryEntryMetadata(entry),
+                existingRegistrationOrder: this.registrationOrders.get(entry.definition.id) ?? 0,
+                incomingRegistrationOrder,
+                resolutionPolicy: 'first-registration-wins'
+            });
+            return;
+        }
+        this.entries.set(entry.definition.id, entry);
+        this.registrationOrders.set(entry.definition.id, incomingRegistrationOrder);
+        this.revision += 1;
+        for (const listener of [...this.revisionListeners]) {
+            if (this.revisionListeners.has(listener))
+                listener(this.revision);
+        }
+    }
+    get(toolId) {
+        return this.entries.get(toolId);
+    }
+    getDefinition(toolId) {
+        return this.entries.get(toolId)?.definition;
+    }
+    list() {
+        return [...this.entries.values()];
+    }
+    listDiagnostics() {
+        return this.duplicateDiagnostics.map(cloneToolRegistryDuplicateDiagnostic);
+    }
+}
+function createToolRegistryEntryMetadata(entry) {
+    return {
+        id: entry.definition.id,
+        title: entry.definition.title,
+        panelTitle: entry.definition.panelTitle,
+        description: entry.definition.description,
+        componentMode: resolveToolComponentMode(entry)
+    };
+}
+function resolveToolComponentMode(entry) {
+    if (entry.component && entry.loadComponent) {
+        return 'component-and-loader';
+    }
+    return entry.component ? 'component' : 'loader';
+}
+function cloneToolRegistryDuplicateDiagnostic(diagnostic) {
+    return {
+        ...diagnostic,
+        existing: { ...diagnostic.existing },
+        incoming: { ...diagnostic.incoming }
+    };
+}

package/dist/infrastructure/widgets/InMemoryShellWidgetRegistry.d.ts

@@ -0,0 +1,42 @@
+import type { ShellWidgetCatalogPort, ShellWidgetDefinition, ShellRegionId } from "../../domain/shell/model.js";
+export type RegisteredShellWidgetComponent = unknown;
+export type RegisteredShellWidgetComponentModule = {
+    default: RegisteredShellWidgetComponent;
+};
+export type RegisteredShellWidgetComponentLoader = () => Promise<RegisteredShellWidgetComponent | RegisteredShellWidgetComponentModule>;
+export interface RegisteredShellWidget {
+    definition: ShellWidgetDefinition;
+    component?: RegisteredShellWidgetComponent;
+    loadComponent?: RegisteredShellWidgetComponentLoader;
+}
+export type ShellWidgetRegistryDuplicateResolutionPolicy = 'first-registration-wins';
+export interface ShellWidgetRegistryEntryMetadata {
+    id: string;
+    title: string;
+    description: string;
+    defaultRegion: ShellRegionId;
+    scope: ShellWidgetDefinition['scope'];
+    componentMode: 'component' | 'loader' | 'component-and-loader';
+}
+export interface ShellWidgetRegistryDuplicateDiagnostic {
+    kind: 'duplicate-id';
+    registryKind: 'shell-widget';
+    duplicateId: string;
+    existing: ShellWidgetRegistryEntryMetadata;
+    incoming: ShellWidgetRegistryEntryMetadata;
+    existingRegistrationOrder: number;
+    incomingRegistrationOrder: number;
+    resolutionPolicy: ShellWidgetRegistryDuplicateResolutionPolicy;
+}
+export declare class InMemoryShellWidgetRegistry implements ShellWidgetCatalogPort {
+    private readonly entries;
+    private readonly registrationOrders;
+    private readonly duplicateDiagnostics;
+    private nextRegistrationOrder;
+    register(entry: RegisteredShellWidget): void;
+    get(widgetId: string): RegisteredShellWidget | undefined;
+    getDefinition(widgetId: string): ShellWidgetDefinition | undefined;
+    list(): ShellWidgetDefinition[];
+    listByRegion(regionId: ShellRegionId): RegisteredShellWidget[];
+    listDiagnostics(): ShellWidgetRegistryDuplicateDiagnostic[];
+}

package/dist/infrastructure/widgets/InMemoryShellWidgetRegistry.js

@@ -0,0 +1,66 @@
+export class InMemoryShellWidgetRegistry {
+    entries = new Map();
+    registrationOrders = new Map();
+    duplicateDiagnostics = [];
+    nextRegistrationOrder = 0;
+    register(entry) {
+        if (!entry.component && !entry.loadComponent) {
+            throw new Error(`Shell widget "${entry.definition.id}" must register a component or component loader.`);
+        }
+        const incomingRegistrationOrder = ++this.nextRegistrationOrder;
+        const existingEntry = this.entries.get(entry.definition.id);
+        if (existingEntry) {
+            this.duplicateDiagnostics.push({
+                kind: 'duplicate-id',
+                registryKind: 'shell-widget',
+                duplicateId: entry.definition.id,
+                existing: createShellWidgetRegistryEntryMetadata(existingEntry),
+                incoming: createShellWidgetRegistryEntryMetadata(entry),
+                existingRegistrationOrder: this.registrationOrders.get(entry.definition.id) ?? 0,
+                incomingRegistrationOrder,
+                resolutionPolicy: 'first-registration-wins'
+            });
+            return;
+        }
+        this.entries.set(entry.definition.id, entry);
+        this.registrationOrders.set(entry.definition.id, incomingRegistrationOrder);
+    }
+    get(widgetId) {
+        return this.entries.get(widgetId);
+    }
+    getDefinition(widgetId) {
+        return this.entries.get(widgetId)?.definition;
+    }
+    list() {
+        return [...this.entries.values()].map((entry) => entry.definition);
+    }
+    listByRegion(regionId) {
+        return [...this.entries.values()].filter((entry) => entry.definition.defaultRegion === regionId);
+    }
+    listDiagnostics() {
+        return this.duplicateDiagnostics.map(cloneShellWidgetRegistryDuplicateDiagnostic);
+    }
+}
+function createShellWidgetRegistryEntryMetadata(entry) {
+    return {
+        id: entry.definition.id,
+        title: entry.definition.title,
+        description: entry.definition.description,
+        defaultRegion: entry.definition.defaultRegion,
+        scope: entry.definition.scope,
+        componentMode: resolveShellWidgetComponentMode(entry)
+    };
+}
+function resolveShellWidgetComponentMode(entry) {
+    if (entry.component && entry.loadComponent) {
+        return 'component-and-loader';
+    }
+    return entry.component ? 'component' : 'loader';
+}
+function cloneShellWidgetRegistryDuplicateDiagnostic(diagnostic) {
+    return {
+        ...diagnostic,
+        existing: { ...diagnostic.existing },
+        incoming: { ...diagnostic.incoming }
+    };
+}

package/dist/infrastructure/widgets/InMemoryWorkbenchWidgetRegistry.d.ts

@@ -0,0 +1,20 @@
+import type { WorkbenchWidgetCatalogPort, WorkbenchWidgetDefinition } from "../../domain/widget/model.js";
+import type { WorkbenchWidgetZoneSurface } from "../../domain/widget/composition.js";
+export type RegisteredWorkbenchWidgetComponent = unknown;
+export type RegisteredWorkbenchWidgetComponentModule = {
+    default: RegisteredWorkbenchWidgetComponent;
+};
+export type RegisteredWorkbenchWidgetComponentLoader = () => Promise<RegisteredWorkbenchWidgetComponent | RegisteredWorkbenchWidgetComponentModule>;
+export interface RegisteredWorkbenchWidget {
+    definition: WorkbenchWidgetDefinition;
+    component?: RegisteredWorkbenchWidgetComponent;
+    loadComponent?: RegisteredWorkbenchWidgetComponentLoader;
+}
+export declare class InMemoryWorkbenchWidgetRegistry implements WorkbenchWidgetCatalogPort {
+    private readonly entries;
+    register(entry: RegisteredWorkbenchWidget): void;
+    get(widgetId: string): RegisteredWorkbenchWidget | undefined;
+    getDefinition(widgetId: string): WorkbenchWidgetDefinition | undefined;
+    list(): WorkbenchWidgetDefinition[];
+    listBySurface(surface: WorkbenchWidgetZoneSurface): RegisteredWorkbenchWidget[];
+}

package/dist/infrastructure/widgets/InMemoryWorkbenchWidgetRegistry.js

@@ -0,0 +1,35 @@
+export class InMemoryWorkbenchWidgetRegistry {
+    entries = new Map();
+    register(entry) {
+        if (!entry.component && !entry.loadComponent) {
+            throw new Error(`Workbench widget "${entry.definition.id}" must register a component or component loader.`);
+        }
+        this.entries.set(entry.definition.id, {
+            ...entry,
+            definition: cloneWorkbenchWidgetDefinition(entry.definition)
+        });
+    }
+    get(widgetId) {
+        return this.entries.get(widgetId);
+    }
+    getDefinition(widgetId) {
+        const definition = this.entries.get(widgetId)?.definition;
+        return definition ? cloneWorkbenchWidgetDefinition(definition) : undefined;
+    }
+    list() {
+        return [...this.entries.values()].map((entry) => cloneWorkbenchWidgetDefinition(entry.definition));
+    }
+    listBySurface(surface) {
+        return [...this.entries.values()]
+            .filter((entry) => {
+            const supportedSurfaces = entry.definition.supportedSurfaces;
+            return !supportedSurfaces?.length || supportedSurfaces.includes(surface);
+        });
+    }
+}
+function cloneWorkbenchWidgetDefinition(definition) {
+    return {
+        ...definition,
+        supportedSurfaces: definition.supportedSurfaces ? [...definition.supportedSurfaces] : undefined
+    };
+}

package/dist/infrastructure/workbenches/InMemoryWorkbenchRegistry.d.ts

@@ -0,0 +1,7 @@
+import type { WorkbenchCatalog, WorkbenchDefinition } from "../../domain/workbench/model.js";
+export declare class InMemoryWorkbenchRegistry implements WorkbenchCatalog {
+    private readonly entries;
+    register(definition: WorkbenchDefinition): void;
+    getDefinition(workbenchId: string): WorkbenchDefinition | undefined;
+    list(): WorkbenchDefinition[];
+}

package/dist/infrastructure/workbenches/InMemoryWorkbenchRegistry.js

@@ -0,0 +1,28 @@
+export class InMemoryWorkbenchRegistry {
+    entries = new Map();
+    register(definition) {
+        this.entries.set(definition.id, {
+            ...definition,
+            toolIds: [...definition.toolIds],
+            shellWidgetIds: definition.shellWidgetIds ? [...definition.shellWidgetIds] : undefined
+        });
+    }
+    getDefinition(workbenchId) {
+        const entry = this.entries.get(workbenchId);
+        if (!entry) {
+            return undefined;
+        }
+        return {
+            ...entry,
+            toolIds: [...entry.toolIds],
+            shellWidgetIds: entry.shellWidgetIds ? [...entry.shellWidgetIds] : undefined
+        };
+    }
+    list() {
+        return [...this.entries.values()].map((entry) => ({
+            ...entry,
+            toolIds: [...entry.toolIds],
+            shellWidgetIds: entry.shellWidgetIds ? [...entry.shellWidgetIds] : undefined
+        }));
+    }
+}

package/dist/physics-runtime.d.ts

@@ -0,0 +1,4 @@
+/** Headless physics kernel. Backend construction and stepping remain caller-driven. */
+export type * from "./domain/physics/contracts.js";
+export { PhysicsService, type PhysicsServiceOptions } from "./application/physics/PhysicsService.js";
+export { NoopPhysicsBackend } from "./application/physics/NoopPhysicsBackend.js";

package/dist/physics-runtime.js

@@ -0,0 +1,2 @@
+export { PhysicsService } from "./application/physics/PhysicsService.js";
+export { NoopPhysicsBackend } from "./application/physics/NoopPhysicsBackend.js";

package/dist/stage/easing.d.ts

@@ -0,0 +1,5 @@
+import type { StageEasingName } from "./types.js";
+export type StageEasingFunction = (t: number) => number;
+export declare const stageEasing: Record<StageEasingName, StageEasingFunction>;
+export declare function clampStageProgress(value: number): number;
+export declare function easeStageProgress(value: number, easing?: StageEasingName): number;

package/dist/stage/easing.js

@@ -0,0 +1,15 @@
+export const stageEasing = {
+    linear: (t) => t,
+    easeIn: (t) => t * t,
+    easeOut: (t) => 1 - (1 - t) * (1 - t),
+    easeInOut: (t) => (t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2),
+};
+export function clampStageProgress(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.min(1, Math.max(0, value));
+}
+export function easeStageProgress(value, easing = 'linear') {
+    return stageEasing[easing](clampStageProgress(value));
+}

package/dist/stage/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./easing.js";
+export * from "./projection.js";
+export * from "./stageRuntime.js";
+export * from "./timeline.js";
+export * from "./tween.js";
+export * from "./types.js";

package/dist/stage/index.js

@@ -0,0 +1,6 @@
+export * from "./easing.js";
+export * from "./projection.js";
+export * from "./stageRuntime.js";
+export * from "./timeline.js";
+export * from "./tween.js";
+export * from "./types.js";

package/dist/stage/projection.d.ts

@@ -0,0 +1,4 @@
+import type { StageAmbientProjection, StageAmbientState, StageCamera, StageNode, StageProjectedNode, StageProjection, StageState, StageViewport } from "./types.js";
+export declare function projectStageState(state: StageState, viewport: StageViewport): StageProjection;
+export declare function projectStageNode(node: StageNode, camera: StageCamera, viewport: StageViewport): StageProjectedNode;
+export declare function projectStageAmbient(ambient: StageAmbientState | undefined, nodes: readonly StageProjectedNode[], viewport: StageViewport): StageAmbientProjection;

package/dist/stage/projection.js

@@ -0,0 +1,74 @@
+export function projectStageState(state, viewport) {
+    const projectedNodes = Object.values(state.nodes)
+        .map((node) => projectStageNode(node, state.camera, viewport))
+        .sort((a, b) => a.zIndex - b.zIndex || a.depth - b.depth);
+    return {
+        viewport: { ...viewport },
+        camera: {
+            position: { ...state.camera.position },
+            rotation: { ...state.camera.rotation },
+            perspective: state.camera.perspective,
+        },
+        nodes: projectedNodes,
+        ambient: projectStageAmbient(state.ambient, projectedNodes, viewport),
+    };
+}
+export function projectStageNode(node, camera, viewport) {
+    const relativeX = node.position.x - camera.position.x;
+    const relativeY = node.position.y - camera.position.y;
+    const relativeZ = node.position.z - camera.position.z;
+    const depth = Math.max(1, camera.perspective + relativeZ);
+    const perspectiveScale = camera.perspective / depth;
+    const scale = ((node.scale.x + node.scale.y) / 2) * perspectiveScale;
+    const x = viewport.width / 2 + relativeX * perspectiveScale;
+    const y = viewport.height / 2 + relativeY * perspectiveScale;
+    const zIndex = node.zIndex ?? Math.round(10000 - depth);
+    return {
+        id: node.id,
+        kind: node.kind,
+        visible: node.visible,
+        opacity: node.opacity,
+        x,
+        y,
+        depth,
+        scale,
+        zIndex,
+        transform: createStageNodeTransform(x, y, node.rotation.z - camera.rotation.z, scale),
+        metadata: node.metadata ? { ...node.metadata } : undefined,
+    };
+}
+export function projectStageAmbient(ambient, nodes, viewport) {
+    const focusNode = ambient?.focusNodeId
+        ? nodes.find((node) => node.id === ambient.focusNodeId && node.visible)
+        : nodes.find((node) => node.visible);
+    const focusPoint = focusNode
+        ? { x: focusNode.x / Math.max(1, viewport.width), y: focusNode.y / Math.max(1, viewport.height) }
+        : { x: 0.5, y: 0.5 };
+    const focusDepth = focusNode ? normalizeStageDepth(focusNode.depth) : 0.5;
+    return {
+        focusPoint,
+        focusDepth,
+        depthIntensity: clampAmbientValue(ambient?.depthIntensity ?? 0.5),
+        fogIntensity: clampAmbientValue(ambient?.fogIntensity ?? 0.32),
+        lightIntensity: clampAmbientValue(ambient?.lightIntensity ?? 0.55),
+        motionIntensity: clampAmbientValue(ambient?.motionIntensity ?? 0.22),
+        parallaxIntensity: clampAmbientValue(ambient?.parallaxIntensity ?? 0.35),
+        tint: ambient?.tint,
+        metadata: ambient?.metadata ? { ...ambient.metadata } : undefined,
+    };
+}
+function createStageNodeTransform(x, y, rotationZ, scale) {
+    return `translate3d(${roundStageNumber(x)}px, ${roundStageNumber(y)}px, 0) rotate(${roundStageNumber(rotationZ)}deg) scale(${roundStageNumber(scale)})`;
+}
+function normalizeStageDepth(depth) {
+    return clampAmbientValue(depth / 1800);
+}
+function clampAmbientValue(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.min(1, Math.max(0, value));
+}
+function roundStageNumber(value) {
+    return Math.round(value * 1000) / 1000;
+}

package/dist/stage/stageRuntime.d.ts

@@ -0,0 +1,2 @@
+import type { StageRuntime, StageState } from "./types.js";
+export declare function createStageRuntime(initialState: StageState): StageRuntime;

package/dist/stage/stageRuntime.js

@@ -0,0 +1,32 @@
+import { applyStageTimeline, cloneStageState } from "./timeline.js";
+export function createStageRuntime(initialState) {
+    let state = cloneStageState(initialState);
+    const listeners = new Set();
+    function notify() {
+        const snapshot = cloneStageState(state);
+        for (const listener of listeners) {
+            listener(cloneStageState(snapshot));
+        }
+    }
+    return {
+        getState() {
+            return cloneStageState(state);
+        },
+        setState(nextState) {
+            state = cloneStageState(nextState);
+            notify();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            listener(cloneStageState(state));
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        applyTimeline(timeline, timeMs) {
+            state = applyStageTimeline(state, timeline, timeMs);
+            notify();
+            return cloneStageState(state);
+        },
+    };
+}

package/dist/stage/timeline.d.ts

@@ -0,0 +1,3 @@
+import type { StageState, StageTimeline } from "./types.js";
+export declare function applyStageTimeline(state: StageState, timeline: StageTimeline, timeMs: number): StageState;
+export declare function cloneStageState(state: StageState): StageState;

package/dist/stage/timeline.js

@@ -0,0 +1,69 @@
+import { resolveStageTrackValue, setStageTweenValue } from "./tween.js";
+export function applyStageTimeline(state, timeline, timeMs) {
+    const nextState = cloneStageState(state);
+    const clampedTime = Math.min(Math.max(0, timeMs), Math.max(0, timeline.duration));
+    for (const track of timeline.tracks) {
+        const value = resolveStageTrackValue(track, clampedTime);
+        if (value !== undefined) {
+            setStageTweenValue(nextState, track.targetId, track.property, value);
+        }
+    }
+    return nextState;
+}
+export function cloneStageState(state) {
+    return {
+        camera: {
+            position: { ...state.camera.position },
+            rotation: { ...state.camera.rotation },
+            perspective: state.camera.perspective,
+        },
+        ambient: state.ambient
+            ? {
+                ...state.ambient,
+                metadata: state.ambient.metadata ? cloneStageMetadata(state.ambient.metadata) : undefined,
+            }
+            : undefined,
+        nodes: Object.fromEntries(Object.entries(state.nodes).map(([id, node]) => [
+            id,
+            {
+                ...node,
+                position: { ...node.position },
+                rotation: { ...node.rotation },
+                scale: { ...node.scale },
+                metadata: node.metadata ? cloneStageMetadata(node.metadata) : undefined,
+            },
+        ])),
+    };
+}
+/** Stage metadata is data, not a container for runtime resources or callbacks. */
+function cloneStageMetadata(value) {
+    const ancestors = new Set();
+    function copy(input) {
+        if (input === null || input === undefined || typeof input === 'string' || typeof input === 'boolean')
+            return input;
+        if (typeof input === 'number' && Number.isFinite(input))
+            return input;
+        if (typeof input !== 'object' || input === null)
+            throw new TypeError('Unsupported Stage metadata value');
+        const array = Array.isArray(input);
+        if (!array && Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null) {
+            throw new TypeError('Stage metadata must contain plain data');
+        }
+        if (ancestors.has(input))
+            throw new TypeError('Cyclic Stage metadata');
+        ancestors.add(input);
+        const result = array ? new Array(input.length) : {};
+        for (const key of Reflect.ownKeys(input)) {
+            if (array && key === 'length')
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(input, key);
+            if (typeof key !== 'string' || !('value' in descriptor))
+                throw new TypeError('Stage metadata cannot contain symbols or accessors');
+            Object.defineProperty(result, key, { value: copy(descriptor.value), enumerable: descriptor.enumerable,
+                configurable: true, writable: true });
+        }
+        ancestors.delete(input);
+        return result;
+    }
+    return copy(value);
+}

package/dist/stage/tween.d.ts

@@ -0,0 +1,3 @@
+import type { StageState, StageTimelineTrack, StageTweenProperty } from "./types.js";
+export declare function resolveStageTrackValue(track: StageTimelineTrack, timeMs: number): number | boolean | undefined;
+export declare function setStageTweenValue(state: StageState, targetId: string, property: StageTweenProperty, value: number | boolean): void;