@sekiban/dcb-domain 0.1.0

package/dist/parse.d.ts

@@ -0,0 +1,24 @@
+import type { z } from "zod";
+import { DomainAuthoringError, type DomainBoundary, type ParsedAt } from "./types.js";
+export declare class BoundaryParseError extends DomainAuthoringError {
+    readonly boundary: DomainBoundary;
+    readonly finding: string;
+    constructor(boundary: DomainBoundary, finding: string, message: string, options?: ErrorOptions);
+}
+export declare function parseAt<Boundary extends DomainBoundary, Schema extends z.ZodTypeAny>(boundary: Boundary, schema: Schema, value: unknown): ParsedAt<Boundary, z.infer<Schema>>;
+export declare function isParsedAt(value: unknown): boolean;
+export declare function assertParsedAt<Boundary extends DomainBoundary, Value>(boundary: Boundary, value: Value): ParsedAt<Boundary, Value>;
+export declare const parseHttpCommandInput: <Schema extends z.ZodTypeAny>(schema: Schema, value: unknown) => ParsedAt<"http-command", z.core.output<Schema>>;
+export declare const parseQueueMessage: <Schema extends z.ZodTypeAny>(schema: Schema, value: unknown) => ParsedAt<"queue", z.core.output<Schema>>;
+export declare const parseStoredEvent: <Schema extends z.ZodTypeAny>(schema: Schema, value: unknown) => ParsedAt<"stored-event", z.core.output<Schema>>;
+export declare const parseExternalQueryInput: <Schema extends z.ZodTypeAny>(schema: Schema, value: unknown) => ParsedAt<"external-query", z.core.output<Schema>>;
+export interface WasmRestoreDecoder<Schema extends z.ZodTypeAny> {
+    readonly boundary: "wasm-restore";
+    readonly decode: (bytes: Uint8Array | string) => ParsedAt<"wasm-restore", z.infer<Schema>>;
+}
+export declare function createWasmRestoreDecoder<Schema extends z.ZodTypeAny>(schema: Schema): WasmRestoreDecoder<Schema>;
+export declare const wasmRestoreDecoder: typeof createWasmRestoreDecoder;
+export declare const parseCommandIngress: <Schema extends z.ZodTypeAny>(schema: Schema, value: unknown) => ParsedAt<"http-command", z.core.output<Schema>>;
+export declare const parseQueueIngress: <Schema extends z.ZodTypeAny>(schema: Schema, value: unknown) => ParsedAt<"queue", z.core.output<Schema>>;
+export declare const parseStoredEventMaterialization: <Schema extends z.ZodTypeAny>(schema: Schema, value: unknown) => ParsedAt<"stored-event", z.core.output<Schema>>;
+export declare const parseQueryInput: <Schema extends z.ZodTypeAny>(schema: Schema, value: unknown) => ParsedAt<"external-query", z.core.output<Schema>>;

package/dist/parse.js

@@ -0,0 +1,71 @@
+import { DomainAuthoringError, } from "./types";
+const parsedValues = new Map();
+const parsedPrimitives = new Map();
+export class BoundaryParseError extends DomainAuthoringError {
+    boundary;
+    finding;
+    constructor(boundary, finding, message, options) {
+        super("BOUNDARY_PARSE_FAILED", message, options);
+        this.name = "BoundaryParseError";
+        this.boundary = boundary;
+        this.finding = finding;
+    }
+}
+export function parseAt(boundary, schema, value) {
+    try {
+        const parsed = schema.parse(value);
+        if (typeof parsed === "object" && parsed !== null) {
+            const values = parsedValues.get(boundary) ?? new WeakSet();
+            values.add(parsed);
+            parsedValues.set(boundary, values);
+        }
+        else {
+            const values = parsedPrimitives.get(boundary) ?? new Set();
+            values.add(parsed);
+            parsedPrimitives.set(boundary, values);
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new BoundaryParseError(boundary, `${boundary}-parse`, `Input failed the ${boundary} parse boundary`, { cause: error });
+    }
+}
+export function isParsedAt(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    for (const values of parsedValues.values())
+        if (values.has(value))
+            return true;
+    return false;
+}
+export function assertParsedAt(boundary, value) {
+    if ((typeof value === "object" && value !== null && parsedValues.get(boundary)?.has(value) === true) || parsedPrimitives.get(boundary)?.has(value) === true) {
+        return value;
+    }
+    throw new BoundaryParseError(boundary, `${boundary}-parse-bypass`, `Value did not come from the ${boundary} parser`);
+}
+export const parseHttpCommandInput = (schema, value) => parseAt("http-command", schema, value);
+export const parseQueueMessage = (schema, value) => parseAt("queue", schema, value);
+export const parseStoredEvent = (schema, value) => parseAt("stored-event", schema, value);
+export const parseExternalQueryInput = (schema, value) => parseAt("external-query", schema, value);
+export function createWasmRestoreDecoder(schema) {
+    return Object.freeze({
+        boundary: "wasm-restore",
+        decode: (bytes) => {
+            let value;
+            try {
+                const text = typeof bytes === "string" ? bytes : new TextDecoder().decode(bytes);
+                value = JSON.parse(text);
+            }
+            catch (error) {
+                throw new BoundaryParseError("wasm-restore", "wasm-restore-malformed-bytes", "WASM restore bytes were not valid JSON", { cause: error });
+            }
+            return parseAt("wasm-restore", schema, value);
+        },
+    });
+}
+export const wasmRestoreDecoder = createWasmRestoreDecoder;
+export const parseCommandIngress = parseHttpCommandInput;
+export const parseQueueIngress = parseQueueMessage;
+export const parseStoredEventMaterialization = parseStoredEvent;
+export const parseQueryInput = parseExternalQueryInput;

package/dist/session.d.ts

@@ -0,0 +1,108 @@
+import { DomainAuthoringError, type CandidateEnvelope, type DecisionLog, type Done, type EventOf, type FixedNow, type None, type PortableSnapshot, type ReadClaim, type ReadSet, type SnapshotReader, type Tag, type TerminalDecision, type TimeProvider } from "./types.js";
+import { type CommandContext, type CommandDefinition, type StagedEvent } from "./command.js";
+import type { EventDefinition } from "./event.js";
+import type { ProjectorDefinition } from "./state.js";
+export type SessionStatus = "OPEN" | "SEALED" | "DISCARDED";
+export type TagPropagationPoint = "staged-log" | "eligible-cells" | "claim-candidate-preflight" | "sealed-envelope";
+export interface TagPropagationObservation {
+    readonly point: TagPropagationPoint;
+    readonly eventType?: string;
+    readonly tags: readonly Tag[];
+}
+export declare class SessionStateError extends DomainAuthoringError {
+    constructor(message: string);
+}
+export declare class UndeclaredReadError extends DomainAuthoringError {
+    readonly projectorId?: string;
+    readonly tag: Tag;
+    constructor(projectorId: string | undefined, tag: Tag);
+}
+export declare class IncoherentSnapshotError extends DomainAuthoringError {
+    constructor(tag: Tag, firstHead: string | null, secondHead: string | null);
+}
+export interface SessionOptions {
+    readonly now: FixedNow;
+    readonly readSet: ReadSet;
+    readonly snapshots?: SnapshotReader;
+    readonly onPropagation?: (observation: TagPropagationObservation) => void;
+}
+export interface PortableSnapshotWire {
+    readonly projectorId: string;
+    readonly tag: string;
+    readonly head: string | null;
+    readonly state: unknown;
+    readonly exists: boolean;
+}
+export declare function serializePortableSnapshot(snapshot: PortableSnapshot): string;
+export declare function deserializePortableSnapshot(serialized: string): PortableSnapshot;
+export declare class Session {
+    readonly now: FixedNow;
+    private statusValue;
+    private readonly readSet;
+    private readonly snapshots?;
+    private readonly onPropagation?;
+    private readonly snapshotByCell;
+    private readonly overlayByCell;
+    private readonly headByTag;
+    private readonly claimsByKey;
+    private readonly staged;
+    private readonly observations;
+    constructor(options: SessionOptions);
+    get status(): SessionStatus;
+    get stagedEvents(): readonly StagedEvent[];
+    get propagation(): readonly TagPropagationObservation[];
+    get readClaims(): readonly ReadClaim[];
+    private observe;
+    private assertOpen;
+    private assertDeclared;
+    private rememberClaim;
+    private loadSnapshot;
+    private stateFor;
+    private existsFor;
+    private snapshotByCellHasTag;
+    preload(): Promise<void>;
+    private findProjector;
+    private readonly readSetProjectors;
+    private attachProjector;
+    attachProjectors(projectors: readonly ProjectorDefinition[]): void;
+    context(projectors?: readonly ProjectorDefinition[]): CommandContext;
+    append<Event extends EventDefinition>(event: Event, payload: EventOf<Event>): void;
+    private candidateTags;
+    seal(decision: Done): CandidateEnvelope;
+    discard(reason?: string): None | TerminalDecision;
+    finish(decision: TerminalDecision): CandidateEnvelope | undefined;
+    decisionLog(decision: TerminalDecision): DecisionLog;
+}
+export type CommitAttemptResult = {
+    readonly kind: "accepted";
+} | {
+    readonly kind: "consistency-conflict";
+} | {
+    readonly kind: "unknown";
+    readonly error?: unknown;
+} | {
+    readonly kind: "rejected";
+    readonly error?: unknown;
+};
+export interface ExecuteCommandOptions {
+    readonly timeProvider?: TimeProvider;
+    readonly snapshots?: SnapshotReader;
+    readonly commit?: (envelope: CandidateEnvelope) => Promise<unknown> | unknown;
+    readonly maxConflictRetries?: number;
+    readonly onPropagation?: (observation: TagPropagationObservation) => void;
+}
+export interface ExecuteCommandResult {
+    readonly status: "accepted" | "discarded" | "unknown" | "rejected";
+    readonly attempts: number;
+    readonly now: FixedNow;
+    readonly decision: TerminalDecision;
+    readonly envelope?: CandidateEnvelope;
+    readonly log: DecisionLog;
+    readonly session: Session;
+    readonly error?: unknown;
+}
+export declare function executeCommand<Command extends CommandDefinition>(command: Command, input: unknown, options?: ExecuteCommandOptions): Promise<ExecuteCommandResult>;
+export declare const runCommand: typeof executeCommand;
+export declare const runSession: typeof executeCommand;
+export declare const executePortableCommand: typeof executeCommand;
+export declare function serializeDecisionLog(log: DecisionLog): string;

package/dist/session.js

@@ -0,0 +1,381 @@
+import { assertJsonValue, DomainAuthoringError, cloneAndFreeze, normalizeTag, } from "./types";
+import { none, } from "./command";
+export class SessionStateError extends DomainAuthoringError {
+    constructor(message) {
+        super("SESSION_STATE_INVALID", message);
+        this.name = "SessionStateError";
+    }
+}
+export class UndeclaredReadError extends DomainAuthoringError {
+    projectorId;
+    tag;
+    constructor(projectorId, tag) {
+        super("UNDECLARED_DYNAMIC_READ", `Read of ${projectorId ?? "exists"}/${tag.id} was not declared`);
+        this.name = "UndeclaredReadError";
+        this.projectorId = projectorId;
+        this.tag = tag;
+    }
+}
+export class IncoherentSnapshotError extends DomainAuthoringError {
+    constructor(tag, firstHead, secondHead) {
+        super("INCOHERENT_SNAPSHOT", `Tag ${tag.id} was supplied with heads ${firstHead ?? "null"} and ${secondHead ?? "null"}`);
+        this.name = "IncoherentSnapshotError";
+    }
+}
+export function serializePortableSnapshot(snapshot) {
+    const state = assertJsonValue(snapshot.state, "snapshot-serialization");
+    return JSON.stringify({
+        projectorId: snapshot.projectorId,
+        tag: snapshot.tag.id,
+        head: snapshot.head,
+        state,
+        exists: snapshot.exists,
+    });
+}
+export function deserializePortableSnapshot(serialized) {
+    let parsed;
+    try {
+        parsed = JSON.parse(serialized);
+    }
+    catch (error) {
+        throw new DomainAuthoringError("SNAPSHOT_SERIALIZATION_INVALID", "Portable snapshot was not valid JSON", { cause: error });
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new DomainAuthoringError("SNAPSHOT_SERIALIZATION_INVALID", "Portable snapshot must be an object");
+    }
+    const record = parsed;
+    if (typeof record.projectorId !== "string" || typeof record.tag !== "string" ||
+        (record.head !== null && typeof record.head !== "string") || typeof record.exists !== "boolean") {
+        throw new DomainAuthoringError("SNAPSHOT_SERIALIZATION_INVALID", "Portable snapshot fields were invalid");
+    }
+    return Object.freeze({
+        projectorId: record.projectorId,
+        tag: normalizeTag(record.tag),
+        head: record.head,
+        state: assertJsonValue(record.state, "snapshot-deserialization"),
+        exists: record.exists,
+    });
+}
+function cellKey(projector, tag) {
+    return `${projector.id}\u0000${tag.id}`;
+}
+function initialState(projector) {
+    return typeof projector.initialState === "function"
+        ? projector.initialState()
+        : projector.initialState;
+}
+function eventEligible(projector, cellTag, event) {
+    return event.tags.some((tag) => tag.id === cellTag.id && tag.family === projector.tag.family)
+        && projector.subscribes(event.eventType);
+}
+function asRecord(event) {
+    return Object.freeze({
+        eventType: event.eventType,
+        eventName: event.event.eventPayloadName,
+        payload: event.payload,
+        tags: Object.freeze([...event.tags]),
+        ordinal: event.ordinal,
+    });
+}
+export class Session {
+    now;
+    statusValue = "OPEN";
+    readSet;
+    snapshots;
+    onPropagation;
+    snapshotByCell = new Map();
+    overlayByCell = new Map();
+    headByTag = new Map();
+    claimsByKey = new Map();
+    staged = [];
+    observations = [];
+    constructor(options) {
+        this.now = options.now;
+        this.readSet = options.readSet;
+        this.snapshots = options.snapshots;
+        this.onPropagation = options.onPropagation;
+    }
+    get status() {
+        return this.statusValue;
+    }
+    get stagedEvents() {
+        return Object.freeze([...this.staged]);
+    }
+    get propagation() {
+        return Object.freeze([...this.observations]);
+    }
+    get readClaims() {
+        return Object.freeze([...this.claimsByKey.values()]);
+    }
+    observe(observation) {
+        const frozen = Object.freeze({ ...observation, tags: Object.freeze([...observation.tags]) });
+        this.observations.push(frozen);
+        this.onPropagation?.(frozen);
+    }
+    assertOpen() {
+        if (this.statusValue !== "OPEN")
+            throw new SessionStateError(`Session is ${this.statusValue}`);
+    }
+    assertDeclared(kind, projectorId, tag) {
+        if (!this.readSet.has(kind, projectorId, tag))
+            throw new UndeclaredReadError(projectorId, tag);
+    }
+    rememberClaim(declaration, head) {
+        const key = `${declaration.kind}\u0000${declaration.projectorId ?? ""}\u0000${declaration.tag.id}`;
+        this.claimsByKey.set(key, Object.freeze({
+            kind: declaration.kind,
+            ...(declaration.projectorId === undefined ? {} : { projectorId: declaration.projectorId }),
+            tag: declaration.tag,
+            head,
+        }));
+    }
+    async loadSnapshot(projector, tag) {
+        const key = cellKey(projector, tag);
+        const cached = this.snapshotByCell.get(key);
+        if (cached !== undefined)
+            return cached;
+        const supplied = this.snapshots === undefined
+            ? { projectorId: projector.id, tag, head: null, state: initialState(projector), exists: false }
+            : await this.snapshots.read(projector, tag);
+        const suppliedTag = normalizeTag(supplied.tag);
+        if (suppliedTag.id !== tag.id || supplied.projectorId !== projector.id) {
+            throw new DomainAuthoringError("SNAPSHOT_IDENTITY_INVALID", `Snapshot identity did not match ${projector.id}/${tag.id}`);
+        }
+        const suppliedHead = supplied.head ?? "";
+        const existingHead = this.headByTag.get(tag.id);
+        if (existingHead !== undefined && existingHead !== suppliedHead) {
+            throw new IncoherentSnapshotError(tag, existingHead, suppliedHead);
+        }
+        this.headByTag.set(tag.id, suppliedHead);
+        this.snapshotByCell.set(key, supplied);
+        return supplied;
+    }
+    async stateFor(projector, tag) {
+        this.assertOpen();
+        this.assertDeclared("state", projector.id, tag);
+        this.attachProjector(projector);
+        const key = cellKey(projector, tag);
+        const overlay = this.overlayByCell.get(key);
+        if (overlay !== undefined)
+            return overlay;
+        const snapshot = await this.loadSnapshot(projector, tag);
+        let state = snapshot.state;
+        for (const staged of this.staged) {
+            const record = asRecord(staged);
+            if (!eventEligible(projector, tag, record))
+                continue;
+            state = projector.apply(state, record);
+            this.observe({ point: "eligible-cells", eventType: record.eventType, tags: record.tags });
+        }
+        this.overlayByCell.set(key, state);
+        this.rememberClaim({ kind: "state", projectorId: projector.id, tag }, snapshot.head ?? "");
+        return state;
+    }
+    async existsFor(tag) {
+        this.assertOpen();
+        this.assertDeclared("exists", undefined, tag);
+        const snapshotExists = this.snapshots?.exists === undefined ? undefined : await this.snapshots.exists(tag);
+        const stagedExists = this.staged.some((event) => event.tags.some((candidate) => candidate.id === tag.id));
+        // A host-provided `exists=false` is the base snapshot result, not a veto
+        // over an event already staged in this session.
+        const result = (snapshotExists ?? this.snapshotByCellHasTag(tag)) || stagedExists;
+        let head = this.headByTag.get(tag.id);
+        if (snapshotExists === false) {
+            // `exists=false` is an observed empty-head fact. Keep it distinct from
+            // an exists-only read that did not provide an exact head.
+            head = "";
+            this.headByTag.set(tag.id, head);
+        }
+        else if (snapshotExists === true && this.snapshots?.head !== undefined) {
+            head = await this.snapshots.head(tag);
+            this.headByTag.set(tag.id, head);
+        }
+        this.rememberClaim({ kind: "exists", tag }, head ?? null);
+        return result;
+    }
+    snapshotByCellHasTag(tag) {
+        return [...this.snapshotByCell.values()].some((snapshot) => snapshot.tag.id === tag.id && snapshot.exists);
+    }
+    async preload() {
+        this.assertOpen();
+        for (const declaration of this.readSet.claims) {
+            if (declaration.kind === "state") {
+                const projector = this.findProjector(declaration.projectorId);
+                await this.stateFor(projector, declaration.tag);
+            }
+            else {
+                await this.existsFor(declaration.tag);
+            }
+        }
+    }
+    findProjector(projectorId) {
+        if (projectorId === undefined)
+            throw new DomainAuthoringError("PROJECTOR_ID_REQUIRED", "A state read requires a projector");
+        const declaration = this.readSet.claims.find((claim) => claim.projectorId === projectorId && claim.projector !== undefined);
+        if (declaration?.projector !== undefined)
+            return declaration.projector;
+        throw new DomainAuthoringError("PROJECTOR_NOT_IN_READ_SET", `Projector ${projectorId} was not attached to this session`);
+    }
+    readSetProjectors = new Map();
+    attachProjector(projector) {
+        this.readSetProjectors.set(projector.id, {
+            id: projector.id,
+            tag: projector.tag,
+            subscribes: projector.subscribes,
+            apply: (state, event) => projector.apply(state, event),
+        });
+    }
+    attachProjectors(projectors) {
+        for (const projector of projectors)
+            this.attachProjector(projector);
+    }
+    context(projectors = []) {
+        this.attachProjectors(projectors);
+        return Object.freeze({
+            state: (projector, tag) => this.stateFor(projector, tag),
+            exists: (tag) => this.existsFor(tag),
+            now: () => this.now,
+            append: (event, payload) => this.append(event, payload),
+        });
+    }
+    append(event, payload) {
+        this.assertOpen();
+        const parsed = event.make(payload);
+        const derivedTags = event.tags(parsed).map(normalizeTag);
+        const ordinal = String(this.staged.length);
+        const staged = Object.freeze({
+            event,
+            eventType: event.eventType,
+            payload: parsed,
+            tags: Object.freeze(derivedTags),
+            ordinal,
+        });
+        this.staged.push(staged);
+        this.observe({ point: "staged-log", eventType: event.eventType, tags: derivedTags });
+        const record = asRecord(staged);
+        for (const [key, snapshot] of this.snapshotByCell) {
+            const separator = key.indexOf("\u0000");
+            const projectorId = key.slice(0, separator);
+            const tagId = key.slice(separator + 1);
+            if (!record.tags.some((tag) => tag.id === tagId))
+                continue;
+            const projector = this.readSetProjectors.get(projectorId);
+            if (projector === undefined || !eventEligible(projector, snapshot.tag, record))
+                continue;
+            const previous = this.overlayByCell.get(key) ?? snapshot.state;
+            const next = projector.apply(previous, record);
+            this.overlayByCell.set(key, next);
+            this.observe({ point: "eligible-cells", eventType: event.eventType, tags: record.tags });
+        }
+    }
+    candidateTags() {
+        const tags = new Map();
+        for (const event of this.staged)
+            for (const tag of event.tags)
+                tags.set(tag.id, tag);
+        for (const tag of this.readSet.tags)
+            tags.set(tag.id, tag);
+        return Object.freeze([...tags.values()]);
+    }
+    seal(decision) {
+        this.assertOpen();
+        const tags = this.candidateTags();
+        this.observe({ point: "claim-candidate-preflight", tags });
+        const envelope = Object.freeze({
+            kind: "candidate-envelope",
+            now: this.now,
+            events: Object.freeze(this.staged.map(asRecord)),
+            tags,
+            readClaims: this.readClaims,
+            decision,
+        });
+        this.observe({ point: "sealed-envelope", tags });
+        this.statusValue = "SEALED";
+        return envelope;
+    }
+    discard(reason = "discarded") {
+        this.assertOpen();
+        this.staged.splice(0, this.staged.length);
+        this.overlayByCell.clear();
+        this.statusValue = "DISCARDED";
+        return reason.length === 0 ? none() : none(reason);
+    }
+    finish(decision) {
+        if (decision.kind === "done")
+            return this.seal(decision);
+        this.discard(decision.kind === "none" ? decision.reason ?? "none" : decision.reason);
+        return undefined;
+    }
+    decisionLog(decision) {
+        return Object.freeze({
+            now: this.now,
+            events: Object.freeze(this.staged.map(asRecord)),
+            readClaims: this.readClaims,
+            terminal: decision,
+        });
+    }
+}
+function classifyCommitResult(value) {
+    if (value === undefined || value === true)
+        return { kind: "accepted" };
+    if (typeof value !== "object" || value === null)
+        return { kind: "accepted" };
+    const record = value;
+    if (record.kind === "consistency-conflict" || record.kind === "conflict" || record.code === "consistency_conflict") {
+        return { kind: "consistency-conflict" };
+    }
+    if (record.kind === "unknown" || record.kind === "timeout" || record.code === "unknown_outcome") {
+        return { kind: "unknown", error: value };
+    }
+    if (record.kind === "rejected" || record.kind === "invalid")
+        return { kind: "rejected", error: value };
+    return { kind: "accepted" };
+}
+export async function executeCommand(command, input, options = {}) {
+    const fixedNow = options.timeProvider?.now() ?? 0;
+    const maxRetries = Math.max(0, Math.floor(options.maxConflictRetries ?? 1));
+    const parsed = command.parseInput(input);
+    let attempts = 0;
+    for (;;) {
+        attempts += 1;
+        const readSet = command.reads(parsed);
+        const session = new Session({
+            now: fixedNow,
+            readSet,
+            snapshots: options.snapshots,
+            onPropagation: options.onPropagation,
+        });
+        try {
+            await session.preload();
+            const context = session.context([]);
+            const decision = await command.handle(parsed, context);
+            const envelope = session.finish(decision);
+            const log = session.decisionLog(decision);
+            if (envelope === undefined) {
+                return Object.freeze({ status: decision.kind === "reject" ? "rejected" : "discarded", attempts, now: fixedNow, decision, log, session });
+            }
+            if (options.commit === undefined) {
+                return Object.freeze({ status: "accepted", attempts, now: fixedNow, decision, envelope, log, session });
+            }
+            const commitResult = classifyCommitResult(await options.commit(envelope));
+            if (commitResult.kind === "consistency-conflict" && attempts <= maxRetries)
+                continue;
+            if (commitResult.kind === "unknown")
+                return Object.freeze({ status: "unknown", attempts, now: fixedNow, decision, envelope, log, session, error: commitResult.error });
+            if (commitResult.kind === "rejected")
+                return Object.freeze({ status: "rejected", attempts, now: fixedNow, decision, envelope, log, session, error: commitResult.error });
+            return Object.freeze({ status: "accepted", attempts, now: fixedNow, decision, envelope, log, session });
+        }
+        catch (error) {
+            if (session.status === "OPEN")
+                session.discard("throw");
+            throw error;
+        }
+    }
+}
+export const runCommand = executeCommand;
+export const runSession = executeCommand;
+export const executePortableCommand = executeCommand;
+export function serializeDecisionLog(log) {
+    return JSON.stringify(cloneAndFreeze(log));
+}

package/dist/state.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { type EventOf, type EventRecord, type Tag, type ProjectorLike, type TagFamily } from "./types.js";
+import type { EventDefinition } from "./event.js";
+declare const projectorFamilyInvariant: unique symbol;
+export interface StateUnion<Schema extends z.ZodTypeAny = z.ZodTypeAny> {
+    readonly kind: "state-union";
+    readonly discriminator: string;
+    readonly schema: Schema;
+    readonly parse: (value: unknown) => z.infer<Schema>;
+    readonly initial: z.infer<Schema> | (() => z.infer<Schema>);
+}
+export declare function stateUnion<Schema extends z.ZodTypeAny>(schema: Schema, options: {
+    readonly discriminator?: string;
+    readonly initial: z.infer<Schema> | (() => z.infer<Schema>);
+}): StateUnion<Schema>;
+export declare const state: typeof stateUnion;
+export declare function states<const Variants extends readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>(variants: Variants, options: {
+    readonly discriminator?: string;
+    readonly initial: z.infer<Variants[number]> | (() => z.infer<Variants[number]>);
+}): StateUnion<z.ZodType<z.infer<Variants[number]>>>;
+export type StateOf<Definition extends StateUnion> = z.infer<Definition["schema"]>;
+export type ValidateResult<Kind extends string = string, Details = unknown> = {
+    readonly kind: "reject";
+    readonly rejectKind: Kind;
+    readonly reason: string;
+    readonly details?: Details;
+} | undefined;
+export declare function validationReject<Kind extends string, Details = unknown>(rejectKind: Kind, reason: string, details?: Details): Exclude<ValidateResult<Kind, Details>, undefined>;
+export type PureValidator<State, Args, Kind extends string = string, Details = unknown> = (state: State, args: Args) => ValidateResult<Kind, Details>;
+export type PureEvolver<State, Event extends EventDefinition = EventDefinition> = (state: State, event: ProjectorEvent<Event>) => State;
+export interface DeciderModule<State, Args, Event extends EventDefinition = EventDefinition, Kind extends string = string> {
+    readonly validate: PureValidator<State, Args, Kind>;
+    readonly evolve: PureEvolver<State, Event>;
+}
+export declare function validate<State, Args, Kind extends string = string, Details = unknown>(fn: PureValidator<State, Args, Kind, Details>): PureValidator<State, Args, Kind, Details>;
+export declare function evolve<State, Event extends EventDefinition>(fn: PureEvolver<State, Event>): PureEvolver<State, Event>;
+export declare function decider<State, Args, Event extends EventDefinition, Kind extends string = string>(module: DeciderModule<State, Args, Event, Kind>): DeciderModule<State, Args, Event, Kind>;
+export interface ProjectorEvent<Event extends EventDefinition = EventDefinition> {
+    readonly definition: Event;
+    readonly eventType: string;
+    readonly payload: EventOf<Event>;
+    readonly tags: readonly Tag[];
+}
+export type ProjectorHandler<State, Event extends EventDefinition = EventDefinition> = (state: State, event: ProjectorEvent<Event>) => State;
+export interface ProjectorDefinition<State = unknown, Family extends string = string, Events extends readonly EventDefinition[] = readonly EventDefinition[]> extends ProjectorLike {
+    readonly id: string;
+    readonly version: number;
+    readonly tag: TagFamily<Family>;
+    readonly [projectorFamilyInvariant]: (value: Family) => Family;
+    readonly events: Events;
+    readonly eventTypes: readonly string[];
+    readonly initialState: State | (() => State);
+    readonly handlers: Readonly<Record<string, ProjectorHandler<State, Events[number]>>>;
+    readonly apply: (state: State, event: EventRecord) => State;
+    readonly reduce: (state: State, event: EventRecord) => State;
+    readonly validateState: (state: unknown) => State;
+    readonly serializeState: (state: State) => string;
+    readonly deserializeState: (serialized: string) => State;
+}
+export type ProjectorOptions<State, Family extends string, Events extends readonly EventDefinition[]> = {
+    readonly id: string;
+    readonly version?: number;
+    readonly tag: TagFamily<Family>;
+    readonly state?: StateUnion<z.ZodType<State>>;
+    readonly source?: EventUnionLike<Events>;
+    readonly events?: Events;
+    readonly initialState?: State | (() => State);
+    readonly initial?: State | (() => State);
+    readonly handlers: Readonly<Record<string, ProjectorHandler<State, Events[number]>>>;
+    readonly serializeState?: (state: State) => string;
+    readonly deserializeState?: (serialized: string) => State;
+};
+export interface EventUnionLike<Events extends readonly EventDefinition[]> {
+    readonly events: Events;
+    readonly eventTypes: readonly string[];
+}
+export declare function projector<const State, const Family extends string, const Events extends readonly EventDefinition[]>(options: ProjectorOptions<State, Family, Events>): ProjectorDefinition<State, Family, Events>;
+export declare function projectorInitialState<State>(definition: ProjectorDefinition<State>): State;
+export declare function projectorFamily<Definition extends ProjectorDefinition>(definition: Definition): Definition["tag"];
+export type ProjectorState<Definition extends ProjectorDefinition> = Definition extends ProjectorDefinition<infer State> ? State : never;
+export {};