@ixo/decision-oracle 0.0.0-stage → 0.2.1

package/dist/testing/samples.js

@@ -0,0 +1,92 @@
+/**
+ * The three sample builders — a claim, a work order and a ctx, each complete enough to run the
+ * runner against and short enough to write inline in a test. They exist so a handler test says
+ * what it is ABOUT ("a claim whose `reference` is ABC", "a rubric declaring one scored source")
+ * and nothing else: every field a handler doesn't care about gets a valid, boring default.
+ *
+ * Node-safe, like the rest of `./testing`: `PulledClaim` and `Attachment` arrive as TYPES only —
+ * their modules reach the chain and must never be pulled into a provider's node test suite.
+ */
+/**
+ * A pulled claim whose body is `answers`. `lane: "cellnode"`, `media: null` (the no-store posture):
+ * there is no store to fetch bytes from in a test — `fakeTools`'s `attachments` map is where bytes
+ * come from instead.
+ */
+export function sampleClaim(answers, opts = {}) {
+    const attachments = (opts.attachments ?? []).map((att) => ({
+        question: att.question,
+        name: att.name,
+        mediaType: att.mediaType,
+        ...(att.cid !== undefined ? { cid: att.cid } : {}),
+        url: att.url ?? "",
+    }));
+    return {
+        claimId: opts.claimId ?? "claim1",
+        collectionId: opts.collectionId ?? "1",
+        network: "devnet",
+        lane: "cellnode",
+        metadata: {
+            agentDid: null,
+            agentAddress: opts.agentAddress ?? null,
+            schemaType: null,
+            submissionDate: opts.submissionDate ?? null,
+            amount: opts.amount ?? [],
+            // An ordinary (non-escrow) unpaid claim by default — the lane that reads as "nothing special".
+            payment: {
+                useIntent: opts.useIntent ?? false,
+                guaranteed: false,
+                amount: opts.amount ?? [],
+            },
+            evaluation: null,
+        },
+        body: answers,
+        attachments,
+        media: null,
+    };
+}
+/**
+ * The engine's work order for a rubric that declares exactly the names you list — the shape
+ * `validateFacts` holds a producer to. Only `expect` (a source) and `instructions` (a check) have
+ * to be given: the rest is the call detail the STOCK lane would need, and a handler under test
+ * usually ignores it.
+ */
+export function sampleManifest(decl = {}) {
+    const ext = {};
+    for (const [name, declared] of Object.entries(decl.ext ?? {})) {
+        ext[name] = {
+            onError: "review",
+            endpoint: `https://source.example/${name}`,
+            audience: "did:web:source.example",
+            send: {},
+            usedBy: [],
+            ...declared,
+        };
+    }
+    const ai = {};
+    for (const [name, declared] of Object.entries(decl.ai ?? {})) {
+        ai[name] = { expect: "boolean", onError: "review", send: {}, usedBy: [], ...declared };
+    }
+    return {
+        rubricId: "0".repeat(64),
+        formProof: { pinned: "p", live: "p", drifted: false },
+        ext,
+        ai,
+        hasAiChecks: Object.keys(ai).length > 0,
+        ctx: decl.ctx ?? [],
+        fields: decl.fields ?? [],
+        derived: decl.derived ?? [],
+        // Keys only when declared: the runner produces a `unique`/`frequency` fact iff one is here.
+        ...(decl.unique ? { unique: decl.unique } : {}),
+        ...(decl.frequency ? { frequency: decl.frequency } : {}),
+    };
+}
+/** The build's frozen clock read and collection window — one fixed instant, so digests repeat. */
+export function sampleCtx(over = {}) {
+    return {
+        now: "2026-01-01T00:00:00.000Z",
+        collection: { startDate: null, endDate: null },
+        claim: { submitter: null, submitterAddress: null, submissionDate: null },
+        ...over,
+    };
+}
+//# sourceMappingURL=samples.js.map

package/dist/testing/samples.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"samples.js","sourceRoot":"","sources":["../../src/testing/samples.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAiCH;;;;GAIG;AACH,MAAM,UAAU,WAAW,CACzB,OAAgC,EAChC,IAAI,GAAuB,EAAE;IAE7B,MAAM,WAAW,GAAiB,CAAC,IAAI,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACvE,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAClD,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,EAAE;KACnB,CAAC,CAAC,CAAC;IACJ,OAAO;QACL,OAAO,EAAE,IAAI,CAAC,OAAO,IAAI,QAAQ;QACjC,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,GAAG;QACtC,OAAO,EAAE,QAAQ;QACjB,IAAI,EAAE,UAAU;QAChB,QAAQ,EAAE;YACR,QAAQ,EAAE,IAAI;YACd,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,IAAI;YACvC,UAAU,EAAE,IAAI;YAChB,cAAc,EAAE,IAAI,CAAC,cAAc,IAAI,IAAI;YAC3C,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,EAAE;YACzB,+FAA+F;YAC/F,OAAO,EAAE;gBACP,SAAS,EAAE,IAAI,CAAC,SAAS,IAAI,KAAK;gBAClC,UAAU,EAAE,KAAK;gBACjB,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,EAAE;aAC1B;YACD,UAAU,EAAE,IAAI;SACjB;QACD,IAAI,EAAE,OAAO;QACb,WAAW;QACX,KAAK,EAAE,IAAI;KACZ,CAAC;AACJ,CAAC;AAYD;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,IAAI,GAAuB,EAAE;IAC1D,MAAM,GAAG,GAAgC,EAAE,CAAC;IAC5C,KAAK,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,CAAC;QAC9D,GAAG,CAAC,IAAI,CAAC,GAAG;YACV,OAAO,EAAE,QAAQ;YACjB,QAAQ,EAAE,0BAA0B,IAAI,EAAE;YAC1C,QAAQ,EAAE,wBAAwB;YAClC,IAAI,EAAE,EAAE;YACR,MAAM,EAAE,EAAE;YACV,GAAG,QAAQ;SACZ,CAAC;IACJ,CAAC;IACD,MAAM,EAAE,GAA+B,EAAE,CAAC;IAC1C,KAAK,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;QAC7D,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,QAAQ,EAAE,CAAC;IACzF,CAAC;IACD,OAAO;QACL,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QACxB,SAAS,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE;QACrD,GAAG;QACH,EAAE;QACF,WAAW,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC;QACvC,GAAG,EAAE,IAAI,CAAC,GAAG,IAAI,EAAE;QACnB,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,EAAE;QACzB,OAAO,EAAE,IAAI,CAAC,OAAO,IAAI,EAAE;QAC3B,4FAA4F;QAC5F,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/C,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACzD,CAAC;AACJ,CAAC;AAED,kGAAkG;AAClG,MAAM,UAAU,SAAS,CAAC,IAAI,GAAsB,EAAE;IACpD,OAAO;QACL,GAAG,EAAE,0BAA0B;QAC/B,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE;QAC9C,KAAK,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE;QACxE,GAAG,IAAI;KACR,CAAC;AACJ,CAAC"}

package/dist/workflows/claim-ingest.d.ts

@@ -0,0 +1,250 @@
+/**
+ * Durable, idempotent claim ingestion (README "How a claim flows" steps 3–6). One instance per claim — the
+ * instance id is the claimId itself when Cloudflare accepts it, else its sha256 (see lib/ids.ts) —
+ * each step checkpointed and auto-retried, so a crash/redeploy/transient failure never re-does
+ * work or drops a claim.
+ *
+ * THE WORKFLOW OWNS ITS LEDGER ROW — one writer, whole lifecycle:
+ *   step "record-queued"   → upsert the `claim_ingests` row as `queued` (durable: the row exists
+ *                            iff the instance started, so nothing can ever strand a row)
+ *   step "evaluate"        → mark the row `processing` (so a later attempt knows one ran), then
+ *                            ONE pull (chain metadata + body + attachment descriptors), the facts
+ *                            lane over the same in-memory claim (`buildFacts`: read the engine's
+ *                            rubric manifest, run the producer, freeze the FactSet), and `POST /v1/decisions` on
+ *                            the eval engine with that FactSet and the claim's content (the
+ *                            pull's `claimContent`: a chain claim's CID-verified bytes, an API
+ *                            claim's stored content) → one `decisions` row
+ *                            (`onConflictDoNothing` — decided once, matching the engine's own
+ *                            evaluated-once mutex). ONE step on purpose, exactly as the engine
+ *                            folded its pull into `evaluate`: the
+ *                            claim body and the FactSet — which CONTAINS the answers — may never
+ *                            be a step result, so pull → facts → decide has to live and die
+ *                            inside one step; only the small decision summary leaves it. A claim
+ *                            the facts lane cannot build for (a rubric the engine's manifest cannot
+ *                            bind, facts that don't match the rubric's work order) gets its row
+ *                            WITHOUT a decide call — nothing to decide, nothing charged
+ *   step "act"             → act on a terminal verdict (chain-write under the AUTO_SIGN policy;
+ *                            workflows/steps.ts). Fail-soft: a delivery failure NEVER fails the
+ *                            ingest — the decision is recorded, and an operator rerun re-enters
+ *                            delivery idempotently. A `pending_review` decision waits for the
+ *                            review lane (routes/v1/reviews.ts → ReviewComplete) to act instead
+ *   step "mark-processed"  → row → `processed`
+ *   terminal catch         → row → `failed` (+ the message), instance shows Errored in the dashboard
+ * The cron (cron/) only discovers claims and creates instances; it never writes this table.
+ *
+ * The engine's answers that are not "here is the decision" (docs/ENGINE-CONTRACT.md "Errors")
+ * are routed, not retried blindly: not hired for the collection ⇒ pause it and stop; credits
+ * exhausted ⇒ pause EVERY watched collection, alert, and keep retrying this claim (cheap — the
+ * engine returns the stored row once decided); a rubric pin the chain has since re-anchored ⇒
+ * invalidate the cached manifest, re-read and rebuild once; a facts shape the engine refuses ⇒
+ * our producer's bug, fail loudly. And the "no" that is not an error: an UNUSABLE rubric — said
+ * by the engine's manifest before a producer runs (`rubric-unusable` from the builder: no `#rub`,
+ * swapped bytes, a drifted `#vct`, an unbindable ref), or by `decision.status = "unusable"` at
+ * decide time (fact coverage; the oracle never pre-binds, the engine's
+ * binder is the only validator of rubric ⇄ form ⇄ facts). Both are recorded (the engine's with its
+ * receipt) AND pause the collection: every claim of it would be refused the same way, so a broken
+ * catalog entry is paid for once — or, from the manifest, not at all. `POST
+ * /v1/collections/:id/resume` lifts it once `#rub`/`#vct` are fixed.
+ *
+ * Replay safety: a step's checkpointed result is returned verbatim on replay and the body of a
+ * completed step never re-runs, so a step may only depend on its own inputs, the DB, and the small
+ * results of earlier steps — never on in-memory state another step built. A retry that re-enters
+ * `evaluate` after its row landed reads the row and returns: no second pull, no second connector
+ * run (AI charges), no second ask. A retry that re-enters in the window BETWEEN the engine
+ * deciding and that row landing finds the row marked `processing` and asks `GET
+ * /v1/decisions/:claimId` first (docs/ENGINE-CONTRACT.md "Auth + preconditions"): decided-once on
+ * the engine plus one extra read on retry ⇒ the producer never runs twice for one claim, and no
+ * claim is stranded. A first attempt never pays that read.
+ *
+ * Self-contained BY DESIGN so operator recovery is just the dashboard: RERUN an errored instance
+ * (params are retained) and the ledger converges. Hand-creating a new instance also works with the
+ * claim CID as the id and no params (the id doubles as the claimId; the collection is resolved
+ * on-chain); only hash-mapped claims (rare non-CID ids) need `{"claimId": "…"}` as params.
+ *
+ * Two front doors, one workflow (Go Prod §7.1): `params.lane` picks the `ClaimSource`
+ * (workflows/claim-source.ts) — `chain` (absent: the cron's claims) or `api` (`startApiClaims`,
+ * whose body lives in D1 and whose decision is never acted on). The steps are the same for both.
+ *
+ * On the chain lane the claim body and attachment bytes are NOT persisted in D1 — attachments are Matrix CID
+ * references, and the `decisions` row stores only the engine's answer plus the FactSet digest. The
+ * one copy is the operator's opt-in answer archive (`ANSWERS_ARCHIVE`, lib/archive.ts), written to
+ * R2 from inside `evaluate` and never a step result.
+ *
+ * Per-review billing (IXO's plan for the oracle, payments/review-billing.ts): a chain claim of a
+ * collection registered with a paying source (`billingSourceId`) is never decided without a
+ * reservation. Inside `evaluate`, before the pull: a claim id the facilitator cannot key (not a
+ * base32 CIDv1) is recorded `skipped` (`unbillable-claim-id`) — no offer, no decide, no chain
+ * write, no pause — and who pays is resolved fresh (no usable delegation ⇒ pause
+ * `payer-delegation`). AFTER the facts lane built — so a facts-lane `unusable` / `invalid_facts`
+ * never spends the delegation's cap — the price is reserved (offer → verify); a refusal for want of
+ * credits pauses `payer-credits`. While a payer pause stands, a retry stops before the pull, like
+ * `engine-credits`. The decision settles on its receipt (an engine `unusable` included), a
+ * `pending_review` extends its hold, and a reserved claim that will never get a receipt (a rebuild
+ * that failed, an engine refusal, a run that gave up) is released.
+ */
+import { WorkflowEntrypoint, type WorkflowEvent, type WorkflowStep } from "cloudflare:workers";
+import type { ClaimLaneKind } from "../contracts/index.js";
+import type { OracleEnv } from "../env.js";
+export interface ClaimIngestParams {
+    claimId: string;
+    /** Known at cron discovery time; absent on manual runs (resolved on-chain in `record-queued`). */
+    collectionId?: string;
+    /**
+     * The front door (Go Prod §7.1): `api` from `startApiClaims`; absent ⇒ `chain`, so every
+     * in-flight or operator-created chain instance keeps working. An operator re-creating an API
+     * claim's instance by hand passes `{"claimId": "apc_…", "lane": "api"}`.
+     */
+    lane?: ClaimLaneKind;
+    /**
+     * The starter's W3C trace — the accepting request's (`startApiClaims`) or the scan tick's — so
+     * the run's logs, its engine call and its webhooks share one `traceId`. Absent (an operator's
+     * hand-made instance, one queued before this field) ⇒ a fresh trace.
+     */
+    traceparent?: string;
+    /** The accepting request's id, API lane only. */
+    requestId?: string;
+}
+/** What leaves the evaluate step: small, log-safe, enough to reason about the run — never the facts. */
+export interface EvaluateResult {
+    status: string;
+    verdict: string | null;
+    resultDigest: string | null;
+    receiptCid: string | null;
+}
+/**
+ * How a review-billing trouble is told apart in the ledger's `error` (a run that gave up while its
+ * collection was paused for payment): the resume cron restarts exactly those.
+ */
+export declare const PAYER_BILLING = "payer-billing:";
+/**
+ * `403 NO_EVALUATE_GRANT` is retry-ONCE (docs/ENGINE-CONTRACT.md): the grant may have landed on
+ * chain seconds ago — the portal grants and registers in one flow — so wait about a block and ask
+ * again before calling it a real "not hired". In-step on purpose: the FactSet may not leave the
+ * step, so a step-level sleep would cost a full rebuild (connectors, AI charges). An object so a
+ * test can shorten it.
+ */
+export declare const GRANT_RETRY_DELAY: {
+    ms: number;
+};
+export declare class ClaimIngest extends WorkflowEntrypoint<OracleEnv, ClaimIngestParams> {
+    run(event: WorkflowEvent<ClaimIngestParams>, step: WorkflowStep): Promise<{
+        status: string;
+        verdict: string | null;
+        resultDigest: string | null;
+        receiptCid: string | null;
+        claimId: string;
+        ok: boolean;
+    }>;
+    private ingest;
+    /**
+     * The evaluate step's body: pull → facts → decide → the `decisions` row. Reads the DB, not step
+     * results, so an operator rerun converges — and a retry that finds the row is done.
+     */
+    private evaluate;
+    /**
+     * Who pays for this chain claim's review (header): null when its collection pays by its
+     * evaluation leg (or the oracle no longer bills per review); `reserved` when a charge already
+     * holds it (a retry); else the payer, resolved fresh — never a guess: the engine's or the chain's
+     * trouble retries the step, and no usable delegation pauses the collection `payer-delegation`.
+     */
+    private billingFor;
+    /**
+     * A billing pause. The payer's two: the owner's notice, never a page (a customer's condition).
+     * `oracle-plan`: IXO's to fix — paged, no notice to the owner or the payer.
+     */
+    private pausePayer;
+    /** The normal path: pull → build → (reserve) → decide → the `decisions` row. */
+    private decideFresh;
+    /** Reserve the review (payments/review-billing.ts), or say why not — a pause, a retry, a stop. */
+    private reserve;
+    /**
+     * A decision recovered from the engine's store → its `decisions` row.
+     *
+     * It is FINAL for this claim — the engine will not judge it twice — so it outranks anything this
+     * attempt would have concluded, including a build that failed. What it lacks is the facts it was
+     * decided on: the attempt that produced them died before writing the row, and the engine keeps a
+     * trace, not a FactSet. So they are rebuilt here — and stand in for the originals only if the
+     * rebuild is PROVABLY the same one, which is exactly what the engine's `factsDigest` proves.
+     * Anything else (a non-deterministic fact, a re-anchored rubric, a failed rebuild) is written as
+     * a park with its reason, at write time: better an explicit blocked row naming the drift than a
+     * decided row the act lane refuses later without knowing why.
+     *
+     * The rebuild may not even be ATTEMPTABLE: the owner's delegation can expire while the claim
+     * sits between attempts, and then the pull fail-closes 403. A deterministic "no" there is NOT a
+     * reason to lose the decision — the ingest would be marked `failed` with no row at all, while
+     * the engine holds a final answer it will never issue again. So it is recorded parked, facts
+     * null, and the act lane refuses to sign it (src/act.ts reads those facts). Only a transient
+     * failure is rethrown, so the step still retries and a later attempt can record the real facts.
+     */
+    private recordRecovered;
+    /**
+     * The engine's answer → the `decisions` row, the collection's rubric pin and the `unusable`
+     * pause: ONE path whether the answer came from `POST /v1/decisions` just now or was recovered
+     * from the engine's store on a retry (see `evaluate`), so the two can never drift apart.
+     *
+     * `sent` is the FactSet this decision was made on — its `ext`/`ai` are frozen onto the row for
+     * the act policy to read at signing time (schema.ts `decisions.facts`), and nothing else of it
+     * is: `answers`/`attachments` are the claim's erasable surface and never persisted here. Null
+     * only on the recovery path when the rebuild could not be proven to be the same facts, which is
+     * what `park` says: the row is written `blocked` with that reason instead of `pending`, so the
+     * claim read explains itself and the act lane never has to guess.
+     */
+    private record;
+    /**
+     * `api.decision.latency` — accept → decision row, the SLO metric. Accepted is the API claim's
+     * `receivedAt`, or the chain claim's ledger `createdAt` (its first `record-queued`). `status` says
+     * whether the protocol's rubric runs AI checks: the frozen FactSet's `ai` keys are exactly the
+     * work order's (validate.ts holds them to the manifest), so no extra read; `-` only when a
+     * recovered decision's facts could not be rebuilt. Best-effort: a metric never fails the step.
+     */
+    private decisionLatency;
+    /**
+     * `POST /v1/decisions`, with the one recoverable refusal handled here: `RUBRIC_PIN_MISMATCH` —
+     * our pin ≠ the chain's `#rub` proof as the engine read it, i.e. `#rub` was re-anchored between
+     * our (KV-cached) manifest read and theirs. Invalidate and re-read the manifest ONCE: a changed
+     * pin is a new work order (new facts, so a rebuild — connectors run again; the fact cache is
+     * keyed by the pin, fact-cache.ts), the same pin means the engine and the chain disagree, which
+     * no retry of ours fixes. The manifest may also have turned `unusable` under the new anchor —
+     * then the rebuild records that, and never decides.
+     */
+    private decide;
+    /** One decide call, with the contract's retry-once on `NO_EVALUATE_GRANT` (see `GRANT_RETRY_DELAY`). */
+    private ask;
+    /**
+     * The engine said no (docs/ENGINE-CONTRACT.md "Errors"): do what the table says, then hand back
+     * the error to throw — NonRetryable for a deterministic refusal, the original for a retryable
+     * one. Non-engine errors pass through for `stepError` to classify.
+     */
+    private engineFailure;
+    /**
+     * Facts that don't match the rubric's work order (lib/facts/validate.ts) — the producer's bug,
+     * never a claim outcome: the issue list is codes and paths (identifiers), logged and paged so the
+     * fix is one grep away, and the error to throw is NonRetryable (a retry would re-run the same
+     * producer). The row is already recorded by the caller.
+     */
+    private invalidFacts;
+    /**
+     * A claim the facts lane could not build for — recorded WITHOUT a decide call (schema.ts
+     * `decisions`): `status` names the reason, `explanation` the issues, and nothing will ever be
+     * acted on, so `chainStatus` is `skipped` from the start. Then the reason's consequence:
+     * `rubric-unusable` is the engine's manifest saying the rubric cannot be bound — the same
+     * handling as its decide-time `unusable` (pause the collection; steps.ts), minus the receipt, and
+     * the ingest completes; `invalid-facts` is OUR (or the provider's) bug, never a claim outcome —
+     * recorded so the claim read says why, then failed loudly, like the engine's own `VALIDATION`
+     * refusal this check exists to catch first.
+     */
+    private buildFailure;
+    /**
+     * A terminal failure's class — the API lane's §5 code (lib/api-lane/record.ts `claimErrorCode`,
+     * read off the same message the ledger stores), for either lane. Best-effort like the rest of
+     * the terminal path.
+     */
+    private failureClass;
+    private ledgerRow;
+    /**
+     * Upsert this claim's ledger row. `error` is null unless `failed` (schema.ts), so a rerun that
+     * succeeds clears the old message.
+     */
+    private recordStatus;
+}
+//# sourceMappingURL=claim-ingest.d.ts.map

package/dist/workflows/claim-ingest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-ingest.d.ts","sourceRoot":"","sources":["../../src/workflows/claim-ingest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AAEH,OAAO,EAAE,kBAAkB,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAI/F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAUlD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAmDxC,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,kGAAkG;IAClG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wGAAwG;AACxG,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAOD;;;GAGG;AACH,eAAO,MAAM,aAAa,mBAAmB,CAAC;AAsB9C;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;IAAK,EAAE;CAAU,CAAC;AAchD,qBAAa,WAAY,SAAQ,kBAAkB,CAAC,SAAS,EAAE,iBAAiB,CAAC;IAChE,GAAG,CAAC,KAAK,EAAE,aAAa,CAAC,iBAAiB,CAAC,EAAE,IAAI,EAAE,YAAY;gBA3DtE,MAAM;iBACL,MAAM,GAAG,IAAI;sBACR,MAAM,GAAG,IAAI;oBACf,MAAM,GAAG,IAAI;;;OA8ExB;YAEa,MAAM;IA+KpB;;;OAGG;YACW,QAAQ;IAyGtB;;;;;OAKG;YACW,UAAU;IA6CxB;;;OAGG;YACW,UAAU;IAyBxB,gFAAgF;YAClE,WAAW;IAgGzB,kGAAkG;YACpF,OAAO;IAgBrB;;;;;;;;;;;;;;;;;;OAkBG;YACW,eAAe;IA2D7B;;;;;;;;;;;OAWG;YACW,MAAM;IAiHpB;;;;;;OAMG;YACW,eAAe;IAmC7B;;;;;;;;OAQG;YACW,MAAM;IAoCpB,wGAAwG;YAC1F,GAAG;IAmBjB;;;;OAIG;YACW,aAAa;IAmI3B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAmBpB;;;;;;;;;OASG;YACW,YAAY;IAwC1B;;;;OAIG;YACW,YAAY;IAa1B,OAAO,CAAC,SAAS;IAMjB;;;OAGG;YACW,YAAY;CAsB3B"}