@series-inc/rundot-game-sdk 5.23.0-beta.5 → 5.23.0-beta.6

package/dist/{SyncplayRoomTransport-DXNJxFKZ.d.ts → SyncplayRoomTransport-ByIm59Ie.d.ts}

@@ -1,4 +1,4 @@
-import { C as CanonicalValue, R as ReplayFile, O as OfflineSession } from './types-BLIISDww.js';
+import { C as CanonicalValue, h as ReplayFile, O as OfflineSession } from './types-DbhOvOdx.js';
 import { M as MultiplayerApi } from './MultiplayerApi-nnrGTTcO.js';
 
 /**
@@ -83,6 +83,95 @@ interface InputAuthority {
 }
 declare function createInputAuthority(config: InputAuthorityConfig): InputAuthority;
 
+/**
+ * Frozen v1 session-control wire protocol for game-agnostic input-authority rooms (§8, M1).
+ *
+ * Covers the server/client roles for a live match: session-start (slot assignment + the
+ * server-owned RNG seed + tick params), clock/time-sync, input, confirmed-input (the verified
+ * tick), reconnect, spectator, and close/error. Snapshot request/offer/chunk/complete for
+ * late-join reuse the existing envelopes in `local-authority-wire.ts` (wired at M5).
+ *
+ * Both families share the `rdm-local-authority/v1` version namespace. Decoding is FAIL-CLOSED:
+ * unknown protocol, unknown version, unknown kind, malformed payload, or checksum mismatch are
+ * rejected with a reason — never silently coerced. This is a public forward-compat boundary; the
+ * discriminants below are frozen and must only be extended, never repurposed.
+ */
+declare const deterministicSessionWireVersion = 1;
+type DeterministicSessionRole = 'player' | 'spectator';
+type DeterministicSessionMessage = {
+    readonly kind: 'session-start';
+    readonly slot: number;
+    readonly playerCount: number;
+    readonly seed: number;
+    readonly tickRateHz: number;
+    readonly hardToleranceTicks: number;
+    readonly role: DeterministicSessionRole;
+} | {
+    readonly kind: 'time-sync-ping';
+    readonly clientSendTick: number;
+    readonly nonce: number;
+} | {
+    readonly kind: 'time-sync-pong';
+    readonly clientSendTick: number;
+    readonly nonce: number;
+    readonly authorityTick: number;
+} | {
+    readonly kind: 'input';
+    readonly slot: number;
+    readonly tick: number;
+    readonly input: EncodedInput;
+    readonly attempt: number;
+} | {
+    readonly kind: 'confirmed-input';
+    readonly authorityTick: number;
+    readonly frames: readonly ConfirmedInputFrame[];
+} | {
+    readonly kind: 'reconnect';
+    readonly slot: number;
+    readonly resumeFromTick: number;
+} | {
+    readonly kind: 'spectator-join';
+} | {
+    readonly kind: 'checksum-report';
+    readonly slot: number;
+    readonly tick: number;
+    readonly checksum: string;
+} | {
+    /**
+     * Client → authority netcode telemetry (G8). Additive v1 extension: unknown
+     * kinds are dropped fail-closed by older decoders, so this never breaks an
+     * old authority. All fields are integers (rttMs rounded, timescale in
+     * permille) so the payload stays canonical-checksum friendly.
+     */
+    readonly kind: 'net-stats';
+    readonly slot: number;
+    readonly tick: number;
+    readonly rttMs: number;
+    readonly rollbacks: number;
+    readonly maxRollbackDepth: number;
+    readonly timescalePermille: number;
+    readonly inputDelayTicks: number;
+} | {
+    readonly kind: 'close';
+    readonly code: string;
+    readonly reason: string;
+} | {
+    readonly kind: 'error';
+    readonly code: string;
+    readonly message: string;
+};
+type DeterministicSessionMessageKind = DeterministicSessionMessage['kind'];
+type DeterministicSessionDecodeRejection = 'invalid-json' | 'not-an-envelope' | 'unknown-protocol' | 'unknown-version' | 'unknown-kind' | 'checksum-mismatch' | 'malformed-payload';
+type DeterministicSessionDecodeResult = {
+    readonly ok: true;
+    readonly message: DeterministicSessionMessage;
+} | {
+    readonly ok: false;
+    readonly reason: DeterministicSessionDecodeRejection;
+};
+declare function encodeDeterministicSessionMessage(message: DeterministicSessionMessage): string;
+declare function decodeDeterministicSessionMessage(text: string): DeterministicSessionDecodeResult;
+
 /**
  * Reusable client transport for game-agnostic deterministic multiplayer (§6 M4).
  *
@@ -120,17 +209,83 @@ interface NetworkedSyncplayClientOptions<State, Input> {
      * `restoreToFrame`, which would rewind the live session. Default 120.
      */
     readonly checksumCadenceTicks?: number;
+    /**
+     * Wall-clock pacing + clock-drift correction (G1), consumed by
+     * {@link NetworkedSyncplayClient.pumpPaced}. The step-counted `pump()` path
+     * ignores all of this, so step-driven tests and existing callers are
+     * unaffected. Rates are per-tick error corrections in the Quantum
+     * TimeCorrectionRate / GGPO frames-behind family: the client measures RTT via
+     * `time-sync-ping/pong`, estimates the authority frontier, and nudges its
+     * local timescale inside [minTimescale, maxTimescale] so it neither stalls at
+     * the prediction cap (fast clock / short path) nor starves into permanent
+     * substitution (slow clock / long path).
+     */
+    readonly pacing?: NetworkedSyncplayClientPacingOptions;
+    /**
+     * Own-input scheduling delay in ticks (G2): input sampled while predicting
+     * tick T is bound and sent for tick T+delay, trading a fixed sliver of local
+     * latency for inputs that arrive before the authority's deadline (fewer
+     * substitutions of THIS client's input, shallower rollbacks for peers).
+     * With `maxTicks > minTicks` the delay auto-tunes from measured RTT
+     * (ping-adaptive, Quantum InputDelayMin/Max analog) — RTT measurement
+     * requires driving `pumpPaced`. Defaults to a static 0 (today's behavior).
+     */
+    readonly inputDelay?: NetworkedSyncplayClientInputDelayOptions;
+    /** Monotonic-enough clock for RTT measurement. Default Date.now. NEVER used by the sim. */
+    readonly now?: () => number;
+}
+interface NetworkedSyncplayClientPacingOptions {
+    /** Interval between time-sync pings while pumpPaced is driven. Default 1000. */
+    readonly pingIntervalMs?: number;
+    /** Safety lead (ticks) kept over the input-arrival deadline. Default 2. */
+    readonly targetLeadTicks?: number;
+    /** Timescale clamp. Defaults 0.9 / 1.1 (±10%, imperceptible per Quantum/GGPO practice). */
+    readonly minTimescale?: number;
+    readonly maxTimescale?: number;
+    /** Timescale correction gain per tick of frame-advantage error. Default 0.02. */
+    readonly correctionPerTick?: number;
+    /** Catch-up cap: max frames stepped per pumpPaced call. Default 4. */
+    readonly maxStepsPerPump?: number;
+}
+interface NetworkedSyncplayClientInputDelayOptions {
+    /** Minimum (and initial) own-input delay in ticks. Default 0. */
+    readonly minTicks?: number;
+    /** Maximum delay for ping-adaptive tuning. Default = minTicks (static). */
+    readonly maxTicks?: number;
+}
+/** Live netcode telemetry for the local client (G8). */
+interface NetworkedSyncplayClientNetStats {
+    /** Smoothed RTT in ms; -1 until the first time-sync pong arrives. */
+    readonly rttMs: number;
+    /** Current pacing timescale in permille (1000 = realtime). */
+    readonly timescalePermille: number;
+    readonly inputDelayTicks: number;
+    readonly rollbacks: number;
+    readonly maxRollbackDepth: number;
 }
 interface NetworkedSyncplayClient {
     readonly slot: number;
+    /** 'player' (holds a slot) or 'spectator' (read-only follower, slot -1). From session-start. */
+    readonly role: DeterministicSessionRole;
     readonly ready: boolean;
     readonly predictedThrough: number;
     readonly appliedThrough: number;
     readonly rollbacks: number;
+    /** Live local netcode telemetry (RTT, timescale, delay, rollback depth). */
+    readonly netStats: NetworkedSyncplayClientNetStats;
     /** Resolves once `session-start` has been received. */
     whenReady(): Promise<void>;
     /** Predict and submit local input up to the prediction budget. */
     pump(): void;
+    /**
+     * Wall-clock-paced pump (G1): steps as many fixed frames as elapsed time ×
+     * the drift-corrected timescale allows (bounded by the prediction budget and
+     * the catch-up cap), and drives RTT pings. Call once per host frame (rAF /
+     * host tick) with a monotonic-enough `nowMs`. Prefer this over raw `pump()`
+     * on real networks — raw pump() slams into the prediction cap and
+     * rubber-bands under asymmetric latency.
+     */
+    pumpPaced(nowMs: number): void;
     /** Report this client's confirmed-state checksum for desync telemetry. */
     reportChecksum(): void;
     /** Confirmed-state checksum at `frame` (must be <= appliedThrough + 1). */
@@ -193,4 +348,4 @@ declare function joinSyncplayRoomByCode(api: MultiplayerApi, code: string): Prom
  */
 declare function createSyncplayRoom(api: MultiplayerApi): Promise<SyncplayRoomTransport>;
 
-export { type ConfirmedInputFrame as C, type EncodedInput as E, type InputAuthority as I, type NetworkedClientTransport as N, type SyncplayRoomTransport as S, type InputAuthorityConfig as a, type InputAuthorityRestoreState as b, type InputAuthorityStats as c, type InputRejectionReason as d, type InputSubmissionResult as e, type NetworkedSyncplayClient as f, type NetworkedSyncplayClientOptions as g, createInputAuthority as h, createNetworkedSyncplayClient as i, createSyncplayRoom as j, joinSyncplayRoomByCode as k };
+export { type ConfirmedInputFrame as C, type DeterministicSessionDecodeRejection as D, type EncodedInput as E, type InputAuthority as I, type NetworkedClientTransport as N, type SyncplayRoomTransport as S, type DeterministicSessionDecodeResult as a, type DeterministicSessionMessage as b, type DeterministicSessionMessageKind as c, type DeterministicSessionRole as d, type InputAuthorityConfig as e, type InputAuthorityRestoreState as f, type InputAuthorityStats as g, type InputRejectionReason as h, type InputSubmissionResult as i, type NetworkedSyncplayClient as j, type NetworkedSyncplayClientInputDelayOptions as k, type NetworkedSyncplayClientNetStats as l, type NetworkedSyncplayClientOptions as m, type NetworkedSyncplayClientPacingOptions as n, createInputAuthority as o, createNetworkedSyncplayClient as p, createSyncplayRoom as q, decodeDeterministicSessionMessage as r, deterministicSessionWireVersion as s, encodeDeterministicSessionMessage as t, joinSyncplayRoomByCode as u };

package/dist/{chunk-T6Q5GL7B.js → chunk-G7TYQYHC.js}

@@ -1714,8 +1714,12 @@ function verifyReplayWithDescriptor(config) {
     replay: config.replay,
     step: config.step,
     defaultInput: config.defaultInput,
-    inputSchemaId: artifacts.descriptor.input.id,
-    stateSchemaId: artifacts.descriptor.state.id,
+    // The CONTENT-HASHED identity, not the author label: runtimes stamp
+    // replayIdentity.* into exported replays (a field edit without a label
+    // bump must change the identity), so the descriptor-derived verifier must
+    // compare the same form or every defineSyncplayGame replay fails identity.
+    inputSchemaId: artifacts.descriptor.replayIdentity.inputSchemaId,
+    stateSchemaId: artifacts.descriptor.replayIdentity.stateSchemaId,
     deterministicVersion: artifacts.descriptor.deterministicVersion,
     canonicalizeInput(input) {
       return artifacts.canonicalizeInput(input);
@@ -2072,6 +2076,38 @@ function createSyncplayOfflineRuntime(config) {
   return runtime;
 }
 
+// ../syncplay/src/collections.ts
+function stableSortedKeys(record) {
+  return Object.keys(record).sort(compareStrings3);
+}
+function stableEntries(record) {
+  return stableSortedKeys(record).map((id) => ({ id, value: record[id] }));
+}
+function createStableIndexedMap(entries) {
+  const sorted = [...entries].sort((left, right) => compareStrings3(left.id, right.id));
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of sorted) {
+    if (result.has(entry.id)) {
+      throw new Error(`Duplicate stable id ${entry.id}`);
+    }
+    result.set(entry.id, entry.value);
+  }
+  return result;
+}
+function compareStrings3(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function deterministicShuffle(values, random) {
+  const result = values.slice();
+  for (let index = result.length - 1; index > 0; index -= 1) {
+    const swapIndex = random.nextInt(0, index);
+    const value = result[index];
+    result[index] = result[swapIndex];
+    result[swapIndex] = value;
+  }
+  return result;
+}
+
 // ../syncplay/src/commands.ts
 function createDeterministicCommandTimeline(config) {
   validateCommandTimelineConfig(config);
@@ -2966,19 +3002,19 @@ function collectCommandAssetRefs(value, fields) {
   } else {
     visitBySchema(value, fields);
   }
-  return refs.sort(compareStrings3);
+  return refs.sort(compareStrings4);
 }
 function stableRecordKeys(record) {
-  return Reflect.ownKeys(record).filter((key) => typeof key === "string").sort(compareStrings3);
+  return Reflect.ownKeys(record).filter((key) => typeof key === "string").sort(compareStrings4);
 }
 function reject(command, reason) {
   return { commandId: command.id, reason };
 }
 function compareCommands(left, right) {
-  return left.frame - right.frame || left.slot - right.slot || compareStrings3(left.channelId, right.channelId) || compareStrings3(left.id, right.id);
+  return left.frame - right.frame || left.slot - right.slot || compareStrings4(left.channelId, right.channelId) || compareStrings4(left.id, right.id);
 }
 function compareRejectedCommands(left, right) {
-  return compareStrings3(left.commandId, right.commandId) || compareStrings3(left.reason, right.reason);
+  return compareStrings4(left.commandId, right.commandId) || compareStrings4(left.reason, right.reason);
 }
 function sortCommands(commands) {
   return [...commands].sort(compareCommands);
@@ -3003,10 +3039,401 @@ function percentile(values, percentileRank) {
   const sorted = [...values].sort((left, right) => left - right);
   return sorted[Math.min(sorted.length - 1, Math.floor(percentileRank / 100 * sorted.length))];
 }
-function compareStrings3(left, right) {
+function compareStrings4(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
-export { DeterministicRandom, SyncplayError, assertDeterministicPayloadFields, canonicalStringify, canonicalize, cloneCanonical, createDeterministicCommandTimeline, createDeterministicCommandTimelineSnapshot, createDeterministicMath, createOfflineSession, createSchemaArtifacts, createSyncplayOfflineRuntime, decodeCanonicalBytes, decodeCanonicalValue, decodeUtf8, defaultChecksum, defineSyncplayGame, deterministicPayloadMatchesFields, encodeCanonicalBytes, encodeUtf8, evaluateDeterministicCommandTimelineMigrationResult, invariant, runDeterministicCommandProtocolFixture, runDeterministicCommandTimelineMigrationFixture, runDeterministicReliableCommandDefaultsFixture, stableDescriptorId, verifyReplay, verifyReplayWithDescriptor, withRuntimeDeterminismGuards };
-//# sourceMappingURL=chunk-T6Q5GL7B.js.map
-//# sourceMappingURL=chunk-T6Q5GL7B.js.map
+// ../syncplay/src/instant-replay.ts
+function runInstantReplay(options) {
+  const session = options.createSession();
+  session.restoreSnapshot(options.snapshot);
+  let expectedFrame = options.snapshot.frame;
+  for (const inputFrame of options.inputs) {
+    if (inputFrame.frame !== expectedFrame) {
+      throw new SyncplayError(
+        `Instant replay inputs must be contiguous from snapshot frame ${options.snapshot.frame}: expected frame ${expectedFrame}, got ${inputFrame.frame}`,
+        { code: "instant-replay.non-contiguous-inputs", frame: inputFrame.frame }
+      );
+    }
+    for (let slot = 0; slot < inputFrame.inputs.length; slot += 1) {
+      const recorded = inputFrame.inputs[slot];
+      session.setInput(slot, options.decodeInput !== void 0 ? options.decodeInput(recorded, slot) : recorded);
+    }
+    session.stepFrames(1);
+    options.onFrame(session.getState(), session.currentFrame);
+    expectedFrame += 1;
+  }
+  const finalSnapshot = session.getSnapshot(session.currentFrame);
+  if (finalSnapshot === void 0) {
+    throw new SyncplayError("Instant replay session has no snapshot at its final frame", {
+      code: "instant-replay.missing-final-snapshot",
+      frame: session.currentFrame
+    });
+  }
+  return { framesPlayed: options.inputs.length, finalChecksum: finalSnapshot.checksum };
+}
+function createInstantReplayRunner(config, options) {
+  invariant(
+    Number.isInteger(options.window) && options.window >= 1,
+    "Instant replay window must be a positive integer",
+    "instant-replay.invalid-window"
+  );
+  const replayConfig = {
+    ...config,
+    replayRecordingMode: "none",
+    snapshotBufferSize: 1,
+    onInputFrameRecorded: void 0,
+    onCommandFrameRecorded: void 0,
+    onChecksumRecorded: void 0
+  };
+  return {
+    window: options.window,
+    run(runOptions) {
+      if (runOptions.inputs.length > options.window) {
+        throw new SyncplayError(
+          `Instant replay covers ${runOptions.inputs.length} ticks, above window ${options.window}`,
+          { code: "instant-replay.window-exceeded", frame: runOptions.snapshot.frame }
+        );
+      }
+      return runInstantReplay({
+        createSession: () => createOfflineSession(replayConfig),
+        snapshot: runOptions.snapshot,
+        inputs: runOptions.inputs,
+        decodeInput: runOptions.decodeInput,
+        onFrame: runOptions.onFrame
+      });
+    }
+  };
+}
+
+// ../syncplay/src/pause-resume.ts
+function createPauseController(options) {
+  const step = (state, inputs, frame, ctx) => {
+    const previousHeld = state.pause.toggleHeld;
+    let risingEdges = 0;
+    const toggleHeld = inputs.map((input, slot) => {
+      const held = options.isPauseToggle(input, slot) === true;
+      if (held && previousHeld[slot] !== true) {
+        risingEdges += 1;
+      }
+      return held;
+    });
+    const flips = risingEdges % 2 === 1;
+    const status = flips ? state.pause.status === "running" ? "paused" : "running" : state.pause.status;
+    const toggleCount = state.pause.toggleCount + risingEdges;
+    if (status === "paused") {
+      return {
+        pause: { status, pausedFrames: state.pause.pausedFrames + 1, toggleCount, toggleHeld },
+        game: state.game
+      };
+    }
+    return {
+      pause: { status, pausedFrames: state.pause.pausedFrames, toggleCount, toggleHeld },
+      game: options.wrap(state.game, inputs, frame, ctx)
+    };
+  };
+  return {
+    wrapInitialState(gameState) {
+      return {
+        pause: { status: "running", pausedFrames: 0, toggleCount: 0, toggleHeld: [] },
+        game: gameState
+      };
+    },
+    step,
+    isPaused(state) {
+      return state.pause.status === "paused";
+    }
+  };
+}
+
+// ../syncplay/src/session-snapshot.ts
+function deterministicRoomDescriptorHash(params) {
+  return defaultChecksum({
+    kind: "rdm-room-descriptor",
+    seed: params.seed,
+    playerCount: params.playerCount,
+    tickRateHz: params.tickRateHz,
+    hardToleranceTicks: params.hardToleranceTicks
+  });
+}
+function encodeDeterministicStateSnapshot(snapshot) {
+  return canonicalStringify(snapshot);
+}
+function decodeDeterministicStateSnapshot(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return { ok: false, reason: "invalid-json" };
+  }
+  if (!isRecord2(parsed)) {
+    return { ok: false, reason: "not-a-snapshot" };
+  }
+  if (parsed.v !== 1) {
+    return { ok: false, reason: "unsupported-snapshot-version" };
+  }
+  if (!isNonNegativeInt(parsed.tick) || !isNonNegativeInt(parsed.sessionFrame) || parsed.sessionFrame !== parsed.tick + 1 || typeof parsed.stateBytes !== "string" || !Number.isInteger(parsed.randomState) || typeof parsed.stateChecksum !== "string" || parsed.stateChecksum.length === 0 || !Array.isArray(parsed.confirmedInputs)) {
+    return { ok: false, reason: "malformed-snapshot" };
+  }
+  return {
+    ok: true,
+    snapshot: {
+      v: 1,
+      tick: parsed.tick,
+      sessionFrame: parsed.sessionFrame,
+      stateBytes: parsed.stateBytes,
+      randomState: parsed.randomState,
+      stateChecksum: parsed.stateChecksum,
+      confirmedInputs: cloneCanonical(parsed.confirmedInputs)
+    }
+  };
+}
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var BASE64_LOOKUP = new Map(
+  [...BASE64_ALPHABET].map((char, index) => [char, index])
+);
+function bytesToBase64(bytes) {
+  let out = "";
+  for (let index = 0; index < bytes.length; index += 3) {
+    const b0 = bytes[index];
+    const b1 = index + 1 < bytes.length ? bytes[index + 1] : 0;
+    const b2 = index + 2 < bytes.length ? bytes[index + 2] : 0;
+    out += BASE64_ALPHABET[b0 >> 2];
+    out += BASE64_ALPHABET[(b0 & 3) << 4 | b1 >> 4];
+    out += index + 1 < bytes.length ? BASE64_ALPHABET[(b1 & 15) << 2 | b2 >> 6] : "=";
+    out += index + 2 < bytes.length ? BASE64_ALPHABET[b2 & 63] : "=";
+  }
+  return out;
+}
+function base64ToBytes(text) {
+  if (text.length % 4 !== 0) {
+    throw new Error("base64 length must be a multiple of 4");
+  }
+  const padding = text.endsWith("==") ? 2 : text.endsWith("=") ? 1 : 0;
+  const byteLength = text.length / 4 * 3 - padding;
+  const bytes = new Uint8Array(byteLength);
+  let byteIndex = 0;
+  for (let index = 0; index < text.length; index += 4) {
+    const values = [];
+    for (let offset = 0; offset < 4; offset += 1) {
+      const char = text[index + offset];
+      if (char === "=") {
+        if (index + 4 < text.length || offset < 2) {
+          throw new Error("base64 padding is only valid at the end");
+        }
+        values.push(0);
+        continue;
+      }
+      const value = BASE64_LOOKUP.get(char);
+      if (value === void 0) {
+        throw new Error(`invalid base64 character ${JSON.stringify(char)}`);
+      }
+      values.push(value);
+    }
+    const triple = values[0] << 18 | values[1] << 12 | values[2] << 6 | values[3];
+    if (byteIndex < byteLength) bytes[byteIndex++] = triple >> 16 & 255;
+    if (byteIndex < byteLength) bytes[byteIndex++] = triple >> 8 & 255;
+    if (byteIndex < byteLength) bytes[byteIndex++] = triple & 255;
+  }
+  return bytes;
+}
+var DEFAULT_SNAPSHOT_CHUNK_SIZE = 262144;
+var DEFAULT_MAX_SNAPSHOT_BYTES = 4194304;
+function createSnapshotTransferFromBytes(snapshotBytes, options) {
+  const chunkSize = options.chunkSize ?? DEFAULT_SNAPSHOT_CHUNK_SIZE;
+  if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
+    throw new Error("Snapshot chunkSize must be a positive integer");
+  }
+  if (snapshotBytes.length === 0) {
+    throw new Error("Snapshot bytes must be non-empty");
+  }
+  const chunks = [];
+  for (let offset = 0; offset < snapshotBytes.length; offset += chunkSize) {
+    chunks.push(snapshotBytes.slice(offset, offset + chunkSize));
+  }
+  return {
+    transferId: options.transferId,
+    identity: cloneCanonical(options.identity),
+    frame: options.frame,
+    snapshotChecksum: defaultChecksum(snapshotBytes),
+    snapshotBytes,
+    chunkSize,
+    chunks,
+    chunkChecksums: chunks.map((chunk) => defaultChecksum(chunk))
+  };
+}
+function createSnapshotTransferCollector(options = {}) {
+  const maxSnapshotBytes = options.maxSnapshotBytes ?? DEFAULT_MAX_SNAPSHOT_BYTES;
+  const pending = /* @__PURE__ */ new Map();
+  return {
+    offer(payload) {
+      const identity = parseIdentity(payload.identity);
+      if (typeof payload.transferId !== "string" || payload.transferId.length === 0 || identity === void 0 || !isNonNegativeInt(payload.frame) || typeof payload.snapshotChecksum !== "string" || !isNonNegativeInt(payload.chunkCount) || payload.chunkCount < 1 || !isNonNegativeInt(payload.totalBytes) || payload.totalBytes < 1 || // Every chunk carries at least one character, so a chunkCount that
+      // exceeds totalBytes is self-contradictory (forged offer).
+      payload.chunkCount > payload.totalBytes || !isStringArray(payload.chunkChecksums) || payload.chunkChecksums.length !== payload.chunkCount) {
+        return { accepted: false, reason: "malformed-snapshot-offer" };
+      }
+      if (payload.totalBytes > maxSnapshotBytes) {
+        return { accepted: false, reason: "snapshot-too-large" };
+      }
+      pending.set(payload.transferId, {
+        transferId: payload.transferId,
+        identity,
+        frame: payload.frame,
+        snapshotChecksum: payload.snapshotChecksum,
+        chunkCount: payload.chunkCount,
+        totalBytes: payload.totalBytes,
+        chunkChecksums: [...payload.chunkChecksums],
+        chunks: /* @__PURE__ */ new Map()
+      });
+      return { accepted: true };
+    },
+    chunk(payload) {
+      if (typeof payload.transferId !== "string") {
+        return { accepted: false, reason: "malformed-snapshot-chunk" };
+      }
+      const transfer = pending.get(payload.transferId);
+      if (transfer === void 0) {
+        return { accepted: false, reason: "unknown-snapshot-transfer" };
+      }
+      if (typeof payload.chunk !== "string" || typeof payload.chunkChecksum !== "string") {
+        return { accepted: false, reason: "malformed-snapshot-chunk" };
+      }
+      const chunkIndex = payload.chunkIndex;
+      if (!isNonNegativeInt(chunkIndex) || chunkIndex >= transfer.chunkCount) {
+        return { accepted: false, reason: "snapshot-chunk-index-out-of-range" };
+      }
+      if (transfer.chunks.has(chunkIndex)) {
+        return { accepted: false, reason: "duplicate-snapshot-chunk" };
+      }
+      if (transfer.chunkChecksums[chunkIndex] !== payload.chunkChecksum || defaultChecksum(payload.chunk) !== payload.chunkChecksum) {
+        return { accepted: false, reason: "snapshot-chunk-checksum-mismatch" };
+      }
+      transfer.chunks.set(chunkIndex, payload.chunk);
+      return { accepted: true };
+    },
+    complete(payload) {
+      if (typeof payload.transferId !== "string") {
+        return { accepted: false, reason: "malformed-snapshot-complete" };
+      }
+      const transfer = pending.get(payload.transferId);
+      if (transfer === void 0) {
+        return { accepted: false, reason: "unknown-snapshot-transfer" };
+      }
+      if (transfer.chunks.size !== transfer.chunkCount) {
+        return { accepted: false, reason: "missing-snapshot-chunk" };
+      }
+      const snapshotBytes = Array.from(
+        { length: transfer.chunkCount },
+        (_, index) => transfer.chunks.get(index)
+      ).join("");
+      pending.delete(payload.transferId);
+      if (snapshotBytes.length !== transfer.totalBytes) {
+        return { accepted: false, reason: "snapshot-byte-length-mismatch" };
+      }
+      if (defaultChecksum(snapshotBytes) !== transfer.snapshotChecksum) {
+        return { accepted: false, reason: "snapshot-transfer-checksum-mismatch" };
+      }
+      return {
+        accepted: true,
+        transfer: {
+          transferId: transfer.transferId,
+          identity: transfer.identity,
+          frame: transfer.frame,
+          snapshotChecksum: transfer.snapshotChecksum,
+          snapshotBytes
+        }
+      };
+    },
+    abort(transferId) {
+      pending.delete(transferId);
+    },
+    get pendingTransferIds() {
+      return [...pending.keys()];
+    }
+  };
+}
+function parseIdentity(value) {
+  if (!isRecord2(value) || typeof value.descriptorHash !== "string" || value.descriptorHash.length === 0) {
+    return void 0;
+  }
+  return {
+    descriptorHash: value.descriptorHash,
+    ...typeof value.schemaHash === "string" ? { schemaHash: value.schemaHash } : {},
+    ...typeof value.assetDbHash === "string" ? { assetDbHash: value.assetDbHash } : {},
+    ...typeof value.configHash === "string" ? { configHash: value.configHash } : {}
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonNegativeInt(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+
+// ../syncplay/src/session-promotion.ts
+function exportPromotionSnapshot(session, frame) {
+  const targetFrame = frame ?? session.currentFrame;
+  invariant(
+    Number.isInteger(targetFrame) && targetFrame >= 1,
+    "Promotion export requires a stepped frame (>= 1): the v1 snapshot envelope encodes tick = frame - 1",
+    "promotion.invalid-frame"
+  );
+  const snapshot = session.getSnapshot(targetFrame);
+  if (snapshot === void 0) {
+    throw new SyncplayError(
+      `No snapshot buffered for frame ${targetFrame} \u2014 it may have been evicted from the rolling buffer`,
+      { code: "promotion.missing-snapshot", frame: targetFrame }
+    );
+  }
+  return encodeDeterministicStateSnapshot({
+    v: 1,
+    tick: targetFrame - 1,
+    sessionFrame: targetFrame,
+    stateBytes: bytesToBase64(snapshot.stateBytes),
+    randomState: snapshot.randomState,
+    stateChecksum: snapshot.checksum,
+    // Session inputs are canonical by construction (cloneCanonical on setInput).
+    confirmedInputs: snapshot.inputs.map((input) => canonicalize(input))
+  });
+}
+function createSessionFromPromotionSnapshot(config, blob) {
+  const decoded = decodeDeterministicStateSnapshot(blob);
+  if (!decoded.ok) {
+    throw new SyncplayError(`Promotion snapshot rejected: ${decoded.reason}`, {
+      code: "promotion.invalid-snapshot"
+    });
+  }
+  const snapshot = decoded.snapshot;
+  invariant(
+    snapshot.confirmedInputs.length === config.playerCount,
+    `Promotion snapshot carries ${snapshot.confirmedInputs.length} input slots but config.playerCount is ${config.playerCount}`,
+    "promotion.player-count-mismatch"
+  );
+  const session = createOfflineSession(config);
+  session.restoreSnapshot({
+    frame: snapshot.sessionFrame,
+    stateBytes: base64ToBytes(snapshot.stateBytes),
+    randomState: snapshot.randomState,
+    inputs: snapshot.confirmedInputs.map(
+      // NOT `??`: a hydrator returning null (the canonical neutral) must win
+      // over the raw recorded value (adversarial-review LOW).
+      (recorded) => config.hydrateInput !== void 0 ? config.hydrateInput(recorded) : recorded
+    )
+  });
+  const restored = session.getSnapshot(session.currentFrame);
+  if (restored === void 0 || restored.checksum !== snapshot.stateChecksum) {
+    throw new SyncplayError(
+      "Promotion snapshot checksum mismatch after hydration \u2014 the game build or state bytes do not match the exporter",
+      { code: "promotion.checksum-mismatch", frame: snapshot.sessionFrame }
+    );
+  }
+  return session;
+}
+
+export { DEFAULT_MAX_SNAPSHOT_BYTES, DEFAULT_SNAPSHOT_CHUNK_SIZE, DeterministicRandom, SyncplayError, assertDeterministicPayloadFields, base64ToBytes, bytesToBase64, canonicalStringify, canonicalize, cloneCanonical, createDeterministicCommandTimeline, createDeterministicCommandTimelineSnapshot, createDeterministicMath, createInstantReplayRunner, createOfflineSession, createPauseController, createSchemaArtifacts, createSessionFromPromotionSnapshot, createSnapshotTransferCollector, createSnapshotTransferFromBytes, createStableIndexedMap, createSyncplayOfflineRuntime, decodeCanonicalBytes, decodeCanonicalValue, decodeDeterministicStateSnapshot, decodeUtf8, defaultChecksum, defineSyncplayGame, deterministicPayloadMatchesFields, deterministicRoomDescriptorHash, deterministicShuffle, encodeCanonicalBytes, encodeDeterministicStateSnapshot, encodeUtf8, evaluateDeterministicCommandTimelineMigrationResult, exportPromotionSnapshot, invariant, runDeterministicCommandProtocolFixture, runDeterministicCommandTimelineMigrationFixture, runDeterministicReliableCommandDefaultsFixture, runInstantReplay, stableDescriptorId, stableEntries, stableSortedKeys, verifyReplay, verifyReplayWithDescriptor, withRuntimeDeterminismGuards };
+//# sourceMappingURL=chunk-G7TYQYHC.js.map
+//# sourceMappingURL=chunk-G7TYQYHC.js.map