@integraledger/lcp-verify 0.9.0

package/dist/steps.js

@@ -0,0 +1,404 @@
+/**
+ * The verification walk as an ordered table of typed steps. At STRUCTURAL depth each step is
+ * presence/absence → outcome plus the pure checks it can do over supplied inputs (no live ports):
+ * `proved | failed(haltClass) | indeterminate | not-attempted(depth)`. A step whose inputs are absent is
+ * `not-attempted(<why>)` — coverage is honest depth, never a silent pass. These outcomes are depth-agnostic;
+ * `verified` is computed FROM them by `computeVerified` (index.ts); the live-port gathering that raises
+ * coverage to mechanical depth is the buyer gate's.
+ *
+ * Three rules hold across every step, and all three exist so the walk can never flatter a record:
+ *   - ABSENT INPUTS NEVER PROVE. An empty authority chain, an acceptance with no verifier to check its
+ *     signature, an identity with no resolution chain — each is `not-attempted`, never `proved`.
+ *   - CONTRADICTIONS FAIL, GAPS DO NOT. `failed` is reserved for a record that contradicts itself (a
+ *     fingerprint that does not match, a link that widens its parent, a signature that does not verify);
+ *     it impeaches `supportedClass` to TC-0. Missing evidence is a gap: `not-attempted`, which leaves
+ *     `verified` false without impeaching a record that simply did not carry that rung.
+ *   - EVERY STEP IS TOTAL. Steps read their slots through `present` and shape-check before dereferencing,
+ *     because the callers they exist for are untyped — a foreign conformance subject, an unvalidated
+ *     intake. A malformed slot reads out as a gap, never as a `failed`: the caller's shape error says
+ *     nothing about whether the record is self-consistent, and a walk that throws cannot report the
+ *     malformation it was handed.
+ *
+ * The authority step is the load-bearing one. Every link must have been PERMITTED by its parent (ATA-3 —
+ * the parent was delegable, it had depth left, and the link stated a depth that fits beneath what the
+ * parent held; an unstated depth is unbounded and therefore an escalation like any other), must ATTENUATE
+ * (`authority.isWithin`), and must be UNREVOKED and UNEXPIRED as-of settlement. Each failure is
+ * `failed(verification-failure)`, never `proved`, so the walk can never affirm a forged chain — whether the
+ * forgery widened the bounds or the authority to delegate them. These are the same four gates
+ * `authority.linkAttenuates` enforces at issuance; producer and verifier must not diverge, and
+ * `vectors/{authority/link-attenuates,verify/authority-walk}.json` pin both halves against each other.
+ *
+ * `authorityStep` reads a FLATTENED chain, every field of which is a derived fact it must take on trust.
+ * `authorityStepFromWalk` is the path that removes that trust — it consumes `authority.walkChain`'s
+ * readout directly, so the caller never flattens anything. Both are exported: the flattened door stays
+ * open because a foreign conformance subject may legitimately derive its links some other way, and this
+ * module's totality rule means such a caller gets an honest readout rather than a compile wall.
+ */
+import { commitmentWithinLeaf, isWithin, verifyAcceptance, } from "@integraledger/lcp-authority";
+import { atrHashEquals, hashAtr } from "@integraledger/lcp-kernel";
+/**
+ * Is the ATR's `terms` slot an `lcp:sha256:` REFERENCE rather than the inlined document?
+ *
+ * Narrow on purpose. Only the content-addressed form means "the document lives elsewhere and must travel
+ * with the package": an inlined string IS the document, and `lcp:ipfs:`/`lcp:ar:` are not what
+ * `kernel.assemble` emits for the terms slot. A non-string slot is not a ref — it reads as absent here and
+ * is the fingerprint step's business, not this one's.
+ */
+function isRefTerms(terms) {
+    return typeof terms === "string" && terms.startsWith("lcp:sha256:");
+}
+/**
+ * RCS-4's required evidence roles — the specification's own enumeration of a self-contained package: the terms
+ * artifact and fingerprint; the acceptance signature and its authority chain (ATA-6); the spend-authorization
+ * artifact or a verifiable reference to it (ASP-5); the identity attestations relied on and their assurance
+ * levels (IDN-3); the settlement reference and weld; timestamps. Its own conditional clause — fulfillment and
+ * order-state, "where performance is disputed" (OPS-2) — is conditional and therefore NOT required here.
+ */
+export const RCS4_REQUIRED_ROLES = [
+    "atr",
+    "signed acceptance",
+    "authority chain",
+    "spend artifact",
+    "attestation",
+    "settlement",
+    "weld",
+    "timestamp",
+];
+/**
+ * Is a slot supplied at all? `=== undefined` is not enough over an untyped caller — a foreign conformance
+ * subject or an unvalidated intake can hand in an explicitly `null` slot, which is *present* to that check
+ * and then dereferences to a TypeError. `typeof null === "object"` slips it past shape guards too. Every
+ * step reads its own slots through this, so a malformed record gets an honest `not-attempted` readout
+ * rather than crashing the walk that exists to report on it. Typed callers cannot express the null case.
+ */
+function present(value) {
+    return value !== undefined && value !== null;
+}
+/** A bounds-shaped slot: an object `isWithin` can walk. Mirrors `authority.walkableBounds`'s own gate, which
+ *  exists for the same reason — `isWithin` reads its arguments with `Object.keys`, which THROWS on `undefined`
+ *  and `null`. `typeof` alone is not that check (`typeof null === "object"`), and an array is not it either:
+ *  `Object.keys([])` answers indices, so an array would read as a bounds with no dimensions instead of being
+ *  refused. Only the shape is screened here — UNKNOWN keys are `isWithin`'s fail-closed refusal to make, not
+ *  a shape gap for this step to pre-empt. */
+function boundsShaped(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** A string that actually STATES something. `present` is not enough where the value IS the claim: `""` is
+ *  a present string asserting nothing, and a walk that accepts it reports a fact nobody supplied. Blank
+ *  runs count as empty — whitespace is not a subject and not a resolution method. */
+function nonBlank(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+/** Recompute the fingerprint over the retrieved ATR bytes and compare to what the settlement committed. */
+export async function fingerprintStep(atrBytes, settledAtrHash) {
+    if (!present(atrBytes))
+        return { status: "indeterminate" }; // unretrievable ATR — not a failure
+    if (!present(settledAtrHash))
+        return { status: "not-attempted", depth: "no-settled-hash" };
+    const recomputed = await hashAtr(atrBytes);
+    // Decoded-byte comparison per LCP §2.5. This is the rung that proves the settlement committed to THIS
+    // document, so a comparison that could answer `true` for two malformed strings is the wrong primitive.
+    return atrHashEquals(recomputed, settledAtrHash)
+        ? { status: "proved" }
+        : { status: "failed", haltClass: "verification-failure" };
+}
+/** Settlement enumeration across supplied forward-indexable bindings (multiply-settled flag). */
+export function settlementStep(settlements) {
+    if (!present(settlements))
+        return { status: "not-attempted", depth: "no-enumeration-port" };
+    if (settlements.length === 0)
+        return { status: "not-attempted", depth: "no-settlement-found" };
+    return { status: "proved" };
+}
+/**
+ * TRM-6: the buyer's acceptance over the fingerprint, SIGNED and TIMESTAMPED. The signature is checked
+ * through `authority.verifyAcceptance` over the injected `SignatureVerifier` port (the EVM implementation
+ * — EOA EIP-191/712 and smart-account ERC-1271/6492 — is `binding-evm-common`'s).
+ *
+ * WITHOUT A VERIFIER THIS STEP CANNOT PROVE. A signature nobody checked is not evidence of a signature, so
+ * an acceptance presented with no verifier is `not-attempted("no-signature-verifier")` — the honest readout
+ * of "this record carries an acceptance whose cryptography this verifier was not equipped to check".
+ * `signedAt` needs no separate gate: `SignedAcceptance` requires it, so an untimestamped acceptance is
+ * unrepresentable rather than rejected at runtime — illegal states are not constructible.
+ */
+export async function acceptanceStep(acceptance, settledAtrHash, verifier) {
+    if (!present(acceptance))
+        return { status: "not-attempted", depth: "no-acceptance" };
+    if (!present(settledAtrHash))
+        return { status: "not-attempted", depth: "no-settled-hash" };
+    if (!present(verifier))
+        return { status: "not-attempted", depth: "no-signature-verifier" };
+    const outcome = await verifyAcceptance(acceptance, settledAtrHash, verifier);
+    return "refused" in outcome
+        ? { status: "failed", haltClass: outcome.haltClass }
+        : { status: "proved" };
+}
+/** Walk the ATA chain: every link attenuates (isWithin), is unrevoked, and is unexpired as-of settlement. */
+export function authorityStep(chain) {
+    // A non-array in the slot is not a chain — `.length` on it is meaningless and `for…of` throws.
+    if (!present(chain) || !Array.isArray(chain))
+        return { status: "not-attempted", depth: "no-authority-chain" };
+    // An empty chain walks nothing. Proving it would let a record with no delegated authority whatsoever
+    // clear the ATA rung — the gap that let placeholder chains carry a class they never earned.
+    if (chain.length === 0)
+        return { status: "not-attempted", depth: "empty-authority-chain" };
+    for (const link of chain) {
+        // An element that is not a link makes the chain UNWALKABLE. That is a gap, not a contradiction: the
+        // caller handed over something malformed, which says nothing about whether the record is self-
+        // consistent. Reporting it as `failed` would impeach a record to TC-0 over the caller's shape error.
+        if (!present(link) || typeof link !== "object")
+            return { status: "not-attempted", depth: "malformed-authority-chain" };
+        // ATA-3, gate one: the parent must have permitted delegation at all. Impeccably attenuated bounds
+        // re-issued by a holder who was never authorized to re-issue them are still a forged link.
+        if (!link.parentDelegable)
+            return { status: "failed", haltClass: "verification-failure" };
+        // ATA-3, gate two: depth. A depth-exhausted parent admits no link below it, and a link may not mint
+        // itself more onward-delegation latitude than the parent held (`isWithin` governs bounds, not depth).
+        // An UNSTATED child depth means unbounded, so under a bounded parent it is an escalation like any
+        // other — the same reason `parentDelegable` is required rather than defaulted.
+        if (present(link.parentMaxDepth)) {
+            // FINITE, not merely present. `NaN` compares false on BOTH sides of the arithmetic below
+            // (`NaN <= 0`, `x > NaN - 1`), so a non-finite depth on either side disengages this gate and the
+            // link reaches `proved` with its depth never actually checked. It reads out as a GAP, not a
+            // failure, under this step's own discipline: a caller's type corruption is a malformed slot, and
+            // says nothing about whether the RECORD contradicts itself — the same ruling the walk makes on the
+            // same value (`authority.walkChainStructure`, which refuses it as `malformed-authority-chain`), so
+            // walk and step stay categorically aligned. JSON cannot express NaN, so no corpus vector can pin
+            // this; the pins are in this package's tests. Negative and fractional depths stay deliberately
+            // un-screened: the arithmetic already fails closed on them.
+            if (!Number.isFinite(link.parentMaxDepth))
+                return { status: "not-attempted", depth: "malformed-authority-chain" };
+            if (link.parentMaxDepth <= 0)
+                return { status: "failed", haltClass: "verification-failure" };
+            // Absent and non-finite part company HERE, and only here: an unstated child depth is unbounded,
+            // which under a bounded parent is a real escalation the record committed (`failed`), while a
+            // non-finite one is the caller's corruption (`not-attempted`).
+            if (!present(link.maxDepth))
+                return { status: "failed", haltClass: "verification-failure" };
+            if (!Number.isFinite(link.maxDepth))
+                return { status: "not-attempted", depth: "malformed-authority-chain" };
+            if (link.maxDepth > link.parentMaxDepth - 1)
+                return { status: "failed", haltClass: "verification-failure" };
+        }
+        // The bounds slots must be WALKABLE before they can be compared. `isWithin` reads both sides with
+        // `Object.keys`, so an absent, null or non-object slot throws there — and this module's contract is
+        // totality over its inputs, not over well-formed inputs. `not-attempted` rather than `failed`, for the
+        // same reason a non-finite depth is: a caller's shape corruption says nothing about whether the RECORD
+        // contradicts itself, and answering `failed` would impeach a record to TC-0 over the caller's mistake.
+        // A well-formed readout always carries objects — `authority.walkChainStructure` supplies `{}` for a root
+        // link's `parentBounds` — and it refuses this same value as `malformed-authority-chain`, so walk and step
+        // stay categorically aligned.
+        if (!boundsShaped(link.bounds) || !boundsShaped(link.parentBounds))
+            return { status: "not-attempted", depth: "malformed-authority-chain" };
+        if (!isWithin(link.bounds, link.parentBounds))
+            return { status: "failed", haltClass: "verification-failure" }; // forged widening
+        // Revocation and liveness, and the ONE place this step used to flatter a record. Both slots are
+        // compile-time REQUIRED, so a typed caller cannot reach the absent arm and `authorityStepFromWalk`
+        // never could — but this step's whole contract is totality over UNTYPED input, and for that caller an
+        // omitted `revoked` used to read as unrevoked and PROVE. That is the permissive direction of the one
+        // rule this module states in capitals: "the flattener never consulted a status list" and "the pinned
+        // snapshot says unrevoked" are not the same fact, and only one of them may prove.
+        //
+        // Absence is therefore a gap with its own name, a contradiction still fails, and a non-boolean is the
+        // caller's shape error — the same three-way split the depth gate above already makes. The order also
+        // matters and is pinned: a link that BOTH widens and omits its status fails, because `isWithin` runs
+        // first and a contradiction outranks a gap.
+        if (!present(link.revoked))
+            return { status: "not-attempted", depth: "no-revocation-stated" };
+        if (typeof link.revoked !== "boolean")
+            return { status: "not-attempted", depth: "malformed-authority-chain" };
+        if (link.revoked)
+            return { status: "failed", haltClass: "verification-failure" };
+        if (!present(link.active))
+            return { status: "not-attempted", depth: "no-liveness-stated" };
+        if (typeof link.active !== "boolean")
+            return { status: "not-attempted", depth: "malformed-authority-chain" };
+        if (!link.active)
+            return { status: "failed", haltClass: "verification-failure" }; // expired
+    }
+    return { status: "proved" };
+}
+/**
+ * The WALK-FED authority step — `authority.walkChain`'s readout mapped onto a `StepOutcome`. Prefer it.
+ *
+ * `authorityStep` accepts any `AuthorityLink[]`, which makes whoever produced that array a trusted
+ * oracle: every field on a link is a DERIVED fact (`parentDelegable`, `parentMaxDepth`, `parentBounds`,
+ * `revoked`, `active`), and the step takes each at face value. A flattener that never verified custody —
+ * never checked that link N+1 was signed by link N's subject, never dereferenced a status list — yields a
+ * confident `proved`. A caller that walks first constructs no link at all and cannot make that mistake.
+ *
+ * The mapping needs no interpretation, because `ChainWalkResult` already draws this module's own line:
+ * `refused` is a reasoned CONTRADICTION (a spliced link, an issuer discontinuity, a forged widening, a
+ * revoked grant) and carries the halt class with it; `not-attempted` is the walk's honest GAP, its depth
+ * passed through verbatim; `walked` hands over links whose every field the walk STATED rather than
+ * defaulted. Re-proving those links through `authorityStep` is deliberate rather than redundant — it is
+ * what stops the custody walk and the verification step from drifting apart, and
+ * `packages/conformance/the repository's walk-readout tests` pins that the walk's output is exactly what the step
+ * proves. Total over untyped input like every step here: an unrecognized readout carries no links, so it
+ * falls through to `authorityStep`'s own gap rather than throwing.
+ */
+export function authorityStepFromWalk(walk) {
+    if (!present(walk) || typeof walk !== "object")
+        return { status: "not-attempted", depth: "no-authority-walk" };
+    if (walk.status === "refused")
+        return { status: "failed", haltClass: walk.haltClass };
+    if (walk.status === "not-attempted")
+        return { status: "not-attempted", depth: walk.depth };
+    return authorityStep(walk.links);
+}
+/** ATA-4: the accepted commitment must be contained by the leaf grant's bounds. */
+export function commitmentStep(c) {
+    // Both halves must be usable bounds objects. `isWithin` is the pure ATA-2 predicate and is deliberately
+    // strict — it does `Object.keys` on what it is given — so the walk, not the predicate, owns the totality
+    // at this boundary. A half-supplied commitment slot is no commitment: a gap, never a contradiction.
+    if (!present(c) ||
+        typeof c !== "object" ||
+        !present(c.commitment) ||
+        typeof c.commitment !== "object" ||
+        !present(c.leafBounds) ||
+        typeof c.leafBounds !== "object")
+        return { status: "not-attempted", depth: "no-commitment" };
+    return commitmentWithinLeaf(c.commitment, c.leafBounds)
+        ? { status: "proved" }
+        : { status: "failed", haltClass: "verification-failure" };
+}
+/**
+ * RCS-1/2/4: the elections the record carries and the package it produced.
+ *
+ * The elections are read from THE HASHED RECORD ITSELF — `atrBytes` parsed as the LCP envelope — never from
+ * a caller-supplied side channel, because RCS-1 requires the forum designation "recorded inside the terms
+ * record" (TRM-9). What this step proves is therefore what was welded.
+ *
+ * This step NEVER returns `failed`. An unelected forum is a record that did not reach for the rung, not a
+ * record that contradicts itself, and impeaching `supportedClass` to TC-0 over it would misreport a
+ * perfectly coherent TC-2. Likewise a non-machine-readable ATR (a ratified prose template, a PDF) is an
+ * honest coverage gap: a human forum can read a governing-law clause a verifier cannot.
+ */
+export function recourseStep(atrBytes, evidenceRoles) {
+    if (!present(atrBytes))
+        return { status: "not-attempted", depth: "no-atr-bytes" };
+    const envelope = parseEnvelope(atrBytes);
+    if (!present(envelope))
+        return { status: "not-attempted", depth: "atr-not-machine-readable" };
+    const recourse = envelope["recourse"];
+    if (!present(recourse) || typeof recourse !== "object")
+        return { status: "not-attempted", depth: "no-elections-recorded" };
+    const elections = recourse;
+    if (!stated(elections["forum"]))
+        return { status: "not-attempted", depth: "no-forum-elected" }; // RCS-1
+    if (!stated(elections["governingLaw"]))
+        return { status: "not-attempted", depth: "no-governing-law-elected" }; // RCS-2
+    if (!present(evidenceRoles))
+        return { status: "not-attempted", depth: "no-evidence-package" }; // RCS-4
+    const supplied = new Set(evidenceRoles);
+    if (!RCS4_REQUIRED_ROLES.every((role) => supplied.has(role)))
+        return { status: "not-attempted", depth: "evidence-package-incomplete" };
+    // CONDITIONAL, and this is the rung the role list alone cannot express. An ATR may carry its terms
+    // INLINE — then the ATR artifact is the document, and the list above is already complete — or by
+    // `lcp:sha256:` REFERENCE, in which case the package holds a fingerprint of a document it does not
+    // contain. A hash without a document is a proof without evidence (LCP §5.5, TRM-7), and the forum that
+    // opens the package years later receives the fingerprint of something nobody retained.
+    //
+    // Required IFF the terms slot is a ref, because an unconditional role would fail every honest
+    // inline-terms package. `manifest.schema.json` already stated this rule; nothing enforced it.
+    if (isRefTerms(envelope["terms"]) &&
+        !supplied.has("referenced terms document"))
+        return { status: "not-attempted", depth: "referenced-terms-not-retained" };
+    return { status: "proved" };
+}
+/**
+ * IDN-1/IDN-3: both parties resolve, each at a STATED assurance level, over a non-empty resolution chain.
+ *
+ * IDN-2 — does the chain terminate in an accountable party rather than a bare key? — is deliberately NOT a
+ * gate here. It is the counterparty-trust question a BUYER's policy asks (`authority.isConsequentialConformant`,
+ * applied by the gate), not a property of the record's class: a record that honestly states
+ * `wallet-signature-only` is conformant at its level, and IDN-3's whole discipline is that the low level
+ * stated honestly passes while an unstated level does not.
+ */
+export function resolvePartyStep(identity) {
+    if (!present(identity))
+        return { status: "not-attempted", depth: "no-identity" };
+    // A party that is absent or carries no resolution chain is an UNRESOLVED party, not a crash: the step is
+    // total over its input, so a foreign conformance subject feeding a half-shaped identity gets an honest
+    // readout instead of a TypeError. Typed callers cannot express this — `RecordIdentity` requires both.
+    for (const party of [identity.seller, identity.buyer]) {
+        if (!present(party) || !present(party.chain))
+            return { status: "not-attempted", depth: "no-resolution" };
+        if (party.chain.length === 0)
+            return { status: "not-attempted", depth: "no-resolution-chain" };
+        // IDN-1 — the statement of WHO. A party resolved to nobody is unresolved.
+        if (!nonBlank(party.subject))
+            return { status: "not-attempted", depth: "no-subject" };
+        // IDN-3 — the statement of HOW. Array LENGTH is not evidence: `[{}]` and `[{via:""}]` are non-empty
+        // arrays that record nothing, and honouring them proved attribution for an identity naming no method
+        // at all. Every entry must say how, or the chain is present in shape only.
+        if (!party.chain.every((step) => nonBlank(step?.via)))
+            return { status: "not-attempted", depth: "no-resolution-method" };
+        // IDN-3 — the statement of AT WHAT LEVEL. A party whose resolution names no assurance stated nothing
+        // to pass honestly at: absence is a gap, exactly as a blank `subject` or `via` is. Typed callers cannot
+        // omit it (`IdentityResolution` requires `assurance`); this gate exists for the untyped ones.
+        if (!nonBlank(party.assurance))
+            return { status: "not-attempted", depth: "no-assurance-stated" };
+    }
+    return { status: "proved" };
+}
+/**
+ * The reference-placement step — did the reference found in the protocol's native field match this record?
+ *
+ * REPORTED, NEVER REQUIRED: no class lists it in `REQUIRED_STEPS`, so its absence never blocks, and it
+ * impeaches only when it FAILS — the `frc-non-gating` pattern exactly. A protocol that never settles has
+ * nothing to enumerate, and letting a placement stand in for a settlement rung would let a record that
+ * moved no money read as classed.
+ *
+ * Total, like every step: the shape checks stay even though the arguments are typed, because the callers
+ * this exists for are untyped — a foreign conformance subject, an unvalidated intake. A malformed
+ * extraction is a GAP, never a `failed`: the caller's shape error says nothing about whether the record
+ * contradicts itself.
+ */
+export function referencePlacementStep(placement, settledAtrHash) {
+    if (!present(placement))
+        return { status: "not-attempted", depth: "no-placement-input" };
+    const extracted = placement.extracted;
+    if (extracted === undefined)
+        return { status: "not-attempted", depth: "no-reference-extracted" };
+    if (typeof extracted !== "object" ||
+        extracted === null ||
+        typeof extracted.value !== "string")
+        return { status: "not-attempted", depth: "malformed-extracted-reference" };
+    if (typeof settledAtrHash !== "string")
+        return { status: "not-attempted", depth: "no-record-fingerprint" };
+    // Both sides are NORMALIZED to the canonical 0x-prefixed lower-case form, not stripped to bare digits.
+    // Hex is case-insensitive, so a conformant uppercase counterparty must not be false-negatived. And a
+    // missing `0x` is a CARRIER-FORM defect that `binding-core`'s decoder already refuses upstream at
+    // extract time — failing here would drive `supportedClass` to TC-0 over formatting, impeaching a record
+    // whose reference names it correctly. Impeachment is reserved for a reference naming a DIFFERENT record.
+    const canonical = (h) => {
+        const lower = h.toLowerCase();
+        return lower.startsWith("0x") ? lower : `0x${lower}`;
+    };
+    if (canonical(extracted.value) !==
+        canonical(settledAtrHash))
+        return { status: "failed", haltClass: "verification-failure" };
+    return { status: "proved" };
+}
+/** A non-empty, non-blank string statement — an empty election is not an election. */
+function stated(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+/** Parse the ATR bytes as an LCP envelope, or `undefined` when they are not one (prose, PDF, foreign JSON). */
+function parseEnvelope(atrBytes) {
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(atrBytes));
+    }
+    catch {
+        return undefined; // not JSON at all — a prose or binary terms artifact
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return undefined;
+    const envelope = parsed;
+    // `lcp` is engine-stamped by kernel.assemble on every record — its absence means these bytes are not an
+    // LCP envelope, whatever else they may be.
+    return typeof envelope["lcp"] === "string" ? envelope : undefined;
+}
+//# sourceMappingURL=steps.js.map

package/dist/steps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps.js","sourceRoot":"","sources":["../src/steps.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@integraledger/lcp-verify",
+  "version": "0.9.0",
+  "description": "The LCP verification walk, and the canonical report it emits.",
+  "keywords": [
+    "lcp",
+    "legal-context-protocol",
+    "legal-terms",
+    "agentic-commerce",
+    "verification",
+    "report"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "CHANGELOG.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/IntegraLedger/integra-protocol.git",
+    "directory": "packages/verify"
+  },
+  "bugs": {
+    "url": "https://github.com/IntegraLedger/integra-protocol/issues"
+  },
+  "homepage": "https://github.com/IntegraLedger/integra-protocol/tree/main/packages/verify#readme",
+  "dependencies": {
+    "@integraledger/lcp-authority": "0.9.0",
+    "@integraledger/lcp-binding-core": "0.9.0",
+    "@integraledger/lcp-kernel": "0.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.3",
+    "fast-check": "4.9.0",
+    "vitest": "4.1.10"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}

package/src/composition.ts

@@ -0,0 +1,100 @@
+/**
+ * The TC-4 **composition readout** — the pure step evaluators the walk appends when a
+ * `composition` slot is supplied. Each evaluator mirrors `fingerprintStep`: presence/absence over the
+ * supplied `CompositionInput` → a `StepOutcome`, no I/O, no fetch, no viem. TC-4 is a READOUT of a record
+ * complete enough to prove it was complete — these steps never gate; they only confirm or impeach.
+ *
+ * FRC is DELIBERATELY non-gating (FRC-1): `frcNonGatingStep` is impeachment-only — a signal that GATED is a
+ * `failed(risk-block)`, its ABSENCE never blocks TC-4 (it is not in `REQUIRED_STEPS["TC-4"]`).
+ */
+import type { StepOutcome } from "./report.js";
+
+/** What the caller can state about a record's composition. **Every field is optional, and absence is
+ *  meaningful**: an omitted field is a gap the readout reports as unproved, never an assumed `false`.
+ *  The values are the CALLER's assertions — this module performs no I/O and cannot check any of them. */
+export interface CompositionInput {
+  readonly offerBound?: boolean;
+  readonly operations?: {
+    readonly orderStateRef?: boolean;
+    readonly reconciliationIds?: boolean;
+  };
+  readonly discoveryIntegrity?: "ok" | "mismatch" | "not-checked";
+  readonly proportionalityTier?: 1 | 2 | 3 | 4;
+  readonly frcSignals?: readonly {
+    readonly role: string;
+    readonly gated: boolean;
+  }[];
+}
+/** The flattened TC-4 readout. It is a READOUT, not a verdict: nothing here gates, and `frcGated: true`
+ *  is an impeachment signal rather than a refusal. `proportionalityTier` stays `undefined` when the caller
+ *  stated none, because an unstated tier is not tier 1. */
+export interface CompositionReadout {
+  readonly offerBound: boolean;
+  readonly operationsBound: boolean;
+  readonly discoveryIntegrity: "ok" | "mismatch" | "not-checked";
+  readonly proportionalityTier: 1 | 2 | 3 | 4 | undefined;
+  readonly frcSignalCount: number;
+  readonly frcGated: boolean;
+}
+
+const na = (why: string): StepOutcome => ({
+  status: "not-attempted",
+  depth: why,
+});
+
+/** OFR — proved iff the offer slot is bound; an unbound offer is incompleteness (not-attempted), never a failure. */
+export function offerBoundStep(c: CompositionInput | undefined): StepOutcome {
+  return c?.offerBound ? { status: "proved" } : na("no-offer");
+}
+/** OPS core — the always-applicable OPS bindings (OPS-2 order/fulfillment ref AND OPS-5 reconciliation). */
+export function operationsStep(c: CompositionInput | undefined): StepOutcome {
+  return c?.operations?.orderStateRef && c.operations.reconciliationIds
+    ? { status: "proved" }
+    : na("ops-incomplete");
+}
+/** DSC-1/2 — "ok" proves; "mismatch" is a hard DSC-2 violation (verification-failure); else not-attempted. */
+export function discoveryIntegrityStep(
+  c: CompositionInput | undefined,
+): StepOutcome {
+  const d = c?.discoveryIntegrity;
+  if (d === undefined || d === "not-checked") return na("no-discovery-check");
+  return d === "ok"
+    ? { status: "proved" }
+    : { status: "failed", haltClass: "verification-failure" };
+}
+/** CMP-6 — proved iff the proportionality tier is declared. */
+export function proportionalityStep(
+  c: CompositionInput | undefined,
+): StepOutcome {
+  return c?.proportionalityTier !== undefined
+    ? { status: "proved" }
+    : na("no-tier");
+}
+/** FRC-1 — impeachment-only: any signal that GATED is a `failed(risk-block)`; signals present but non-gating
+ *  prove the stack recorded-not-gated; no signals is not-attempted (FRC is not a v1 requirement). */
+export function frcNonGatingStep(c: CompositionInput | undefined): StepOutcome {
+  const sigs = c?.frcSignals ?? [];
+  if (sigs.length === 0) return na("no-frc-signals");
+  return sigs.some((s) => s.gated)
+    ? { status: "failed", haltClass: "risk-block" }
+    : { status: "proved" };
+}
+
+/** Flatten a {@link CompositionInput} into a {@link CompositionReadout}. Pure and total — an `undefined`
+ *  input is legitimate and reads as "nothing stated" rather than throwing. `operationsBound` requires BOTH
+ *  operations fields; either alone is a partially-composed record and reads `false`. */
+export function readCompositionSlots(
+  input: CompositionInput | undefined,
+): CompositionReadout {
+  const sigs = input?.frcSignals ?? [];
+  return {
+    offerBound: !!input?.offerBound,
+    operationsBound: !!(
+      input?.operations?.orderStateRef && input.operations.reconciliationIds
+    ),
+    discoveryIntegrity: input?.discoveryIntegrity ?? "not-checked",
+    proportionalityTier: input?.proportionalityTier,
+    frcSignalCount: sigs.length,
+    frcGated: sigs.some((s) => s.gated),
+  };
+}