@rotorsoft/act 1.32.30 → 1.33.1

package/dist/@types/builders/state-builder.d.ts

@@ -1,378 +1,5 @@
-/**
- * @module state-builder
- * @category Builders
- *
- * Fluent interface for defining a strongly-typed state machine using Zod schemas.
- */
-import type { ZodType } from "zod";
-import { type AutoclosePolicy } from "../internal/index.js";
-import type { ActionHandler, ActionOptions, Actor, AutocloseArchiver, Committed, Invariant, PatchHandlers, Schema, Schemas, Snapshot, State, ZodTypes } from "../types/index.js";
-/**
- * Builder interface for defining a state with event sourcing.
- *
- * Provides a fluent API to configure the initial state, event types,
- * and event handlers (reducers) before moving to action configuration.
- *
- * @template TState - State schema type
- * @template TName - State name literal type
- *
- * @see {@link state} for usage examples
- * @see {@link ActionBuilder} for action configuration
- */
-export type StateBuilder<TState extends Schema, TName extends string = string> = {
-    /**
-     * Defines the initial state for new state instances.
-     *
-     * The init function is called when a new stream is created (first event).
-     * It can accept initial data or return a default state.
-     *
-     * @param init - Function returning the initial state
-     * @returns A builder with `.emits()` to declare event types
-     *
-     * @example
-     * ```typescript
-     * .init(() => ({ count: 0, created: new Date() }))
-     * ```
-     */
-    init: (init: () => Readonly<TState>) => {
-        /**
-         * Declares the event types that this state can emit.
-         *
-         * Events represent facts that have happened - they should be named in past tense.
-         * Each event is defined with a Zod schema for type safety and runtime validation.
-         *
-         * @template TEvents - Event schemas type
-         * @param events - Object mapping event names to Zod schemas
-         * @returns An ActionBuilder (with optional `.patch()` to override specific reducers)
-         *
-         * @example
-         * ```typescript
-         * .emits({
-         *   Incremented: z.object({ amount: z.number() }),
-         *   Decremented: z.object({ amount: z.number() }),
-         *   Reset: z.object({})
-         * })
-         * ```
-         */
-        emits: <TEvents extends Schemas>(events: ZodTypes<TEvents>) => ActionBuilder<TState, TEvents, {}, TName> & {
-            /**
-             * Overrides specific event reducers. Events without a custom patch
-             * default to passthrough: `({ data }) => data` (event data merges
-             * into state).
-             *
-             * @param patch - Partial map of event names to patch handler functions
-             * @returns An ActionBuilder for defining actions
-             *
-             * @example Only override the events that need custom logic
-             * ```typescript
-             * .emits({ TicketOpened, TicketClosed, TicketResolved })
-             * .patch({
-             *   TicketOpened: ({ data }) => {
-             *     const { message, messageId, userId, ...other } = data;
-             *     return { ...other, userId, messages: { [messageId]: { ... } } };
-             *   },
-             * })
-             * // TicketClosed and TicketResolved use passthrough
-             * ```
-             */
-            patch: (patch: Partial<PatchHandlers<TState, TEvents>>) => ActionBuilder<TState, TEvents, {}, TName>;
-        };
-    };
-};
-/** Helper: a single-key record mapping a state name to its Zod schema. */
-type StateEntry<TKey extends string = string, TState extends Schema = Schema> = {
-    [P in TKey]: ZodType<TState>;
-};
-/** Helper: a single-key record mapping an action name to its Zod schema. */
-type ActionEntry<TKey extends string = string, TNewActions extends Schema = Schema> = {
-    [P in TKey]: ZodType<TNewActions>;
-};
-/**
- * Builder interface for defining actions (commands) on a state.
- *
- * Actions represent user/system intents to modify state. Each action is validated
- * against a schema, can have business rule invariants, and must emit one or more events.
- *
- * @template TState - State schema type
- * @template TEvents - Event schemas type
- * @template TActions - Action schemas type
- * @template TName - State name literal type
- * @template TSnap - `true` once `.snap(...)` has been called. Gates the
- *   `.autocloses({ keep })` rolling-window option — a windowed close is
- *   meaningless without snapshots, so `keep` only typechecks after
- *   `.snap` in the chain.
- *
- * @see {@link state} for complete usage examples
- */
-export type ActionBuilder<TState extends Schema, TEvents extends Schemas, TActions extends Schemas, TName extends string = string, TSnap extends boolean = false> = {
-    /**
-     * Defines an action (command) that can be executed on this state.
-     *
-     * Actions represent intents to change state - they should be named in imperative form
-     * (e.g., "CreateUser", "IncrementCounter", "PlaceOrder"). Actions are validated against
-     * their schema and must emit at least one event.
-     *
-     * Pass a `{ ActionName: schema }` record — use shorthand `{ ActionName }`
-     * when the variable name matches the action name. The key becomes the
-     * action name, the value the Zod schema.
-     *
-     * Pass an optional second argument to declare a per-action retry
-     * policy — the orchestrator retries this action on
-     * {@link ConcurrencyError} up to `maxRetries` extra times, applying
-     * `backoff` between attempts when set. Omit the argument to keep the
-     * current single-attempt behavior (`ConcurrencyError` surfaces on
-     * first conflict).
-     *
-     * @template TKey - Action name (string literal type)
-     * @template TNewActions - Action payload schema type
-     * @param entry - Single-key record `{ ActionName: schema }`
-     * @param options - Optional per-action retry policy
-     *   ({@link ActionOptions}).
-     * @returns An object with `.given()` and `.emit()` for further configuration
-     *
-     * @example Simple action without invariants
-     * ```typescript
-     * .on({ increment: z.object({ by: z.number() }) })
-     *   .emit((action) => ["Incremented", { amount: action.by }])
-     * ```
-     */
-    on: <TKey extends string, TNewActions extends Schema>(entry: ActionEntry<TKey, TNewActions>, options?: ActionOptions) => {
-        /**
-         * Adds business rule invariants that must hold before the action can execute.
-         *
-         * Invariants are checked after loading the current state but before emitting
-         * events. Each invariant pairs a `description` with a `valid(state, actor?)`
-         * predicate — when a predicate returns `false`, the action throws
-         * `InvariantError` carrying the description. All invariants must pass for
-         * the action to succeed.
-         *
-         * @param rules - Array of {@link Invariant} objects (`{ description, valid }`)
-         * @returns An object with `.emit()` to finalize the action
-         *
-         * @example
-         * ```typescript
-         * .given([
-         *   { description: "Must be active", valid: (state) => state.status === "active" },
-         *   { description: "Must be the owner", valid: (state, actor) => state.ownerId === actor?.id }
-         * ])
-         * ```
-         */
-        given: (rules: Invariant<TState>[]) => {
-            /**
-             * Defines the action handler that emits events.
-             *
-             * The handler receives the action payload and current state snapshot,
-             * and must return one or more events to emit. Events are applied to state
-             * via the patch handlers defined earlier.
-             *
-             * Pass a string event name for passthrough: the action payload becomes
-             * the event data directly.
-             *
-             * @param handler - Function that returns events to emit, or event name string for passthrough
-             * @returns The ActionBuilder for chaining more actions
-             *
-             * @example Custom handler
-             * ```typescript
-             * .emit((action, snapshot) => {
-             *   const newBalance = snapshot.state.balance + action.amount;
-             *   return ["Deposited", { amount: action.amount, newBalance }];
-             * })
-             * ```
-             */
-            emit: {
-                /** Custom handler — receives `(action, snapshot)` and returns one
-                 *  or more `[EventName, data]` tuples (or `undefined`). */
-                (handler: ActionHandler<TState, TEvents, {
-                    [P in TKey]: TNewActions;
-                }, TKey>): ActionBuilder<TState, TEvents, TActions & {
-                    [P in TKey]: TNewActions;
-                }, TName, TSnap>;
-                /** Passthrough — the action payload becomes the event data
-                 *  directly. Must reference an event declared in `.emits()`. */
-                (event_name: keyof TEvents & string): ActionBuilder<TState, TEvents, TActions & {
-                    [P in TKey]: TNewActions;
-                }, TName, TSnap>;
-            };
-        };
-        /**
-         * Defines the action handler that emits events. Same two overloads as
-         * the post-`.given()` form above:
-         *
-         * - **Function** — receives `(action, snapshot)` and returns one or
-         *   more `[EventName, data]` tuples (or `undefined`).
-         * - **String** — passthrough: the action payload becomes the event
-         *   data directly. Must reference an event declared in `.emits()`.
-         *
-         * The two overloads are kept separate (rather than merged into a
-         * `handler | string` union) so that TS contextual typing of the
-         * function alternative isn't degraded by considering the string
-         * branch — under the union form `TState` could collapse to its
-         * `Schema` constraint inside the callback.
-         *
-         * @example Passthrough (action payload = event data)
-         * ```typescript
-         * .emit("Incremented")
-         * ```
-         */
-        emit: {
-            (handler: ActionHandler<TState, TEvents, {
-                [P in TKey]: TNewActions;
-            }, TKey>): ActionBuilder<TState, TEvents, TActions & {
-                [P in TKey]: TNewActions;
-            }, TName, TSnap>;
-            (event_name: keyof TEvents & string): ActionBuilder<TState, TEvents, TActions & {
-                [P in TKey]: TNewActions;
-            }, TName, TSnap>;
-        };
-    };
-    /**
-     * Defines a snapshotting strategy to optimize state reconstruction.
-     *
-     * Snapshots store the current state at a point in time, allowing faster state loading
-     * by avoiding replaying all events from the beginning. The snap function is called
-     * after each event is applied and should return `true` when a snapshot should be taken.
-     *
-     * @param snap - Predicate function that returns true when a snapshot should be taken
-     * @returns The ActionBuilder for chaining
-     *
-     * @example Snapshot every 10 events
-     * ```typescript
-     * .snap((snapshot) => snapshot.patches >= 10)
-     * ```
-     */
-    snap: (snap: (snapshot: Snapshot<TState, TEvents>) => boolean) => ActionBuilder<TState, TEvents, TActions, TName, true>;
-    /**
-     * Declares the disclosure predicate for `sensitive(...)`-marked event
-     * fields. Gates external reads: returning `true` allows the actor to see
-     * plaintext on the event; returning `false` substitutes `"[REDACTED]"`.
-     * When absent, the framework default-denies on every external read —
-     * fail-safe.
-     *
-     * One predicate per state. A second `.discloses(...)` call replaces the
-     * first (same shape as snapshots being state-level, not per-event).
-     *
-     * The predicate receives the full event including merged PII so it can
-     * branch on the payload itself (e.g.
-     * `event.data.ownerId === actor.id`). Reducers, projections, and
-     * reactions are unaffected — they follow separate visibility rules.
-     *
-     * @param disclose - Predicate `(event, actor) => boolean`. `true` =
-     *   plaintext, `false` = `"[REDACTED]"` substitution.
-     * @returns The ActionBuilder for chaining.
-     *
-     * @example Owner-or-admin disclosure
-     * ```typescript
-     * state({ User: userSchema })
-     *   .init(() => ({ ... }))
-     *   .emits({ UserRegistered: z.object({ email: sensitive(z.string()) }) })
-     *   .discloses((event, actor) =>
-     *     actor.id === event.stream || actor.roles?.includes("admin"))
-     * ```
-     */
-    discloses: (disclose: (event: Committed<TEvents, keyof TEvents & string>, actor: Actor) => boolean) => ActionBuilder<TState, TEvents, TActions, TName, TSnap>;
-    /**
-     * Declares the online close predicate for this state. The
-     * orchestrator's autoclose cycle iterates the state's streams once
-     * per tick and calls the predicate per candidate; truthy results are
-     * scheduled for atomic truncate-and-seed via `Store.truncate` on the
-     * next batch.
-     *
-     * One predicate per state. A second `.autocloses(...)` call replaces
-     * the first (same shape as `.snap` / `.discloses` — state-level, not
-     * per-event). Absent → the state opts out of online close entirely;
-     * the cycle skips it and pays zero per-tick cost for it.
-     *
-     * Pass a declarative {@link AutoclosePolicy} object literal covering the
-     * three operational pressure points (`after`, `is`, `reaches`). Top-level
-     * fields combine with AND; an optional `or: {...}` block opens an
-     * alternative OR path. Validated via Zod at build time; misconfiguration
-     * throws before `act().build()` completes.
-     *
-     * Under the hood this compiles to a synthesized reaction that runs
-     * on a per-aggregate synthetic stream: it defers to `head.created + the
-     * policy's min after` while the cooldown holds and closes the stream once
-     * the policy matches. There is no background sweep.
-     *
-     * **The function-predicate form was removed.** `.autocloses` no
-     * longer accepts `(stream, head, count) => boolean`; an opaque predicate has
-     * no derivable due-time or terminal event to react to. For conditions the
-     * declarative form can't express, call `app.close(...)` from your own logic.
-     *
-     * @param policy The declarative {@link AutoclosePolicy} bag.
-     * @returns The ActionBuilder for chaining.
-     *
-     * @example Declarative — cooldown after terminal (a Ticket closes
-     *   90 days after resolution).
-     * ```typescript
-     * .autocloses({ is: "TicketResolved", after: { days: 90 } })
-     * ```
-     */
-    autocloses: (policy: [TSnap] extends [true] ? AutoclosePolicy : Omit<AutoclosePolicy, "keep"> & {
-        /** Rolling-window retention requires `.snap(...)` earlier in
-         *  the builder chain — a windowed close prunes behind a real
-         *  snapshot, so a state that never snapshots has nothing to
-         *  prune behind. */
-        keep?: never;
-    }) => ActionBuilder<TState, TEvents, TActions, TName, TSnap>;
-    /**
-     * Declares the archiver the online close cycle runs **before**
-     * truncating a stream this state's `.autocloses(...)` predicate
-     * accepted. Hosts use it to write events to durable storage (S3,
-     * an analytics warehouse, cold tier) before the tombstone lands,
-     * so the truncate doesn't lose history that the operator still
-     * needs.
-     *
-     * Threads into `CloseTarget.archive` via the same plumbing
-     * `app.close({ stream, archive })` already uses — the cycle holds
-     * the stream's guard while the archiver runs, and a thrown
-     * archiver leaves the stream guarded but un-truncated. No partial
-     * truncate state, no data loss. It is not retried automatically;
-     * `app.close([{ stream, archive }])` resumes the guarded stream.
-     *
-     * One archiver per state. A second `.archives(...)` call replaces
-     * the first (same shape as `.snap` / `.discloses` /
-     * `.autocloses`). Absent → the cycle truncates without an archive
-     * step.
-     *
-     * @param archive `(stream, head) => Promise<void>`. Runs while
-     *   the stream is locked against new writes; the truncate runs
-     *   immediately after a successful resolve.
-     * @returns The ActionBuilder for chaining.
-     *
-     * @example Archive to S3 before truncate.
-     * ```typescript
-     * state({ Ticket: ticketSchema })
-     *   .emits({ TicketOpened, TicketResolved })
-     *   // ...
-     *   .autocloses({ is: "TicketResolved" })
-     *   .archives(async (stream) => {
-     *     const events = await loadEvents(stream);
-     *     await s3.upload(`tickets/${stream}.jsonl`, events);
-     *   })
-     * ```
-     */
-    archives: (archive: AutocloseArchiver<TEvents>) => ActionBuilder<TState, TEvents, TActions, TName, TSnap>;
-    /**
-     * Finalizes and builds the state definition.
-     *
-     * Call this method after defining all actions, invariants, and patches to create
-     * the complete State object that can be registered with Act.
-     *
-     * @returns The complete strongly-typed State definition
-     *
-     * @example
-     * ```typescript
-     * const Counter = state({ Counter: schema })
-     *   .init(() => ({ count: 0 }))
-     *   .emits({ Incremented: z.object({ amount: z.number() }) })
-     *   .patch({ Incremented: ({ data }, state) => ({ count: state.count + data.amount }) })
-     *   .on({ increment: z.object({ by: z.number() }) })
-     *     .emit((action) => ["Incremented", { amount: action.by }])
-     *   .build(); // Returns State<TState, TEvents, TActions, TName>
-     * ```
-     */
-    build: () => State<TState, TEvents, TActions, TName>;
-};
+import type { StateBuilder, StateEntry } from "../types/builders.js";
+import type { Schema } from "../types/index.js";
 /**
  * Creates a new state definition with event sourcing capabilities.
  *
@@ -417,5 +44,4 @@ export type ActionBuilder<TState extends Schema, TEvents extends Schemas, TActio
  * @see {@link https://rotorsoft.github.io/act-root/docs/examples/calculator | Calculator Example}
  */
 export declare function state<TName extends string, TState extends Schema>(entry: StateEntry<TName, TState>): StateBuilder<TState, TName>;
-export {};
 //# sourceMappingURL=state-builder.d.ts.map

package/dist/@types/builders/state-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/state-builder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"state-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/state-builder.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAGV,YAAY,EACZ,UAAU,EACX,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAYV,MAAM,EAKP,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,KAAK,CAAC,KAAK,SAAS,MAAM,EAAE,MAAM,SAAS,MAAM,EAC/D,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,GAC/B,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,CAmD7B"}

package/dist/@types/config.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { type ActOptions, type AutocloseConfig, type Config } from "./types/index.js";
 /**
  * Zod schema for validating package.json metadata.
  * @internal
@@ -14,48 +15,6 @@ export declare const PackageSchema: z.ZodObject<{
     license: z.ZodOptional<z.ZodString>;
     dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
-/**
- * Type representing the validated package.json metadata.
- *
- * @internal
- */
-export type Package = z.infer<typeof PackageSchema>;
-/**
- * Zod schema for the full Act Framework configuration object.
- * Includes package metadata, environment, logging, and timing options.
- * @internal
- */
-declare const BaseSchema: z.ZodObject<{
-    name: z.ZodString;
-    version: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    author: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodObject<{
-        name: z.ZodString;
-        email: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>, z.ZodString]>>;
-    license: z.ZodOptional<z.ZodString>;
-    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    env: z.ZodEnum<{
-        development: "development";
-        production: "production";
-        staging: "staging";
-        test: "test";
-    }>;
-    logLevel: z.ZodEnum<{
-        debug: "debug";
-        error: "error";
-        fatal: "fatal";
-        info: "info";
-        trace: "trace";
-        warn: "warn";
-    }>;
-    logSingleLine: z.ZodBoolean;
-    sleepMs: z.ZodNumber;
-}, z.core.$strip>;
-/**
- * Type representing the validated Act Framework configuration object.
- */
-export type Config = z.infer<typeof BaseSchema>;
 /**
  * Gets the current Act Framework configuration.
  *
@@ -88,5 +47,9 @@ export type Config = z.infer<typeof BaseSchema>;
  * @see {@link Config} for configuration type
  */
 export declare const config: () => Config;
-export {};
+/**
+ * Validates and defaults the autoclose knobs of `ActOptions`, the way
+ * `act().build()` does. Throws `ZodError` on an out-of-range value.
+ */
+export declare function resolveAutocloseConfig(options: ActOptions | undefined): AutocloseConfig;
 //# sourceMappingURL=config.d.ts.map

package/dist/@types/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;iBAWxB,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAsDpD;;;;GAIG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKd,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAsBhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,MAAM,QAAO,MAwBzB,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EACL,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,MAAM,EAMZ,MAAM,kBAAkB,CAAC;AAG1B;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;iBAWK,CAAC;AAsFhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,MAAM,QAAO,MAwBzB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,UAAU,GAAG,SAAS,GAC9B,eAAe,CAEjB"}

package/dist/@types/csv.d.ts

@@ -15,21 +15,7 @@
  * implemented — `CsvFile` is a transfer-only primitive, not a
  * store you'd run an Act app against.
  */
-import type { Committed, EventSink, EventSource, Query, Schemas } from "./types/action.js";
-/**
- * Construct a {@link CsvFile} from either a filesystem path (for
- * reading and/or writing through the OS) or an in-memory blob (a
- * pre-loaded CSV string, used by the inspector when a CSV arrives
- * over the wire via tRPC).
- *
- * Both modes share the same on-disk format, so the same blob shape
- * can be round-tripped through the transfer pipeline.
- */
-export type CsvFileOptions = {
-    path: string;
-} | {
-    blob: string;
-};
+import type { Committed, CsvFileOptions, EventSink, EventSource, Query, Schemas } from "./types/action.js";
 export declare class CsvFile implements EventSource, EventSink {
     private readonly path;
     private readonly blob;

package/dist/@types/csv.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"csv.d.ts","sourceRoot":"","sources":["../../src/csv.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,EACV,SAAS,EACT,SAAS,EACT,WAAW,EACX,KAAK,EACL,OAAO,EACR,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAgBjE,qBAAa,OAAQ,YAAW,WAAW,EAAE,SAAS;IACpD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IAErC,YAAY,OAAO,EAAE,cAAc,EAQlC;IAEK,KAAK,CAAC,CAAC,SAAS,OAAO,EAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,KAAK,IAAI,EAChD,OAAO,CAAC,EAAE,KAAK,GACd,OAAO,CAAC,MAAM,CAAC,CAsCjB;IAEK,OAAO,CACX,MAAM,EAAE,CACN,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,KACpE,OAAO,CAAC,IAAI,CAAC,GACjB,OAAO,CAAC,IAAI,CAAC,CA6Bf;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAK7B;CACF"}
+{"version":3,"file":"csv.d.ts","sourceRoot":"","sources":["../../src/csv.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,SAAS,EACT,WAAW,EACX,KAAK,EACL,OAAO,EACR,MAAM,mBAAmB,CAAC;AAgB3B,qBAAa,OAAQ,YAAW,WAAW,EAAE,SAAS;IACpD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IAErC,YAAY,OAAO,EAAE,cAAc,EAQlC;IAEK,KAAK,CAAC,CAAC,SAAS,OAAO,EAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,KAAK,IAAI,EAChD,OAAO,CAAC,EAAE,KAAK,GACd,OAAO,CAAC,MAAM,CAAC,CAsCjB;IAEK,OAAO,CACX,MAAM,EAAE,CACN,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,KACpE,OAAO,CAAC,IAAI,CAAC,GACjB,OAAO,CAAC,IAAI,CAAC,CA6Bf;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAK7B;CACF"}

package/dist/@types/index.d.ts

@@ -9,7 +9,6 @@ export * from "./adapters/index.js";
 export * from "./builders/index.js";
 export * from "./config.js";
 export * from "./csv.js";
-export { DeferSignal } from "./internal/index.js";
 export * from "./ports.js";
 export * from "./types/index.js";
 export * from "./utils.js";

package/dist/@types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,CAAC;AAEtB;;;;GAIG;AACH,cAAc,UAAU,CAAC;AACzB,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AAIzB,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,CAAC;AAEtB;;;;GAIG;AACH,cAAc,UAAU,CAAC;AACzB,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/@types/internal/autoclose-policy.d.ts

@@ -6,68 +6,11 @@
  * then, not on the first cycle. Semantics and examples:
  * docs/docs/guides/close-policies.md.
  */
-import { z } from "zod";
-import type { AutoclosePredicate, Schemas } from "../types/action.js";
+import type { AutoclosePolicy, AutoclosePredicate, Schemas } from "../types/action.js";
 /** The `Date` that lies `days` after `date`. */
 export declare function days_after(date: Date, days: number): Date;
 /** The `Date` that lies `days` in the past. */
 export declare function days_before_now(days: number): Date;
-/**
- * Zod schema for the declarative {@link AutoclosePolicy} bag.
- * Internal `const` per the config-validation-schema standard (CLAUDE.md
- * "Config-validation schemas") — the public surface is the inferred
- * {@link AutoclosePolicy} type and the `.autocloses({...})` overload,
- * never this schema. `.strict()` rejects unknown keys so typos surface
- * at build instead of being silently ignored.
- */
-declare const AutoclosePolicySchema: z.ZodObject<{
-    after: z.ZodOptional<z.ZodObject<{
-        days: z.ZodNumber;
-    }, z.core.$strip>>;
-    is: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString>>]>>;
-    reaches: z.ZodOptional<z.ZodNumber>;
-    or: z.ZodOptional<z.ZodObject<{
-        after: z.ZodOptional<z.ZodObject<{
-            days: z.ZodNumber;
-        }, z.core.$strip>>;
-        is: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString>>]>>;
-        reaches: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>;
-    keep: z.ZodOptional<z.ZodObject<{
-        days: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strict>;
-/**
- * Declarative close-policy options consumed by `.autocloses({...})`.
- * Top-level fields are AND-combined; the optional `or` block opens an
- * alternative OR-path. Omitted fields contribute nothing — they do
- * not mean "match everything."
- *
- * @property after - Close when `head.created` is at least the resolved
- *   window in the past. Days are the close surface's only unit;
- *   fractional `days` cover sub-day cooldowns (`{ days: 1/24 }` is one
- *   hour) without introducing another denomination.
- * @property is - Close when `head.name` matches. String for the
- *   single-terminal-event case (the most common); `readonly string[]`
- *   for multi-terminal states (`Order: Shipped | Delivered |
- *   Cancelled`).
- * @property reaches - Close when the stream's event count is `>= N`
- *   (inclusive — fires the moment the threshold is reached).
- * @property or - Alternative OR-path. When present, the policy fires
- *   if EITHER the top-level AND group matches OR any field inside
- *   `or` matches. Used for safety-net backstops layered onto a
- *   primary cooldown policy (e.g. *"(Resolved AND 90 days) OR reaches
- *   10k"*). Nested `or` inside `or` rejects at build time.
- * @property keep - Rolling-window retention, **independent** of
- *   the terminate fields: while the stream stays open, prune events
- *   older than `now − keep` behind the closest safe snapshot via a
- *   windowed close. Does not participate in the AND group or the `or`
- *   block — a policy may terminate, prune, or both. Requires
- *   `.snap(...)` earlier in the builder chain (type-gated) and a
- *   window of at least one day — the close cycle is low-cadence
- *   housekeeping, never sub-day realtime.
- */
-export type AutoclosePolicy = z.infer<typeof AutoclosePolicySchema>;
 /**
  * Compile a declarative {@link AutoclosePolicy} into an
  * {@link AutoclosePredicate}. The state-builder's
@@ -118,5 +61,4 @@ export declare function policy_min_after_days(options: AutoclosePolicy): number
  */
 export declare function policy_keep_days(options: AutoclosePolicy): number | undefined;
 export declare function compile_autoclose_policy(options: AutoclosePolicy): AutoclosePredicate<Schemas>;
-export {};
 //# sourceMappingURL=autoclose-policy.d.ts.map

package/dist/@types/internal/autoclose-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autoclose-policy.d.ts","sourceRoot":"","sources":["../../../src/internal/autoclose-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AA2BtE,gDAAgD;AAChD,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEzD;AAED,+CAA+C;AAC/C,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAElD;AA+DD;;;;;;;GAOG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;kBAoBxB,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAwBpE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,GACvB,MAAM,GAAG,SAAS,CAMpB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,GAAG,SAAS,CAG7E;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,eAAe,GACvB,kBAAkB,CAAC,OAAO,CAAC,CAiC7B"}
+{"version":3,"file":"autoclose-policy.d.ts","sourceRoot":"","sources":["../../../src/internal/autoclose-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,OAAO,EACR,MAAM,oBAAoB,CAAC;AA2B5B,gDAAgD;AAChD,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEzD;AAED,+CAA+C;AAC/C,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAElD;AAmHD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,GACvB,MAAM,GAAG,SAAS,CAMpB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,GAAG,SAAS,CAG7E;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,eAAe,GACvB,kBAAkB,CAAC,OAAO,CAAC,CAiC7B"}

package/dist/@types/internal/autoclose-reaction.d.ts

@@ -12,8 +12,7 @@
  * registry is complete once the builder finishes; the orchestrator never
  * mutates it.
  */
-import type { Registry, SchemaRegister, Schemas, State } from "../types/index.js";
-import { type AutocloseConfig } from "./config.js";
+import type { AutocloseConfig, Registry, SchemaRegister, Schemas, State } from "../types/index.js";
 /**
  * Inject one synthesized autoclose reaction per `.autocloses(...)` state
  * into the registry's event registers. The handler resolves ports at call

package/dist/@types/internal/autoclose-reaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autoclose-reaction.d.ts","sourceRoot":"","sources":["../../../src/internal/autoclose-reaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAEV,QAAQ,EACR,cAAc,EACd,OAAO,EACP,KAAK,EACN,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EAAE,KAAK,eAAe,EAAuB,MAAM,aAAa,CAAC;AAYxE;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,SAAS,cAAc,CAAC,QAAQ,CAAC,EAC3C,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EAExB,QAAQ,EAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,EACjD,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AACjD;;;;;;GAMG;AACH,WAAW,EAAE,MAAM,eAAe,CAAC,iBAAiB,CAAC,GACpD,IAAI,CAkHN"}
+{"version":3,"file":"autoclose-reaction.d.ts","sourceRoot":"","sources":["../../../src/internal/autoclose-reaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EACV,eAAe,EAEf,QAAQ,EACR,cAAc,EACd,OAAO,EACP,KAAK,EACN,MAAM,mBAAmB,CAAC;AAgB3B;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,SAAS,cAAc,CAAC,QAAQ,CAAC,EAC3C,OAAO,SAAS,OAAO,EACvB,QAAQ,SAAS,OAAO,EAExB,QAAQ,EAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,EACjD,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AACjD;;;;;;GAMG;AACH,WAAW,EAAE,MAAM,eAAe,CAAC,iBAAiB,CAAC,GACpD,IAAI,CAkHN"}

package/dist/@types/internal/autoclose-window.d.ts

@@ -2,7 +2,7 @@
  * Off-hours window math for autoclose — hour-in-zone, DST-gap handling, and
  * "next time the window opens".
  */
-import type { AutocloseConfig } from "./config.js";
+import type { AutocloseConfig } from "../types/index.js";
 /**
  * The current hour `[0, 23]` in the given IANA time zone, DST-correct
  * via `Intl`. Split out so the window check can be unit-tested without

package/dist/@types/internal/autoclose-window.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autoclose-window.d.ts","sourceRoot":"","sources":["../../../src/internal/autoclose-window.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAOhE;AAkCD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,EAC1C,GAAG,EAAE,IAAI,GACR,OAAO,CAOT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,WAAW,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAAC,EACvD,GAAG,EAAE,IAAI,GACR,IAAI,CAoBN"}
+{"version":3,"file":"autoclose-window.d.ts","sourceRoot":"","sources":["../../../src/internal/autoclose-window.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAOhE;AAkCD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,EAC1C,GAAG,EAAE,IAAI,GACR,OAAO,CAOT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,WAAW,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAAC,EACvD,GAAG,EAAE,IAAI,GACR,IAAI,CAoBN"}

package/dist/@types/internal/circuit-breaker.d.ts

@@ -15,9 +15,8 @@
  * Time is passed in (`now`) rather than read from the clock so the state
  * machine is deterministic under test.
  */
+import type { CircuitState } from "../types/index.js";
 import type { CircuitBreakerConfig } from "./config.js";
-/** Circuit breaker state. */
-export type CircuitState = "closed" | "open" | "half-open";
 /**
  * Side-effect hooks the orchestrator wires into the breaker so consumers
  * (drain / settle / autoclose) don't each thread their own callbacks.

package/dist/@types/internal/circuit-breaker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../../src/internal/circuit-breaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD,6BAA6B;AAC7B,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAE3D;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,KAAK,IAAI,CAAC;IACpE;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CAChC,CAAC;AAEF,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,KAAK,CAA4C;IACzD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAE7C,YAAY,MAAM,EAAE,oBAAoB,EAAE,KAAK,GAAE,mBAAwB,EAIxE;IAED;;;;;OAKG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,uEAAuE;IACvE,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,gDAAgD;IAChD,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAG/B;IAED,wEAAwE;IACxE,MAAM,IAAI,IAAI,CAIb;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,YAAY,CAKjD;IAED,oEAAoE;IACpE,IAAI,IAAI,IAAI,CAEX;IAED;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,WAAW;IAOnB,6DAA6D;IAC7D,OAAO,CAAC,QAAQ;CAcjB"}
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../../src/internal/circuit-breaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,KAAK,IAAI,CAAC;IACpE;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CAChC,CAAC;AAEF,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,KAAK,CAA4C;IACzD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAE7C,YAAY,MAAM,EAAE,oBAAoB,EAAE,KAAK,GAAE,mBAAwB,EAIxE;IAED;;;;;OAKG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,uEAAuE;IACvE,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,gDAAgD;IAChD,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAG/B;IAED,wEAAwE;IACxE,MAAM,IAAI,IAAI,CAIb;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,YAAY,CAKjD;IAED,oEAAoE;IACpE,IAAI,IAAI,IAAI,CAEX;IAED;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,WAAW;IAOnB,6DAA6D;IAC7D,OAAO,CAAC,QAAQ;CAcjB"}