@graphorin/core 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,102 @@
 # @graphorin/core
 
+## 0.6.0
+
+### Minor Changes
+
+- [#136](https://github.com/o-stepper/graphorin/pull/136) [`17a2d30`](https://github.com/o-stepper/graphorin/commit/17a2d30564154ca2ab87473335cdef43a5089c84) Thanks [@o-stepper](https://github.com/o-stepper)! - Prompt-cache economics end-to-end (audit 2026-07-04 Wave C, cluster C1).
+
+  - `Usage` gains `cachedReadTokens` / `cacheWriteTokens` (subsets of `promptTokens`), mapped by the vercel adapter (v7 `inputTokenDetails`; reasoning split kept exclusive of `completionTokens`) and the OpenAI-compatible adapter (`prompt_tokens_details.cached_tokens`); the fields flow through step/run aggregation, `usageByModel`, run-state (de)serialization and `withCostTracking` (new `cachedReadPerMtok`/`cacheWritePerMtok` lookup rates, full-input-rate fallback).
+  - New opt-in `ProviderRequest.cachePolicy` / `AgentConfig.cachePolicy` (`{ breakpoints: 'auto', ttl? }`): the vercel adapter anchors Anthropic `cache_control` on the first and last conversation messages so the stable prefix is written once and read at the discounted rate every later step.
+  - `ModelPrice` gains `cacheWriteUsdPerToken`; `calculateCost` bills cache writes; the bundled pricing snapshot is regenerated (2026-07-04) with current Anthropic 4.x / OpenAI gpt-5 + gpt-4.1 + o3/o4-mini / Gemini 2.5 families (legacy ids retained), `lookupPrice` resolves dated ids via a date-suffix fallback, and a new snapshot-coverage release gate cross-checks the model-tier classifier against the snapshot with an explicit known-unpriced allowlist (post-cutoff models report null cost + WARN instead of invented numbers).
+  - Cache-friendly catalogue: handoff tools serialize BEFORE the growing promoted section (byte-stable prefix under `tool_search` promotions), and new `toolPromotion: 'run-boundary'` freezes the advertised catalogue for a whole run while still persisting discoveries.
+
+- [#136](https://github.com/o-stepper/graphorin/pull/136) [`17a2d30`](https://github.com/o-stepper/graphorin/commit/17a2d30564154ca2ab87473335cdef43a5089c84) Thanks [@o-stepper](https://github.com/o-stepper)! - Agent harness quality (audit 2026-07-04 Wave C, cluster C3).
+
+  - Recoverable error envelope: `ToolError` gains `recoverable` + `recoveryHint` (retry_later / check_input / try_alternative / report_to_user), stamped from the kind at the executor's completion funnel and rendered to the model as a bracketed recovery line under the familiar `Error: <message>`.
+  - Transparent bounded tool retry: `rate_limited` outcomes from pure/read-only tools (or tools with an `idempotencyKey`) silently re-execute with exponential backoff up to 3 total attempts (`ToolRateLimitError.retryAfterMs` wins); tune via executor `retry` / `AgentConfig.toolRetry`.
+  - Verifier seam: `AgentConfig.verifiers` run deterministic checks on every terminal response, emit `verifier.result` events, feed failures back as a user message and continue up to `maxVerifierRounds` (default 1); throwing verifiers count as passed. Deliberately no evidence-free self-reflection step.
+  - ACI: empty successful tool output renders as an explicit `(tool ran successfully with no output)` marker.
+  - Deterministic replay: opt-in `recordProviderResponses` journals each step's raw model response onto `RunState.steps[].providerResponse`; new `createReplayProvider(state)` re-drives a run offline and fails loudly on divergence.
+
+- [#136](https://github.com/o-stepper/graphorin/pull/136) [`17a2d30`](https://github.com/o-stepper/graphorin/commit/17a2d30564154ca2ab87473335cdef43a5089c84) Thanks [@o-stepper](https://github.com/o-stepper)! - Deterministic security adoptions (audit 2026-07-04 Wave C, cluster C6).
+
+  - Derived-taint propagation: opt-in `dataFlowPolicy.derivedTaint: 'strict'` fires the paraphrase-robust `derived-untrusted-to-sink` flow for every model-driven sink call once untrusted content entered the run (CaMeL-style control-flow integrity); the agent also records each tainted step's assistant text as `llm-derived` spans so model-echoed phrasing trips the verbatim probe.
+  - Taint into memory (cross-session MINJA leg): `ToolReturn` gains a widen-only `taint` override honoured through the executor record path; `fact_search` / `deep_recall` / `recall_episodes` attach it when any returned item is quarantined or foreign-provenance, re-arming the ledger at recall. `RunState.taintSummary` additionally carries one-way FNV-1a span-tile hashes (no plaintext), so a resumed run re-detects pre-suspend verbatim copies.
+  - MCP pinning completed: `toTools({ pinStore })` records fingerprints on first use and REJECTS drift by default when a store is present (rug-pull defense; `onPinMismatch: 'warn'` downgrades); tool-description injection hits at registration are counted (`mcp.tool-description.injection-flagged.total`).
+  - Signal-only heuristics + Unicode pre-pass: shared `normalizeForMatching` (NFKC + zero-width strip) applied in the guardrails injection catalogue and the memory quarantine heuristics; security.md repositions all pattern catalogues as best-effort signal, never a sole gate. `TaintLabel.sourceKind` widened to `string` for the new descriptive kinds.
+
+- [#136](https://github.com/o-stepper/graphorin/pull/136) [`17a2d30`](https://github.com/o-stepper/graphorin/commit/17a2d30564154ca2ab87473335cdef43a5089c84) Thanks [@o-stepper](https://github.com/o-stepper)! - Trace-tree observability (audit 2026-07-04 Wave C, cluster C7; pairs periphery-04).
+
+  The agent loop now emits the previously-declared `agent.run` span per run and `agent.step` spans per step (parented under the run); `tool.execute` parents under the current step via the new optional `RunContext.span`; a `withTracing`-wrapped provider parents under the step via the new `ProviderRequest.parentSpan` (a live handle like `signal`). Attributes align to the OTel GenAI semantic conventions (`gen_ai.operation.name`, `gen_ai.agent.id/name`, `gen_ai.tool.name`, `gen_ai.request.model`, `gen_ai.usage.input_tokens/output_tokens`), parent-based sampling finally has parents to follow, and observability.md documents the real tree plus the memory-tier-spans-not-yet-parented limitation.
+
+- [#137](https://github.com/o-stepper/graphorin/pull/137) [`ce06b47`](https://github.com/o-stepper/graphorin/commit/ce06b472af9e30ac5d0792f7a8b6f42170a94627) Thanks [@o-stepper](https://github.com/o-stepper)! - Durable workflow orchestration (audit 2026-07-04 Wave D, cluster D1) - promotes the workflow engine to step-checkpoint durable execution and closes the confirmed `workflow-01..14` correctness floor.
+
+  - Feature floor: atomic checkpoint compare-and-set (`CheckpointStore.put({ expectedLatestId })` + `CheckpointConflictError`, honoured by both bundled stores), planned-order channel writes, merge-failure + boundary-abort + max-steps terminal checkpointing, all-false-`__start__` dead-end, ephemeral-value observability on `workflow.channel.update`, satisfied-pause retention on sibling failure, `maxConcurrentTasks` bounded task pool, `Dispatch` cross-realm brand, and hygiene (dead `visitedNodes`, six->seven stream modes, `'async'` source removed, resume durability override).
+  - New durable capabilities: per-node `timeoutMs` + `retry` (`nodeDefaults`), durable timers (`sleepUntil`/`sleepFor` + `workflow.tick`), durable promises (`awaitExternal` + `resolveAwakeable`), persisted approvals (`requestApproval` + `approve`), `WorkflowConfig.version` pinning (`workflow-version-mismatch`) + journal-divergence detection, and opt-in step journaling (`journalSteps`) with crash-recovery that replays completed tasks and re-runs only unfinished work.
+
+- [#137](https://github.com/o-stepper/graphorin/pull/137) [`ce06b47`](https://github.com/o-stepper/graphorin/commit/ce06b472af9e30ac5d0792f7a8b6f42170a94627) Thanks [@o-stepper](https://github.com/o-stepper)! - Sub-agent isolation & orchestration primitives (audit 2026-07-04 Wave D, cluster D2).
+
+  - Run-level `'read-only'` capability (single-writer constraint): `AgentConfig.capability` / `AgentCallOptions.capability` never advertise writer tools or handoffs and the executor deterministically blocks fabricated writer calls with the new `capability_blocked` `ToolErrorKind` (threaded through `executeBatch`/`executeOne`, HITL resume, and the code-mode bridge).
+  - `toTool({ contextFold })` returns a compact distilled child-run outcome instead of raw output; `toTool({ propagateTaint })` (default on) carries the child's coarse taint flags across the fold as a widen-only `ToolReturn.taint` override (`sourceKind: 'sub-agent'`) that re-arms the parent's data-flow ledger.
+
+- [#137](https://github.com/o-stepper/graphorin/pull/137) [`ce06b47`](https://github.com/o-stepper/graphorin/commit/ce06b472af9e30ac5d0792f7a8b6f42170a94627) Thanks [@o-stepper](https://github.com/o-stepper)! - Memory architecture evolution (audit 2026-07-04 Wave D, cluster D3) - opt-in; defaults byte-identical.
+
+  - Learned-context digest block (Letta sleep-time): a deep-phase pass rewrites the reserved `learned_context` working block from recent evidence via one budgeted LLM call (`consolidator.learnedContext`, off at every tier).
+  - Principal/owner dimension (`MemoryOwner` on facts/episodes/rules/insights, migration 026) stamped `'agent'` on synthesized writes, with a retrieval-time `owner` filter (`FactSearchOptions.owner`); default reads apply no filter.
+  - Retrieval-frequency reinforcement: `facts.access_count` (migration 027) + opt-in `SalienceWeights.accessReinforcement` (default 0 = inert).
+  - Runbook memory: `rules_fts` (migration 028) + `ProceduralMemory.search` returns whole validated procedures, with a gated `runbook_search` tool (`createMemory({ runbookSearch: true })`).
+
+- [#137](https://github.com/o-stepper/graphorin/pull/137) [`ce06b47`](https://github.com/o-stepper/graphorin/commit/ce06b472af9e30ac5d0792f7a8b6f42170a94627) Thanks [@o-stepper](https://github.com/o-stepper)! - Security hardening (audit 2026-07-04 Wave D, cluster D4) - architectural, deterministic layers.
+
+  - RFC-6962 Merkle transparency over the audit log (`@graphorin/security/audit`): tree head, inclusion + consistency proofs, and Ed25519-signed checkpoints, so anchoring a signed head out-of-band makes the trail tamper-resistant (a rewrite of a checkpointed prefix fails the consistency proof).
+  - Operator trust root for skills: `verifySkillSignature`/`installSkillFrom{Npm,Git}` gain `trustRoot` - a valid signature from a key absent from the root returns `valid: false` reason `'untrusted-key'`.
+  - Progent-style tool-argument policies + Rule-of-Two capability profiles (`@graphorin/security/policy`): `AgentConfig.toolPolicy` (forbid-before-allow, default-deny sensitive) + `ruleOfTwo` (drops a lethal-trifecta leg, forcing a read-only capability floor) enforced by a new `ExecutorOptions.argumentPolicy` hook (`capability_blocked`).
+  - Code-mode sandbox blocklist parity (`bridged-source.ts`) blocks the process-escape modules (child_process/vm/worker_threads/cluster/inspector) via the ESM resolve hook + a CJS `Module._load` patch.
+
+- [#137](https://github.com/o-stepper/graphorin/pull/137) [`ce06b47`](https://github.com/o-stepper/graphorin/commit/ce06b472af9e30ac5d0792f7a8b6f42170a94627) Thanks [@o-stepper](https://github.com/o-stepper)! - Retrieval SOTA graph wins (audit 2026-07-04 Wave D, cluster D5) - offline, opt-in; the billed/migration-heavy legs stay eval-gated.
+
+  - PPR-lite graded expansion (HippoRAG-style damped spreading activation): `SqliteGraphStore.expandActivation` + `FactSearchOptions.expandHops: 0|1|2` + `graphScoring: 'ppr'` score neighbours by `damping^hopDepth` instead of a flat 1.
+  - Graph + entity as first-class tunable fusion weights (`FusionWeights.graph` / `.entity`, were hardcoded neutral).
+  - Exact entity-match retriever: `SqliteGraphStore.factsForEntityName` + `FactSearchOptions.entityMatch` add a precise "facts about <entity>" candidate leg.
+  - `longmemeval` harness gains `--retrieval ppr` / `--retrieval entity`. Bitemporal event time, Matryoshka truncation, and cascade LLM reranking remain eval-gated.
+
+- [#137](https://github.com/o-stepper/graphorin/pull/137) [`ce06b47`](https://github.com/o-stepper/graphorin/commit/ce06b472af9e30ac5d0792f7a8b6f42170a94627) Thanks [@o-stepper](https://github.com/o-stepper)! - Context engineering trial (audit 2026-07-04 Wave D, cluster D6) - opt-in; tool surface unchanged by default.
+
+  - Structured plan tool (`update_plan`, TodoWrite-style full-replace checklist) journaled in the new `RunState.todos` (core `TodoItem`), surviving suspend/resume via the strict run-state (de)serializer.
+  - Attention recitation: the current plan is rendered into a compact `<plan>` block appended to each step's request copy - request-only and cache-layout-aware (rides the last prompt-cache anchor, never touches the shared buffer or persisted state).
+  - `AgentConfig.plan` opt-in. Progress files, resume-recap injection, and the degraded-mode ladder are documented as trial follow-ups.
+
+### Patch Changes
+
+- [#134](https://github.com/o-stepper/graphorin/pull/134) [`32f20c1`](https://github.com/o-stepper/graphorin/commit/32f20c110f184f8cef7eec85bf39f5f07c886cb6) Thanks [@o-stepper](https://github.com/o-stepper)! - Session hard-delete and the RP-6 retention sweep now purge the session's CONTENT (store-01): `session_messages` rows plus their FTS and per-embedder vector index entries, and episodes scoped to the session, all inside the existing cascade transaction. Previously no code path anywhere deleted `session_messages`, so a "deleted" conversation stayed permanently searchable via `memory.session.list/search` - a GDPR hazard for a privacy-positioned framework. The core `SessionStoreExt.deleteSession` contract is updated to document the content cascade.
+
+- [#135](https://github.com/o-stepper/graphorin/pull/135) [`4f850d9`](https://github.com/o-stepper/graphorin/commit/4f850d9bc0a05d6256c59c5117b010336fcb41d3) Thanks [@o-stepper](https://github.com/o-stepper)! - Provider adapters now match their real SDK / wire contracts (audit 2026-07-04 Wave B, cluster B1).
+
+  - vercel adapter: Graphorin tools convert to the AI SDK's name-keyed record with `jsonSchema()`-shaped input schemas; assistant `toolCalls` become `tool-call` content parts, `ToolMessage`s become `tool-result` messages, system-role messages hoist into the `system` option, and `toolChoice` maps onto the SDK spelling. Tool loops now run against the real `ai` peer (previously every tool conversation failed SDK validation). A real-SDK contract test suite (dev-only `ai` dependency) pins the shapes.
+  - Anthropic token counter posts Anthropic wire-shaped bodies (system hoist, `tool_use` / `tool_result` blocks, turn merging) instead of raw Graphorin messages that 400'd on any agent transcript; degradation to the tiktoken fallback now WARNs once.
+  - HTTP errors carry a canonical `errorKind` (shared `classifyHttpStatus` mapper: 429 rate-limit, 401/403 unauthorized, 5xx transient/capacity, context-length body sniff) plus captured `retry-after` / `x-ratelimit-*` headers; `withFallback` / `withRetry` consult them, so a 429 on the primary finally fails over and honours server-provided delays.
+  - llamacpp-node: the system prompt is no longer injected twice, per-request contexts/sequences are disposed after every stream (KV-cache leak), and aborted streams report `finishReason: 'aborted'`.
+  - OpenAI-compatible streaming sends `stream_options: { include_usage: true }` so vLLM / Together / OpenAI report real usage; `openAICompatibleAdapter` gained the `capabilities` / `timeoutMs` options its siblings had.
+  - `withCostTracking` bills separately-reported reasoning tokens at the output rate; classifiers recognise Bedrock cross-region ids (`us.anthropic.claude-...`) and the AI SDK's dotted provider ids.
+
+- [#135](https://github.com/o-stepper/graphorin/pull/135) [`4f850d9`](https://github.com/o-stepper/graphorin/commit/4f850d9bc0a05d6256c59c5117b010336fcb41d3) Thanks [@o-stepper](https://github.com/o-stepper)! - Retrieval and consolidation now honour the trust contracts they document (audit 2026-07-04 Wave B, cluster B3).
+
+  - memory-retrieval-01: default fact reads (FTS / vector / graph) behave as `asOf = now`, so superseded and validity-expired facts no longer surface as current - exactly what the `fact_supersede` tool promises. New `includeSuperseded: true` escape hatch (core `MemorySearchOptions`, memory `FactSearchOptions`, graph expand options) restores the full history for inspector / audit paths; `fact_search` and `deep_recall` outputs expose `validTo` / `supersededBy`.
+  - memory-retrieval-02: `deep_recall` passes `forceHard: true` (choosing the tool IS the hardness signal; the local heuristic gate rejected the tool's own documented examples and is English-only). Iterative results carry a new `graded` flag so ungraded single-shot passes stop claiming sufficiency as a verdict.
+  - memory-retrieval-03: a tagged search widens the fusion pool the same way decay does - the record-level tags filter runs after the topK cut, so tagged searches no longer silently return fewer than topK hits.
+  - memory-consolidation-01: the deep-phase dedup verdict now soft-forgets (replayable tombstone) instead of preferring the GDPR hard-delete `purge`, and a vanished conflicting fact skips the judge entirely (admit, no provider call) - a model verdict can no longer hard-delete the only surviving copy.
+  - memory-consolidation-07: the standard phase gains an embedder-independent exact-text duplicate guard (FTS + string equality, quarantine-aware), so replaying a partially-committed slice (DLQ / cursor retry) without an embedder no longer duplicates already-committed facts.
+
+## 0.5.0
+
+First version published to the npm registry (with Sigstore build
+provenance). The 0.2.0, 0.3.0, and 0.4.0 versions were internal lockstep
+milestones and were never published. All `@graphorin/*` packages release
+lockstep at the same version; the full release notes for 0.2.0-0.5.0 live
+in the repository-level
+[CHANGELOG](https://github.com/o-stepper/graphorin/blob/main/CHANGELOG.md).
+
 ## 0.1.0
 
 ### Minor Changes
@@ -17,7 +114,7 @@
   `withSignal`, `assertNever`, `md5`, `xxhash`, …).
 - Workflow channel primitives under `@graphorin/core/channels`:
   `Directive`, `Dispatch`, `pause`, `LatestValue`, `Reducer`, `Stream`,
-  `Barrier`, `Ephemeral`, `AnyValue`, `ListAggregate` — Graphorin's own
+  `Barrier`, `Ephemeral`, `AnyValue`, `ListAggregate` - Graphorin's own
   vocabulary; names are part of the public API.
 - Typed no-op defaults `NOOP_TRACER` and `NOOP_LOGGER` so downstream
   packages can carry a non-null observability surface without taking the

package/README.md

@@ -8,11 +8,11 @@ implementation (sandbox, secrets store, memory store, provider adapters,
 agent runtime, workflow engine, server, …) lives in a sibling package and
 depends on the interfaces declared here.
 
-- **Status:** v0.5.0 — type and contract surface for the v0.1 release line.
-- **License:** [MIT](./LICENSE) — © 2026 Oleksiy Stepurenko.
+- **Status:** v0.6.0 - type and contract surface for the v0.1 release line.
+- **License:** [MIT](./LICENSE) - © 2026 Oleksiy Stepurenko.
 - **Engines:** Node.js 22+ (ESM only).
 - **Runtime dependencies:** none.
-- **Peer dependency:** `zod` (`^3.23 || ^4`) — used for schema-typed values
+- **Peer dependency:** `zod` (`^3.23 || ^4`) - used for schema-typed values
   (`stateSchema`, `inputSchema`, `outputSchema`, `EvalScorer`, …). Bring
   whichever Zod version your application already uses.
 
@@ -52,8 +52,8 @@ sub-paths so that consumers can import only what they need:
 
 Every exported type is annotated with one of two TSDoc tags:
 
-- `@stable` — covered by semver guarantees for the `v0.x` line.
-- `@experimental` — may change between minor versions; a deprecation note
+- `@stable` - covered by semver guarantees for the `v0.x` line.
+- `@experimental` - may change between minor versions; a deprecation note
   in the `CHANGELOG.md` will accompany every removal.
 
 The vast majority of the surface ships as `@stable`; the deliberately
@@ -67,4 +67,4 @@ records are still being refined for v0.2.
 
 ---
 
-**Graphorin** · v0.5.0 · MIT License · © 2026 Oleksiy Stepurenko · <https://github.com/o-stepper/graphorin>
+**Graphorin** · v0.6.0 · MIT License · © 2026 Oleksiy Stepurenko · <https://github.com/o-stepper/graphorin>

package/dist/channels/channels.d.ts

@@ -33,7 +33,7 @@ interface LatestValue<T = unknown> {
   readonly default?: T;
 }
 /**
- * Overwrite-on-write — collisions are silently allowed (last-write-wins
+ * Overwrite-on-write - collisions are silently allowed (last-write-wins
  * semantics within a step).
  *
  * @stable
@@ -75,7 +75,7 @@ interface Stream<T = unknown> {
   readonly default?: ReadonlyArray<T>;
 }
 /**
- * Barrier — completes when every writer in `from` has produced a value.
+ * Barrier - completes when every writer in `from` has produced a value.
  *
  * @stable
  */
@@ -85,7 +85,7 @@ interface Barrier<T = unknown> {
   readonly default?: T;
 }
 /**
- * Value scoped to a single execution step — discarded when the step
+ * Value scoped to a single execution step - discarded when the step
  * ends.
  *
  * @stable

package/dist/channels/channels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"channels.d.ts","names":[],"sources":["../../src/channels/channels.ts"],"sourcesContent":[],"mappings":";;AAYA;AAkBA;;;;;;;;;;AAKI,KAvBQ,WAAA,GAuBR,cAAA,GAAA,WAAA,GAAA,SAAA,GAAA,gBAAA,GAAA,QAAA,GAAA,SAAA,GAAA,WAAA;;;;;;AAUJ;AAWA;AAYA;;AAG0B,KAzCd,OAyCc,CAAA,IAAA,OAAA,CAAA,GAxCtB,WAwCsB,CAxCV,CAwCU,CAAA,GAvCtB,QAuCsB,CAvCb,CAuCa,CAAA,GAtCtB,OAsCsB,CAtCd,CAsCc,CAAA,GArCtB,aAqCsB,CArCR,CAqCQ,CAAA,GApCtB,MAoCsB,CApCf,CAoCe,CAAA,GAnCtB,OAmCsB,CAnCd,CAmCc,CAAA,GAlCtB,SAkCsB,CAlCZ,CAkCY,CAAA;;;;AAQ1B;AAWA;AAWA;AAYiB,UApEA,WAoES,CAAA,IAEJ,OAAA,CAAA,CAAA;EAQN,SAAA,IAAA,EAAW,cAAA;EAAgC,SAAA,OAAA,CAAA,EA5EtC,CA4EsC;;;;AAW3D;;;;AAAsE,UA9ErD,QA8EqD,CAAA,IAAA,OAAA,CAAA,CAAA;EAWtD,SAAA,IAAO,EAAA,WAAA;EACN,SAAA,OAAA,CAAA,EAxFI,CAwFJ;;;;;;;AAajB;;AAA6D,UA3F5C,OA2F4C,CAAA,IAAA,OAAA,CAAA,CAAA;EAAmC,SAAA,IAAA,EAAA,SAAA;EAAd,SAAA,OAAA,CAAA,EAzF7D,CAyF6D;EAAa,SAAA,MAAA,EAAA,CAAA,IAAA,EAxFrE,CAwFqE,EAAA,IAAA,EAxF5D,CAwF4D,EAAA,GAxFtD,CAwFsD;AAW/F;;;;;;AAiBgB,UA5GC,aA4GM,CAAA,IAAA,OAAA,CAAA,CAAA;EACf,SAAA,IAAA,EAAA,gBAAA;EACsB,SAAA,OAAA,CAAA,EA5GT,aA4GS,CA5GK,CA4GL,CAAA;;;;AAY9B;;;;AAAwE,UA/GvD,MA+GuD,CAAA,IAAA,OAAA,CAAA,CAAA;;;qBA5GnD,cAAc;;;;;;;UAQlB;;iBAEA;qBACI;;;;;;;;UASJ;;qBAEI;;;;;;;iBAQL;qBAA2C;IAAM,YAAY;;;;;;iBAW7D;qBAAwC;IAAM,SAAS;;;;;;iBAWvD,0BACC,SAAS,MAAM;qBACF;IAC3B,QAAQ;;;;;;iBAWK;qBAA6C,cAAc;IAAO,cAAc;;;;;;iBAWhF;;qBAEK,cAAc;IAC/B,OAAO;;;;;;iBAcK,iBACR;qBACsB;IAC3B,QAAQ;;;;;;iBAWK;qBAAyC;IAAM,UAAU"}
+{"version":3,"file":"channels.d.ts","names":[],"sources":["../../src/channels/channels.ts"],"sourcesContent":[],"mappings":";;AAYA;AAkBA;;;;;;;;;;AAKI,KAvBQ,WAAA,GAuBR,cAAA,GAAA,WAAA,GAAA,SAAA,GAAA,gBAAA,GAAA,QAAA,GAAA,SAAA,GAAA,WAAA;;;;;;AAUJ;AAWA;AAYA;;AAG0B,KAzCd,OAyCc,CAAA,IAAA,OAAA,CAAA,GAxCtB,WAwCsB,CAxCV,CAwCU,CAAA,GAvCtB,QAuCsB,CAvCb,CAuCa,CAAA,GAtCtB,OAsCsB,CAtCd,CAsCc,CAAA,GArCtB,aAqCsB,CArCR,CAqCQ,CAAA,GApCtB,MAoCsB,CApCf,CAoCe,CAAA,GAnCtB,OAmCsB,CAnCd,CAmCc,CAAA,GAlCtB,SAkCsB,CAlCZ,CAkCY,CAAA;;;;AAQ1B;AAWA;AAWA;AAYiB,UApEA,WAoES,CAEL,IAAC,OAAA,CAAA,CAAA;EAQN,SAAA,IAAA,EAAW,cAAA;EAAgC,SAAA,OAAA,CAAA,EA5EtC,CA4EsC;;;;AAW3D;;;;AAAsE,UA9ErD,QA8EqD,CAAA,IAAA,OAAA,CAAA,CAAA;EAWtD,SAAA,IAAO,EAAA,WAAA;EACN,SAAA,OAAA,CAAA,EAxFI,CAwFJ;;;;;;;AAajB;;AAA6D,UA3F5C,OA2F4C,CAAA,IAAA,OAAA,CAAA,CAAA;EAAmC,SAAA,IAAA,EAAA,SAAA;EAAd,SAAA,OAAA,CAAA,EAzF7D,CAyF6D;EAAa,SAAA,MAAA,EAAA,CAAA,IAAA,EAxFrE,CAwFqE,EAAA,IAAA,EAxF5D,CAwF4D,EAAA,GAxFtD,CAwFsD;AAW/F;;;;;;AAiBgB,UA5GC,aA4GM,CAAA,IAAA,OAAA,CAAA,CAAA;EACf,SAAA,IAAA,EAAA,gBAAA;EACsB,SAAA,OAAA,CAAA,EA5GT,aA4GS,CA5GK,CA4GL,CAAA;;;;AAY9B;;;;AAAwE,UA/GvD,MA+GuD,CAAA,IAAA,OAAA,CAAA,CAAA;;;qBA5GnD,cAAc;;;;;;;UAQlB;;iBAEA;qBACI;;;;;;;;UASJ;;qBAEI;;;;;;;iBAQL;qBAA2C;IAAM,YAAY;;;;;;iBAW7D;qBAAwC;IAAM,SAAS;;;;;;iBAWvD,0BACC,SAAS,MAAM;qBACF;IAC3B,QAAQ;;;;;;iBAWK;qBAA6C,cAAc;IAAO,cAAc;;;;;;iBAWhF;;qBAEK,cAAc;IAC/B,OAAO;;;;;;iBAcK,iBACR;qBACsB;IAC3B,QAAQ;;;;;;iBAWK;qBAAyC;IAAM,UAAU"}

package/dist/channels/channels.js.map

@@ -1 +1 @@
-{"version":3,"file":"channels.js","names":["out: { kind: 'stream'; unique?: boolean; default?: ReadonlyArray<T> }"],"sources":["../../src/channels/channels.ts"],"sourcesContent":["/**\n * Workflow channel kinds. Every state field declared on a workflow's\n * `stateSchema` is bound to a channel that decides the merge strategy\n * applied when multiple writers update the same field within a single\n * execution step.\n *\n * The names are **Graphorin's own design** and must not be aliased to\n * terms from other workflow libraries. A dedicated lint rule lands later\n * in the release line to enforce this.\n *\n * @stable\n */\nexport type ChannelKind =\n  | 'latest-value'\n  | 'any-value'\n  | 'reducer'\n  | 'list-aggregate'\n  | 'stream'\n  | 'barrier'\n  | 'ephemeral';\n\n/**\n * Discriminated union of every channel descriptor.\n *\n * Channels are a *description* of the merge strategy, not a runtime\n * value: the engine reads the `kind` field plus optional auxiliary\n * fields (`reduce`, `from`, `unique`) to decide how to combine writes.\n *\n * @stable\n */\nexport type Channel<T = unknown> =\n  | LatestValue<T>\n  | AnyValue<T>\n  | Reducer<T>\n  | ListAggregate<T>\n  | Stream<T>\n  | Barrier<T>\n  | Ephemeral<T>;\n\n/**\n * Overwrite-on-write. Multiple writes within the same execution step\n * raise `MultiWriteError` (use `AnyValue` if collisions are acceptable).\n *\n * @stable\n */\nexport interface LatestValue<T = unknown> {\n  readonly kind: 'latest-value';\n  readonly default?: T;\n}\n\n/**\n * Overwrite-on-write — collisions are silently allowed (last-write-wins\n * semantics within a step).\n *\n * @stable\n */\nexport interface AnyValue<T = unknown> {\n  readonly kind: 'any-value';\n  readonly default?: T;\n}\n\n/**\n * Fold writes via a user-provided `reduce` function. The reducer is\n * invoked left-to-right over the writes collected within an execution\n * step.\n *\n * @stable\n */\nexport interface Reducer<T = unknown> {\n  readonly kind: 'reducer';\n  readonly default?: T;\n  readonly reduce: (prev: T, next: T) => T;\n}\n\n/**\n * Specialization of `Reducer<T[]>` that appends each write to a list.\n *\n * @stable\n */\nexport interface ListAggregate<T = unknown> {\n  readonly kind: 'list-aggregate';\n  readonly default?: ReadonlyArray<T>;\n}\n\n/**\n * Append-only queue. Used for dynamic task creation via `Dispatch(...)`\n * and for application-defined event streams.\n *\n * @stable\n */\nexport interface Stream<T = unknown> {\n  readonly kind: 'stream';\n  readonly unique?: boolean;\n  readonly default?: ReadonlyArray<T>;\n}\n\n/**\n * Barrier — completes when every writer in `from` has produced a value.\n *\n * @stable\n */\nexport interface Barrier<T = unknown> {\n  readonly kind: 'barrier';\n  readonly from: ReadonlyArray<string>;\n  readonly default?: T;\n}\n\n/**\n * Value scoped to a single execution step — discarded when the step\n * ends.\n *\n * @stable\n */\nexport interface Ephemeral<T = unknown> {\n  readonly kind: 'ephemeral';\n  readonly default?: T;\n}\n\n/**\n * Construct a `LatestValue` channel.\n *\n * @stable\n */\nexport function latestValue<T>(opts?: { readonly default?: T }): LatestValue<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'latest-value', default: opts.default }\n    : { kind: 'latest-value' };\n}\n\n/**\n * Construct an `AnyValue` channel.\n *\n * @stable\n */\nexport function anyValue<T>(opts?: { readonly default?: T }): AnyValue<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'any-value', default: opts.default }\n    : { kind: 'any-value' };\n}\n\n/**\n * Construct a `Reducer` channel.\n *\n * @stable\n */\nexport function reducer<T>(\n  reduce: (prev: T, next: T) => T,\n  opts?: { readonly default?: T },\n): Reducer<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'reducer', reduce, default: opts.default }\n    : { kind: 'reducer', reduce };\n}\n\n/**\n * Construct a `ListAggregate` channel.\n *\n * @stable\n */\nexport function listAggregate<T>(opts?: { readonly default?: ReadonlyArray<T> }): ListAggregate<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'list-aggregate', default: opts.default }\n    : { kind: 'list-aggregate' };\n}\n\n/**\n * Construct a `Stream` channel.\n *\n * @stable\n */\nexport function stream<T>(opts?: {\n  readonly unique?: boolean;\n  readonly default?: ReadonlyArray<T>;\n}): Stream<T> {\n  const out: { kind: 'stream'; unique?: boolean; default?: ReadonlyArray<T> } = {\n    kind: 'stream',\n  };\n  if (opts?.unique !== undefined) out.unique = opts.unique;\n  if (opts?.default !== undefined) out.default = opts.default;\n  return out;\n}\n\n/**\n * Construct a `Barrier` channel.\n *\n * @stable\n */\nexport function barrier<T>(\n  from: ReadonlyArray<string>,\n  opts?: { readonly default?: T },\n): Barrier<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'barrier', from, default: opts.default }\n    : { kind: 'barrier', from };\n}\n\n/**\n * Construct an `Ephemeral` channel.\n *\n * @stable\n */\nexport function ephemeral<T>(opts?: { readonly default?: T }): Ephemeral<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'ephemeral', default: opts.default }\n    : { kind: 'ephemeral' };\n}\n"],"mappings":";;;;;;AA2HA,SAAgB,YAAe,MAAiD;AAC9E,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAgB,SAAS,KAAK;EAAS,GAC/C,EAAE,MAAM,gBAAgB;;;;;;;AAQ9B,SAAgB,SAAY,MAA8C;AACxE,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAa,SAAS,KAAK;EAAS,GAC5C,EAAE,MAAM,aAAa;;;;;;;AAQ3B,SAAgB,QACd,QACA,MACY;AACZ,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAW;EAAQ,SAAS,KAAK;EAAS,GAClD;EAAE,MAAM;EAAW;EAAQ;;;;;;;AAQjC,SAAgB,cAAiB,MAAkE;AACjG,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAkB,SAAS,KAAK;EAAS,GACjD,EAAE,MAAM,kBAAkB;;;;;;;AAQhC,SAAgB,OAAU,MAGZ;CACZ,MAAMA,MAAwE,EAC5E,MAAM,UACP;AACD,KAAI,MAAM,WAAW,OAAW,KAAI,SAAS,KAAK;AAClD,KAAI,MAAM,YAAY,OAAW,KAAI,UAAU,KAAK;AACpD,QAAO;;;;;;;AAQT,SAAgB,QACd,MACA,MACY;AACZ,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAW;EAAM,SAAS,KAAK;EAAS,GAChD;EAAE,MAAM;EAAW;EAAM;;;;;;;AAQ/B,SAAgB,UAAa,MAA+C;AAC1E,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAa,SAAS,KAAK;EAAS,GAC5C,EAAE,MAAM,aAAa"}
+{"version":3,"file":"channels.js","names":["out: { kind: 'stream'; unique?: boolean; default?: ReadonlyArray<T> }"],"sources":["../../src/channels/channels.ts"],"sourcesContent":["/**\n * Workflow channel kinds. Every state field declared on a workflow's\n * `stateSchema` is bound to a channel that decides the merge strategy\n * applied when multiple writers update the same field within a single\n * execution step.\n *\n * The names are **Graphorin's own design** and must not be aliased to\n * terms from other workflow libraries. A dedicated lint rule lands later\n * in the release line to enforce this.\n *\n * @stable\n */\nexport type ChannelKind =\n  | 'latest-value'\n  | 'any-value'\n  | 'reducer'\n  | 'list-aggregate'\n  | 'stream'\n  | 'barrier'\n  | 'ephemeral';\n\n/**\n * Discriminated union of every channel descriptor.\n *\n * Channels are a *description* of the merge strategy, not a runtime\n * value: the engine reads the `kind` field plus optional auxiliary\n * fields (`reduce`, `from`, `unique`) to decide how to combine writes.\n *\n * @stable\n */\nexport type Channel<T = unknown> =\n  | LatestValue<T>\n  | AnyValue<T>\n  | Reducer<T>\n  | ListAggregate<T>\n  | Stream<T>\n  | Barrier<T>\n  | Ephemeral<T>;\n\n/**\n * Overwrite-on-write. Multiple writes within the same execution step\n * raise `MultiWriteError` (use `AnyValue` if collisions are acceptable).\n *\n * @stable\n */\nexport interface LatestValue<T = unknown> {\n  readonly kind: 'latest-value';\n  readonly default?: T;\n}\n\n/**\n * Overwrite-on-write - collisions are silently allowed (last-write-wins\n * semantics within a step).\n *\n * @stable\n */\nexport interface AnyValue<T = unknown> {\n  readonly kind: 'any-value';\n  readonly default?: T;\n}\n\n/**\n * Fold writes via a user-provided `reduce` function. The reducer is\n * invoked left-to-right over the writes collected within an execution\n * step.\n *\n * @stable\n */\nexport interface Reducer<T = unknown> {\n  readonly kind: 'reducer';\n  readonly default?: T;\n  readonly reduce: (prev: T, next: T) => T;\n}\n\n/**\n * Specialization of `Reducer<T[]>` that appends each write to a list.\n *\n * @stable\n */\nexport interface ListAggregate<T = unknown> {\n  readonly kind: 'list-aggregate';\n  readonly default?: ReadonlyArray<T>;\n}\n\n/**\n * Append-only queue. Used for dynamic task creation via `Dispatch(...)`\n * and for application-defined event streams.\n *\n * @stable\n */\nexport interface Stream<T = unknown> {\n  readonly kind: 'stream';\n  readonly unique?: boolean;\n  readonly default?: ReadonlyArray<T>;\n}\n\n/**\n * Barrier - completes when every writer in `from` has produced a value.\n *\n * @stable\n */\nexport interface Barrier<T = unknown> {\n  readonly kind: 'barrier';\n  readonly from: ReadonlyArray<string>;\n  readonly default?: T;\n}\n\n/**\n * Value scoped to a single execution step - discarded when the step\n * ends.\n *\n * @stable\n */\nexport interface Ephemeral<T = unknown> {\n  readonly kind: 'ephemeral';\n  readonly default?: T;\n}\n\n/**\n * Construct a `LatestValue` channel.\n *\n * @stable\n */\nexport function latestValue<T>(opts?: { readonly default?: T }): LatestValue<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'latest-value', default: opts.default }\n    : { kind: 'latest-value' };\n}\n\n/**\n * Construct an `AnyValue` channel.\n *\n * @stable\n */\nexport function anyValue<T>(opts?: { readonly default?: T }): AnyValue<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'any-value', default: opts.default }\n    : { kind: 'any-value' };\n}\n\n/**\n * Construct a `Reducer` channel.\n *\n * @stable\n */\nexport function reducer<T>(\n  reduce: (prev: T, next: T) => T,\n  opts?: { readonly default?: T },\n): Reducer<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'reducer', reduce, default: opts.default }\n    : { kind: 'reducer', reduce };\n}\n\n/**\n * Construct a `ListAggregate` channel.\n *\n * @stable\n */\nexport function listAggregate<T>(opts?: { readonly default?: ReadonlyArray<T> }): ListAggregate<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'list-aggregate', default: opts.default }\n    : { kind: 'list-aggregate' };\n}\n\n/**\n * Construct a `Stream` channel.\n *\n * @stable\n */\nexport function stream<T>(opts?: {\n  readonly unique?: boolean;\n  readonly default?: ReadonlyArray<T>;\n}): Stream<T> {\n  const out: { kind: 'stream'; unique?: boolean; default?: ReadonlyArray<T> } = {\n    kind: 'stream',\n  };\n  if (opts?.unique !== undefined) out.unique = opts.unique;\n  if (opts?.default !== undefined) out.default = opts.default;\n  return out;\n}\n\n/**\n * Construct a `Barrier` channel.\n *\n * @stable\n */\nexport function barrier<T>(\n  from: ReadonlyArray<string>,\n  opts?: { readonly default?: T },\n): Barrier<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'barrier', from, default: opts.default }\n    : { kind: 'barrier', from };\n}\n\n/**\n * Construct an `Ephemeral` channel.\n *\n * @stable\n */\nexport function ephemeral<T>(opts?: { readonly default?: T }): Ephemeral<T> {\n  return opts !== undefined && 'default' in opts && opts.default !== undefined\n    ? { kind: 'ephemeral', default: opts.default }\n    : { kind: 'ephemeral' };\n}\n"],"mappings":";;;;;;AA2HA,SAAgB,YAAe,MAAiD;AAC9E,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAgB,SAAS,KAAK;EAAS,GAC/C,EAAE,MAAM,gBAAgB;;;;;;;AAQ9B,SAAgB,SAAY,MAA8C;AACxE,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAa,SAAS,KAAK;EAAS,GAC5C,EAAE,MAAM,aAAa;;;;;;;AAQ3B,SAAgB,QACd,QACA,MACY;AACZ,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAW;EAAQ,SAAS,KAAK;EAAS,GAClD;EAAE,MAAM;EAAW;EAAQ;;;;;;;AAQjC,SAAgB,cAAiB,MAAkE;AACjG,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAkB,SAAS,KAAK;EAAS,GACjD,EAAE,MAAM,kBAAkB;;;;;;;AAQhC,SAAgB,OAAU,MAGZ;CACZ,MAAMA,MAAwE,EAC5E,MAAM,UACP;AACD,KAAI,MAAM,WAAW,OAAW,KAAI,SAAS,KAAK;AAClD,KAAI,MAAM,YAAY,OAAW,KAAI,UAAU,KAAK;AACpD,QAAO;;;;;;;AAQT,SAAgB,QACd,MACA,MACY;AACZ,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAW;EAAM,SAAS,KAAK;EAAS,GAChD;EAAE,MAAM;EAAW;EAAM;;;;;;;AAQ/B,SAAgB,UAAa,MAA+C;AAC1E,QAAO,SAAS,UAAa,aAAa,QAAQ,KAAK,YAAY,SAC/D;EAAE,MAAM;EAAa,SAAS,KAAK;EAAS,GAC5C,EAAE,MAAM,aAAa"}

package/dist/channels/directive.d.ts

@@ -4,9 +4,14 @@
  * `Workflow.resume(threadId, directive?)` (or returned from a node's
  * `pause(...)` resolution) carrying any combination of:
  *
- * - `goto`   — jump to a named node, bypassing the edge graph.
- * - `resume` — value supplied to the `pause(value)` call that suspended.
- * - `update` — additional channel writes applied before the next step.
+ * - `goto`   - jump to a named node, bypassing the edge graph.
+ *   **Destructive (workflow-09):** the restored frontier is discarded -
+ *   surviving dynamic tasks, completed-but-unwalked nodes, and every
+ *   pending pause record (including already-delivered pause answers)
+ *   are dropped in favour of the single goto task. Use it as an
+ *   operator escape hatch, not routine control flow.
+ * - `resume` - value supplied to the `pause(value)` call that suspended.
+ * - `update` - additional channel writes applied before the next step.
  *
  * The shape is **Graphorin's own design** (the name `Directive` is part
  * of the public API).

package/dist/channels/directive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directive.d.ts","names":[],"sources":["../../src/channels/directive.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;;;;AAiBA;;;;;cAjBa,oBAAoB;;oBAEb;oBACA;oBAEA,iBAAiB,SAAS;;;;;;;UAY7B,2BAA2B;;oBAExB;oBACA"}
+{"version":3,"file":"directive.d.ts","names":[],"sources":["../../src/channels/directive.ts"],"sourcesContent":[],"mappings":";;AAmBA;;;;;;;;AAiBA;;;;;;;;;;cAjBa,oBAAoB;;oBAEb;oBACA;oBAEA,iBAAiB,SAAS;;;;;;;UAY7B,2BAA2B;;oBAExB;oBACA"}

package/dist/channels/directive.js

@@ -4,9 +4,14 @@
 * `Workflow.resume(threadId, directive?)` (or returned from a node's
 * `pause(...)` resolution) carrying any combination of:
 *
-* - `goto`   — jump to a named node, bypassing the edge graph.
-* - `resume` — value supplied to the `pause(value)` call that suspended.
-* - `update` — additional channel writes applied before the next step.
+* - `goto`   - jump to a named node, bypassing the edge graph.
+*   **Destructive (workflow-09):** the restored frontier is discarded -
+*   surviving dynamic tasks, completed-but-unwalked nodes, and every
+*   pending pause record (including already-delivered pause answers)
+*   are dropped in favour of the single goto task. Use it as an
+*   operator escape hatch, not routine control flow.
+* - `resume` - value supplied to the `pause(value)` call that suspended.
+* - `update` - additional channel writes applied before the next step.
 *
 * The shape is **Graphorin's own design** (the name `Directive` is part
 * of the public API).

package/dist/channels/directive.js.map

@@ -1 +1 @@
-{"version":3,"file":"directive.js","names":[],"sources":["../../src/channels/directive.ts"],"sourcesContent":["/**\n * Workflow control-flow primitive: a single value handed to\n * `Workflow.resume(threadId, directive?)` (or returned from a node's\n * `pause(...)` resolution) carrying any combination of:\n *\n * - `goto`   — jump to a named node, bypassing the edge graph.\n * - `resume` — value supplied to the `pause(value)` call that suspended.\n * - `update` — additional channel writes applied before the next step.\n *\n * The shape is **Graphorin's own design** (the name `Directive` is part\n * of the public API).\n *\n * @stable\n */\nexport class Directive<TUpdate = Record<string, unknown>, TResume = unknown> {\n  readonly goto?: string;\n  readonly resume?: TResume;\n  readonly update?: TUpdate;\n\n  constructor(opts: DirectiveOptions<TUpdate, TResume>) {\n    if (opts.goto !== undefined) this.goto = opts.goto;\n    if ('resume' in opts && opts.resume !== undefined) this.resume = opts.resume;\n    if (opts.update !== undefined) this.update = opts.update;\n  }\n}\n\n/**\n * Constructor parameters for `Directive`.\n *\n * @stable\n */\nexport interface DirectiveOptions<TUpdate = Record<string, unknown>, TResume = unknown> {\n  readonly goto?: string;\n  readonly resume?: TResume;\n  readonly update?: TUpdate;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAcA,IAAa,YAAb,MAA6E;CAC3E,AAAS;CACT,AAAS;CACT,AAAS;CAET,YAAY,MAA0C;AACpD,MAAI,KAAK,SAAS,OAAW,MAAK,OAAO,KAAK;AAC9C,MAAI,YAAY,QAAQ,KAAK,WAAW,OAAW,MAAK,SAAS,KAAK;AACtE,MAAI,KAAK,WAAW,OAAW,MAAK,SAAS,KAAK"}
+{"version":3,"file":"directive.js","names":[],"sources":["../../src/channels/directive.ts"],"sourcesContent":["/**\n * Workflow control-flow primitive: a single value handed to\n * `Workflow.resume(threadId, directive?)` (or returned from a node's\n * `pause(...)` resolution) carrying any combination of:\n *\n * - `goto`   - jump to a named node, bypassing the edge graph.\n *   **Destructive (workflow-09):** the restored frontier is discarded -\n *   surviving dynamic tasks, completed-but-unwalked nodes, and every\n *   pending pause record (including already-delivered pause answers)\n *   are dropped in favour of the single goto task. Use it as an\n *   operator escape hatch, not routine control flow.\n * - `resume` - value supplied to the `pause(value)` call that suspended.\n * - `update` - additional channel writes applied before the next step.\n *\n * The shape is **Graphorin's own design** (the name `Directive` is part\n * of the public API).\n *\n * @stable\n */\nexport class Directive<TUpdate = Record<string, unknown>, TResume = unknown> {\n  readonly goto?: string;\n  readonly resume?: TResume;\n  readonly update?: TUpdate;\n\n  constructor(opts: DirectiveOptions<TUpdate, TResume>) {\n    if (opts.goto !== undefined) this.goto = opts.goto;\n    if ('resume' in opts && opts.resume !== undefined) this.resume = opts.resume;\n    if (opts.update !== undefined) this.update = opts.update;\n  }\n}\n\n/**\n * Constructor parameters for `Directive`.\n *\n * @stable\n */\nexport interface DirectiveOptions<TUpdate = Record<string, unknown>, TResume = unknown> {\n  readonly goto?: string;\n  readonly resume?: TResume;\n  readonly update?: TUpdate;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBA,IAAa,YAAb,MAA6E;CAC3E,AAAS;CACT,AAAS;CACT,AAAS;CAET,YAAY,MAA0C;AACpD,MAAI,KAAK,SAAS,OAAW,MAAK,OAAO,KAAK;AAC9C,MAAI,YAAY,QAAQ,KAAK,WAAW,OAAW,MAAK,SAAS,KAAK;AACtE,MAAI,KAAK,WAAW,OAAW,MAAK,SAAS,KAAK"}

package/dist/channels/dispatch.d.ts

@@ -4,13 +4,21 @@
  * `Dispatch(nodeName, args)` values to schedule additional tasks in the
  * next execution step.
  *
- * The class is intentionally tiny — the engine inspects only the public
+ * The class is intentionally tiny - the engine inspects only the public
  * `nodeName` and `args` fields. The shape is **Graphorin's own design**
  * (the name `Dispatch` is part of the public API).
  *
  * @stable
  */
 declare class Dispatch<TArgs = unknown> {
+  /**
+   * Cross-realm brand (workflow-13): the engine's structural fallback
+   * requires this marker so a plain state object that happens to carry
+   * `nodeName` + `args` keys is treated as channel WRITES, never
+   * silently swallowed as a dispatch. A plain own property (not a
+   * symbol) so it survives `structuredClone` across worker boundaries.
+   */
+  readonly __graphorinDispatch: true;
   readonly nodeName: string;
   readonly args: TArgs;
   constructor(nodeName: string, args: TArgs);

package/dist/channels/dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.d.ts","names":[],"sources":["../../src/channels/dispatch.ts"],"sourcesContent":[],"mappings":";;AAWA;AAeA;;;;;;;;;cAfa;;iBAEI;sCAEqB;;;;;;;iBAWtB,wCAAwC,QAAQ,SAAS"}
+{"version":3,"file":"dispatch.d.ts","names":[],"sources":["../../src/channels/dispatch.ts"],"sourcesContent":[],"mappings":";;AAWA;AAuBA;;;;;;;;;cAvBa;;;;;;;;;;iBAUI;sCAEqB;;;;;;;iBAWtB,wCAAwC,QAAQ,SAAS"}

package/dist/channels/dispatch.js

@@ -4,13 +4,21 @@
 * `Dispatch(nodeName, args)` values to schedule additional tasks in the
 * next execution step.
 *
-* The class is intentionally tiny — the engine inspects only the public
+* The class is intentionally tiny - the engine inspects only the public
 * `nodeName` and `args` fields. The shape is **Graphorin's own design**
 * (the name `Dispatch` is part of the public API).
 *
 * @stable
 */
 var Dispatch = class {
+	/**
+	* Cross-realm brand (workflow-13): the engine's structural fallback
+	* requires this marker so a plain state object that happens to carry
+	* `nodeName` + `args` keys is treated as channel WRITES, never
+	* silently swallowed as a dispatch. A plain own property (not a
+	* symbol) so it survives `structuredClone` across worker boundaries.
+	*/
+	__graphorinDispatch = true;
 	nodeName;
 	args;
 	constructor(nodeName, args) {

package/dist/channels/dispatch.js.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.js","names":[],"sources":["../../src/channels/dispatch.ts"],"sourcesContent":["/**\n * Workflow dynamic-task primitive. A node returns one or more\n * `Dispatch(nodeName, args)` values to schedule additional tasks in the\n * next execution step.\n *\n * The class is intentionally tiny — the engine inspects only the public\n * `nodeName` and `args` fields. The shape is **Graphorin's own design**\n * (the name `Dispatch` is part of the public API).\n *\n * @stable\n */\nexport class Dispatch<TArgs = unknown> {\n  readonly nodeName: string;\n  readonly args: TArgs;\n\n  constructor(nodeName: string, args: TArgs) {\n    this.nodeName = nodeName;\n    this.args = args;\n  }\n}\n\n/**\n * Convenience factory equivalent to `new Dispatch(nodeName, args)`.\n *\n * @stable\n */\nexport function dispatch<TArgs>(nodeName: string, args: TArgs): Dispatch<TArgs> {\n  return new Dispatch(nodeName, args);\n}\n"],"mappings":";;;;;;;;;;;;AAWA,IAAa,WAAb,MAAuC;CACrC,AAAS;CACT,AAAS;CAET,YAAY,UAAkB,MAAa;AACzC,OAAK,WAAW;AAChB,OAAK,OAAO;;;;;;;;AAShB,SAAgB,SAAgB,UAAkB,MAA8B;AAC9E,QAAO,IAAI,SAAS,UAAU,KAAK"}
+{"version":3,"file":"dispatch.js","names":[],"sources":["../../src/channels/dispatch.ts"],"sourcesContent":["/**\n * Workflow dynamic-task primitive. A node returns one or more\n * `Dispatch(nodeName, args)` values to schedule additional tasks in the\n * next execution step.\n *\n * The class is intentionally tiny - the engine inspects only the public\n * `nodeName` and `args` fields. The shape is **Graphorin's own design**\n * (the name `Dispatch` is part of the public API).\n *\n * @stable\n */\nexport class Dispatch<TArgs = unknown> {\n  /**\n   * Cross-realm brand (workflow-13): the engine's structural fallback\n   * requires this marker so a plain state object that happens to carry\n   * `nodeName` + `args` keys is treated as channel WRITES, never\n   * silently swallowed as a dispatch. A plain own property (not a\n   * symbol) so it survives `structuredClone` across worker boundaries.\n   */\n  readonly __graphorinDispatch: true = true;\n  readonly nodeName: string;\n  readonly args: TArgs;\n\n  constructor(nodeName: string, args: TArgs) {\n    this.nodeName = nodeName;\n    this.args = args;\n  }\n}\n\n/**\n * Convenience factory equivalent to `new Dispatch(nodeName, args)`.\n *\n * @stable\n */\nexport function dispatch<TArgs>(nodeName: string, args: TArgs): Dispatch<TArgs> {\n  return new Dispatch(nodeName, args);\n}\n"],"mappings":";;;;;;;;;;;;AAWA,IAAa,WAAb,MAAuC;;;;;;;;CAQrC,AAAS,sBAA4B;CACrC,AAAS;CACT,AAAS;CAET,YAAY,UAAkB,MAAa;AACzC,OAAK,WAAW;AAChB,OAAK,OAAO;;;;;;;;AAShB,SAAgB,SAAgB,UAAkB,MAA8B;AAC9E,QAAO,IAAI,SAAS,UAAU,KAAK"}

package/dist/channels/durable.d.ts

@@ -0,0 +1,94 @@
+//#region src/channels/durable.d.ts
+/**
+ * Durable workflow primitives (D1) built on the `pause(...)` substrate:
+ *
+ * - {@link sleepUntil} / {@link sleepFor} - **durable timers**: the node
+ *   suspends with a persisted wake-at timestamp; `workflow.tick(threadId)`
+ *   (or any scheduler calling it) resumes the thread once the deadline
+ *   passes. The timer survives process restarts because it lives in the
+ *   checkpointed frontier, not in a `setTimeout`.
+ * - {@link awaitExternal} - **durable promises (awakeables)**: the node
+ *   suspends under a caller-chosen name; an external system resolves it
+ *   later via `workflow.resolveAwakeable(threadId, name, value)` and the
+ *   node receives `value` as the call's return.
+ * - {@link requestApproval} - **first-class persisted approvals**: an
+ *   awakeable specialized for human sign-off, resolved via
+ *   `workflow.approve(threadId, name, decision)`.
+ *
+ * Each helper throws the same branded `PauseSignal` that `pause(...)`
+ * throws, carrying a reserved, JSON-safe pause value the engine
+ * recognises (`kind: 'graphorin.timer' | 'graphorin.awakeable' |
+ * 'graphorin.approval'`) to stamp `wakeAt` / `name` onto the persisted
+ * pause record. On resume the body re-executes from the top and the
+ * already-delivered values replay in order (WF-2), exactly like plain
+ * `pause(...)`.
+ *
+ * @packageDocumentation
+ */
+/** Reserved pause-value kind for durable timers (D1). */
+declare const TIMER_PAUSE_KIND: "graphorin.timer";
+/** Reserved pause-value kind for awakeables / durable promises (D1). */
+declare const AWAKEABLE_PAUSE_KIND: "graphorin.awakeable";
+/** Reserved pause-value kind for persisted approvals (D1). */
+declare const APPROVAL_PAUSE_KIND: "graphorin.approval";
+/** Pause value carried by a durable-timer suspension. */
+interface TimerPauseValue {
+  readonly kind: typeof TIMER_PAUSE_KIND;
+  /** Epoch milliseconds at which the timer becomes due. */
+  readonly wakeAt: number;
+}
+/** Pause value carried by an awakeable suspension. */
+interface AwakeablePauseValue {
+  readonly kind: typeof AWAKEABLE_PAUSE_KIND;
+  /** Caller-chosen name targeted by `workflow.resolveAwakeable(...)`. */
+  readonly name: string;
+}
+/** Pause value carried by a persisted-approval suspension. */
+interface ApprovalPauseValue {
+  readonly kind: typeof APPROVAL_PAUSE_KIND;
+  /** Caller-chosen name targeted by `workflow.approve(...)`. */
+  readonly name: string;
+  /** Free-form payload surfaced to the approver (what is being approved). */
+  readonly payload?: unknown;
+}
+/** Type guard for {@link TimerPauseValue}. @stable */
+declare function isTimerPauseValue(value: unknown): value is TimerPauseValue;
+/** Type guard for {@link AwakeablePauseValue}. @stable */
+declare function isAwakeablePauseValue(value: unknown): value is AwakeablePauseValue;
+/** Type guard for {@link ApprovalPauseValue}. @stable */
+declare function isApprovalPauseValue(value: unknown): value is ApprovalPauseValue;
+/**
+ * Durably sleep until an absolute instant. Suspends the workflow thread
+ * with a persisted wake-at timestamp; `workflow.tick(threadId)` resumes
+ * it once due. Returns nothing on resume.
+ *
+ * @stable
+ */
+declare function sleepUntil(at: string | number | Date): void;
+/**
+ * Durably sleep for a relative duration (sugar over {@link sleepUntil}).
+ *
+ * @stable
+ */
+declare function sleepFor(ms: number): void;
+/**
+ * Suspend on a named durable promise. The thread stays suspended (and
+ * survives restarts) until an external caller resolves it via
+ * `workflow.resolveAwakeable(threadId, name, value)`; that `value` is
+ * returned here.
+ *
+ * @stable
+ */
+declare function awaitExternal<TResume = unknown>(name: string): TResume;
+/**
+ * Suspend on a named persisted approval. Resolved by
+ * `workflow.approve(threadId, name, decision)`; the decision is returned
+ * here. The optional payload is surfaced on the pending pause record so
+ * an approval UI can show what is being approved.
+ *
+ * @stable
+ */
+declare function requestApproval<TDecision = unknown>(name: string, payload?: unknown): TDecision;
+//#endregion
+export { APPROVAL_PAUSE_KIND, AWAKEABLE_PAUSE_KIND, ApprovalPauseValue, AwakeablePauseValue, TIMER_PAUSE_KIND, TimerPauseValue, awaitExternal, isApprovalPauseValue, isAwakeablePauseValue, isTimerPauseValue, requestApproval, sleepFor, sleepUntil };
+//# sourceMappingURL=durable.d.ts.map

package/dist/channels/durable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable.d.ts","names":[],"sources":["../../src/channels/durable.ts"],"sourcesContent":[],"mappings":";;AA8BA;AAEA;AAEA;AAGA;AAOA;AAOA;AASA;AAUA;AAUA;AAgBA;AAeA;AAeA;AAeA;;;;;;;;;;;;;;cA/Ga;;cAEA;;cAEA;;UAGI,eAAA;wBACO;;;;;UAMP,mBAAA;wBACO;;;;;UAMP,kBAAA;wBACO;;;;;;;iBAQR,iBAAA,2BAA4C;;iBAU5C,qBAAA,2BAAgD;;iBAUhD,oBAAA,2BAA+C;;;;;;;;iBAgB/C,UAAA,uBAAiC;;;;;;iBAejC,QAAA;;;;;;;;;iBAeA,gDAAgD;;;;;;;;;iBAehD,uEAAuE"}

package/dist/channels/durable.js

@@ -0,0 +1,106 @@
+import { pause } from "./pause.js";
+
+//#region src/channels/durable.ts
+/**
+* Durable workflow primitives (D1) built on the `pause(...)` substrate:
+*
+* - {@link sleepUntil} / {@link sleepFor} - **durable timers**: the node
+*   suspends with a persisted wake-at timestamp; `workflow.tick(threadId)`
+*   (or any scheduler calling it) resumes the thread once the deadline
+*   passes. The timer survives process restarts because it lives in the
+*   checkpointed frontier, not in a `setTimeout`.
+* - {@link awaitExternal} - **durable promises (awakeables)**: the node
+*   suspends under a caller-chosen name; an external system resolves it
+*   later via `workflow.resolveAwakeable(threadId, name, value)` and the
+*   node receives `value` as the call's return.
+* - {@link requestApproval} - **first-class persisted approvals**: an
+*   awakeable specialized for human sign-off, resolved via
+*   `workflow.approve(threadId, name, decision)`.
+*
+* Each helper throws the same branded `PauseSignal` that `pause(...)`
+* throws, carrying a reserved, JSON-safe pause value the engine
+* recognises (`kind: 'graphorin.timer' | 'graphorin.awakeable' |
+* 'graphorin.approval'`) to stamp `wakeAt` / `name` onto the persisted
+* pause record. On resume the body re-executes from the top and the
+* already-delivered values replay in order (WF-2), exactly like plain
+* `pause(...)`.
+*
+* @packageDocumentation
+*/
+/** Reserved pause-value kind for durable timers (D1). */
+const TIMER_PAUSE_KIND = "graphorin.timer";
+/** Reserved pause-value kind for awakeables / durable promises (D1). */
+const AWAKEABLE_PAUSE_KIND = "graphorin.awakeable";
+/** Reserved pause-value kind for persisted approvals (D1). */
+const APPROVAL_PAUSE_KIND = "graphorin.approval";
+/** Type guard for {@link TimerPauseValue}. @stable */
+function isTimerPauseValue(value) {
+	return typeof value === "object" && value !== null && value.kind === TIMER_PAUSE_KIND && typeof value.wakeAt === "number";
+}
+/** Type guard for {@link AwakeablePauseValue}. @stable */
+function isAwakeablePauseValue(value) {
+	return typeof value === "object" && value !== null && value.kind === AWAKEABLE_PAUSE_KIND && typeof value.name === "string";
+}
+/** Type guard for {@link ApprovalPauseValue}. @stable */
+function isApprovalPauseValue(value) {
+	return typeof value === "object" && value !== null && value.kind === APPROVAL_PAUSE_KIND && typeof value.name === "string";
+}
+/**
+* Durably sleep until an absolute instant. Suspends the workflow thread
+* with a persisted wake-at timestamp; `workflow.tick(threadId)` resumes
+* it once due. Returns nothing on resume.
+*
+* @stable
+*/
+function sleepUntil(at) {
+	const wakeAt = typeof at === "number" ? at : at instanceof Date ? at.getTime() : Date.parse(at);
+	if (!Number.isFinite(wakeAt)) throw new TypeError(`[graphorin/core] sleepUntil(...) got an unparseable instant: ${String(at)}`);
+	pause({
+		kind: TIMER_PAUSE_KIND,
+		wakeAt
+	});
+}
+/**
+* Durably sleep for a relative duration (sugar over {@link sleepUntil}).
+*
+* @stable
+*/
+function sleepFor(ms) {
+	if (!Number.isFinite(ms) || ms < 0) throw new TypeError(`[graphorin/core] sleepFor(...) needs a non-negative duration, got ${ms}`);
+	sleepUntil(Date.now() + ms);
+}
+/**
+* Suspend on a named durable promise. The thread stays suspended (and
+* survives restarts) until an external caller resolves it via
+* `workflow.resolveAwakeable(threadId, name, value)`; that `value` is
+* returned here.
+*
+* @stable
+*/
+function awaitExternal(name) {
+	if (typeof name !== "string" || name.length === 0) throw new TypeError("[graphorin/core] awaitExternal(name) needs a non-empty name");
+	return pause({
+		kind: AWAKEABLE_PAUSE_KIND,
+		name
+	});
+}
+/**
+* Suspend on a named persisted approval. Resolved by
+* `workflow.approve(threadId, name, decision)`; the decision is returned
+* here. The optional payload is surfaced on the pending pause record so
+* an approval UI can show what is being approved.
+*
+* @stable
+*/
+function requestApproval(name, payload) {
+	if (typeof name !== "string" || name.length === 0) throw new TypeError("[graphorin/core] requestApproval(name) needs a non-empty name");
+	return pause({
+		kind: APPROVAL_PAUSE_KIND,
+		name,
+		...payload !== void 0 ? { payload } : {}
+	});
+}
+
+//#endregion
+export { APPROVAL_PAUSE_KIND, AWAKEABLE_PAUSE_KIND, TIMER_PAUSE_KIND, awaitExternal, isApprovalPauseValue, isAwakeablePauseValue, isTimerPauseValue, requestApproval, sleepFor, sleepUntil };
+//# sourceMappingURL=durable.js.map

package/dist/channels/durable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable.js","names":[],"sources":["../../src/channels/durable.ts"],"sourcesContent":["/**\n * Durable workflow primitives (D1) built on the `pause(...)` substrate:\n *\n * - {@link sleepUntil} / {@link sleepFor} - **durable timers**: the node\n *   suspends with a persisted wake-at timestamp; `workflow.tick(threadId)`\n *   (or any scheduler calling it) resumes the thread once the deadline\n *   passes. The timer survives process restarts because it lives in the\n *   checkpointed frontier, not in a `setTimeout`.\n * - {@link awaitExternal} - **durable promises (awakeables)**: the node\n *   suspends under a caller-chosen name; an external system resolves it\n *   later via `workflow.resolveAwakeable(threadId, name, value)` and the\n *   node receives `value` as the call's return.\n * - {@link requestApproval} - **first-class persisted approvals**: an\n *   awakeable specialized for human sign-off, resolved via\n *   `workflow.approve(threadId, name, decision)`.\n *\n * Each helper throws the same branded `PauseSignal` that `pause(...)`\n * throws, carrying a reserved, JSON-safe pause value the engine\n * recognises (`kind: 'graphorin.timer' | 'graphorin.awakeable' |\n * 'graphorin.approval'`) to stamp `wakeAt` / `name` onto the persisted\n * pause record. On resume the body re-executes from the top and the\n * already-delivered values replay in order (WF-2), exactly like plain\n * `pause(...)`.\n *\n * @packageDocumentation\n */\n\nimport { pause } from './pause.js';\n\n/** Reserved pause-value kind for durable timers (D1). */\nexport const TIMER_PAUSE_KIND = 'graphorin.timer' as const;\n/** Reserved pause-value kind for awakeables / durable promises (D1). */\nexport const AWAKEABLE_PAUSE_KIND = 'graphorin.awakeable' as const;\n/** Reserved pause-value kind for persisted approvals (D1). */\nexport const APPROVAL_PAUSE_KIND = 'graphorin.approval' as const;\n\n/** Pause value carried by a durable-timer suspension. */\nexport interface TimerPauseValue {\n  readonly kind: typeof TIMER_PAUSE_KIND;\n  /** Epoch milliseconds at which the timer becomes due. */\n  readonly wakeAt: number;\n}\n\n/** Pause value carried by an awakeable suspension. */\nexport interface AwakeablePauseValue {\n  readonly kind: typeof AWAKEABLE_PAUSE_KIND;\n  /** Caller-chosen name targeted by `workflow.resolveAwakeable(...)`. */\n  readonly name: string;\n}\n\n/** Pause value carried by a persisted-approval suspension. */\nexport interface ApprovalPauseValue {\n  readonly kind: typeof APPROVAL_PAUSE_KIND;\n  /** Caller-chosen name targeted by `workflow.approve(...)`. */\n  readonly name: string;\n  /** Free-form payload surfaced to the approver (what is being approved). */\n  readonly payload?: unknown;\n}\n\n/** Type guard for {@link TimerPauseValue}. @stable */\nexport function isTimerPauseValue(value: unknown): value is TimerPauseValue {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === TIMER_PAUSE_KIND &&\n    typeof (value as { wakeAt?: unknown }).wakeAt === 'number'\n  );\n}\n\n/** Type guard for {@link AwakeablePauseValue}. @stable */\nexport function isAwakeablePauseValue(value: unknown): value is AwakeablePauseValue {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === AWAKEABLE_PAUSE_KIND &&\n    typeof (value as { name?: unknown }).name === 'string'\n  );\n}\n\n/** Type guard for {@link ApprovalPauseValue}. @stable */\nexport function isApprovalPauseValue(value: unknown): value is ApprovalPauseValue {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === APPROVAL_PAUSE_KIND &&\n    typeof (value as { name?: unknown }).name === 'string'\n  );\n}\n\n/**\n * Durably sleep until an absolute instant. Suspends the workflow thread\n * with a persisted wake-at timestamp; `workflow.tick(threadId)` resumes\n * it once due. Returns nothing on resume.\n *\n * @stable\n */\nexport function sleepUntil(at: string | number | Date): void {\n  const wakeAt = typeof at === 'number' ? at : at instanceof Date ? at.getTime() : Date.parse(at);\n  if (!Number.isFinite(wakeAt)) {\n    throw new TypeError(\n      `[graphorin/core] sleepUntil(...) got an unparseable instant: ${String(at)}`,\n    );\n  }\n  pause<TimerPauseValue, unknown>({ kind: TIMER_PAUSE_KIND, wakeAt });\n}\n\n/**\n * Durably sleep for a relative duration (sugar over {@link sleepUntil}).\n *\n * @stable\n */\nexport function sleepFor(ms: number): void {\n  if (!Number.isFinite(ms) || ms < 0) {\n    throw new TypeError(`[graphorin/core] sleepFor(...) needs a non-negative duration, got ${ms}`);\n  }\n  sleepUntil(Date.now() + ms);\n}\n\n/**\n * Suspend on a named durable promise. The thread stays suspended (and\n * survives restarts) until an external caller resolves it via\n * `workflow.resolveAwakeable(threadId, name, value)`; that `value` is\n * returned here.\n *\n * @stable\n */\nexport function awaitExternal<TResume = unknown>(name: string): TResume {\n  if (typeof name !== 'string' || name.length === 0) {\n    throw new TypeError('[graphorin/core] awaitExternal(name) needs a non-empty name');\n  }\n  return pause<AwakeablePauseValue, TResume>({ kind: AWAKEABLE_PAUSE_KIND, name });\n}\n\n/**\n * Suspend on a named persisted approval. Resolved by\n * `workflow.approve(threadId, name, decision)`; the decision is returned\n * here. The optional payload is surfaced on the pending pause record so\n * an approval UI can show what is being approved.\n *\n * @stable\n */\nexport function requestApproval<TDecision = unknown>(name: string, payload?: unknown): TDecision {\n  if (typeof name !== 'string' || name.length === 0) {\n    throw new TypeError('[graphorin/core] requestApproval(name) needs a non-empty name');\n  }\n  return pause<ApprovalPauseValue, TDecision>({\n    kind: APPROVAL_PAUSE_KIND,\n    name,\n    ...(payload !== undefined ? { payload } : {}),\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,mBAAmB;;AAEhC,MAAa,uBAAuB;;AAEpC,MAAa,sBAAsB;;AA0BnC,SAAgB,kBAAkB,OAA0C;AAC1E,QACE,OAAO,UAAU,YACjB,UAAU,QACT,MAA6B,SAAS,oBACvC,OAAQ,MAA+B,WAAW;;;AAKtD,SAAgB,sBAAsB,OAA8C;AAClF,QACE,OAAO,UAAU,YACjB,UAAU,QACT,MAA6B,SAAS,wBACvC,OAAQ,MAA6B,SAAS;;;AAKlD,SAAgB,qBAAqB,OAA6C;AAChF,QACE,OAAO,UAAU,YACjB,UAAU,QACT,MAA6B,SAAS,uBACvC,OAAQ,MAA6B,SAAS;;;;;;;;;AAWlD,SAAgB,WAAW,IAAkC;CAC3D,MAAM,SAAS,OAAO,OAAO,WAAW,KAAK,cAAc,OAAO,GAAG,SAAS,GAAG,KAAK,MAAM,GAAG;AAC/F,KAAI,CAAC,OAAO,SAAS,OAAO,CAC1B,OAAM,IAAI,UACR,gEAAgE,OAAO,GAAG,GAC3E;AAEH,OAAgC;EAAE,MAAM;EAAkB;EAAQ,CAAC;;;;;;;AAQrE,SAAgB,SAAS,IAAkB;AACzC,KAAI,CAAC,OAAO,SAAS,GAAG,IAAI,KAAK,EAC/B,OAAM,IAAI,UAAU,qEAAqE,KAAK;AAEhG,YAAW,KAAK,KAAK,GAAG,GAAG;;;;;;;;;;AAW7B,SAAgB,cAAiC,MAAuB;AACtE,KAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAC9C,OAAM,IAAI,UAAU,8DAA8D;AAEpF,QAAO,MAAoC;EAAE,MAAM;EAAsB;EAAM,CAAC;;;;;;;;;;AAWlF,SAAgB,gBAAqC,MAAc,SAA8B;AAC/F,KAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAC9C,OAAM,IAAI,UAAU,gEAAgE;AAEtF,QAAO,MAAqC;EAC1C,MAAM;EACN;EACA,GAAI,YAAY,SAAY,EAAE,SAAS,GAAG,EAAE;EAC7C,CAAC"}

package/dist/channels/index.d.ts

@@ -1,5 +1,6 @@
 import { AnyValue, Barrier, Channel, ChannelKind, Ephemeral, LatestValue, ListAggregate, Reducer, Stream, anyValue, barrier, ephemeral, latestValue, listAggregate, reducer, stream } from "./channels.js";
 import { Directive, DirectiveOptions } from "./directive.js";
 import { Dispatch, dispatch } from "./dispatch.js";
+import { APPROVAL_PAUSE_KIND, AWAKEABLE_PAUSE_KIND, ApprovalPauseValue, AwakeablePauseValue, TIMER_PAUSE_KIND, TimerPauseValue, awaitExternal, isApprovalPauseValue, isAwakeablePauseValue, isTimerPauseValue, requestApproval, sleepFor, sleepUntil } from "./durable.js";
 import { PAUSE_SIGNAL_BRAND, PauseResumeScope, PauseSignal, isPauseSignal, pause, runWithPauseResume } from "./pause.js";
-export { type AnyValue, type Barrier, type Channel, type ChannelKind, Directive, type DirectiveOptions, Dispatch, type Ephemeral, type LatestValue, type ListAggregate, PAUSE_SIGNAL_BRAND, type PauseResumeScope, PauseSignal, type Reducer, type Stream, anyValue, barrier, dispatch, ephemeral, isPauseSignal, latestValue, listAggregate, pause, reducer, runWithPauseResume, stream };
+export { APPROVAL_PAUSE_KIND, AWAKEABLE_PAUSE_KIND, type AnyValue, type ApprovalPauseValue, type AwakeablePauseValue, type Barrier, type Channel, type ChannelKind, Directive, type DirectiveOptions, Dispatch, type Ephemeral, type LatestValue, type ListAggregate, PAUSE_SIGNAL_BRAND, type PauseResumeScope, PauseSignal, type Reducer, type Stream, TIMER_PAUSE_KIND, type TimerPauseValue, anyValue, awaitExternal, barrier, dispatch, ephemeral, isApprovalPauseValue, isAwakeablePauseValue, isPauseSignal, isTimerPauseValue, latestValue, listAggregate, pause, reducer, requestApproval, runWithPauseResume, sleepFor, sleepUntil, stream };

package/dist/channels/index.js

@@ -2,5 +2,6 @@ import { anyValue, barrier, ephemeral, latestValue, listAggregate, reducer, stre
 import { Directive } from "./directive.js";
 import { Dispatch, dispatch } from "./dispatch.js";
 import { PAUSE_SIGNAL_BRAND, PauseSignal, isPauseSignal, pause, runWithPauseResume } from "./pause.js";
+import { APPROVAL_PAUSE_KIND, AWAKEABLE_PAUSE_KIND, TIMER_PAUSE_KIND, awaitExternal, isApprovalPauseValue, isAwakeablePauseValue, isTimerPauseValue, requestApproval, sleepFor, sleepUntil } from "./durable.js";
 
-export { Directive, Dispatch, PAUSE_SIGNAL_BRAND, PauseSignal, anyValue, barrier, dispatch, ephemeral, isPauseSignal, latestValue, listAggregate, pause, reducer, runWithPauseResume, stream };
+export { APPROVAL_PAUSE_KIND, AWAKEABLE_PAUSE_KIND, Directive, Dispatch, PAUSE_SIGNAL_BRAND, PauseSignal, TIMER_PAUSE_KIND, anyValue, awaitExternal, barrier, dispatch, ephemeral, isApprovalPauseValue, isAwakeablePauseValue, isPauseSignal, isTimerPauseValue, latestValue, listAggregate, pause, reducer, requestApproval, runWithPauseResume, sleepFor, sleepUntil, stream };