@demlik/tea 0.15.0 → 0.16.0

package/README.md

@@ -8,21 +8,26 @@ A TEA / Elm-Architecture TypeScript library for durable, replayable state machin
 pnpm add @demlik/tea
 ```
 
-`better-result` is a runtime dependency and is installed for you. The host and
+The one runtime dependency is `@standard-schema/spec`, a types-only package
+installed for you. `Cmd.define` takes any Standard Schema, so bring the schema
+library you already use (zod, or Effect Schema through
+`Schema.toStandardSchemaV1`). The host and
 testing adapters ride on optional peers you add only for the surface you use:
 `react` / `react-dom` (the `./react` hooks), `ws` (Node WebSocket subs),
-`fast-check` (the `./pbt` property-testing helpers), and `vitest` (the testing
-utilities).
+`fast-check` (the `./pbt` property-testing helpers), `vitest` (the testing
+utilities), and `effect` (the `./effect` engine).
 
 ## Quickstart
 
-A machine is plain data: an `init`, an `update` map keyed by `Msg` type, and —
-when it has effects — an `interpret` map. `run` drives it; `dispatch` folds a
-`Msg`; `getState` reads the current Model. You name the Model and the `Msg` union
+A machine is plain data: an `init` and an `update` map keyed by `Msg` type.
+`run` drives it, and when it has effects you hand `run` the `interpret` map
+that performs them; `dispatch` folds a `Msg`; `getState` reads the current
+Model. You name the Model and the `Msg` union
 once, under `types`; everything else is inferred from the machine itself.
 
 ```ts
-import { defineMachine, run } from "@demlik/tea";
+import { defineMachine } from "@demlik/tea";
+import { run } from "@demlik/tea/promise";
 
 type State = { readonly count: number };
 type Msg = { readonly type: "increment" } | { readonly type: "reset" };
@@ -41,6 +46,24 @@ await runtime.dispatch({ type: "increment" });
 runtime.getState(); // { count: 1 }
 ```
 
+## Two engines, one machine
+
+The core is `@demlik/tea`, and each engine has its own entry point. A machine
+file imports only the core, so it runs unchanged on either engine.
+
+- `@demlik/tea` — the core: `defineMachine`, `Cmd`, `replay` and the types. It
+  imports no engine.
+- `@demlik/tea/promise` — the Promise engine. Handlers return Promises.
+- `@demlik/tea/effect` — the Effect engine (`experimental`, Effect v4). Handlers
+  return Effects, services come from your Layers, and closing the scope
+  interrupts whatever is in flight.
+
+[Run a machine on the Promise engine](https://github.com/kamp-us/demlik/blob/main/docs/how-to/run-on-the-promise-engine.md)
+and [on the Effect engine](https://github.com/kamp-us/demlik/blob/main/docs/how-to/run-on-the-effect-engine.md)
+build on the same machine file. Coming from 0.15?
+[The migration guide](https://github.com/kamp-us/demlik/blob/main/docs/how-to/migrate-from-0-15.md)
+shows every removed or reshaped API, before and after.
+
 ## Documentation
 
 The four Diátaxis quadrants live in [`docs/`](https://github.com/kamp-us/demlik/blob/main/docs/README.md):

package/dist/agent/index.d.ts

@@ -1,20 +1,19 @@
-import { R as RequiredCtx, M as Machine, I as Interpret, C as Cmd } from '../core-DnzqWy6u.js';
-import { T as ToolCall, a as ToolOutcome, C as Conversation, A as AnyToolDef, P as PlainModel, b as AgentTurn, S as StreamingModel, c as AgentState, d as ToolResult, e as ToolFailureOf, f as ToolCmd, g as AgentEvent, h as TurnChunk, i as AgentMachineMsg, W as WiredToolMsg, j as AgentCmd, k as AgentConfigCore, l as CompactionPolicy, m as AgentKnob } from '../machine-DGlPWCWI.js';
-export { n as AgentBootMsg, o as AgentCancelMsg, p as AgentCompactErrMsg, q as AgentCompactOkMsg, r as AgentCompactRunCmd, s as AgentCompactionConfig, t as AgentConfig, u as AgentDetachedHandlers, v as AgentFailure, w as AgentLlmErrMsg, x as AgentLlmOkMsg, y as AgentLlmRunCmd, z as AgentPorts, B as AgentSnapshotConfig, D as AgentStatus, E as AgentTerminalFailure, F as AgentTimerMsg, G as AgentToMachine, H as Awaiting, I as COMPACTION_PURPOSE, J as CompactInterpret, K as CompactionOutputs, L as CompactionPurpose, M as CompactionSummary, N as LlmCall, O as LlmErr, Q as LlmFailMsg, R as LlmOk, U as LlmRunCmd, V as LlmSucceedMsg, X as MessageLoader, Y as ModelFactory, Z as ModelPort, _ as ModelStream, $ as PLAIN_MODEL_MISROUTE_REASON, a0 as ReservedToolName, a1 as Schema, a2 as SnapshotInterpret, a3 as TOOL_RETRY_EXHAUSTED_TAG, a4 as TOOL_TIMEOUT_TAG, a5 as TaggedFailure, a6 as ToolConstructors, a7 as ToolDef, a8 as ToolError, a9 as ToolFail, aa as ToolFailure, ab as ToolHandler, ac as ToolInput, ad as ToolMsg, ae as ToolOk, af as ToolRecord, ag as ToolRejectedCmd, ah as ToolRejection, ai as ToolResilience, aj as ToolResilienceError, ak as ToolRetryExhausted, al as ToolRouter, am as ToolSettlement, an as ToolThrown, ao as ToolTimedOut, ap as WiredToolCmd, aq as agentBootMsg, ar as agentCancelMsg, as as agentEvents, at as agentTurnSchema, au as compactionSummarySchema, av as fanOutInterpret, aw as isAgentTurn, ax as isCompactionSummary, ay as isReservedToolName, az as isStreamingModel, aA as liftAgent, aB as mergeInterpret, aC as plainModel, aD as status, aE as tool, aF as toolErrorReason, aG as toolRouter } from '../machine-DGlPWCWI.js';
-import { a as ScopedCtxArg, S as Store } from '../runtime-types-CMF13BBh.js';
-import { E as EndedRun } from '../index-KXqTRJyb.js';
-export { M as MonitoredRunCmd, R as RunFailure } from '../index-KXqTRJyb.js';
+import { M as Machine, p as Interpret, d as Subscribe, C as Cmd } from '../core-BbgtiXdg.js';
+import { b as DeadlinesSub } from '../index-Xufl55W8.js';
+export { a as DeadlineSub, c as deadlineSub, e as deadlinesSub, s as subscribeDeadline } from '../index-Xufl55W8.js';
+import { T as ToolCall, a as ToolOutcome, C as Conversation, A as AnyToolDef, P as PlainModel, b as AgentTurn, S as StreamingModel, c as AgentState, d as ToolResult, e as ToolFailureOf, f as ToolsCtx, g as AgentEvent, h as TurnChunk, i as AgentMachineMsg, W as WiredToolMsg, j as AgentCmd, k as ToolCmd, l as AgentConfigCore, m as CompactionPolicy, n as AgentKnob } from '../machine-BQzTV8On.js';
+export { o as AgentBootMsg, p as AgentCancelMsg, q as AgentCompactErrMsg, r as AgentCompactOkMsg, s as AgentCompactRunCmd, t as AgentCompactionConfig, u as AgentConfig, v as AgentFailure, w as AgentLlmErrMsg, x as AgentLlmOkMsg, y as AgentLlmRunCmd, z as AgentSnapshotConfig, B as AgentStatus, D as AgentTerminalFailure, E as AgentTimerMsg, F as AgentToMachine, G as Awaiting, H as COMPACTION_PURPOSE, I as CompactInterpret, J as CompactionOutputs, K as CompactionPurpose, L as CompactionSummary, M as Llm, N as LlmCall, O as LlmErr, Q as LlmFailMsg, R as LlmOk, U as LlmRunCmd, V as LlmSucceedMsg, X as MessageLoader, Y as ModelFactory, Z as ModelPort, _ as ModelStream, $ as PLAIN_MODEL_MISROUTE_REASON, a0 as ReservedToolName, a1 as Schema, a2 as SnapshotInterpret, a3 as TOOL_RETRY_EXHAUSTED_TAG, a4 as TOOL_TIMEOUT_TAG, a5 as TaggedFailure, a6 as ToolConstructors, a7 as ToolDef, a8 as ToolError, a9 as ToolFail, aa as ToolFailure, ab as ToolHandler, ac as ToolInput, ad as ToolMsg, ae as ToolOk, af as ToolRecord, ag as ToolRejectedCmd, ah as ToolRejection, ai as ToolResilience, aj as ToolResilienceError, ak as ToolRetryExhausted, al as ToolRouter, am as ToolSettlement, an as ToolThrown, ao as ToolTimedOut, ap as WiredToolCmd, aq as agentBootMsg, ar as agentCancelMsg, as as agentEvents, at as agentTurnSchema, au as compactionSummarySchema, av as fanOutInterpret, aw as isAgentTurn, ax as isCompactionSummary, ay as isReservedToolName, az as isStreamingModel, aA as liftAgent, aB as mergeInterpret, aC as plainModel, aD as status, aE as tool, aF as toolErrorReason, aG as toolRouter } from '../machine-BQzTV8On.js';
+import { C as CtxArg, S as Store } from '../runtime-types-CiVpC0HN.js';
+import { E as EndedRun } from '../index-Bz5Rh9Ga.js';
+export { M as MonitoredRunCmd, R as RunFailure } from '../index-Bz5Rh9Ga.js';
 import { RetryPolicy } from '../retry-backoff/index.js';
-import { a as DeadlineSub } from '../index-HSYgG2Yt.js';
-export { b as deadlineSub, s as subscribeDeadline } from '../index-HSYgG2Yt.js';
-import 'zod';
-import '../index-CA_7I5g9.js';
-import '../protocol-D8VbH-VH.js';
-import '../index-CuNO9m8i.js';
-import '../index-CSyMYDAB.js';
-import 'better-result';
-import '../index-ZCMhnVKN.js';
-import '../types-BseNPIhr.js';
+import '@standard-schema/spec';
+import '../types-LxZxGYda.js';
+import '../index-Cou86-GX.js';
+import '../protocol-ClRZBhHQ.js';
+import '../index-CkFYA9Y6.js';
+import '../index-7vV8xmsD.js';
+import '../index-CjFDUBeq.js';
 
 /**
  * @demlik/tea/agent — `defineAgent`, the convenience layer over `createAgent`.
@@ -88,8 +87,8 @@ type DefinedAgentState<T extends AnyToolDef> = AgentState<string, LidPurpose, Li
 type DefinedAgentResolvedState<T extends AnyToolDef> = Omit<DefinedAgentState<T>, "run"> & {
     readonly run: EndedRun<string>;
 };
-/** The ctx the tools' `needs` demand, intersected — what `run` asks for. */
-type DefinedAgentCtx<T extends AnyToolDef> = RequiredCtx<ToolCmd<T>>;
+/** The ctx the tools' handlers read, intersected — what `run` asks for. */
+type DefinedAgentCtx<T extends AnyToolDef> = ToolsCtx<T>;
 /** The Msg union a defined agent's machine folds. */
 type DefinedAgentMsg<T extends AnyToolDef> = AgentMachineMsg<LidPurpose, LidOutputs, ToolResult<T>> | WiredToolMsg<T>;
 /**
@@ -112,8 +111,19 @@ type DefinedAgentCmd<T extends AnyToolDef> = AgentCmd<LidPurpose, ToolCmd<T>, fa
  * router's `tool_rejected`, and the agent-owned brain call.
  */
 type DefinedAgentInterpret<T extends AnyToolDef> = Interpret<DefinedAgentMsg<T>, DefinedAgentCmd<T>, DefinedAgentCtx<T>>;
-/** The wired machine `defineAgent` builds per `input` — feed it to the raw `run`. */
-type DefinedAgentMachine<T extends AnyToolDef> = Machine<DefinedAgentState<T>, DefinedAgentMsg<T>, DefinedAgentCmd<T>, DeadlineSub, DefinedAgentCtx<T>>;
+/** The wired machine `defineAgent` builds per `input`. */
+type DefinedAgentMachine<T extends AnyToolDef> = Machine<DefinedAgentState<T>, DefinedAgentMsg<T>, DefinedAgentCmd<T>, DeadlinesSub, DefinedAgentCtx<T>>;
+/**
+ * The machine `defineAgent` builds per `input` beside the handlers it runs
+ * under — the interpret table and the `deadline` runner (a machine carries
+ * none — #278, #279). It is a `Wired`; feed it to the raw `run`:
+ * `run(wired.machine, { ...wired, ctx })`.
+ */
+type DefinedAgentWired<T extends AnyToolDef> = {
+    readonly machine: DefinedAgentMachine<T>;
+    readonly interpret: DefinedAgentInterpret<T>;
+    readonly subscribe: Subscribe<DefinedAgentMsg<T>, DeadlinesSub, DefinedAgentCtx<T>>;
+};
 /**
  * The brain a defined agent runs, in either of its two shapes:
  *
@@ -327,12 +337,10 @@ type DefinedAgentEvent<T extends AnyToolDef> = AgentEvent<ToolResult<T>>;
 /**
  * Host wiring for one `run`: the store, the ctx the tools need, a runId, a clock.
  *
- * `ctx` is `ScopedCtxArg`, the same widening `run` itself takes: an agent's tools
- * are exactly the handlers a scoped resource is for, so a `provide({ … })` graph
- * is accepted here in place of the object and gets the same acquire-at-boot /
- * release-at-terminal lifetime.
+ * `ctx` is the plain object the tools' handlers read (ADR 0020). A host with a
+ * resource to release wraps `run` in its own `try` / `finally`.
  */
-type DefinedAgentRunOptions<T extends AnyToolDef> = ScopedCtxArg<DefinedAgentCtx<T>> & {
+type DefinedAgentRunOptions<T extends AnyToolDef> = CtxArg<DefinedAgentCtx<T>> & {
     readonly store?: Store<DefinedAgentState<T>>;
     /** The run's identity. Omit → a fresh UUID. */
     readonly runId?: string;
@@ -407,9 +415,10 @@ type DefinedAgentRunOptions<T extends AnyToolDef> = ScopedCtxArg<DefinedAgentCtx
  * `defineAgent` built.
  *
  * The wrapper's signature is the cell's, so calling `next(cmd, ctx, dispatch)`
- * is how the wrapped work happens — that is the typed Cmd→Msg edge
- * (`Cmd.define`'s `_ok` / `_err` Msgs), and returning its Msg is what keeps the
- * fold, and therefore a replay, identical to the unwrapped run's.
+ * is how the wrapped work happens. A tool cell returns its outcome and the
+ * engine mints `<name>_ok` / `<name>_err` from it (ADR 0021), so returning
+ * what `next` returned is what keeps the fold, and therefore a replay,
+ * identical to the unwrapped run's.
  */
 type InterpretOverlay<T extends AnyToolDef> = CellWrappers<DefinedAgentInterpret<T>>;
 /**
@@ -444,8 +453,11 @@ interface DefinedAgent<T extends AnyToolDef> {
      * reads without a guard against an `idle` arm this promise cannot produce.
      */
     readonly run: (input: string, ...opts: [Record<never, never>] extends [DefinedAgentCtx<T>] ? [opts?: DefinedAgentRunOptions<T>] : [opts: DefinedAgentRunOptions<T>]) => Promise<DefinedAgentResolvedState<T>>;
-    /** The machine `run` drives for `input` — the door down to the raw kernel. */
-    readonly machine: (input: string) => DefinedAgentMachine<T>;
+    /**
+     * The machine `run` drives for `input` and the interpret table it runs under
+     * — the door down to the raw kernel.
+     */
+    readonly machine: (input: string) => DefinedAgentWired<T>;
     /**
      * The ramp between the lid and `createAgent`: wrap ONE interpret cell of the
      * machine this agent builds and get back a NEW defined agent that runs the
@@ -616,8 +628,8 @@ declare function transcript<R>(seed?: TranscriptSeed<R>): Transcript<R>;
  * (via the llm-call message loader), the schemas, and the model. `createAgent(config)` returns the uniform handle contract every
  * composition exposes (`init` / verbs returning `readonly [State, Cmd[]]` /
  * `subs`) AND a ready-to-`run` `defineMachine` (`toMachine`) — THE one wired
- * path. (`unsafeDetachedHandlers` is the hand-wiring escape hatch; its name
- * advertises that it does not drive the retry loop.)
+ * path. (`brainInterpret` and `brain` are the pieces a consumer wiring the
+ * verbs by hand reaches for.)
  *
  * ## The composition (three siblings wired into ONE machine)
  *
@@ -628,7 +640,8 @@ declare function transcript<R>(seed?: TranscriptSeed<R>): Transcript<R>;
  *     delegates `start` / `advance` / `progress` / `onDeadline` / `boot` to it.
  *   - `../llm-call` — every brain call. One
  *     `LlmCall` per turn, structured-output parsed, retry composed in. The agent
- *     delegates the resilient slice + verbs and reuses the detached handler.
+ *     delegates the resilient slice + verbs, and owns the one Promise handler
+ *     that invokes the model (`./model`).
  *   - `../fan-out` — the tool calls a turn produced. Tools dispatch SERIALLY by
  *     default (concurrency 1); fan-out generalizes that to a bounded number
  *     LAUNCHED per transition, `config.toolConcurrency`. Above `1` a router's
@@ -700,8 +713,8 @@ declare function transcript<R>(seed?: TranscriptSeed<R>): Transcript<R>;
  *   });
  *   // The consumer supplies the per-tool (+ snapshot) interpret; the agent owns
  *   // the brain interpret and merges them in `toMachine`.
- *   const machine = agent.toMachine({ toolInterpret });
- *   const runtime = run(machine, { ctx, store });
+ *   const wired = agent.toMachine({ toolInterpret });
+ *   const runtime = run(wired.machine, { ...wired, ctx, store });
  */
 
 /**
@@ -716,7 +729,6 @@ declare function transcript<R>(seed?: TranscriptSeed<R>): Transcript<R>;
  * pass obliges you to supply the matching handler at `toMachine`, and each one
  * you omit forbids it. `rng` is the determinism seam for the retry backoff —
  * pass a fixed `() => 0` to pin it in tests; omit for `Math.random`.
- * `unsafeDetachedHandlers` is the hand-wiring escape hatch.
  *
  * The four overloads exist because the two obligations are derived
  * from the `config` VALUE, never inferred. `{ snapshotEvery: number }` REQUIRES
@@ -745,4 +757,4 @@ declare function createAgent<Stage, P extends string, O extends Record<P, AgentT
     readonly compaction?: never;
 }): AgentKnob<Stage, P, O, R, TC, false, false>;
 
-export { AgentCmd, AgentConfigCore, AgentEvent, AgentKnob, AgentMachineMsg, type AgentMessage, type AgentPrompt, AgentState, AgentTurn, AnyToolDef, CompactionPolicy, Conversation, DeadlineSub, type DefineAgentCompaction, type DefineAgentConfig, type DefinedAgent, type DefinedAgentCmd, type DefinedAgentCtx, type DefinedAgentEvent, type DefinedAgentInterpret, type DefinedAgentMachine, type DefinedAgentModel, type DefinedAgentMsg, type DefinedAgentOverlay, type DefinedAgentResolvedState, type DefinedAgentRunOptions, type DefinedAgentState, EndedRun, type InterpretOverlay, type LidPurpose, PlainModel, StreamingModel, ToolCall, ToolCmd, type ToolErrorContext, ToolFailureOf, ToolOutcome, ToolResult, type Transcript, type TranscriptOutcome, type TranscriptSeed, type TranscriptSnapshot, type TranscriptToolResult, TurnChunk, WiredToolMsg, createAgent, defineAgent, renderPrompt, transcript };
+export { AgentCmd, AgentConfigCore, AgentEvent, AgentKnob, AgentMachineMsg, type AgentMessage, type AgentPrompt, AgentState, AgentTurn, AnyToolDef, CompactionPolicy, Conversation, DeadlinesSub, type DefineAgentCompaction, type DefineAgentConfig, type DefinedAgent, type DefinedAgentCmd, type DefinedAgentCtx, type DefinedAgentEvent, type DefinedAgentInterpret, type DefinedAgentMachine, type DefinedAgentModel, type DefinedAgentMsg, type DefinedAgentOverlay, type DefinedAgentResolvedState, type DefinedAgentRunOptions, type DefinedAgentState, type DefinedAgentWired, EndedRun, type InterpretOverlay, type LidPurpose, PlainModel, StreamingModel, ToolCall, ToolCmd, type ToolErrorContext, ToolFailureOf, ToolOutcome, ToolResult, ToolsCtx, type Transcript, type TranscriptOutcome, type TranscriptSeed, type TranscriptSnapshot, type TranscriptToolResult, TurnChunk, WiredToolMsg, createAgent, defineAgent, renderPrompt, transcript };

package/dist/agent/index.js

@@ -1,12 +1,16 @@
-export { COMPACTION_PURPOSE, PLAIN_MODEL_MISROUTE_REASON, TOOL_RETRY_EXHAUSTED_TAG, TOOL_TIMEOUT_TAG, agentBootMsg, agentCancelMsg, agentEvents, agentTurnSchema, compactionSummarySchema, createAgent, defineAgent, fanOutInterpret, isAgentTurn, isCompactionSummary, isReservedToolName, isStreamingModel, liftAgent, mergeInterpret, plainModel, renderPrompt, status, tool, toolErrorReason, toolRouter, transcript } from '../chunk-TCLBCERH.js';
-import '../chunk-3B5X7SBB.js';
-import '../chunk-MYXFNWAJ.js';
+export { COMPACTION_PURPOSE, PLAIN_MODEL_MISROUTE_REASON, TOOL_RETRY_EXHAUSTED_TAG, TOOL_TIMEOUT_TAG, agentBootMsg, agentCancelMsg, agentEvents, agentTurnSchema, compactionSummarySchema, createAgent, defineAgent, fanOutInterpret, isAgentTurn, isCompactionSummary, isReservedToolName, isStreamingModel, liftAgent, mergeInterpret, plainModel, renderPrompt, status, tool, toolErrorReason, toolRouter, transcript } from '../chunk-EHUDXAKC.js';
+import '../chunk-G5E74IJB.js';
+import '../chunk-7MGXQZPW.js';
+import '../chunk-CIHSHLQX.js';
+import '../chunk-QNGYQMZB.js';
 import '../chunk-TXN2KFHF.js';
-import '../chunk-L3TND7LA.js';
-import '../chunk-AYS5N6WY.js';
+import '../chunk-6NG4V5SB.js';
 import '../chunk-VBDU4JL6.js';
-export { deadlineSub, subscribeDeadline } from '../chunk-22POWGFA.js';
-import '../chunk-G5E74IJB.js';
-import '../chunk-66PY5WYF.js';
+import '../chunk-4LPY67E4.js';
+export { deadlineSub, deadlinesSub, subscribeDeadline } from '../chunk-IVJP3GKJ.js';
+import '../chunk-WT5PBPLB.js';
+import '../chunk-5XU6ZJO2.js';
+import '../chunk-GOX2CYIM.js';
+import '../chunk-CH5KTOEZ.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/chunk-4LPY67E4.js

@@ -0,0 +1,18 @@
+// src/internal/schema.ts
+var VENDOR = "@demlik/tea";
+function schema(validate) {
+  return { "~standard": { version: 1, vendor: VENDOR, validate } };
+}
+function unchecked() {
+  return schema((value) => ({ value }));
+}
+var undefinedOnly = schema(
+  (value) => value === void 0 ? { value: void 0 } : { issues: [{ message: "expected no value" }] }
+);
+var rejectAll = schema(() => ({
+  issues: [{ message: "this Cmd never settles Ok" }]
+}));
+
+export { rejectAll, unchecked, undefinedOnly };
+//# sourceMappingURL=chunk-4LPY67E4.js.map
+//# sourceMappingURL=chunk-4LPY67E4.js.map

package/dist/chunk-4LPY67E4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/schema.ts"],"names":[],"mappings":";AAaA,IAAM,MAAA,GAAS,aAAA;AAEf,SAAS,OACP,QAAA,EACwB;AACxB,EAAA,OAAO,EAAE,aAAa,EAAE,OAAA,EAAS,GAAG,MAAA,EAAQ,MAAA,EAAQ,UAAS,EAAE;AACjE;AAGO,SAAS,SAAA,GAAuC;AACrD,EAAA,OAAO,MAAA,CAAO,CAAC,KAAA,MAAW,EAAE,OAAkB,CAAE,CAAA;AAClD;AAGO,IAAM,aAAA,GAAwD,MAAA;AAAA,EACnE,CAAC,KAAA,KACC,KAAA,KAAU,MAAA,GACN,EAAE,KAAA,EAAO,MAAA,EAAU,GACnB,EAAE,QAAQ,CAAC,EAAE,OAAA,EAAS,mBAAA,EAAqB,CAAA;AACnD;AAGO,IAAM,SAAA,GAA4C,OAAO,OAAO;AAAA,EACrE,MAAA,EAAQ,CAAC,EAAE,OAAA,EAAS,6BAA6B;AACnD,CAAA,CAAE","file":"chunk-4LPY67E4.js","sourcesContent":["/**\n * The three Standard Schemas tea's own `Cmd.define`s need, written by hand so\n * the published package depends on no schema library (ADR 0021 §5).\n *\n * A battery's Cmd input is data it built itself and its `ok` is mostly a type\n * annotation, so what these check is deliberately thin: `unchecked<T>()` names\n * a type and checks nothing, `undefinedOnly` is a handler that settles with no\n * value, and `rejectAll` is a Cmd that never settles `Ok`. A consumer's own\n * `Cmd.define` brings a real schema — zod, Effect Schema — instead.\n */\n\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\nconst VENDOR = \"@demlik/tea\";\n\nfunction schema<T>(\n  validate: (value: unknown) => StandardSchemaV1.Result<T>,\n): StandardSchemaV1<T, T> {\n  return { \"~standard\": { version: 1, vendor: VENDOR, validate } };\n}\n\n/** Accept every value as `T`. The type is the whole contract. */\nexport function unchecked<T>(): StandardSchemaV1<T, T> {\n  return schema((value) => ({ value: value as T }));\n}\n\n/** Accept `undefined` only — the `ok` of a handler that settles with no value. */\nexport const undefinedOnly: StandardSchemaV1<undefined, undefined> = schema(\n  (value) =>\n    value === undefined\n      ? { value: undefined }\n      : { issues: [{ message: \"expected no value\" }] },\n);\n\n/** Accept nothing — the `ok` of a Cmd whose handler only ever fails. */\nexport const rejectAll: StandardSchemaV1<never, never> = schema(() => ({\n  issues: [{ message: \"this Cmd never settles Ok\" }],\n}));\n"]}