@agentplat/mesh-sim 0.3.0-alpha.1 → 0.3.0-alpha.2

package/dist/reducer-scenario.js

@@ -0,0 +1,774 @@
+import { canonicalizeMeshJsonBytes } from '@agentplat/mesh-protocol';
+import { MESH_SIMULATION_FAULT_LIMITS, } from './index.js';
+const reducerScenarioCanonicalLimits = Object.freeze({
+    maximumEnvelopeBytes: 64 * 1024 * 1024,
+    maximumPayloadBytes: 64 * 1024 * 1024,
+    maximumNestingDepth: 128,
+    maximumTotalObjectKeys: 2_000_000,
+    maximumObjectKeys: 1_000_000,
+    maximumTotalArrayItems: 2_000_000,
+    maximumArrayItems: 1_000_000,
+    maximumStringBytes: 1_048_576,
+});
+/**
+ * Runs a closed serialized schedule against a caller supplied production reducer
+ * dispatch table. Faults mutate only driver availability, links, clocks, or the
+ * event queue.
+ */
+export async function runMeshReducerScenario(inputConfig, inputRuntime) {
+    assertPlainRecord(inputRuntime, 'runtime');
+    assertExactKeys(inputRuntime, ['driverId', 'project', 'projectionId', 'reduce'], ['invariants']);
+    if (typeof inputRuntime.reduce !== 'function' ||
+        typeof inputRuntime.project !== 'function')
+        throw new TypeError('Invalid Mesh reducer scenario runtime');
+    const rawInvariants = inputRuntime.invariants ?? [];
+    assertDenseArray(rawInvariants, 'runtime invariants');
+    if (rawInvariants.length > 256)
+        throw new RangeError('Mesh reducer scenario invariant limit exceeded');
+    const invariants = Object.freeze(rawInvariants.map((invariant) => {
+        assertPlainRecord(invariant, 'runtime invariant');
+        assertExactKeys(invariant, ['evaluate', 'name']);
+        assertString(invariant.name, 'invariant name');
+        if (typeof invariant.evaluate !== 'function')
+            throw new TypeError('Invalid Mesh reducer scenario invariant');
+        return Object.freeze({
+            name: invariant.name,
+            evaluate: invariant.evaluate,
+        });
+    }));
+    const runtime = Object.freeze({
+        driverId: inputRuntime.driverId,
+        projectionId: inputRuntime.projectionId,
+        reduce: inputRuntime.reduce,
+        project: inputRuntime.project,
+        invariants,
+    });
+    const config = deepFreezeData(inputConfig);
+    validateScenario(config, runtime);
+    const runtimeDescriptor = Object.freeze({
+        driverId: runtime.driverId,
+        projectionId: runtime.projectionId,
+        invariantNames: Object.freeze(runtime.invariants.map(({ name }) => name)),
+    });
+    const configurationDigest = await digest({
+        config,
+        ...runtimeDescriptor,
+    });
+    const faultPlanDigest = await digest(config.faultPlan);
+    const states = new Map(config.peers.map(({ peerId, state }) => [peerId, deepFreezeData(state)]));
+    const availability = new Map(config.peers.map(({ peerId }) => [peerId, true]));
+    const clockOffsets = new Map(config.peers.map(({ peerId }) => [peerId, 0]));
+    const links = new Map(config.links.map((link) => [linkKey(link.fromPeerId, link.toPeerId), link]));
+    const prngStates = new Map();
+    let insertionSequence = 0;
+    const queue = [];
+    for (const event of config.events)
+        queue.push(Object.freeze({
+            ...event,
+            action: deepFreezeData(event.action),
+            insertionSequence: ++insertionSequence,
+        }));
+    for (const fault of config.faultPlan.faults) {
+        const frozenFault = deepFreezeData(fault);
+        const targetPeerId = faultTargetPeerId(frozenFault, config.peers);
+        const faultEventId = `fault:${frozenFault.faultId}`;
+        assertString(faultEventId, 'fault eventId');
+        queue.push(Object.freeze({
+            eventId: faultEventId,
+            targetPeerId,
+            logicalTime: frozenFault.logicalTime,
+            priority: frozenFault.priority,
+            action: Object.freeze({}),
+            insertionSequence: ++insertionSequence,
+            fault: frozenFault,
+        }));
+    }
+    queue.sort(compareQueued);
+    const records = [];
+    const faultRecords = [];
+    let chainDigest = configurationDigest;
+    let logicalTime = 0;
+    let reducerCalls = 0;
+    let acceptedReducerCalls = 0;
+    let rejectedReducerCalls = 0;
+    let suppressedEvents = 0;
+    while (queue.length > 0) {
+        if (records.length >= config.limits.maximumEvents)
+            throw new RangeError('Mesh reducer scenario event limit exceeded');
+        const event = queue.shift();
+        if (event === undefined)
+            throw new TypeError('Mesh reducer scenario queue became inconsistent');
+        logicalTime = event.logicalTime;
+        const order = Object.freeze({
+            logicalTime,
+            priority: event.priority,
+            insertionSequence: event.insertionSequence,
+        });
+        let kind = 'reducer';
+        let accepted = false;
+        let rejectionCode;
+        let effects = Object.freeze([]);
+        let faultRecord;
+        if (event.fault !== undefined) {
+            kind = 'fault';
+            const applied = applyFault(event.fault, queue, availability, clockOffsets, links, config, () => ++insertionSequence);
+            suppressedEvents += applied.suppressedEvents ?? 0;
+            accepted = applied.applied;
+            faultRecord = Object.freeze({
+                faultId: event.fault.faultId,
+                kind: event.fault.kind,
+                applied: applied.applied,
+                affectedEventIds: Object.freeze(applied.affectedEventIds),
+                affectedLinkIds: Object.freeze(applied.affectedLinkIds ?? []),
+            });
+            faultRecords.push(faultRecord);
+        }
+        else {
+            const sourcePeerId = event.sourcePeerId;
+            const unavailable = availability.get(event.targetPeerId) !== true;
+            const partitioned = sourcePeerId !== undefined &&
+                links.get(linkKey(sourcePeerId, event.targetPeerId))?.enabled !== true;
+            if (unavailable || partitioned) {
+                kind = 'suppressed';
+                accepted = false;
+                rejectionCode = unavailable
+                    ? 'simulation_peer_crashed'
+                    : 'simulation_partitioned';
+                suppressedEvents += 1;
+            }
+            else {
+                const state = states.get(event.targetPeerId);
+                if (state === undefined)
+                    throw new TypeError('Mesh reducer scenario peer state disappeared');
+                let decision;
+                try {
+                    decision = runtime.reduce({
+                        peerId: event.targetPeerId,
+                        state,
+                        action: event.action,
+                        logicalTime,
+                        clockOffset: clockOffsets.get(event.targetPeerId) ?? 0,
+                        random(scope) {
+                            const scoped = `${event.targetPeerId}:${scope}`;
+                            let value = prngStates.get(scoped) ?? mixSeed(config.seed >>> 0, scoped);
+                            value = xorshift32(value);
+                            prngStates.set(scoped, value);
+                            return value / 0x1_0000_0000;
+                        },
+                    });
+                }
+                catch (error) {
+                    throw new Error(`Mesh reducer scenario event ${event.eventId} threw: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+                }
+                assertDecision(decision);
+                const frozenState = deepFreezeData(decision.state);
+                assertCanonicalWithin(frozenState, config.limits.maximumStateBytes, 'state');
+                states.set(event.targetPeerId, frozenState);
+                accepted = decision.accepted;
+                rejectionCode = decision.rejectionCode;
+                effects = deepFreezeData([...(decision.effects ?? [])]);
+                reducerCalls += 1;
+                if (accepted)
+                    acceptedReducerCalls += 1;
+                else
+                    rejectedReducerCalls += 1;
+            }
+        }
+        const peerStates = frozenRecord([...states]);
+        const projections = frozenRecord([...states].map(([peerId, state]) => [
+            peerId,
+            deepFreezeData(runtime.project(state)),
+        ]));
+        for (const invariant of runtime.invariants ?? [])
+            invariant.evaluate({
+                eventId: event.eventId,
+                peerStates,
+                projections,
+                queuedEvents: queue.length,
+            });
+        const [actionDigest, effectsDigest, stateDigest, projectionDigest] = await Promise.all([
+            digest(event.fault ?? event.action),
+            digest(effects),
+            digest(peerStates),
+            digest(projections),
+        ]);
+        const base = {
+            eventId: event.eventId,
+            peerId: event.targetPeerId,
+            order,
+            kind,
+            accepted,
+            ...(rejectionCode === undefined ? {} : { rejectionCode }),
+            ...(faultRecord === undefined
+                ? {}
+                : {
+                    faultId: faultRecord.faultId,
+                    faultKind: faultRecord.kind,
+                }),
+            actionDigest,
+            effectsDigest,
+            stateDigest,
+            projectionDigest,
+        };
+        chainDigest = await digest({ previous: chainDigest, record: base });
+        records.push(Object.freeze({ ...base, chainDigest }));
+        queue.sort(compareQueued);
+    }
+    const peerStates = frozenRecord([...states]);
+    const projections = frozenRecord([...states].map(([peerId, state]) => [
+        peerId,
+        deepFreezeData(runtime.project(state)),
+    ]));
+    return Object.freeze({
+        scenarioId: config.scenarioId,
+        seed: config.seed,
+        prngVersion: config.prngVersion,
+        configurationDigest,
+        faultPlanDigest,
+        chainDigest,
+        metrics: Object.freeze({
+            processedEvents: records.length,
+            reducerCalls,
+            acceptedReducerCalls,
+            rejectedReducerCalls,
+            faultEvents: faultRecords.length,
+            suppressedEvents,
+            finalLogicalTime: logicalTime,
+        }),
+        records: Object.freeze(records),
+        faults: Object.freeze(faultRecords),
+        peerStates,
+        projections,
+    });
+}
+export async function replayMeshReducerScenario(config, runtime, expected) {
+    const actual = await runMeshReducerScenario(config, runtime);
+    const count = Math.max(expected.records.length, actual.records.length);
+    let firstDivergence;
+    for (let index = 0; index < count; index += 1) {
+        if (expected.records[index]?.chainDigest !==
+            actual.records[index]?.chainDigest) {
+            firstDivergence = index;
+            break;
+        }
+    }
+    const matches = expected.configurationDigest === actual.configurationDigest &&
+        expected.chainDigest === actual.chainDigest;
+    return Object.freeze({
+        matches,
+        expectedChainDigest: expected.chainDigest,
+        actualChainDigest: actual.chainDigest,
+        ...(matches || firstDivergence === undefined ? {} : { firstDivergence }),
+    });
+}
+function validateScenario(config, runtime) {
+    assertPlainRecord(config, 'configuration');
+    assertExactKeys(config, [
+        'events',
+        'faultPlan',
+        'limits',
+        'links',
+        'peers',
+        'prngVersion',
+        'scenarioId',
+        'schemaVersion',
+        'seed',
+    ]);
+    if (!config ||
+        config.schemaVersion !== 1 ||
+        !Number.isSafeInteger(config.seed) ||
+        config.prngVersion !== 'xorshift32-v1')
+        throw new TypeError('Invalid Mesh reducer scenario configuration');
+    assertString(config.scenarioId, 'scenarioId');
+    assertString(runtime.driverId, 'driverId');
+    assertString(runtime.projectionId, 'projectionId');
+    assertDenseArray(config.peers, 'peers');
+    assertDenseArray(config.events, 'events');
+    assertDenseArray(config.links, 'links');
+    assertPlainRecord(config.faultPlan, 'faultPlan');
+    assertExactKeys(config.faultPlan, ['faults', 'schemaVersion']);
+    assertDenseArray(config.faultPlan.faults, 'faults');
+    if (config.peers.length === 0 ||
+        config.peers.length > 256 ||
+        !config.faultPlan ||
+        config.faultPlan.schemaVersion !== 1 ||
+        config.faultPlan.faults.length > MESH_SIMULATION_FAULT_LIMITS.maximumFaults)
+        throw new TypeError('Invalid Mesh reducer scenario collections');
+    const peerIds = new Set();
+    for (const peer of config.peers) {
+        assertPlainRecord(peer, 'peer');
+        assertExactKeys(peer, ['peerId', 'state']);
+        assertString(peer.peerId, 'peerId');
+        if (peerIds.has(peer.peerId))
+            throw new TypeError('Duplicate Mesh reducer scenario peer');
+        peerIds.add(peer.peerId);
+        assertCanonicalWithin(deepFreezeData(peer.state), config.limits.maximumStateBytes, 'initial state');
+    }
+    assertPlainRecord(config.limits, 'limits');
+    assertExactKeys(config.limits, [
+        'maximumEvents',
+        'maximumLogicalTime',
+        'maximumQueuedEvents',
+        'maximumStateBytes',
+    ]);
+    if (!Number.isSafeInteger(config.limits.maximumEvents) ||
+        config.limits.maximumEvents < 1 ||
+        !Number.isSafeInteger(config.limits.maximumLogicalTime) ||
+        config.limits.maximumLogicalTime < 0 ||
+        !Number.isSafeInteger(config.limits.maximumQueuedEvents) ||
+        config.limits.maximumQueuedEvents < 1 ||
+        !Number.isSafeInteger(config.limits.maximumStateBytes) ||
+        config.limits.maximumStateBytes < 1 ||
+        config.limits.maximumStateBytes > 16 * 1024 * 1024 ||
+        config.events.length + config.faultPlan.faults.length >
+            config.limits.maximumQueuedEvents)
+        throw new RangeError('Invalid Mesh reducer scenario limits');
+    const ids = new Set();
+    const eventsById = new Map();
+    for (const event of config.events) {
+        assertPlainRecord(event, 'event');
+        assertExactKeys(event, ['action', 'eventId', 'logicalTime', 'priority', 'targetPeerId'], ['scheduledAt', 'sourcePeerId']);
+        assertString(event.eventId, 'eventId');
+        if (ids.has(event.eventId) ||
+            event.eventId.startsWith('fault:') ||
+            !peerIds.has(event.targetPeerId) ||
+            (event.sourcePeerId !== undefined && !peerIds.has(event.sourcePeerId)) ||
+            (event.scheduledAt !== undefined &&
+                (event.sourcePeerId === undefined ||
+                    !Number.isSafeInteger(event.scheduledAt) ||
+                    event.scheduledAt < 0 ||
+                    event.scheduledAt > event.logicalTime)) ||
+            !Number.isSafeInteger(event.logicalTime) ||
+            event.logicalTime < 0 ||
+            event.logicalTime > config.limits.maximumLogicalTime ||
+            !Number.isSafeInteger(event.priority))
+            throw new TypeError('Invalid Mesh reducer scenario event');
+        ids.add(event.eventId);
+        eventsById.set(event.eventId, event);
+        assertCanonicalWithin(event.action, 1_048_576, 'action');
+    }
+    for (const link of config.links) {
+        assertPlainRecord(link, 'link');
+        assertExactKeys(link, ['enabled', 'fromPeerId', 'latency', 'toPeerId']);
+        if (!peerIds.has(link.fromPeerId) ||
+            !peerIds.has(link.toPeerId) ||
+            link.fromPeerId === link.toPeerId ||
+            !Number.isSafeInteger(link.latency) ||
+            link.latency < 0 ||
+            typeof link.enabled !== 'boolean')
+            throw new TypeError('Invalid Mesh reducer scenario link');
+    }
+    const configuredLinks = new Set();
+    for (const link of config.links) {
+        const key = linkKey(link.fromPeerId, link.toPeerId);
+        if (configuredLinks.has(key))
+            throw new TypeError('Duplicate Mesh reducer scenario link');
+        configuredLinks.add(key);
+    }
+    const faultIds = new Set();
+    for (const fault of config.faultPlan.faults) {
+        validateFaultShape(fault);
+        assertString(fault.faultId, 'faultId');
+        if (faultIds.has(fault.faultId) ||
+            !Number.isSafeInteger(fault.logicalTime) ||
+            fault.logicalTime < 0 ||
+            fault.logicalTime > config.limits.maximumLogicalTime ||
+            !Number.isSafeInteger(fault.priority))
+            throw new TypeError('Invalid Mesh reducer scenario fault');
+        faultIds.add(fault.faultId);
+        validateFaultTargets(fault, peerIds, eventsById, configuredLinks, config.limits.maximumLogicalTime);
+    }
+    const invariantNames = new Set();
+    for (const invariant of runtime.invariants ?? []) {
+        assertString(invariant.name, 'invariant name');
+        if (invariantNames.has(invariant.name))
+            throw new TypeError('Duplicate Mesh reducer scenario invariant');
+        invariantNames.add(invariant.name);
+    }
+    assertCanonicalWithin(deepFreezeData(config), Number.MAX_SAFE_INTEGER, 'configuration');
+}
+function validateFaultTargets(fault, peerIds, eventsById, configuredLinks, maximumLogicalTime) {
+    if ('peerId' in fault && !peerIds.has(fault.peerId))
+        throw new TypeError('Mesh reducer scenario fault peer is unknown');
+    if ('deliveryEventId' in fault) {
+        const target = eventsById.get(fault.deliveryEventId);
+        if (target === undefined)
+            throw new TypeError('Mesh reducer scenario fault event is unknown');
+        if (target.sourcePeerId === undefined)
+            throw new TypeError('Mesh reducer scenario message fault target is not a delivery');
+    }
+    if ('copies' in fault &&
+        (!Number.isSafeInteger(fault.copies) ||
+            fault.copies < 1 ||
+            fault.copies > 16))
+        throw new RangeError('Mesh reducer scenario duplicate limit exceeded');
+    if (fault.kind === 'clock.offset' &&
+        (!Number.isSafeInteger(fault.offset) ||
+            Math.abs(fault.offset) > MESH_SIMULATION_FAULT_LIMITS.maximumClockOffset))
+        throw new RangeError('Mesh reducer scenario clock offset limit exceeded');
+    if ('delay' in fault &&
+        (!Number.isSafeInteger(fault.delay) ||
+            fault.delay < 1 ||
+            !Number.isSafeInteger(eventsById.get(fault.deliveryEventId).logicalTime + fault.delay) ||
+            eventsById.get(fault.deliveryEventId).logicalTime + fault.delay >
+                maximumLogicalTime))
+        throw new RangeError('Invalid Mesh reducer scenario delay');
+    if ('links' in fault) {
+        if (fault.links.length === 0)
+            throw new TypeError('Mesh reducer scenario partition is empty');
+        if (fault.links.length > MESH_SIMULATION_FAULT_LIMITS.maximumLinksPerFault)
+            throw new RangeError('Mesh reducer scenario partition link limit exceeded');
+        const links = new Set();
+        for (const link of fault.links)
+            if (!peerIds.has(link.fromPeerId) ||
+                !peerIds.has(link.toPeerId) ||
+                link.fromPeerId === link.toPeerId)
+                throw new TypeError('Mesh reducer scenario fault link is unknown');
+            else {
+                const key = linkKey(link.fromPeerId, link.toPeerId);
+                if (links.has(key))
+                    throw new TypeError('Duplicate Mesh reducer scenario fault link');
+                if (!configuredLinks.has(key))
+                    throw new TypeError('Mesh reducer scenario fault link is not configured');
+                links.add(key);
+            }
+    }
+    if (fault.kind === 'message.reorder' &&
+        (!Number.isSafeInteger(fault.newLogicalTime) ||
+            !Number.isSafeInteger(fault.newPriority) ||
+            fault.newLogicalTime < fault.logicalTime ||
+            fault.newLogicalTime > maximumLogicalTime))
+        throw new RangeError('Invalid Mesh reducer scenario reorder');
+}
+function validateFaultShape(fault) {
+    assertPlainRecord(fault, 'fault');
+    const base = ['faultId', 'kind', 'logicalTime', 'priority'];
+    if (fault.kind === 'peer.crash' ||
+        fault.kind === 'peer.resume' ||
+        fault.kind === 'clock.offset') {
+        assertExactKeys(fault, [
+            ...base,
+            'peerId',
+            ...(fault.kind === 'clock.offset' ? ['offset'] : []),
+        ]);
+        return;
+    }
+    if (fault.kind === 'message.drop') {
+        assertExactKeys(fault, [...base, 'deliveryEventId']);
+        return;
+    }
+    if (fault.kind === 'message.duplicate') {
+        assertExactKeys(fault, [...base, 'copies', 'deliveryEventId']);
+        return;
+    }
+    if (fault.kind === 'message.delay') {
+        assertExactKeys(fault, [...base, 'delay', 'deliveryEventId']);
+        return;
+    }
+    if (fault.kind === 'message.reorder') {
+        assertExactKeys(fault, [
+            ...base,
+            'deliveryEventId',
+            'newLogicalTime',
+            'newPriority',
+        ]);
+        return;
+    }
+    if (fault.kind === 'network.partition' || fault.kind === 'network.heal') {
+        assertExactKeys(fault, [...base, 'links']);
+        assertDenseArray(fault.links, 'fault links');
+        for (const link of fault.links) {
+            assertPlainRecord(link, 'fault link');
+            assertExactKeys(link, ['fromPeerId', 'toPeerId']);
+        }
+        return;
+    }
+    throw new TypeError('Unsupported Mesh reducer scenario fault kind');
+}
+function applyFault(fault, queue, availability, clockOffsets, links, config, nextInsertionSequence) {
+    if (fault.kind === 'peer.crash') {
+        const changed = availability.get(fault.peerId) !== false;
+        availability.set(fault.peerId, false);
+        if (!changed)
+            return { applied: false, affectedEventIds: [] };
+        const affectedEventIds = [];
+        for (let index = queue.length - 1; index >= 0; index -= 1) {
+            const event = queue[index];
+            if (event.fault === undefined &&
+                event.sourcePeerId !== undefined &&
+                (event.scheduledAt ?? 0) <= fault.logicalTime &&
+                event.targetPeerId === fault.peerId) {
+                affectedEventIds.push(event.eventId);
+                queue.splice(index, 1);
+            }
+        }
+        affectedEventIds.reverse();
+        return { applied: true, affectedEventIds };
+    }
+    if (fault.kind === 'peer.resume') {
+        const changed = availability.get(fault.peerId) !== true;
+        availability.set(fault.peerId, true);
+        return { applied: changed, affectedEventIds: [] };
+    }
+    if (fault.kind === 'clock.offset') {
+        const changed = clockOffsets.get(fault.peerId) !== fault.offset;
+        clockOffsets.set(fault.peerId, fault.offset);
+        return { applied: changed, affectedEventIds: [] };
+    }
+    if (fault.kind === 'network.partition' || fault.kind === 'network.heal') {
+        const enabled = fault.kind === 'network.heal';
+        const affectedEventIds = [];
+        const affectedLinkIds = [];
+        const requestedLinks = new Set(fault.links.map((target) => linkKey(target.fromPeerId, target.toPeerId)));
+        for (const target of fault.links) {
+            const key = linkKey(target.fromPeerId, target.toPeerId);
+            const link = links.get(key);
+            if (link !== undefined && link.enabled !== enabled) {
+                links.set(key, Object.freeze({ ...link, enabled }));
+                affectedLinkIds.push(key);
+            }
+        }
+        let suppressedEvents = 0;
+        if (!enabled) {
+            const droppedEventIds = [];
+            for (let index = queue.length - 1; index >= 0; index -= 1) {
+                const event = queue[index];
+                if (event.fault === undefined &&
+                    event.sourcePeerId !== undefined &&
+                    (event.scheduledAt ?? 0) <= fault.logicalTime &&
+                    requestedLinks.has(linkKey(event.sourcePeerId, event.targetPeerId))) {
+                    droppedEventIds.push(event.eventId);
+                    queue.splice(index, 1);
+                    suppressedEvents += 1;
+                }
+            }
+            affectedEventIds.push(...droppedEventIds.reverse());
+        }
+        return {
+            applied: affectedEventIds.length > 0 || affectedLinkIds.length > 0,
+            affectedEventIds,
+            affectedLinkIds,
+            suppressedEvents,
+        };
+    }
+    if (fault.kind !== 'message.drop' &&
+        fault.kind !== 'message.duplicate' &&
+        fault.kind !== 'message.delay' &&
+        fault.kind !== 'message.reorder')
+        throw new TypeError('Unsupported Mesh reducer scenario fault');
+    const index = queue.findIndex(({ eventId, fault: queuedFault, sourcePeerId, scheduledAt }) => queuedFault === undefined &&
+        sourcePeerId !== undefined &&
+        (scheduledAt ?? 0) <= fault.logicalTime &&
+        eventId === fault.deliveryEventId);
+    if (index < 0)
+        return { applied: false, affectedEventIds: [] };
+    const target = queue[index];
+    if (fault.kind === 'message.drop') {
+        queue.splice(index, 1);
+        return { applied: true, affectedEventIds: [target.eventId] };
+    }
+    if (fault.kind === 'message.duplicate') {
+        const affectedEventIds = [];
+        for (let copy = 1; copy <= fault.copies; copy += 1) {
+            if (queue.length >= config.limits.maximumQueuedEvents)
+                throw new RangeError('Mesh reducer scenario queue limit exceeded');
+            const eventId = `${target.eventId}:duplicate:${fault.faultId}:${copy}`;
+            assertString(eventId, 'duplicate eventId');
+            if (queue.some((event) => event.eventId === eventId))
+                throw new TypeError('Duplicate Mesh reducer scenario event');
+            queue.push(Object.freeze({
+                ...target,
+                eventId,
+                insertionSequence: nextInsertionSequence(),
+            }));
+            affectedEventIds.push(eventId);
+        }
+        return { applied: true, affectedEventIds };
+    }
+    if (fault.kind === 'message.delay') {
+        const logicalTime = target.logicalTime + fault.delay;
+        if (logicalTime > config.limits.maximumLogicalTime)
+            throw new RangeError('Mesh reducer scenario delay exceeds time limit');
+        queue[index] = Object.freeze({ ...target, logicalTime });
+        return { applied: true, affectedEventIds: [target.eventId] };
+    }
+    if (fault.kind !== 'message.reorder')
+        throw new TypeError('Unsupported Mesh reducer scenario queue fault');
+    if (fault.newLogicalTime < fault.logicalTime ||
+        fault.newLogicalTime > config.limits.maximumLogicalTime)
+        throw new RangeError('Mesh reducer scenario reorder exceeds time limit');
+    queue[index] = Object.freeze({
+        ...target,
+        logicalTime: fault.newLogicalTime,
+        priority: fault.newPriority,
+    });
+    return { applied: true, affectedEventIds: [target.eventId] };
+}
+function assertDecision(decision) {
+    if (!decision ||
+        typeof decision !== 'object' ||
+        typeof decision.accepted !== 'boolean' ||
+        (decision.rejectionCode !== undefined &&
+            typeof decision.rejectionCode !== 'string') ||
+        (decision.effects !== undefined && !Array.isArray(decision.effects)))
+        throw new TypeError('Invalid Mesh reducer scenario decision');
+}
+function compareQueued(left, right) {
+    return (left.logicalTime - right.logicalTime ||
+        left.priority - right.priority ||
+        left.insertionSequence - right.insertionSequence);
+}
+function faultTargetPeerId(fault, peers) {
+    const peerId = 'peerId' in fault
+        ? fault.peerId
+        : 'links' in fault
+            ? fault.links[0]?.fromPeerId
+            : peers[0]?.peerId;
+    if (peerId === undefined)
+        throw new TypeError('Mesh reducer scenario fault lacks a target');
+    return peerId;
+}
+function linkKey(fromPeerId, toPeerId) {
+    return JSON.stringify([fromPeerId, toPeerId]);
+}
+function xorshift32(input) {
+    let value = input || 0x6d2b79f5;
+    value ^= value << 13;
+    value ^= value >>> 17;
+    value ^= value << 5;
+    return value >>> 0;
+}
+function mixSeed(seed, scope) {
+    let value = seed ^ 0x811c9dc5;
+    for (let index = 0; index < scope.length; index += 1)
+        value = Math.imul(value ^ scope.charCodeAt(index), 0x01000193);
+    return value >>> 0 || 1;
+}
+function assertPlainRecord(value, name) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new TypeError(`Mesh reducer scenario ${name} must be a record`);
+    const prototype = Object.getPrototypeOf(value);
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if ((prototype !== Object.prototype && prototype !== null) ||
+        Object.getOwnPropertySymbols(value).length !== 0 ||
+        Object.values(descriptors).some((descriptor) => !descriptor.enumerable || !Object.hasOwn(descriptor, 'value')))
+        throw new TypeError(`Mesh reducer scenario ${name} must contain plain data`);
+}
+function assertDenseArray(value, name) {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype)
+        throw new TypeError(`Mesh reducer scenario ${name} must be an array`);
+    const names = Object.getOwnPropertyNames(value);
+    if (names.length !== value.length + 1)
+        throw new TypeError(`Mesh reducer scenario ${name} must be dense`);
+    for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (descriptor === undefined ||
+            !descriptor.enumerable ||
+            !Object.hasOwn(descriptor, 'value'))
+            throw new TypeError(`Mesh reducer scenario ${name} must be dense`);
+    }
+}
+function assertExactKeys(value, required, optional = []) {
+    const supported = new Set([...required, ...optional]);
+    const keys = Object.keys(value);
+    if (keys.some((key) => !supported.has(key)) ||
+        required.some((key) => !Object.hasOwn(value, key)))
+        throw new TypeError('Mesh reducer scenario value contains unsupported fields');
+}
+function assertString(value, name) {
+    if (typeof value !== 'string' ||
+        value.length === 0 ||
+        new TextEncoder().encode(value).byteLength > 768)
+        throw new TypeError(`Invalid Mesh reducer scenario ${name}`);
+}
+function assertCanonicalWithin(value, maximumBytes, name) {
+    const canonical = canonicalizeMeshJsonBytes(value, {
+        limits: reducerScenarioCanonicalLimits,
+    });
+    if (!canonical.ok)
+        throw new TypeError(`Mesh reducer scenario ${name} is not canonical`);
+    if (canonical.value.byteLength > maximumBytes)
+        throw new RangeError(`Mesh reducer scenario ${name} exceeds its byte limit`);
+}
+function deepFreezeData(value, context = {
+    active: new WeakSet(),
+    copies: new WeakMap(),
+    nodes: 0,
+    totalArrayItems: 0,
+    totalObjectKeys: 0,
+}, depth = 0) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'boolean' ||
+        (typeof value === 'number' && Number.isFinite(value)))
+        return value;
+    if (typeof value !== 'object')
+        throw new TypeError('Mesh reducer scenario values must contain data only');
+    if (depth > reducerScenarioCanonicalLimits.maximumNestingDepth ||
+        context.nodes >=
+            reducerScenarioCanonicalLimits.maximumTotalArrayItems +
+                reducerScenarioCanonicalLimits.maximumTotalObjectKeys ||
+        context.active.has(value))
+        throw new RangeError('Mesh reducer scenario value exceeds data limits');
+    const prior = context.copies.get(value);
+    if (prior !== undefined)
+        return prior;
+    context.active.add(value);
+    context.nodes += 1;
+    if (Array.isArray(value)) {
+        if (value.length > reducerScenarioCanonicalLimits.maximumArrayItems ||
+            context.totalArrayItems + value.length >
+                reducerScenarioCanonicalLimits.maximumTotalArrayItems)
+            throw new RangeError('Mesh reducer scenario array exceeds data limits');
+        context.totalArrayItems += value.length;
+        assertDenseArray(value, 'value array');
+        const result = [];
+        context.copies.set(value, result);
+        for (const entry of value) {
+            if (entry === undefined)
+                throw new TypeError('Mesh reducer scenario arrays cannot contain undefined');
+            result.push(deepFreezeData(entry, context, depth + 1));
+        }
+        context.active.delete(value);
+        const frozen = Object.freeze(result);
+        context.copies.set(value, frozen);
+        return frozen;
+    }
+    const propertyNames = Object.getOwnPropertyNames(value);
+    if (propertyNames.length > reducerScenarioCanonicalLimits.maximumObjectKeys ||
+        context.totalObjectKeys + propertyNames.length >
+            reducerScenarioCanonicalLimits.maximumTotalObjectKeys)
+        throw new RangeError('Mesh reducer scenario object exceeds data limits');
+    context.totalObjectKeys += propertyNames.length;
+    assertPlainRecord(value, 'value');
+    const result = Object.create(null);
+    context.copies.set(value, result);
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+        const entry = descriptor.value;
+        if (entry !== undefined)
+            result[key] = deepFreezeData(entry, context, depth + 1);
+    }
+    context.active.delete(value);
+    const frozen = Object.freeze(result);
+    context.copies.set(value, frozen);
+    return frozen;
+}
+async function digest(value) {
+    const canonical = canonicalizeMeshJsonBytes(value, {
+        limits: reducerScenarioCanonicalLimits,
+    });
+    if (!canonical.ok)
+        throw new TypeError(`Mesh reducer scenario value is not canonical: ${JSON.stringify(canonical.issues)}`);
+    const bytes = canonical.value;
+    const source = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    const result = new Uint8Array(await globalThis.crypto.subtle.digest('SHA-256', source));
+    return [...result].map((byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function frozenRecord(entries) {
+    const record = Object.create(null);
+    for (const [key, value] of entries)
+        record[key] = value;
+    return Object.freeze(record);
+}
+//# sourceMappingURL=reducer-scenario.js.map