@rotorsoft/act 1.32.29 → 1.33.0

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;AA0CpD;;;;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

@@ -1,108 +1,16 @@
 /**
- * @module autoclose-policy
- * @category Internal
- *
- * Declarative close-policy options consumed by `.autocloses({...})`
- * Three optional fields cover the three
- * operational pressure points every real close policy traces back to:
- *
- *   - `after`   — time / compliance ("autocloses **after** N days")
- *   - `is`      — domain lifecycle ("autocloses ... **is** Resolved")
- *   - `reaches` — resource ("autocloses ... **reaches** 10k events")
- *
- * Top-level fields combine with **AND** semantics. This captures the
- * common cooldown-after-terminal pattern that runs through almost
- * every business app — *"close 90 days after `Resolved`"*, *"close 14
- * days after `Delivered`"*, *"close 30 days after a GDPR deletion
- * request"*. All conditions must hold for the cycle to truncate.
- *
- * A separate `or: {...}` block opens an alternative path: when
- * present, the policy fires if **either** the top-level AND group
- * matches **or** any field inside `or` matches. Use it for safety
- * nets — *"close (Resolved AND aged 90 days) OR if event count
- * reaches 10k"*. The two-axis split mirrors the two ways close
- * policies appear in practice: primary close logic (AND-shaped) and
- * defensive backstops (OR-shaped).
- *
- * The state builder's `.autocloses(...)` overload distinguishes
- * function (predicate) from object (policy) and routes the latter
- * through {@link compile_autoclose_policy}, which validates via
- * {@link AutoclosePolicySchema} and returns the compiled predicate.
- * Operators with custom needs (per-stream metadata, multi-branch
- * AND/OR like "(`Resolved` + 90d) OR (`Cancelled` + 30d)") keep the
- * function form; the declarative form covers the 90% case.
- *
- * Validation runs at the builder call (`act().build()` time), so
- * misconfiguration — empty bag, sub-1 `reaches`, sub-minute `after`,
- * empty `is`, empty `or`, nested `or` inside `or`, unknown keys —
- * throws at build, not on the first cycle tick.
- *
- * @internal
+ * Compiles the declarative `.autocloses({...})` policy into a predicate.
+ * Top-level `after` / `is` / `reaches` combine with AND; an `or: {...}`
+ * block adds an alternative path. Validated with
+ * {@link AutoclosePolicySchema} when the app builds, so a bad policy throws
+ * 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";
-/** The `Date` that lies `days` after `date`. @internal */
+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. @internal */
+/** 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.
- *
- * @internal
- */
-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
@@ -128,8 +36,6 @@ export type AutoclosePolicy = z.infer<typeof AutoclosePolicySchema>;
  * Throws `ZodError` at call time when the options are invalid (empty
  * bag, non-positive `reaches`, sub-minute `after`, empty `is`, empty
  * `or`, nested `or`, unknown keys).
- *
- * @internal
  */
 /**
  * The smallest `after` window (in days) anywhere in a policy — across
@@ -143,8 +49,6 @@ export type AutoclosePolicy = z.infer<typeof AutoclosePolicySchema>;
  * just waits for the next event to re-trigger rather than parking on a
  * due-time. Conservative — the min across branches never defers past
  * the soonest a branch could fire.
- *
- * @internal
  */
 export declare function policy_min_after_days(options: AutoclosePolicy): number | undefined;
 /**
@@ -154,10 +58,7 @@ export declare function policy_min_after_days(options: AutoclosePolicy): number
  * window (via a windowed close) and derives its prune due-time as
  * `tail.created` plus this many days — the earliest the oldest
  * surviving domain event can age out of the window.
- *
- * @internal
  */
 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AA2BtE,0DAA0D;AAC1D,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEzD;AAED,yDAAyD;AACzD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAElD;AAmED;;;;;;;;;GASG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;kBAoBxB,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAwBpE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,GACvB,MAAM,GAAG,SAAS,CAMpB;AAED;;;;;;;;;GASG;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

@@ -1,7 +1,4 @@
 /**
- * @module autoclose-reaction
- * @category Internal
- *
  * Synthesis of the online close-the-books reaction. `.autocloses(policy)`
  * is not a sweep: it is a reaction on every event the declaring state owns
  * that evaluates the policy against the LIVE head (so a reopened stream
@@ -14,11 +11,8 @@
  * discovered by `classify_registry` and its target stream subscribed. The
  * registry is complete once the builder finishes; the orchestrator never
  * mutates it.
- *
- * @internal
  */
-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
@@ -26,8 +20,6 @@ import { type AutocloseConfig } from "./config.js";
  * The reactions are synthesized once into the shared registry, so nothing
  * per-Act is captured here — the off-hours window is read from the running
  * Act at resolution time via the injected `read_window`.
- *
- * @internal
  */
 export declare function synthesize_autoclose_reactions<TSchemaReg extends SchemaRegister<TActions>, TEvents extends Schemas, TActions extends Schemas>(registry: Registry<TSchemaReg, TEvents, TActions>, states: ReadonlyMap<string, State<any, any, any>>, 
 /**

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;;;;;;;;;;;;;;;;;;GAkBG;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;;;;;;;;;GASG;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

@@ -1,21 +1,12 @@
 /**
- * @module autoclose-window
- * @category Internal
- *
  * Off-hours window math for autoclose — hour-in-zone, DST-gap handling, and
- * "next time the window opens". The autoclose **config** (defaults, schema,
- * resolver) lives in `./config.js`, the single home for builder-facing config
- * bags; this module is the runtime window logic those knobs drive.
- *
- * @internal
+ * "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
  * spinning a controller.
- *
- * @internal
  */
 export declare function hour_in_zone(now: Date, timeZone: string): number;
 /**
@@ -28,8 +19,6 @@ export declare function hour_in_zone(now: Date, timeZone: string): number;
  * would otherwise be closed for the whole day (the `start` hour never
  * occurs). The gap's replacement instant is admitted so autoclose still
  * runs — see {@link is_dst_gap_open}.
- *
- * @internal
  */
 export declare function in_autoclose_window(window: AutocloseConfig["autocloseWindow"], now: Date): boolean;
 /**
@@ -59,8 +48,6 @@ export declare function in_autoclose_window(window: AutocloseConfig["autocloseWi
  * that boundary instant — deferring ~1 h to the replacement instant
  * rather than a full day. The boundary is returned as-is (no minute
  * offset): the gap opening is a single transition instant, not a range.
- *
- * @internal
  */
 export declare function next_window_open(window: NonNullable<AutocloseConfig["autocloseWindow"]>, now: Date): Date;
 //# sourceMappingURL=autoclose-window.d.ts.map

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;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAOhE;AAsCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,EAC1C,GAAG,EAAE,IAAI,GACR,OAAO,CAOT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;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/backoff.d.ts

@@ -1,11 +1,6 @@
 /**
- * @module backoff
- * @category Internal
- *
  * Per-reaction retry backoff delay computation. Pure function — keeps
- * `DrainController` and `reactions._finalize` testable in isolation.
- *
- * @internal
+ * `DrainController` and `finalize` (in `drain-cycle.ts`) testable in isolation.
  */
 import type { BackoffOptions } from "../types/action.js";
 /**

package/dist/@types/internal/backoff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../../src/internal/backoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAMzD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,cAAc,GAAG,SAAS,GAC/B,MAAM,CAyBR"}
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../../src/internal/backoff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,cAAc,GAAG,SAAS,GAC/B,MAAM,CAyBR"}

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

@@ -1,6 +1,4 @@
 /**
- * @module internal/circuit-breaker
- *
  * Orchestrator-level circuit breaker for store operations. The drain loop
  * polls `claim()` continuously; when the backing store goes down every poll
  * throws a {@link StoreError}, and without a breaker the orchestrator would
@@ -17,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;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD,6BAA6B;AAC7B,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAM3D;;;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"}

package/dist/@types/{builders/build-classify.d.ts → internal/classify.d.ts}

@@ -1,7 +1,4 @@
 /**
- * @module build-classify
- * @category Internal
- *
  * Build-time classification of the registry + state map. The Act constructor
  * needs three pre-computed inputs to wire its runtime subsystems:
  *
@@ -15,24 +12,18 @@
  *
  * Pure function — single pass over events + states, fully testable without
  * instantiating Act.
- *
- * @internal
  */
-import type { StaticTarget } from "../internal/index.js";
 import type { Registry, Schema, SchemaRegister, Schemas, State } from "../types/index.js";
+import type { StaticTarget } from "./correlate-cycle.js";
 /**
  * Classification result. Returned by {@link classify_registry}; consumed
  * piecewise by Act's constructor.
- *
- * @internal
  */
 /**
  * Sentinel for "any reaction on this event has a dynamic resolver, so
  * the lane is opaque until correlate runs the function — arm every
  * controller." A Symbol rather than a string literal so it can't
  * collide with a user-declared lane named `"all"`.
- *
- * @internal
  */
 export declare const ALL_LANES: unique symbol;
 /**
@@ -41,8 +32,6 @@ export declare const ALL_LANES: unique symbol;
  * declared lanes — `do()` arms only those controllers on commit. For
  * events with at least one dynamic resolver, the value is
  * {@link ALL_LANES}; `do()` falls back to arming every controller.
- *
- * @internal
  */
 export type EventLaneSet = ReadonlySet<string> | typeof ALL_LANES;
 export type Classification = {
@@ -55,8 +44,6 @@ export type Classification = {
  * reactive event names, the per-event lane fan-in, and the event-to-state
  * map. Static targets are deduplicated by (target, source) — two reactions
  * routing to the same projection produce one subscription.
- *
- * @internal
  */
 export declare function classify_registry<TSchemaReg extends SchemaRegister<TActions>, TEvents extends Schemas, TActions extends Schemas>(registry: Registry<TSchemaReg, TEvents, TActions>, states: ReadonlyMap<string, State<Schema, any, any>>): Classification;
-//# sourceMappingURL=build-classify.d.ts.map
+//# sourceMappingURL=classify.d.ts.map

package/dist/@types/internal/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../../../src/internal/classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,QAAQ,EACR,MAAM,EACN,cAAc,EACd,OAAO,EACP,KAAK,EACN,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;;GAGG;AACH;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,OAAO,MAAqC,CAAC;AAErE;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,SAAS,CAAC;AAElE,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,cAAc,EAAE,YAAY,EAAE,CAAC;IACxC,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACnE,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CAC5D,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,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,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,GACnD,cAAc,CA4EhB"}

package/dist/@types/internal/close-cycle.d.ts

@@ -1,7 +1,4 @@
 /**
- * @module close-cycle
- * @category Internal
- *
  * Pure orchestration of the close-the-books flow: scan stream heads,
  * partition by reaction safety, guard with tombstones, optionally seed
  * restart state, run user archive callbacks, atomically truncate, and
@@ -10,16 +7,12 @@
  * Also home to the pieces a closer needs around the cycle: the per-stream
  * {@link CloseLock} and the bounded {@link catch_up_correlation}. The Act
  * orchestrator only wires its ports in and emits `"closed"`.
- *
- * @internal
  */
 import type { CloseResult, CloseTarget, Logger, State } from "../types/index.js";
 import type { EsOps } from "./event-sourcing.js";
 /**
  * Dependencies the close cycle needs from the Act orchestrator. Decoupled
  * from `Act` itself so the cycle can be exercised from tests in isolation.
- *
- * @internal
  */
 export type CloseCycleDeps = {
     /** Whether any event has a reaction; without one nothing can be pending. */
@@ -75,8 +68,6 @@ export type CloseCycleDeps = {
  *
  * Stops as soon as a pass makes no progress (the log has no more to give),
  * and after {@link CLOSE_CATCH_UP_PASSES} windows.
- *
- * @internal
  */
 export declare function catch_up_correlation(cursor: {
     readonly checkpoint: number;
@@ -86,8 +77,6 @@ export declare function catch_up_correlation(cursor: {
  * Per-stream serialization for close critical sections: two closers of the
  * same stream never prune or archive concurrently, while different streams
  * proceed in parallel. One instance per Act.
- *
- * @internal
  */
 export declare class CloseLock {
     private readonly _tails;
@@ -102,8 +91,6 @@ export declare class CloseLock {
  * pure prefix delete behind an existing snapshot (see
  * {@link run_windowed_closes}); the rest run the guarded
  * tombstone/restart pipeline below.
- *
- * @internal
  */
 export declare function run_close_cycle(targets: CloseTarget[], deps: CloseCycleDeps): Promise<CloseResult>;
 //# sourceMappingURL=close-cycle.d.ts.map

package/dist/@types/internal/close-cycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"close-cycle.d.ts","sourceRoot":"","sources":["../../../src/internal/close-cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,MAAM,EAEN,KAAK,EACN,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAGjD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACnE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;;;;;;;OASG;IACH,QAAQ,CAAC,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAClE;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC,EAC5B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KACnB,OAAO,CAAC,CAAC,CAAC,CAAC;IAChB;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CAC1D,CAAC;AAYF;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE;IAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAAC,GAAG,IAAI,IAAI,CAAA;CAAE,EACpD,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,EAC9C,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,CAAC,CAajB;AAED;;;;;;GAMG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAE9D,oEAAoE;IACpE,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAYzD;CACF;AAgCD;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,WAAW,EAAE,EACtB,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,WAAW,CAAC,CA+BtB"}
+{"version":3,"file":"close-cycle.d.ts","sourceRoot":"","sources":["../../../src/internal/close-cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,MAAM,EAEN,KAAK,EACN,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAGjD;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACnE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;;;;;;;OASG;IACH,QAAQ,CAAC,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAClE;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC,EAC5B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KACnB,OAAO,CAAC,CAAC,CAAC,CAAC;IAChB;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CAC1D,CAAC;AAUF;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE;IAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAAC,GAAG,IAAI,IAAI,CAAA;CAAE,EACpD,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,EAC9C,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,CAAC,CAajB;AAED;;;;GAIG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAE9D,oEAAoE;IACpE,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAYzD;CACF;AA8BD;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,WAAW,EAAE,EACtB,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,WAAW,CAAC,CA+BtB"}

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

@@ -1,46 +1,14 @@
 /**
- * @module internal/config
- * @category Internal
- *
- * **The single home for every builder-facing config bag in act-core.** Any
- * options object an operator hands to `act().build()`, a builder method
- * (`.on(...)`, `.do(...)`, `.withLane(...)`), or a runtime cycle
- * (`drain(...)` / `settle(...)`) is validated here with Zod — never with a
- * hand-written `if (x < min) throw` ladder — so misconfiguration surfaces as
- * a `ZodError` at the entry point, not as `NaN` arithmetic on the first cycle
- * tick.
- *
- * Layout: one section per bag, each with its `DEFAULT_*` constants, an
- * internal `<Type>OptionsSchema`, an inferred `<Type>Config`, and a
- * `resolve<Type>Config(options): <Type>Config`. The schema is never
- * re-exported — the public surface is the inferred type + resolver.
- *
- * Index of bags owned here:
- * - **Backoff** — retry pacing (`BackoffOptions`), nested in reaction/action.
- * - **Reaction** — `.do(handler, options)` (`blockOnError` / `maxRetries` / `backoff`).
- * - **Action** — `.on(entry, options)` (`maxRetries` / `backoff`).
- * - **Lane** — `.withLane({...})` (`leaseMillis` / `streamLimit` / `cycleMs`).
- * - **Drain / Settle** — `drain(...)` / `settle(...)` runtime knobs.
- * - **Autoclose** — the `.autocloses` / `ActOptions` autoclose knobs (+ window).
- * - **CircuitBreaker** — the store-op breaker on `ActOptions`.
- * - **Fold** — `projection(...).of(...)` batch-fold knobs.
- *
- * Sibling env/package config (`config()`, `NODE_ENV`, log level) lives in the
- * public `../config.ts` — a different concern (process environment, not
- * builder input). The `@rotorsoft/act-http` transport bags (`SseOptions`,
- * `OpenAPIOptions`) live in that package; core cannot own another package's
- * surface.
- *
- * Validation philosophy: reject only what is genuinely broken — `NaN`,
- * `±Infinity` (Zod 4's `z.number()` rejects both by default), and negatives
- * where nonsensical. A value that works today is never newly rejected. The
- * real strictness lands on `maxRetries` and `backoff`, the knobs whose bad
- * values silently corrupt the poison-quarantine and retry-loop-exit gates.
- *
- * @internal
+ * The single home for every builder-facing config bag in act-core: one
+ * section per bag, each with its `DEFAULT_*` constants, an internal
+ * `<Type>OptionsSchema`, the inferred `<Type>Config` and a
+ * `resolve<Type>Config`, so misconfiguration throws a `ZodError` at the
+ * entry point. Validation rejects only what is broken (`NaN`, `±Infinity`,
+ * nonsensical negatives) and never newly rejects a value that works. The
+ * rules are in CLAUDE.md § Config-validation schemas.
  */
 import { z } from "zod";
-import type { ActOptions } from "../act.js";
+import type { ActOptions, AutocloseConfig, CircuitBreakerOptions } from "../types/act.js";
 import type { ActionOptions, BackoffOptions, DrainOptions, FoldOptions, LaneConfig, ReactionOptions, SettleOptions, ShutdownOptions } from "../types/index.js";
 /**
  * Retry pacing for a reaction that declares no backoff, and for projections
@@ -97,18 +65,6 @@ export declare const DEFAULT_STREAM_LIMIT = 10;
 export declare const DEFAULT_EVENT_LIMIT = 10;
 /** How long a drain holds a stream's lease (ms). */
 export declare const DEFAULT_LEASE_MILLIS = 10000;
-/**
- * Default debounce window (ms) for `settle()` when neither the per-call
- * `SettleOptions.debounceMs` nor `ActOptions.settleDebounceMs` is set.
- * Coalesces commits in the same tick and small bursts.
- */
-export declare const DEFAULT_SETTLE_DEBOUNCE_MS = 10;
-/**
- * Default LRU cap for the subscribed-streams cache. Apps that mint many
- * dynamic targets (one per aggregate) should override it with
- * `ActOptions.maxSubscribedStreams`.
- */
-export declare const DEFAULT_MAX_SUBSCRIBED_STREAMS = 1000;
 /** Validate drain options, or pass `undefined` through. Throws `ZodError`. */
 export declare function resolveDrainConfig(options: DrainOptions | undefined): DrainOptions | undefined;
 /** Validate settle options, or pass `undefined` through. Throws `ZodError`. */
@@ -126,38 +82,10 @@ export declare const MAX_SHUTDOWN_GRACE_MS = 30000;
 export declare function resolveShutdownConfig(options: ShutdownOptions | undefined): ShutdownOptions | undefined;
 /** Validate the scalar `ActOptions` knobs at build. Throws `ZodError`. */
 export declare function resolveActConfig(options: ActOptions | undefined): ActOptions | undefined;
-/**
- * @deprecated The cadence knob is derived from `autocloseWindow` now;
- * nothing consumes it. Kept for compat; removed in the next major.
- */
-export declare const DEFAULT_AUTOCLOSE_CYCLE_MINUTES = 720;
-/** @deprecated Unused since the autoclose sweep was removed. */
-export declare const DEFAULT_CLOSE_BATCH_SIZE = 64;
-/** @deprecated Unused since the autoclose sweep was removed. */
-export declare const DEFAULT_CLOSE_YIELD_MS = 0;
-declare const AutocloseOptionsSchema: z.ZodObject<{
-    autocloseCycleMinutes: z.ZodDefault<z.ZodNumber>;
-    closeBatchSize: z.ZodDefault<z.ZodNumber>;
-    closeYieldMs: z.ZodDefault<z.ZodNumber>;
-    closeOnError: z.ZodDefault<z.ZodBoolean>;
-    autocloseWindow: z.ZodOptional<z.ZodObject<{
-        start: z.ZodNumber;
-        end: z.ZodNumber;
-        timeZone: z.ZodDefault<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-/** Resolved autoclose configuration after validation + default expansion. */
-export type AutocloseConfig = z.infer<typeof AutocloseOptionsSchema>;
 /** Validate + default the autoclose knobs on `ActOptions`. Throws `ZodError`. */
 export declare function resolveAutocloseConfig(options: ActOptions | undefined): AutocloseConfig;
-declare const CircuitBreakerOptionsSchema: z.ZodObject<{
-    failureThreshold: z.ZodDefault<z.ZodNumber>;
-    cooldownMs: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
-/** Public, all-optional circuit-breaker options bag for `act().build()`. */
-export type CircuitBreakerOptions = z.input<typeof CircuitBreakerOptionsSchema>;
 /** Resolved circuit-breaker configuration. */
-export type CircuitBreakerConfig = z.infer<typeof CircuitBreakerOptionsSchema>;
+export type CircuitBreakerConfig = Required<CircuitBreakerOptions>;
 /** Parse + apply defaults. Throws `ZodError` on out-of-range values. */
 export declare const resolveCircuitBreakerConfig: (options?: CircuitBreakerOptions) => CircuitBreakerConfig;
 declare const FoldOptionsSchema: z.ZodObject<{