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

package/dist/ecs-lite.d.ts

@@ -0,0 +1,26 @@
+export type EcsEntityId = number;
+export type EcsComponentName = string;
+export type EcsLiteSnapshot = {
+    readonly nextEntityId: number;
+    readonly entities: readonly EcsEntityId[];
+    readonly components: Readonly<Record<EcsComponentName, Readonly<Record<string, unknown>>>>;
+    readonly singletons: Readonly<Record<string, unknown>>;
+};
+export type EcsLiteQueryResult<ComponentNames extends readonly EcsComponentName[] = readonly EcsComponentName[]> = {
+    readonly entityId: EcsEntityId;
+    readonly components: Readonly<Record<ComponentNames[number], unknown>>;
+};
+export type EcsLiteWorld = {
+    readonly createEntity: () => EcsEntityId;
+    readonly destroyEntity: (entityId: EcsEntityId) => void;
+    readonly addComponent: (entityId: EcsEntityId, componentName: EcsComponentName, value: unknown) => void;
+    readonly removeComponent: (entityId: EcsEntityId, componentName: EcsComponentName) => void;
+    readonly getComponent: <T>(entityId: EcsEntityId, componentName: EcsComponentName) => T | undefined;
+    readonly setSingleton: (name: string, value: unknown) => void;
+    readonly getSingleton: <T>(name: string) => T | undefined;
+    readonly query: <ComponentNames extends readonly EcsComponentName[]>(componentNames: ComponentNames) => readonly EcsLiteQueryResult<ComponentNames>[];
+    readonly snapshot: () => EcsLiteSnapshot;
+    readonly restore: (snapshot: EcsLiteSnapshot) => void;
+    readonly checksum: () => string;
+};
+export declare function createEcsLiteWorld(snapshot?: EcsLiteSnapshot): EcsLiteWorld;

package/dist/ecs-lite.js

@@ -0,0 +1,152 @@
+import { cloneCanonical, defaultChecksum } from './canonical.js';
+export function createEcsLiteWorld(snapshot) {
+    const world = snapshot === undefined
+        ? { nextEntityId: 1, entities: [], components: new Map(), singletons: new Map() }
+        : mutableFromSnapshot(snapshot);
+    return {
+        createEntity() {
+            const entityId = world.nextEntityId;
+            world.nextEntityId += 1;
+            world.entities.push(entityId);
+            world.entities.sort((left, right) => left - right);
+            return entityId;
+        },
+        destroyEntity(entityId) {
+            requireEntity(world, entityId);
+            world.entities = world.entities.filter((candidate) => candidate !== entityId);
+            for (const componentName of Array.from(world.components.keys()).sort(compareStrings)) {
+                world.components.get(componentName)?.delete(String(entityId));
+            }
+        },
+        addComponent(entityId, componentName, value) {
+            requireEntity(world, entityId);
+            const entityKey = String(entityId);
+            const componentValues = world.components.get(componentName) ?? new Map();
+            componentValues.set(entityKey, cloneCanonical(value));
+            world.components.set(componentName, componentValues);
+        },
+        removeComponent(entityId, componentName) {
+            requireEntity(world, entityId);
+            world.components.get(componentName)?.delete(String(entityId));
+        },
+        getComponent(entityId, componentName) {
+            requireEntity(world, entityId);
+            const value = world.components.get(componentName)?.get(String(entityId));
+            return value === undefined ? undefined : cloneCanonical(value);
+        },
+        setSingleton(name, value) {
+            world.singletons.set(name, cloneCanonical(value));
+        },
+        getSingleton(name) {
+            const value = world.singletons.get(name);
+            return value === undefined ? undefined : cloneCanonical(value);
+        },
+        query(componentNames) {
+            const sortedNames = componentNames.slice().sort(compareStrings);
+            return world.entities.flatMap((entityId) => {
+                const components = {};
+                for (const componentName of sortedNames) {
+                    const component = world.components.get(componentName)?.get(String(entityId));
+                    if (component === undefined) {
+                        return [];
+                    }
+                    components[componentName] = cloneCanonical(component);
+                }
+                return [{ entityId, components }];
+            });
+        },
+        snapshot() {
+            return snapshotFromMutable(world);
+        },
+        restore(snapshotToRestore) {
+            const restored = mutableFromSnapshot(snapshotToRestore);
+            world.nextEntityId = restored.nextEntityId;
+            world.entities = restored.entities;
+            world.components = restored.components;
+            world.singletons = restored.singletons;
+        },
+        checksum() {
+            return defaultChecksum(snapshotFromMutable(world));
+        },
+    };
+}
+function requireEntity(world, entityId) {
+    if (!world.entities.includes(entityId)) {
+        throw new Error(`Unknown ECS entity ${entityId}`);
+    }
+}
+function mutableFromSnapshot(snapshot) {
+    validateSnapshot(snapshot);
+    return {
+        nextEntityId: snapshot.nextEntityId,
+        entities: snapshot.entities.slice().sort((left, right) => left - right),
+        components: componentsMapFromSnapshot(snapshot.components),
+        singletons: new Map(Object.keys(snapshot.singletons)
+            .sort(compareStrings)
+            .map((key) => [key, cloneCanonical(snapshot.singletons[key])])),
+    };
+}
+function validateSnapshot(snapshot) {
+    validateEntityId(snapshot.nextEntityId, 'nextEntityId');
+    const entityIds = new Set();
+    let maxEntityId = 0;
+    for (const entityId of snapshot.entities) {
+        validateEntityId(entityId, 'entity');
+        if (entityIds.has(entityId)) {
+            throw new Error(`Duplicate ECS entity ${entityId}`);
+        }
+        entityIds.add(entityId);
+        maxEntityId = Math.max(maxEntityId, entityId);
+    }
+    if (snapshot.nextEntityId <= maxEntityId) {
+        throw new Error(`Invalid ECS nextEntityId ${snapshot.nextEntityId}`);
+    }
+    for (const componentName of Object.keys(snapshot.components).sort(compareStrings)) {
+        for (const entityKey of Object.keys(snapshot.components[componentName]).sort(compareStrings)) {
+            const entityId = Number(entityKey);
+            validateEntityId(entityId, `component ${componentName}`);
+            if (entityKey !== String(entityId)) {
+                throw new Error(`Invalid ECS component ${componentName} key ${entityKey}`);
+            }
+            if (!entityIds.has(entityId)) {
+                throw new Error(`Unknown ECS entity ${entityId} in component ${componentName}`);
+            }
+        }
+    }
+}
+function validateEntityId(entityId, label) {
+    if (!Number.isSafeInteger(entityId) || entityId < 1) {
+        throw new Error(`Invalid ECS ${label} ${entityId}`);
+    }
+}
+function snapshotFromMutable(world) {
+    const components = Object.fromEntries(Array.from(world.components.keys()).sort(compareStrings).map((componentName) => {
+        const values = world.components.get(componentName);
+        return [
+            componentName,
+            Object.fromEntries(Array.from(values.keys())
+                .sort((left, right) => Number(left) - Number(right))
+                .map((entityId) => [entityId, cloneCanonical(values.get(entityId))])),
+        ];
+    }));
+    const singletons = Object.fromEntries(Array.from(world.singletons.keys())
+        .sort(compareStrings)
+        .map((key) => [key, cloneCanonical(world.singletons.get(key))]));
+    return {
+        nextEntityId: world.nextEntityId,
+        entities: world.entities.slice().sort((left, right) => left - right),
+        components,
+        singletons,
+    };
+}
+function componentsMapFromSnapshot(components) {
+    return new Map(Object.keys(components).sort(compareStrings).map((componentName) => [
+        componentName,
+        new Map(Object.keys(components[componentName])
+            .sort((left, right) => Number(left) - Number(right))
+            .map((entityId) => [entityId, cloneCanonical(components[componentName][entityId])])),
+    ]));
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/effects-adapter.d.ts

@@ -0,0 +1,21 @@
+import type { DeterministicEventRecord } from './events.js';
+export type DeterministicEffectTarget = 'r3f' | 'audio' | 'ui' | 'custom';
+export interface DeterministicEffectDispatch<Payload, Effect> {
+    readonly target: DeterministicEffectTarget;
+    readonly record: DeterministicEventRecord<Payload>;
+    readonly effect: DeterministicRenderSafeEffect<Effect>;
+}
+export type DeterministicRenderSafeEffect<T> = T extends (...args: readonly never[]) => unknown ? never : T extends readonly (infer Item)[] ? readonly DeterministicRenderSafeEffect<Item>[] : T extends object ? {
+    readonly [Key in keyof T]: DeterministicRenderSafeEffect<T[Key]>;
+} : T;
+export interface DeterministicEventEffectsAdapter<Payload, Effect> {
+    dispatch(records: readonly DeterministicEventRecord<Payload>[]): readonly DeterministicEffectDispatch<Payload, Effect>[];
+    getDispatched(): readonly DeterministicEffectDispatch<Payload, Effect>[];
+    subscribe(listener: (dispatch: DeterministicEffectDispatch<Payload, Effect>) => void): () => void;
+    reset(): void;
+}
+export interface DeterministicEventEffectsAdapterConfig<Payload, Effect> {
+    readonly target: DeterministicEffectTarget;
+    readonly mapEvent: (record: DeterministicEventRecord<Payload>) => Effect | undefined;
+}
+export declare function createDeterministicEventEffectsAdapter<Payload, Effect>(config: DeterministicEventEffectsAdapterConfig<Payload, Effect>): DeterministicEventEffectsAdapter<Payload, Effect>;

package/dist/effects-adapter.js

@@ -0,0 +1,94 @@
+import { cloneCanonical } from './canonical.js';
+import { stableSortedKeys } from './collections.js';
+import { SyncplayError } from './errors.js';
+export function createDeterministicEventEffectsAdapter(config) {
+    validateTarget(config.target);
+    const dispatched = [];
+    const seen = new Set();
+    const listeners = new Set();
+    return {
+        dispatch(records) {
+            const nextDispatches = [];
+            for (const record of records) {
+                const dedupeKey = `${record.sequence}:${record.predictionState}`;
+                if (seen.has(dedupeKey)) {
+                    continue;
+                }
+                const effect = config.mapEvent(cloneEventRecord(record));
+                seen.add(dedupeKey);
+                if (effect === undefined) {
+                    continue;
+                }
+                const dispatch = freezeEffectDispatch({
+                    target: config.target,
+                    record: cloneEventRecord(record),
+                    effect: freezeEffectValue(cloneCanonical(effect)),
+                });
+                dispatched.push(dispatch);
+                nextDispatches.push(dispatch);
+                for (const listener of listeners) {
+                    listener(dispatch);
+                }
+            }
+            return nextDispatches;
+        },
+        getDispatched() {
+            return dispatched.map((dispatch) => freezeEffectDispatch({
+                target: dispatch.target,
+                record: cloneEventRecord(dispatch.record),
+                effect: freezeEffectValue(cloneCanonical(dispatch.effect)),
+            }));
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        reset() {
+            dispatched.length = 0;
+            seen.clear();
+        },
+    };
+}
+function cloneEventRecord(record) {
+    return freezeEffectValue({
+        eventId: record.eventId,
+        frame: record.frame,
+        sequence: record.sequence,
+        payload: cloneCanonical(record.payload),
+        predictionState: record.predictionState,
+        dedupeKey: record.dedupeKey,
+        notHashedKeys: [...record.notHashedKeys],
+        deliveryScope: record.deliveryScope,
+        playerSlot: record.playerSlot,
+    });
+}
+function freezeEffectDispatch(dispatch) {
+    freezeEffectValue(dispatch.record);
+    freezeEffectValue(dispatch.effect);
+    return Object.freeze(dispatch);
+}
+function freezeEffectValue(value) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            freezeEffectValue(item);
+        }
+        return Object.freeze(value);
+    }
+    const record = value;
+    for (const key of stableSortedKeys(record)) {
+        freezeEffectValue(record[key]);
+    }
+    return Object.freeze(value);
+}
+function validateTarget(target) {
+    if (target !== 'r3f' && target !== 'audio' && target !== 'ui' && target !== 'custom') {
+        throw new SyncplayError(`Unsupported deterministic effect target ${target}`, {
+            code: 'effects.target',
+        });
+    }
+}

package/dist/engine-complete.d.ts

@@ -0,0 +1,45 @@
+export type DeterministicEngineCompleteCategory = 'typed-frame-runtime' | 'schema-dsl-binary' | 'sparse-set-storage' | 'input-button' | 'system-lifecycle' | 'event-keywords' | 'simulation-signals' | 'commands' | 'replay-bundle' | 'integrated-headless-scene' | 'project-runtime' | 'physics3d' | 'kcc3d' | 'navmesh' | 'bot-documents' | 'animation' | 'config-bundle' | 'local-authority' | 'deterministic-session';
+export interface DeterministicEngineCompleteOptions {
+    readonly players?: number;
+    readonly frames?: number;
+    readonly seed?: number;
+    readonly benchmark?: boolean;
+    readonly noFastStress?: boolean;
+    readonly enforceThresholds?: boolean;
+    readonly filter?: string;
+}
+export interface DeterministicEngineCompleteCategoryReport {
+    readonly category: DeterministicEngineCompleteCategory;
+    readonly result: 'pass' | 'fail';
+    readonly checksum: string;
+    readonly invariants: Readonly<Record<string, boolean | number | string>>;
+    readonly metrics: Readonly<Record<string, boolean | number | string>>;
+    readonly failures: readonly string[];
+}
+export interface DeterministicEngineCompleteReport {
+    readonly schemaVersion: 1;
+    readonly reportId: string;
+    readonly players: number;
+    readonly frames: number;
+    readonly seed: number;
+    readonly benchmark: boolean;
+    readonly noFastStress: boolean;
+    readonly enforceThresholds: boolean;
+    readonly provenance?: {
+        readonly kind: 'engine-complete-suite';
+        readonly version: 1;
+        readonly sourceHash: string;
+        readonly generator: 'runDeterministicEngineCompleteSuite';
+    };
+    readonly categories: readonly DeterministicEngineCompleteCategoryReport[];
+    readonly failures: readonly string[];
+    readonly summary: {
+        readonly passed: number;
+        readonly failed: number;
+        readonly requiredCategories: readonly DeterministicEngineCompleteCategory[];
+    };
+    readonly result: 'pass' | 'fail';
+}
+export declare function runDeterministicEngineCompleteSuite(...args: readonly [DeterministicEngineCompleteOptions?]): DeterministicEngineCompleteReport;
+export declare function stableDeterministicEngineCompleteJson(report: DeterministicEngineCompleteReport): string;
+export declare function engineCompleteExecutionProofHash(category: DeterministicEngineCompleteCategory, subsystemChecksum: string, metrics: Readonly<Record<string, boolean | number | string>>): string;