@agenticprimitives/fabric 0.0.0-alpha.4 → 0.0.0-alpha.41

package/CLAUDE.md

@@ -6,22 +6,9 @@ exec/case FSM. Decentralized (per-principal gateway + vault), tiered (T0/T1/T2),
 re-verified against the principal SA. Transport-agnostic core; the Cloudflare `PrincipalGatewayDO`
 adapter ships from `./cloudflare`.
 
-## Status (wave-by-wave build)
-- **W1 DONE:** exec/case FSM spine + absorbed messaging/interactions reducers (`./messaging`,
-  `./interactions` subpaths) + unified reducer + inbox projection. Golden-vectored.
-- **W2 DONE (`./cloudflare` adapter):** `PrincipalGatewayDO`, co-resident on one `state.storage.sql`
-  trust domain — `createDurableObjectSqlVault` (per-owner DEK, L2 envelope crypto); durable
-  single-writer `createDurableObjectExchangeStore` (fail-closed `applyExchangeEvent`); T0
-  `deliver`/`applyEvent`/`inbox`; T1 `AuthorityVerdictCache` + `RequestIdLedger` (§3a: cached verdict
-  A + single-use requestId); **co-resident MCP** (`invokeFast` runs the tool IN-PROCESS over the DO
-  vault after the A→B→requestId gate; heavy verify + KEK wrapper INJECTED via `GatewayDeps`); **T2
-  orchestration loop** (co-resident tools AS the `orchestration` ToolInvoker; only the LLM planner
-  injected); **signed `DeliveryReceiptV1`** (DO-local secp256k1). The ONLY subtree importing
-  `@cloudflare/workers-types`.
-- **W4 DONE:** `GatewaySurfaceCommitmentV1` (gatewayRoot preimage) + peer `DeliveryEnvelopeV1` +
-  `receiveDelivery` + `OutboxStore` store-and-forward.
-- **Next:** on-chain `atl:gatewayRoot` record (contracts, separate); `A2aTaskDO`/`SessionStoreDO`
-  absorption + `alarm()` drain; `fetch`/`alarm` e2e via vitest-pool-workers.
+## Status
+**W1–W10b DONE** — history: [`docs/architecture.md` §7a](docs/architecture.md). Next: `MessageEnvelopeV1.kind`
+(a re-signing cutover, spec 340 §R.1/§R.3); on-chain `atl:gatewayRoot`; `A2aTaskDO`/`SessionStoreDO` absorption.
 
 ## What this package owns
 - `ExchangeRecordV1` — the ONE canonical object (spine id `xch_`); two-level FSM: `ExecState`
@@ -33,12 +20,29 @@ adapter ships from `./cloudflare`.
   case reducer + typed payloads + runs (from `interactions`), delivery/admission/discovery.
 
 ## Hard rules
+- **DO-local is the serving plane; the vault is the RECORD** ([ADR-0055](../../docs/architecture/decisions/0055-vaults-are-the-canonical-system-of-record-for-content.md)
+  + amendment). `state.storage.sql` holds ordering, cursors, receipts, request-id ledgers, projections,
+  caches. Test for any new table: *if this DO were wiped, is the loss a rebuild or a bereavement?* A
+  projection must be rebuildable AND the rebuild tested (vault-first write · `rebuild()` in code · a test
+  that wipes and rebuilds) — `createVaultExchangeStore` / `createVaultInteractionStore` satisfy all three;
+  residency (**each party holds their own copy**) is [spec 316 §0b](../../specs/316-agentic-interaction-fabric.md).
+  `PrincipalGatewayDO` builds a DO-SQL vault INTERNALLY, so an adopting app MUST inject.
+- **Two serving planes; the transition is a LADDER** ([ADR-0060](../../docs/architecture/decisions/0060-incremental-gateway-adoption.md)).
+  `InteractionsDO` serves; this is the target. Ops climb `off → shadow → serving` one at a time. A clean
+  shadow proves the planes AGREE, never that either is right.
+- **The gateway authenticates its own ingress** (spec 445 §3.4): `principal`/`tier`/`actor` come only from the
+  injected `GatewayDeps.authenticate` via `admitCaller` → `AuthenticatedCaller`; no authenticator ⇒ refused.
+  `orchestrate` = verdict + per-step caveat pass + request id. Only an `active` interaction takes exchanges;
+  `openInteraction` never overwrites. Consult eligibility = current member ∩ live grant (two inputs).
 - **Authority is never satisfied by the exchange.** A request carries an `authorityRef`; approving a
   case advances the lifecycle, it NEVER unlocks a resource (spec 316 §2, ADR-0041).
 - **`ExecState` is `fulfillment`'s `TaskState`, unmodified** — `fulfillment` stays a pure leaf.
 - **Fail-closed coupling.** An `(exec, case)` pair with no mapping is a typed rejection.
 - **Transport-agnostic core.** No Cloudflare/MCP/A2A-SDK imports in `src/` — `./cloudflare` is the
   only adapter and the only `@cloudflare/workers-types` consumer.
+- **The adoption ladder's mechanics are here** (`src/adoption.ts`, spec 399 §4): `adoptionStage(ledger, op, env)`
+  (`GATEWAY_SHADOW` gates a shadow; `""` is unset), `compareServed` / `classifyDivergence`, `shouldShadow`,
+  `recordDivergence`. The ledger VALUES — which op is on which rung, and why — stay with the product.
 
 ## Boundary
 `types`, `fulfillment`, `vault`, `audit`, `delegation`, `chain-state`, `tool-policy`, `agent-naming`
@@ -46,22 +50,11 @@ adapter ships from `./cloudflare`.
 provenance` (the PROV-O projector). No back-edges; nothing imports `fabric` except `./cloudflare` + apps.
 
 ## Validate
-```bash
-pnpm --filter @agenticprimitives/fabric typecheck
-pnpm --filter @agenticprimitives/fabric test
-```
-
-## Capabilities this package participates in
-- **Messaging + Interactions** ([`specs/309`](../../specs/309-messaging-and-interactions.md)) — fabric IS
-  the substrate the messaging (envelope/inbox) + interactions (case/run) capability was absorbed into
-  (spec 316 W1); demo guide: [`apps/demo-sso-next/docs/messaging-interactions/guide.md`](../../apps/demo-sso-next/docs/messaging-interactions/guide.md).
-- **Home / agentic control plane + inbox** ([`specs/310`](../../specs/310-agentic-trust-home-control-plane-and-inbox.md)) —
-  the vault-resident inbox + control-plane projections read fabric wire types; demo guide:
-  [`apps/demo-sso-next/docs/home-inbox/guide.md`](../../apps/demo-sso-next/docs/home-inbox/guide.md).
-- Index: [`docs/architecture/cross-cutting-capabilities.md`](../../docs/architecture/cross-cutting-capabilities.md).
-
-## Spec + demo guides
-`../../specs/316-agentic-interaction-fabric.md` (architect-of-record) +
-`../../docs/architecture/agentic-interaction-fabric-target.md` + ADR-0047. Demo guides: spec 309
-`../../apps/demo-sso-next/docs/messaging-interactions/guide.md` · spec 310
-`../../apps/demo-sso-next/docs/home-inbox/guide.md`.
+`pnpm --filter @agenticprimitives/fabric typecheck && pnpm --filter @agenticprimitives/fabric test`
+
+## Capabilities, spec + guides
+Messaging + Interactions ([spec 309](../../specs/309-messaging-and-interactions.md)) · Home control plane +
+inbox ([spec 310](../../specs/310-agentic-trust-home-control-plane-and-inbox.md)) ·
+[index](../../docs/architecture/cross-cutting-capabilities.md) · [spec 316](../../specs/316-agentic-interaction-fabric.md) (architect-of-record) ·
+[target](../../docs/architecture/agentic-interaction-fabric-target.md) · ADR-0047 ·
+[fabric architecture](docs/architecture.md) (live wiring + build history).

package/README.md

@@ -1,21 +1,23 @@
 # @agenticprimitives/fabric
 
-The **Agentic Interaction Fabric** (spec 316): the A2A-native substrate that absorbs `messaging`
-(envelope/inbox) and `interactions` (case/run) into ONE canonical exchange object over a two-level
-exec/case state machine. Transport-agnostic core; the Cloudflare gateway ships as a `./cloudflare` adapter.
+> Part of **[Agentic Primitives](https://agenticprimitives.dev)** — the open-source trust substrate for agentic applications: identity that can sign, authority checked at act time, evidence the owner carries. [Developer kit](https://github.com/agentictrustlabs/agentic-primitives) · [All packages](https://agenticprimitives.dev/developers)
 
-- **One object:** `ExchangeRecordV1` — an `ExecState` transport envelope carrying an optional 11-state
-  `CaseState` business substate, coupled by an exhaustive fail-closed table.
-- **One reducer:** `applyExchangeEvent` over a single append-only event stream (message | case | artifact |
-  transport). The inbox is a projection (`projectInboxItem`).
-- **Subpaths:** `@agenticprimitives/fabric/messaging` + `/interactions` re-export the absorbed surfaces.
+Ring-0 **operational** realization of Agentic Interaction. Semantics live under `apix:`
+([ADR-0058](../../docs/architecture/decisions/0058-agentic-interaction-canonical-bounded-context.md) ·
+[spec 340](../../specs/340-agentic-interaction.md)); this package owns wire types, reducers, and the
+Cloudflare gateway adapter — not the ontology namespace (`apfab:` retired).
 
-Authority is never satisfied by the exchange — a request carries an `authorityRef`; approving a case advances
-the lifecycle, it never unlocks a resource (ADR-0041).
+Runtime doctrine still [spec 316](../../specs/316-agentic-interaction-fabric.md) /
+[ADR-0047](../../docs/architecture/decisions/0047-agent-exchange-fabric-a2a-native.md): A2A-native
+substrate absorbing messaging + interactions into one exchange object over a two-level exec/case FSM.
 
-See `CLAUDE.md` for the implementation guide and `../../specs/316-agentic-interaction-fabric.md` (architect
-of record) + `../../docs/architecture/agentic-interaction-fabric-target.md` + ADR-0047.
-Interaction-flow diagrams (person↔person, org channels, cases) + XMTP/Diode alignment:
-[`docs/architecture.md`](docs/architecture.md) · commercial comparison:
-[`docs/fabric-capabilities-vs-commercial.md`](docs/fabric-capabilities-vs-commercial.md) · gaps:
-[`docs/fabric-capability-gaps.md`](docs/fabric-capability-gaps.md).
+- **Exchange:** `ExchangeRecordV1` — `ExecState` + optional `CaseState`, fail-closed coupling.
+- **Interaction (spec 340):** `InteractionRecordV1` + profiles + context snapshots on
+  `PrincipalGatewayDO` — **in package; apps still use demo-a2a `InteractionsDO` + vault board**.
+- **Subpaths:** `@agenticprimitives/fabric/messaging` + `/interactions`.
+
+Authority is never satisfied by the exchange (ADR-0041).
+
+**Start here for app wiring + adoption matrix:** [`docs/architecture.md`](docs/architecture.md).  
+Also: `CLAUDE.md` · [target architecture](../../docs/architecture/agentic-interaction-fabric-target.md) ·
+[commercial comparison](docs/fabric-capabilities-vs-commercial.md) · [gaps](docs/fabric-capability-gaps.md).

package/dist/adoption.d.ts

@@ -0,0 +1,79 @@
+/** Which of the five candidate causes an op's move actually exercises. Naming it per op is the point of
+ *  moving one at a time: if an op diverges, its concerns say where to look, and where not to. */
+export type AdoptionConcern = 'auth' | 'projection' | 'ordering' | 'data-shape' | 'assistant';
+export type AdoptionStage = 'off' | 'shadow' | 'serving';
+export interface AdoptionEntry {
+    stage: AdoptionStage;
+    /** What moving this op puts at risk — read this first when its shadow diverges. */
+    concerns: readonly AdoptionConcern[];
+    /** Why this op is at this rung. Prose, because "it's next" and "it's blocked" look identical in a stage
+     *  field, and the difference is the whole state of the migration. */
+    note: string;
+    /**
+     * Fields that legitimately differ between the two planes because each computes them at its own instant.
+     * Declared PER OP and BEFORE evidence arrives — classifying noise after seeing a report is how a real
+     * divergence gets explained away as expected. An EMPTY list is a claim, not an omission: it asserts this
+     * op has no per-read computation, so any difference is either a race or a defect. Say why in `note`.
+     */
+    volatileFields: readonly string[];
+}
+/** The ledger: one place that says which plane serves what, so adoption is data rather than conditionals
+ *  spread across a serving object. An op absent from it is `off`: adoption is opt-in, because the failure
+ *  mode of opt-out is an op that moved because nobody remembered to stop it. */
+export type AdoptionLedger = Readonly<Record<string, AdoptionEntry>>;
+/**
+ * The stage an op runs at IN THIS DEPLOYMENT. The ledger says how far an op has climbed in the code; the
+ * deployment's `GATEWAY_SHADOW` says whether it is running the comparison at all. Both are required, and the
+ * env one defaults to OFF — constructing the gateway creates its tables, and an ungated shadow on a hot op
+ * would make that storage decision for every principal at once. Empty string is unset, not enabled
+ * (`wrangler`'s `VAR = ""` binds an empty string that `??` sails straight past).
+ */
+export declare function adoptionStage(ledger: AdoptionLedger, op: string, env?: {
+    GATEWAY_SHADOW?: string;
+}): AdoptionStage;
+export interface Divergence {
+    op: string;
+    at: string;
+    /** `equal` is recorded too. A shadow that only reports differences cannot distinguish "the planes agree"
+     *  from "the shadow never ran", and those justify opposite decisions about promoting. */
+    kind: 'equal' | 'value' | 'raced' | 'gateway-error' | 'shadow-skipped';
+    detail?: string;
+}
+/**
+ * Compare the two planes' answers. Canonical JSON with sorted keys: key ORDER is not a difference worth
+ * blocking a promotion on. Everything else counts, including `undefined` vs absent — a field that vanished
+ * is exactly the data-shape drift being watched for.
+ */
+export declare function compareServed(op: string, served: unknown, shadow: unknown, at: string): Divergence;
+/**
+ * Was an apparent divergence just the document moving between the two reads? After the shadow read, take
+ * the serving read AGAIN: `servedAgain` matches the shadow ⇒ the document moved — RACED, benign, evidence of
+ * nothing; `servedAgain` still matches the original and differs from the shadow ⇒ the planes really
+ * disagree. DELIBERATELY CONSERVATIVE: anything not provably a race stays `value`.
+ */
+export declare function classifyDivergence(input: {
+    op: string;
+    served: unknown;
+    shadow: unknown;
+    servedAgain: unknown;
+    at: string;
+}): Divergence;
+/**
+ * Should this call run its shadow? Shadowing doubles the delegated reads on the path being shadowed, so it
+ * is SAMPLED: at most one shadow per principal per `intervalMs`. Time-based rather than 1-in-N because it
+ * bounds the ADDED LOAD directly; a ratio bounds a proportion of a rate that varies with how many clients a
+ * principal has open. The first call always samples — a low-traffic principal must still contribute.
+ */
+export declare function shouldShadow(input: {
+    lastShadowAt: number | undefined;
+    now: number;
+    intervalMs: number;
+}): boolean;
+/** One shadow per principal per minute: enough to catch a systematic difference within a session, far below
+ *  a per-principal read limiter's budget even with several clients open. */
+export declare const SHADOW_INTERVAL_MS = 60000;
+/** How many divergences to keep — in MEMORY, not durable storage: diagnostics with a shelf life of one
+ *  investigation. Losing them on isolate recycle is the correct trade. */
+export declare const DIVERGENCE_BUFFER = 20;
+export declare function recordDivergence(buf: Divergence[], d: Divergence): Divergence[];
+//# sourceMappingURL=adoption.d.ts.map

package/dist/adoption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adoption.d.ts","sourceRoot":"","sources":["../src/adoption.ts"],"names":[],"mappings":"AAiBA;iGACiG;AACjG,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,YAAY,GAAG,UAAU,GAAG,YAAY,GAAG,WAAW,CAAC;AAE9F,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEzD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,aAAa,CAAC;IACrB,mFAAmF;IACnF,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;IACrC;yEACqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED;;gFAEgF;AAChF,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;AAErE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAIlH;AAID,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX;6FACyF;IACzF,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,eAAe,GAAG,gBAAgB,CAAC;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,CAKlG;AAoBD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,UAAU,CAQxI;AAID;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAAE,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAGlH;AAED;4EAC4E;AAC5E,eAAO,MAAM,kBAAkB,QAAS,CAAC;AAEzC;0EAC0E;AAC1E,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU,EAAE,CAG/E"}

package/dist/adoption.js

@@ -0,0 +1,95 @@
+// INCREMENTAL SERVING-PLANE ADOPTION — the LADDER (ADR-0060; ADR-0055 amendment). Promoted from the runtime
+// app in spec 399 W0 (§4): the ledger TYPES, the rung rule and the divergence/sampling mechanics are the
+// contract every product adopting `PrincipalGatewayDO` needs; the ledger VALUES (which op sits on which rung,
+// and why) stay with the product that owns those ops.
+//
+// THE LADDER. Every op climbs the same three rungs, and never skips one:
+//   `off`     — the incumbent plane serves. The gateway is not consulted.
+//   `shadow`  — the incumbent serves AND ITS ANSWER IS THE RESPONSE. The gateway runs alongside and the
+//               two are compared. Divergence is recorded; it never reaches the caller and never fails the
+//               request. This is the rung that converts "we think it matches" into evidence.
+//   `serving` — the gateway serves. Promotion is earned by a shadow run with no unexplained divergence,
+//               not by the code being finished.
+//
+// WHAT A RUNG DOES NOT DO. Shadowing proves the two planes AGREE; it does not prove either is right. An op
+// whose incumbent implementation is wrong will shadow perfectly clean while the gateway faithfully
+// reproduces the bug. Promotion is evidence of equivalence, not of correctness.
+/**
+ * The stage an op runs at IN THIS DEPLOYMENT. The ledger says how far an op has climbed in the code; the
+ * deployment's `GATEWAY_SHADOW` says whether it is running the comparison at all. Both are required, and the
+ * env one defaults to OFF — constructing the gateway creates its tables, and an ungated shadow on a hot op
+ * would make that storage decision for every principal at once. Empty string is unset, not enabled
+ * (`wrangler`'s `VAR = ""` binds an empty string that `??` sails straight past).
+ */
+export function adoptionStage(ledger, op, env) {
+    const stage = ledger[op]?.stage ?? 'off';
+    if (stage === 'shadow' && (env?.GATEWAY_SHADOW ?? '').trim().toLowerCase() !== 'on')
+        return 'off';
+    return stage;
+}
+/**
+ * Compare the two planes' answers. Canonical JSON with sorted keys: key ORDER is not a difference worth
+ * blocking a promotion on. Everything else counts, including `undefined` vs absent — a field that vanished
+ * is exactly the data-shape drift being watched for.
+ */
+export function compareServed(op, served, shadow, at) {
+    const a = canonical(served);
+    const b = canonical(shadow);
+    if (a === b)
+        return { op, at, kind: 'equal' };
+    return { op, at, kind: 'value', detail: firstDifference(a, b) };
+}
+function canonical(v) {
+    return JSON.stringify(v, (_k, val) => val && typeof val === 'object' && !Array.isArray(val)
+        ? Object.fromEntries(Object.entries(val).sort(([x], [y]) => x.localeCompare(y)))
+        : val) ?? 'undefined';
+}
+/** A bounded excerpt around the first difference. Bounded because a divergence report that embeds two whole
+ *  documents is a copy of the person's records in a diagnostic buffer — the thing the vault doctrine exists
+ *  to prevent, arrived at through the back door. */
+function firstDifference(a, b) {
+    let i = 0;
+    while (i < a.length && i < b.length && a[i] === b[i])
+        i++;
+    const w = 40;
+    return `@${i}: served=${JSON.stringify(a.slice(Math.max(0, i - 8), i + w))} shadow=${JSON.stringify(b.slice(Math.max(0, i - 8), i + w))}`;
+}
+/**
+ * Was an apparent divergence just the document moving between the two reads? After the shadow read, take
+ * the serving read AGAIN: `servedAgain` matches the shadow ⇒ the document moved — RACED, benign, evidence of
+ * nothing; `servedAgain` still matches the original and differs from the shadow ⇒ the planes really
+ * disagree. DELIBERATELY CONSERVATIVE: anything not provably a race stays `value`.
+ */
+export function classifyDivergence(input) {
+    const first = compareServed(input.op, input.served, input.shadow, input.at);
+    if (first.kind === 'equal')
+        return first;
+    const settled = compareServed(input.op, input.servedAgain, input.shadow, input.at);
+    if (settled.kind === 'equal') {
+        return { op: input.op, at: input.at, kind: 'raced', detail: 'document changed between the serving read and the shadow read' };
+    }
+    return first;
+}
+// ── Sampling ──────────────────────────────────────────────────────────────────────────────────────────
+/**
+ * Should this call run its shadow? Shadowing doubles the delegated reads on the path being shadowed, so it
+ * is SAMPLED: at most one shadow per principal per `intervalMs`. Time-based rather than 1-in-N because it
+ * bounds the ADDED LOAD directly; a ratio bounds a proportion of a rate that varies with how many clients a
+ * principal has open. The first call always samples — a low-traffic principal must still contribute.
+ */
+export function shouldShadow(input) {
+    if (input.lastShadowAt === undefined)
+        return true;
+    return input.now - input.lastShadowAt >= input.intervalMs;
+}
+/** One shadow per principal per minute: enough to catch a systematic difference within a session, far below
+ *  a per-principal read limiter's budget even with several clients open. */
+export const SHADOW_INTERVAL_MS = 60_000;
+/** How many divergences to keep — in MEMORY, not durable storage: diagnostics with a shelf life of one
+ *  investigation. Losing them on isolate recycle is the correct trade. */
+export const DIVERGENCE_BUFFER = 20;
+export function recordDivergence(buf, d) {
+    buf.push(d);
+    return buf.length > DIVERGENCE_BUFFER ? buf.slice(-DIVERGENCE_BUFFER) : buf;
+}
+//# sourceMappingURL=adoption.js.map

package/dist/adoption.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adoption.js","sourceRoot":"","sources":["../src/adoption.ts"],"names":[],"mappings":"AAAA,4GAA4G;AAC5G,yGAAyG;AACzG,8GAA8G;AAC9G,sDAAsD;AACtD,EAAE;AACF,yEAAyE;AACzE,0EAA0E;AAC1E,wGAAwG;AACxG,0GAA0G;AAC1G,6FAA6F;AAC7F,wGAAwG;AACxG,gDAAgD;AAChD,EAAE;AACF,2GAA2G;AAC3G,mGAAmG;AACnG,gFAAgF;AA6BhF;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,MAAsB,EAAE,EAAU,EAAE,GAAiC;IACjG,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,EAAE,KAAK,IAAI,KAAK,CAAC;IACzC,IAAI,KAAK,KAAK,QAAQ,IAAI,CAAC,GAAG,EAAE,cAAc,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAClG,OAAO,KAAK,CAAC;AACf,CAAC;AAaD;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,EAAU,EAAE,MAAe,EAAE,MAAe,EAAE,EAAU;IACpF,MAAM,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;IAC5B,MAAM,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;IAC5B,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAC9C,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;AAClE,CAAC;AAED,SAAS,SAAS,CAAC,CAAU;IAC3B,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,CACnC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;QACnD,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,GAA8B,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3G,CAAC,CAAC,GAAG,CACR,IAAI,WAAW,CAAC;AACnB,CAAC;AAED;;oDAEoD;AACpD,SAAS,eAAe,CAAC,CAAS,EAAE,CAAS;IAC3C,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAAE,CAAC,EAAE,CAAC;IAC1D,MAAM,CAAC,GAAG,EAAE,CAAC;IACb,OAAO,IAAI,CAAC,YAAY,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;AAC5I,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAyF;IAC1H,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;IAC5E,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;QAAE,OAAO,KAAK,CAAC;IACzC,MAAM,OAAO,GAAG,aAAa,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;IACnF,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC7B,OAAO,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,+DAA+D,EAAE,CAAC;IAChI,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,yGAAyG;AAEzG;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,KAA4E;IACvG,IAAI,KAAK,CAAC,YAAY,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAClD,OAAO,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,YAAY,IAAI,KAAK,CAAC,UAAU,CAAC;AAC5D,CAAC;AAED;4EAC4E;AAC5E,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC;AAEzC;0EAC0E;AAC1E,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAEpC,MAAM,UAAU,gBAAgB,CAAC,GAAiB,EAAE,CAAa;IAC/D,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACZ,OAAO,GAAG,CAAC,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AAC9E,CAAC"}

package/dist/case-emissions.d.ts

@@ -0,0 +1,95 @@
+import type { CanonicalAgentId } from '@agenticprimitives/types';
+import type { CommitmentRecordV1, CommitmentTransition, DecisionRecordV1, DecisionTransition, MachineRejection } from './interaction-machines.js';
+import type { CaseFsmFields, CaseTransition, CaseTransitionEventV1 } from './case-machine.js';
+/**
+ * A record this emission needs to exist before its transition can land, given in its INITIAL state.
+ *
+ * Both machines refuse a transition out of a state the record is not in — `grant` is `pending →
+ * granted`, `void` is `proposed|active → void`. So an emission that only carried a transition would be
+ * unapplicable on the first move of a case that never had a decision record. The applier creates the
+ * record if absent, in exactly this state, and then applies the transition through the machine. It
+ * does NOT create it in the resulting state; that would be the state-assignment bypass this module
+ * exists to avoid.
+ */
+export interface DecisionSeedV1 {
+    decisionId: string;
+    decider: CanonicalAgentId;
+    subject: string;
+    expiresAt?: string;
+}
+export interface CommitmentSeedV1 {
+    commitmentId: string;
+    debtor: CanonicalAgentId;
+    creditor: CanonicalAgentId;
+}
+export interface CaseEmissionsV1 {
+    decision?: {
+        seed: DecisionSeedV1;
+        transition: DecisionTransition;
+        createIfAbsent: boolean;
+    };
+    commitment?: {
+        seed: CommitmentSeedV1;
+        transition: CommitmentTransition;
+        createIfAbsent: boolean;
+    };
+}
+/**
+ * Deterministic ids, derived from the case id.
+ *
+ * Deliberately not random and not clock-derived: a case transition may be replayed (the interaction
+ * store is idempotent on `idempotencyKey`, and `processDue` re-runs sweeps), and a fresh id per replay
+ * would fork one determination into several. Same case ⇒ same decision ⇒ the second application is a
+ * no-op against a terminal state rather than a duplicate record.
+ */
+export declare function decisionIdForCase(caseId: string): string;
+export declare function commitmentIdForCase(caseId: string): string;
+/**
+ * Derive what a case transition emits. Pure, and total over `CaseTransition` — a transition with no
+ * emission returns `{}` rather than throwing, because most transitions genuinely emit nothing.
+ *
+ * Call this only for a transition the case machine ACCEPTED. It does not re-check legality: duplicating
+ * the case machine's role and ordering rules here would create a second, quietly diverging copy of them.
+ */
+export declare function caseTransitionEmissions(current: CaseFsmFields, event: CaseTransitionEventV1): CaseEmissionsV1;
+/** The case transitions that emit something. Exported so a test can assert the set rather than
+ *  restate it, and so a newly-added emitting transition shows up in a diff of this constant. */
+export declare const EMITTING_CASE_TRANSITIONS: readonly CaseTransition[];
+/** Seed a decision record in its INITIAL state. Never the resulting state — see `DecisionSeedV1`. */
+export declare function seedDecision(seed: DecisionSeedV1, at: string): DecisionRecordV1;
+/** Seed a commitment record in its INITIAL state. */
+export declare function seedCommitment(seed: CommitmentSeedV1, at: string): CommitmentRecordV1;
+/** Why an emission produced no record. `absent` is the deliberate `void`-without-a-commitment case;
+ *  the others are the owning machine's own typed rejection, surfaced rather than swallowed. */
+export type EmissionOutcome<T> = {
+    applied: true;
+    record: T;
+} | {
+    applied: false;
+    reason: MachineRejection | 'absent';
+};
+export interface CaseEmissionApplyResult {
+    decision?: EmissionOutcome<DecisionRecordV1>;
+    commitment?: EmissionOutcome<CommitmentRecordV1>;
+}
+/**
+ * Apply emissions through the OWNING machines.
+ *
+ * The point of this function is what it does not do: it never assigns a state. A record is created
+ * only in its initial state and every move goes through `applyDecisionTransition` /
+ * `applyCommitmentTransition`, so their role and ordering checks still hold — the creditor still
+ * voids, the decider still decides.
+ *
+ * Rejections are RETURNED, not thrown and not swallowed. A caller that persists these must treat a
+ * rejected emission as a fact about the record it failed to write, because a silent no-op here is
+ * indistinguishable from success and would leave a case whose determination was never recorded
+ * looking exactly like one whose determination was.
+ */
+export declare function applyCaseEmissions(emissions: CaseEmissionsV1, existing: {
+    decision: DecisionRecordV1 | null;
+    commitment: CommitmentRecordV1 | null;
+}, event: {
+    actor: CanonicalAgentId;
+    at: string;
+}): CaseEmissionApplyResult;
+//# sourceMappingURL=case-emissions.d.ts.map

package/dist/case-emissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"case-emissions.d.ts","sourceRoot":"","sources":["../src/case-emissions.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,OAAO,KAAK,EACV,kBAAkB,EAClB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAEjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE9F;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE;QAAE,IAAI,EAAE,cAAc,CAAC;QAAC,UAAU,EAAE,kBAAkB,CAAC;QAAC,cAAc,EAAE,OAAO,CAAA;KAAE,CAAC;IAC7F,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,gBAAgB,CAAC;QAAC,UAAU,EAAE,oBAAoB,CAAC;QAAC,cAAc,EAAE,OAAO,CAAA;KAAE,CAAC;CACpG;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1D;AAqGD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,qBAAqB,GAC3B,eAAe,CAmBjB;AAED;gGACgG;AAChG,eAAO,MAAM,yBAAyB,EAAE,SAAS,cAAc,EAE1C,CAAC;AAEtB,qGAAqG;AACrG,wBAAgB,YAAY,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,GAAG,gBAAgB,CAS/E;AAED,qDAAqD;AACrD,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE,EAAE,EAAE,MAAM,GAAG,kBAAkB,CAQrF;AAED;+FAC+F;AAC/F,MAAM,MAAM,eAAe,CAAC,CAAC,IACzB;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,GAC5B;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,gBAAgB,GAAG,QAAQ,CAAA;CAAE,CAAC;AAE5D,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,eAAe,CAAC,gBAAgB,CAAC,CAAC;IAC7C,UAAU,CAAC,EAAE,eAAe,CAAC,kBAAkB,CAAC,CAAC;CAClD;AAeD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE;IAAE,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAAC,UAAU,EAAE,kBAAkB,GAAG,IAAI,CAAA;CAAE,EACtF,KAAK,EAAE;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC7C,uBAAuB,CAsBzB"}

package/dist/case-emissions.js

@@ -0,0 +1,208 @@
+// spec 340 W10 — what a case transition EMITS into the decision and commitment machines.
+//
+// §R.2 established that the eleven `CaseState`s were never one machine: `approved`/`denied`/`expired`
+// are **decisions**, `revoked` is what happens to a **commitment**, and the rest are **execution**. One
+// field was answering three questions with three different signers, which is why a case could be
+// `denied` while a commitment stayed outstanding with nowhere to record it.
+//
+// §R.3 names the order this has to happen in: the case flow EMITS decision and commitment records
+// FIRST, and only then can `CaseState` shrink to execution. Deleting the enum before this module
+// existed would have replaced working behaviour with machines nothing writes to — a regression wearing
+// the costume of a cleanup.
+//
+// WHAT THIS MODULE IS NOT. It derives records; it does not move state. Every emission is expressed as a
+// TRANSITION to be applied by the owning machine, never as a state assignment, so the machines keep
+// their role checks — the creditor still discharges, the decider still decides, and persistence does
+// not become a bypass (ADR-0058 §15, and the same rule `createDurableObjectInteractionStore` follows).
+//
+// NONE OF THIS IS AUTHORITY. A `grant` here records that a determination was made. It permits nothing:
+// the authority re-check happens at the moment of acting regardless of what any of these records say
+// (ADR-0041, ADR-0043).
+import { applyCommitmentTransition, applyDecisionTransition } from './interaction-machines.js';
+/**
+ * Deterministic ids, derived from the case id.
+ *
+ * Deliberately not random and not clock-derived: a case transition may be replayed (the interaction
+ * store is idempotent on `idempotencyKey`, and `processDue` re-runs sweeps), and a fresh id per replay
+ * would fork one determination into several. Same case ⇒ same decision ⇒ the second application is a
+ * no-op against a terminal state rather than a duplicate record.
+ */
+export function decisionIdForCase(caseId) {
+    return `dec_${caseId}`;
+}
+export function commitmentIdForCase(caseId) {
+    return `cmt_${caseId}`;
+}
+/**
+ * WHO IS THE CREDITOR. The approving side — `responder` / `resource-owner`.
+ *
+ * This is a derivation, not a preference. Case `revoke` is signed by `responder`/`resource-owner`, and
+ * the only creditor-only commitment transition is `void`. Under the opposite assignment (debtor =
+ * responder, creditor = requester) an issuer revoking what it granted has no legal transition at all,
+ * which contradicts a case machine that plainly permits it. One reading is self-consistent; the other
+ * is not. `issue-credential` corroborates it: its signers are `resource-owner`/`responder` and
+ * `activate` is likewise creditor-only.
+ */
+function creditorOf(c) {
+    return c.resourceOwner ?? c.responder;
+}
+/**
+ * WHO IS THE DECIDER — and why it is not one rule.
+ *
+ * For `approve`/`deny` it is `event.actor`: the party that actually made the determination. It cannot
+ * be the deciding ROLE, because the case machine accepts EITHER `responder` or `resource-owner` for
+ * those moves while the decision machine requires exactly `decision.decider`. Pinning the decider to
+ * the role would make a responder-signed approval on a case that also has a resource-owner emit a
+ * decision the decision machine then rejects as `unauthorized-actor` — a case that succeeded and an
+ * emission that silently could not land.
+ *
+ * For `expire` it is the creditor. `expire` is signed by role `any` (time is not an actor, so a
+ * deterministic sweep may record it), and attributing an expiry to whichever party happened to run the
+ * sweep would put a determination in someone's name they never made. The decision machine skips the
+ * actor check for `expire` precisely so this is possible.
+ */
+function decisionSeed(c, event, transition) {
+    return {
+        decisionId: decisionIdForCase(c.id),
+        decider: transition === 'expire' ? creditorOf(c) : event.actor,
+        subject: c.id,
+        expiresAt: c.expiresAt,
+    };
+}
+function commitmentSeed(c) {
+    return {
+        commitmentId: commitmentIdForCase(c.id),
+        debtor: c.requester,
+        creditor: creditorOf(c),
+    };
+}
+/**
+ * The mapping, stated once.
+ *
+ * `deliver-credential` is deliberately ABSENT. It completes the case, and completing the work does not
+ * discharge the obligation — that is exactly the collapse ADR-0058 §15 forbids, and `fabric` already
+ * refuses to draw that edge implicitly (`mayDischargeOnExecution` exists so a profile has to choose it
+ * in a diff). A creditor who wants to discharge does so as its own act, against the commitment
+ * machine, with its own signature.
+ *
+ * `fail` is absent for the same reason in the other direction: a failed execution is not a refusal by
+ * anyone, and recording it as one would attribute a determination nobody made.
+ */
+const EMITTING_TRANSITIONS = {
+    approve: { decision: 'grant' },
+    deny: { decision: 'refuse' },
+    expire: { decision: 'expire' },
+    // Issuing is what creates the obligation, so this emission may bring the commitment into being.
+    'issue-credential': { commitment: 'activate' },
+    revoke: { commitment: 'void' },
+};
+/**
+ * Whether an emission may bring its record into existence.
+ *
+ * Deciding CREATES a determination — there was no prior record and the act of approving or denying is
+ * what makes one. Issuing likewise creates the obligation.
+ *
+ * `void` must not. `revoke` is legal from any non-terminal case, including `submitted`, where nothing
+ * was ever approved and no obligation ever arose. Seeding a commitment there so it could immediately
+ * be voided would write a record asserting an obligation existed and was released, when neither
+ * happened — inventing history to satisfy a type. Absent a commitment, this emission is a no-op, and
+ * the case's own `revoked` state remains the honest record of what occurred.
+ */
+const CREATES_ITS_RECORD = {
+    grant: true,
+    refuse: true,
+    expire: true,
+    activate: true,
+    withdraw: false,
+    supersede: false,
+    'claim-fulfilment': false,
+    'dispute-claim': false,
+    discharge: false,
+    'assert-breach': false,
+    void: false,
+};
+/**
+ * Derive what a case transition emits. Pure, and total over `CaseTransition` — a transition with no
+ * emission returns `{}` rather than throwing, because most transitions genuinely emit nothing.
+ *
+ * Call this only for a transition the case machine ACCEPTED. It does not re-check legality: duplicating
+ * the case machine's role and ordering rules here would create a second, quietly diverging copy of them.
+ */
+export function caseTransitionEmissions(current, event) {
+    const spec = EMITTING_TRANSITIONS[event.transition];
+    if (!spec)
+        return {};
+    const out = {};
+    if (spec.decision) {
+        out.decision = {
+            seed: decisionSeed(current, event, spec.decision),
+            transition: spec.decision,
+            createIfAbsent: CREATES_ITS_RECORD[spec.decision],
+        };
+    }
+    if (spec.commitment) {
+        out.commitment = {
+            seed: commitmentSeed(current),
+            transition: spec.commitment,
+            createIfAbsent: CREATES_ITS_RECORD[spec.commitment],
+        };
+    }
+    return out;
+}
+/** The case transitions that emit something. Exported so a test can assert the set rather than
+ *  restate it, and so a newly-added emitting transition shows up in a diff of this constant. */
+export const EMITTING_CASE_TRANSITIONS = Object.keys(EMITTING_TRANSITIONS);
+/** Seed a decision record in its INITIAL state. Never the resulting state — see `DecisionSeedV1`. */
+export function seedDecision(seed, at) {
+    return {
+        decisionId: seed.decisionId,
+        state: 'pending',
+        decider: seed.decider,
+        subject: seed.subject,
+        expiresAt: seed.expiresAt,
+        updatedAt: at,
+    };
+}
+/** Seed a commitment record in its INITIAL state. */
+export function seedCommitment(seed, at) {
+    return {
+        commitmentId: seed.commitmentId,
+        state: 'proposed',
+        debtor: seed.debtor,
+        creditor: seed.creditor,
+        updatedAt: at,
+    };
+}
+function applyOne(emission, existing, create, apply) {
+    if (!emission)
+        return undefined;
+    const record = existing ?? (emission.createIfAbsent ? create() : null);
+    if (record === null)
+        return { applied: false, reason: 'absent' };
+    const res = apply(record, emission.transition);
+    return res.ok ? { applied: true, record: res.next } : { applied: false, reason: res.reason };
+}
+/**
+ * Apply emissions through the OWNING machines.
+ *
+ * The point of this function is what it does not do: it never assigns a state. A record is created
+ * only in its initial state and every move goes through `applyDecisionTransition` /
+ * `applyCommitmentTransition`, so their role and ordering checks still hold — the creditor still
+ * voids, the decider still decides.
+ *
+ * Rejections are RETURNED, not thrown and not swallowed. A caller that persists these must treat a
+ * rejected emission as a fact about the record it failed to write, because a silent no-op here is
+ * indistinguishable from success and would leave a case whose determination was never recorded
+ * looking exactly like one whose determination was.
+ */
+export function applyCaseEmissions(emissions, existing, event) {
+    const out = {};
+    const decision = applyOne(emissions.decision, existing.decision, () => seedDecision(emissions.decision.seed, event.at), (record, transition) => applyDecisionTransition(record, { transition, actor: event.actor, at: event.at }));
+    if (decision)
+        out.decision = decision;
+    const commitment = applyOne(emissions.commitment, existing.commitment, () => seedCommitment(emissions.commitment.seed, event.at), (record, transition) => applyCommitmentTransition(record, { transition, actor: event.actor, at: event.at }));
+    if (commitment)
+        out.commitment = commitment;
+    return out;
+}
+//# sourceMappingURL=case-emissions.js.map

package/dist/case-emissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"case-emissions.js","sourceRoot":"","sources":["../src/case-emissions.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,EAAE;AACF,sGAAsG;AACtG,wGAAwG;AACxG,iGAAiG;AACjG,4EAA4E;AAC5E,EAAE;AACF,kGAAkG;AAClG,iGAAiG;AACjG,uGAAuG;AACvG,4BAA4B;AAC5B,EAAE;AACF,wGAAwG;AACxG,oGAAoG;AACpG,qGAAqG;AACrG,uGAAuG;AACvG,EAAE;AACF,uGAAuG;AACvG,qGAAqG;AACrG,wBAAwB;AAGxB,OAAO,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAuC/F;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC9C,OAAO,OAAO,MAAM,EAAE,CAAC;AACzB,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAc;IAChD,OAAO,OAAO,MAAM,EAAE,CAAC;AACzB,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,UAAU,CAAC,CAAgB;IAClC,OAAO,CAAC,CAAC,aAAa,IAAI,CAAC,CAAC,SAAS,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAS,YAAY,CACnB,CAAgB,EAChB,KAA4B,EAC5B,UAA8B;IAE9B,OAAO;QACL,UAAU,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC;QACnC,OAAO,EAAE,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK;QAC9D,OAAO,EAAE,CAAC,CAAC,EAAE;QACb,SAAS,EAAE,CAAC,CAAC,SAAS;KACvB,CAAC;AACJ,CAAC;AAED,SAAS,cAAc,CAAC,CAAgB;IACtC,OAAO;QACL,YAAY,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAAC;QACvC,MAAM,EAAE,CAAC,CAAC,SAAS;QACnB,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC;KACxB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,oBAAoB,GAEtB;IACF,OAAO,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE;IAC9B,IAAI,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE;IAC5B,MAAM,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE;IAC9B,gGAAgG;IAChG,kBAAkB,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE;IAC9C,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE;CAC/B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,kBAAkB,GAA+D;IACrF,KAAK,EAAE,IAAI;IACX,MAAM,EAAE,IAAI;IACZ,MAAM,EAAE,IAAI;IACZ,QAAQ,EAAE,IAAI;IACd,QAAQ,EAAE,KAAK;IACf,SAAS,EAAE,KAAK;IAChB,kBAAkB,EAAE,KAAK;IACzB,eAAe,EAAE,KAAK;IACtB,SAAS,EAAE,KAAK;IAChB,eAAe,EAAE,KAAK;IACtB,IAAI,EAAE,KAAK;CACZ,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CACrC,OAAsB,EACtB,KAA4B;IAE5B,MAAM,IAAI,GAAG,oBAAoB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACpD,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,CAAC;IACrB,MAAM,GAAG,GAAoB,EAAE,CAAC;IAChC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClB,GAAG,CAAC,QAAQ,GAAG;YACb,IAAI,EAAE,YAAY,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC;YACjD,UAAU,EAAE,IAAI,CAAC,QAAQ;YACzB,cAAc,EAAE,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC;SAClD,CAAC;IACJ,CAAC;IACD,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;QACpB,GAAG,CAAC,UAAU,GAAG;YACf,IAAI,EAAE,cAAc,CAAC,OAAO,CAAC;YAC7B,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,cAAc,EAAE,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC;SACpD,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;gGACgG;AAChG,MAAM,CAAC,MAAM,yBAAyB,GAA8B,MAAM,CAAC,IAAI,CAC7E,oBAAoB,CACD,CAAC;AAEtB,qGAAqG;AACrG,MAAM,UAAU,YAAY,CAAC,IAAoB,EAAE,EAAU;IAC3D,OAAO;QACL,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,KAAK,EAAE,SAAS;QAChB,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,SAAS,EAAE,EAAE;KACd,CAAC;AACJ,CAAC;AAED,qDAAqD;AACrD,MAAM,UAAU,cAAc,CAAC,IAAsB,EAAE,EAAU;IAC/D,OAAO;QACL,YAAY,EAAE,IAAI,CAAC,YAAY;QAC/B,KAAK,EAAE,UAAU;QACjB,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,SAAS,EAAE,EAAE;KACd,CAAC;AACJ,CAAC;AAaD,SAAS,QAAQ,CACf,QAAgF,EAChF,QAAkB,EAClB,MAAe,EACf,KAAsD;IAEtD,IAAI,CAAC,QAAQ;QAAE,OAAO,SAAS,CAAC;IAChC,MAAM,MAAM,GAAG,QAAQ,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACvE,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IACjE,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC/C,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC;AAC/F,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,kBAAkB,CAChC,SAA0B,EAC1B,QAAsF,EACtF,KAA8C;IAE9C,MAAM,GAAG,GAA4B,EAAE,CAAC;IAExC,MAAM,QAAQ,GAAG,QAAQ,CACvB,SAAS,CAAC,QAAQ,EAClB,QAAQ,CAAC,QAAQ,EACjB,GAAG,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,QAAS,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,EACtD,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CACrB,uBAAuB,CAAC,MAAM,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CACpF,CAAC;IACF,IAAI,QAAQ;QAAE,GAAG,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAEtC,MAAM,UAAU,GAAG,QAAQ,CACzB,SAAS,CAAC,UAAU,EACpB,QAAQ,CAAC,UAAU,EACnB,GAAG,EAAE,CAAC,cAAc,CAAC,SAAS,CAAC,UAAW,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,EAC1D,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CACrB,yBAAyB,CAAC,MAAM,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CACtF,CAAC;IACF,IAAI,UAAU;QAAE,GAAG,CAAC,UAAU,GAAG,UAAU,CAAC;IAE5C,OAAO,GAAG,CAAC;AACb,CAAC"}