@hunterzhu/pulse-runtime 0.1.0

package/dist/storage/artifacts.d.ts

@@ -0,0 +1,17 @@
+import type { ArtifactRecord, ArtifactRef, LaneId, PrivacyLabel, PrivacyTaint, ProvenanceRef, RuntimeState } from '../core/types.js';
+export interface ArtifactPublication {
+    mediaType: string;
+    content: Uint8Array | string;
+    laneId?: LaneId;
+    ref?: ArtifactRef;
+    privacy?: PrivacyLabel;
+    privacyTaints?: PrivacyTaint[];
+    derivedFrom?: ProvenanceRef[];
+}
+export declare function prepareArtifactPublication(state: RuntimeState, publication: ArtifactPublication): ArtifactRecord;
+export declare function publishArtifact(state: RuntimeState, publication: ArtifactPublication): ArtifactRecord;
+export declare function advanceArtifactId(state: RuntimeState, ref: ArtifactRef): void;
+export declare function readArtifact(state: RuntimeState, ref: ArtifactRef): Uint8Array;
+export declare function pinArtifact(state: RuntimeState, ref: ArtifactRef): void;
+export declare function unpinArtifact(state: RuntimeState, ref: ArtifactRef): void;
+export declare function markArtifactPersisted(state: RuntimeState, ref: ArtifactRef): void;

package/dist/storage/artifacts.js

@@ -0,0 +1,90 @@
+import { createHash } from 'node:crypto';
+import { effectivePrivacy, privacyMetadataForDerivedRef, privacyTaintsForDerivedRefs, privacyRank, strictestPrivacy, validatePrivacyTaints } from '../core/types.js';
+function bytesOf(content) { return typeof content === 'string' ? Buffer.from(content, 'utf8') : new Uint8Array(content); }
+function mergeTaints(...groups) {
+    const output = [];
+    const seen = new Set();
+    for (const group of groups)
+        for (const taint of group ?? []) {
+            const key = JSON.stringify(taint);
+            if (!seen.has(key)) {
+                seen.add(key);
+                output.push(structuredClone(taint));
+            }
+        }
+    return output;
+}
+export function prepareArtifactPublication(state, publication) {
+    if (!publication.mediaType || publication.mediaType.length > 255)
+        throw new Error('INVALID_ARTIFACT_MEDIA_TYPE');
+    const taintError = validatePrivacyTaints(publication.privacyTaints);
+    if (taintError)
+        throw new Error(taintError);
+    const lane = publication.laneId === undefined ? undefined : state.lanes.get(publication.laneId);
+    if (publication.laneId !== undefined && !lane)
+        throw new Error('UNKNOWN_LANE');
+    const refs = publication.derivedFrom ?? [];
+    const sourceMetadata = refs.map((ref) => lane ? privacyMetadataForDerivedRef(state, lane, ref) : undefined);
+    if (sourceMetadata.some((metadata) => metadata === undefined))
+        throw new Error('UNKNOWN_ARTIFACT_SOURCE');
+    const sourcePrivacy = sourceMetadata.map((metadata) => effectivePrivacy(metadata.privacy, metadata.privacyTaints));
+    const privacy = strictestPrivacy([publication.privacy ?? 'public', ...sourcePrivacy]);
+    if (publication.privacy !== undefined && privacyRank(publication.privacy) < privacyRank(strictestPrivacy(sourcePrivacy)))
+        throw new Error('PRIVACY_DOWNGRADE_WITHOUT_PROOF');
+    const sourceTaints = lane ? privacyTaintsForDerivedRefs(state, lane, refs) : [];
+    const content = bytesOf(publication.content);
+    const ref = publication.ref ?? `artifact-${state.nextIds.artifact}`;
+    if (state.artifacts.has(ref))
+        throw new Error('ARTIFACT_REF_ALREADY_EXISTS');
+    const record = {
+        ref,
+        ...(lane ? { agentId: lane.agentId } : {}),
+        mediaType: publication.mediaType,
+        sizeBytes: content.byteLength,
+        contentHash: createHash('sha256').update(content).digest('hex'),
+        contentBase64: Buffer.from(content).toString('base64'),
+        privacy,
+        ...(mergeTaints(sourceTaints, publication.privacyTaints).length ? { privacyTaints: mergeTaints(sourceTaints, publication.privacyTaints) } : {}),
+        ...(refs.length ? { derivedFrom: [...refs] } : {}),
+        storageState: 'memory',
+        pinCount: 0,
+    };
+    return structuredClone(record);
+}
+export function publishArtifact(state, publication) {
+    const record = prepareArtifactPublication(state, publication);
+    state.artifacts.set(record.ref, record);
+    advanceArtifactId(state, record.ref);
+    return structuredClone(record);
+}
+export function advanceArtifactId(state, ref) {
+    const match = /^artifact-(\d+)$/.exec(ref);
+    if (match)
+        state.nextIds.artifact = Math.max(state.nextIds.artifact, Number(match[1]) + 1);
+}
+export function readArtifact(state, ref) {
+    const record = state.artifacts.get(ref);
+    if (!record)
+        throw new Error('UNKNOWN_ARTIFACT_REF');
+    return new Uint8Array(Buffer.from(record.contentBase64, 'base64'));
+}
+export function pinArtifact(state, ref) {
+    const record = state.artifacts.get(ref);
+    if (!record)
+        throw new Error('UNKNOWN_ARTIFACT_REF');
+    record.pinCount++;
+}
+export function unpinArtifact(state, ref) {
+    const record = state.artifacts.get(ref);
+    if (!record)
+        throw new Error('UNKNOWN_ARTIFACT_REF');
+    if (record.pinCount === 0)
+        throw new Error('ARTIFACT_NOT_PINNED');
+    record.pinCount--;
+}
+export function markArtifactPersisted(state, ref) {
+    const record = state.artifacts.get(ref);
+    if (!record)
+        throw new Error('UNKNOWN_ARTIFACT_REF');
+    record.storageState = 'persisted';
+}

package/dist/storage/findings.d.ts

@@ -0,0 +1,12 @@
+import type { DataRef, FindingRecord, LaneId, PrivacyLabel, PrivacyTaint, RuntimeState } from '../core/types.js';
+export interface FindingPublication {
+    statement: string;
+    evidenceRefs: DataRef[];
+    laneId: LaneId;
+    ref?: string;
+    privacy?: PrivacyLabel;
+    privacyTaints?: PrivacyTaint[];
+}
+export declare function prepareFindingPublication(state: RuntimeState, publication: FindingPublication): FindingRecord;
+export declare function publishFinding(state: RuntimeState, publication: FindingPublication): FindingRecord;
+export declare function advanceFindingId(state: RuntimeState, ref: string): void;

package/dist/storage/findings.js

@@ -0,0 +1,70 @@
+import { effectivePrivacy, privacyMetadataForDerivedRef, privacyRank, privacyTaintsForDerivedRefs, provenanceRefId, strictestPrivacy, validatePrivacyTaints } from '../core/types.js';
+import { contentHash, stableSerialize } from '../context/builder.js';
+function sourceVisible(state, laneId, ref) {
+    const lane = state.lanes.get(laneId);
+    if (!lane)
+        return false;
+    if (ref.kind === 'result')
+        return lane.visibleResultRefs === undefined || lane.visibleResultRefs.has(ref.ref);
+    const artifact = state.artifacts.get(ref.ref);
+    return artifact !== undefined && (artifact.agentId === undefined || artifact.agentId === lane.agentId);
+}
+export function prepareFindingPublication(state, publication) {
+    if (!publication.statement.trim() || publication.statement.length > 4096)
+        throw new Error('INVALID_FINDING_STATEMENT');
+    if (publication.evidenceRefs.length === 0)
+        throw new Error('FINDING_REQUIRES_EVIDENCE');
+    const taintError = validatePrivacyTaints(publication.privacyTaints);
+    if (taintError)
+        throw new Error(taintError);
+    const lane = state.lanes.get(publication.laneId);
+    if (!lane)
+        throw new Error('UNKNOWN_LANE');
+    for (const ref of publication.evidenceRefs) {
+        if (!sourceVisible(state, lane.id, ref) || !privacyMetadataForDerivedRef(state, lane, ref))
+            throw new Error(`UNKNOWN_FINDING_EVIDENCE:${provenanceRefId(ref)}`);
+    }
+    const sourceMetadata = publication.evidenceRefs.map((ref) => privacyMetadataForDerivedRef(state, lane, ref));
+    const sourcePrivacy = sourceMetadata.map((metadata) => effectivePrivacy(metadata.privacy, metadata.privacyTaints));
+    const privacy = strictestPrivacy([publication.privacy ?? 'public', ...sourcePrivacy]);
+    if (publication.privacy !== undefined && privacyRank(publication.privacy) < privacyRank(strictestPrivacy(sourcePrivacy)))
+        throw new Error('PRIVACY_DOWNGRADE_WITHOUT_PROOF');
+    const sourceTaints = privacyTaintsForDerivedRefs(state, lane, publication.evidenceRefs);
+    const ref = publication.ref ?? `finding-${state.nextIds.result}`;
+    if (state.results.has(ref))
+        throw new Error('FINDING_REF_ALREADY_EXISTS');
+    const record = {
+        id: ref,
+        producer: { kind: 'lane', id: lane.id },
+        kind: 'finding',
+        agentId: lane.agentId,
+        laneId: lane.id,
+        statement: publication.statement,
+        evidenceRefs: structuredClone(publication.evidenceRefs),
+        value: { statement: publication.statement, evidenceRefs: structuredClone(publication.evidenceRefs) },
+        sizeBytes: Buffer.byteLength(stableSerialize({ statement: publication.statement, evidenceRefs: publication.evidenceRefs }), 'utf8'),
+        contentHash: contentHash({ statement: publication.statement, evidenceRefs: publication.evidenceRefs }),
+        storageState: 'memory',
+        pinCount: 0,
+        privacy,
+        ...(sourceTaints.length || publication.privacyTaints?.length ? { privacyTaints: [...sourceTaints, ...(publication.privacyTaints ?? [])] } : {}),
+        derivedFrom: structuredClone(publication.evidenceRefs),
+    };
+    return structuredClone(record);
+}
+export function publishFinding(state, publication) {
+    const record = prepareFindingPublication(state, publication);
+    state.results.set(record.id, record);
+    const lane = state.lanes.get(record.laneId);
+    if (lane?.visibleResultRefs)
+        lane.visibleResultRefs.add(record.id);
+    else if (lane)
+        lane.visibleResultRefs = new Set([record.id]);
+    advanceFindingId(state, record.id);
+    return structuredClone(record);
+}
+export function advanceFindingId(state, ref) {
+    const match = /^finding-(\d+)$/.exec(ref);
+    if (match)
+        state.nextIds.result = Math.max(state.nextIds.result, Number(match[1]) + 1);
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,8 @@
+export * from './memory.js';
+export * from './session.js';
+export * from './mutation-log.js';
+export * from './policy.js';
+export * from './outbox.js';
+export * from './persistence.js';
+export * from './artifacts.js';
+export * from './findings.js';

package/dist/storage/index.js

@@ -0,0 +1,8 @@
+export * from './memory.js';
+export * from './session.js';
+export * from './mutation-log.js';
+export * from './policy.js';
+export * from './outbox.js';
+export * from './persistence.js';
+export * from './artifacts.js';
+export * from './findings.js';

package/dist/storage/memory.d.ts

@@ -0,0 +1,11 @@
+import type { JsonValue } from '../core/types.js';
+export declare class MemoryStorage {
+    readonly hardLimitBytes: number;
+    private readonly values;
+    private bytes;
+    constructor(hardLimitBytes?: number);
+    put(key: string, value: JsonValue): void;
+    get(key: string): JsonValue | undefined;
+    delete(key: string): boolean;
+    get sizeBytes(): number;
+}

package/dist/storage/memory.js

@@ -0,0 +1,21 @@
+import { stableSerialize } from '../context/builder.js';
+export class MemoryStorage {
+    hardLimitBytes;
+    values = new Map();
+    bytes = 0;
+    constructor(hardLimitBytes = 1_000_000) {
+        this.hardLimitBytes = hardLimitBytes;
+    }
+    put(key, value) {
+        const nextBytes = Buffer.byteLength(stableSerialize(value));
+        const previous = this.values.has(key) ? Buffer.byteLength(stableSerialize(this.values.get(key))) : 0;
+        if (this.bytes - previous + nextBytes > this.hardLimitBytes)
+            throw new Error('SESSION_STORAGE_LIMIT_EXCEEDED');
+        this.values.set(key, structuredClone(value));
+        this.bytes = this.bytes - previous + nextBytes;
+    }
+    get(key) { const value = this.values.get(key); return value === undefined ? undefined : structuredClone(value); }
+    delete(key) { const value = this.values.get(key); if (value === undefined)
+        return false; this.bytes -= Buffer.byteLength(stableSerialize(value)); return this.values.delete(key); }
+    get sizeBytes() { return this.bytes; }
+}

package/dist/storage/mutation-log.d.ts

@@ -0,0 +1,41 @@
+import type { JsonValue, RuntimeState } from '../core/types.js';
+import type { Mutation } from '../core/mutations.js';
+export interface MutationLogEntry {
+    seq: number;
+    transactionId: string;
+    committedAt: number;
+    checksum: string;
+    mutations: Mutation[];
+}
+export interface MutationLogSnapshot {
+    schemaVersion: 1;
+    baseSeq?: number;
+    nextSeq: number;
+    entries: Array<{
+        seq: number;
+        transactionId: string;
+        committedAt: number;
+        checksum: string;
+        mutations: JsonValue;
+    }>;
+}
+export declare class MutationLog {
+    private readonly log;
+    private nextSequence;
+    private baseSequence;
+    constructor(entries?: MutationLogEntry[], baseSequence?: number);
+    get entries(): MutationLogEntry[];
+    get size(): number;
+    get watermark(): number;
+    get lastSequence(): number;
+    findTransaction(transactionId: string): MutationLogEntry | undefined;
+    prepareAppend(transactionId: string, mutations: Mutation[], committedAt?: number): MutationLogEntry;
+    commitPrepared(entry: MutationLogEntry): MutationLogEntry;
+    append(transactionId: string, mutations: Mutation[], committedAt?: number): MutationLogEntry;
+    snapshot(): MutationLogSnapshot;
+    truncateThrough(seq: number): void;
+    static fromSnapshot(snapshot: MutationLogSnapshot | JsonValue): MutationLog;
+    replay(state: RuntimeState, entries?: MutationLogEntry[]): void;
+    private validate;
+}
+export declare function commitMutationTransaction(state: RuntimeState, log: MutationLog, transactionId: string, mutations: Mutation[], committedAt?: number, sessionId?: string): MutationLogEntry;

package/dist/storage/mutation-log.js

@@ -0,0 +1,140 @@
+import { createHash } from 'node:crypto';
+import { apply } from '../core/mutations.js';
+function encode(value) {
+    if (value === undefined)
+        return { $pulseType: 'undefined' };
+    if (value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number')
+        return value;
+    if (Array.isArray(value))
+        return value.map(encode);
+    if (value instanceof Map)
+        return { $pulseType: 'map', entries: [...value.entries()].map(([key, item]) => [encode(key), encode(item)]) };
+    if (value instanceof Set)
+        return { $pulseType: 'set', values: [...value.values()].map(encode) };
+    if (typeof value === 'object') {
+        const result = {};
+        for (const [key, item] of Object.entries(value))
+            result[key] = encode(item);
+        return result;
+    }
+    throw new Error('UNSERIALIZABLE_MUTATION_VALUE');
+}
+function decode(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number')
+        return value;
+    if (Array.isArray(value))
+        return value.map(decode);
+    if (!value || typeof value !== 'object')
+        throw new Error('INVALID_MUTATION_LOG');
+    const object = value;
+    if (object.$pulseType === 'undefined')
+        return undefined;
+    if (object.$pulseType === 'map')
+        return new Map(object.entries.map((entry) => { const pair = entry; return [decode(pair[0]), decode(pair[1])]; }));
+    if (object.$pulseType === 'set')
+        return new Set(object.values.map(decode));
+    return Object.fromEntries(Object.entries(object).map(([key, item]) => [key, decode(item)]));
+}
+function checksum(seq, transactionId, mutations) {
+    return createHash('sha256').update(JSON.stringify(encode({ seq, transactionId, mutations }))).digest('hex');
+}
+function cloneMutations(mutations) { return structuredClone(mutations); }
+export class MutationLog {
+    log;
+    nextSequence;
+    baseSequence;
+    constructor(entries = [], baseSequence = 0) {
+        this.log = entries.map((entry) => ({ ...entry, mutations: cloneMutations(entry.mutations) }));
+        this.baseSequence = baseSequence;
+        this.nextSequence = this.log.length ? Math.max(...this.log.map((entry) => entry.seq)) + 1 : baseSequence + 1;
+        this.validate();
+    }
+    get entries() { return this.log.map((entry) => ({ ...entry, mutations: cloneMutations(entry.mutations) })); }
+    get size() { return this.log.length; }
+    get watermark() { return this.baseSequence; }
+    get lastSequence() { return this.log.at(-1)?.seq ?? this.baseSequence; }
+    findTransaction(transactionId) {
+        const entry = this.log.find((candidate) => candidate.transactionId === transactionId);
+        return entry === undefined ? undefined : { ...entry, mutations: cloneMutations(entry.mutations) };
+    }
+    prepareAppend(transactionId, mutations, committedAt = 0) {
+        if (!transactionId)
+            throw new Error('INVALID_TRANSACTION_ID');
+        const existing = this.findTransaction(transactionId);
+        if (existing)
+            return existing;
+        const seq = this.nextSequence;
+        const clonedMutations = cloneMutations(mutations);
+        return { seq, transactionId, committedAt, mutations: clonedMutations, checksum: checksum(seq, transactionId, clonedMutations) };
+    }
+    commitPrepared(entry) {
+        const existing = this.findTransaction(entry.transactionId);
+        if (existing)
+            return existing;
+        if (entry.seq !== this.nextSequence || checksum(entry.seq, entry.transactionId, entry.mutations) !== entry.checksum)
+            throw new Error('INVALID_MUTATION_LOG');
+        this.log.push({ ...entry, mutations: cloneMutations(entry.mutations) });
+        this.nextSequence = entry.seq + 1;
+        return { ...entry, mutations: cloneMutations(entry.mutations) };
+    }
+    append(transactionId, mutations, committedAt = 0) {
+        return this.commitPrepared(this.prepareAppend(transactionId, mutations, committedAt));
+    }
+    snapshot() {
+        return { schemaVersion: 1, ...(this.baseSequence === 0 ? {} : { baseSeq: this.baseSequence }), nextSeq: this.nextSequence, entries: this.log.map((entry) => ({ seq: entry.seq, transactionId: entry.transactionId, committedAt: entry.committedAt, checksum: entry.checksum, mutations: encode(entry.mutations) })) };
+    }
+    truncateThrough(seq) {
+        if (!Number.isInteger(seq) || seq < this.baseSequence || seq > this.lastSequence)
+            throw new Error('INVALID_CHECKPOINT_WATERMARK');
+        while (this.log[0] && this.log[0].seq <= seq)
+            this.log.shift();
+        this.baseSequence = seq;
+        this.nextSequence = this.log[0]?.seq ?? seq + 1;
+        this.validate();
+    }
+    static fromSnapshot(snapshot) {
+        const value = snapshot;
+        if (!value || value.schemaVersion !== 1 || !Number.isInteger(value.nextSeq) || !Array.isArray(value.entries) || (value.baseSeq !== undefined && (!Number.isInteger(value.baseSeq) || value.baseSeq < 0)))
+            throw new Error('INVALID_MUTATION_LOG');
+        const entries = value.entries.map((entry) => {
+            if (!entry || !Number.isInteger(entry.seq) || typeof entry.transactionId !== 'string' || typeof entry.committedAt !== 'number' || typeof entry.checksum !== 'string')
+                throw new Error('INVALID_MUTATION_LOG');
+            const mutations = decode(entry.mutations);
+            if (!Array.isArray(mutations))
+                throw new Error('INVALID_MUTATION_LOG');
+            return { seq: entry.seq, transactionId: entry.transactionId, committedAt: entry.committedAt, checksum: entry.checksum, mutations: mutations };
+        });
+        const log = new MutationLog(entries, value.baseSeq ?? 0);
+        if (log.nextSequence !== value.nextSeq)
+            throw new Error('INVALID_MUTATION_LOG');
+        return log;
+    }
+    replay(state, entries = this.log) {
+        let expected = this.baseSequence + 1;
+        for (const entry of entries) {
+            if (entry.seq !== expected || checksum(entry.seq, entry.transactionId, entry.mutations) !== entry.checksum)
+                throw new Error('INVALID_MUTATION_LOG');
+            apply(state, cloneMutations(entry.mutations));
+            expected++;
+        }
+    }
+    validate() {
+        let expected = this.baseSequence + 1;
+        for (const entry of this.log) {
+            if (entry.seq !== expected || checksum(entry.seq, entry.transactionId, entry.mutations) !== entry.checksum)
+                throw new Error('INVALID_MUTATION_LOG');
+            expected++;
+        }
+    }
+}
+export function commitMutationTransaction(state, log, transactionId, mutations, committedAt = state.now, sessionId = 'session-unknown') {
+    const existing = log.findTransaction(transactionId);
+    if (existing)
+        return existing;
+    const transactionalMutations = mutations.map((mutation) => mutation.op === 'appendEvent' && mutation.event.txId === undefined ? { ...mutation, event: { ...mutation.event, txId: transactionId } } : mutation);
+    const candidate = structuredClone(state);
+    apply(candidate, transactionalMutations, { sessionId, timestamp: committedAt });
+    const entry = log.prepareAppend(transactionId, transactionalMutations, committedAt);
+    apply(state, cloneMutations(entry.mutations), { sessionId, timestamp: committedAt });
+    return log.commitPrepared(entry);
+}

package/dist/storage/outbox.d.ts

@@ -0,0 +1,30 @@
+import type { EffectRecord, JsonValue, RuntimeState } from '../core/types.js';
+export interface OutboxEntry {
+    id: string;
+    effectId: string;
+    attemptId: string;
+    state: 'pending' | 'claimed';
+    createdAt: number;
+    claimCount: number;
+}
+export interface OutboxSnapshot {
+    schemaVersion: 1;
+    entries: OutboxEntry[];
+}
+export declare class EffectOutbox {
+    private readonly entries;
+    enqueue(effect: Pick<EffectRecord, 'id' | 'attemptId'>, createdAt?: number): OutboxEntry;
+    claim(id: string): OutboxEntry | undefined;
+    requeue(id: string): void;
+    ack(id: string): boolean;
+    get(id: string): OutboxEntry | undefined;
+    get size(): number;
+    pending(): OutboxEntry[];
+    claimed(): OutboxEntry[];
+    snapshot(): OutboxSnapshot;
+    static fromSnapshot(snapshot: OutboxSnapshot | JsonValue): EffectOutbox;
+    recover(state: RuntimeState): {
+        requeued: string[];
+        unknown: string[];
+    };
+}

package/dist/storage/outbox.js

@@ -0,0 +1,59 @@
+export class EffectOutbox {
+    entries = new Map();
+    enqueue(effect, createdAt = 0) {
+        const id = `${effect.id}:${effect.attemptId}`;
+        const existing = this.entries.get(id);
+        if (existing)
+            return { ...existing };
+        const entry = { id, effectId: effect.id, attemptId: effect.attemptId, state: 'pending', createdAt, claimCount: 0 };
+        this.entries.set(id, entry);
+        return { ...entry };
+    }
+    claim(id) {
+        const entry = this.entries.get(id);
+        if (!entry || entry.state === 'claimed')
+            return undefined;
+        entry.state = 'claimed';
+        entry.claimCount++;
+        return { ...entry };
+    }
+    requeue(id) { const entry = this.entries.get(id); if (entry)
+        entry.state = 'pending'; }
+    ack(id) { return this.entries.delete(id); }
+    get(id) { const entry = this.entries.get(id); return entry === undefined ? undefined : { ...entry }; }
+    get size() { return this.entries.size; }
+    pending() { return [...this.entries.values()].filter((entry) => entry.state === 'pending').map((entry) => ({ ...entry })); }
+    claimed() { return [...this.entries.values()].filter((entry) => entry.state === 'claimed').map((entry) => ({ ...entry })); }
+    snapshot() { return { schemaVersion: 1, entries: [...this.entries.values()].map((entry) => ({ ...entry })) }; }
+    static fromSnapshot(snapshot) {
+        const value = snapshot;
+        if (!value || value.schemaVersion !== 1 || !Array.isArray(value.entries))
+            throw new Error('INVALID_OUTBOX_SNAPSHOT');
+        const outbox = new EffectOutbox();
+        for (const entry of value.entries) {
+            if (!entry || typeof entry.id !== 'string' || entry.id.length === 0 || typeof entry.effectId !== 'string' || entry.effectId.length === 0 || typeof entry.attemptId !== 'string' || entry.attemptId.length === 0 || entry.id !== `${entry.effectId}:${entry.attemptId}` || !['pending', 'claimed'].includes(entry.state) || typeof entry.createdAt !== 'number' || !Number.isFinite(entry.createdAt) || !Number.isInteger(entry.claimCount) || entry.claimCount < 0 || (entry.state === 'claimed' && entry.claimCount < 1))
+                throw new Error('INVALID_OUTBOX_SNAPSHOT');
+            if (outbox.entries.has(entry.id))
+                throw new Error('INVALID_OUTBOX_SNAPSHOT');
+            outbox.entries.set(entry.id, { ...entry });
+        }
+        return outbox;
+    }
+    recover(state) {
+        const requeued = [];
+        const unknown = [];
+        for (const entry of this.entries.values()) {
+            const effect = state.effects.get(entry.effectId);
+            if (!effect || effect.attemptId !== entry.attemptId || effect.outcome) {
+                this.entries.delete(entry.id);
+                unknown.push(entry.id);
+                continue;
+            }
+            if (entry.state === 'claimed') {
+                entry.state = 'pending';
+                requeued.push(entry.id);
+            }
+        }
+        return { requeued, unknown };
+    }
+}