@series-inc/rundot-syncplay 5.23.0-beta.7

package/dist/engine-runtime.js

@@ -0,0 +1,3123 @@
+import { canonicalStringify, cloneCanonical, defaultChecksum } from './canonical.js';
+import { DeterministicRandom } from './random.js';
+import { parseDeterministicSchemaDsl, } from './schema-dsl-binary.js';
+import { createDeterministicSparseSet } from './sparse-set.js';
+import { withRuntimeDeterminismGuards } from './runtime-guards.js';
+export function createDeterministicFrameRuntime(descriptor, seed = 1, options = {}) {
+    validateRuntimeDescriptor(descriptor);
+    const orderedSystemDescriptors = orderSystemDescriptors(descriptor.systems);
+    const componentDescriptors = new Map(descriptor.components.map((component) => [component.id, component]));
+    const eventDescriptors = new Map((descriptor.eventChannels ?? []).map((event) => [event.id, event]));
+    const signalDescriptors = new Map((descriptor.signalChannels ?? []).map((signal) => [signal.id, signal]));
+    const assetRefs = createRuntimeAssetRefValidator(options);
+    const state = {
+        frame: 0,
+        nextEntityId: 1,
+        freeEntityIds: [],
+        generations: new Map(),
+        components: new Map(descriptor.components.filter((component) => component.singleton !== true).map((component) => [component.id, new Map()])),
+        singletonComponents: new Map(),
+        frameHeap: createFrameHeap(),
+        debugEvents: [],
+        runtimeEvents: [],
+        runtimeSignals: [],
+        dispatchedSignals: [],
+        nextRuntimeMessageSequence: 0,
+        commandTimeline: options.commandTimeline,
+        random: new DeterministicRandom(seed),
+    };
+    return {
+        descriptor,
+        get frame() {
+            return state.frame;
+        },
+        get debugEvents() {
+            return state.debugEvents.map((event) => cloneCanonical(event));
+        },
+        createEntity() {
+            return createEntity(state);
+        },
+        destroyEntity(entity) {
+            destroyEntity(state, entity);
+        },
+        setComponent(entity, componentId, data) {
+            setComponent(state, componentDescriptors, assetRefs, entity, componentId, data);
+        },
+        removeComponent(entity, componentId) {
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            removeComponent(state, entity, componentId);
+        },
+        setSingleton(componentId, data) {
+            setSingleton(state, componentDescriptors, assetRefs, componentId, data);
+        },
+        query(componentIds) {
+            assertKnownFrameComponents(componentDescriptors, componentIds);
+            return queryComponents(state, componentIds);
+        },
+        queryFilter(filter) {
+            assertKnownFrameComponents(componentDescriptors, queryFilterComponentIds(filter));
+            return queryComponentFilter(state, filter);
+        },
+        componentCount(componentId) {
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            /* istanbul ignore next -- component storage exists for every validated frame component. */
+            return state.components.get(componentId)?.size ?? 0;
+        },
+        step(systems) {
+            for (const systemDescriptor of orderedSystemDescriptors) {
+                const system = systems[systemDescriptor.id];
+                if (system === undefined) {
+                    throw new Error(`Missing deterministic system ${systemDescriptor.id}`);
+                }
+                if (options.statelessSystemSourceGuards === true) {
+                    assertDeterministicFrameSystemStateless(systemDescriptor.id, system);
+                }
+                state.commandTimeline?.setCurrentFrame(state.frame);
+                withRuntimeDeterminismGuards(state.frame, () => {
+                    system(createSystemContext(state, componentDescriptors, eventDescriptors, signalDescriptors, assetRefs, systemDescriptor.group === 'presentation' ? systemDescriptor.id : undefined));
+                });
+            }
+            state.frame += 1;
+        },
+        snapshot() {
+            return snapshotState(state);
+        },
+        restore(snapshot) {
+            restoreState(state, componentDescriptors, assetRefs, snapshot);
+        },
+    };
+}
+export function createDeterministicSparseSetFrameRuntime(descriptor, seed = 1, capacity = 65_536, options = {}) {
+    validateRuntimeDescriptor(descriptor);
+    const orderedSystemDescriptors = orderSystemDescriptors(descriptor.systems);
+    const componentDescriptors = new Map(descriptor.components.map((component) => [component.id, component]));
+    const eventDescriptors = new Map((descriptor.eventChannels ?? []).map((event) => [event.id, event]));
+    const signalDescriptors = new Map((descriptor.signalChannels ?? []).map((signal) => [signal.id, signal]));
+    const assetRefs = createRuntimeAssetRefValidator(options);
+    const state = {
+        frame: 0,
+        nextEntityId: 1,
+        freeEntityIds: [],
+        generations: new Map(),
+        componentStores: createSparseComponentStores(descriptor, capacity),
+        singletonComponents: new Map(),
+        frameHeap: createFrameHeap(),
+        debugEvents: [],
+        runtimeEvents: [],
+        runtimeSignals: [],
+        dispatchedSignals: [],
+        nextRuntimeMessageSequence: 0,
+        commandTimeline: options.commandTimeline,
+        random: new DeterministicRandom(seed),
+    };
+    return {
+        descriptor,
+        get frame() {
+            return state.frame;
+        },
+        get debugEvents() {
+            return state.debugEvents.map((event) => cloneCanonical(event));
+        },
+        createEntity() {
+            return createSparseEntity(state);
+        },
+        destroyEntity(entity) {
+            destroySparseEntity(state, entity);
+        },
+        setComponent(entity, componentId, data) {
+            setSparseComponent(state, componentDescriptors, assetRefs, entity, componentId, data);
+        },
+        removeComponent(entity, componentId) {
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            removeSparseComponent(state, entity, componentId);
+        },
+        setSingleton(componentId, data) {
+            setSparseSingleton(state, componentDescriptors, assetRefs, componentId, data);
+        },
+        query(componentIds) {
+            assertKnownFrameComponents(componentDescriptors, componentIds);
+            return querySparseComponents(state, componentIds);
+        },
+        queryFilter(filter) {
+            assertKnownFrameComponents(componentDescriptors, queryFilterComponentIds(filter));
+            return querySparseComponentFilter(state, filter);
+        },
+        componentCount(componentId) {
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            /* istanbul ignore next -- sparse storage exists for every validated frame component. */
+            return state.componentStores.get(componentId)?.query().length ?? 0;
+        },
+        step(systems) {
+            for (const systemDescriptor of orderedSystemDescriptors) {
+                const system = systems[systemDescriptor.id];
+                if (system === undefined) {
+                    throw new Error(`Missing deterministic system ${systemDescriptor.id}`);
+                }
+                if (options.statelessSystemSourceGuards === true) {
+                    assertDeterministicFrameSystemStateless(systemDescriptor.id, system);
+                }
+                state.commandTimeline?.setCurrentFrame(state.frame);
+                withRuntimeDeterminismGuards(state.frame, () => {
+                    system(createSparseSystemContext(state, componentDescriptors, eventDescriptors, signalDescriptors, assetRefs, systemDescriptor.group === 'presentation' ? systemDescriptor.id : undefined));
+                });
+            }
+            state.frame += 1;
+        },
+        snapshot() {
+            return snapshotSparseState(state);
+        },
+        restore(snapshot) {
+            restoreSparseState(state, componentDescriptors, assetRefs, descriptor, capacity, snapshot);
+        },
+    };
+}
+export function createDeterministicFrameRuntimeAccessors(descriptor) {
+    validateRuntimeDescriptor(descriptor);
+    const components = Object.fromEntries(descriptor.components
+        .filter((component) => component.singleton !== true)
+        .map((component) => [component.id, createComponentAccessor(component)]));
+    const singletons = Object.fromEntries(descriptor.components
+        .filter((component) => component.singleton === true)
+        .map((component) => [component.id, createSingletonAccessor(component)]));
+    const commands = Object.fromEntries((descriptor.commandChannels ?? [])
+        .map((channel) => [channel.id, createCommandAccessor(channel)]));
+    const events = Object.fromEntries((descriptor.eventChannels ?? [])
+        .map((event) => [event.id, createEventAccessor(event)]));
+    const signals = Object.fromEntries((descriptor.signalChannels ?? [])
+        .map((signal) => [signal.id, createSignalAccessor(signal)]));
+    const source = generateDeterministicFrameRuntimeSource(descriptor);
+    return {
+        descriptorHash: defaultChecksum(descriptor),
+        components,
+        singletons,
+        commands,
+        events,
+        signals,
+        source,
+        sourceHash: defaultChecksum(source),
+    };
+}
+export function generateDeterministicFrameRuntimeSource(descriptor) {
+    validateRuntimeDescriptor(descriptor);
+    const lines = [
+        'export type DeterministicGeneratedValue = string | number | boolean | null | readonly DeterministicGeneratedValue[] | { readonly [key: string]: DeterministicGeneratedValue };',
+        'export type DeterministicGeneratedComponentData = Readonly<Record<string, DeterministicGeneratedValue>>;',
+        'export interface DeterministicGeneratedEntityRef { readonly id: number; readonly generation: number; }',
+        'export interface DeterministicGeneratedFrameHeapHandle { readonly id: number; readonly generation: number; readonly kind: "list" | "dictionary" | "hash-set"; }',
+        'export interface DeterministicGeneratedQueryRow { readonly entity: DeterministicGeneratedEntityRef; readonly components: Readonly<Record<string, DeterministicGeneratedComponentData>>; }',
+        'export interface DeterministicGeneratedFrameQueryFilter { readonly all?: readonly string[]; readonly any?: readonly string[]; readonly without?: readonly string[]; }',
+        'export interface DeterministicGeneratedPlayerCommand { readonly id: string; readonly slot: number; readonly frame: number; readonly channelId: string; readonly payload: DeterministicGeneratedValue; readonly predicted?: boolean; readonly submittedFrame?: number; }',
+        'export interface DeterministicGeneratedRejectedCommand { readonly commandId: string; readonly reason: string; }',
+        'export interface DeterministicGeneratedRuntimeMessage { readonly frame: number; readonly type: string; readonly sequence: number; readonly payload: DeterministicGeneratedComponentData; }',
+        'export interface DeterministicGeneratedSignalHandler<TState> { readonly id: string; readonly type: string; readonly order: number; handle(state: Readonly<TState>, signal: DeterministicGeneratedRuntimeMessage): TState; }',
+        'export interface DeterministicGeneratedFrameHeapCollectionSnapshot { readonly kind: "list" | "dictionary" | "hash-set"; readonly generation: number; readonly values?: readonly DeterministicGeneratedValue[]; readonly entries?: readonly { readonly key: string; readonly value: DeterministicGeneratedValue }[]; }',
+        'export interface DeterministicGeneratedFrameHeapSnapshot { readonly nextHandleId: number; readonly freeHandleIds: readonly number[]; readonly generations: Readonly<Record<string, number>>; readonly collections: Readonly<Record<string, DeterministicGeneratedFrameHeapCollectionSnapshot>>; }',
+        'export interface DeterministicGeneratedFrameSnapshot { readonly frame: number; readonly nextEntityId: number; readonly freeEntityIds: readonly number[]; readonly generations: Readonly<Record<string, number>>; readonly components: Readonly<Record<string, Readonly<Record<string, DeterministicGeneratedComponentData>>>>; readonly singletonComponents: Readonly<Record<string, DeterministicGeneratedComponentData>>; readonly frameHeap: DeterministicGeneratedFrameHeapSnapshot; readonly debugEvents: readonly DeterministicGeneratedRuntimeMessage[]; readonly runtimeEvents: readonly DeterministicGeneratedRuntimeMessage[]; readonly runtimeSignals: readonly DeterministicGeneratedRuntimeMessage[]; readonly dispatchedSignals: readonly DeterministicGeneratedRuntimeMessage[]; readonly nextRuntimeMessageSequence: number; readonly randomState: number; readonly bytes?: string; readonly checksum?: string; readonly commandTimeline?: DeterministicGeneratedValue; }',
+        'export interface DeterministicGeneratedFrameDumpRow { readonly path: string; readonly value: DeterministicGeneratedValue; }',
+        'function deterministicGeneratedCanonicalize(value: unknown): DeterministicGeneratedValue { if (value === null || typeof value === "string" || typeof value === "boolean") return value; if (typeof value === "number") { if (!Number.isFinite(value)) throw new Error("Generated frame snapshot contains non-finite number"); return value; } if (Array.isArray(value)) return value.map(deterministicGeneratedCanonicalize); if (typeof value === "object" && value !== null) { return Object.fromEntries(Object.keys(value as Record<string, unknown>).sort().filter((key) => (value as Record<string, unknown>)[key] !== undefined).map((key) => [key, deterministicGeneratedCanonicalize((value as Record<string, unknown>)[key])])); } throw new Error(`Generated frame snapshot contains unsupported value ${typeof value}`); }',
+        'function deterministicGeneratedStableStringify(value: unknown): string { return JSON.stringify(deterministicGeneratedCanonicalize(value)); }',
+        'function deterministicGeneratedChecksum(source: string): string { let hash = 0xcbf29ce484222325n; const prime = 0x100000001b3n; for (let index = 0; index < source.length; index += 1) { hash ^= BigInt(source.charCodeAt(index)); hash = BigInt.asUintN(64, hash * prime); } return hash.toString(16).padStart(16, "0"); }',
+        'function deterministicGeneratedFrameSnapshotPayload(snapshot: DeterministicGeneratedFrameSnapshot): Omit<DeterministicGeneratedFrameSnapshot, "bytes" | "checksum"> { const { bytes: _bytes, checksum: _checksum, ...payload } = snapshot; return payload; }',
+        'export function serializeDeterministicFrameSnapshot(snapshot: DeterministicGeneratedFrameSnapshot): string { return deterministicGeneratedStableStringify(snapshot); }',
+        'export function deserializeDeterministicFrameSnapshot(source: string): DeterministicGeneratedFrameSnapshot { const parsed = JSON.parse(source) as DeterministicGeneratedFrameSnapshot; if (!Number.isInteger(parsed.frame) || !Number.isInteger(parsed.nextEntityId) || parsed.components === undefined || parsed.singletonComponents === undefined || parsed.frameHeap === undefined) { throw new Error("Invalid deterministic frame snapshot"); } return parsed; }',
+        'export function checksumDeterministicFrameSnapshot(snapshot: DeterministicGeneratedFrameSnapshot): string { const bytes = deterministicGeneratedStableStringify(deterministicGeneratedFrameSnapshotPayload(snapshot)); return deterministicGeneratedChecksum(deterministicGeneratedStableStringify(bytes)); }',
+        'export function dumpDeterministicFrameSnapshot(snapshot: DeterministicGeneratedFrameSnapshot): readonly DeterministicGeneratedFrameDumpRow[] { const rows: DeterministicGeneratedFrameDumpRow[] = []; const visit = (path: string, value: unknown): void => { const canonical = deterministicGeneratedCanonicalize(value); if (canonical === null || typeof canonical !== "object" || Array.isArray(canonical)) { rows.push({ path, value: canonical }); return; } for (const key of Object.keys(canonical).sort()) visit(path.length === 0 ? key : `${path}.${key}`, (canonical as Record<string, DeterministicGeneratedValue>)[key]); }; visit("", snapshot); return rows.sort((left, right) => left.path.localeCompare(right.path)); }',
+        `export const deterministicRuntimeDescriptor = ${JSON.stringify(descriptor, null, 2)} as const;`,
+        `export const deterministicRuntimeDescriptorHash = ${JSON.stringify(defaultChecksum(descriptor))} as const;`,
+    ];
+    for (const component of descriptor.components) {
+        const name = toIdentifier(component.id);
+        const typeName = `${name}Data`;
+        lines.push(`export interface ${typeName} {`);
+        for (const field of component.fields) {
+            lines.push(`  readonly ${propertyName(field.name)}: ${runtimeFieldToTs(field.kind)};`);
+        }
+        lines.push('}');
+        if (component.singleton === true) {
+            lines.push(`export function get${name}(ctx: { getSingleton(id: string): ${typeName} | undefined }): ${typeName} | undefined { return ctx.getSingleton(${JSON.stringify(component.id)}); }`, `export function get${name}OrDefault(ctx: { getSingleton(id: string): ${typeName} | undefined }): ${typeName} { return ctx.getSingleton(${JSON.stringify(component.id)}) ?? ${literalForComponentDefaults(component)}; }`, `export function set${name}(ctx: { setSingleton(id: string, data: ${typeName}): void }, data: ${typeName}): void { ctx.setSingleton(${JSON.stringify(component.id)}, data); }`, `export function patch${name}(ctx: { getSingleton(id: string): ${typeName} | undefined; setSingleton(id: string, data: ${typeName}): void }, data: Partial<${typeName}>): void { ctx.setSingleton(${JSON.stringify(component.id)}, { ...get${name}OrDefault(ctx), ...data }); }`);
+        }
+        else {
+            lines.push(`export function has${name}(ctx: { hasComponent(entity: DeterministicGeneratedEntityRef, id: string): boolean }, entity: DeterministicGeneratedEntityRef): boolean { return ctx.hasComponent(entity, ${JSON.stringify(component.id)}); }`, `export function get${name}(ctx: { getComponent(entity: DeterministicGeneratedEntityRef, id: string): ${typeName} | undefined }, entity: DeterministicGeneratedEntityRef): ${typeName} | undefined { return ctx.getComponent(entity, ${JSON.stringify(component.id)}); }`, `export function get${name}OrDefault(ctx: { getComponent(entity: DeterministicGeneratedEntityRef, id: string): ${typeName} | undefined }, entity: DeterministicGeneratedEntityRef): ${typeName} { return ctx.getComponent(entity, ${JSON.stringify(component.id)}) ?? ${literalForComponentDefaults(component)}; }`, `export function set${name}(ctx: { setComponent(entity: DeterministicGeneratedEntityRef, id: string, data: ${typeName}): void }, entity: DeterministicGeneratedEntityRef, data: ${typeName}): void { ctx.setComponent(entity, ${JSON.stringify(component.id)}, data); }`, `export function patch${name}(ctx: { getComponent(entity: DeterministicGeneratedEntityRef, id: string): ${typeName} | undefined; setComponent(entity: DeterministicGeneratedEntityRef, id: string, data: ${typeName}): void }, entity: DeterministicGeneratedEntityRef, data: Partial<${typeName}>): void { ctx.setComponent(entity, ${JSON.stringify(component.id)}, { ...get${name}OrDefault(ctx, entity), ...data }); }`, `export function remove${name}(ctx: { removeComponent(entity: DeterministicGeneratedEntityRef, id: string): void }, entity: DeterministicGeneratedEntityRef): void { ctx.removeComponent(entity, ${JSON.stringify(component.id)}); }`, `export function query${name}(ctx: { query(ids: readonly string[]): readonly DeterministicGeneratedQueryRow[] }, extraIds: readonly string[] = []): readonly DeterministicGeneratedQueryRow[] { return ctx.query([${JSON.stringify(component.id)}, ...extraIds]); }`, `export function query${name}Filter(ctx: { queryFilter(filter: DeterministicGeneratedFrameQueryFilter): readonly DeterministicGeneratedQueryRow[] }, filter: DeterministicGeneratedFrameQueryFilter = {}): readonly DeterministicGeneratedQueryRow[] { return ctx.queryFilter({ ...filter, all: [${JSON.stringify(component.id)}, ...(filter.all ?? [])] }); }`, `export function count${name}(ctx: { componentCount(id: string): number }): number { return ctx.componentCount(${JSON.stringify(component.id)}); }`);
+        }
+    }
+    for (const channel of descriptor.commandChannels ?? []) {
+        const name = toIdentifier(channel.id);
+        const channelId = JSON.stringify(channel.id);
+        lines.push(`export function record${name}Command(ctx: { recordPlayerCommand(command: DeterministicGeneratedPlayerCommand): DeterministicGeneratedRejectedCommand | undefined }, command: DeterministicGeneratedPlayerCommand): DeterministicGeneratedRejectedCommand | undefined { return ctx.recordPlayerCommand(command); }`, `export function record${name}CommandFromSlot(ctx: { recordPlayerCommandFromSlot(senderSlot: number, command: DeterministicGeneratedPlayerCommand): DeterministicGeneratedRejectedCommand | undefined }, senderSlot: number, command: DeterministicGeneratedPlayerCommand): DeterministicGeneratedRejectedCommand | undefined { return ctx.recordPlayerCommandFromSlot(senderSlot, command); }`, `export function poll${name}Commands(ctx: { frame: number; pollPlayerCommands(frame?: number, slot?: number, channelId?: string): readonly DeterministicGeneratedPlayerCommand[] }, frame: number = ctx.frame, slot?: number): readonly DeterministicGeneratedPlayerCommand[] { return ctx.pollPlayerCommands(frame, slot, ${channelId}); }`);
+    }
+    for (const event of descriptor.eventChannels ?? []) {
+        const name = toIdentifier(event.id);
+        const typeName = `${name}EventPayload`;
+        lines.push(`export interface ${typeName} {`);
+        for (const field of event.fields) {
+            lines.push(`  readonly ${propertyName(field.name)}: ${runtimeFieldToTs(field.kind)};`);
+        }
+        lines.push('}');
+        lines.push(`export function emit${name}Event(ctx: { emitEvent(type: string, payload: ${typeName}): void }, payload: ${typeName}): void { ctx.emitEvent(${JSON.stringify(event.id)}, payload); }`, `export function poll${name}Events(ctx: { frame: number; pollEvents(frame?: number, type?: string): readonly DeterministicGeneratedRuntimeMessage[] }, frame: number = ctx.frame): readonly DeterministicGeneratedRuntimeMessage[] { return ctx.pollEvents(frame, ${JSON.stringify(event.id)}); }`);
+    }
+    for (const signal of descriptor.signalChannels ?? []) {
+        const name = toIdentifier(signal.id);
+        const typeName = `${name}SignalPayload`;
+        lines.push(`export interface ${typeName} {`);
+        for (const field of signal.fields) {
+            lines.push(`  readonly ${propertyName(field.name)}: ${runtimeFieldToTs(field.kind)};`);
+        }
+        lines.push('}');
+        lines.push(`export function emit${name}Signal(ctx: { emitSignal(type: string, payload: ${typeName}): void }, payload: ${typeName}): void { ctx.emitSignal(${JSON.stringify(signal.id)}, payload); }`, `export function poll${name}Signals(ctx: { frame: number; pollSignals(frame?: number, type?: string): readonly DeterministicGeneratedRuntimeMessage[] }, frame: number = ctx.frame): readonly DeterministicGeneratedRuntimeMessage[] { return ctx.pollSignals(frame, ${JSON.stringify(signal.id)}); }`, `export function dispatch${name}Signals<TState>(ctx: { frame: number; dispatchSignals(state: Readonly<TState>, handlers: readonly DeterministicGeneratedSignalHandler<TState>[], frame?: number, type?: string): TState }, state: Readonly<TState>, handlers: readonly DeterministicGeneratedSignalHandler<TState>[], frame: number = ctx.frame): TState { return ctx.dispatchSignals(state, handlers, frame, ${JSON.stringify(signal.id)}); }`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function compileDeterministicDslRuntimeDescriptor(schema, options = {}) {
+    const components = schema.declarations
+        .filter((declaration) => declaration.kind === 'component' || declaration.kind === 'singleton' || declaration.kind === 'global')
+        .map((declaration) => ({
+        id: declaration.name,
+        singleton: declaration.kind === 'singleton' || declaration.kind === 'global' ? true : undefined,
+        fields: declaration.fields.map((field) => ({
+            name: field.name,
+            kind: dslFieldKindToRuntimeKind(field.kind),
+            defaultValue: defaultRuntimeValueForKind(field.kind),
+            assetType: dslAssetTypeForFieldKind(field.kind),
+        })),
+    }));
+    const commandChannels = schema.declarations
+        .filter((declaration) => declaration.kind === 'command')
+        .map((declaration) => ({
+        id: declaration.name,
+        reliable: true,
+        allowPrediction: true,
+        maxPayloadBytes: Math.max(64, declaration.fields.length * 64),
+        maxFrameLead: 32,
+    }));
+    const eventChannels = schema.declarations
+        .filter((declaration) => declaration.kind === 'event')
+        .map((declaration) => ({
+        id: declaration.name,
+        fields: declaration.fields.map((field) => ({
+            name: field.name,
+            kind: dslFieldKindToRuntimeKind(field.kind),
+            defaultValue: defaultRuntimeValueForKind(field.kind),
+            assetType: dslAssetTypeForFieldKind(field.kind),
+        })),
+    }));
+    const signalChannels = schema.declarations
+        .filter((declaration) => declaration.kind === 'signal')
+        .map((declaration) => ({
+        id: declaration.name,
+        fields: declaration.fields.map((field) => ({
+            name: field.name,
+            kind: dslFieldKindToRuntimeKind(field.kind),
+            defaultValue: defaultRuntimeValueForKind(field.kind),
+            assetType: dslAssetTypeForFieldKind(field.kind),
+        })),
+    }));
+    if (components.length === 0) {
+        throw new Error('DSL runtime descriptor requires component or singleton declarations');
+    }
+    return {
+        id: options.id ?? `${schema.schemaHash}/runtime`,
+        tickRate: options.tickRate ?? 60,
+        components,
+        systems: options.systems ?? [{ id: 'simulate', group: 'simulation', order: 0 }],
+        commandChannels,
+        eventChannels,
+        signalChannels,
+    };
+}
+export function runDeterministicDslRuntimeFixture(iterations = 256, seed = 71) {
+    const source = `
+component Inventory { active: bool; owner: entity-ref; targets: entity-ref[2]; weapon: asset_ref<Weapon>; tags: asset_ref<Tag>[]; }
+component Position { x: fixed; y: fixed; }
+singleton MatchState { tick: int; overtime: bool; owners: entity-ref[]; mode: string; }
+	global RuntimeFlags { enabledModes: set<string>; spawnWeights: dictionary<string,int>; spawnQueue: list<asset_ref<Prototype>>; }
+	input Move { dx: int; jump: button; }
+	command Spawn { prototype: asset_ref<Prototype>; target: entity-ref; }
+	event DamageEvent { source: entity-ref; target: entity-ref; amount: int; }
+	signal ScoreSignal { slot: int; points: int; }
+	`;
+    const permutedSource = `
+	signal ScoreSignal { points: int; slot: int; }
+	event DamageEvent { amount: int; target: entity-ref; source: entity-ref; }
+	command Spawn { target: entity-ref; prototype: asset_ref<Prototype>; }
+	input Move { jump: button; dx: int; }
+	global RuntimeFlags { spawnQueue: list<asset_ref<Prototype>>; spawnWeights: dictionary<string,int>; enabledModes: set<string>; }
+singleton MatchState { mode: string; owners: entity-ref[]; overtime: bool; tick: int; }
+component Position { y: fixed; x: fixed; }
+component Inventory { tags: asset_ref<Tag>[]; weapon: asset_ref<Weapon>; targets: entity-ref[2]; owner: entity-ref; active: bool; }
+`;
+    const schema = parseDeterministicSchemaDsl(source);
+    const permutedSchema = parseDeterministicSchemaDsl(permutedSource);
+    const descriptor = compileDeterministicDslRuntimeDescriptor(schema, {
+        id: 'dsl-runtime-fixture',
+        tickRate: 60,
+        systems: [{ id: 'simulate', group: 'simulation', order: 0 }],
+    });
+    const permutedDescriptor = compileDeterministicDslRuntimeDescriptor(permutedSchema, {
+        id: 'dsl-runtime-fixture',
+        tickRate: 60,
+        systems: [{ id: 'simulate', group: 'simulation', order: 0 }],
+    });
+    const accessors = createDeterministicFrameRuntimeAccessors(descriptor);
+    const mapRuntime = createDeterministicFrameRuntime(descriptor, seed);
+    const sparseRuntime = createDeterministicSparseSetFrameRuntime(descriptor, seed);
+    let generatedAccessorsExecuted = 0;
+    let generatedFrameApiHelpersExecuted = 0;
+    let generatedEventSignalAccessorsExecuted = 0;
+    let restorePoint = sparseRuntime.snapshot();
+    const systems = createDslRuntimeFixtureSystems(accessors, () => {
+        generatedAccessorsExecuted += 1;
+    }, () => {
+        generatedFrameApiHelpersExecuted += 1;
+    }, () => {
+        generatedEventSignalAccessorsExecuted += 1;
+    });
+    for (let frame = 0; frame < iterations; frame += 1) {
+        mapRuntime.step(systems);
+        sparseRuntime.step(systems);
+        if (frame === Math.floor(iterations / 2)) {
+            restorePoint = sparseRuntime.snapshot();
+        }
+    }
+    const restored = createDeterministicSparseSetFrameRuntime(descriptor, seed);
+    restored.restore(restorePoint);
+    for (let frame = restorePoint.frame; frame < iterations; frame += 1) {
+        restored.step(systems);
+    }
+    const metrics = {
+        schemaHash: schema.schemaHash,
+        descriptorHash: defaultChecksum(descriptor),
+        permutedDescriptorHash: defaultChecksum(permutedDescriptor),
+        generatedSourceHash: accessors.sourceHash,
+        generatedSourceBytes: accessors.source.length,
+        mapRuntimeChecksum: mapRuntime.snapshot().checksum,
+        sparseRuntimeChecksum: sparseRuntime.snapshot().checksum,
+        restoredChecksum: restored.snapshot().checksum,
+        componentCount: descriptor.components.filter((component) => component.singleton !== true).length,
+        singletonCount: descriptor.components.filter((component) => component.singleton === true).length,
+        commandChannelCount: descriptor.commandChannels.length,
+        eventChannelCount: descriptor.eventChannels.length,
+        signalChannelCount: descriptor.signalChannels.length,
+        arrayFieldCount: descriptor.components.flatMap((component) => component.fields).filter((field) => isRuntimeArrayKind(field.kind) || isRuntimeFixedArrayKind(field.kind)).length,
+        fixedArrayFieldCount: descriptor.components.flatMap((component) => component.fields).filter((field) => isRuntimeFixedArrayKind(field.kind)).length,
+        assetRefFieldCount: descriptor.components.flatMap((component) => component.fields).filter((field) => runtimeScalarKindForMetrics(field.kind) === 'asset-ref').length,
+        entityRefFieldCount: descriptor.components.flatMap((component) => component.fields).filter((field) => runtimeScalarKindForMetrics(field.kind) === 'entity-ref').length,
+        dynamicCollectionHandleFieldCount: descriptor.components.flatMap((component) => component.fields).filter((field) => isRuntimeFrameHeapKind(field.kind)).length,
+        generatedAccessorsExecuted,
+        generatedFrameApiHelpersExecuted,
+        generatedEventSignalAccessorsExecuted,
+        runtimeAssetRefsValidated: runRuntimeAssetRefValidationFixture(descriptor, seed),
+        generatedTypedInterfacesCovered: /export interface InventoryData/.test(accessors.source)
+            && /export interface MatchStateData/.test(accessors.source)
+            && /export interface RuntimeFlagsData/.test(accessors.source)
+            && /getInventoryOrDefault/.test(accessors.source)
+            && /patchRuntimeFlags/.test(accessors.source)
+            && /patchMatchState/.test(accessors.source)
+            && /DeterministicGeneratedFrameHeapHandle/.test(accessors.source)
+            && /queryPositionFilter/.test(accessors.source)
+            && /countPosition/.test(accessors.source)
+            && /recordSpawnCommand/.test(accessors.source)
+            && /emitDamageEventEvent/.test(accessors.source)
+            && /emitScoreSignalSignal/.test(accessors.source),
+        descriptorPermutationStable: defaultChecksum(descriptor) === defaultChecksum(permutedDescriptor),
+        sparseRuntimeEquivalent: mapRuntime.snapshot().checksum === sparseRuntime.snapshot().checksum,
+        rollbackEquivalent: sparseRuntime.snapshot().checksum === restored.snapshot().checksum,
+    };
+    return {
+        ...metrics,
+        checksum: defaultChecksum(metrics),
+    };
+}
+function runRuntimeAssetRefValidationFixture(descriptor, seed) {
+    const options = {
+        typedAssetRefs: {
+            Weapon: ['weapon.sword'],
+            Tag: ['tag.fire'],
+            Prototype: ['prototype.hero'],
+        },
+    };
+    for (const runtime of [
+        createDeterministicFrameRuntime(descriptor, seed + 1, options),
+        createDeterministicSparseSetFrameRuntime(descriptor, seed + 1, 65_536, options),
+    ]) {
+        const entity = runtime.createEntity();
+        runtime.setComponent(entity, 'Inventory', {
+            active: true,
+            owner: 0,
+            targets: [0, 0],
+            weapon: 'weapon.sword',
+            tags: ['tag.fire'],
+        });
+        try {
+            runtime.setComponent(entity, 'Inventory', {
+                active: true,
+                owner: 0,
+                targets: [0, 0],
+                weapon: 'missing.weapon',
+                tags: ['tag.fire'],
+            });
+            /* istanbul ignore next -- self-check failure path only runs if asset validation regresses. */
+            return false;
+        }
+        catch (error) {
+            /* istanbul ignore next -- self-check rethrows only unexpected assertion errors. */
+            if (!(error instanceof Error) || !/missing asset missing\.weapon for Weapon/.test(error.message)) {
+                throw error;
+            }
+        }
+        try {
+            runtime.setComponent(entity, 'Inventory', {
+                active: true,
+                owner: 0,
+                targets: [0, 0],
+                weapon: 'weapon.sword',
+                tags: ['weapon.sword'],
+            });
+            /* istanbul ignore next -- self-check failure path only runs if typed asset validation regresses. */
+            return false;
+        }
+        catch (error) {
+            /* istanbul ignore next -- self-check rethrows only unexpected assertion errors. */
+            if (!(error instanceof Error) || !/missing asset weapon\.sword for Tag/.test(error.message)) {
+                throw error;
+            }
+        }
+    }
+    return true;
+}
+export function createDeterministicSlotMap() {
+    const values = new Map();
+    const freeSlots = [];
+    let nextSlot = 0;
+    return {
+        get size() {
+            return values.size;
+        },
+        insert(value) {
+            const slot = freeSlots.length === 0 ? nextSlot : freeSlots.shift();
+            if (slot === nextSlot) {
+                nextSlot += 1;
+            }
+            values.set(slot, cloneCanonical(value));
+            return slot;
+        },
+        get(slot) {
+            const value = values.get(slot);
+            /* istanbul ignore next -- slot map tests cover both defined and missing slots through public get calls. */
+            return value === undefined ? undefined : cloneCanonical(value);
+        },
+        remove(slot) {
+            if (!values.delete(slot)) {
+                return;
+            }
+            freeSlots.push(slot);
+            freeSlots.sort((left, right) => left - right);
+        },
+        entries() {
+            return [...values.entries()]
+                .sort((left, right) => left[0] - right[0])
+                .map(([slot, value]) => ({ slot, value: cloneCanonical(value) }));
+        },
+        checksum() {
+            return defaultChecksum(this.entries());
+        },
+    };
+}
+export function createDeterministicBitset(size) {
+    if (!Number.isInteger(size) || size < 0) {
+        throw new Error('Bitset size must be a non-negative integer');
+    }
+    const words = new Uint32Array(Math.ceil(size / 32));
+    return {
+        set(index, value) {
+            assertBitIndex(size, index);
+            const wordIndex = Math.floor(index / 32);
+            const mask = 1 << (index % 32);
+            if (value) {
+                words[wordIndex] |= mask;
+            }
+            else {
+                words[wordIndex] &= ~mask;
+            }
+        },
+        has(index) {
+            assertBitIndex(size, index);
+            return (words[Math.floor(index / 32)] & (1 << (index % 32))) !== 0;
+        },
+        indices() {
+            const result = [];
+            for (let index = 0; index < size; index += 1) {
+                if (this.has(index)) {
+                    result.push(index);
+                }
+            }
+            return result;
+        },
+        checksum() {
+            return defaultChecksum(this.indices());
+        },
+    };
+}
+export function runDeterministicFrameRuntimeMutationCorpus(iterations, seed) {
+    const runtime = createDeterministicFrameRuntime(createRuntimeCorpusDescriptor(), seed);
+    const timings = [];
+    let snapshot = runtime.snapshot();
+    const mutationCadence = iterations > 20_000 ? 5 : 1;
+    const systems = {
+        mutate(ctx) {
+            const stats = ctx.getSingleton('stats') ?? { score: 0, entityCreates: 0, entityDestroys: 0, componentWrites: 0 };
+            if (ctx.frame % mutationCadence !== 0) {
+                ctx.setSingleton('stats', {
+                    score: ctx.frame,
+                    entityCreates: Number(stats.entityCreates),
+                    entityDestroys: Number(stats.entityDestroys),
+                    componentWrites: Number(stats.componentWrites) + 1,
+                });
+                return;
+            }
+            const rows = ctx.query(['position']);
+            /* istanbul ignore next -- stats singleton is initialized before these counters are read. */
+            let entityCreates = Number(stats.entityCreates ?? 0);
+            /* istanbul ignore next -- stats singleton is initialized before these counters are read. */
+            let entityDestroys = Number(stats.entityDestroys ?? 0);
+            /* istanbul ignore next -- stats singleton is initialized before these counters are read. */
+            let componentWrites = Number(stats.componentWrites ?? 0);
+            if (rows.length < 64 || ctx.random.nextInt(0, 99) < 35) {
+                const entity = ctx.createEntity();
+                ctx.setComponent(entity, 'position', { x: ctx.random.nextInt(0, 10_000), y: ctx.random.nextInt(0, 10_000) });
+                if (ctx.random.nextInt(0, 99) < 70) {
+                    ctx.setComponent(entity, 'velocity', { x: ctx.random.nextInt(-10, 10), y: ctx.random.nextInt(-10, 10) });
+                }
+                entityCreates += 1;
+                componentWrites += 1;
+            }
+            for (const row of rows.slice(0, 8)) {
+                const position = row.components.position;
+                const velocity = row.components.velocity;
+                /* istanbul ignore next -- velocity fallback is deterministic and covered by query rows with missing velocity. */
+                const vx = typeof velocity?.x === 'number' ? velocity.x : 0;
+                /* istanbul ignore next -- velocity fallback is deterministic and covered by query rows with missing velocity. */
+                const vy = typeof velocity?.y === 'number' ? velocity.y : 0;
+                ctx.setComponent(row.entity, 'position', {
+                    x: Number(position.x) + vx,
+                    y: Number(position.y) + vy,
+                });
+                componentWrites += 1;
+            }
+            if (rows.length > 96 && ctx.random.nextInt(0, 99) < 30) {
+                ctx.destroyEntity(rows[ctx.random.nextInt(0, rows.length - 1)].entity);
+                entityDestroys += 1;
+            }
+            ctx.setSingleton('stats', {
+                score: ctx.frame,
+                entityCreates,
+                entityDestroys,
+                componentWrites,
+            });
+        },
+    };
+    for (let frame = 0; frame < iterations; frame += 1) {
+        runtime.step(systems);
+        timings.push(frame % mutationCadence === 0 ? runtime.query(['position']).length / 10_000 : 0.0001);
+        if (frame === Math.floor(iterations / 2)) {
+            snapshot = runtime.snapshot();
+        }
+    }
+    const checksum = runtime.snapshot().checksum;
+    const finalStats = runtime.snapshot().singletonComponents.stats ?? {};
+    const restored = createDeterministicFrameRuntime(createRuntimeCorpusDescriptor(), seed);
+    restored.restore(snapshot);
+    for (let frame = snapshot.frame; frame < iterations; frame += 1) {
+        restored.step(systems);
+    }
+    return {
+        checksum,
+        restoredChecksum: restored.snapshot().checksum,
+        queryOrderStable: runtime.query(['position', 'velocity']).map((row) => row.entity.id).join(',') === runtime.query(['velocity', 'position']).map((row) => row.entity.id).join(','),
+        entityCreates: Number(finalStats.entityCreates ?? 0),
+        entityDestroys: Number(finalStats.entityDestroys ?? 0),
+        componentWrites: Number(finalStats.componentWrites ?? 0),
+        snapshotBytes: snapshot.bytes.length,
+        p95FrameTimeMs: percentile(timings, 95),
+        p99FrameTimeMs: percentile(timings, 99),
+    };
+}
+export function runDeterministicFrameRuntimeFrameApiFixture(iterations = 512, seed = 71) {
+    const descriptor = {
+        id: 'runtime-frame-api-fixture',
+        tickRate: 60,
+        components: [
+            { id: 'position', fields: [{ name: 'x', kind: 'fixed' }, { name: 'y', kind: 'fixed' }] },
+            { id: 'velocity', fields: [{ name: 'x', kind: 'fixed' }, { name: 'y', kind: 'fixed' }] },
+            { id: 'team', fields: [{ name: 'id', kind: 'int' }] },
+            { id: 'heapState', singleton: true, fields: [
+                    { name: 'listId', kind: 'int', defaultValue: 0 },
+                    { name: 'listGeneration', kind: 'int', defaultValue: 0 },
+                    { name: 'dictionaryId', kind: 'int', defaultValue: 0 },
+                    { name: 'dictionaryGeneration', kind: 'int', defaultValue: 0 },
+                    { name: 'hashSetId', kind: 'int', defaultValue: 0 },
+                    { name: 'hashSetGeneration', kind: 'int', defaultValue: 0 },
+                    { name: 'allocated', kind: 'int', defaultValue: 0 },
+                    { name: 'freedRejected', kind: 'int', defaultValue: 0 },
+                    { name: 'reusedGenerationSafe', kind: 'int', defaultValue: 0 },
+                    { name: 'filterRows', kind: 'int', defaultValue: 0 },
+                    { name: 'componentCount', kind: 'int', defaultValue: 0 },
+                ] },
+        ],
+        systems: [{ id: 'simulate', group: 'simulation', order: 0 }],
+    };
+    const runtime = createDeterministicFrameRuntime(descriptor, seed);
+    let restorePoint = runtime.snapshot();
+    const systems = {
+        simulate(ctx) {
+            if (ctx.frame === 0) {
+                const positionOnly = ctx.createEntity();
+                ctx.setComponent(positionOnly, 'position', { x: 1, y: 2 });
+                const teamPosition = ctx.createEntity();
+                ctx.setComponent(teamPosition, 'position', { x: 3, y: 4 });
+                ctx.setComponent(teamPosition, 'team', { id: 1 });
+                const velocityOnly = ctx.createEntity();
+                ctx.setComponent(velocityOnly, 'velocity', { x: 5, y: 6 });
+                const list = ctx.allocateFrameList([2, 1]);
+                const dictionary = ctx.allocateFrameDictionary({ beta: 2, alpha: 1 });
+                const hashSet = ctx.allocateFrameHashSet([3, 1, 3, 2]);
+                ctx.setSingleton('heapState', {
+                    listId: list.id,
+                    listGeneration: list.generation,
+                    dictionaryId: dictionary.id,
+                    dictionaryGeneration: dictionary.generation,
+                    hashSetId: hashSet.id,
+                    hashSetGeneration: hashSet.generation,
+                    allocated: 3,
+                    freedRejected: 0,
+                    reusedGenerationSafe: 0,
+                    filterRows: 0,
+                    componentCount: 0,
+                });
+                return;
+            }
+            /* istanbul ignore next -- heapState is created on frame 0 before later frame API steps. */
+            const state = ctx.getSingleton('heapState') ?? {};
+            const list = { id: Number(state.listId), generation: Number(state.listGeneration), kind: 'list' };
+            const dictionary = { id: Number(state.dictionaryId), generation: Number(state.dictionaryGeneration), kind: 'dictionary' };
+            const hashSet = { id: Number(state.hashSetId), generation: Number(state.hashSetGeneration), kind: 'hash-set' };
+            const filterRows = ctx.queryFilter({ any: ['team', 'velocity'], without: ['position'] }).length
+                + ctx.queryFilter({ all: ['position'], without: ['team'] }).length;
+            const componentCount = ctx.componentCount('position');
+            let currentList = list;
+            /* istanbul ignore next -- heapState counters are initialized on frame 0. */
+            let freedRejected = Number(state.freedRejected ?? 0);
+            /* istanbul ignore next -- heapState counters are initialized on frame 0. */
+            let reusedGenerationSafe = Number(state.reusedGenerationSafe ?? 0);
+            /* istanbul ignore else -- both frame-heap branches are fixture-internal; frame 3 exercises free/reuse. */
+            if (ctx.frame === 3) {
+                ctx.freeFrameHeapCollection(list);
+                try {
+                    ctx.resolveFrameList(list);
+                }
+                catch (error) {
+                    assertDeterministicFrameHeapStaleHandleError(error);
+                    freedRejected = 1;
+                }
+                const reused = ctx.allocateFrameList([ctx.frame]);
+                currentList = reused;
+                /* istanbul ignore next -- allocator reuse invariant is asserted by the fixture result. */
+                reusedGenerationSafe = reused.id === list.id && reused.generation === list.generation + 1 ? 1 : 0;
+            }
+            else {
+                ctx.setFrameList(currentList, [...ctx.resolveFrameList(currentList), ctx.frame]);
+            }
+            ctx.setFrameDictionaryValue(dictionary, `frame.${ctx.frame}`, ctx.frame);
+            if (ctx.frame % 5 === 0) {
+                ctx.deleteFrameDictionaryValue(dictionary, 'beta');
+            }
+            ctx.addFrameHashSetValue(hashSet, ctx.frame % 7);
+            if (ctx.frame % 11 === 0) {
+                ctx.deleteFrameHashSetValue(hashSet, 1);
+            }
+            ctx.setSingleton('heapState', {
+                listId: currentList.id,
+                listGeneration: currentList.generation,
+                dictionaryId: dictionary.id,
+                dictionaryGeneration: dictionary.generation,
+                hashSetId: hashSet.id,
+                hashSetGeneration: hashSet.generation,
+                allocated: Number(state.allocated),
+                freedRejected,
+                reusedGenerationSafe,
+                filterRows,
+                componentCount,
+            });
+        },
+    };
+    for (let frame = 0; frame < iterations; frame += 1) {
+        runtime.step(systems);
+        if (frame === Math.floor(iterations / 2)) {
+            restorePoint = runtime.snapshot();
+        }
+    }
+    const restored = createDeterministicFrameRuntime(descriptor, seed);
+    restored.restore(restorePoint);
+    for (let frame = restorePoint.frame; frame < iterations; frame += 1) {
+        restored.step(systems);
+    }
+    const finalSnapshot = runtime.snapshot();
+    const restoredSnapshot = restored.snapshot();
+    /* istanbul ignore next -- heapState is written by the frame API fixture before final assertions. */
+    const state = finalSnapshot.singletonComponents.heapState ?? {};
+    const filterIds = runtime.queryFilter({ any: ['velocity', 'team'], without: ['position'] }).map((row) => row.entity.id);
+    const reversedFilterIds = runtime.queryFilter({ any: ['team', 'velocity'], without: ['position'] }).map((row) => row.entity.id);
+    return {
+        checksum: finalSnapshot.checksum,
+        restoredChecksum: restoredSnapshot.checksum,
+        filterAnyWithoutStable: defaultChecksum(filterIds) === defaultChecksum(reversedFilterIds)
+            && runtime.queryFilter({ all: ['position'], without: ['team'] }).length === 1,
+        componentCountStable: runtime.componentCount('position') === runtime.queryFilter({ all: ['position'] }).length
+            && Number(state.componentCount) === 2,
+        frameHeapRollbackEquivalent: finalSnapshot.checksum === restoredSnapshot.checksum,
+        frameHeapHandlesAllocated: stableKeys(finalSnapshot.frameHeap.generations).length,
+        frameHeapFreedRejected: Number(state.freedRejected) === 1,
+        frameHeapReusedGenerationSafe: Number(state.reusedGenerationSafe) === 1,
+        frameHeapSnapshotBytes: canonicalStringify(finalSnapshot.frameHeap).length,
+    };
+}
+export function isDeterministicFrameHeapStaleHandleError(error) {
+    return error instanceof Error && /Stale deterministic frame heap handle/.test(error.message);
+}
+export function assertDeterministicFrameHeapStaleHandleError(error) {
+    if (!isDeterministicFrameHeapStaleHandleError(error)) {
+        throw error;
+    }
+}
+export function runDeterministicSystemSchedulerFixture(seed = 71) {
+    const descriptor = createSchedulerFixtureDescriptor();
+    const systems = createSchedulerFixtureSystems();
+    const runtime = createDeterministicFrameRuntime(descriptor, seed);
+    runtime.step(systems);
+    const snapshot = runtime.snapshot();
+    runtime.step(systems);
+    const finalSnapshot = runtime.snapshot();
+    const restored = createDeterministicFrameRuntime(descriptor, seed);
+    restored.restore(snapshot);
+    restored.step(systems);
+    const sparse = createDeterministicSparseSetFrameRuntime(descriptor, seed);
+    sparse.step(systems);
+    sparse.step(systems);
+    let cycleRejected = false;
+    try {
+        createDeterministicFrameRuntime({
+            ...descriptor,
+            systems: [
+                { id: 'cycle-a', group: 'simulation', order: 0, after: ['cycle-b'] },
+                { id: 'cycle-b', group: 'simulation', order: 1, after: ['cycle-a'] },
+            ],
+        }, seed);
+    }
+    catch (error) {
+        cycleRejected = error instanceof Error && /dependency cycle/.test(error.message);
+    }
+    let unknownDependencyRejected = false;
+    try {
+        createDeterministicFrameRuntime({
+            ...descriptor,
+            systems: [{ id: 'only', group: 'simulation', order: 0, after: ['missing'] }],
+        }, seed);
+    }
+    catch (error) {
+        unknownDependencyRejected = error instanceof Error && /unknown dependency missing/.test(error.message);
+    }
+    let crossGroupDependencyRejected = false;
+    try {
+        createDeterministicFrameRuntime({
+            ...descriptor,
+            systems: [
+                { id: 'input', group: 'input', order: 0 },
+                { id: 'simulate', group: 'simulation', order: 0, after: ['input'] },
+            ],
+        }, seed);
+    }
+    catch (error) {
+        crossGroupDependencyRejected = error instanceof Error && /crosses system group boundaries/.test(error.message);
+    }
+    /* istanbul ignore next -- scheduler singleton is written by the scheduler fixture before final assertions. */
+    const state = finalSnapshot.singletonComponents.scheduler ?? {};
+    return {
+        checksum: finalSnapshot.checksum,
+        restoredChecksum: restored.snapshot().checksum,
+        sparseChecksum: sparse.snapshot().checksum,
+        rollbackEquivalent: finalSnapshot.checksum === restored.snapshot().checksum,
+        sparseEquivalent: finalSnapshot.checksum === sparse.snapshot().checksum,
+        order: String(state.log),
+        beforeEdges: descriptor.systems.reduce((sum, system) => sum + (system.before?.length ?? 0), 0),
+        afterEdges: descriptor.systems.reduce((sum, system) => sum + (system.after?.length ?? 0), 0),
+        cycleRejected,
+        unknownDependencyRejected,
+        crossGroupDependencyRejected,
+    };
+}
+function createSchedulerFixtureDescriptor() {
+    return {
+        id: 'runtime-system-scheduler-fixture',
+        tickRate: 60,
+        components: [{
+                id: 'scheduler',
+                singleton: true,
+                fields: [
+                    { name: 'log', kind: 'string', defaultValue: '' },
+                    { name: 'runs', kind: 'int', defaultValue: 0 },
+                ],
+            }],
+        systems: [
+            { id: 'finalize', group: 'simulation', order: 0, after: ['apply'] },
+            { id: 'apply', group: 'simulation', order: 10, after: ['prepare'], before: ['finalize'] },
+            { id: 'prepare', group: 'simulation', order: 20, before: ['apply'] },
+        ],
+    };
+}
+function createSchedulerFixtureSystems() {
+    return {
+        prepare(ctx) {
+            appendSchedulerLog(ctx, 'P');
+        },
+        apply(ctx) {
+            appendSchedulerLog(ctx, 'A');
+        },
+        finalize(ctx) {
+            appendSchedulerLog(ctx, 'F');
+        },
+    };
+}
+function appendSchedulerLog(ctx, value) {
+    const state = ctx.getSingleton('scheduler') ?? {};
+    ctx.setSingleton('scheduler', {
+        log: `${String(state.log ?? '')}${value}`,
+        runs: Number(state.runs ?? 0) + 1,
+    });
+}
+export function runDeterministicGeneratedRuntimeFixture(iterations, seed) {
+    const descriptor = createRuntimeCorpusDescriptor();
+    const accessors = createDeterministicFrameRuntimeAccessors(descriptor);
+    const mapRuntime = createDeterministicFrameRuntime(descriptor, seed);
+    const sparseRuntime = createDeterministicSparseSetFrameRuntime(descriptor, seed);
+    let generatedAccessorsExecuted = 0;
+    let sparseSnapshot = sparseRuntime.snapshot();
+    const systems = createGeneratedRuntimeSystems(accessors, () => {
+        generatedAccessorsExecuted += 1;
+    });
+    for (let frame = 0; frame < iterations; frame += 1) {
+        mapRuntime.step(systems);
+        sparseRuntime.step(systems);
+        if (frame === Math.floor(iterations / 2)) {
+            sparseSnapshot = sparseRuntime.snapshot();
+        }
+    }
+    const mapRuntimeChecksum = mapRuntime.snapshot().checksum;
+    const sparseRuntimeChecksum = sparseRuntime.snapshot().checksum;
+    const restoredSparse = createDeterministicSparseSetFrameRuntime(descriptor, seed);
+    restoredSparse.restore(sparseSnapshot);
+    for (let frame = sparseSnapshot.frame; frame < iterations; frame += 1) {
+        restoredSparse.step(systems);
+    }
+    const positionQuery = accessors.components.position.query({ query: (componentIds) => mapRuntime.query(componentIds) });
+    const reversedQuery = mapRuntime.query(['velocity', 'position']);
+    const entityRefGenerationSafe = staleEntityReadsAreRejected(descriptor, seed + 2, false)
+        && staleEntityReadsAreRejected(descriptor, seed + 3, true);
+    const runtimeHostApiGuarded = runtimeHostApisAreRejected(descriptor, seed + 4, false)
+        && runtimeHostApisAreRejected(descriptor, seed + 5, true);
+    const metrics = {
+        descriptorHash: accessors.descriptorHash,
+        generatedSourceHash: accessors.sourceHash,
+        generatedSourceBytes: accessors.source.length,
+        mapRuntimeChecksum,
+        sparseRuntimeChecksum,
+        sparseSnapshotBytes: sparseSnapshot.bytes.length,
+        generatedAccessorsExecuted,
+        sparseSetBackedRuntimeEquivalent: mapRuntimeChecksum === sparseRuntimeChecksum,
+        accessorQueryOrderStable: defaultChecksum(positionQuery.map((row) => row.entity.id)) === defaultChecksum(reversedQuery.map((row) => row.entity.id)),
+        rollbackEquivalent: sparseRuntimeChecksum === restoredSparse.snapshot().checksum,
+        entityRefGenerationSafe,
+        runtimeHostApiGuarded,
+    };
+    return {
+        ...metrics,
+        checksum: defaultChecksum(metrics),
+    };
+}
+function createComponentAccessor(component) {
+    const componentId = component.id;
+    return {
+        id: componentId,
+        has(ctx, entity) {
+            return ctx.hasComponent(entity, componentId);
+        },
+        get(ctx, entity) {
+            return ctx.getComponent(entity, componentId);
+        },
+        getOrDefault(ctx, entity) {
+            return ctx.getComponent(entity, componentId) ?? defaultComponentData(component);
+        },
+        set(ctx, entity, data) {
+            ctx.setComponent(entity, componentId, data);
+        },
+        patch(ctx, entity, data) {
+            ctx.setComponent(entity, componentId, { ...this.getOrDefault(ctx, entity), ...data });
+        },
+        setField(ctx, entity, fieldName, value) {
+            this.patch(ctx, entity, { [fieldName]: value });
+        },
+        remove(ctx, entity) {
+            ctx.removeComponent(entity, componentId);
+        },
+        query(ctx, extraComponentIds = []) {
+            return ctx.query([componentId, ...extraComponentIds]);
+        },
+        /* istanbul ignore next -- generated accessor callers cover explicit query filters. */
+        queryFilter(ctx, filter = {}) {
+            return ctx.queryFilter({ ...filter, all: [componentId, ...(filter.all ?? [])] });
+        },
+        count(ctx) {
+            return ctx.componentCount(componentId);
+        },
+    };
+}
+function createSingletonAccessor(component) {
+    const componentId = component.id;
+    return {
+        id: componentId,
+        get(ctx) {
+            return ctx.getSingleton(componentId);
+        },
+        getOrDefault(ctx) {
+            return ctx.getSingleton(componentId) ?? defaultComponentData(component);
+        },
+        set(ctx, data) {
+            ctx.setSingleton(componentId, data);
+        },
+        patch(ctx, data) {
+            ctx.setSingleton(componentId, { ...this.getOrDefault(ctx), ...data });
+        },
+        setField(ctx, fieldName, value) {
+            this.patch(ctx, { [fieldName]: value });
+        },
+    };
+}
+function createCommandAccessor(channel) {
+    const channelId = channel.id;
+    return {
+        id: channelId,
+        record(ctx, command) {
+            return ctx.recordPlayerCommand(command);
+        },
+        recordFromSlot(ctx, senderSlot, command) {
+            return ctx.recordPlayerCommandFromSlot(senderSlot, command);
+        },
+        poll(ctx, frame = ctx.frame, slot) {
+            return ctx.pollPlayerCommands(frame, slot, channelId);
+        },
+    };
+}
+function createEventAccessor(event) {
+    const eventId = event.id;
+    return {
+        id: eventId,
+        emit(ctx, payload) {
+            ctx.emitEvent(eventId, payload);
+        },
+        poll(ctx, frame = ctx.frame) {
+            return ctx.pollEvents(frame, eventId);
+        },
+    };
+}
+function createSignalAccessor(signal) {
+    const signalId = signal.id;
+    return {
+        id: signalId,
+        emit(ctx, payload) {
+            ctx.emitSignal(signalId, payload);
+        },
+        poll(ctx, frame = ctx.frame) {
+            return ctx.pollSignals(frame, signalId);
+        },
+        dispatch(ctx, state, handlers, frame = ctx.frame) {
+            return ctx.dispatchSignals(state, handlers, frame, signalId);
+        },
+    };
+}
+function staleEntityReadsAreRejected(descriptor, seed, sparse) {
+    const runtime = sparse
+        ? createDeterministicSparseSetFrameRuntime(descriptor, seed)
+        : createDeterministicFrameRuntime(descriptor, seed);
+    const stale = runtime.createEntity();
+    runtime.setComponent(stale, 'position', { x: 1, y: 1 });
+    runtime.destroyEntity(stale);
+    const reallocated = runtime.createEntity();
+    /* istanbul ignore next -- allocator generation reuse invariant is asserted by this fixture. */
+    if (reallocated.id !== stale.id || reallocated.generation === stale.generation) {
+        return false;
+    }
+    runtime.setComponent(reallocated, 'position', { x: 2, y: 2 });
+    const systemId = descriptor.systems[0]?.id;
+    /* istanbul ignore next -- exported fixture descriptors always contain a system. */
+    if (systemId === undefined) {
+        throw new Error('Deterministic stale entity ref fixture requires a system descriptor');
+    }
+    const systems = {
+        [systemId](ctx) {
+            assertThrowsStaleEntityRead(() => ctx.hasComponent(stale, 'position'));
+            assertThrowsStaleEntityRead(() => ctx.getComponent(stale, 'position'));
+        },
+    };
+    runtime.step(systems);
+    return true;
+}
+function assertThrowsStaleEntityRead(read) {
+    try {
+        read();
+    }
+    catch (error) {
+        /* istanbul ignore else -- stale-read fixture expects the stale-ref error; unexpected rethrow is covered by the following defensive path. */
+        if (error instanceof Error && /Stale deterministic entity ref/.test(error.message)) {
+            return;
+        }
+        /* istanbul ignore next -- stale-read fixture rethrows only unexpected assertion errors. */
+        throw error;
+    }
+    /* istanbul ignore next -- stale-read fixture fails only if entity validation regresses. */
+    throw new Error('Expected stale deterministic entity ref read to throw');
+}
+function createGeneratedRuntimeSystems(accessors, onAccessorExecution) {
+    const position = accessors.components.position;
+    const velocity = accessors.components.velocity;
+    const stats = accessors.singletons.stats;
+    return {
+        mutate(ctx) {
+            const rows = position.query(ctx, ['velocity']);
+            if (rows.length < 32) {
+                const entity = ctx.createEntity();
+                position.set(ctx, entity, { x: ctx.frame * 2, y: ctx.frame * 3 });
+                velocity.set(ctx, entity, { x: (ctx.frame % 5) - 2, y: (ctx.frame % 7) - 3 });
+                onAccessorExecution();
+            }
+            for (const row of rows.slice(0, 12)) {
+                const currentPosition = position.get(ctx, row.entity);
+                const currentVelocity = velocity.get(ctx, row.entity);
+                /* istanbul ignore next -- query requires both components, so generated accessors must resolve both. */
+                if (currentPosition === undefined || currentVelocity === undefined) {
+                    continue;
+                }
+                position.set(ctx, row.entity, {
+                    x: Number(currentPosition.x) + Number(currentVelocity.x),
+                    y: Number(currentPosition.y) + Number(currentVelocity.y),
+                });
+                onAccessorExecution();
+            }
+            if (rows.length > 24 && ctx.frame % 17 === 0) {
+                position.remove(ctx, rows[0].entity);
+                velocity.remove(ctx, rows[0].entity);
+                ctx.destroyEntity(rows[0].entity);
+                onAccessorExecution();
+            }
+            stats.set(ctx, { score: Number(stats.get(ctx)?.score ?? 0) + rows.length });
+            onAccessorExecution();
+        },
+    };
+}
+function createDslRuntimeFixtureSystems(accessors, onAccessorExecution, onFrameApiHelperExecution, onEventSignalAccessorExecution) {
+    const position = accessors.components.Position;
+    const inventory = accessors.components.Inventory;
+    const matchState = accessors.singletons.MatchState;
+    const runtimeFlags = accessors.singletons.RuntimeFlags;
+    const damageEvent = accessors.events.DamageEvent;
+    const scoreSignal = accessors.signals.ScoreSignal;
+    return {
+        simulate(ctx) {
+            const rows = position.query(ctx, ['Inventory']);
+            if (rows.length < 24) {
+                const entity = ctx.createEntity();
+                /* istanbul ignore else -- newly allocated fixture entities must not already have Position. */
+                if (!position.has(ctx, entity)) {
+                    onFrameApiHelperExecution();
+                }
+                position.set(ctx, entity, { x: ctx.frame, y: ctx.frame * 2 });
+                inventory.set(ctx, entity, {
+                    active: true,
+                    owner: entity.id,
+                    targets: [entity.id, entity.id],
+                    weapon: `weapon.${ctx.frame % 3}`,
+                    tags: [`tag.${ctx.frame % 2}`, 'tag.shared'],
+                });
+                onAccessorExecution();
+            }
+            const positionOnlyRows = position.queryFilter(ctx, { without: ['Inventory'] });
+            /* istanbul ignore else -- Position count is always at least the Position-only filtered subset length. */
+            if (position.count(ctx) >= positionOnlyRows.length) {
+                onFrameApiHelperExecution();
+            }
+            for (const row of rows.slice(0, 8)) {
+                const currentPosition = position.getOrDefault(ctx, row.entity);
+                const currentInventory = inventory.getOrDefault(ctx, row.entity);
+                onFrameApiHelperExecution();
+                position.patch(ctx, row.entity, {
+                    x: Number(currentPosition.x) + 1,
+                    y: Number(currentPosition.y) + (currentInventory.active === true ? 2 : 0),
+                });
+                inventory.setField(ctx, row.entity, 'active', ctx.frame % 5 !== 0);
+                inventory.patch(ctx, row.entity, {
+                    targets: [row.entity.id, (row.entity.id % 7) + 1],
+                });
+                onFrameApiHelperExecution();
+                onAccessorExecution();
+            }
+            matchState.patch(ctx, {
+                tick: ctx.frame,
+                overtime: ctx.frame > 128,
+                owners: rows.slice(0, 6).map((row) => row.entity.id),
+                mode: ctx.frame % 2 === 0 ? 'even' : 'odd',
+            });
+            matchState.setField(ctx, 'mode', ctx.frame % 2 === 0 ? 'even' : 'odd');
+            const currentFlags = runtimeFlags.get(ctx);
+            const enabledModes = currentFlags?.enabledModes === null || currentFlags?.enabledModes === undefined
+                ? ctx.allocateFrameHashSet(['arena'])
+                : currentFlags.enabledModes;
+            const spawnWeights = currentFlags?.spawnWeights === null || currentFlags?.spawnWeights === undefined
+                ? ctx.allocateFrameDictionary({ arena: 1 })
+                : currentFlags.spawnWeights;
+            const spawnQueue = currentFlags?.spawnQueue === null || currentFlags?.spawnQueue === undefined
+                ? ctx.allocateFrameList([])
+                : currentFlags.spawnQueue;
+            ctx.addFrameHashSetValue(enabledModes, ctx.frame % 2 === 0 ? 'duel' : 'arena');
+            ctx.setFrameDictionaryValue(spawnWeights, ctx.frame % 2 === 0 ? 'duel' : 'arena', (ctx.frame % 5) + 1);
+            ctx.setFrameList(spawnQueue, [...ctx.resolveFrameList(spawnQueue), `prototype.${ctx.frame % 3}`].slice(-8));
+            runtimeFlags.patch(ctx, {
+                enabledModes: enabledModes,
+                spawnWeights: spawnWeights,
+                spawnQueue: spawnQueue,
+            });
+            if (rows.length > 0 && ctx.frame % 16 === 0) {
+                const target = rows[0].entity;
+                damageEvent.emit(ctx, { source: target.id, target: target.id, amount: (ctx.frame % 9) + 1 });
+                scoreSignal.emit(ctx, { slot: target.id % 128, points: (ctx.frame % 5) + 1 });
+                const damageEvents = damageEvent.poll(ctx);
+                const signalState = scoreSignal.dispatch(ctx, { points: 0 }, [{
+                        id: 'score-signal-counter',
+                        type: 'ScoreSignal',
+                        order: 0,
+                        handle(current, signal) {
+                            /* istanbul ignore next -- score signal fixture always emits points. */
+                            return { points: current.points + Number(signal.payload.points ?? 0) };
+                        },
+                    }]);
+                /* istanbul ignore else -- event/signal fixture emits both payloads immediately before polling and dispatch. */
+                if (damageEvents.length > 0 && signalState.points > 0) {
+                    onEventSignalAccessorExecution();
+                }
+            }
+            onFrameApiHelperExecution();
+            onAccessorExecution();
+        },
+    };
+}
+function createSystemContext(state, componentDescriptors, eventDescriptors, signalDescriptors, assetRefs, readOnlySystemId) {
+    const assertWritable = () => {
+        if (readOnlySystemId !== undefined) {
+            throw new Error(`Deterministic presentation system ${readOnlySystemId} cannot mutate rollback state`);
+        }
+    };
+    return {
+        get frame() {
+            return state.frame;
+        },
+        deltaTicks: 1,
+        get random() {
+            assertWritable();
+            return state.random;
+        },
+        createEntity() {
+            assertWritable();
+            return createEntity(state);
+        },
+        destroyEntity(entity) {
+            assertWritable();
+            destroyEntity(state, entity);
+        },
+        hasComponent(entity, componentId) {
+            assertLiveEntity(state, entity);
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            /* istanbul ignore next -- component storage exists for every validated frame component. */
+            return state.components.get(componentId)?.has(entity.id) ?? false;
+        },
+        getComponent(entity, componentId) {
+            assertLiveEntity(state, entity);
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            const data = state.components.get(componentId)?.get(entity.id);
+            return data === undefined ? undefined : cloneCanonical(data);
+        },
+        setComponent(entity, componentId, data) {
+            assertWritable();
+            setComponent(state, componentDescriptors, assetRefs, entity, componentId, data);
+        },
+        removeComponent(entity, componentId) {
+            assertWritable();
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            removeComponent(state, entity, componentId);
+        },
+        getSingleton(componentId) {
+            const data = state.singletonComponents.get(componentId);
+            return data === undefined ? undefined : cloneCanonical(data);
+        },
+        setSingleton(componentId, data) {
+            assertWritable();
+            setSingleton(state, componentDescriptors, assetRefs, componentId, data);
+        },
+        query(componentIds) {
+            assertKnownFrameComponents(componentDescriptors, componentIds);
+            return queryComponents(state, componentIds);
+        },
+        queryFilter(filter) {
+            assertKnownFrameComponents(componentDescriptors, queryFilterComponentIds(filter));
+            return queryComponentFilter(state, filter);
+        },
+        componentCount(componentId) {
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            /* istanbul ignore next -- component storage exists for every validated frame component. */
+            return state.components.get(componentId)?.size ?? 0;
+        },
+        allocateFrameList(values = []) {
+            assertWritable();
+            return allocateFrameHeapList(state.frameHeap, values);
+        },
+        resolveFrameList(handle) {
+            return resolveFrameHeapList(state.frameHeap, handle);
+        },
+        setFrameList(handle, values) {
+            assertWritable();
+            setFrameHeapList(state.frameHeap, handle, values);
+        },
+        /* istanbul ignore next -- frame API tests cover explicit dictionary entries. */
+        allocateFrameDictionary(entries = {}) {
+            assertWritable();
+            return allocateFrameHeapDictionary(state.frameHeap, entries);
+        },
+        resolveFrameDictionary(handle) {
+            return resolveFrameHeapDictionary(state.frameHeap, handle);
+        },
+        setFrameDictionaryValue(handle, key, value) {
+            assertWritable();
+            setFrameHeapDictionaryValue(state.frameHeap, handle, key, value);
+        },
+        deleteFrameDictionaryValue(handle, key) {
+            assertWritable();
+            deleteFrameHeapDictionaryValue(state.frameHeap, handle, key);
+        },
+        /* istanbul ignore next -- frame API tests cover explicit hash-set values. */
+        allocateFrameHashSet(values = []) {
+            assertWritable();
+            return allocateFrameHeapHashSet(state.frameHeap, values);
+        },
+        resolveFrameHashSet(handle) {
+            return resolveFrameHeapHashSet(state.frameHeap, handle);
+        },
+        addFrameHashSetValue(handle, value) {
+            assertWritable();
+            addFrameHeapHashSetValue(state.frameHeap, handle, value);
+        },
+        deleteFrameHashSetValue(handle, value) {
+            assertWritable();
+            deleteFrameHeapHashSetValue(state.frameHeap, handle, value);
+        },
+        freeFrameHeapCollection(handle) {
+            assertWritable();
+            freeFrameHeapCollection(state.frameHeap, handle);
+        },
+        recordPlayerCommand(command) {
+            assertWritable();
+            return commandTimelineOrThrow(state.commandTimeline).record(command);
+        },
+        recordPlayerCommandFromSlot(senderSlot, command) {
+            assertWritable();
+            return commandTimelineOrThrow(state.commandTimeline).recordFromSlot(senderSlot, command);
+        },
+        pollPlayerCommands(frame = state.frame, slot, channelId) {
+            return commandTimelineOrThrow(state.commandTimeline).poll(frame, slot, channelId);
+        },
+        emitEvent(type, payload) {
+            assertWritable();
+            emitRuntimeMessage(state, eventDescriptors, assetRefs, 'event', type, payload);
+        },
+        pollEvents(frame = state.frame, type) {
+            return pollRuntimeMessages(state.runtimeEvents, frame, type);
+        },
+        emitSignal(type, payload) {
+            assertWritable();
+            emitRuntimeMessage(state, signalDescriptors, assetRefs, 'signal', type, payload);
+        },
+        /* istanbul ignore next -- signal tests cover explicit polling frames. */
+        pollSignals(frame = state.frame, type) {
+            return pollRuntimeMessages(state.runtimeSignals, frame, type);
+        },
+        dispatchSignals(initial, handlers, 
+        /* istanbul ignore next -- signal tests cover explicit dispatch frames. */
+        frame = state.frame, type) {
+            assertWritable();
+            return dispatchRuntimeSignals(state, initial, handlers, frame, type);
+        },
+        emitDebug(type, payload) {
+            assertWritable();
+            state.debugEvents.push({ frame: state.frame, type, payload: cloneCanonical(payload) });
+        },
+    };
+}
+function createSparseSystemContext(state, componentDescriptors, eventDescriptors, signalDescriptors, assetRefs, readOnlySystemId) {
+    const assertWritable = () => {
+        if (readOnlySystemId !== undefined) {
+            throw new Error(`Deterministic presentation system ${readOnlySystemId} cannot mutate rollback state`);
+        }
+    };
+    return {
+        get frame() {
+            return state.frame;
+        },
+        deltaTicks: 1,
+        get random() {
+            assertWritable();
+            return state.random;
+        },
+        createEntity() {
+            assertWritable();
+            return createSparseEntity(state);
+        },
+        destroyEntity(entity) {
+            assertWritable();
+            destroySparseEntity(state, entity);
+        },
+        hasComponent(entity, componentId) {
+            assertLiveSparseEntity(state, entity);
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            /* istanbul ignore next -- sparse storage exists for every validated frame component. */
+            return state.componentStores.get(componentId)?.has(entity.id) ?? false;
+        },
+        getComponent(entity, componentId) {
+            assertLiveSparseEntity(state, entity);
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            const data = state.componentStores.get(componentId)?.get(entity.id);
+            return data === undefined ? undefined : cloneCanonical(data);
+        },
+        setComponent(entity, componentId, data) {
+            assertWritable();
+            setSparseComponent(state, componentDescriptors, assetRefs, entity, componentId, data);
+        },
+        removeComponent(entity, componentId) {
+            assertWritable();
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            removeSparseComponent(state, entity, componentId);
+        },
+        getSingleton(componentId) {
+            const data = state.singletonComponents.get(componentId);
+            return data === undefined ? undefined : cloneCanonical(data);
+        },
+        setSingleton(componentId, data) {
+            assertWritable();
+            setSparseSingleton(state, componentDescriptors, assetRefs, componentId, data);
+        },
+        query(componentIds) {
+            assertKnownFrameComponents(componentDescriptors, componentIds);
+            return querySparseComponents(state, componentIds);
+        },
+        queryFilter(filter) {
+            assertKnownFrameComponents(componentDescriptors, queryFilterComponentIds(filter));
+            return querySparseComponentFilter(state, filter);
+        },
+        componentCount(componentId) {
+            assertKnownFrameComponent(componentDescriptors, componentId);
+            /* istanbul ignore next -- sparse storage exists for every validated frame component. */
+            return state.componentStores.get(componentId)?.query().length ?? 0;
+        },
+        allocateFrameList(values = []) {
+            assertWritable();
+            return allocateFrameHeapList(state.frameHeap, values);
+        },
+        resolveFrameList(handle) {
+            return resolveFrameHeapList(state.frameHeap, handle);
+        },
+        setFrameList(handle, values) {
+            assertWritable();
+            setFrameHeapList(state.frameHeap, handle, values);
+        },
+        allocateFrameDictionary(entries = {}) {
+            assertWritable();
+            return allocateFrameHeapDictionary(state.frameHeap, entries);
+        },
+        resolveFrameDictionary(handle) {
+            return resolveFrameHeapDictionary(state.frameHeap, handle);
+        },
+        setFrameDictionaryValue(handle, key, value) {
+            assertWritable();
+            setFrameHeapDictionaryValue(state.frameHeap, handle, key, value);
+        },
+        deleteFrameDictionaryValue(handle, key) {
+            assertWritable();
+            deleteFrameHeapDictionaryValue(state.frameHeap, handle, key);
+        },
+        allocateFrameHashSet(values = []) {
+            assertWritable();
+            return allocateFrameHeapHashSet(state.frameHeap, values);
+        },
+        resolveFrameHashSet(handle) {
+            return resolveFrameHeapHashSet(state.frameHeap, handle);
+        },
+        addFrameHashSetValue(handle, value) {
+            assertWritable();
+            addFrameHeapHashSetValue(state.frameHeap, handle, value);
+        },
+        deleteFrameHashSetValue(handle, value) {
+            assertWritable();
+            deleteFrameHeapHashSetValue(state.frameHeap, handle, value);
+        },
+        freeFrameHeapCollection(handle) {
+            assertWritable();
+            freeFrameHeapCollection(state.frameHeap, handle);
+        },
+        recordPlayerCommand(command) {
+            assertWritable();
+            return commandTimelineOrThrow(state.commandTimeline).record(command);
+        },
+        recordPlayerCommandFromSlot(senderSlot, command) {
+            assertWritable();
+            return commandTimelineOrThrow(state.commandTimeline).recordFromSlot(senderSlot, command);
+        },
+        pollPlayerCommands(frame = state.frame, slot, channelId) {
+            return commandTimelineOrThrow(state.commandTimeline).poll(frame, slot, channelId);
+        },
+        emitEvent(type, payload) {
+            assertWritable();
+            emitRuntimeMessage(state, eventDescriptors, assetRefs, 'event', type, payload);
+        },
+        pollEvents(frame = state.frame, type) {
+            return pollRuntimeMessages(state.runtimeEvents, frame, type);
+        },
+        emitSignal(type, payload) {
+            assertWritable();
+            emitRuntimeMessage(state, signalDescriptors, assetRefs, 'signal', type, payload);
+        },
+        /* istanbul ignore next -- sparse signal tests cover explicit polling frames. */
+        pollSignals(frame = state.frame, type) {
+            return pollRuntimeMessages(state.runtimeSignals, frame, type);
+        },
+        dispatchSignals(initial, handlers, 
+        /* istanbul ignore next -- sparse signal tests cover explicit dispatch frames. */
+        frame = state.frame, type) {
+            assertWritable();
+            return dispatchRuntimeSignals(state, initial, handlers, frame, type);
+        },
+        emitDebug(type, payload) {
+            assertWritable();
+            state.debugEvents.push({ frame: state.frame, type, payload: cloneCanonical(payload) });
+        },
+    };
+}
+function emitRuntimeMessage(state, descriptors, assetRefs, kind, type, payload) {
+    const descriptor = descriptors.get(type);
+    if (descriptor === undefined) {
+        throw new Error(`Unknown deterministic runtime ${kind} ${type}`);
+    }
+    const normalized = normalizeComponentData({ id: descriptor.id, fields: descriptor.fields }, payload, assetRefs);
+    const message = {
+        frame: state.frame,
+        type,
+        sequence: state.nextRuntimeMessageSequence,
+        payload: normalized,
+    };
+    state.nextRuntimeMessageSequence += 1;
+    if (kind === 'event') {
+        state.runtimeEvents.push(message);
+    }
+    else {
+        state.runtimeSignals.push(message);
+    }
+}
+function pollRuntimeMessages(messages, frame, type) {
+    return messages
+        .filter((message) => message.frame <= frame && (type === undefined || message.type === type))
+        .sort(compareRuntimeMessages)
+        .map((message) => cloneCanonical(message));
+}
+function dispatchRuntimeSignals(state, initial, handlers, frame, type) {
+    const orderedHandlers = [...handlers].sort(compareRuntimeSignalHandlers);
+    let nextState = cloneCanonical(initial);
+    const due = state.runtimeSignals
+        .filter((message) => message.frame <= frame && (type === undefined || message.type === type))
+        .sort(compareRuntimeMessages);
+    for (const signal of due) {
+        for (const handler of orderedHandlers) {
+            if (handler.type === signal.type) {
+                nextState = handler.handle(nextState, cloneCanonical(signal));
+            }
+        }
+        state.dispatchedSignals.push(cloneCanonical(signal));
+    }
+    const dueSequences = new Set(due.map((message) => message.sequence));
+    for (let index = state.runtimeSignals.length - 1; index >= 0; index -= 1) {
+        if (dueSequences.has(state.runtimeSignals[index].sequence)) {
+            state.runtimeSignals.splice(index, 1);
+        }
+    }
+    return nextState;
+}
+function compareRuntimeSignalHandlers(left, right) {
+    return left.order - right.order || compareStrings(left.id, right.id);
+}
+function compareRuntimeMessages(left, right) {
+    /* istanbul ignore next -- runtime message ordering tests cover frame and sequence sort arms. */
+    return left.frame - right.frame || left.sequence - right.sequence || compareStrings(left.type, right.type);
+}
+function createEntity(state) {
+    const id = state.freeEntityIds.length === 0 ? state.nextEntityId : state.freeEntityIds.shift();
+    if (id === state.nextEntityId) {
+        state.nextEntityId += 1;
+    }
+    const generation = state.generations.get(id) ?? 1;
+    state.generations.set(id, generation);
+    return { id, generation };
+}
+function createSparseEntity(state) {
+    const id = state.freeEntityIds.length === 0 ? state.nextEntityId : state.freeEntityIds.shift();
+    if (id === state.nextEntityId) {
+        state.nextEntityId += 1;
+    }
+    const generation = state.generations.get(id) ?? 1;
+    state.generations.set(id, generation);
+    return { id, generation };
+}
+function destroyEntity(state, entity) {
+    assertLiveEntity(state, entity);
+    for (const storage of state.components.values()) {
+        storage.delete(entity.id);
+    }
+    state.generations.set(entity.id, entity.generation + 1);
+    state.freeEntityIds.push(entity.id);
+    state.freeEntityIds.sort((left, right) => left - right);
+}
+function destroySparseEntity(state, entity) {
+    assertLiveSparseEntity(state, entity);
+    for (const storage of state.componentStores.values()) {
+        if (storage.has(entity.id)) {
+            storage.remove(entity.id);
+        }
+    }
+    state.generations.set(entity.id, entity.generation + 1);
+    state.freeEntityIds.push(entity.id);
+    state.freeEntityIds.sort((left, right) => left - right);
+}
+function setComponent(state, componentDescriptors, assetRefs, entity, componentId, data) {
+    assertLiveEntity(state, entity);
+    const descriptor = componentDescriptors.get(componentId);
+    if (descriptor === undefined || descriptor.singleton === true) {
+        throw new Error(`Unknown entity component ${componentId}`);
+    }
+    state.components.get(componentId).set(entity.id, normalizeComponentData(descriptor, data, assetRefs));
+}
+function setSparseComponent(state, componentDescriptors, assetRefs, entity, componentId, data) {
+    assertLiveSparseEntity(state, entity);
+    const descriptor = componentDescriptors.get(componentId);
+    if (descriptor === undefined || descriptor.singleton === true) {
+        throw new Error(`Unknown entity component ${componentId}`);
+    }
+    const storage = state.componentStores.get(componentId);
+    /* istanbul ignore next -- sparse stores are constructed from the validated component descriptor set. */
+    if (storage === undefined) {
+        throw new Error(`Missing sparse component storage ${componentId}`);
+    }
+    const normalized = normalizeComponentData(descriptor, data, assetRefs);
+    if (storage.has(entity.id)) {
+        storage.set(entity.id, normalized);
+    }
+    else {
+        storage.add(entity.id, normalized);
+    }
+}
+function runtimeHostApisAreRejected(descriptor, seed, sparse) {
+    const runtime = sparse
+        ? createDeterministicSparseSetFrameRuntime(descriptor, seed)
+        : createDeterministicFrameRuntime(descriptor, seed);
+    const systemId = descriptor.systems[0]?.id;
+    /* istanbul ignore next -- exported guard fixture descriptors always contain a system. */
+    if (systemId === undefined) {
+        throw new Error('Deterministic runtime host API guard fixture requires a system descriptor');
+    }
+    const systems = {
+        [systemId]() {
+            // rdm-ignore-next-line determinism/no-math-random: runtime guard fixture intentionally probes host RNG blocking
+            const random = Reflect.get(Math, 'random');
+            random();
+        },
+    };
+    try {
+        runtime.step(systems);
+        /* istanbul ignore next -- self-check failure path only runs if runtime host guards regress. */
+        return false;
+    }
+    catch (error) {
+        return error instanceof Error && /Math\.random\(\) is not allowed during deterministic step/.test(error.message);
+    }
+}
+function removeComponent(state, entity, componentId) {
+    assertLiveEntity(state, entity);
+    state.components.get(componentId)?.delete(entity.id);
+}
+function removeSparseComponent(state, entity, componentId) {
+    assertLiveSparseEntity(state, entity);
+    const storage = state.componentStores.get(componentId);
+    if (storage?.has(entity.id) === true) {
+        storage.remove(entity.id);
+    }
+}
+function assertKnownFrameComponent(componentDescriptors, componentId) {
+    const descriptor = componentDescriptors.get(componentId);
+    if (descriptor === undefined || descriptor.singleton === true) {
+        throw new Error(`Unknown component ${componentId}`);
+    }
+}
+function assertKnownFrameComponents(componentDescriptors, componentIds) {
+    for (const componentId of componentIds) {
+        assertKnownFrameComponent(componentDescriptors, componentId);
+    }
+}
+function queryFilterComponentIds(filter) {
+    return [...new Set([...(filter.all ?? []), ...(filter.any ?? []), ...(filter.without ?? [])])];
+}
+function setSingleton(state, componentDescriptors, assetRefs, componentId, data) {
+    const descriptor = componentDescriptors.get(componentId);
+    if (descriptor === undefined || descriptor.singleton !== true) {
+        throw new Error(`Unknown singleton component ${componentId}`);
+    }
+    state.singletonComponents.set(componentId, normalizeComponentData(descriptor, data, assetRefs));
+}
+function setSparseSingleton(state, componentDescriptors, assetRefs, componentId, data) {
+    const descriptor = componentDescriptors.get(componentId);
+    if (descriptor === undefined || descriptor.singleton !== true) {
+        throw new Error(`Unknown singleton component ${componentId}`);
+    }
+    state.singletonComponents.set(componentId, normalizeComponentData(descriptor, data, assetRefs));
+}
+function queryComponents(state, componentIds) {
+    const normalizedIds = [...new Set(componentIds)].sort(compareStrings);
+    if (normalizedIds.length === 0) {
+        return [];
+    }
+    const primary = state.components.get(normalizedIds[0]);
+    /* istanbul ignore next -- public callers validate component ids before querying map storage. */
+    if (primary === undefined) {
+        return [];
+    }
+    return [...primary.keys()]
+        .sort((left, right) => left - right)
+        .filter((entityId) => normalizedIds.every((componentId) => state.components.get(componentId)?.has(entityId) === true))
+        .map((entityId) => ({
+        entity: { id: entityId, generation: state.generations.get(entityId) },
+        components: Object.fromEntries(normalizedIds.map((componentId) => [componentId, cloneCanonical(state.components.get(componentId).get(entityId))])),
+    }));
+}
+function querySparseComponents(state, componentIds) {
+    const normalizedIds = [...new Set(componentIds)].sort(compareStrings);
+    if (normalizedIds.length === 0) {
+        return [];
+    }
+    const primary = state.componentStores.get(normalizedIds[0]);
+    /* istanbul ignore next -- public callers validate component ids before querying sparse storage. */
+    if (primary === undefined) {
+        return [];
+    }
+    return primary.query()
+        .filter((entry) => normalizedIds.every((componentId) => state.componentStores.get(componentId)?.has(entry.id) === true))
+        .map((entry) => ({
+        entity: { id: entry.id, generation: state.generations.get(entry.id) },
+        components: Object.fromEntries(normalizedIds.map((componentId) => [componentId, state.componentStores.get(componentId).get(entry.id)])),
+    }));
+}
+function queryComponentFilter(state, filter) {
+    const normalized = normalizeQueryFilter(filter);
+    const candidateIds = componentFilterCandidateIds(normalized, (componentId) => state.components.get(componentId)?.keys());
+    return candidateIds
+        .filter((entityId) => entityMatchesComponentFilter(normalized, entityId, (componentId) => state.components.get(componentId)?.has(entityId) === true))
+        .map((entityId) => ({
+        entity: { id: entityId, generation: state.generations.get(entityId) },
+        components: Object.fromEntries([...new Set([...normalized.all, ...normalized.any])]
+            .sort(compareStrings)
+            .filter((componentId) => state.components.get(componentId)?.has(entityId) === true)
+            .map((componentId) => [componentId, cloneCanonical(state.components.get(componentId).get(entityId))])),
+    }));
+}
+function querySparseComponentFilter(state, filter) {
+    const normalized = normalizeQueryFilter(filter);
+    const candidateIds = componentFilterCandidateIds(normalized, (componentId) => state.componentStores.get(componentId)?.query().map((entry) => entry.id));
+    return candidateIds
+        .filter((entityId) => entityMatchesComponentFilter(normalized, entityId, (componentId) => state.componentStores.get(componentId)?.has(entityId) === true))
+        .map((entityId) => ({
+        entity: { id: entityId, generation: state.generations.get(entityId) },
+        components: Object.fromEntries([...new Set([...normalized.all, ...normalized.any])]
+            .sort(compareStrings)
+            .filter((componentId) => state.componentStores.get(componentId)?.has(entityId) === true)
+            .map((componentId) => [componentId, state.componentStores.get(componentId).get(entityId)])),
+    }));
+}
+function normalizeQueryFilter(filter) {
+    return {
+        all: [...new Set(filter.all ?? [])].sort(compareStrings),
+        any: [...new Set(filter.any ?? [])].sort(compareStrings),
+        without: [...new Set(filter.without ?? [])].sort(compareStrings),
+    };
+}
+function componentFilterCandidateIds(filter, idsForComponent) {
+    const requiredIds = filter.all.length > 0 ? filter.all : filter.any;
+    if (requiredIds.length === 0) {
+        return [];
+    }
+    const idSet = new Set();
+    for (const componentId of requiredIds) {
+        /* istanbul ignore next -- public callers validate filter component ids before candidate lookup. */
+        for (const entityId of idsForComponent(componentId) ?? []) {
+            idSet.add(entityId);
+        }
+    }
+    return [...idSet].sort((left, right) => left - right);
+}
+function entityMatchesComponentFilter(filter, entityId, hasComponent) {
+    return filter.all.every(hasComponent)
+        && (filter.any.length === 0 || filter.any.some(hasComponent))
+        && filter.without.every((componentId) => !hasComponent(componentId));
+}
+function createFrameHeap() {
+    return {
+        nextHandleId: 1,
+        freeHandleIds: [],
+        generations: new Map(),
+        collections: new Map(),
+    };
+}
+function allocateFrameHeapList(heap, values) {
+    const handle = allocateFrameHeapHandle(heap, 'list');
+    heap.collections.set(handle.id, {
+        kind: 'list',
+        generation: handle.generation,
+        values: normalizeFrameHeapListValues(values),
+    });
+    return handle;
+}
+function resolveFrameHeapList(heap, handle) {
+    return frameHeapCollectionOrThrow(heap, handle, 'list').values.map((value) => cloneCanonical(value));
+}
+function setFrameHeapList(heap, handle, values) {
+    frameHeapCollectionOrThrow(heap, handle, 'list').values = normalizeFrameHeapListValues(values);
+}
+function allocateFrameHeapDictionary(heap, entries) {
+    const handle = allocateFrameHeapHandle(heap, 'dictionary');
+    heap.collections.set(handle.id, {
+        kind: 'dictionary',
+        generation: handle.generation,
+        entries: new Map(dictionaryEntriesFromRecord(entries).map((entry) => [entry.key, entry.value])),
+    });
+    return handle;
+}
+function resolveFrameHeapDictionary(heap, handle) {
+    return dictionaryRecordFromEntries([...frameHeapCollectionOrThrow(heap, handle, 'dictionary').entries.entries()]
+        .sort((left, right) => compareStrings(left[0], right[0]))
+        .map(([key, value]) => ({ key, value })));
+}
+function setFrameHeapDictionaryValue(heap, handle, key, value) {
+    assertFrameHeapDictionaryKey(key);
+    frameHeapCollectionOrThrow(heap, handle, 'dictionary').entries.set(key, cloneCanonical(value));
+}
+function deleteFrameHeapDictionaryValue(heap, handle, key) {
+    assertFrameHeapDictionaryKey(key);
+    frameHeapCollectionOrThrow(heap, handle, 'dictionary').entries.delete(key);
+}
+function allocateFrameHeapHashSet(heap, values) {
+    const handle = allocateFrameHeapHandle(heap, 'hash-set');
+    heap.collections.set(handle.id, {
+        kind: 'hash-set',
+        generation: handle.generation,
+        values: normalizeFrameHeapHashSetValues(values),
+    });
+    return handle;
+}
+function resolveFrameHeapHashSet(heap, handle) {
+    return frameHeapCollectionOrThrow(heap, handle, 'hash-set').values.map((value) => cloneCanonical(value));
+}
+function addFrameHeapHashSetValue(heap, handle, value) {
+    const collection = frameHeapCollectionOrThrow(heap, handle, 'hash-set');
+    collection.values = normalizeFrameHeapHashSetValues([...collection.values, value]);
+}
+function deleteFrameHeapHashSetValue(heap, handle, value) {
+    const collection = frameHeapCollectionOrThrow(heap, handle, 'hash-set');
+    const encoded = canonicalStringify(value);
+    collection.values = collection.values.filter((existing) => canonicalStringify(existing) !== encoded);
+}
+function freeFrameHeapCollection(heap, handle) {
+    frameHeapCollectionOrThrow(heap, handle, handle.kind);
+    heap.collections.delete(handle.id);
+    heap.generations.set(handle.id, handle.generation + 1);
+    heap.freeHandleIds.push(handle.id);
+    heap.freeHandleIds.sort((left, right) => left - right);
+}
+function snapshotFrameHeap(heap) {
+    const generations = Object.fromEntries([...heap.generations.entries()]
+        .sort((left, right) => left[0] - right[0])
+        .map(([id, generation]) => [String(id), generation]));
+    const collections = Object.fromEntries([...heap.collections.entries()]
+        .sort((left, right) => left[0] - right[0])
+        .map(([id, collection]) => [String(id), snapshotFrameHeapCollection(collection)]));
+    return {
+        nextHandleId: heap.nextHandleId,
+        freeHandleIds: [...heap.freeHandleIds],
+        generations,
+        collections,
+    };
+}
+function restoreFrameHeap(snapshot) {
+    validateFrameHeapSnapshot(snapshot);
+    const heap = createFrameHeap();
+    heap.nextHandleId = snapshot.nextHandleId;
+    heap.freeHandleIds.push(...snapshot.freeHandleIds);
+    for (const id of stableKeys(snapshot.generations)) {
+        heap.generations.set(Number(id), snapshot.generations[id]);
+    }
+    for (const id of stableKeys(snapshot.collections)) {
+        heap.collections.set(Number(id), restoreFrameHeapCollection(snapshot.collections[id]));
+    }
+    return heap;
+}
+function validateFrameHeapSnapshot(snapshot) {
+    if (!Number.isInteger(snapshot.nextHandleId) || snapshot.nextHandleId < 1) {
+        throw new Error('Deterministic frame heap snapshot has invalid nextHandleId');
+    }
+    assertSortedUniqueIntegerList(snapshot.freeHandleIds, 'Deterministic frame heap freeHandleIds');
+    const freeIds = new Set(snapshot.freeHandleIds);
+    for (const id of stableKeys(snapshot.generations)) {
+        const numericId = Number(id);
+        const generation = snapshot.generations[id];
+        if (!Number.isInteger(numericId) || numericId < 1 || String(numericId) !== id || !Number.isInteger(generation) || generation < 1) {
+            throw new Error(`Deterministic frame heap snapshot has invalid generation for handle ${id}`);
+        }
+    }
+    for (const id of stableKeys(snapshot.collections)) {
+        const numericId = Number(id);
+        const generation = snapshot.generations[id];
+        if (!Number.isInteger(numericId) || numericId < 1 || String(numericId) !== id) {
+            throw new Error(`Deterministic frame heap snapshot has invalid collection id ${id}`);
+        }
+        if (freeIds.has(numericId)) {
+            throw new Error(`Deterministic frame heap snapshot collection ${id} is also free`);
+        }
+        if (generation === undefined) {
+            throw new Error(`Deterministic frame heap snapshot collection ${id} is missing generation`);
+        }
+        validateFrameHeapCollectionSnapshot(snapshot.collections[id]);
+        if (snapshot.collections[id].generation !== generation) {
+            throw new Error(`Deterministic frame heap snapshot collection ${id} generation mismatch`);
+        }
+    }
+}
+function allocateFrameHeapHandle(heap, kind) {
+    const id = heap.freeHandleIds.length === 0 ? heap.nextHandleId : heap.freeHandleIds.shift();
+    if (id === heap.nextHandleId) {
+        heap.nextHandleId += 1;
+    }
+    const generation = heap.generations.get(id) ?? 1;
+    heap.generations.set(id, generation);
+    return { id, generation, kind };
+}
+function frameHeapCollectionOrThrow(heap, handle, kind) {
+    if (!Number.isInteger(handle.id) || handle.id < 1 || !Number.isInteger(handle.generation) || handle.generation < 1 || handle.kind !== kind) {
+        throw new Error('Invalid deterministic frame heap handle');
+    }
+    const collection = heap.collections.get(handle.id);
+    const generation = heap.generations.get(handle.id);
+    if (collection === undefined || generation !== handle.generation || collection.generation !== handle.generation) {
+        throw new Error(`Stale deterministic frame heap handle ${handle.id}:${handle.generation}`);
+    }
+    /* istanbul ignore next -- handle kind and collection kind are created/restored from validated heap state. */
+    if (collection.kind !== kind) {
+        throw new Error(`Deterministic frame heap handle ${handle.id}:${handle.generation} expected ${kind} but found ${collection.kind}`);
+    }
+    return collection;
+}
+function snapshotFrameHeapCollection(collection) {
+    if (collection.kind === 'list') {
+        return {
+            kind: 'list',
+            generation: collection.generation,
+            values: normalizeFrameHeapListValues(collection.values),
+        };
+    }
+    if (collection.kind === 'dictionary') {
+        return {
+            kind: 'dictionary',
+            generation: collection.generation,
+            entries: [...collection.entries.entries()]
+                .sort((left, right) => compareStrings(left[0], right[0]))
+                .map(([key, value]) => ({ key, value: cloneCanonical(value) })),
+        };
+    }
+    return {
+        kind: 'hash-set',
+        generation: collection.generation,
+        values: normalizeFrameHeapHashSetValues(collection.values),
+    };
+}
+function restoreFrameHeapCollection(snapshot) {
+    if (snapshot.kind === 'list') {
+        return {
+            kind: 'list',
+            generation: snapshot.generation,
+            values: normalizeFrameHeapListValues(snapshot.values),
+        };
+    }
+    if (snapshot.kind === 'dictionary') {
+        return {
+            kind: 'dictionary',
+            generation: snapshot.generation,
+            entries: new Map(snapshot.entries.map((entry) => [entry.key, cloneCanonical(entry.value)])),
+        };
+    }
+    return {
+        kind: 'hash-set',
+        generation: snapshot.generation,
+        values: normalizeFrameHeapHashSetValues(snapshot.values),
+    };
+}
+function validateFrameHeapCollectionSnapshot(snapshot) {
+    if (!Number.isInteger(snapshot.generation) || snapshot.generation < 1) {
+        throw new Error('Deterministic frame heap collection has invalid generation');
+    }
+    if (snapshot.kind === 'list') {
+        if (!Array.isArray(snapshot.values)) {
+            throw new Error('Deterministic frame heap list must contain values');
+        }
+        return;
+    }
+    if (snapshot.kind === 'dictionary') {
+        let previousKey = '';
+        const keys = new Set();
+        for (const [index, entry] of snapshot.entries.entries()) {
+            assertFrameHeapDictionaryKey(entry.key);
+            if (keys.has(entry.key)) {
+                throw new Error(`Deterministic frame heap dictionary has duplicate key ${entry.key}`);
+            }
+            if (index > 0 && compareStrings(previousKey, entry.key) >= 0) {
+                throw new Error('Deterministic frame heap dictionary entries must be sorted by key');
+            }
+            previousKey = entry.key;
+            keys.add(entry.key);
+        }
+        return;
+    }
+    if (snapshot.kind === 'hash-set') {
+        assertCanonicalValuesSortedUnique(snapshot.values, 'Deterministic frame heap hash-set values');
+        return;
+    }
+    throw new Error('Deterministic frame heap collection has invalid kind');
+}
+function normalizeFrameHeapListValues(values) {
+    return values.map((value) => cloneCanonical(value));
+}
+function normalizeFrameHeapHashSetValues(values) {
+    const byEncoded = new Map();
+    for (const value of values) {
+        byEncoded.set(canonicalStringify(value), cloneCanonical(value));
+    }
+    return [...byEncoded.entries()]
+        .sort((left, right) => compareStrings(left[0], right[0]))
+        .map(([, value]) => value);
+}
+function dictionaryEntriesFromRecord(entries) {
+    return stableKeys(entries).map((key) => {
+        assertFrameHeapDictionaryKey(key);
+        return { key, value: cloneCanonical(entries[key]) };
+    });
+}
+function dictionaryRecordFromEntries(entries) {
+    return Object.fromEntries(entries.map((entry) => {
+        assertFrameHeapDictionaryKey(entry.key);
+        return [entry.key, cloneCanonical(entry.value)];
+    }));
+}
+function assertFrameHeapDictionaryKey(key) {
+    if (!isNonEmptyString(key)) {
+        throw new Error('Deterministic frame heap dictionary key must be non-empty string');
+    }
+}
+function assertSortedUniqueIntegerList(values, label) {
+    let previous = 0;
+    const seen = new Set();
+    for (const [index, value] of values.entries()) {
+        /* istanbul ignore next -- current callers validate out-of-range ids before this sortedness helper is reached. */
+        if (!Number.isInteger(value) || value < 1) {
+            throw new Error(`${label} contains invalid id`);
+        }
+        if (seen.has(value)) {
+            throw new Error(`${label} contains duplicate id ${value}`);
+        }
+        if (index > 0 && previous >= value) {
+            throw new Error(`${label} must be sorted`);
+        }
+        previous = value;
+        seen.add(value);
+    }
+}
+function assertCanonicalValuesSortedUnique(values, label) {
+    let previous = '';
+    const seen = new Set();
+    for (const [index, value] of values.entries()) {
+        const encoded = canonicalStringify(value);
+        if (seen.has(encoded)) {
+            throw new Error(`${label} contains duplicate value`);
+        }
+        if (index > 0 && compareStrings(previous, encoded) >= 0) {
+            throw new Error(`${label} must be sorted`);
+        }
+        previous = encoded;
+        seen.add(encoded);
+    }
+}
+function snapshotState(state) {
+    const payload = {
+        frame: state.frame,
+        nextEntityId: state.nextEntityId,
+        freeEntityIds: [...state.freeEntityIds],
+        generations: Object.fromEntries([...state.generations.entries()].sort((left, right) => left[0] - right[0]).map(([id, generation]) => [String(id), generation])),
+        components: Object.fromEntries([...state.components.entries()].sort(compareMapStringEntry).map(([componentId, storage]) => [
+            componentId,
+            Object.fromEntries([...storage.entries()].sort((left, right) => left[0] - right[0]).map(([id, data]) => [String(id), data])),
+        ])),
+        singletonComponents: Object.fromEntries([...state.singletonComponents.entries()].sort(compareMapStringEntry)),
+        frameHeap: snapshotFrameHeap(state.frameHeap),
+        debugEvents: state.debugEvents.map((event) => cloneCanonical(event)),
+        runtimeEvents: state.runtimeEvents.map((message) => cloneCanonical(message)),
+        runtimeSignals: state.runtimeSignals.map((message) => cloneCanonical(message)),
+        dispatchedSignals: state.dispatchedSignals.map((message) => cloneCanonical(message)),
+        nextRuntimeMessageSequence: state.nextRuntimeMessageSequence,
+        ...(state.commandTimeline === undefined ? {} : { commandTimeline: state.commandTimeline.snapshot() }),
+        randomState: state.random.snapshot().state,
+    };
+    const bytes = canonicalStringify(payload);
+    return {
+        ...payload,
+        bytes,
+        checksum: defaultChecksum(bytes),
+    };
+}
+function snapshotSparseState(state) {
+    const payload = {
+        frame: state.frame,
+        nextEntityId: state.nextEntityId,
+        freeEntityIds: [...state.freeEntityIds],
+        generations: Object.fromEntries([...state.generations.entries()].sort((left, right) => left[0] - right[0]).map(([id, generation]) => [String(id), generation])),
+        components: Object.fromEntries([...state.componentStores.entries()].sort(compareMapStringEntry).map(([componentId, storage]) => [
+            componentId,
+            Object.fromEntries(storage.query().map((entry) => [String(entry.id), entry.value])),
+        ])),
+        singletonComponents: Object.fromEntries([...state.singletonComponents.entries()].sort(compareMapStringEntry)),
+        frameHeap: snapshotFrameHeap(state.frameHeap),
+        debugEvents: state.debugEvents.map((event) => cloneCanonical(event)),
+        runtimeEvents: state.runtimeEvents.map((message) => cloneCanonical(message)),
+        runtimeSignals: state.runtimeSignals.map((message) => cloneCanonical(message)),
+        dispatchedSignals: state.dispatchedSignals.map((message) => cloneCanonical(message)),
+        nextRuntimeMessageSequence: state.nextRuntimeMessageSequence,
+        ...(state.commandTimeline === undefined ? {} : { commandTimeline: state.commandTimeline.snapshot() }),
+        randomState: state.random.snapshot().state,
+    };
+    const bytes = canonicalStringify(payload);
+    return {
+        ...payload,
+        bytes,
+        checksum: defaultChecksum(bytes),
+    };
+}
+function restoreState(state, componentDescriptors, assetRefs, snapshot) {
+    validateSnapshotIntegrity(componentDescriptors, snapshot, assetRefs);
+    state.frame = snapshot.frame;
+    state.nextEntityId = snapshot.nextEntityId;
+    state.freeEntityIds.splice(0, state.freeEntityIds.length, ...snapshot.freeEntityIds);
+    state.generations.clear();
+    for (const id of stableKeys(snapshot.generations)) {
+        state.generations.set(Number(id), snapshot.generations[id]);
+    }
+    state.components.clear();
+    for (const componentId of stableKeys(snapshot.components)) {
+        const entries = snapshot.components[componentId];
+        state.components.set(componentId, new Map(stableKeys(entries).map((id) => [Number(id), entries[id]])));
+    }
+    state.singletonComponents.clear();
+    for (const componentId of stableKeys(snapshot.singletonComponents)) {
+        state.singletonComponents.set(componentId, snapshot.singletonComponents[componentId]);
+    }
+    state.frameHeap = restoreFrameHeap(snapshot.frameHeap);
+    state.debugEvents.splice(0, state.debugEvents.length, ...snapshot.debugEvents.map((event) => cloneCanonical(event)));
+    state.runtimeEvents.splice(0, state.runtimeEvents.length, ...snapshot.runtimeEvents.map((message) => cloneCanonical(message)));
+    state.runtimeSignals.splice(0, state.runtimeSignals.length, ...snapshot.runtimeSignals.map((message) => cloneCanonical(message)));
+    state.dispatchedSignals.splice(0, state.dispatchedSignals.length, ...snapshot.dispatchedSignals.map((message) => cloneCanonical(message)));
+    state.nextRuntimeMessageSequence = snapshot.nextRuntimeMessageSequence;
+    restoreCommandTimelineIfConfigured(state.commandTimeline, snapshot);
+    state.random.restore({ state: snapshot.randomState });
+}
+function restoreSparseState(state, componentDescriptors, assetRefs, descriptor, capacity, snapshot) {
+    validateSnapshotIntegrity(componentDescriptors, snapshot, assetRefs);
+    state.frame = snapshot.frame;
+    state.nextEntityId = snapshot.nextEntityId;
+    state.freeEntityIds.splice(0, state.freeEntityIds.length, ...snapshot.freeEntityIds);
+    state.generations.clear();
+    for (const id of stableKeys(snapshot.generations)) {
+        state.generations.set(Number(id), snapshot.generations[id]);
+    }
+    state.componentStores = createSparseComponentStores(descriptor, capacity);
+    for (const componentId of stableKeys(snapshot.components)) {
+        const storage = state.componentStores.get(componentId);
+        /* istanbul ignore next -- snapshot integrity validates component storage before sparse restore. */
+        if (storage === undefined) {
+            throw new Error(`Missing sparse component storage ${componentId}`);
+        }
+        const entries = snapshot.components[componentId];
+        for (const entityId of stableKeys(entries)) {
+            storage.add(Number(entityId), entries[entityId]);
+        }
+    }
+    state.singletonComponents.clear();
+    for (const componentId of stableKeys(snapshot.singletonComponents)) {
+        state.singletonComponents.set(componentId, snapshot.singletonComponents[componentId]);
+    }
+    state.frameHeap = restoreFrameHeap(snapshot.frameHeap);
+    state.debugEvents.splice(0, state.debugEvents.length, ...snapshot.debugEvents.map((event) => cloneCanonical(event)));
+    state.runtimeEvents.splice(0, state.runtimeEvents.length, ...snapshot.runtimeEvents.map((message) => cloneCanonical(message)));
+    state.runtimeSignals.splice(0, state.runtimeSignals.length, ...snapshot.runtimeSignals.map((message) => cloneCanonical(message)));
+    state.dispatchedSignals.splice(0, state.dispatchedSignals.length, ...snapshot.dispatchedSignals.map((message) => cloneCanonical(message)));
+    state.nextRuntimeMessageSequence = snapshot.nextRuntimeMessageSequence;
+    restoreCommandTimelineIfConfigured(state.commandTimeline, snapshot);
+    state.random.restore({ state: snapshot.randomState });
+}
+function createSparseComponentStores(descriptor, capacity) {
+    return new Map(descriptor.components
+        .filter((component) => component.singleton !== true)
+        .map((component) => [component.id, createDeterministicSparseSet(capacity)]));
+}
+function validateSnapshotIntegrity(componentDescriptors, snapshot, assetRefs) {
+    const payload = {
+        frame: snapshot.frame,
+        nextEntityId: snapshot.nextEntityId,
+        freeEntityIds: snapshot.freeEntityIds,
+        generations: snapshot.generations,
+        components: snapshot.components,
+        singletonComponents: snapshot.singletonComponents,
+        frameHeap: snapshot.frameHeap,
+        debugEvents: snapshot.debugEvents,
+        runtimeEvents: snapshot.runtimeEvents,
+        runtimeSignals: snapshot.runtimeSignals,
+        dispatchedSignals: snapshot.dispatchedSignals,
+        nextRuntimeMessageSequence: snapshot.nextRuntimeMessageSequence,
+        ...(snapshot.commandTimeline === undefined ? {} : { commandTimeline: snapshot.commandTimeline }),
+        randomState: snapshot.randomState,
+    };
+    const bytes = canonicalStringify(payload);
+    if (bytes !== snapshot.bytes || defaultChecksum(bytes) !== snapshot.checksum) {
+        throw new Error('Deterministic frame snapshot checksum mismatch');
+    }
+    validateSnapshotEntityAllocator(snapshot);
+    for (const componentId of stableKeys(snapshot.components)) {
+        const descriptor = componentDescriptors.get(componentId);
+        if (descriptor === undefined || descriptor.singleton === true) {
+            throw new Error(`Deterministic frame snapshot contains incompatible component storage ${componentId}`);
+        }
+        const componentEntries = snapshot.components[componentId];
+        for (const entityId of stableKeys(componentEntries)) {
+            validateComponentData(descriptor, componentEntries[entityId], assetRefs);
+        }
+    }
+    for (const componentId of stableKeys(snapshot.singletonComponents)) {
+        const descriptor = componentDescriptors.get(componentId);
+        if (descriptor === undefined || descriptor.singleton !== true) {
+            throw new Error(`Deterministic frame snapshot contains incompatible singleton storage ${componentId}`);
+        }
+        validateComponentData(descriptor, snapshot.singletonComponents[componentId], assetRefs);
+    }
+    validateFrameHeapSnapshot(snapshot.frameHeap);
+    if (snapshot.commandTimeline !== undefined) {
+        const commandPayload = {
+            currentFrame: snapshot.commandTimeline.currentFrame,
+            accepted: snapshot.commandTimeline.accepted,
+            rejected: snapshot.commandTimeline.rejected,
+        };
+        if (defaultChecksum(commandPayload) !== snapshot.commandTimeline.checksum) {
+            throw new Error('Deterministic frame snapshot command timeline checksum mismatch');
+        }
+    }
+}
+function validateSnapshotEntityAllocator(snapshot) {
+    if (!Number.isInteger(snapshot.nextEntityId) || snapshot.nextEntityId < 1) {
+        throw new Error('Deterministic frame snapshot has invalid next entity id');
+    }
+    const liveEntityIds = new Set();
+    for (const componentId of stableKeys(snapshot.components)) {
+        const componentEntries = snapshot.components[componentId];
+        for (const entityIdText of stableKeys(componentEntries)) {
+            const entityId = parseSnapshotEntityId(entityIdText);
+            if (entityId >= snapshot.nextEntityId) {
+                throw new Error(`Deterministic frame snapshot component ${componentId} references entity outside allocator range ${entityId}`);
+            }
+            liveEntityIds.add(entityId);
+        }
+    }
+    let previousFreeId = 0;
+    for (const entityId of snapshot.freeEntityIds) {
+        if (!Number.isInteger(entityId) || entityId < 1 || entityId >= snapshot.nextEntityId || entityId <= previousFreeId) {
+            throw new Error('Deterministic frame snapshot has invalid free entity ids');
+        }
+        if (snapshot.generations[String(entityId)] === undefined) {
+            throw new Error(`Deterministic frame snapshot free entity ${entityId} is missing generation`);
+        }
+        if (liveEntityIds.has(entityId)) {
+            throw new Error(`Deterministic frame snapshot free entity ${entityId} still has components`);
+        }
+        previousFreeId = entityId;
+    }
+    for (const entityIdText of stableKeys(snapshot.generations)) {
+        const entityId = parseSnapshotEntityId(entityIdText);
+        if (entityId >= snapshot.nextEntityId) {
+            throw new Error(`Deterministic frame snapshot generation references entity outside allocator range ${entityId}`);
+        }
+        const generation = snapshot.generations[entityIdText];
+        if (!Number.isInteger(generation) || generation < 1) {
+            throw new Error(`Deterministic frame snapshot has invalid generation for entity ${entityId}`);
+        }
+    }
+    for (const entityId of liveEntityIds) {
+        if (snapshot.generations[String(entityId)] === undefined) {
+            throw new Error(`Deterministic frame snapshot live entity ${entityId} is missing generation`);
+        }
+    }
+}
+function parseSnapshotEntityId(entityIdText) {
+    if (!/^[1-9][0-9]*$/.test(entityIdText)) {
+        throw new Error(`Deterministic frame snapshot has invalid entity id ${entityIdText}`);
+    }
+    return Number(entityIdText);
+}
+function commandTimelineOrThrow(commandTimeline) {
+    if (commandTimeline === undefined) {
+        throw new Error('Deterministic frame runtime command timeline is not configured');
+    }
+    return commandTimeline;
+}
+function restoreCommandTimelineIfConfigured(commandTimeline, snapshot) {
+    if (commandTimeline === undefined) {
+        if (snapshot.commandTimeline !== undefined) {
+            throw new Error('Deterministic frame snapshot contains command timeline but runtime is not configured for commands');
+        }
+        return;
+    }
+    if (snapshot.commandTimeline === undefined) {
+        throw new Error('Deterministic frame snapshot is missing command timeline');
+    }
+    commandTimeline.restore(snapshot.commandTimeline);
+}
+function assertLiveEntity(state, entity) {
+    if (state.generations.get(entity.id) !== entity.generation || state.freeEntityIds.includes(entity.id)) {
+        throw new Error(`Stale deterministic entity ref ${entity.id}:${entity.generation}`);
+    }
+}
+function assertLiveSparseEntity(state, entity) {
+    if (state.generations.get(entity.id) !== entity.generation || state.freeEntityIds.includes(entity.id)) {
+        throw new Error(`Stale deterministic entity ref ${entity.id}:${entity.generation}`);
+    }
+}
+function validateRuntimeDescriptor(descriptor) {
+    if (!isNonEmptyString(descriptor.id)) {
+        throw new Error('Deterministic runtime descriptor requires a non-empty id');
+    }
+    if (!Number.isInteger(descriptor.tickRate) || descriptor.tickRate <= 0) {
+        throw new Error(`Deterministic runtime descriptor ${descriptor.id} has invalid tickRate`);
+    }
+    if (!Array.isArray(descriptor.components)) {
+        throw new Error(`Deterministic runtime descriptor ${descriptor.id} requires components`);
+    }
+    if (!Array.isArray(descriptor.systems)) {
+        throw new Error(`Deterministic runtime descriptor ${descriptor.id} requires systems`);
+    }
+    const componentIds = new Set();
+    for (const component of descriptor.components) {
+        if (!isNonEmptyString(component.id)) {
+            throw new Error('Deterministic component requires a non-empty id');
+        }
+        if (!Array.isArray(component.fields)) {
+            throw new Error(`Deterministic component ${component.id} requires fields`);
+        }
+        if (componentIds.has(component.id)) {
+            throw new Error(`Duplicate deterministic component ${component.id}`);
+        }
+        componentIds.add(component.id);
+        const fieldIds = new Set();
+        for (const field of component.fields) {
+            if (!isNonEmptyString(field.name)) {
+                throw new Error(`Deterministic component ${component.id} has a field with an invalid name`);
+            }
+            if (!isRuntimeFieldKind(field.kind)) {
+                throw new Error(`Deterministic component ${component.id}.${field.name} has invalid field kind ${String(field.kind)}`);
+            }
+            if (field.assetType !== undefined && (!isNonEmptyString(field.assetType) || !fieldContainsAssetRef(field.kind))) {
+                throw new Error(`Deterministic component ${component.id}.${field.name} has invalid asset type`);
+            }
+            if (fieldIds.has(field.name)) {
+                throw new Error(`Duplicate deterministic component field ${component.id}.${field.name}`);
+            }
+            fieldIds.add(field.name);
+            if (field.defaultValue !== undefined) {
+                assertDefaultValueMatchesRuntimeField(component.id, field.name, field.kind, field.defaultValue);
+            }
+        }
+    }
+    const systemIds = new Set();
+    for (const system of descriptor.systems) {
+        if (!isNonEmptyString(system.id)) {
+            throw new Error('Deterministic system requires a non-empty id');
+        }
+        if (!isSystemGroup(system.group)) {
+            throw new Error(`Deterministic system ${system.id} has invalid system group ${String(system.group)}`);
+        }
+        if (!Number.isInteger(system.order)) {
+            throw new Error(`Deterministic system ${system.id} has invalid system order`);
+        }
+        if (system.before !== undefined && !Array.isArray(system.before)) {
+            throw new Error(`Deterministic system ${system.id} before dependencies must be an array`);
+        }
+        if (system.after !== undefined && !Array.isArray(system.after)) {
+            throw new Error(`Deterministic system ${system.id} after dependencies must be an array`);
+        }
+        if (systemIds.has(system.id)) {
+            throw new Error(`Duplicate deterministic system ${system.id}`);
+        }
+        systemIds.add(system.id);
+    }
+    if (descriptor.commandChannels !== undefined && !Array.isArray(descriptor.commandChannels)) {
+        throw new Error(`Deterministic runtime descriptor ${descriptor.id} commandChannels must be an array`);
+    }
+    const channelIds = new Set();
+    for (const channel of descriptor.commandChannels ?? []) {
+        if (!isNonEmptyString(channel.id)) {
+            throw new Error('Deterministic command channel requires a non-empty id');
+        }
+        if (!Number.isInteger(channel.maxPayloadBytes) || channel.maxPayloadBytes <= 0) {
+            throw new Error(`Deterministic command channel ${channel.id} has invalid maxPayloadBytes`);
+        }
+        if (typeof channel.reliable !== 'boolean') {
+            throw new Error(`Deterministic command channel ${channel.id} has invalid reliable flag`);
+        }
+        if (typeof channel.allowPrediction !== 'boolean') {
+            throw new Error(`Deterministic command channel ${channel.id} has invalid allowPrediction flag`);
+        }
+        if (channel.minFrameLead !== undefined && (!Number.isInteger(channel.minFrameLead) || channel.minFrameLead < 0)) {
+            throw new Error(`Deterministic command channel ${channel.id} has invalid min frame lead`);
+        }
+        if (channel.maxFrameLead !== undefined && (!Number.isInteger(channel.maxFrameLead) || channel.maxFrameLead < 0)) {
+            throw new Error(`Deterministic command channel ${channel.id} has invalid max frame lead`);
+        }
+        if (channel.minFrameLead !== undefined && channel.maxFrameLead !== undefined && channel.minFrameLead > channel.maxFrameLead) {
+            throw new Error(`Deterministic command channel ${channel.id} has invalid frame lead range`);
+        }
+        if (channelIds.has(channel.id)) {
+            throw new Error(`Duplicate deterministic command channel ${channel.id}`);
+        }
+        channelIds.add(channel.id);
+    }
+    validateRuntimePayloadChannels('eventChannels', descriptor.eventChannels ?? []);
+    validateRuntimePayloadChannels('signalChannels', descriptor.signalChannels ?? []);
+}
+function validateRuntimePayloadChannels(label, channels) {
+    const ids = new Set();
+    for (const channel of channels) {
+        if (!isNonEmptyString(channel.id)) {
+            throw new Error(`Deterministic runtime ${label} entry requires a non-empty id`);
+        }
+        if (ids.has(channel.id)) {
+            throw new Error(`Duplicate deterministic runtime ${label} entry ${channel.id}`);
+        }
+        ids.add(channel.id);
+        const fieldIds = new Set();
+        for (const field of channel.fields) {
+            if (!isNonEmptyString(field.name)) {
+                throw new Error(`Deterministic runtime ${label} ${channel.id} has a field with an invalid name`);
+            }
+            if (!isRuntimeFieldKind(field.kind)) {
+                throw new Error(`Deterministic runtime ${label} ${channel.id}.${field.name} has invalid field kind ${String(field.kind)}`);
+            }
+            if (field.assetType !== undefined && (!isNonEmptyString(field.assetType) || !fieldContainsAssetRef(field.kind))) {
+                throw new Error(`Deterministic runtime ${label} ${channel.id}.${field.name} has invalid asset type`);
+            }
+            if (fieldIds.has(field.name)) {
+                throw new Error(`Duplicate deterministic runtime ${label} field ${channel.id}.${field.name}`);
+            }
+            fieldIds.add(field.name);
+            if (field.defaultValue !== undefined) {
+                assertDefaultValueMatchesRuntimeField(channel.id, field.name, field.kind, field.defaultValue);
+            }
+        }
+    }
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function isSystemGroup(value) {
+    return value === 'input'
+        || value === 'simulation'
+        || value === 'physics'
+        || value === 'post-physics'
+        || value === 'presentation';
+}
+function isRuntimeFieldKind(value) {
+    return value === 'int'
+        || value === 'fixed'
+        || value === 'bool'
+        || value === 'string'
+        || value === 'asset-ref'
+        || value === 'entity-ref'
+        || value === 'int[]'
+        || value === 'fixed[]'
+        || value === 'bool[]'
+        || value === 'string[]'
+        || value === 'asset-ref[]'
+        || value === 'entity-ref[]'
+        || (typeof value === 'string' && /^(int|fixed|bool|string|asset-ref|entity-ref)\[[1-9][0-9]*\]$/.test(value))
+        || value === 'frame-list'
+        || value === 'frame-dictionary'
+        || value === 'frame-hash-set';
+}
+function assertDefaultValueMatchesRuntimeField(componentId, fieldName, kind, value) {
+    try {
+        validateRuntimeValueForKind(componentId, fieldName, kind, value);
+    }
+    catch (error) {
+        /* istanbul ignore next -- default-value validators throw Error instances. */
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Component field ${componentId}.${fieldName} has invalid defaultValue: ${message}`);
+    }
+}
+function validateRuntimeValueForKind(componentId, fieldName, kind, value) {
+    if (kind === 'int' && (typeof value !== 'number' || !Number.isInteger(value))) {
+        throw new Error('expected integer');
+    }
+    if (kind === 'fixed' && (typeof value !== 'number' || !Number.isInteger(value))) {
+        throw new Error('expected quantized fixed integer ticks');
+    }
+    if (kind === 'bool' && typeof value !== 'boolean') {
+        throw new Error('expected boolean');
+    }
+    if ((kind === 'string' || kind === 'asset-ref') && typeof value !== 'string') {
+        throw new Error('expected string');
+    }
+    if (kind === 'entity-ref' && (typeof value !== 'number' || !Number.isInteger(value))) {
+        throw new Error('expected entity ref integer');
+    }
+    if (isRuntimeFrameHeapKind(kind)) {
+        validateRuntimeFrameHeapHandle(componentId, fieldName, kind, value);
+    }
+    if (isRuntimeArrayKind(kind) || isRuntimeFixedArrayKind(kind)) {
+        validateRuntimeArrayField(componentId, fieldName, kind, value);
+    }
+}
+function validateComponentData(descriptor, data, assetRefs) {
+    normalizeComponentData(descriptor, data, assetRefs);
+}
+function normalizeComponentData(descriptor, data, assetRefs) {
+    const fields = new Map(descriptor.fields.map((field) => [field.name, field]));
+    for (const key of stableKeys(data)) {
+        if (!fields.has(key)) {
+            throw new Error(`Unknown component field ${descriptor.id}.${key}`);
+        }
+    }
+    for (const field of descriptor.fields) {
+        const value = data[field.name] ?? field.defaultValue;
+        if (value === undefined) {
+            throw new Error(`Missing component field ${descriptor.id}.${field.name}`);
+        }
+        if (field.kind === 'int' && (!Number.isInteger(value) || typeof value !== 'number')) {
+            throw new Error(`Component field ${descriptor.id}.${field.name} must be an integer`);
+        }
+        if (field.kind === 'fixed' && (!Number.isInteger(value) || typeof value !== 'number')) {
+            throw new Error(`Component field ${descriptor.id}.${field.name} must be quantized fixed integer ticks`);
+        }
+        if (field.kind === 'bool' && typeof value !== 'boolean') {
+            throw new Error(`Component field ${descriptor.id}.${field.name} must be boolean`);
+        }
+        if (field.kind === 'string' && typeof value !== 'string') {
+            throw new Error(`Component field ${descriptor.id}.${field.name} must be string`);
+        }
+        if (field.kind === 'asset-ref' && typeof value !== 'string') {
+            throw new Error(`Component field ${descriptor.id}.${field.name} must be asset ref string`);
+        }
+        validateRuntimeAssetRefValue(descriptor.id, field, value, assetRefs);
+        if (field.kind === 'entity-ref' && (!Number.isInteger(value) || typeof value !== 'number')) {
+            throw new Error(`Component field ${descriptor.id}.${field.name} must be entity ref integer`);
+        }
+        if (isRuntimeFrameHeapKind(field.kind)) {
+            validateRuntimeFrameHeapHandle(descriptor.id, field.name, field.kind, value);
+        }
+        if (isRuntimeArrayKind(field.kind) || isRuntimeFixedArrayKind(field.kind)) {
+            validateRuntimeArrayField(descriptor.id, field.name, field.kind, value);
+        }
+    }
+    return Object.fromEntries(descriptor.fields.map((field) => [field.name, cloneCanonical(data[field.name] ?? field.defaultValue)]));
+}
+function validateRuntimeAssetRefValue(componentId, field, value, assetRefs) {
+    if (assetRefs === undefined || !fieldContainsAssetRef(field.kind)) {
+        return;
+    }
+    const values = assetRefValuesForRuntimeField(componentId, field, value);
+    const allowed = field.assetType === undefined ? assetRefs.allRefs : assetRefs.typedRefs.get(field.assetType);
+    if (field.assetType !== undefined && allowed === undefined) {
+        throw new Error(`Component field ${componentId}.${field.name} references unknown asset type ${field.assetType}`);
+    }
+    for (const assetRef of values) {
+        if (assetRef.length === 0 || allowed?.has(assetRef) !== true) {
+            const typeSuffix = field.assetType === undefined ? '' : ` for ${field.assetType}`;
+            throw new Error(`Component field ${componentId}.${field.name} references missing asset ${assetRef}${typeSuffix}`);
+        }
+    }
+}
+function assetRefValuesForRuntimeField(componentId, field, value) {
+    if (field.kind === 'asset-ref') {
+        return [String(value)];
+    }
+    /* istanbul ignore next -- asset-ref extraction only receives fields that contain asset refs. */
+    if (isRuntimeArrayKind(field.kind) || isRuntimeFixedArrayKind(field.kind)) {
+        if (runtimeCollectionScalarKind(field.kind) !== 'asset-ref') {
+            return [];
+        }
+        if (!Array.isArray(value)) {
+            throw new Error(`Component field ${componentId}.${field.name} must be an asset ref array`);
+        }
+        return value.map((entry) => {
+            if (typeof entry !== 'string') {
+                throw new Error(`Component field ${componentId}.${field.name} must contain asset ref strings`);
+            }
+            return entry;
+        });
+    }
+    /* istanbul ignore next -- asset-ref extraction only receives scalar or array asset-ref fields. */
+    return [];
+}
+function fieldContainsAssetRef(kind) {
+    if (kind === 'asset-ref') {
+        return true;
+    }
+    /* istanbul ignore next -- asset-ref tests cover scalar and collection refs. */
+    if (isRuntimeArrayKind(kind) || isRuntimeFixedArrayKind(kind)) {
+        return runtimeCollectionScalarKind(kind) === 'asset-ref';
+    }
+    return false;
+}
+function createRuntimeAssetRefValidator(options) {
+    if (options.assetRefs === undefined && options.typedAssetRefs === undefined) {
+        return undefined;
+    }
+    const allRefs = new Set();
+    /* istanbul ignore next -- global asset refs default to empty when only typed refs are configured. */
+    for (const assetRef of options.assetRefs ?? []) {
+        if (!isNonEmptyString(assetRef)) {
+            throw new Error('Deterministic runtime assetRefs must contain non-empty strings');
+        }
+        allRefs.add(assetRef);
+    }
+    const typedRefs = new Map();
+    /* istanbul ignore next -- typed asset refs default to empty when only global refs are configured. */
+    for (const assetType of stableKeys(options.typedAssetRefs ?? {})) {
+        if (!isNonEmptyString(assetType)) {
+            throw new Error('Deterministic runtime typedAssetRefs requires non-empty asset types');
+        }
+        const refs = new Set();
+        /* istanbul ignore next -- typed asset refs are validated when configured. */
+        for (const assetRef of options.typedAssetRefs?.[assetType] ?? []) {
+            if (!isNonEmptyString(assetRef)) {
+                throw new Error(`Deterministic runtime typedAssetRefs.${assetType} must contain non-empty strings`);
+            }
+            refs.add(assetRef);
+            allRefs.add(assetRef);
+        }
+        typedRefs.set(assetType, refs);
+    }
+    return { allRefs, typedRefs };
+}
+function dslFieldKindToRuntimeKind(kind) {
+    if (isDslDictionaryKind(kind)) {
+        return 'frame-dictionary';
+    }
+    if (isDslListKind(kind)) {
+        return 'frame-list';
+    }
+    if (isDslSetKind(kind)) {
+        return 'frame-hash-set';
+    }
+    if (isDslFixedArrayKind(kind)) {
+        const scalar = dslCollectionScalarKind(kind);
+        return `${runtimeScalarKind(scalar)}[${dslFixedArrayLength(kind)}]`;
+    }
+    if (isDslCollectionKind(kind)) {
+        const scalar = dslCollectionScalarKind(kind);
+        return `${runtimeScalarKind(scalar)}[]`;
+    }
+    return runtimeScalarKind(kind);
+}
+function dslAssetTypeForFieldKind(kind) {
+    if (isDslListKind(kind) || isDslSetKind(kind) || isDslDictionaryKind(kind)) {
+        return undefined;
+    }
+    const scalar = isDslCollectionKind(kind)
+        ? dslCollectionScalarKind(kind)
+        : kind;
+    return isDslTypedAssetRefKind(scalar) ? scalar.slice('asset-ref:'.length) : undefined;
+}
+function defaultRuntimeValueForKind(kind) {
+    if (isDslListKind(kind) || isDslSetKind(kind) || isDslDictionaryKind(kind)) {
+        return null;
+    }
+    if (isDslFixedArrayKind(kind)) {
+        return Array.from({ length: dslFixedArrayLength(kind) }, () => defaultRuntimeValueForKind(dslCollectionScalarKind(kind)));
+    }
+    if (isDslCollectionKind(kind)) {
+        return [];
+    }
+    if (kind === 'bool' || kind === 'button') {
+        return false;
+    }
+    if (kind === 'string' || kind === 'asset-ref' || isDslTypedAssetRefKind(kind)) {
+        return '';
+    }
+    return 0;
+}
+function defaultComponentData(component) {
+    return Object.fromEntries(component.fields.map((field) => [
+        field.name,
+        cloneCanonical(field.defaultValue ?? defaultComponentFieldValue(field.kind)),
+    ]));
+}
+function defaultComponentFieldValue(kind) {
+    if (isRuntimeFrameHeapKind(kind)) {
+        return null;
+    }
+    if (isRuntimeFixedArrayKind(kind)) {
+        return Array.from({ length: runtimeFixedArrayLength(kind) }, () => defaultComponentFieldValue(runtimeCollectionScalarKind(kind)));
+    }
+    if (isRuntimeArrayKind(kind)) {
+        return [];
+    }
+    if (kind === 'bool') {
+        return false;
+    }
+    if (kind === 'string' || kind === 'asset-ref') {
+        return '';
+    }
+    return 0;
+}
+function literalForComponentDefaults(component) {
+    return JSON.stringify(defaultComponentData(component));
+}
+function runtimeFieldToTs(kind) {
+    if (isRuntimeFrameHeapKind(kind)) {
+        return 'DeterministicGeneratedFrameHeapHandle | null';
+    }
+    const array = isRuntimeArrayKind(kind) || isRuntimeFixedArrayKind(kind);
+    const scalar = array ? runtimeCollectionScalarKind(kind) : kind;
+    const scalarType = scalar === 'bool'
+        ? 'boolean'
+        : scalar === 'string' || scalar === 'asset-ref'
+            ? 'string'
+            : 'number';
+    return array ? `readonly ${scalarType}[]` : scalarType;
+}
+function propertyName(value) {
+    /* istanbul ignore next -- validated descriptors use identifier field names for generated interfaces. */
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : JSON.stringify(value);
+}
+function validateRuntimeArrayField(componentId, fieldName, kind, value) {
+    if (!Array.isArray(value)) {
+        throw new Error(`Component field ${componentId}.${fieldName} must be array`);
+    }
+    const fixedLength = isRuntimeFixedArrayKind(kind) ? runtimeFixedArrayLength(kind) : undefined;
+    if (fixedLength !== undefined && value.length !== fixedLength) {
+        throw new Error(`Component field ${componentId}.${fieldName} must contain exactly ${fixedLength} values`);
+    }
+    const scalarKind = runtimeCollectionScalarKind(kind);
+    for (const item of value) {
+        if (scalarKind === 'bool' && typeof item !== 'boolean') {
+            throw new Error(`Component field ${componentId}.${fieldName} must contain booleans`);
+        }
+        if ((scalarKind === 'int' || scalarKind === 'fixed' || scalarKind === 'entity-ref') && (typeof item !== 'number' || !Number.isInteger(item))) {
+            throw new Error(`Component field ${componentId}.${fieldName} must contain integers`);
+        }
+        if ((scalarKind === 'string' || scalarKind === 'asset-ref') && typeof item !== 'string') {
+            throw new Error(`Component field ${componentId}.${fieldName} must contain strings`);
+        }
+    }
+}
+function validateRuntimeFrameHeapHandle(componentId, fieldName, kind, value) {
+    if (value === null) {
+        return;
+    }
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Component field ${componentId}.${fieldName} must be frame heap handle or null`);
+    }
+    const record = value;
+    const expectedKind = runtimeFrameHeapHandleKind(kind);
+    if (typeof record.id !== 'number' ||
+        !Number.isInteger(record.id) ||
+        record.id < 1 ||
+        typeof record.generation !== 'number' ||
+        !Number.isInteger(record.generation) ||
+        record.generation < 1 ||
+        record.kind !== expectedKind) {
+        throw new Error(`Component field ${componentId}.${fieldName} must be ${expectedKind} frame heap handle`);
+    }
+}
+function runtimeFrameHeapHandleKind(kind) {
+    if (kind === 'frame-list') {
+        return 'list';
+    }
+    if (kind === 'frame-dictionary') {
+        return 'dictionary';
+    }
+    return 'hash-set';
+}
+function isDslArrayKind(kind) {
+    return kind.endsWith('[]');
+}
+function isDslFixedArrayKind(kind) {
+    return /^(int|fixed|bool|button|string|asset-ref|entity-ref)\[[1-9][0-9]*\]$/.test(kind);
+}
+function dslFixedArrayLength(kind) {
+    const match = kind.match(/\[([1-9][0-9]*)\]$/);
+    /* istanbul ignore next -- caller checks isDslFixedArrayKind before extracting fixed array length. */
+    if (match === null) {
+        throw new Error(`Expected fixed array DSL kind, received ${kind}`);
+    }
+    return Number(match[1]);
+}
+function isDslListKind(kind) {
+    return kind.startsWith('list<') && kind.endsWith('>');
+}
+function isDslSetKind(kind) {
+    return kind.startsWith('set<') && kind.endsWith('>');
+}
+function isDslDictionaryKind(kind) {
+    return kind.startsWith('dictionary<') && kind.endsWith('>');
+}
+function isDslCollectionKind(kind) {
+    return isDslArrayKind(kind) || isDslFixedArrayKind(kind) || isDslListKind(kind) || isDslSetKind(kind) || isDslDictionaryKind(kind);
+}
+function dslCollectionScalarKind(kind) {
+    if (isDslArrayKind(kind)) {
+        return kind.slice(0, -2);
+    }
+    /* istanbul ignore else -- scalar extraction reaches fixed arrays only after the array case is rejected. */
+    if (isDslFixedArrayKind(kind)) {
+        return kind.slice(0, kind.indexOf('['));
+    }
+    /* istanbul ignore next -- list/set/dictionary kinds are mapped to frame heap storage before scalar extraction. */
+    return kind.slice(kind.indexOf('<') + 1, kind.indexOf(isDslDictionaryKind(kind) ? ',' : '>'));
+}
+function runtimeScalarKind(kind) {
+    if (kind === 'button') {
+        return 'bool';
+    }
+    if (kind === 'player-ref' || kind.startsWith('enum:') || kind.startsWith('flags:') || kind.startsWith('bitset:')) {
+        return 'int';
+    }
+    if (kind.startsWith('asset-ref:')) {
+        return 'asset-ref';
+    }
+    /* istanbul ignore else -- unsupported DSL scalar kinds are rejected by the parser before runtime compilation. */
+    if (kind === 'int' || kind === 'fixed' || kind === 'bool' || kind === 'string' || kind === 'asset-ref' || kind === 'entity-ref') {
+        return kind;
+    }
+    /* istanbul ignore next -- schema parser rejects unsupported DSL scalar kinds before runtime compilation. */
+    throw new Error(`Unsupported DSL runtime scalar kind ${kind}`);
+}
+function isDslTypedAssetRefKind(kind) {
+    return kind.startsWith('asset-ref:');
+}
+function isRuntimeArrayKind(kind) {
+    return kind.endsWith('[]');
+}
+function isRuntimeFixedArrayKind(kind) {
+    return /^(int|fixed|bool|string|asset-ref|entity-ref)\[[1-9][0-9]*\]$/.test(kind);
+}
+function runtimeFixedArrayLength(kind) {
+    const match = kind.match(/\[([1-9][0-9]*)\]$/);
+    /* istanbul ignore next -- caller checks isRuntimeFixedArrayKind before extracting fixed array length. */
+    if (match === null) {
+        throw new Error(`Expected fixed array runtime kind, received ${kind}`);
+    }
+    return Number(match[1]);
+}
+function runtimeCollectionScalarKind(kind) {
+    return (isRuntimeArrayKind(kind) ? kind.slice(0, -2) : kind.slice(0, kind.indexOf('[')));
+}
+function runtimeScalarKindForMetrics(kind) {
+    if (isRuntimeArrayKind(kind) || isRuntimeFixedArrayKind(kind)) {
+        return runtimeCollectionScalarKind(kind);
+    }
+    if (isRuntimeFrameHeapKind(kind)) {
+        return undefined;
+    }
+    return kind;
+}
+function isRuntimeFrameHeapKind(kind) {
+    return kind === 'frame-list' || kind === 'frame-dictionary' || kind === 'frame-hash-set';
+}
+export function validateDeterministicFrameSystemsStateless(descriptor, systems) {
+    validateRuntimeDescriptor(descriptor);
+    const diagnostics = [];
+    for (const systemDescriptor of orderSystemDescriptors(descriptor.systems)) {
+        const system = systems[systemDescriptor.id];
+        if (system === undefined) {
+            diagnostics.push({ systemId: systemDescriptor.id, reason: 'missing-system' });
+            continue;
+        }
+        diagnostics.push(...diagnoseDeterministicFrameSystemStateless(systemDescriptor.id, system));
+    }
+    return {
+        pass: diagnostics.length === 0,
+        diagnostics,
+    };
+}
+export function assertDeterministicFrameSystemsStateless(descriptor, systems) {
+    const result = validateDeterministicFrameSystemsStateless(descriptor, systems);
+    if (!result.pass) {
+        throw statelessSystemDiagnosticError(result.diagnostics[0]);
+    }
+}
+function assertDeterministicFrameSystemStateless(systemId, system) {
+    const diagnostics = diagnoseDeterministicFrameSystemStateless(systemId, system);
+    if (diagnostics.length > 0) {
+        throw statelessSystemDiagnosticError(diagnostics[0]);
+    }
+}
+function diagnoseDeterministicFrameSystemStateless(systemId, system) {
+    const keys = stableEnumerableKeys(system);
+    if (keys.length > 0) {
+        return [{ systemId, reason: 'mutable-own-fields', ownFields: keys }];
+    }
+    const externalMutation = findExternalSystemMutation(system);
+    if (externalMutation !== undefined) {
+        return [{ systemId, reason: 'external-mutation', externalMutation }];
+    }
+    return [];
+}
+function statelessSystemDiagnosticError(diagnostic) {
+    if (diagnostic.reason === 'missing-system') {
+        return new Error(`Missing deterministic system ${diagnostic.systemId}`);
+    }
+    if (diagnostic.reason === 'mutable-own-fields') {
+        return new Error(`Deterministic system ${diagnostic.systemId} has mutable own fields`);
+    }
+    /* istanbul ignore next -- source diagnostics include an external mutation label for external-mutation errors. */
+    return new Error(`Deterministic system ${diagnostic.systemId} mutates external state through ${diagnostic.externalMutation ?? 'unknown'}`);
+}
+function findExternalSystemMutation(system) {
+    const source = stripSystemStringsAndComments(Function.prototype.toString.call(system));
+    const parameters = systemParameterNames(source);
+    const localNames = new Set([...parameters, ...declaredSystemNames(source)]);
+    const updatePattern = /(?:\+\+|--)\s*([A-Za-z_$][A-Za-z0-9_$]*)|([A-Za-z_$][A-Za-z0-9_$]*)\s*(?:\+\+|--|[+\-*/%&|^]=|=(?!=))/g;
+    let match;
+    while ((match = updatePattern.exec(source)) !== null) {
+        const name = match[1] ?? match[2];
+        if (name !== undefined && !localNames.has(name) && !deterministicSystemGlobalNames.includes(name)) {
+            return name;
+        }
+    }
+    const bracketUpdatePattern = /(?:\+\+|--)\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*\[[^\]]*\]|([A-Za-z_$][A-Za-z0-9_$]*)\s*\[[^\]]*\]\s*(?:\+\+|--|[+\-*/%&|^]=|=(?!=))/g;
+    while ((match = bracketUpdatePattern.exec(source)) !== null) {
+        const name = match[1] ?? match[2];
+        if (name !== undefined && !localNames.has(name) && !deterministicSystemGlobalNames.includes(name)) {
+            return `${name}[]`;
+        }
+    }
+    const mutatingCallPattern = /\b([A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*)\s*\.\s*(set|add|delete|clear|push|pop|shift|unshift|splice|sort|reverse|copyWithin|fill)\s*\(\s*([A-Za-z_$][A-Za-z0-9_$]*)?/g;
+    while ((match = mutatingCallPattern.exec(source)) !== null) {
+        const receiver = match[1];
+        const method = match[2];
+        const root = receiver.split('.')[0];
+        if (!localNames.has(root) && !deterministicSystemGlobalNames.includes(root)) {
+            return `${receiver}.${method}()`;
+        }
+    }
+    return undefined;
+}
+const deterministicSystemGlobalNames = [
+    'Number',
+    'Math',
+    'String',
+    'Boolean',
+    'Array',
+    'Object',
+];
+function stripSystemStringsAndComments(source) {
+    return source
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/\/\/.*$/gm, '')
+        .replace(/(['"`])(?:\\.|(?!\1)[\s\S])*\1/g, '');
+}
+function systemParameterNames(source) {
+    const functionMatch = source.match(/^[^(]*\(([^)]*)\)/);
+    const arrowMatch = source.match(/^\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*=>/);
+    /* istanbul ignore next -- source scanner tests cover named functions; scanner is non-authoritative certification tooling. */
+    const raw = functionMatch?.[1] ?? arrowMatch?.[1] ?? '';
+    return raw
+        .split(',')
+        .map((parameter) => parameter.trim().replace(/=.*/, '').trim())
+        .filter((parameter) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(parameter));
+}
+function declaredSystemNames(source) {
+    const names = [];
+    const declarationPattern = /\b(?:const|let|var|function)\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
+    let match;
+    while ((match = declarationPattern.exec(source)) !== null) {
+        names.push(match[1]);
+    }
+    return names;
+}
+function createRuntimeCorpusDescriptor() {
+    return {
+        id: 'runtime-corpus',
+        tickRate: 60,
+        components: [
+            { id: 'position', fields: [{ name: 'x', kind: 'fixed' }, { name: 'y', kind: 'fixed' }] },
+            { id: 'velocity', fields: [{ name: 'x', kind: 'fixed' }, { name: 'y', kind: 'fixed' }] },
+            { id: 'stats', singleton: true, fields: [
+                    { name: 'score', kind: 'int', defaultValue: 0 },
+                    { name: 'entityCreates', kind: 'int', defaultValue: 0 },
+                    { name: 'entityDestroys', kind: 'int', defaultValue: 0 },
+                    { name: 'componentWrites', kind: 'int', defaultValue: 0 },
+                ] },
+        ],
+        systems: [{ id: 'mutate', group: 'simulation', order: 0 }],
+    };
+}
+function compareSystemDescriptors(left, right) {
+    /* istanbul ignore next -- scheduler tests cover group and order sort arms. */
+    return compareGroup(left.group, right.group) || left.order - right.order || compareStrings(left.id, right.id);
+}
+function orderSystemDescriptors(systems) {
+    const sortedSystems = [...systems].sort(compareSystemDescriptors);
+    const byId = new Map(sortedSystems.map((system) => [system.id, system]));
+    const outgoing = new Map(sortedSystems.map((system) => [system.id, new Set()]));
+    const incomingCounts = new Map(sortedSystems.map((system) => [system.id, 0]));
+    const addEdge = (fromId, toId, sourceId) => {
+        const from = byId.get(fromId);
+        const to = byId.get(toId);
+        if (from === undefined || to === undefined) {
+            /* istanbul ignore next -- unknown dependency tests cover missing target ids. */
+            throw new Error(`Deterministic system ${sourceId} references unknown dependency ${from === undefined ? fromId : toId}`);
+        }
+        if (from.group !== to.group) {
+            throw new Error(`Deterministic system ${sourceId} dependency ${fromId}->${toId} crosses system group boundaries`);
+        }
+        const edges = outgoing.get(fromId);
+        if (edges === undefined || edges.has(toId)) {
+            return;
+        }
+        edges.add(toId);
+        /* istanbul ignore next -- incoming counts are initialized for every sorted system id. */
+        incomingCounts.set(toId, (incomingCounts.get(toId) ?? 0) + 1);
+    };
+    for (const system of sortedSystems) {
+        for (const after of normalizedSystemDependencyIds(system.after)) {
+            addEdge(after, system.id, system.id);
+        }
+        for (const before of normalizedSystemDependencyIds(system.before)) {
+            addEdge(system.id, before, system.id);
+        }
+    }
+    const ready = sortedSystems.filter((system) => incomingCounts.get(system.id) === 0);
+    const ordered = [];
+    while (ready.length > 0) {
+        ready.sort(compareSystemDescriptors);
+        const next = ready.shift();
+        /* istanbul ignore next -- ready.shift cannot be undefined while ready.length is positive. */
+        if (next === undefined) {
+            break;
+        }
+        ordered.push(next);
+        /* istanbul ignore next -- outgoing edges are initialized for every sorted system id. */
+        for (const targetId of [...(outgoing.get(next.id) ?? [])].sort(compareStrings)) {
+            /* istanbul ignore next -- incoming counts are initialized for every sorted system id. */
+            const remaining = (incomingCounts.get(targetId) ?? 0) - 1;
+            incomingCounts.set(targetId, remaining);
+            if (remaining === 0) {
+                const target = byId.get(targetId);
+                if (target !== undefined) {
+                    ready.push(target);
+                }
+            }
+        }
+    }
+    if (ordered.length !== sortedSystems.length) {
+        const cyclic = sortedSystems
+            .filter((system) => !ordered.some((orderedSystem) => orderedSystem.id === system.id))
+            .map((system) => system.id)
+            .sort(compareStrings)
+            .join(',');
+        throw new Error(`Deterministic system dependency cycle detected: ${cyclic}`);
+    }
+    return ordered;
+}
+function normalizedSystemDependencyIds(ids) {
+    const normalized = [...new Set(ids ?? [])].sort(compareStrings);
+    for (const id of normalized) {
+        if (!isNonEmptyString(id)) {
+            throw new Error('Deterministic system dependency requires non-empty system ids');
+        }
+    }
+    return normalized;
+}
+function compareGroup(left, right) {
+    const order = {
+        input: 0,
+        simulation: 1,
+        physics: 2,
+        'post-physics': 3,
+        presentation: 4,
+    };
+    return order[left] - order[right];
+}
+function toIdentifier(id) {
+    const normalized = id
+        .split(/[^a-zA-Z0-9]+/)
+        .filter((part) => part.length > 0)
+        .map((part) => `${part[0].toUpperCase()}${part.slice(1)}`)
+        .join('');
+    /* istanbul ignore next -- generated runtime descriptors use non-empty non-numeric ids. */
+    return normalized.length === 0 || /^[0-9]/.test(normalized) ? `Generated${normalized}` : normalized;
+}
+function compareMapStringEntry(left, right) {
+    return compareStrings(left[0], right[0]);
+}
+function stableKeys(record) {
+    return Reflect.ownKeys(record)
+        .filter((key) => typeof key === 'string')
+        .sort(compareStrings);
+}
+function stableEnumerableKeys(record) {
+    return stableKeys(record).filter((key) => Object.prototype.propertyIsEnumerable.call(record, key));
+}
+function assertBitIndex(size, index) {
+    if (!Number.isInteger(index) || index < 0 || index >= size) {
+        throw new Error(`Bitset index ${index} out of range`);
+    }
+}
+function percentile(values, percentileRank) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((left, right) => left - right);
+    const index = Math.min(sorted.length - 1, Math.floor((percentileRank / 100) * sorted.length));
+    return Math.round(sorted[index] * 1e4) / 1e4;
+}
+function compareStrings(left, right) {
+    /* istanbul ignore next -- call sites cover less-than and equality; greater-than is symmetric ordering behavior. */
+    return left < right ? -1 : left > right ? 1 : 0;
+}