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

package/dist/cjs/local-authority-wire.js

@@ -0,0 +1,1497 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deterministicLocalAuthorityWireProtocol = void 0;
+exports.encodeDeterministicLocalAuthorityWireEnvelope = encodeDeterministicLocalAuthorityWireEnvelope;
+exports.decodeDeterministicLocalAuthorityWireEnvelope = decodeDeterministicLocalAuthorityWireEnvelope;
+exports.createDeterministicLocalAuthorityWireAuth = createDeterministicLocalAuthorityWireAuth;
+exports.createDeterministicLocalAuthorityInputBundleEnvelope = createDeterministicLocalAuthorityInputBundleEnvelope;
+exports.createDeterministicLocalAuthorityCommandBundleEnvelope = createDeterministicLocalAuthorityCommandBundleEnvelope;
+exports.createDeterministicLocalAuthorityAckEnvelope = createDeterministicLocalAuthorityAckEnvelope;
+exports.createDeterministicLocalAuthorityCorrectionEnvelope = createDeterministicLocalAuthorityCorrectionEnvelope;
+exports.createDeterministicLocalAuthoritySnapshotEnvelope = createDeterministicLocalAuthoritySnapshotEnvelope;
+exports.createDeterministicLocalAuthoritySnapshotTransfer = createDeterministicLocalAuthoritySnapshotTransfer;
+exports.createDeterministicLocalAuthoritySnapshotRequestEnvelope = createDeterministicLocalAuthoritySnapshotRequestEnvelope;
+exports.createDeterministicLocalAuthoritySnapshotOfferEnvelope = createDeterministicLocalAuthoritySnapshotOfferEnvelope;
+exports.createDeterministicLocalAuthoritySnapshotChunkEnvelope = createDeterministicLocalAuthoritySnapshotChunkEnvelope;
+exports.createDeterministicLocalAuthoritySnapshotCompleteEnvelope = createDeterministicLocalAuthoritySnapshotCompleteEnvelope;
+exports.applyDeterministicLocalAuthorityInputBundleEnvelope = applyDeterministicLocalAuthorityInputBundleEnvelope;
+exports.applyDeterministicLocalAuthorityCommandBundleEnvelope = applyDeterministicLocalAuthorityCommandBundleEnvelope;
+exports.createDeterministicLocalAuthorityWireReceiver = createDeterministicLocalAuthorityWireReceiver;
+exports.runDeterministicLocalAuthorityWireFixture = runDeterministicLocalAuthorityWireFixture;
+const canonical_js_1 = require("./canonical.js");
+const commands_js_1 = require("./commands.js");
+const local_authority_js_1 = require("./local-authority.js");
+exports.deterministicLocalAuthorityWireProtocol = 'rdm-local-authority/v1';
+function encodeDeterministicLocalAuthorityWireEnvelope(envelope, sign) {
+    assertWireKind(envelope.kind);
+    assertWireSequence(envelope.sequence);
+    if (!isRecord(envelope.payload)) {
+        throw new Error('Wire envelope payload must be an object');
+    }
+    const withoutChecksum = {
+        schemaVersion: 1,
+        protocol: exports.deterministicLocalAuthorityWireProtocol,
+        kind: envelope.kind,
+        sequence: envelope.sequence,
+        payload: (0, canonical_js_1.cloneCanonical)(envelope.payload),
+    };
+    const auth = sign === undefined ? undefined : createDeterministicLocalAuthorityWireAuth(withoutChecksum, sign);
+    const signedEnvelope = auth === undefined ? withoutChecksum : { ...withoutChecksum, auth };
+    return (0, canonical_js_1.canonicalStringify)({
+        ...signedEnvelope,
+        checksum: (0, canonical_js_1.defaultChecksum)(signedEnvelope),
+    });
+}
+function decodeDeterministicLocalAuthorityWireEnvelope(encoded) {
+    // Bound parse cost BEFORE JSON.parse. The kind-specific budget is only known
+    // post-parse, so pre-cap at the largest budget: `.length` counts UTF-16
+    // units and UTF-8 bytes are always >= that, so length > cap already implies
+    // the byte budget is blown without touching the bytes. The exact UTF-8
+    // measurement below then only ever runs on a bounded string.
+    if (encoded.length > absoluteMaxWireEnvelopeBytes) {
+        throw new Error(`Wire envelope exceeds ${absoluteMaxWireEnvelopeBytes} byte payload budget`);
+    }
+    const encodedByteLength = (0, canonical_js_1.encodeUtf8)(encoded).byteLength;
+    if (encodedByteLength > absoluteMaxWireEnvelopeBytes) {
+        throw new Error(`Wire envelope exceeds ${absoluteMaxWireEnvelopeBytes} byte payload budget`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(encoded);
+    }
+    catch {
+        throw new Error('Wire envelope must be valid JSON');
+    }
+    if (!isRecord(parsed)) {
+        throw new Error('Wire envelope must be an object');
+    }
+    if (parsed.schemaVersion !== 1) {
+        throw new Error('Wire envelope schemaVersion must be 1');
+    }
+    if (parsed.protocol !== exports.deterministicLocalAuthorityWireProtocol) {
+        throw new Error(`Wire envelope protocol must be ${exports.deterministicLocalAuthorityWireProtocol}`);
+    }
+    if (typeof parsed.kind !== 'string') {
+        throw new Error('Wire envelope kind must be a string');
+    }
+    assertWireKind(parsed.kind);
+    const maxBytes = maxWireEnvelopeBytes(parsed.kind);
+    if (encodedByteLength > maxBytes) {
+        throw new Error(`Wire envelope exceeds ${maxBytes} byte payload budget`);
+    }
+    if (typeof parsed.sequence !== 'number') {
+        throw new Error('Wire envelope sequence must be an integer');
+    }
+    assertWireSequence(parsed.sequence);
+    if (!isRecord(parsed.payload)) {
+        throw new Error('Wire envelope payload must be an object');
+    }
+    if (typeof parsed.checksum !== 'string') {
+        throw new Error('Wire envelope checksum must be a string');
+    }
+    // Symmetry with encode: the encoder checksummed the LIVE payload and then
+    // canonical-encoded it, so sentinel values (-0, NaN, ±Infinity, undefined,
+    // bigint, Map/Set/typed arrays) sit on the wire as literal `{"$rdm":…}`
+    // objects. Decode them back to real values BEFORE recomputing the checksum —
+    // hashing the raw parse output trips canonicalize's reserved-key guard, which
+    // made every legitimately-produced snapshot containing a non-finite number
+    // undecodable on a frozen wire.
+    const payload = (0, canonical_js_1.decodeCanonicalValue)(parsed.payload);
+    if (!isRecord(payload)) {
+        throw new Error('Wire envelope payload must be an object');
+    }
+    const baseEnvelope = {
+        schemaVersion: 1,
+        protocol: exports.deterministicLocalAuthorityWireProtocol,
+        kind: parsed.kind,
+        sequence: parsed.sequence,
+        payload,
+    };
+    const auth = parsed.auth === undefined ? undefined : parseWireAuth(parsed.auth);
+    const expectedChecksum = (0, canonical_js_1.defaultChecksum)(auth === undefined ? baseEnvelope : { ...baseEnvelope, auth });
+    if (parsed.checksum !== expectedChecksum) {
+        throw new Error('Wire envelope checksum mismatch');
+    }
+    // The decoded payload is already a fresh deep structure (decodeCanonical
+    // rebuilds it), so the envelope is assembled directly — re-encoding the raw
+    // parse output through cloneCanonical would re-trip the reserved-key guard.
+    return (auth === undefined
+        ? { ...baseEnvelope, checksum: parsed.checksum }
+        : { ...baseEnvelope, auth, checksum: parsed.checksum });
+}
+function createDeterministicLocalAuthorityWireAuth(envelope, sign) {
+    assertWireSenderId(sign.senderId);
+    if (typeof sign.key !== 'string' || sign.key.length === 0) {
+        throw new Error('Wire auth key must be a non-empty string');
+    }
+    return {
+        senderId: sign.senderId,
+        signature: hmacSha256Hex(sign.key, (0, canonical_js_1.canonicalStringify)({ senderId: sign.senderId, envelope })),
+    };
+}
+function createDeterministicLocalAuthorityInputBundleEnvelope(sequence, inputs, sign) {
+    return encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'input-bundle',
+        sequence,
+        payload: { inputs: inputs.map((input) => (0, canonical_js_1.cloneCanonical)(input)) },
+    }, sign);
+}
+function createDeterministicLocalAuthorityCommandBundleEnvelope(sequence, commands, sign) {
+    return encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'command-bundle',
+        sequence,
+        payload: { commands: commands.map((command) => (0, canonical_js_1.cloneCanonical)(command)) },
+    }, sign);
+}
+function createDeterministicLocalAuthorityAckEnvelope(sequence, runtime, sign) {
+    return encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'ack',
+        sequence,
+        payload: { checksums: runtime.checksums(), frame: runtime.state.frame },
+    }, sign);
+}
+function createDeterministicLocalAuthorityCorrectionEnvelope(sequence, runtime, identityOrSign, sign) {
+    const snapshot = runtime.snapshot();
+    const identity = isSnapshotIdentityLike(identityOrSign) ? (0, canonical_js_1.cloneCanonical)(identityOrSign) : undefined;
+    const signer = isSnapshotIdentityLike(identityOrSign) ? sign : identityOrSign;
+    return encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'correction',
+        sequence,
+        payload: {
+            ...(identity === undefined ? {} : { identity }),
+            frame: snapshot.state.frame,
+            snapshotChecksum: (0, canonical_js_1.defaultChecksum)(snapshot),
+            snapshot,
+            state: snapshot.state,
+        },
+    }, signer);
+}
+function createDeterministicLocalAuthoritySnapshotEnvelope(sequence, runtime, identityOrSign, sign) {
+    const snapshot = runtime.snapshot();
+    const identity = isSnapshotIdentityLike(identityOrSign) ? (0, canonical_js_1.cloneCanonical)(identityOrSign) : undefined;
+    const signer = isSnapshotIdentityLike(identityOrSign) ? sign : identityOrSign;
+    return encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'snapshot',
+        sequence,
+        payload: {
+            ...(identity === undefined ? {} : { identity }),
+            frame: snapshot.state.frame,
+            snapshotChecksum: (0, canonical_js_1.defaultChecksum)(snapshot),
+            snapshot,
+        },
+    }, signer);
+}
+function createDeterministicLocalAuthoritySnapshotTransfer(runtime, identity, transferId, chunkSize = 1024) {
+    if (!isValidTransferId(transferId)) {
+        throw new Error('Snapshot transferId is invalid');
+    }
+    if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
+        throw new Error('Snapshot chunkSize must be a positive integer');
+    }
+    assertSnapshotIdentity(identity);
+    const snapshot = runtime.snapshot();
+    const snapshotBytes = (0, canonical_js_1.canonicalStringify)(snapshot);
+    const chunks = [];
+    for (let offset = 0; offset < snapshotBytes.length; offset += chunkSize) {
+        chunks.push(snapshotBytes.slice(offset, offset + chunkSize));
+    }
+    return {
+        transferId,
+        identity: (0, canonical_js_1.cloneCanonical)(identity),
+        frame: snapshot.state.frame,
+        snapshotChecksum: (0, canonical_js_1.defaultChecksum)(snapshot),
+        snapshotBytes,
+        chunkSize,
+        chunks,
+        chunkChecksums: chunks.map((chunk) => (0, canonical_js_1.defaultChecksum)(chunk)),
+    };
+}
+function createDeterministicLocalAuthoritySnapshotRequestEnvelope(sequence, identity, minFrame, sign) {
+    assertSnapshotIdentity(identity);
+    return encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'snapshot-request',
+        sequence,
+        payload: { identity: (0, canonical_js_1.cloneCanonical)(identity), minFrame },
+    }, sign);
+}
+function createDeterministicLocalAuthoritySnapshotOfferEnvelope(sequence, transfer, sign) {
+    return encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'snapshot-offer',
+        sequence,
+        payload: {
+            transferId: transfer.transferId,
+            identity: (0, canonical_js_1.cloneCanonical)(transfer.identity),
+            frame: transfer.frame,
+            snapshotChecksum: transfer.snapshotChecksum,
+            chunkCount: transfer.chunks.length,
+            totalBytes: transfer.snapshotBytes.length,
+            chunkChecksums: [...transfer.chunkChecksums],
+        },
+    }, sign);
+}
+function createDeterministicLocalAuthoritySnapshotChunkEnvelope(sequence, transfer, chunkIndex, sign) {
+    if (!Number.isInteger(chunkIndex) || chunkIndex < 0 || chunkIndex >= transfer.chunks.length) {
+        throw new Error('Snapshot chunkIndex is out of range');
+    }
+    const chunk = transfer.chunks[chunkIndex];
+    return encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'snapshot-chunk',
+        sequence,
+        payload: {
+            transferId: transfer.transferId,
+            chunkIndex,
+            chunk,
+            chunkChecksum: (0, canonical_js_1.defaultChecksum)(chunk),
+        },
+    }, sign);
+}
+function createDeterministicLocalAuthoritySnapshotCompleteEnvelope(sequence, transferId, sign) {
+    if (!isValidTransferId(transferId)) {
+        throw new Error('Snapshot transferId is invalid');
+    }
+    return encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'snapshot-complete',
+        sequence,
+        payload: { transferId },
+    }, sign);
+}
+function applyDeterministicLocalAuthorityInputBundleEnvelope(runtime, senderSlot, envelope) {
+    if (envelope.kind !== 'input-bundle') {
+        throw new Error(`Expected input-bundle envelope, received ${envelope.kind}`);
+    }
+    const inputs = envelope.payload.inputs;
+    if (!Array.isArray(inputs)) {
+        throw new Error('Input bundle payload requires inputs array');
+    }
+    let accepted = 0;
+    let rejected = 0;
+    const rejectionReasons = [];
+    for (const input of inputs) {
+        const message = parseInputMessage(input);
+        if (message.slot !== senderSlot) {
+            rejected += 1;
+            rejectionReasons.push('forged-slot');
+            continue;
+        }
+        const beforeRejected = runtime.state.rejectedMessages;
+        if (runtime.submitInput(message)) {
+            accepted += 1;
+        }
+        else {
+            rejected += 1;
+            rejectionReasons.push(classifyRuntimeInputRejection(runtime, beforeRejected, message));
+        }
+    }
+    return { accepted, rejected, rejectionReasons };
+}
+function applyDeterministicLocalAuthorityCommandBundleEnvelope(timeline, senderSlot, envelope) {
+    if (envelope.kind !== 'command-bundle') {
+        throw new Error(`Expected command-bundle envelope, received ${envelope.kind}`);
+    }
+    const commands = envelope.payload.commands;
+    if (!Array.isArray(commands)) {
+        throw new Error('Command bundle payload requires commands array');
+    }
+    let accepted = 0;
+    let rejected = 0;
+    const rejectionReasons = [];
+    for (const command of commands) {
+        const message = parseCommandMessage(command);
+        const rejection = timeline.recordFromSlot(senderSlot, message);
+        if (rejection === undefined) {
+            accepted += 1;
+        }
+        else {
+            rejected += 1;
+            rejectionReasons.push(rejection.reason);
+        }
+    }
+    return { accepted, rejected, rejectionReasons };
+}
+function createDeterministicLocalAuthorityWireReceiver(runtime, options = {}) {
+    const seenSequenceKeys = new Set();
+    const highestSequenceBySender = new Map();
+    const sequenceReplayWindow = readSequenceReplayWindow(options.sequenceReplayWindow);
+    const pendingSnapshotTransfers = new Map();
+    let lastAckFrame = -1;
+    let lastCorrectionFrame = -1;
+    let lastSnapshotFrame = -1;
+    function reject(kind, reason) {
+        return { kind, accepted: 0, rejected: 1, rejectionReasons: [reason], appliedAck: false, appliedCorrection: false, appliedSnapshot: false };
+    }
+    function sequenceKey(sender, sequence) {
+        return `${sender}:${sequence}`;
+    }
+    function rejectOrReserveSequence(envelope, sender) {
+        const key = sequenceKey(sender, envelope.sequence);
+        if (seenSequenceKeys.has(key)) {
+            return 'replayed-envelope';
+        }
+        const highestSequence = highestSequenceBySender.get(sender) ?? -1;
+        if (envelope.sequence < highestSequence - sequenceReplayWindow) {
+            return 'duplicate-sequence';
+        }
+        return undefined;
+    }
+    function markSequence(sender, sequence) {
+        seenSequenceKeys.add(sequenceKey(sender, sequence));
+        const highest = Math.max(highestSequenceBySender.get(sender) ?? -1, sequence);
+        highestSequenceBySender.set(sender, highest);
+        // Prune this sender's keys below the replay window: anything older is
+        // already rejected as duplicate-sequence by the window rule, so retaining
+        // it only grows memory without bound (an adversary can advance sequence
+        // numbers arbitrarily). Pruning keeps the set at O(window × senders).
+        const floor = highest - sequenceReplayWindow;
+        const senderPrefix = `${sender}:`;
+        for (const key of seenSequenceKeys) {
+            if (!key.startsWith(senderPrefix))
+                continue;
+            if (Number(key.slice(senderPrefix.length)) < floor) {
+                seenSequenceKeys.delete(key);
+            }
+        }
+    }
+    function rejectAuth(envelope, expectedSenderId) {
+        return verifyWireEnvelopeAuth(envelope, expectedSenderId, options.auth);
+    }
+    return {
+        receive(envelope, senderSlot) {
+            if (envelope.kind === 'input-bundle') {
+                if (senderSlot === undefined) {
+                    return reject(envelope.kind, 'missing-sender-slot');
+                }
+                const sender = `slot:${senderSlot}`;
+                const authRejection = rejectAuth(envelope, sender);
+                if (authRejection !== undefined) {
+                    return reject(envelope.kind, authRejection);
+                }
+                const sequenceRejection = rejectOrReserveSequence(envelope, sender);
+                if (sequenceRejection !== undefined) {
+                    return reject(envelope.kind, sequenceRejection);
+                }
+                const applied = applyDeterministicLocalAuthorityInputBundleEnvelope(runtime, senderSlot, envelope);
+                markSequence(sender, envelope.sequence);
+                return { ...applied, kind: envelope.kind, appliedAck: false, appliedCorrection: false, appliedSnapshot: false };
+            }
+            if (envelope.kind === 'command-bundle') {
+                if (senderSlot === undefined) {
+                    return reject(envelope.kind, 'missing-sender-slot');
+                }
+                if (options.commandTimeline === undefined) {
+                    return reject(envelope.kind, 'missing-command-timeline');
+                }
+                const sender = `slot:${senderSlot}`;
+                const authRejection = rejectAuth(envelope, sender);
+                if (authRejection !== undefined) {
+                    return reject(envelope.kind, authRejection);
+                }
+                const sequenceRejection = rejectOrReserveSequence(envelope, sender);
+                if (sequenceRejection !== undefined) {
+                    return reject(envelope.kind, sequenceRejection);
+                }
+                if (runtime.state.clients[senderSlot]?.spectator === true) {
+                    markSequence(sender, envelope.sequence);
+                    return { kind: envelope.kind, accepted: 0, rejected: 1, rejectionReasons: ['spectator-command'], appliedAck: false, appliedCorrection: false, appliedSnapshot: false };
+                }
+                const applied = applyDeterministicLocalAuthorityCommandBundleEnvelope(options.commandTimeline, senderSlot, envelope);
+                markSequence(sender, envelope.sequence);
+                return { ...applied, kind: envelope.kind, appliedAck: false, appliedCorrection: false, appliedSnapshot: false };
+            }
+            if (envelope.kind === 'snapshot-request') {
+                if (senderSlot === undefined) {
+                    return reject(envelope.kind, 'missing-sender-slot');
+                }
+                const sender = `slot:${senderSlot}`;
+                const authRejection = rejectAuth(envelope, sender);
+                if (authRejection !== undefined) {
+                    return reject(envelope.kind, authRejection);
+                }
+                const sequenceRejection = rejectOrReserveSequence(envelope, sender);
+                if (sequenceRejection !== undefined) {
+                    return reject(envelope.kind, sequenceRejection);
+                }
+                if (options.snapshotIdentity === undefined) {
+                    return reject(envelope.kind, 'snapshot-identity-required');
+                }
+                const requestIdentity = parseSnapshotIdentityPayload(envelope);
+                if (!snapshotIdentityMatches(options.snapshotIdentity, requestIdentity)) {
+                    return reject(envelope.kind, 'snapshot-descriptor-mismatch');
+                }
+                const minFrame = integerPayloadField(envelope, 'minFrame');
+                if (minFrame > runtime.state.frame) {
+                    return reject(envelope.kind, 'snapshot-min-frame-unavailable');
+                }
+                markSequence(sender, envelope.sequence);
+                return { kind: envelope.kind, accepted: 1, rejected: 0, rejectionReasons: [], appliedAck: false, appliedCorrection: false, appliedSnapshot: false };
+            }
+            const sender = 'authority';
+            const authRejection = rejectAuth(envelope, sender);
+            if (authRejection !== undefined) {
+                return reject(envelope.kind, authRejection);
+            }
+            const sequenceRejection = rejectOrReserveSequence(envelope, sender);
+            if (sequenceRejection !== undefined) {
+                return reject(envelope.kind, sequenceRejection);
+            }
+            if (envelope.kind === 'ack') {
+                const frame = integerPayloadField(envelope, 'frame');
+                if (frame < lastAckFrame) {
+                    return reject(envelope.kind, 'stale-ack');
+                }
+                markSequence(sender, envelope.sequence);
+                lastAckFrame = frame;
+                return { kind: envelope.kind, accepted: 1, rejected: 0, rejectionReasons: [], appliedAck: true, appliedCorrection: false, appliedSnapshot: false };
+            }
+            if (envelope.kind === 'correction') {
+                const frame = integerPayloadField(envelope, 'frame');
+                if (frame < lastCorrectionFrame) {
+                    return reject(envelope.kind, 'stale-correction');
+                }
+                const identityRejection = directSnapshotIdentityRejection(envelope, options.snapshotIdentity);
+                if (identityRejection !== undefined) {
+                    return reject(envelope.kind, identityRejection);
+                }
+                const snapshot = parseRuntimeSnapshotPayload(envelope, 'snapshot');
+                assertSnapshotChecksum(envelope, snapshot);
+                runtime.restore(snapshot);
+                markSequence(sender, envelope.sequence);
+                lastCorrectionFrame = frame;
+                return { kind: envelope.kind, accepted: 1, rejected: 0, rejectionReasons: [], appliedAck: false, appliedCorrection: true, appliedSnapshot: false };
+            }
+            if (envelope.kind === 'snapshot') {
+                const frame = integerPayloadField(envelope, 'frame');
+                if (frame < lastSnapshotFrame) {
+                    return reject(envelope.kind, 'stale-snapshot');
+                }
+                const identityRejection = directSnapshotIdentityRejection(envelope, options.snapshotIdentity);
+                if (identityRejection !== undefined) {
+                    return reject(envelope.kind, identityRejection);
+                }
+                const snapshot = parseRuntimeSnapshotPayload(envelope, 'snapshot');
+                assertSnapshotChecksum(envelope, snapshot);
+                runtime.restore(snapshot);
+                markSequence(sender, envelope.sequence);
+                lastSnapshotFrame = frame;
+                return { kind: envelope.kind, accepted: 1, rejected: 0, rejectionReasons: [], appliedAck: false, appliedCorrection: false, appliedSnapshot: true };
+            }
+            if (envelope.kind === 'snapshot-offer') {
+                const offer = parseSnapshotOffer(envelope);
+                if (options.snapshotIdentity === undefined) {
+                    return reject(envelope.kind, 'snapshot-identity-required');
+                }
+                if (!snapshotIdentityMatches(options.snapshotIdentity, offer.identity)) {
+                    return reject(envelope.kind, 'snapshot-descriptor-mismatch');
+                }
+                const maxAge = options.maxSnapshotAgeFrames ?? 256;
+                if (offer.frame < runtime.state.frame - maxAge) {
+                    return reject(envelope.kind, 'stale-snapshot-offer');
+                }
+                pendingSnapshotTransfers.set(offer.transferId, {
+                    ...offer,
+                    chunks: new Map(),
+                });
+                markSequence(sender, envelope.sequence);
+                return { kind: envelope.kind, accepted: 1, rejected: 0, rejectionReasons: [], appliedAck: false, appliedCorrection: false, appliedSnapshot: false };
+            }
+            if (envelope.kind === 'snapshot-chunk') {
+                const transferId = stringPayloadField(envelope, 'transferId');
+                const transfer = pendingSnapshotTransfers.get(transferId);
+                if (transfer === undefined) {
+                    return reject(envelope.kind, 'unknown-snapshot-transfer');
+                }
+                const chunkIndex = integerPayloadField(envelope, 'chunkIndex');
+                if (chunkIndex < 0 || chunkIndex >= transfer.chunkCount) {
+                    return reject(envelope.kind, 'snapshot-chunk-index-out-of-range');
+                }
+                if (transfer.chunks.has(chunkIndex)) {
+                    return reject(envelope.kind, 'duplicate-snapshot-chunk');
+                }
+                const chunk = stringPayloadField(envelope, 'chunk');
+                const chunkChecksum = stringPayloadField(envelope, 'chunkChecksum');
+                if (transfer.chunkChecksums[chunkIndex] !== chunkChecksum || (0, canonical_js_1.defaultChecksum)(chunk) !== chunkChecksum) {
+                    return reject(envelope.kind, 'snapshot-chunk-checksum-mismatch');
+                }
+                transfer.chunks.set(chunkIndex, chunk);
+                markSequence(sender, envelope.sequence);
+                return { kind: envelope.kind, accepted: 1, rejected: 0, rejectionReasons: [], appliedAck: false, appliedCorrection: false, appliedSnapshot: false };
+            }
+            const transferId = stringPayloadField(envelope, 'transferId');
+            const transfer = pendingSnapshotTransfers.get(transferId);
+            if (transfer === undefined) {
+                return reject(envelope.kind, 'unknown-snapshot-transfer');
+            }
+            if (transfer.chunks.size !== transfer.chunkCount) {
+                return reject(envelope.kind, 'missing-snapshot-chunk');
+            }
+            const snapshotBytes = Array.from({ length: transfer.chunkCount }, (_, index) => transfer.chunks.get(index)).join('');
+            if (snapshotBytes.length !== transfer.totalBytes) {
+                return reject(envelope.kind, 'snapshot-byte-length-mismatch');
+            }
+            const parsed = parseSnapshotBytes(snapshotBytes);
+            if ((0, canonical_js_1.defaultChecksum)(parsed) !== transfer.snapshotChecksum) {
+                return reject(envelope.kind, 'snapshot-transfer-checksum-mismatch');
+            }
+            runtime.restore(parsed);
+            pendingSnapshotTransfers.delete(transferId);
+            markSequence(sender, envelope.sequence);
+            lastSnapshotFrame = Math.max(lastSnapshotFrame, transfer.frame);
+            return { kind: envelope.kind, accepted: 1, rejected: 0, rejectionReasons: [], appliedAck: false, appliedCorrection: false, appliedSnapshot: true };
+        },
+        snapshot() {
+            const perSenderEntries = [...highestSequenceBySender.entries()].sort((left, right) => compareStrings(left[0], right[0]));
+            const perSenderHighestSequences = Object.fromEntries(perSenderEntries);
+            const seenSequences = [...new Set([...seenSequenceKeys].map((key) => Number(key.slice(key.lastIndexOf(':') + 1))))].sort(compareNumbers);
+            const state = {
+                highestSequence: perSenderEntries.reduce((highest, entry) => Math.max(highest, entry[1]), -1),
+                seenSequences,
+                perSenderHighestSequences,
+                lastAckFrame,
+                lastCorrectionFrame,
+                lastSnapshotFrame,
+            };
+            return { ...state, checksum: (0, canonical_js_1.defaultChecksum)(state) };
+        },
+    };
+}
+function runDeterministicLocalAuthorityWireFixture(players, frames, seed) {
+    const runtime = (0, local_authority_js_1.createDeterministicLocalAuthorityRuntime)(players, { maxFrameLead: 16 });
+    const commandChannels = [
+        { id: 'ability', reliable: true, allowPrediction: true, maxPayloadBytes: 128, maxFrameLead: 16 },
+        { id: 'emote', reliable: false, allowPrediction: false, maxPayloadBytes: 64, minFrameLead: 1, maxFrameLead: 8 },
+    ];
+    const commandTimeline = (0, commands_js_1.createDeterministicCommandTimeline)({
+        playerCount: players,
+        currentFrame: 0,
+        channels: commandChannels,
+        validAssetRefs: ['ability.dash', 'emote.wave'],
+        validatePayload(command) {
+            return typeof command.payload === 'object' && command.payload !== null && !Array.isArray(command.payload);
+        },
+    });
+    const snapshotIdentity = {
+        descriptorHash: (0, canonical_js_1.defaultChecksum)({ kind: 'local-authority-wire-fixture', players, seed }),
+        schemaHash: 'local-authority-wire-schema@1',
+        assetDbHash: 'local-authority-wire-assets@1',
+        configHash: 'local-authority-wire-config@1',
+    };
+    const auth = createWireFixtureAuth(players, seed);
+    const receiver = createDeterministicLocalAuthorityWireReceiver(runtime, {
+        commandTimeline,
+        snapshotIdentity,
+        maxSnapshotAgeFrames: Math.max(1, Math.min(64, Math.floor(frames / 2))),
+        auth: { requireAuth: true, authorityKey: auth.authorityKey, slotKeys: auth.slotKeys },
+    });
+    let sequence = 0;
+    let encodedEnvelopes = 0;
+    let decodedEnvelopes = 0;
+    let wireAuthSignedEnvelopes = 0;
+    let acceptedInputs = 0;
+    let rejectedInputs = 0;
+    let acceptedCommands = 0;
+    let rejectedCommands = 0;
+    let ackEnvelopes = 0;
+    let commandEnvelopes = 0;
+    let correctionEnvelopes = 0;
+    let snapshotEnvelopes = 0;
+    let snapshotRequestEnvelopes = 0;
+    let snapshotOfferEnvelopes = 0;
+    let snapshotChunkEnvelopes = 0;
+    let snapshotCompleteEnvelopes = 0;
+    let correctionsApplied = 0;
+    let snapshotsApplied = 0;
+    let snapshotNegotiationCompletesApplied = 0;
+    const rejectionReasons = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        commandTimeline.setCurrentFrame(frame);
+        for (let slot = 0; slot < players; slot += 1) {
+            const encoded = createDeterministicLocalAuthorityInputBundleEnvelope(sequence, [{
+                    slot,
+                    frame,
+                    value: seed + frame * 31 + slot,
+                    delay: slot % 4,
+                }], wireFixtureSlotSign(auth, slot));
+            sequence += 1;
+            encodedEnvelopes += 1;
+            const decoded = decodeDeterministicLocalAuthorityWireEnvelope(encoded);
+            wireAuthSignedEnvelopes += 1;
+            decodedEnvelopes += 1;
+            const applied = receiver.receive(decoded, slot);
+            acceptedInputs += applied.accepted;
+            rejectedInputs += applied.rejected;
+            rejectionReasons.push(...applied.rejectionReasons);
+            if ((frame + slot + seed) % 19 === 0) {
+                const commandFrame = frame + 1;
+                const command = {
+                    id: `wire:${slot}:${frame}:ability`,
+                    slot,
+                    frame: commandFrame,
+                    channelId: 'ability',
+                    payload: { assetRef: 'ability.dash', power: (slot + frame) % 7 },
+                    predicted: frame % 2 === 0,
+                };
+                const commandEnvelope = createDeterministicLocalAuthorityCommandBundleEnvelope(sequence, [command], wireFixtureSlotSign(auth, slot));
+                sequence += 1;
+                encodedEnvelopes += 1;
+                const decodedCommand = decodeDeterministicLocalAuthorityWireEnvelope(commandEnvelope);
+                wireAuthSignedEnvelopes += 1;
+                decodedEnvelopes += 1;
+                commandEnvelopes += 1;
+                const appliedCommand = receiver.receive(decodedCommand, slot);
+                acceptedCommands += appliedCommand.accepted;
+                rejectedCommands += appliedCommand.rejected;
+                rejectionReasons.push(...appliedCommand.rejectionReasons);
+            }
+        }
+        if (frame % 8 === 0) {
+            const ack = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityAckEnvelope(sequence, runtime, wireFixtureAuthoritySign(auth)));
+            wireAuthSignedEnvelopes += 1;
+            const appliedAck = receiver.receive(ack);
+            rejectionReasons.push(...appliedAck.rejectionReasons);
+            sequence += 1;
+            encodedEnvelopes += 1;
+            decodedEnvelopes += 1;
+            ackEnvelopes += 1;
+        }
+        if (frame % 16 === 0) {
+            const correction = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityCorrectionEnvelope(sequence, runtime, snapshotIdentity, wireFixtureAuthoritySign(auth)));
+            wireAuthSignedEnvelopes += 1;
+            const appliedCorrection = receiver.receive(correction);
+            sequence += 1;
+            encodedEnvelopes += 1;
+            decodedEnvelopes += 1;
+            correctionEnvelopes += 1;
+            correctionsApplied += Number(appliedCorrection.appliedCorrection);
+            rejectionReasons.push(...appliedCorrection.rejectionReasons);
+        }
+        runtime.step();
+    }
+    const finalSnapshot = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotEnvelope(sequence, runtime, snapshotIdentity, wireFixtureAuthoritySign(auth)));
+    wireAuthSignedEnvelopes += 1;
+    const appliedSnapshot = receiver.receive(finalSnapshot);
+    encodedEnvelopes += 1;
+    decodedEnvelopes += 1;
+    snapshotEnvelopes += 1;
+    snapshotsApplied += Number(appliedSnapshot.appliedSnapshot);
+    rejectionReasons.push(...appliedSnapshot.rejectionReasons);
+    const transfer = createDeterministicLocalAuthoritySnapshotTransfer(runtime, snapshotIdentity, `transfer:${seed}:${frames}`, 512);
+    const snapshotRequest = receiver.receive(decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotRequestEnvelope(sequence + 1, snapshotIdentity, runtime.state.frame, wireFixtureSlotSign(auth, 0))), 0);
+    wireAuthSignedEnvelopes += 1;
+    encodedEnvelopes += 1;
+    decodedEnvelopes += 1;
+    snapshotRequestEnvelopes += 1;
+    rejectionReasons.push(...snapshotRequest.rejectionReasons);
+    sequence += 1;
+    const snapshotOffer = receiver.receive(decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotOfferEnvelope(sequence + 1, transfer, wireFixtureAuthoritySign(auth))));
+    wireAuthSignedEnvelopes += 1;
+    encodedEnvelopes += 1;
+    decodedEnvelopes += 1;
+    snapshotOfferEnvelopes += 1;
+    rejectionReasons.push(...snapshotOffer.rejectionReasons);
+    sequence += 1;
+    for (let chunkIndex = 0; chunkIndex < transfer.chunks.length; chunkIndex += 1) {
+        const chunk = receiver.receive(decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotChunkEnvelope(sequence + 1, transfer, chunkIndex, wireFixtureAuthoritySign(auth))));
+        wireAuthSignedEnvelopes += 1;
+        encodedEnvelopes += 1;
+        decodedEnvelopes += 1;
+        snapshotChunkEnvelopes += 1;
+        rejectionReasons.push(...chunk.rejectionReasons);
+        sequence += 1;
+    }
+    const snapshotComplete = receiver.receive(decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotCompleteEnvelope(sequence + 1, transfer.transferId, wireFixtureAuthoritySign(auth))));
+    wireAuthSignedEnvelopes += 1;
+    encodedEnvelopes += 1;
+    decodedEnvelopes += 1;
+    snapshotCompleteEnvelopes += 1;
+    snapshotsApplied += Number(snapshotComplete.appliedSnapshot);
+    snapshotNegotiationCompletesApplied += Number(snapshotComplete.appliedSnapshot);
+    rejectionReasons.push(...snapshotComplete.rejectionReasons);
+    sequence += 1;
+    const hostile = runHostileWireCases(runtime, receiver, players, frames, sequence + 1, snapshotIdentity, auth);
+    const sequenceWindow = runWireSequenceWindowFixture(auth);
+    rejectedInputs += hostile.rejectedInputs;
+    rejectedCommands += hostile.rejectedCommands;
+    wireAuthSignedEnvelopes += hostile.signedEnvelopes;
+    rejectionReasons.push(...hostile.rejectionReasons);
+    rejectionReasons.push(...sequenceWindow.rejectionReasons);
+    const convergenceDrainFrames = 4;
+    for (let drain = 0; drain < convergenceDrainFrames; drain += 1) {
+        runtime.step();
+    }
+    const checksums = runtime.checksums();
+    const metrics = {
+        players,
+        frames,
+        encodedEnvelopes,
+        decodedEnvelopes,
+        acceptedInputs,
+        rejectedInputs,
+        acceptedCommands,
+        rejectedCommands,
+        malformedRejected: hostile.malformedRejected,
+        forgedSlotRejected: rejectionReasons.filter((reason) => reason === 'forged-slot').length,
+        staleFrameRejected: rejectionReasons.filter((reason) => reason === 'stale-frame').length,
+        futureFrameRejected: rejectionReasons.filter((reason) => reason === 'future-frame').length,
+        oversizedRejected: hostile.oversizedRejected,
+        duplicateInputRejected: rejectionReasons.filter((reason) => reason === 'duplicate-input').length,
+        invalidInputIdRejected: rejectionReasons.filter((reason) => reason === 'invalid-input-id').length,
+        ackEnvelopes,
+        commandEnvelopes,
+        correctionEnvelopes,
+        snapshotEnvelopes,
+        snapshotRequestEnvelopes,
+        snapshotOfferEnvelopes,
+        snapshotChunkEnvelopes,
+        snapshotCompleteEnvelopes,
+        snapshotNegotiationCompletesApplied,
+        snapshotNegotiationRejected: rejectionReasons.filter((reason) => reason.startsWith('snapshot-') || reason === 'missing-snapshot-chunk' || reason === 'stale-snapshot-offer').length,
+        snapshotDescriptorMismatchRejected: rejectionReasons.filter((reason) => reason === 'snapshot-descriptor-mismatch').length,
+        snapshotChunkChecksumRejected: rejectionReasons.filter((reason) => reason === 'snapshot-chunk-checksum-mismatch').length,
+        snapshotMissingChunkRejected: rejectionReasons.filter((reason) => reason === 'missing-snapshot-chunk').length,
+        staleSnapshotOfferRejected: rejectionReasons.filter((reason) => reason === 'stale-snapshot-offer').length,
+        reorderedSequenceAccepted: sequenceWindow.reorderedSequenceAccepted,
+        duplicateSequenceRejected: rejectionReasons.filter((reason) => reason === 'duplicate-sequence').length,
+        replayedEnvelopeRejected: rejectionReasons.filter((reason) => reason === 'replayed-envelope').length,
+        staleAckRejected: rejectionReasons.filter((reason) => reason === 'stale-ack').length,
+        staleCorrectionRejected: rejectionReasons.filter((reason) => reason === 'stale-correction').length,
+        staleSnapshotRejected: rejectionReasons.filter((reason) => reason === 'stale-snapshot').length,
+        wireAuthSignedEnvelopes,
+        wireAuthMissingRejected: rejectionReasons.filter((reason) => reason === 'missing-wire-auth').length,
+        wireAuthSenderMismatchRejected: rejectionReasons.filter((reason) => reason === 'wire-auth-sender-mismatch').length,
+        wireAuthSignatureRejected: rejectionReasons.filter((reason) => reason === 'wire-auth-signature-mismatch').length,
+        wireAuthHmacSha256Covered: isKnownHmacSha256VectorCovered(),
+        forgedAuthorityCorrectionRejected: hostile.forgedAuthorityCorrectionRejected,
+        forgedAuthoritySnapshotRejected: hostile.forgedAuthoritySnapshotRejected,
+        snapshotIdentityRequiredRejected: hostile.snapshotIdentityRequiredRejected,
+        correctionsApplied,
+        snapshotsApplied,
+        convergenceDrainFrames,
+        authorityProjectionChecksum: checksums.authorityProjectionChecksum,
+        clientProjectionChecksum: checksums.clientProjectionChecksum,
+        convergence: checksums.convergence,
+    };
+    return { ...metrics, checksum: (0, canonical_js_1.defaultChecksum)(metrics) };
+}
+function runHostileWireCases(runtime, receiver, players, frames, sequence, snapshotIdentity, auth) {
+    let malformedRejected = 0;
+    let oversizedRejected = 0;
+    let rejectedInputs = 0;
+    let rejectedCommands = 0;
+    let signedEnvelopes = 0;
+    let forgedAuthorityCorrectionRejected = 0;
+    let forgedAuthoritySnapshotRejected = 0;
+    let snapshotIdentityRequiredRejected = 0;
+    const rejectionReasons = [];
+    const malformedCases = [
+        '{bad-json',
+        (0, canonical_js_1.canonicalStringify)({ schemaVersion: 2, protocol: exports.deterministicLocalAuthorityWireProtocol, kind: 'input-bundle', sequence, payload: {}, checksum: 'x' }),
+        (0, canonical_js_1.canonicalStringify)({ schemaVersion: 1, protocol: exports.deterministicLocalAuthorityWireProtocol, kind: 'input-bundle', sequence, payload: {}, checksum: 'x' }),
+    ];
+    for (const encoded of malformedCases) {
+        try {
+            decodeDeterministicLocalAuthorityWireEnvelope(encoded);
+        }
+        catch {
+            malformedRejected += 1;
+        }
+    }
+    const hostileBundles = [
+        { senderSlot: 0, inputs: [{ slot: 1, frame: runtime.state.frame, value: 1 }] },
+        { senderSlot: 0, inputs: [{ slot: 0, frame: Math.max(0, runtime.state.frame - 2), value: 1 }] },
+        { senderSlot: 0, inputs: [{ slot: 0, frame: runtime.state.frame + frames + 128, value: 1 }] },
+        { senderSlot: 0, inputs: [{ slot: 0, frame: Math.max(0, runtime.state.frame - 1), value: 1 }] },
+        { senderSlot: 0, inputs: [{ slot: 0, frame: runtime.state.frame, value: 1, inputId: 'invalid input id' }] },
+    ];
+    let nextSequence = sequence + malformedCases.length;
+    const missingAuth = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityInputBundleEnvelope(nextSequence, [
+        { slot: 0, frame: runtime.state.frame, value: 101 },
+    ]));
+    nextSequence += 1;
+    const missingAuthResult = receiver.receive(missingAuth, 0);
+    rejectedInputs += missingAuthResult.rejected;
+    rejectionReasons.push(...missingAuthResult.rejectionReasons);
+    const senderMismatch = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityInputBundleEnvelope(nextSequence, [
+        { slot: 0, frame: runtime.state.frame, value: 102 },
+    ], wireFixtureSlotSign(auth, 1)));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const senderMismatchResult = receiver.receive(senderMismatch, 0);
+    rejectedInputs += senderMismatchResult.rejected;
+    rejectionReasons.push(...senderMismatchResult.rejectionReasons);
+    const badSignature = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityInputBundleEnvelope(nextSequence, [
+        { slot: 0, frame: runtime.state.frame, value: 103 },
+    ], { senderId: 'slot:0', key: `${wireFixtureSlotSign(auth, 0).key}:wrong` }));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const badSignatureResult = receiver.receive(badSignature, 0);
+    rejectedInputs += badSignatureResult.rejected;
+    rejectionReasons.push(...badSignatureResult.rejectionReasons);
+    for (const hostile of hostileBundles) {
+        const decoded = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityInputBundleEnvelope(nextSequence, hostile.inputs, wireFixtureSlotSign(auth, hostile.senderSlot)));
+        signedEnvelopes += 1;
+        nextSequence += 1;
+        const applied = receiver.receive(decoded, hostile.senderSlot);
+        rejectedInputs += applied.rejected;
+        rejectionReasons.push(...applied.rejectionReasons);
+    }
+    const gapAck = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityAckEnvelope(nextSequence + 1, runtime, wireFixtureAuthoritySign(auth)));
+    signedEnvelopes += 1;
+    const gapAckResult = receiver.receive(gapAck);
+    rejectedInputs += gapAckResult.rejected;
+    rejectionReasons.push(...gapAckResult.rejectionReasons);
+    const gapInput = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityInputBundleEnvelope(nextSequence + 1, [
+        { slot: 0, frame: runtime.state.frame, value: 98 },
+    ], wireFixtureSlotSign(auth, 0)));
+    signedEnvelopes += 1;
+    const gapInputResult = receiver.receive(gapInput, 0);
+    rejectedInputs += gapInputResult.rejected;
+    rejectionReasons.push(...gapInputResult.rejectionReasons);
+    const duplicateSequence = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityInputBundleEnvelope(nextSequence, [
+        { slot: 0, frame: runtime.state.frame, value: 99 },
+    ], wireFixtureSlotSign(auth, 0)));
+    signedEnvelopes += 1;
+    nextSequence += 2;
+    const duplicateSequenceResult = receiver.receive(duplicateSequence, 0);
+    rejectedInputs += duplicateSequenceResult.rejected;
+    rejectionReasons.push(...duplicateSequenceResult.rejectionReasons);
+    const currentAck = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityAckEnvelope(nextSequence, runtime, wireFixtureAuthoritySign(auth)));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const currentAckResult = receiver.receive(currentAck);
+    const replayedAckResult = receiver.receive(currentAck);
+    const staleAck = decodeDeterministicLocalAuthorityWireEnvelope(encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'ack',
+        sequence: nextSequence,
+        payload: { checksums: runtime.checksums(), frame: Math.max(0, runtime.state.frame - 1) },
+    }, wireFixtureAuthoritySign(auth)));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const staleAckResult = receiver.receive(staleAck);
+    rejectedInputs += currentAckResult.rejected + replayedAckResult.rejected + staleAckResult.rejected;
+    rejectionReasons.push(...currentAckResult.rejectionReasons, ...replayedAckResult.rejectionReasons, ...staleAckResult.rejectionReasons);
+    const currentCorrection = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityCorrectionEnvelope(nextSequence, runtime, snapshotIdentity, wireFixtureAuthoritySign(auth)));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const forgedCorrection = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityCorrectionEnvelope(nextSequence, runtime, snapshotIdentity, wireFixtureSlotSign(auth, 0)));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const staleCorrection = decodeDeterministicLocalAuthorityWireEnvelope(encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'correction',
+        sequence: nextSequence,
+        payload: { ...currentCorrection.payload, frame: Math.max(0, Number(currentCorrection.payload.frame) - 1) },
+    }, wireFixtureAuthoritySign(auth)));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const currentCorrectionResult = receiver.receive(currentCorrection);
+    const forgedCorrectionResult = receiver.receive(forgedCorrection);
+    const staleCorrectionResult = receiver.receive(staleCorrection);
+    forgedAuthorityCorrectionRejected += Number(forgedCorrectionResult.rejectionReasons.includes('wire-auth-sender-mismatch'));
+    rejectedInputs += currentCorrectionResult.rejected + forgedCorrectionResult.rejected + staleCorrectionResult.rejected;
+    rejectionReasons.push(...currentCorrectionResult.rejectionReasons, ...forgedCorrectionResult.rejectionReasons, ...staleCorrectionResult.rejectionReasons);
+    const currentSnapshot = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotEnvelope(nextSequence, runtime, snapshotIdentity, wireFixtureAuthoritySign(auth)));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const forgedSnapshot = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotEnvelope(nextSequence, runtime, snapshotIdentity, wireFixtureSlotSign(auth, 0)));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const staleSnapshot = decodeDeterministicLocalAuthorityWireEnvelope(encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'snapshot',
+        sequence: nextSequence,
+        payload: { ...currentSnapshot.payload, frame: Math.max(0, Number(currentSnapshot.payload.frame) - 1) },
+    }, wireFixtureAuthoritySign(auth)));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const currentSnapshotResult = receiver.receive(currentSnapshot);
+    const forgedSnapshotResult = receiver.receive(forgedSnapshot);
+    const staleSnapshotResult = receiver.receive(staleSnapshot);
+    forgedAuthoritySnapshotRejected += Number(forgedSnapshotResult.rejectionReasons.includes('wire-auth-sender-mismatch'));
+    rejectedInputs += currentSnapshotResult.rejected + forgedSnapshotResult.rejected + staleSnapshotResult.rejected;
+    rejectionReasons.push(...currentSnapshotResult.rejectionReasons, ...forgedSnapshotResult.rejectionReasons, ...staleSnapshotResult.rejectionReasons);
+    const hostileCommands = [
+        { senderSlot: 0, commands: [{ id: 'wire:hostile:forged', slot: 1, frame: runtime.state.frame, channelId: 'ability', payload: { assetRef: 'ability.dash' } }] },
+        { senderSlot: 0, commands: [{ id: 'wire:hostile:bad-asset', slot: 0, frame: runtime.state.frame, channelId: 'ability', payload: { assetRef: 'missing.asset' } }] },
+        { senderSlot: 0, commands: [{ id: 'wire:hostile:bad-schema', slot: 0, frame: runtime.state.frame, channelId: 'ability', payload: 'bad' }] },
+        { senderSlot: 0, commands: [{ id: 'wire:hostile:future', slot: 0, frame: runtime.state.frame + frames + 128, channelId: 'ability', payload: { assetRef: 'ability.dash' } }] },
+    ];
+    for (const hostile of hostileCommands) {
+        const decoded = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityCommandBundleEnvelope(nextSequence, hostile.commands, wireFixtureSlotSign(auth, hostile.senderSlot)));
+        signedEnvelopes += 1;
+        nextSequence += 1;
+        const applied = receiver.receive(decoded, hostile.senderSlot);
+        rejectedCommands += applied.rejected;
+        rejectionReasons.push(...applied.rejectionReasons);
+    }
+    const wrongIdentity = { ...snapshotIdentity, descriptorHash: `${snapshotIdentity.descriptorHash}:wrong` };
+    const descriptorMismatch = receiver.receive(decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotRequestEnvelope(nextSequence, wrongIdentity, runtime.state.frame, wireFixtureSlotSign(auth, 0))), 0);
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    rejectedInputs += descriptorMismatch.rejected;
+    rejectionReasons.push(...descriptorMismatch.rejectionReasons);
+    const staleTransfer = createDeterministicLocalAuthoritySnapshotTransfer(runtime, snapshotIdentity, `hostile-stale:${nextSequence}`, 512);
+    const staleOffer = receiver.receive(decodeDeterministicLocalAuthorityWireEnvelope(encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'snapshot-offer',
+        sequence: nextSequence,
+        payload: {
+            transferId: staleTransfer.transferId,
+            identity: staleTransfer.identity,
+            frame: Math.max(0, runtime.state.frame - frames - 128),
+            snapshotChecksum: staleTransfer.snapshotChecksum,
+            chunkCount: staleTransfer.chunks.length,
+            totalBytes: staleTransfer.snapshotBytes.length,
+            chunkChecksums: staleTransfer.chunkChecksums,
+        },
+    }, wireFixtureAuthoritySign(auth))));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    rejectedInputs += staleOffer.rejected;
+    rejectionReasons.push(...staleOffer.rejectionReasons);
+    const missingChunkTransfer = createDeterministicLocalAuthoritySnapshotTransfer(runtime, snapshotIdentity, `hostile-missing:${nextSequence}`, 64);
+    const missingOffer = receiver.receive(decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotOfferEnvelope(nextSequence, missingChunkTransfer, wireFixtureAuthoritySign(auth))));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const missingComplete = receiver.receive(decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotCompleteEnvelope(nextSequence, missingChunkTransfer.transferId, wireFixtureAuthoritySign(auth))));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    rejectedInputs += missingOffer.rejected + missingComplete.rejected;
+    rejectionReasons.push(...missingOffer.rejectionReasons, ...missingComplete.rejectionReasons);
+    const badChunkTransfer = createDeterministicLocalAuthoritySnapshotTransfer(runtime, snapshotIdentity, `hostile-bad-chunk:${nextSequence}`, 512);
+    const badOffer = receiver.receive(decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotOfferEnvelope(nextSequence, badChunkTransfer, wireFixtureAuthoritySign(auth))));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    const badChunk = receiver.receive(decodeDeterministicLocalAuthorityWireEnvelope(encodeDeterministicLocalAuthorityWireEnvelope({
+        kind: 'snapshot-chunk',
+        sequence: nextSequence,
+        payload: {
+            transferId: badChunkTransfer.transferId,
+            chunkIndex: 0,
+            chunk: `${badChunkTransfer.chunks[0]}x`,
+            chunkChecksum: badChunkTransfer.chunkChecksums[0],
+        },
+    }, wireFixtureAuthoritySign(auth))));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    rejectedInputs += badOffer.rejected + badChunk.rejected;
+    rejectionReasons.push(...badOffer.rejectionReasons, ...badChunk.rejectionReasons);
+    const identitylessRuntime = (0, local_authority_js_1.createDeterministicLocalAuthorityRuntime)(players, { maxFrameLead: 16 });
+    const identitylessReceiver = createDeterministicLocalAuthorityWireReceiver(identitylessRuntime, {
+        auth: { requireAuth: true, authorityKey: auth.authorityKey, slotKeys: auth.slotKeys },
+    });
+    const identitylessTransfer = createDeterministicLocalAuthoritySnapshotTransfer(identitylessRuntime, snapshotIdentity, `hostile-no-identity:${nextSequence}`, 512);
+    const identitylessOffer = identitylessReceiver.receive(decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthoritySnapshotOfferEnvelope(nextSequence, identitylessTransfer, wireFixtureAuthoritySign(auth))));
+    signedEnvelopes += 1;
+    nextSequence += 1;
+    snapshotIdentityRequiredRejected += Number(identitylessOffer.rejectionReasons.includes('snapshot-identity-required'));
+    rejectedInputs += identitylessOffer.rejected;
+    rejectionReasons.push(...identitylessOffer.rejectionReasons);
+    try {
+        decodeDeterministicLocalAuthorityWireEnvelope(encodeDeterministicLocalAuthorityWireEnvelope({
+            kind: 'input-bundle',
+            sequence: nextSequence,
+            payload: { inputs: [{ slot: 0, frame: runtime.state.frame, value: 1, blob: 'x'.repeat(70_000) }] },
+        }));
+    }
+    catch {
+        oversizedRejected += 1;
+    }
+    return {
+        rejectedInputs,
+        rejectedCommands,
+        malformedRejected,
+        oversizedRejected,
+        signedEnvelopes,
+        forgedAuthorityCorrectionRejected,
+        forgedAuthoritySnapshotRejected,
+        snapshotIdentityRequiredRejected,
+        rejectionReasons,
+    };
+}
+function runWireSequenceWindowFixture(auth) {
+    const runtime = (0, local_authority_js_1.createDeterministicLocalAuthorityRuntime)(1, { maxFrameLead: 8 });
+    const receiver = createDeterministicLocalAuthorityWireReceiver(runtime, {
+        sequenceReplayWindow: 2,
+        auth: { requireAuth: true, authorityKey: auth.authorityKey, slotKeys: auth.slotKeys },
+    });
+    const high = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityInputBundleEnvelope(10, [
+        { slot: 0, frame: 0, value: 10, delay: 0, inputId: 'sequence-window-high' },
+    ], wireFixtureSlotSign(auth, 0)));
+    const delayed = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityInputBundleEnvelope(9, [
+        { slot: 0, frame: 1, value: 9, delay: 0, inputId: 'sequence-window-delayed' },
+    ], wireFixtureSlotSign(auth, 0)));
+    const replayedDelayed = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityInputBundleEnvelope(9, [
+        { slot: 0, frame: 2, value: 99, delay: 0, inputId: 'sequence-window-replayed' },
+    ], wireFixtureSlotSign(auth, 0)));
+    const tooOld = decodeDeterministicLocalAuthorityWireEnvelope(createDeterministicLocalAuthorityInputBundleEnvelope(7, [
+        { slot: 0, frame: 2, value: 7, delay: 0, inputId: 'sequence-window-too-old' },
+    ], wireFixtureSlotSign(auth, 0)));
+    const highResult = receiver.receive(high, 0);
+    const delayedResult = receiver.receive(delayed, 0);
+    const replayedDelayedResult = receiver.receive(replayedDelayed, 0);
+    const tooOldResult = receiver.receive(tooOld, 0);
+    return {
+        reorderedSequenceAccepted: Number(highResult.accepted === 1) * Number(delayedResult.accepted === 1),
+        rejectionReasons: [
+            ...highResult.rejectionReasons,
+            ...delayedResult.rejectionReasons,
+            ...replayedDelayedResult.rejectionReasons,
+            ...tooOldResult.rejectionReasons,
+        ],
+    };
+}
+function isKnownHmacSha256VectorCovered() {
+    return createDeterministicLocalAuthorityWireAuth({
+        schemaVersion: 1,
+        protocol: exports.deterministicLocalAuthorityWireProtocol,
+        kind: 'input-bundle',
+        sequence: 42,
+        payload: { inputs: [{ slot: 0, frame: 1, value: 7 }] },
+    }, { senderId: 'slot:0', key: 'test-secret' }).signature === '945ddd63621adbcbe77e1a02eb18fa63ff500ee9bf34f1870fd359ca08cd5bcf';
+}
+function integerPayloadField(envelope, key) {
+    const value = envelope.payload[key];
+    if (typeof value !== 'number' || !Number.isInteger(value)) {
+        throw new Error(`Wire ${envelope.kind} payload ${key} must be an integer`);
+    }
+    return value;
+}
+function parseRuntimeSnapshotPayload(envelope, key) {
+    const value = envelope.payload[key];
+    if (!isRecord(value)) {
+        throw new Error(`Wire ${envelope.kind} payload ${key} must be a runtime snapshot`);
+    }
+    return (0, canonical_js_1.cloneCanonical)(value);
+}
+function assertSnapshotChecksum(envelope, snapshot) {
+    const expected = envelope.payload.snapshotChecksum;
+    if (typeof expected !== 'string') {
+        throw new Error(`Wire ${envelope.kind} payload snapshotChecksum must be a string`);
+    }
+    const actual = (0, canonical_js_1.defaultChecksum)(snapshot);
+    if (expected !== actual) {
+        throw new Error(`Wire ${envelope.kind} snapshot checksum mismatch`);
+    }
+}
+function parseSnapshotIdentityPayload(envelope) {
+    const value = envelope.payload.identity;
+    if (!isRecord(value)) {
+        throw new Error(`Wire ${envelope.kind} payload identity must be an object`);
+    }
+    const identity = (0, canonical_js_1.cloneCanonical)(value);
+    assertSnapshotIdentity(identity);
+    return identity;
+}
+function directSnapshotIdentityRejection(envelope, expected) {
+    if (expected === undefined) {
+        return undefined;
+    }
+    if (!isRecord(envelope.payload.identity)) {
+        return 'snapshot-identity-required';
+    }
+    const actual = parseSnapshotIdentityPayload(envelope);
+    return snapshotIdentityMatches(expected, actual) ? undefined : 'snapshot-descriptor-mismatch';
+}
+function parseSnapshotOffer(envelope) {
+    const transferId = stringPayloadField(envelope, 'transferId');
+    if (!isValidTransferId(transferId)) {
+        throw new Error('Snapshot transferId is invalid');
+    }
+    const identity = parseSnapshotIdentityPayload(envelope);
+    const frame = integerPayloadField(envelope, 'frame');
+    const chunkCount = integerPayloadField(envelope, 'chunkCount');
+    const totalBytes = integerPayloadField(envelope, 'totalBytes');
+    const snapshotChecksum = stringPayloadField(envelope, 'snapshotChecksum');
+    const rawChunkChecksums = envelope.payload.chunkChecksums;
+    if (!Array.isArray(rawChunkChecksums) || rawChunkChecksums.some((checksum) => typeof checksum !== 'string')) {
+        throw new Error('Wire snapshot-offer payload chunkChecksums must be a string array');
+    }
+    if (chunkCount <= 0 || rawChunkChecksums.length !== chunkCount) {
+        throw new Error('Wire snapshot-offer chunkCount must match chunkChecksums');
+    }
+    if (totalBytes < 0) {
+        throw new Error('Wire snapshot-offer totalBytes must be non-negative');
+    }
+    return {
+        transferId,
+        identity,
+        frame,
+        snapshotChecksum,
+        chunkCount,
+        totalBytes,
+        chunkChecksums: [...rawChunkChecksums],
+    };
+}
+function parseSnapshotBytes(snapshotBytes) {
+    let parsed;
+    try {
+        parsed = JSON.parse(snapshotBytes);
+    }
+    catch {
+        throw new Error('Snapshot transfer bytes must be valid JSON');
+    }
+    if (!isRecord(parsed)) {
+        throw new Error('Snapshot transfer bytes must encode an object');
+    }
+    return (0, canonical_js_1.cloneCanonical)(parsed);
+}
+function assertSnapshotIdentity(identity) {
+    if (typeof identity.descriptorHash !== 'string' || identity.descriptorHash.length === 0) {
+        throw new Error('Snapshot identity descriptorHash is required');
+    }
+    for (const key of ['schemaHash', 'assetDbHash', 'configHash']) {
+        if (identity[key] !== undefined && (typeof identity[key] !== 'string' || identity[key].length === 0)) {
+            throw new Error(`Snapshot identity ${key} must be a non-empty string`);
+        }
+    }
+}
+function isSnapshotIdentityLike(value) {
+    return value !== undefined && isRecord(value) && typeof value.descriptorHash === 'string';
+}
+function snapshotIdentityMatches(expected, actual) {
+    return expected.descriptorHash === actual.descriptorHash
+        && (expected.schemaHash ?? '') === (actual.schemaHash ?? '')
+        && (expected.assetDbHash ?? '') === (actual.assetDbHash ?? '')
+        && (expected.configHash ?? '') === (actual.configHash ?? '');
+}
+function isValidTransferId(transferId) {
+    return /^[A-Za-z0-9:._-]{1,128}$/.test(transferId);
+}
+function createWireFixtureAuth(players, seed) {
+    return {
+        authorityKey: (0, canonical_js_1.defaultChecksum)({ kind: 'wire-fixture-authority-key', players, seed }),
+        slotKeys: Object.fromEntries(Array.from({ length: players }, (_, slot) => [
+            `slot:${slot}`,
+            (0, canonical_js_1.defaultChecksum)({ kind: 'wire-fixture-slot-key', players, seed, slot }),
+        ])),
+    };
+}
+function wireFixtureAuthoritySign(auth) {
+    return { senderId: 'authority', key: auth.authorityKey };
+}
+function wireFixtureSlotSign(auth, slot) {
+    const senderId = `slot:${slot}`;
+    const key = auth.slotKeys[senderId];
+    if (key === undefined) {
+        throw new Error(`Missing wire fixture auth key for ${senderId}`);
+    }
+    return { senderId, key };
+}
+function parseInputMessage(value) {
+    if (!isRecord(value)) {
+        throw new Error('Wire input must be an object');
+    }
+    const slot = integerField(value, 'slot');
+    const frame = integerField(value, 'frame');
+    const inputValue = integerField(value, 'value');
+    const delay = value.delay === undefined ? undefined : integerField(value, 'delay');
+    const inputId = value.inputId === undefined ? undefined : stringField(value, 'inputId');
+    const data = value.data === undefined ? undefined : canonicalField(value, 'data');
+    // Conditional spreads, not explicit `undefined` properties: a present-but-
+    // undefined field re-encodes as a literal `{"$rdm":"undefined"}` on the wire,
+    // so a benign decode→re-encode relay would emit frames its peers reject.
+    return {
+        slot,
+        frame,
+        value: inputValue,
+        ...(data === undefined ? {} : { data }),
+        ...(delay === undefined ? {} : { delay }),
+        ...(inputId === undefined ? {} : { inputId }),
+    };
+}
+function parseCommandMessage(value) {
+    if (!isRecord(value)) {
+        throw new Error('Wire command must be an object');
+    }
+    const id = stringField(value, 'id');
+    const slot = integerField(value, 'slot');
+    const frame = integerField(value, 'frame');
+    const channelId = stringField(value, 'channelId');
+    const payload = canonicalField(value, 'payload');
+    const predicted = value.predicted === undefined ? undefined : booleanField(value, 'predicted');
+    const submittedFrame = value.submittedFrame === undefined ? undefined : integerField(value, 'submittedFrame');
+    return {
+        id,
+        slot,
+        frame,
+        channelId,
+        payload,
+        ...(predicted === undefined ? {} : { predicted }),
+        ...(submittedFrame === undefined ? {} : { submittedFrame }),
+    };
+}
+function classifyRuntimeInputRejection(runtime, beforeRejected, message) {
+    if (runtime.state.rejectedMessages === beforeRejected) {
+        return 'unknown';
+    }
+    if (message.inputId !== undefined && !isValidWireInputId(message.inputId)) {
+        return 'invalid-input-id';
+    }
+    if (message.frame === runtime.state.frame - 1) {
+        return 'duplicate-input';
+    }
+    if (message.frame < runtime.state.frame) {
+        return 'stale-frame';
+    }
+    if (message.frame > runtime.state.frame + 16) {
+        return 'future-frame';
+    }
+    const client = runtime.state.clients[message.slot];
+    if (client?.connected === true && client.spectator !== true) {
+        return 'duplicate-input';
+    }
+    return 'runtime-policy';
+}
+function isValidWireInputId(inputId) {
+    return /^[A-Za-z0-9:._-]{1,128}$/.test(inputId);
+}
+function assertWireKind(kind) {
+    if (kind !== 'input-bundle' &&
+        kind !== 'command-bundle' &&
+        kind !== 'ack' &&
+        kind !== 'correction' &&
+        kind !== 'snapshot' &&
+        kind !== 'snapshot-request' &&
+        kind !== 'snapshot-offer' &&
+        kind !== 'snapshot-chunk' &&
+        kind !== 'snapshot-complete') {
+        throw new Error(`Unknown local authority wire kind ${kind}`);
+    }
+}
+/**
+ * Pre-parse cap: the largest of the per-kind budgets below. Applied to the raw
+ * string before JSON.parse so a hostile blob can't buy unbounded parse cost.
+ */
+const absoluteMaxWireEnvelopeBytes = 2_097_152;
+// NOTE on transports: the engine's local ws-frame codec caps a single frame at
+// 65535 bytes, so a monolithic `snapshot`/`correction` envelope near the 2 MB
+// budget cannot traverse that harness transport — use the chunked
+// snapshot-offer/chunk/complete path there (1 KB chunks). The 2 MB budget
+// exists for host transports (mp-room envelopes) without that frame limit.
+function maxWireEnvelopeBytes(kind) {
+    return kind === 'input-bundle' || kind === 'command-bundle' ? 65_536 : 2_097_152;
+}
+function parseWireAuth(value) {
+    if (!isRecord(value)) {
+        throw new Error('Wire envelope auth must be an object');
+    }
+    const senderId = value.senderId;
+    const signature = value.signature;
+    if (typeof senderId !== 'string') {
+        throw new Error('Wire envelope auth senderId must be a string');
+    }
+    assertWireSenderId(senderId);
+    if (typeof signature !== 'string' || signature.length === 0) {
+        throw new Error('Wire envelope auth signature must be a non-empty string');
+    }
+    return { senderId, signature };
+}
+function assertWireSenderId(senderId) {
+    if (!/^[A-Za-z0-9:._-]{1,128}$/.test(senderId)) {
+        throw new Error('Wire auth senderId is invalid');
+    }
+}
+function verifyWireEnvelopeAuth(envelope, expectedSenderId, options) {
+    const auth = envelope.auth;
+    if (auth === undefined) {
+        return options?.requireAuth === true ? 'missing-wire-auth' : undefined;
+    }
+    if (auth.senderId !== expectedSenderId) {
+        return 'wire-auth-sender-mismatch';
+    }
+    const key = expectedSenderId === 'authority'
+        ? options?.authorityKey
+        : options?.slotKeys?.[expectedSenderId];
+    if (key === undefined) {
+        return 'missing-wire-auth-key';
+    }
+    const baseEnvelope = {
+        schemaVersion: envelope.schemaVersion,
+        protocol: envelope.protocol,
+        kind: envelope.kind,
+        sequence: envelope.sequence,
+        payload: envelope.payload,
+    };
+    const expectedAuth = createDeterministicLocalAuthorityWireAuth(baseEnvelope, { senderId: expectedSenderId, key });
+    return constantTimeEqualHex(auth.signature, expectedAuth.signature) ? undefined : 'wire-auth-signature-mismatch';
+}
+function assertWireSequence(sequence) {
+    if (!Number.isInteger(sequence) || sequence < 0) {
+        throw new Error('Wire envelope sequence must be a non-negative integer');
+    }
+}
+function hmacSha256Hex(key, message) {
+    const blockSize = 64;
+    const rawKey = (0, canonical_js_1.encodeUtf8)(key);
+    const normalizedKey = rawKey.length > blockSize ? sha256(rawKey) : rawKey;
+    const keyBlock = new Uint8Array(blockSize);
+    keyBlock.set(normalizedKey);
+    const outer = new Uint8Array(blockSize);
+    const inner = new Uint8Array(blockSize);
+    for (let index = 0; index < blockSize; index += 1) {
+        outer[index] = keyBlock[index] ^ 0x5c;
+        inner[index] = keyBlock[index] ^ 0x36;
+    }
+    return toHex(sha256(concatBytes(outer, sha256(concatBytes(inner, (0, canonical_js_1.encodeUtf8)(message))))));
+}
+function sha256(bytes) {
+    const hash = [
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ];
+    const constants = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    ];
+    const bitLengthHigh = Math.floor((bytes.length * 8) / 0x100000000);
+    const bitLengthLow = (bytes.length * 8) >>> 0;
+    const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
+    const padded = new Uint8Array(paddedLength);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    writeUint32(padded, paddedLength - 8, bitLengthHigh);
+    writeUint32(padded, paddedLength - 4, bitLengthLow);
+    const words = new Array(64).fill(0);
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+        for (let index = 0; index < 16; index += 1) {
+            words[index] = readUint32(padded, offset + index * 4);
+        }
+        for (let index = 16; index < 64; index += 1) {
+            const s0 = rotateRight(words[index - 15], 7) ^ rotateRight(words[index - 15], 18) ^ (words[index - 15] >>> 3);
+            const s1 = rotateRight(words[index - 2], 17) ^ rotateRight(words[index - 2], 19) ^ (words[index - 2] >>> 10);
+            words[index] = add32(words[index - 16], s0, words[index - 7], s1);
+        }
+        let a = hash[0];
+        let b = hash[1];
+        let c = hash[2];
+        let d = hash[3];
+        let e = hash[4];
+        let f = hash[5];
+        let g = hash[6];
+        let h = hash[7];
+        for (let index = 0; index < 64; index += 1) {
+            const s1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const temp1 = add32(h, s1, ch, constants[index], words[index]);
+            const s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = add32(s0, maj);
+            h = g;
+            g = f;
+            f = e;
+            e = add32(d, temp1);
+            d = c;
+            c = b;
+            b = a;
+            a = add32(temp1, temp2);
+        }
+        hash[0] = add32(hash[0], a);
+        hash[1] = add32(hash[1], b);
+        hash[2] = add32(hash[2], c);
+        hash[3] = add32(hash[3], d);
+        hash[4] = add32(hash[4], e);
+        hash[5] = add32(hash[5], f);
+        hash[6] = add32(hash[6], g);
+        hash[7] = add32(hash[7], h);
+    }
+    const digest = new Uint8Array(32);
+    for (let index = 0; index < hash.length; index += 1) {
+        writeUint32(digest, index * 4, hash[index]);
+    }
+    return digest;
+}
+function constantTimeEqualHex(left, right) {
+    const leftBytes = hexToBytes(left);
+    const rightBytes = hexToBytes(right);
+    const length = Math.max(leftBytes.length, rightBytes.length);
+    let diff = leftBytes.length ^ rightBytes.length;
+    for (let index = 0; index < length; index += 1) {
+        diff |= leftBytes[index] ^ rightBytes[index];
+    }
+    return diff === 0;
+}
+function hexToBytes(hex) {
+    if (!/^[0-9a-f]*$/i.test(hex) || hex.length % 2 !== 0) {
+        return new Uint8Array(0);
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let index = 0; index < bytes.length; index += 1) {
+        bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+    }
+    return bytes;
+}
+function concatBytes(left, right) {
+    const bytes = new Uint8Array(left.length + right.length);
+    bytes.set(left);
+    bytes.set(right, left.length);
+    return bytes;
+}
+function add32(...values) {
+    return values.reduce((sum, value) => (sum + value) >>> 0, 0);
+}
+function rotateRight(value, bits) {
+    return (value >>> bits) | (value << (32 - bits));
+}
+function readUint32(bytes, offset) {
+    return ((bytes[offset] << 24) | (bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3]) >>> 0;
+}
+function writeUint32(bytes, offset, value) {
+    bytes[offset] = (value >>> 24) & 0xff;
+    bytes[offset + 1] = (value >>> 16) & 0xff;
+    bytes[offset + 2] = (value >>> 8) & 0xff;
+    bytes[offset + 3] = value & 0xff;
+}
+function toHex(bytes) {
+    return [...bytes].map((byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function readSequenceReplayWindow(window) {
+    if (window === undefined) {
+        return 64;
+    }
+    if (!Number.isInteger(window) || window < 0) {
+        throw new Error('Wire sequence replay window must be a non-negative integer');
+    }
+    return window;
+}
+function compareNumbers(left, right) {
+    return left - right;
+}
+function compareStrings(left, right) {
+    return Number(left > right) - Number(left < right);
+}
+function integerField(record, key) {
+    const value = record[key];
+    if (typeof value !== 'number' || !Number.isInteger(value)) {
+        throw new Error(`Wire input ${key} must be an integer`);
+    }
+    return value;
+}
+function stringField(record, key) {
+    const value = record[key];
+    if (typeof value !== 'string') {
+        throw new Error(`Wire input ${key} must be a string`);
+    }
+    return value;
+}
+function stringPayloadField(envelope, key) {
+    const value = envelope.payload[key];
+    if (typeof value !== 'string') {
+        throw new Error(`Wire ${envelope.kind} payload ${key} must be a string`);
+    }
+    return value;
+}
+function booleanField(record, key) {
+    const value = record[key];
+    if (typeof value !== 'boolean') {
+        throw new Error(`Wire input ${key} must be a boolean`);
+    }
+    return value;
+}
+function canonicalField(record, key) {
+    return (0, canonical_js_1.cloneCanonical)(record[key]);
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}