@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/simulation.d.ts

@@ -0,0 +1,391 @@
+import { Schema } from 'effect';
+
+declare type AnySchema = Schema.Codec<unknown, unknown>;
+
+/* Excluded from this release type: assertCapturedSimulation */
+
+/* Excluded from this release type: captureSimulationInputs */
+
+/** Local snapshot capture is not network/server provenance. */
+export declare const captureSimulationSnapshot: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>>(simulation: Simulation<S, I, O>, offered: SimulationSnapshot<S["Type"]>, maxRejectionAttempts?: number) => SimulationSnapshot<S["Type"]>;
+
+/** Compare provided observations only. Runner identity/artifacts/exit status
+ * must be established outside this pure helper before any engine claim. */
+export declare const compareSimulationConformanceTraces: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, expected: SimulationConformanceTrace, actual: SimulationConformanceTrace, offeredLimits?: SimulationConformanceLimits) => {
+    readonly scope: "provided-trace-comparison";
+    readonly ticks: number;
+    readonly comparisons: number;
+};
+
+/** Source-portable fixture construction only. It never initializes simulation
+ * state, and the entire typed matrix is captured before a conformance run. */
+export declare const createSimulationConformanceCase: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, offered: SimulationConformanceCaseOptions<I["Type"], O["Type"]>) => SimulationConformanceCase;
+
+export declare const createSimulationInputHistoryCodec: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>>(simulation: Simulation<S, I, O>, options?: SimulationInputHistoryCodecOptions) => SimulationInputHistoryCodec<S, I, O>;
+
+export declare const createSimulationOptionsCodec: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>>(simulation: Simulation<S, I, O>) => SimulationOptionsCodec<S, I, O>;
+
+export declare const createSimulationRecoveryCodec: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>>(simulation: Simulation<S, I, O>, options?: SimulationRecoveryCodecOptions) => SimulationRecoveryCodec<S, I, O>;
+
+export declare const createSimulationRunner: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>>(simulation: Simulation<S, I, O>, seed: number, options: O["Type"], budgets?: SimulationRunnerOptions) => SimulationRunner<S, I, O>;
+
+export declare const createSimulationSnapshotCodec: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>>(simulation: Simulation<S, I, O>, options?: SimulationSnapshotCodecOptions) => SimulationSnapshotCodec<S, I, O>;
+
+/** Field IDs and integer raw values define authoritative hash order. Cosmetic
+ * fields are validated/copied but never hashed. This hash is not authentication. */
+export declare const createSimulationState: <S extends Schema.Codec<unknown, unknown>>(schema: S, limits?: Partial<SimulationValueLimits>) => SimulationStateCodec<S>;
+
+/** Whole byte/layout/count/schema admission precedes any simulation init. */
+export declare const decodeSimulationConformanceCase: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, offered: Uint8Array, offeredLimits?: SimulationConformanceLimits) => SimulationConformanceCase;
+
+/** Pure captured author callbacks and shared schema plans. No Room mode, host,
+ * store, scheduler, port installation, network or global entropy is acquired. */
+export declare const defineSimulation: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>>(offered: SimulationDefinition<S, I, O>) => Simulation<S, I, O>;
+
+/** SCF/v1 is an offline reproducibility artifact, not a Room frame, remote
+ * authentication grant, snapshot or process-execution receipt. */
+export declare const encodeSimulationConformanceCase: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, offered: SimulationConformanceCase, offeredLimits?: SimulationConformanceLimits) => Uint8Array;
+
+/** Cosmetic state remains schema-validated and copied, but is excluded from simulation hashes. */
+export declare const nonAuthoritative: () => <S extends Schema.Codec<unknown, unknown>>(schema: S) => S;
+
+/** PCG-XSH-RR 64/32. Numeric seeds are unsigned 32-bit; word seeds retain 64 bits.
+ * Algorithm reference: https://www.pcg-random.org/using-pcg-c-basic.html
+ * No global generator, BigInt, native dependency or implicit time/entropy seed. */
+declare class Pcg32 {
+    #private;
+    constructor(seed: Pcg32Seed, stream?: Pcg32Seed, maxRejectionAttempts?: number);
+    get maxRejectionAttempts(): number;
+    nextU32(): number;
+    /** Rejection removes modulo bias. Exhaustion consumes exactly the bounded
+     * draws and fails; it never returns a biased fallback or substitutes entropy. */
+    bounded(bound: number): number;
+    snapshot(): Pcg32Snapshot;
+    restore(offered: Pcg32Snapshot): void;
+    clone(): Pcg32;
+    /** Exact skip-ahead modulo 2^64; at most 32 iterations for this delta API. */
+    advance(delta: number): void;
+}
+
+declare type Pcg32Seed = number | Uint64Words;
+
+declare interface Pcg32Snapshot {
+    readonly stateHi: number;
+    readonly stateLo: number;
+    readonly incrementHi: number;
+    readonly incrementLo: number;
+}
+
+/* Excluded from this release type: prepareSimulationSnapshot */
+
+/** Every option present and defined: `Required` keeps an explicit `| undefined`, this removes it. */
+declare type Resolved<T> = {
+    readonly [K in keyof T]-?: Exclude<T[K], undefined>;
+};
+
+declare interface RoomCodecLimits {
+    readonly maxBytes: number;
+    readonly maxCollectionLength: number;
+    readonly maxFieldId: number;
+}
+
+/** Plain mutable state; the author receives no store or database capability. */
+declare type RoomState<A> = A extends ReadonlyArray<infer V> ? Array<RoomState<V>> : A extends object ? {
+    -readonly [K in keyof A]: RoomState<A[K]>;
+} : A;
+
+/** Emit actual observations in this invocation. The result does not identify an
+ * engine, authenticate a remote runner or establish a cross-engine proof. */
+export declare const runSimulationConformanceTrace: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, offered: SimulationConformanceCase, offeredLimits?: SimulationConformanceLimits) => SimulationConformanceTrace;
+
+/** Exported default hash slot, reusing the admitted schema state codec. */
+export declare const schemaSimulationHash: <S extends Schema.Codec<unknown, unknown>>(codec: SimulationStateCodec<S>, state: S["Type"]) => Uint64Words;
+
+export declare interface Simulation<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    readonly definition: SimulationDefinition<S, I, O>;
+    readonly stateCodec: SimulationStateCodec<S>;
+    readonly inputCodec: SimulationStateCodec<I>;
+    readonly optionsCodec: SimulationStateCodec<O>;
+}
+
+/** Same-invocation fresh-run and real retained rollback controls, not B31. */
+export declare const simulationConformance: <S extends AnySchema, I extends AnySchema, O extends AnySchema>(simulation: Simulation<S, I, O>, offered: SimulationConformanceCase, offeredLimits?: SimulationConformanceLimits) => SimulationConformanceResult;
+
+export declare interface SimulationConformanceCase {
+    readonly seed: number;
+    readonly stateSchemaHash: number;
+    /** Actual LSO bytes: never JSON-roundtrip init options. */
+    readonly options: Uint8Array;
+    /** Actual LSI bytes: complete canonical tick-zero input history. */
+    readonly inputs: Uint8Array;
+}
+
+export declare interface SimulationConformanceCaseOptions<I, O> {
+    readonly seed: number;
+    readonly options: O;
+    readonly playerIds: ReadonlyArray<number>;
+    readonly sample: (context: SimulationConformanceSampleContext) => I;
+    readonly inputSeed?: number;
+    readonly ticks?: number;
+    readonly maxBytes?: number | undefined;
+}
+
+export declare interface SimulationConformanceLimits {
+    readonly maxTicks?: number;
+    readonly maxCaseBytes?: number;
+    readonly maxStateBytes?: number;
+    readonly maxRetainedStateBytes?: number;
+    readonly maxWorkSteps?: number;
+    readonly maxObservations?: number;
+    readonly rollbackHorizonTicks?: number;
+    readonly replayEveryTicks?: number;
+}
+
+export declare interface SimulationConformanceObservation {
+    readonly tick: number;
+    /** Always compute the schema hash even when the author overrides hash. */
+    readonly schemaHash: Uint64Words;
+    readonly hash: Uint64Words;
+    readonly rng: Pcg32Snapshot;
+}
+
+export declare interface SimulationConformanceResult {
+    readonly scope: 'local-repeat-and-rollback';
+    readonly trace: SimulationConformanceTrace;
+    readonly ticks: number;
+    readonly stepsExecuted: number;
+    readonly comparisons: number;
+    readonly replays: number;
+}
+
+export declare interface SimulationConformanceSampleContext {
+    readonly tick: number;
+    readonly playerId: number;
+    /** Separate case-generation RNG, never the simulation's retained RNG. */
+    readonly rng: Pcg32;
+}
+
+export declare interface SimulationConformanceTrace {
+    readonly case: SimulationConformanceCase;
+    readonly observations: ReadonlyArray<SimulationConformanceObservation>;
+}
+
+export declare interface SimulationDefinition<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    readonly state: S;
+    readonly input: I;
+    readonly options: O;
+    readonly init: (seed: number, options: (O)["Type"]) => (S)["Type"];
+    readonly step: (state: RoomState<(S)["Type"]>, inputs: ReadonlyArray<SimulationPlayerInput<(I)["Type"]>>, tick: number, rng: Pcg32) => (S)["Type"];
+    readonly hash?: (state: (S)["Type"]) => Uint64Words;
+    /** Late join: runs before `step` at the tick a player's input first appears (it was absent
+     * from the previous tick's inputs), in player-ID order, e.g. to spawn the player. Pure and
+     * deterministic like `step`. Start players are `init`'s job: tick 1 runs no join. */
+    readonly join?: (state: RoomState<(S)["Type"]>, playerId: number, tick: number, rng: Pcg32) => (S)["Type"];
+    readonly limits?: Partial<SimulationValueLimits>;
+}
+
+export declare interface SimulationInputHistory<I> {
+    readonly fromTick: number;
+    readonly playerIds: ReadonlyArray<number>;
+    readonly inputs: ReadonlyArray<SimulationTickInputs<I>>;
+    /** Late joins (LSI/v2): these `playerIds` appear in rows from `tick` on. */
+    readonly joins?: ReadonlyArray<{
+        readonly playerId: number;
+        readonly tick: number;
+    }>;
+}
+
+/** LSI/v1 contains public IDs and actual intentions only. LSI/v2 (late joins) adds each
+ * player's first tick; a row carries only players active at its tick. It supplies neither
+ * state/hash nor Subject/Session/epoch authentication; owner verifies provenance. */
+export declare class SimulationInputHistoryCodec<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    #private;
+    constructor(simulation: Simulation<S, I, O>, offered?: SimulationInputHistoryCodecOptions);
+    private work;
+    private pack;
+    capture(offered: SimulationInputHistory<(I)["Type"]>): SimulationInputHistory<(I)["Type"]>;
+    encode(offered: SimulationInputHistory<(I)["Type"]>): Uint8Array;
+    decode(offered: Uint8Array): SimulationInputHistory<(I)["Type"]>;
+}
+
+export declare interface SimulationInputHistoryCodecOptions {
+    readonly maxBytes?: number | undefined;
+    readonly maxPlayers?: number;
+    readonly maxTicks?: number;
+}
+
+/** Exact bounded options on wire and in SQL. One shared Room compiler with
+ * implicit field IDs and f64 defaults, not a second serialization schema. */
+export declare class SimulationOptionsCodec<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    #private;
+    constructor(simulation: Simulation<S, I, O>);
+    get schemaHash(): number;
+    get maxBytes(): number;
+    private work;
+    private captureOwned;
+    capture(offered: unknown): (O)["Type"];
+    encode(offered: unknown): Uint8Array;
+    decode(offered: Uint8Array): (O)["Type"];
+}
+
+export declare interface SimulationPlayerInput<I> {
+    readonly playerId: number;
+    readonly input: I;
+}
+
+export declare interface SimulationRecovery<S, I> {
+    readonly snapshot: SimulationSnapshot<S>;
+    readonly inputs: ReadonlyArray<SimulationPlayerInput<I>>;
+    readonly continuation?: ReadonlyArray<SimulationTickInputs<I>> | undefined;
+}
+
+/** LSS/v2: actual current LSR snapshot, complete used input base, and following
+ * authoritative matrices. Decoding grants no Session/epoch/roster authority. */
+export declare class SimulationRecoveryCodec<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    #private;
+    constructor(simulation: Simulation<S, I, O>, offered?: SimulationRecoveryCodecOptions);
+    get maxBytes(): number;
+    private work;
+    encode(offered: SimulationRecovery<(S)["Type"], (I)["Type"]>): Uint8Array;
+    decode(offered: Uint8Array): SimulationRecovery<(S)["Type"], (I)["Type"]>;
+}
+
+export declare interface SimulationRecoveryCodecOptions {
+    readonly maxBytes?: number | undefined;
+    readonly maxPlayers?: number;
+    readonly maxTicks?: number;
+}
+
+export declare interface SimulationReplay<S> {
+    readonly fromTick: number;
+    readonly steps: number;
+    readonly snapshot: SimulationSnapshot<S>;
+}
+
+export declare interface SimulationReplayRecording<S, I, O> {
+    readonly seed: number;
+    readonly options: O;
+    readonly base: SimulationSnapshot<S>;
+    readonly inputs: ReadonlyArray<{
+        readonly tick: number;
+        readonly inputs: ReadonlyArray<SimulationPlayerInput<I>>;
+        readonly hash: Uint64Words;
+    }>;
+    /** The matrix used at the base tick: a `join` hook on the first replayed tick compares with it. */
+    readonly baseInputs?: ReadonlyArray<SimulationPlayerInput<I>>;
+}
+
+export declare type SimulationReplayVerification = {
+    readonly _tag: 'verified';
+    readonly ticks: number;
+    readonly throughTick: number;
+    readonly hash: Uint64Words;
+} | {
+    readonly _tag: 'diverged';
+    readonly tick: number;
+    readonly expected: Uint64Words;
+    readonly actual: Uint64Words;
+};
+
+export declare interface SimulationReplayVerifyOptions {
+    readonly maxReplayTicks?: number;
+    readonly maxInputBytes?: number;
+    readonly maxPlayers?: number;
+    readonly maxRejectionAttempts?: number;
+}
+
+/** Memory-only runner. Caller supplies ordered intent authority; replaceInputs
+ * and installSnapshot are explicit local operations, never socket admission. */
+export declare class SimulationRunner<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    #private;
+    constructor(simulation: Simulation<S, I, O>, seed: number, options: (O)["Type"], budgets?: SimulationRunnerOptions);
+    get tick(): number;
+    /** Diagnostic for the last guarded operation only. No state/input/exception
+     * data is retained; read before starting another guarded operation. */
+    get lastFailedTransitionTick(): number | null;
+    get limits(): Resolved<SimulationRunnerOptions>;
+    get oldestTick(): number;
+    private work;
+    private position;
+    private rng;
+    private prepare;
+    private publicSnapshot;
+    snapshot(): SimulationSnapshot<(S)["Type"]>;
+    snapshotAt(tick: number): SimulationSnapshot<(S)["Type"]>;
+    /** Detached retained actual intents for scoped server export/replay owners. */
+    inputsAt(tick: number): ReadonlyArray<SimulationPlayerInput<(I)["Type"]>>;
+    private captureInputs;
+    /** Inputs of a retained tick, or undefined when the runner does not hold them (tick 0, before a snapshot). */
+    private retainedInputs;
+    private transition;
+    advance(inputs: ReadonlyArray<SimulationPlayerInput<(I)["Type"]>>): SimulationSnapshot<(S)["Type"]>;
+    replaceInputs(tick: number, inputs: ReadonlyArray<SimulationPlayerInput<(I)["Type"]>>): SimulationReplay<(S)["Type"]>;
+    replaceInputsRange(changes: ReadonlyArray<SimulationTickInputs<(I)["Type"]>>): SimulationReplay<(S)["Type"]>;
+    /** `inputs`: the matrix used at the snapshot's tick, when known; a `join` hook compares the next tick with it. */
+    installSnapshot(snapshot: SimulationSnapshot<(S)["Type"]>, inputs?: ReadonlyArray<SimulationPlayerInput<(I)["Type"]>>): SimulationSnapshot<(S)["Type"]>;
+    private advanceOwned;
+    /** Replay all affected retained steps in temporary ownership. A callback,
+     * schema/hash/RNG/work failure preserves the original ring and current tick. */
+    private replaceInputsRangeOwned;
+    /** Local reset seam. Network/server provenance must be verified by the Room
+     * integration before calling; matching a non-cryptographic hash grants none. */
+    private installSnapshotOwned;
+}
+
+export declare interface SimulationRunnerOptions {
+    readonly rollbackHorizonTicks?: number;
+    readonly maxReplaySteps?: number;
+    readonly maxPlayers?: number;
+    readonly maxRejectionAttempts?: number;
+}
+
+export declare interface SimulationSnapshot<S> {
+    readonly tick: number;
+    readonly state: S;
+    readonly rng: Pcg32Snapshot;
+    readonly hash: Uint64Words;
+}
+
+/** LSR/v1 bounded snapshot envelope. Reuses the actual Room state codec;
+ * header validates layouts/tick/PCG words/hash, never Room/Subject authority. */
+export declare class SimulationSnapshotCodec<S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>> {
+    #private;
+    constructor(simulation: Simulation<S, I, O>, offered?: SimulationSnapshotCodecOptions);
+    get maxBytes(): number;
+    private work;
+    encode(offered: SimulationSnapshot<(S)["Type"]>): Uint8Array;
+    decode(offered: Uint8Array): SimulationSnapshot<(S)["Type"]>;
+}
+
+export declare interface SimulationSnapshotCodecOptions {
+    readonly maxBytes?: number | undefined;
+}
+
+export declare interface SimulationStateCodec<S extends Schema.Codec<unknown, unknown>> {
+    readonly limits: SimulationValueLimits;
+    /** Admitted capture/hash plan, not a binary Room wire schema. */
+    schemaDescription?(): string;
+    capture(value: unknown): (S)["Type"];
+    hash(value: (S)["Type"]): Uint64Words;
+}
+
+export declare interface SimulationTickInputs<I> {
+    readonly tick: number;
+    readonly inputs: ReadonlyArray<SimulationPlayerInput<I>>;
+}
+
+export declare interface SimulationValueLimits extends RoomCodecLimits {
+    readonly maxNodes: number;
+}
+
+/** Exact unsigned 64-bit integer as independent 32-bit words. */
+declare interface Uint64Words {
+    readonly hi: number;
+    readonly lo: number;
+}
+
+/** Actual local replay execution, first divergent tick only. No engine/run
+ * provenance, live identity, network authority, Nightly or capacity conclusion. */
+export declare const verifySimulationReplay: <S extends Schema.Codec<unknown, unknown>, I extends Schema.Codec<unknown, unknown>, O extends Schema.Codec<unknown, unknown>>(simulation: Simulation<S, I, O>, offered: SimulationReplayRecording<S["Type"], I["Type"], O["Type"]>, budgets?: SimulationReplayVerifyOptions) => SimulationReplayVerification;
+
+export { }

package/dist/simulation.js

@@ -0,0 +1,281 @@
+import { BudgetExceeded as e, RoomAuthoringError as t } from "./errors.js";
+import { captureUint64Words as n, unsignedWord as r } from "./fixedWords.js";
+import { Pcg32 as i } from "./pcg32.js";
+import { freezeSimulationValue as a, simulationOwnData as o, simulationSyncValue as s } from "./simulationAuthoring.js";
+import { createSimulationState as c, schemaSimulationHash as l, simulationValueCodec as u } from "./simulationState.js";
+import { SimulationOptionsCodec as d, createSimulationOptionsCodec as f } from "./simulationOptionsWire.js";
+import { SimulationInputHistoryCodec as p, createSimulationInputHistoryCodec as m } from "./simulationInputHistoryWire.js";
+import { compareSimulationConformanceTraces as h, createSimulationConformanceCase as g, decodeSimulationConformanceCase as _, encodeSimulationConformanceCase as v, runSimulationConformanceTrace as y, simulationConformance as b } from "./simulationConformance.js";
+import { SimulationSnapshotCodec as x, createSimulationSnapshotCodec as S } from "./simulationSnapshotWire.js";
+import { verifySimulationReplay as C } from "./simulationReplay.js";
+import { SimulationRecoveryCodec as w, createSimulationRecoveryCodec as T } from "./simulationRecoveryWire.js";
+import { nonAuthoritative as E } from "./room.js";
+// src/simulation.ts
+var D = /* @__PURE__ */ new WeakSet(), O = (e) => {
+	if (!e || typeof e != "object" || !D.has(e)) throw new t({
+		room: "simulation",
+		detail: "Runner requires a captured simulation declaration"
+	});
+};
+function k(e) {
+	throw new t({
+		room: "simulation",
+		detail: e
+	});
+}
+var A = (e) => {
+	let t = o(e, [
+		"state",
+		"input",
+		"options",
+		"init",
+		"step",
+		"hash",
+		"join",
+		"limits"
+	], [
+		"state",
+		"input",
+		"options",
+		"init",
+		"step"
+	]);
+	if (typeof t.init != "function" || typeof t.step != "function" || ["hash", "join"].some((e) => Object.hasOwn(t, e) && typeof t[e] != "function")) return k("Simulation callbacks must be functions");
+	let n = Object.freeze(t), r = c(n.state, n.limits), i = u(n.input, n.limits ?? {}, !1, !0), a = u(n.options, n.limits ?? {}, !1, !1), s = Object.freeze({
+		definition: Object.freeze({
+			...n,
+			limits: r.limits
+		}),
+		stateCodec: r,
+		inputCodec: i,
+		optionsCodec: a
+	});
+	return D.add(s), s;
+}, j = (e, t) => {
+	let n = new i(0, 0, t);
+	return n.restore(e), n.snapshot();
+}, M = (e, t, i, o, c = 64) => {
+	O(e), r(t);
+	let u = a(e.stateCodec.capture(s(i))), d = e.definition.hash ? n(s(e.definition.hash(u))) : l(e.stateCodec, u);
+	return Object.freeze({
+		tick: t,
+		state: u,
+		rng: j(o, c),
+		hash: d
+	});
+}, N = (e, t, i = 64) => {
+	let a = o(t, [
+		"tick",
+		"state",
+		"rng",
+		"hash"
+	], [
+		"tick",
+		"state",
+		"rng",
+		"hash"
+	]), s = n(a.hash), c = M(e, r(a.tick), a.state, a.rng, i);
+	return c.hash.hi !== s.hi || c.hash.lo !== s.lo ? k("Installed snapshot hash does not match its validated state") : c;
+}, P = (t, n, i) => {
+	if (O(t), !Number.isInteger(i) || i < 1 || i > 64) return k("Invalid simulation player work limit");
+	if (!Array.isArray(n) || n.length > i) throw new e({
+		budget: "simulationPlayers",
+		limit: i
+	});
+	if (Reflect.ownKeys(n).length !== n.length + 1) return k("Simulation inputs require a dense array without extra fields");
+	let s = /* @__PURE__ */ new Set(), c = [];
+	for (let e = 0; e < n.length; e++) {
+		let i = Object.getOwnPropertyDescriptor(n, String(e));
+		if (!i?.enumerable || !("value" in i)) return k("Simulation input arrays cannot contain holes or accessors");
+		let l = o(i.value, ["playerId", "input"], ["playerId", "input"]), u = r(l.playerId);
+		if (s.has(u)) return k("Simulation input player IDs must be unique");
+		s.add(u), c.push(Object.freeze({
+			playerId: u,
+			input: a(t.inputCodec.capture(l.input))
+		}));
+	}
+	return c.sort((e, t) => e.playerId - t.playerId), Object.freeze(c);
+}, F = (e) => {
+	let t = o(e, [
+		"rollbackHorizonTicks",
+		"maxReplaySteps",
+		"maxPlayers",
+		"maxRejectionAttempts"
+	], []), n = (e, n) => Object.hasOwn(t, e) ? t[e] : n, r = n("rollbackHorizonTicks", 8), i = {
+		rollbackHorizonTicks: r,
+		maxReplaySteps: n("maxReplaySteps", r),
+		maxPlayers: n("maxPlayers", 8),
+		maxRejectionAttempts: n("maxRejectionAttempts", 64)
+	}, a = {
+		rollbackHorizonTicks: 4096,
+		maxReplaySteps: 4096,
+		maxPlayers: 64,
+		maxRejectionAttempts: 65536
+	};
+	for (let e of Object.keys(i)) if (!Number.isSafeInteger(i[e]) || i[e] < 1 || i[e] > a[e]) return k("Simulation runner budgets require bounded positive integers");
+	return Object.freeze(i);
+}, I = class {
+	#e;
+	#t;
+	#n = !1;
+	#r = null;
+	#i = 0;
+	#a;
+	#o;
+	#s;
+	constructor(e, t, n, o = {}) {
+		O(e), this.#e = e, this.#t = F(o), r(t);
+		let c = a(e.optionsCodec.capture(n)), l = e.stateCodec.capture(s(e.definition.init(t, c))), u = new i(t, 54, this.#t.maxRejectionAttempts);
+		this.#a = this.prepare(0, l, u.snapshot()), this.#o = Array(this.#t.rollbackHorizonTicks + 1), this.#s = Array(this.#t.rollbackHorizonTicks + 1), this.#o[0] = this.#a;
+	}
+	get tick() {
+		return this.#a.tick;
+	}
+	get lastFailedTransitionTick() {
+		return this.#r;
+	}
+	get limits() {
+		return this.#t;
+	}
+	get oldestTick() {
+		return Math.max(this.#i, this.tick - this.#t.rollbackHorizonTicks);
+	}
+	work(e) {
+		if (this.#n) return k("Simulation mutation cannot reenter an active step or replay");
+		this.#r = null, this.#n = !0;
+		try {
+			return e();
+		} finally {
+			this.#n = !1;
+		}
+	}
+	position(e) {
+		return e % this.#o.length;
+	}
+	rng(e) {
+		let t = new i(0, 0, this.#t.maxRejectionAttempts);
+		return t.restore(e), t;
+	}
+	prepare(e, t, n) {
+		return M(this.#e, e, t, n, this.#t.maxRejectionAttempts);
+	}
+	publicSnapshot(e) {
+		return Object.freeze({
+			tick: e.tick,
+			state: a(this.#e.stateCodec.capture(e.state)),
+			rng: Object.freeze({ ...e.rng }),
+			hash: Object.freeze({ ...e.hash })
+		});
+	}
+	snapshot() {
+		return this.publicSnapshot(this.#a);
+	}
+	snapshotAt(e) {
+		r(e);
+		let t = this.#o[this.position(e)];
+		return !t || t.tick !== e || e < this.oldestTick || e > this.tick ? k("Simulation snapshot is outside retained history") : this.publicSnapshot(t);
+	}
+	inputsAt(e) {
+		return this.work(() => {
+			r(e);
+			let t = this.#s[this.position(e)];
+			return !t || t.tick !== e || e <= this.oldestTick || e > this.tick ? k("Simulation inputs are outside retained history") : this.captureInputs(t.inputs);
+		});
+	}
+	captureInputs(e) {
+		return P(this.#e, e, this.#t.maxPlayers);
+	}
+	retainedInputs(e) {
+		let t = this.#s[this.position(e)];
+		return t?.tick === e ? t.inputs : void 0;
+	}
+	transition(e, t, n) {
+		if (e.tick === 4294967295) return k("Simulation tick overflow requires an explicit new run");
+		try {
+			let r = this.#e.stateCodec.capture(e.state), i = this.rng(e.rng), a = this.#e.definition.join;
+			if (a && n) for (let o of t) n.some((e) => e.playerId === o.playerId) || (r = this.#e.stateCodec.capture(s(a(r, o.playerId, e.tick + 1, i))));
+			let o = this.#e.definition.step(r, t, e.tick + 1, i);
+			return this.prepare(e.tick + 1, o, i.snapshot());
+		} catch (t) {
+			throw this.#r = e.tick + 1, t;
+		}
+	}
+	advance(e) {
+		return this.work(() => this.advanceOwned(e));
+	}
+	replaceInputs(e, t) {
+		return this.work(() => this.replaceInputsRangeOwned([{
+			tick: e,
+			inputs: t
+		}]));
+	}
+	replaceInputsRange(e) {
+		return this.work(() => this.replaceInputsRangeOwned(e));
+	}
+	installSnapshot(e, t) {
+		return this.work(() => this.installSnapshotOwned(e, t));
+	}
+	advanceOwned(e) {
+		let t = this.captureInputs(e), n = this.transition(this.#a, t, this.retainedInputs(this.#a.tick)), r = this.publicSnapshot(n), i = this.position(n.tick);
+		return this.#o[i] = n, this.#s[i] = Object.freeze({
+			tick: n.tick,
+			inputs: t
+		}), this.#a = n, r;
+	}
+	replaceInputsRangeOwned(t) {
+		if (!Array.isArray(t) || t.length < 1 || t.length > this.#t.maxReplaySteps) throw new e({
+			budget: "simulationReplaySteps",
+			limit: this.#t.maxReplaySteps
+		});
+		if (Reflect.ownKeys(t).length !== t.length + 1) return k("Simulation corrections require a dense own-data array");
+		let n = /* @__PURE__ */ new Map(), i = this.tick;
+		for (let e = 0; e < t.length; e++) {
+			let a = Object.getOwnPropertyDescriptor(t, String(e));
+			if (!a?.enumerable || !("value" in a)) return k("Simulation correction arrays cannot contain holes or accessors");
+			let s = o(a.value, ["tick", "inputs"], ["tick", "inputs"]), c = r(s.tick);
+			if (c < 1 || c <= this.oldestTick || c > this.tick) return k("Corrected input tick is outside retained rollback history");
+			if (n.has(c)) return k("Simulation correction ticks must be unique");
+			n.set(c, this.captureInputs(s.inputs)), i = Math.min(i, c);
+		}
+		let a = this.tick - i + 1;
+		if (a > this.#t.maxReplaySteps) throw new e({
+			budget: "simulationReplaySteps",
+			limit: this.#t.maxReplaySteps
+		});
+		let s = this.#o[this.position(i - 1)];
+		if (!s || s.tick !== i - 1) return k("Rollback base snapshot is unavailable");
+		let c = [], l = s, u = this.retainedInputs(i - 1);
+		for (let e = i; e <= this.tick; e++) {
+			let t = this.#s[this.position(e)];
+			if (!t || t.tick !== e) return k("Rollback input history is unavailable");
+			let r = n.get(e) ?? t.inputs;
+			l = this.transition(l, r, u), c.push({
+				snapshot: l,
+				inputs: r
+			}), u = r;
+		}
+		let d = Object.freeze({
+			fromTick: i,
+			steps: a,
+			snapshot: this.publicSnapshot(l)
+		});
+		for (let e of c) {
+			let t = this.position(e.snapshot.tick);
+			this.#o[t] = e.snapshot, this.#s[t] = Object.freeze({
+				tick: e.snapshot.tick,
+				inputs: e.inputs
+			});
+		}
+		return this.#a = l, d;
+	}
+	installSnapshotOwned(e, t) {
+		let n = N(this.#e, e, this.#t.maxRejectionAttempts), r = n.tick, i = t === void 0 ? void 0 : this.captureInputs(t), a = this.publicSnapshot(n), o = Array(this.#o.length);
+		o[this.position(r)] = n;
+		let s = Array(this.#s.length);
+		return i && (s[this.position(r)] = Object.freeze({
+			tick: r,
+			inputs: i
+		})), this.#o = o, this.#s = s, this.#a = n, this.#i = r, a;
+	}
+}, L = (e, t, n, r = {}) => new I(e, t, n, r);
+export { p as SimulationInputHistoryCodec, d as SimulationOptionsCodec, w as SimulationRecoveryCodec, I as SimulationRunner, x as SimulationSnapshotCodec, O as assertCapturedSimulation, P as captureSimulationInputs, N as captureSimulationSnapshot, h as compareSimulationConformanceTraces, g as createSimulationConformanceCase, m as createSimulationInputHistoryCodec, f as createSimulationOptionsCodec, T as createSimulationRecoveryCodec, L as createSimulationRunner, S as createSimulationSnapshotCodec, c as createSimulationState, _ as decodeSimulationConformanceCase, A as defineSimulation, v as encodeSimulationConformanceCase, E as nonAuthoritative, M as prepareSimulationSnapshot, y as runSimulationConformanceTrace, l as schemaSimulationHash, b as simulationConformance, C as verifySimulationReplay };