@sekiban/dcb-domain 0.1.0

package/LICENSE

@@ -0,0 +1,92 @@
+Elastic License 2.0
+
+Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject
+to the limitations and conditions below.
+
+Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set
+of the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other
+notices of the licensor in the software. Any use of the licensor's trademarks
+is subject to applicable law.
+
+Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software.
+
+If you or your company make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license for the software
+granted under these terms ends immediately. If your company makes such a
+claim, your patent license ends immediately for work on behalf of your company.
+
+Notices
+
+You must ensure that anyone who gets a copy of any part of the software from
+you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+No Liability
+
+As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.
+
+Definitions
+
+The licensor is the entity offering these terms, and the software is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+you refers to the individual or entity agreeing to these terms.
+
+your company is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that organization.
+control means ownership of substantially all the assets of an entity, or the
+power to direct its management and policies by vote, contract, or otherwise.
+Control can be direct or indirect.
+
+your licenses are all the licenses granted to you for the software under these
+terms.
+
+use means anything you do with the software requiring one of your licenses.
+
+trademark means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,104 @@
+# @sekiban/dcb-domain
+
+`@sekiban/dcb-domain` is the runtime-free, schema-first authoring layer for
+Sekiban DCB domains. It depends on `zod` only and does not import the runtime,
+storage, transport, or host APIs.
+
+## Install
+
+```sh
+npm install @sekiban/dcb-domain zod
+```
+
+The package is ESM-only and supports Node.js 20 or newer. The `zod` runtime
+dependency is pinned to `4.4.3` for the 0.1.x line.
+
+```ts
+import { z } from "zod";
+import {
+  command,
+  done,
+  domain,
+  event,
+  projector,
+  read,
+  stateUnion,
+  tagFamily,
+  toRuntimeDomain,
+} from "@sekiban/dcb-domain";
+
+const order = tagFamily("order");
+const placed = event("OrderPlaced", z.object({ orderId: z.string() }), {
+  tags: (value) => [order.of(value.orderId)],
+});
+
+const orderProjector = projector({
+  id: "orders",
+  tag: order,
+  events: [placed],
+  state: stateUnion(z.object({ count: z.number() }), { initial: { count: 0 } }),
+  initialState: { count: 0 },
+  handlers: {
+    OrderPlaced: (state) => ({ count: state.count + 1 }),
+  },
+});
+
+const place = command({
+  id: "place-order",
+  input: z.object({ orderId: z.string() }),
+  reads: (input) => read(orderProjector, order.of(input.orderId)),
+  handle: async (input, ctx) => {
+    ctx.append(placed, placed.make(input));
+    return done();
+  },
+});
+
+const authoringDomain = domain({
+  events: [placed],
+  projectors: [orderProjector],
+  commands: [place],
+});
+
+// The bridge is the only adapter needed by the existing runtime.
+const runtimeDomain = toRuntimeDomain(authoringDomain);
+```
+
+Events require both a Zod schema and an explicit tag derivation. `make()`
+validates and brands the payload; `append()` accepts that branded payload and
+derives tags from the event definition, so caller-supplied routing cannot drift.
+Projectors bind their tag family at compile time. Commands declare their pure,
+bounded read set and receive only `state`, `exists`, `now`, and `append`.
+
+Sessions use one executor-captured `now`, per-(projector, tag) snapshots, a
+fresh session on consistency-conflict retry, and an atomic `done` envelope.
+`none`, `reject`, thrown errors, and cancellation discard all tentative work.
+Portable snapshots, decision logs, and the five ingress/query parse boundaries
+are exported from the main entrypoint. Pure command/evolve exercises are
+available from `@sekiban/dcb-domain/testing`.
+
+The package boundary is enforced in CI by the dedicated compile-fail project,
+source import/global checks, negative fixtures, and an `npm pack --dry-run`
+inspection. Its only runtime dependency is the pinned `zod` package.
+
+## Versioning
+
+The package follows semver while the major version is `0`: minor releases may
+add public authoring capabilities, and patch releases are limited to fixes and
+documentation. The public surface is frozen to the following entrypoints and
+helpers for the `0.1.x` line:
+
+- Main entrypoint: `domain`, `event`, `eventUnion`, `projector`, `stateUnion`,
+  `command`, `done`, `none`, `reject`, `read`, `readExists`, `Session`,
+  portable-snapshot serialization, the five boundary parsers, and the
+  runtime-domain bridge (`toRuntimeDomain`).
+- Testing entrypoint: `given`, `evolveTable`, and `evolve` from
+  `@sekiban/dcb-domain/testing`.
+- No deep imports beyond `.` and `./testing` are supported.
+
+The earlier `@sekiban/core` and related packages belong to the older
+sekiban-ts line; they are not dependencies or aliases for this package.
+
+The first public release is `0.1.0`. The repository tag
+`dcb-domain-v0.1.0` drives the provenance-enabled release workflow. The final
+`npm publish --provenance --access public` is an operator action performed
+only after the trusted publisher or `NPM_TOKEN` fallback has been configured.

package/dist/bridge.d.ts

@@ -0,0 +1,162 @@
+import { type CandidateEnvelope, type CommitCandidateEvent, type FixedNow, type JsonValue, type SnapshotReader } from "./types.js";
+import type { CommandDefinition } from "./command.js";
+import type { EventDefinition, RuntimeEventValue } from "./event.js";
+import type { AuthoringDomain, DomainViewDefinition } from "./domain.js";
+export interface RuntimeProjectionEvent {
+    readonly eventId?: string;
+    readonly suid?: string;
+    readonly eventType: string;
+    readonly eventPayloadName?: string;
+    readonly payload: unknown;
+    readonly eventTags?: readonly string[];
+    readonly provenance?: "g32";
+}
+export interface RuntimeEventDefinition {
+    readonly name: string;
+    readonly eventName: string;
+    readonly eventPayloadName: string;
+    readonly eventType: string;
+    readonly create: (payload: unknown) => RuntimeEventValue;
+    readonly construct: (payload: unknown) => RuntimeEventValue;
+    readonly parse: (payload: unknown) => JsonValue;
+}
+export interface RuntimeProjectorDefinition {
+    readonly id: string;
+    readonly projectorId: string;
+    readonly version: number;
+    readonly projectorVersion: number;
+    readonly subscribedEventNames: readonly string[];
+    readonly subscribedEventTypes: readonly string[];
+    readonly initialState: JsonValue;
+    readonly apply: (state: JsonValue, event: RuntimeProjectionEvent) => JsonValue;
+    readonly reduce: (state: JsonValue, event: RuntimeProjectionEvent) => JsonValue;
+    readonly serializeState: (state: JsonValue) => string;
+    readonly deserializeState: (serialized: string) => JsonValue;
+}
+export interface RuntimeCommandDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly parseInput: (value: unknown) => unknown;
+    readonly execute: (value: unknown, options?: RuntimeCommandExecutionOptions) => RuntimeCommandOutcome | Promise<RuntimeCommandOutcome>;
+    readonly handle: (value: unknown, options?: RuntimeCommandExecutionOptions) => RuntimeCommandOutcome | Promise<RuntimeCommandOutcome>;
+}
+export interface RuntimeCommandCandidateEvent extends CommitCandidateEvent {
+    readonly provenance: "g32";
+}
+export interface RuntimeCommandCandidateEnvelope {
+    readonly kind: "candidate-envelope";
+    readonly now: FixedNow;
+    readonly events: readonly RuntimeCommandCandidateEvent[];
+    readonly tags: CandidateEnvelope["tags"];
+    readonly readClaims: CandidateEnvelope["readClaims"];
+    readonly decision: CandidateEnvelope["decision"];
+}
+export interface RuntimeAllocationVector {
+    readonly candidates: readonly {
+        readonly ordinal: string;
+        readonly suid: string;
+    }[];
+    readonly allocatorLineageId?: string;
+    /** Durable attempt identity returned by the runtime allocator/admission path. */
+    readonly attemptId?: string;
+}
+/**
+ * Immutable response-loss context. Reconciliation must use this exact
+ * candidate and allocation rather than constructing a fresh submission.
+ */
+export interface RuntimeCommandAttemptContext {
+    readonly candidateKey: string;
+    readonly attemptId: string;
+    readonly candidate: RuntimeCommandCandidateEnvelope;
+    readonly allocation?: RuntimeAllocationVector;
+}
+export type RuntimeCommandPortResult = {
+    readonly kind: "accepted";
+    readonly attemptId?: string;
+} | {
+    readonly kind: "consistency-conflict";
+    readonly error?: unknown;
+} | {
+    readonly kind: "unknown";
+    readonly error?: unknown;
+    readonly attemptId?: string;
+} | {
+    readonly kind: "rejected";
+    readonly error?: unknown;
+    readonly reason?: string;
+    readonly code?: string;
+};
+export interface RuntimeCommandPort {
+    /** Read-only conflict barrier. A conflict here must not enter any write port. */
+    readonly conflictBarrier?: (candidate: RuntimeCommandCandidateEnvelope) => Promise<RuntimeCommandPortResult> | RuntimeCommandPortResult;
+    /** Admission write gate runs after the read-only conflict barrier and before allocation. */
+    readonly admit?: (candidate: RuntimeCommandCandidateEnvelope) => Promise<RuntimeCommandPortResult> | RuntimeCommandPortResult;
+    /** Allocation is deliberately after admission and receives no durable id from the authoring log. */
+    readonly allocate?: (candidate: RuntimeCommandCandidateEnvelope) => Promise<RuntimeAllocationVector> | RuntimeAllocationVector;
+    /** Commit receives the one allocated vector and the same canonical G27 event identity. */
+    readonly commit?: (candidate: RuntimeCommandCandidateEnvelope, allocation?: RuntimeAllocationVector) => Promise<RuntimeCommandPortResult> | RuntimeCommandPortResult;
+    /** An unknown outcome is reconciled against the same immutable candidate/attempt/vector, never resubmitted as new work. */
+    readonly reconcile?: (context: RuntimeCommandAttemptContext, outcome: RuntimeCommandPortResult) => Promise<RuntimeCommandPortResult> | RuntimeCommandPortResult;
+}
+export interface RuntimeCommandExecutionOptions {
+    readonly state?: Readonly<Record<string, JsonValue>>;
+    readonly now?: FixedNow;
+    readonly snapshots?: SnapshotReader;
+    readonly runtimePort?: RuntimeCommandPort;
+}
+export interface RuntimeCommandCommitted {
+    readonly kind: "committed";
+    readonly value?: JsonValue;
+    readonly events: readonly RuntimeCommandCandidateEvent[];
+}
+export interface RuntimeCommandNoop {
+    readonly kind: "noop";
+    readonly reason?: string;
+    readonly events: readonly [];
+}
+export interface RuntimeCommandRejected {
+    readonly kind: "rejected";
+    readonly reason: string;
+    readonly code: string;
+    readonly events: readonly [];
+}
+export type RuntimeCommandOutcome = RuntimeCommandCommitted | RuntimeCommandNoop | RuntimeCommandRejected;
+export interface RuntimeDomainDefinition {
+    readonly events: readonly RuntimeEventDefinition[];
+    readonly commands: readonly RuntimeCommandDefinition[];
+    readonly projectors: readonly RuntimeProjectorDefinition[];
+    readonly views: readonly DomainViewDefinition[];
+    readonly queries: readonly [];
+    readonly materializedViews: readonly [];
+    readonly eventByName: ReadonlyMap<string, RuntimeEventDefinition>;
+    readonly eventByType: ReadonlyMap<string, RuntimeEventDefinition>;
+    readonly __sekibanAuthoringBridge: true;
+}
+interface LegacyEventDefinition {
+    readonly name?: string;
+    readonly eventName?: string;
+    readonly eventPayloadName?: string;
+    readonly eventType?: string;
+    readonly parse?: (payload: unknown) => unknown;
+    readonly create?: (payload: unknown) => {
+        readonly payload?: unknown;
+        readonly eventName?: string;
+        readonly eventPayloadName?: string;
+    };
+    readonly construct?: (payload: unknown) => {
+        readonly payload?: unknown;
+        readonly eventName?: string;
+        readonly eventPayloadName?: string;
+    };
+}
+interface LegacyDomainDefinition {
+    readonly events?: readonly LegacyEventDefinition[];
+    readonly commands?: readonly RuntimeCommandDefinition[];
+    readonly projectors?: readonly RuntimeProjectorDefinition[];
+    readonly views?: readonly DomainViewDefinition[];
+}
+/** Adapt an authoring command into the existing runtime's three-outcome contract. */
+export declare function adaptRuntimeCommand(command: CommandDefinition): RuntimeCommandDefinition;
+export declare function toRuntimeDomain(domain: AuthoringDomain<readonly EventDefinition[], readonly unknown[], readonly unknown[]> | LegacyDomainDefinition): RuntimeDomainDefinition;
+export declare const normalizeRuntimeDomain: typeof toRuntimeDomain;
+export {};

package/dist/bridge.js

@@ -0,0 +1,250 @@
+import { assertJsonValue, DomainAuthoringError, } from "./types";
+import { executeCommand } from "./session";
+function runtimeEventFrom(definition) {
+    const name = definition.name ?? definition.eventPayloadName;
+    if (name === undefined || name.length === 0 || name.includes(":"))
+        throw new DomainAuthoringError("EVENT_NAME_INVALID", "Runtime event name is invalid");
+    const eventPayloadName = definition.eventPayloadName ?? name;
+    if (eventPayloadName.length === 0 || eventPayloadName.includes(":"))
+        throw new DomainAuthoringError("EVENT_NAME_INVALID", "Runtime event payload name is invalid");
+    const expectedEventType = eventPayloadName;
+    const eventType = definition.eventType ?? expectedEventType;
+    if (eventType !== expectedEventType)
+        throw new DomainAuthoringError("CANONICAL_EVENT_IDENTITY_INVALID", `Runtime event identity must be ${expectedEventType}`);
+    const parse = (payload) => {
+        const parsed = definition.parse === undefined
+            ? definition.create?.(payload)?.payload ?? definition.construct?.(payload)?.payload ?? payload
+            : definition.parse(payload);
+        return assertJsonValue(parsed, "event-construction");
+    };
+    const create = (payload) => Object.freeze({
+        eventName: name,
+        eventPayloadName,
+        eventType,
+        payload: parse(payload),
+        tags: Object.freeze([]),
+    });
+    return Object.freeze({
+        name,
+        eventName: name,
+        eventPayloadName: definition.eventPayloadName ?? name,
+        eventType,
+        create,
+        construct: create,
+        parse,
+    });
+}
+function runtimeProjectorFrom(definition, events) {
+    const eventTypes = Object.freeze([...definition.eventTypes]);
+    const eventNames = Object.freeze(eventTypes.map((eventType) => events.get(eventType)?.name ?? eventType));
+    const initial = typeof definition.initialState === "function"
+        ? definition.initialState()
+        : definition.initialState;
+    const apply = (state, event) => {
+        const registered = events.get(event.eventType);
+        if (registered === undefined || !eventTypes.includes(event.eventType)) {
+            throw new DomainAuthoringError("EVENT_TYPE_UNREGISTERED", `Runtime projector received ${event.eventType}`);
+        }
+        const syntheticTag = definition.tag.of("__runtime__");
+        const next = definition.apply(state, {
+            eventType: event.eventType,
+            eventName: registered.name,
+            payload: registered.parse(event.payload),
+            tags: [syntheticTag],
+            ordinal: "runtime",
+        });
+        return assertJsonValue(next, "state-persistence");
+    };
+    const serializeState = (state) => definition.serializeState(state);
+    const deserializeState = (serialized) => assertJsonValue(definition.deserializeState(serialized), "state-persistence");
+    return Object.freeze({
+        id: definition.id,
+        projectorId: definition.id,
+        version: definition.version,
+        projectorVersion: definition.version,
+        subscribedEventNames: eventNames,
+        subscribedEventTypes: eventTypes,
+        initialState: assertJsonValue(initial, "state-persistence"),
+        apply,
+        reduce: apply,
+        serializeState,
+        deserializeState,
+    });
+}
+function runtimeCandidateFrom(envelope) {
+    return Object.freeze({
+        kind: "candidate-envelope",
+        now: envelope.now,
+        events: Object.freeze(envelope.events.map((event) => Object.freeze({
+            ...event,
+            provenance: "g32",
+        }))),
+        tags: envelope.tags,
+        readClaims: envelope.readClaims,
+        decision: envelope.decision,
+    });
+}
+function candidateKey(candidate) {
+    return JSON.stringify({
+        now: candidate.now.toString(),
+        events: candidate.events.map((event) => ({
+            eventType: event.eventType,
+            eventName: event.eventName,
+            payload: event.payload,
+            tags: event.tags.map((tag) => tag.id),
+            ordinal: event.ordinal,
+        })),
+        tags: candidate.tags.map((tag) => tag.id),
+        readClaims: candidate.readClaims.map((claim) => ({ kind: claim.kind, projectorId: claim.projectorId, tag: claim.tag.id, head: claim.head })),
+    });
+}
+function freezeAllocation(allocation) {
+    if (allocation === undefined)
+        return undefined;
+    return Object.freeze({
+        ...allocation,
+        candidates: Object.freeze(allocation.candidates.map((candidate) => Object.freeze({ ...candidate }))),
+    });
+}
+function attemptContext(candidate, allocation, attemptId) {
+    const key = candidateKey(candidate);
+    return Object.freeze({
+        candidateKey: key,
+        attemptId: attemptId ?? allocation?.attemptId ?? key,
+        candidate,
+        ...(allocation === undefined ? {} : { allocation }),
+    });
+}
+function defaultRuntimeSnapshots(options) {
+    if (options.snapshots !== undefined)
+        return options.snapshots;
+    const states = options.state ?? {};
+    return {
+        read: (projector, tag) => ({
+            projectorId: projector.id,
+            tag,
+            head: null,
+            state: states[tag.id] ?? (typeof projector.initialState === "function" ? projector.initialState() : projector.initialState),
+            exists: states[tag.id] !== undefined,
+        }),
+    };
+}
+async function commitThroughRuntimePort(envelope, port) {
+    if (port === undefined)
+        return { kind: "accepted" };
+    const candidate = runtimeCandidateFrom(envelope);
+    const barrier = port.conflictBarrier === undefined ? { kind: "accepted" } : await port.conflictBarrier(candidate);
+    if (barrier.kind !== "accepted") {
+        return barrier.kind === "unknown" && port.reconcile !== undefined
+            ? await port.reconcile(attemptContext(candidate, undefined, barrier.attemptId), barrier)
+            : barrier;
+    }
+    const admitted = port.admit === undefined ? { kind: "accepted" } : await port.admit(candidate);
+    if (admitted.kind !== "accepted") {
+        return admitted.kind === "unknown" && port.reconcile !== undefined
+            ? await port.reconcile(attemptContext(candidate, undefined, admitted.attemptId), admitted)
+            : admitted;
+    }
+    const allocation = freezeAllocation(port.allocate === undefined ? undefined : await port.allocate(candidate));
+    const committed = port.commit === undefined
+        ? { kind: "accepted" }
+        : await port.commit(candidate, allocation);
+    return committed.kind === "unknown" && port.reconcile !== undefined
+        ? await port.reconcile(attemptContext(candidate, allocation, committed.attemptId ?? allocation?.attemptId ?? admitted.attemptId), committed)
+        : committed;
+}
+function runtimeEventsFrom(result) {
+    return result.envelope === undefined
+        ? Object.freeze([])
+        : Object.freeze(result.envelope.events.map((event) => Object.freeze({
+            ...event,
+            provenance: "g32",
+        })));
+}
+function runtimeOutcomeFrom(result) {
+    if (result.status === "accepted" && result.decision.kind === "done") {
+        return Object.freeze({
+            kind: "committed",
+            ...(result.decision.value === undefined ? {} : { value: result.decision.value }),
+            events: runtimeEventsFrom(result),
+        });
+    }
+    if (result.status === "discarded") {
+        const reason = result.decision.kind === "none" || result.decision.kind === "reject" ? result.decision.reason : undefined;
+        return Object.freeze({
+            kind: "noop",
+            ...(reason === undefined ? {} : { reason }),
+            events: Object.freeze([]),
+        });
+    }
+    if (result.status === "rejected") {
+        return Object.freeze({
+            kind: "rejected",
+            reason: result.decision.kind === "reject" ? result.decision.reason : "Command was rejected",
+            code: result.decision.kind === "reject" ? result.decision.code : "command_rejected",
+            events: Object.freeze([]),
+        });
+    }
+    return Object.freeze({
+        kind: "rejected",
+        reason: "Command outcome is unknown and requires durable reconciliation",
+        code: "unknown_outcome",
+        events: Object.freeze([]),
+    });
+}
+/** Adapt an authoring command into the existing runtime's three-outcome contract. */
+export function adaptRuntimeCommand(command) {
+    const execute = async (value, options = {}) => {
+        const result = await executeCommand(command, value, {
+            timeProvider: { now: () => options.now ?? 0 },
+            snapshots: defaultRuntimeSnapshots(options),
+            commit: (envelope) => commitThroughRuntimePort(envelope, options.runtimePort),
+        });
+        return runtimeOutcomeFrom(result);
+    };
+    return Object.freeze({
+        id: command.id,
+        name: command.id,
+        parseInput: command.parseInput,
+        execute,
+        handle: execute,
+    });
+}
+export function toRuntimeDomain(domain) {
+    const rawEvents = domain.events ?? [];
+    const events = rawEvents.map(runtimeEventFrom);
+    const byType = new Map();
+    for (const event of events) {
+        if (byType.has(event.eventType))
+            throw new DomainAuthoringError("DUPLICATE_CANONICAL_EVENT_IDENTITY", `Duplicate event identity ${event.eventType}`);
+        byType.set(event.eventType, event);
+    }
+    const byName = new Map();
+    for (const event of events)
+        if (!byName.has(event.name))
+            byName.set(event.name, event);
+    const projectors = [];
+    for (const projectorValue of domain.projectors ?? []) {
+        if (typeof projectorValue === "object" && projectorValue !== null && "tag" in projectorValue) {
+            projectors.push(runtimeProjectorFrom(projectorValue, byType));
+        }
+        else {
+            projectors.push(projectorValue);
+        }
+    }
+    const commands = (domain.commands ?? []).map((command) => typeof command === "object" && command !== null && "reads" in command
+        ? adaptRuntimeCommand(command)
+        : command);
+    return Object.freeze({
+        events: Object.freeze(events),
+        commands: Object.freeze(commands),
+        projectors: Object.freeze(projectors),
+        views: Object.freeze([...(domain.views ?? [])]),
+        queries: Object.freeze([]),
+        materializedViews: Object.freeze([]),
+        eventByName: byName,
+        eventByType: byType,
+        __sekibanAuthoringBridge: true,
+    });
+}
+export const normalizeRuntimeDomain = toRuntimeDomain;

package/dist/command.d.ts

@@ -0,0 +1,53 @@
+import type { z } from "zod";
+import { type EventOf, type FixedNow, type JsonValue, type ReadClaimDeclaration, type ReadSet, type Reject, type RejectKind, type Tag, type TerminalDecision } from "./types.js";
+import type { EventDefinition } from "./event.js";
+import type { ProjectorDefinition, ProjectorState } from "./state.js";
+export interface CommandContext {
+    readonly state: <State, Family extends string, Events extends readonly EventDefinition[]>(projector: ProjectorDefinition<State, Family, Events>, tag: Tag<Family>) => Promise<State>;
+    readonly exists: <Family extends string>(tag: Tag<Family>) => Promise<boolean>;
+    readonly now: () => FixedNow;
+    readonly append: <Event extends EventDefinition>(event: Event, payload: EventOf<Event>) => void;
+}
+export interface StagedEvent<Event extends EventDefinition = EventDefinition> {
+    readonly event: Event;
+    readonly eventType: string;
+    readonly payload: EventOf<Event>;
+    readonly tags: readonly Tag[];
+    readonly ordinal: string;
+}
+export declare function read<State, Family extends string, Events extends readonly EventDefinition[]>(projector: ProjectorDefinition<State, Family, Events>, tag: Tag<Family>): ReadSet;
+export declare function readExists<Family extends string>(tag: Tag<Family>): ReadSet;
+export declare const readTag: typeof readExists;
+export declare function readSet(...declarations: readonly (ReadClaimDeclaration | ReadSet)[]): ReadSet;
+export interface CommandDefinition<Id extends string = string, InputSchema extends z.ZodTypeAny = z.ZodTypeAny> {
+    readonly id: Id;
+    readonly input: InputSchema;
+    readonly parseInput: (value: unknown) => z.infer<InputSchema>;
+    readonly reads: (input: z.infer<InputSchema>) => ReadSet;
+    readonly handle: (input: z.infer<InputSchema>, context: CommandContext) => TerminalDecision | Promise<TerminalDecision>;
+    readonly execute: (input: unknown, context: CommandContext) => TerminalDecision | Promise<TerminalDecision>;
+}
+export interface CommandOptions<InputSchema extends z.ZodTypeAny> {
+    readonly id: string;
+    readonly input: InputSchema;
+    readonly reads: (input: z.infer<InputSchema>) => ReadSet;
+    readonly handle: (input: z.infer<InputSchema>, context: CommandContext) => TerminalDecision | Promise<TerminalDecision>;
+}
+export declare function command<const Id extends string, InputSchema extends z.ZodTypeAny>(options: CommandOptions<InputSchema> & {
+    readonly id: Id;
+}): CommandDefinition<Id, InputSchema>;
+export declare function done<Value extends JsonValue = JsonValue>(value?: Value): Extract<TerminalDecision, {
+    readonly kind: "done";
+}>;
+export declare function none(reason?: string): Extract<TerminalDecision, {
+    readonly kind: "none";
+}>;
+export declare function reject<Kind extends RejectKind, Details = unknown>(rejectKind: Kind, reason: string, details?: Details): Reject<Kind, Details>;
+export declare const terminal: {
+    readonly done: typeof done;
+    readonly none: typeof none;
+    readonly reject: typeof reject;
+};
+export type CommandInput<Definition extends CommandDefinition> = Definition extends CommandDefinition<string, infer Schema> ? z.infer<Schema> : never;
+export type CommandState<Definition extends CommandDefinition> = Definition extends CommandDefinition<string, z.ZodTypeAny> ? ProjectorState<ProjectorDefinition> : never;
+export type CommandDecision = TerminalDecision;