capacity-attest 0.1.2 → 0.2.0

package/dist/schema.d.ts

@@ -3,6 +3,157 @@ export declare const ASSET_TYPES: readonly ["gpu-hours", "storage", "api-credits
 export type AssetType = (typeof ASSET_TYPES)[number];
 export declare const DELIVERED_VALUES: readonly ["yes", "no", "partial"];
 export type Delivered = (typeof DELIVERED_VALUES)[number];
+export declare const MEASURED_UNITS: readonly ["gpu-second", "byte", "byte-second", "call", "token", "credit"];
+export type MeasuredUnit = (typeof MEASURED_UNITS)[number];
+export declare const MEASURED_BASIS_VALUES: readonly ["supplied", "consumed"];
+export type MeasuredBasis = (typeof MEASURED_BASIS_VALUES)[number];
+export declare const MEASURED_ATTRIBUTION_VALUES: readonly ["buyer", "seller", "third-party", "undisclosed"];
+export type MeasuredAttribution = (typeof MEASURED_ATTRIBUTION_VALUES)[number];
+/**
+ * Which units are meaningful for which assetType. A literal 4-row table, not
+ * a derivation: there is nothing here to infer, and therefore nothing that
+ * can differ between reimplementations in other languages.
+ */
+export declare const UNITS_BY_ASSET_TYPE: Record<AssetType, readonly MeasuredUnit[]>;
+/**
+ * The `measured` block. Strict: unknown keys are REFUSED, not stripped —
+ * stripping would let a producer believe it is sending data that silently
+ * falls out of the preimage. `readingsHash` is the only optional key in the
+ * block, because its absence itself carries meaning (there either is a pinned
+ * meter dump or there is not); making any other field optional would add a
+ * branch to the canonicalization without absence saying anything.
+ */
+export declare const MeasuredSchema: z.ZodObject<{
+    unit: z.ZodEnum<{
+        "gpu-second": "gpu-second";
+        byte: "byte";
+        "byte-second": "byte-second";
+        call: "call";
+        token: "token";
+        credit: "credit";
+    }>;
+    basis: z.ZodEnum<{
+        supplied: "supplied";
+        consumed: "consumed";
+    }>;
+    promisedAmount: z.ZodString;
+    deliveredAmount: z.ZodString;
+    period: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+    }, z.core.$strict>;
+    method: z.ZodObject<{
+        attribution: z.ZodEnum<{
+            buyer: "buyer";
+            seller: "seller";
+            "third-party": "third-party";
+            undisclosed: "undisclosed";
+        }>;
+        instrument: z.ZodString;
+        readingsHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type Measured = z.infer<typeof MeasuredSchema>;
+export declare const ClaimContentObject: z.ZodObject<{
+    sellerAddress: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    buyerAddress: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    assetType: z.ZodEnum<{
+        "gpu-hours": "gpu-hours";
+        storage: "storage";
+        "api-credits": "api-credits";
+        bandwidth: "bandwidth";
+    }>;
+    promisedSpec: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    delivered: z.ZodEnum<{
+        yes: "yes";
+        no: "no";
+        partial: "partial";
+    }>;
+    evidenceHash: z.ZodString;
+    settlementRef: z.ZodString;
+    timestamp: z.ZodString;
+    measured: z.ZodOptional<z.ZodObject<{
+        unit: z.ZodEnum<{
+            "gpu-second": "gpu-second";
+            byte: "byte";
+            "byte-second": "byte-second";
+            call: "call";
+            token: "token";
+            credit: "credit";
+        }>;
+        basis: z.ZodEnum<{
+            supplied: "supplied";
+            consumed: "consumed";
+        }>;
+        promisedAmount: z.ZodString;
+        deliveredAmount: z.ZodString;
+        period: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, z.core.$strict>;
+        method: z.ZodObject<{
+            attribution: z.ZodEnum<{
+                buyer: "buyer";
+                seller: "seller";
+                "third-party": "third-party";
+                undisclosed: "undisclosed";
+            }>;
+            instrument: z.ZodString;
+            readingsHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export declare const DeliveryClaimObject: z.ZodObject<{
+    sellerAddress: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    buyerAddress: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    assetType: z.ZodEnum<{
+        "gpu-hours": "gpu-hours";
+        storage: "storage";
+        "api-credits": "api-credits";
+        bandwidth: "bandwidth";
+    }>;
+    promisedSpec: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    delivered: z.ZodEnum<{
+        yes: "yes";
+        no: "no";
+        partial: "partial";
+    }>;
+    evidenceHash: z.ZodString;
+    settlementRef: z.ZodString;
+    timestamp: z.ZodString;
+    measured: z.ZodOptional<z.ZodObject<{
+        unit: z.ZodEnum<{
+            "gpu-second": "gpu-second";
+            byte: "byte";
+            "byte-second": "byte-second";
+            call: "call";
+            token: "token";
+            credit: "credit";
+        }>;
+        basis: z.ZodEnum<{
+            supplied: "supplied";
+            consumed: "consumed";
+        }>;
+        promisedAmount: z.ZodString;
+        deliveredAmount: z.ZodString;
+        period: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, z.core.$strict>;
+        method: z.ZodObject<{
+            attribution: z.ZodEnum<{
+                buyer: "buyer";
+                seller: "seller";
+                "third-party": "third-party";
+                undisclosed: "undisclosed";
+            }>;
+            instrument: z.ZodString;
+            readingsHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    claimId: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>;
 export declare const ClaimContentSchema: z.ZodObject<{
     sellerAddress: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     buyerAddress: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
@@ -21,6 +172,36 @@ export declare const ClaimContentSchema: z.ZodObject<{
     evidenceHash: z.ZodString;
     settlementRef: z.ZodString;
     timestamp: z.ZodString;
+    measured: z.ZodOptional<z.ZodObject<{
+        unit: z.ZodEnum<{
+            "gpu-second": "gpu-second";
+            byte: "byte";
+            "byte-second": "byte-second";
+            call: "call";
+            token: "token";
+            credit: "credit";
+        }>;
+        basis: z.ZodEnum<{
+            supplied: "supplied";
+            consumed: "consumed";
+        }>;
+        promisedAmount: z.ZodString;
+        deliveredAmount: z.ZodString;
+        period: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, z.core.$strict>;
+        method: z.ZodObject<{
+            attribution: z.ZodEnum<{
+                buyer: "buyer";
+                seller: "seller";
+                "third-party": "third-party";
+                undisclosed: "undisclosed";
+            }>;
+            instrument: z.ZodString;
+            readingsHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 export type ClaimContent = z.infer<typeof ClaimContentSchema>;
 /** The full, stored, signed claim — ClaimContent plus its content-address and signature. */
@@ -42,6 +223,36 @@ export declare const DeliveryClaimSchema: z.ZodObject<{
     evidenceHash: z.ZodString;
     settlementRef: z.ZodString;
     timestamp: z.ZodString;
+    measured: z.ZodOptional<z.ZodObject<{
+        unit: z.ZodEnum<{
+            "gpu-second": "gpu-second";
+            byte: "byte";
+            "byte-second": "byte-second";
+            call: "call";
+            token: "token";
+            credit: "credit";
+        }>;
+        basis: z.ZodEnum<{
+            supplied: "supplied";
+            consumed: "consumed";
+        }>;
+        promisedAmount: z.ZodString;
+        deliveredAmount: z.ZodString;
+        period: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, z.core.$strict>;
+        method: z.ZodObject<{
+            attribution: z.ZodEnum<{
+                buyer: "buyer";
+                seller: "seller";
+                "third-party": "third-party";
+                undisclosed: "undisclosed";
+            }>;
+            instrument: z.ZodString;
+            readingsHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
     claimId: z.ZodString;
     signature: z.ZodString;
 }, z.core.$strip>;
@@ -53,6 +264,18 @@ export type DeliveryClaim = z.infer<typeof DeliveryClaimSchema>;
  * sorted.
  */
 export declare function canonicalize(value: unknown): string;
+/**
+ * The EXACT bytes that get hashed for a claim, as a string.
+ *
+ * Exported because canonicalize() on its own is NOT the preimage, and that is
+ * the single most likely thing to get wrong when reimplementing this in
+ * another language: the preimage is `canonicalize(ClaimContentSchema.parse(content))`,
+ * not `canonicalize(content)`. The parse step is what lower-cases the two
+ * address fields and strips unknown top-level keys. Port only canonicalize()
+ * and you will silently produce wrong ids for any claim submitted with
+ * mixed-case addresses.
+ */
+export declare function claimPreimage(content: ClaimContent): string;
 /**
  * Content-addressed id for a claim: sha256 of the canonical JSON of its
  * content fields (everything except claimId and signature themselves).
@@ -60,4 +283,106 @@ export declare function canonicalize(value: unknown): string;
  * over a shape that wouldn't itself pass ClaimContentSchema.
  */
 export declare function computeClaimId(content: ClaimContent): string;
+/** ClaimContentSchema plus the ingest hardening of S-1..S-6. Used by recordDelivery(), never by computeClaimId(). */
+export declare const StrictClaimContentSchema: z.ZodObject<{
+    sellerAddress: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    buyerAddress: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    assetType: z.ZodEnum<{
+        "gpu-hours": "gpu-hours";
+        storage: "storage";
+        "api-credits": "api-credits";
+        bandwidth: "bandwidth";
+    }>;
+    promisedSpec: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    delivered: z.ZodEnum<{
+        yes: "yes";
+        no: "no";
+        partial: "partial";
+    }>;
+    evidenceHash: z.ZodString;
+    settlementRef: z.ZodString;
+    timestamp: z.ZodString;
+    measured: z.ZodOptional<z.ZodObject<{
+        unit: z.ZodEnum<{
+            "gpu-second": "gpu-second";
+            byte: "byte";
+            "byte-second": "byte-second";
+            call: "call";
+            token: "token";
+            credit: "credit";
+        }>;
+        basis: z.ZodEnum<{
+            supplied: "supplied";
+            consumed: "consumed";
+        }>;
+        promisedAmount: z.ZodString;
+        deliveredAmount: z.ZodString;
+        period: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, z.core.$strict>;
+        method: z.ZodObject<{
+            attribution: z.ZodEnum<{
+                buyer: "buyer";
+                seller: "seller";
+                "third-party": "third-party";
+                undisclosed: "undisclosed";
+            }>;
+            instrument: z.ZodString;
+            readingsHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+/** DeliveryClaimSchema plus the ingest hardening of S-1..S-6. This is what record_delivery validates against. */
+export declare const StrictDeliveryClaimSchema: z.ZodObject<{
+    sellerAddress: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    buyerAddress: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    assetType: z.ZodEnum<{
+        "gpu-hours": "gpu-hours";
+        storage: "storage";
+        "api-credits": "api-credits";
+        bandwidth: "bandwidth";
+    }>;
+    promisedSpec: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    delivered: z.ZodEnum<{
+        yes: "yes";
+        no: "no";
+        partial: "partial";
+    }>;
+    evidenceHash: z.ZodString;
+    settlementRef: z.ZodString;
+    timestamp: z.ZodString;
+    measured: z.ZodOptional<z.ZodObject<{
+        unit: z.ZodEnum<{
+            "gpu-second": "gpu-second";
+            byte: "byte";
+            "byte-second": "byte-second";
+            call: "call";
+            token: "token";
+            credit: "credit";
+        }>;
+        basis: z.ZodEnum<{
+            supplied: "supplied";
+            consumed: "consumed";
+        }>;
+        promisedAmount: z.ZodString;
+        deliveredAmount: z.ZodString;
+        period: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, z.core.$strict>;
+        method: z.ZodObject<{
+            attribution: z.ZodEnum<{
+                buyer: "buyer";
+                seller: "seller";
+                "third-party": "third-party";
+                undisclosed: "undisclosed";
+            }>;
+            instrument: z.ZodString;
+            readingsHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    claimId: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,eAAO,MAAM,WAAW,+DAAgE,CAAC;AACzF,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,eAAO,MAAM,gBAAgB,mCAAoC,CAAC;AAClE,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAoD1D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;iBA6C7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,4FAA4F;AAC5F,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;iBAS9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEnD;AA+BD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAI5D"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,eAAO,MAAM,WAAW,+DAAgE,CAAC;AACzF,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,eAAO,MAAM,gBAAgB,mCAAoC,CAAC;AAClE,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAkF1D,eAAO,MAAM,cAAc,2EAA4E,CAAC;AACxG,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D,eAAO,MAAM,qBAAqB,mCAAoC,CAAC;AACvE,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AASnE,eAAO,MAAM,2BAA2B,4DAA6D,CAAC;AACtG,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/E;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,SAAS,EAAE,SAAS,YAAY,EAAE,CAK1E,CAAC;AA4HF;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkCzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAkEtD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyD7B,CAAC;AAWH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG9B,CAAC;AASH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA2D,CAAC;AAC3F,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,4FAA4F;AAC5F,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA4D,CAAC;AAC7F,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEnD;AA+BD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAE3D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAG5D;AAoLD,qHAAqH;AACrH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA6F,CAAC;AAEnI,iHAAiH;AACjH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA8F,CAAC"}

package/dist/schema.js

@@ -16,6 +16,10 @@ export const ASSET_TYPES = ["gpu-hours", "storage", "api-credits", "bandwidth"];
 export const DELIVERED_VALUES = ["yes", "no", "partial"];
 const ETH_ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
 const SHA256_HEX_RE = /^[0-9a-fA-F]{64}$/;
+// Lower-case-only sha256 hex. Used for readingsHash (new in 0.2.0, so it can
+// be strict from day one) and, at ingest only, for evidenceHash — see
+// StrictClaimContentSchema below and the 0.1.3 section of CHANGELOG.md (S-3).
+const LOWER_SHA256_HEX_RE = /^[0-9a-f]{64}$/;
 const CLAIM_ID_RE = /^0x[0-9a-fA-F]{64}$/;
 // 65-byte ECDSA signature (r ++ s ++ v), hex-encoded with 0x prefix — the
 // shape ethers.Signer#signMessage() / ethers.verifyMessage() produce.
@@ -64,7 +68,247 @@ function exceedsMaxDepth(value, maxDepth) {
     }
     return false;
 }
-export const ClaimContentSchema = z.object({
+// ---------------------------------------------------------------------------
+// `measured` — the optional quantitative block, added in 0.2.0.
+//
+// Full, language-neutral rules: the 0.1.3 section of CHANGELOG.md. The
+// short version of the architecture, because it is the thing that is easy to
+// break by accident:
+//
+//   THE PREIMAGE FUNCTION IS FROZEN. canonicalize(), sortKeysDeep() and the
+//   sha256 step do not change. Everything that gets stricter is a REFUSAL AT
+//   INPUT, never a transformation on the hash route.
+//
+// `measured` is added to ClaimContentSchema (the schema computeClaimId()
+// parses through) as exactly one `.optional()` key — no .default(), no
+// .passthrough(), no .catchall(). A .default() would materialize the key and
+// change the preimage of every already-recorded claim. Its validation lives
+// here rather than only at ingest because it IS preimage-relevant: a
+// non-canonical decimal must never be hashable.
+//
+// Its presence is the version marker; there is deliberately no `scheme`
+// string inside the block. A 0.1.x node reading a 0.2 claim strips the
+// unknown `measured` key, computes the v1 id, and answers claimId_mismatch —
+// it refuses rather than silently accepting unverified measurement data,
+// which is the safe failure direction and is the reason `measured` sits
+// INSIDE the hashed content instead of next to it.
+// ---------------------------------------------------------------------------
+export const MEASURED_UNITS = ["gpu-second", "byte", "byte-second", "call", "token", "credit"];
+export const MEASURED_BASIS_VALUES = ["supplied", "consumed"];
+// Provenance of the number, and nothing else. This enum is deliberately NOT
+// ranked: nowhere in this codebase or its docs does "third-party" mean
+// "better than seller". There is no reliability/quality/trust field and there
+// will not be one — every field in a claim is an assertion by the buyer.
+// `undisclosed` exists because attribution is mandatory: without an escape
+// hatch, someone unwilling to name the source would just pick an untrue
+// value. Withholding should be visible, not silent.
+export const MEASURED_ATTRIBUTION_VALUES = ["buyer", "seller", "third-party", "undisclosed"];
+/**
+ * Which units are meaningful for which assetType. A literal 4-row table, not
+ * a derivation: there is nothing here to infer, and therefore nothing that
+ * can differ between reimplementations in other languages.
+ */
+export const UNITS_BY_ASSET_TYPE = {
+    "gpu-hours": ["gpu-second"],
+    storage: ["byte", "byte-second"],
+    bandwidth: ["byte"],
+    "api-credits": ["call", "token", "credit"],
+};
+// CDEC — canonical decimal string. ASCII [0-9], never \d: Python's `re`
+// matches \d on U+0664 (Arabic-Indic four) while JavaScript does not, so a
+// spec written with \d is impossible to implement identically in both.
+// No sign (quantities are non-negative, which also removes -0 entirely), no
+// exponent, no leading zeros, integer part mandatory and at most 30 digits,
+// optional fraction of 1..18 digits whose last digit is not 0. Exactly one
+// legal string per value, in both directions.
+const CDEC_RE = /^(0|[1-9][0-9]{0,29})(\.[0-9]{0,17}[1-9])?$/;
+// CINST — canonical UTC instant, exactly 20 characters. No offsets (those are
+// refused, not converted: converting would be a transformation on the hash
+// route), no fractional seconds, no 24:00:00, no leap second :60, no
+// date-only form. Every field is fixed-width and pinned to Z, so a plain
+// lexicographic byte comparison of two CINST strings is identical to
+// chronological ordering — which is why no time rule in this schema needs a
+// date library.
+const CINST_RE = /^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]Z$/;
+// The form `timestamp` must have when `measured` is present (and, at ingest,
+// the form it must have for every new claim — see S-2).
+//
+// EXACTLY three fractional digits, not one-to-nine. An earlier version of
+// this rule allowed `(\.[0-9]{1,9})?`, which closed the four spellings named
+// in the original defect report but left the whole family around them open:
+// `…:00Z`, `…:00.0Z`, `…:00.00Z`, `…:00.000Z` and `…:00.000000000Z` are five
+// spellings of one instant, and each hashed to its own claimId. That was
+// demonstrated end to end, not theorised: one buyer, one seller, one
+// settlementRef, one moment, five accepted ledger rows, and the duplicate
+// check never fired because it keys on bytes the schema had not made
+// canonical. A seller could inflate a delivery history tenfold without
+// breaking a single rule. It is precisely the failure this file's own S-3
+// message describes for evidence hashes ("upper-case hex mints a second
+// claimId for the same evidence"), one field over.
+//
+// Three digits costs nothing: the only claim producer that has ever existed
+// here is `new Date().toISOString()`, which always emits exactly three,
+// including the real production claim in data-selftest/claims.jsonl
+// (2026-08-31T18:06:48.102Z). One spelling per millisecond, no producer
+// broken. `measured.period` already had this discipline via CINST; the
+// claim's own timestamp did not.
+const MEASURED_TIMESTAMP_RE = /^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]\.[0-9]{3}Z$/;
+const MAX_INSTRUMENT_LENGTH = 200;
+/**
+ * Real calendar check for a YYYY-MM-DD prefix. The regexes above still let
+ * 2026-02-30 through; this closes that without pulling in a date library, so
+ * a reimplementation in any language can copy these six lines verbatim.
+ */
+function isRealCalendarDate(isoPrefix) {
+    const y = Number(isoPrefix.slice(0, 4));
+    const m = Number(isoPrefix.slice(5, 7));
+    const d = Number(isoPrefix.slice(8, 10));
+    const leap = (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0;
+    const daysInMonth = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][m - 1];
+    return d >= 1 && d <= daysInMonth;
+}
+/**
+ * True if `s` contains a C0 control character (U+0000-U+001F), U+007F, or a
+ * lone surrogate. Hygiene and log-injection safety, not a determinism
+ * requirement — the escape rules in the spec already cover determinism
+ * completely.
+ */
+function hasForbiddenTextChars(s) {
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c <= 0x1f || c === 0x7f)
+            return true;
+        if (c >= 0xd800 && c <= 0xdbff) {
+            const next = s.charCodeAt(i + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                return true;
+            i++; // valid surrogate pair — skip the low half
+        }
+        else if (c >= 0xdc00 && c <= 0xdfff) {
+            return true; // lone low surrogate
+        }
+    }
+    return false;
+}
+/**
+ * True if `s` contains a LONE surrogate: an unpaired U+D800..U+DFFF code
+ * unit. Deliberately NARROWER than hasForbiddenTextChars above, and used for
+ * a different reason.
+ *
+ * hasForbiddenTextChars is hygiene (log-injection safety). This is a
+ * PORTABILITY rule, and it is the only text property that makes a string
+ * genuinely unrepresentable outside JavaScript: a lone surrogate has no UTF-8
+ * encoding at all, so `Buffer.from(s, "utf8").toString("utf8") !== s` (this
+ * package measured that directly). JavaScript hides the problem because
+ * well-formed JSON.stringify escapes it to "\ud800" and JS strings are
+ * UTF-16, but a verifier written in Rust (`String` is UTF-8 by definition),
+ * Go, or Python cannot reconstruct the preimage bytes at all. That is the
+ * same failure mode S-5 closes for object KEYS, left open for string VALUES.
+ * See S-6 below.
+ */
+function hasLoneSurrogate(s) {
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c >= 0xd800 && c <= 0xdbff) {
+            const next = s.charCodeAt(i + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                return true;
+            i++; // valid surrogate pair — skip the low half
+        }
+        else if (c >= 0xdc00 && c <= 0xdfff) {
+            return true; // lone low surrogate
+        }
+    }
+    return false;
+}
+const CinstSchema = z
+    .string()
+    .regex(CINST_RE, "must be a canonical UTC instant: YYYY-MM-DDTHH:MM:SSZ, exactly 20 chars, no offset, no fractional seconds")
+    .refine(isRealCalendarDate, "must be a real calendar date (e.g. 2026-02-30 does not exist)");
+const CdecSchema = z
+    .string()
+    .regex(CDEC_RE, "must be a canonical decimal string: no sign, no exponent, no leading zeros, at most 30 integer digits, optional 1..18 fraction digits not ending in 0");
+/**
+ * The `measured` block. Strict: unknown keys are REFUSED, not stripped —
+ * stripping would let a producer believe it is sending data that silently
+ * falls out of the preimage. `readingsHash` is the only optional key in the
+ * block, because its absence itself carries meaning (there either is a pinned
+ * meter dump or there is not); making any other field optional would add a
+ * branch to the canonicalization without absence saying anything.
+ */
+export const MeasuredSchema = z.strictObject({
+    unit: z.enum(MEASURED_UNITS).describe("Unit of the quantities below — must be in this assetType's row of UNITS_BY_ASSET_TYPE"),
+    basis: z
+        .enum(MEASURED_BASIS_VALUES)
+        .describe("Does the number count what the seller made available (`supplied`) or what the buyer actually drew (`consumed`)"),
+    promisedAmount: CdecSchema.refine((v) => v !== "0", 'promisedAmount must not be "0" — a promise of nothing is meaningless').describe("How much was promised, as a canonical decimal string"),
+    deliveredAmount: CdecSchema.describe("How much was measured, as a canonical decimal string"),
+    period: z
+        .strictObject({
+        start: CinstSchema.describe("Start of the closed measurement window, canonical UTC instant"),
+        end: CinstSchema.describe("End of the closed measurement window, canonical UTC instant"),
+    })
+        .refine((p) => p.start < p.end, "period.start must be strictly before period.end — a zero-length window is meaningless")
+        .describe("The closed window this measurement covers"),
+    method: z
+        .strictObject({
+        attribution: z
+            .enum(MEASURED_ATTRIBUTION_VALUES)
+            .describe("WHO produced the number — provenance only, never a quality or trust signal"),
+        instrument: z
+            .string()
+            .min(1, "instrument is required and must not be empty")
+            .max(MAX_INSTRUMENT_LENGTH)
+            .refine((v) => !hasForbiddenTextChars(v), "instrument must not contain C0 control characters, U+007F, or lone surrogates")
+            .describe('Free text about the measuring instrument, e.g. "nvidia-smi accounting, 10s polling"'),
+        readingsHash: z
+            .string()
+            .regex(LOWER_SHA256_HEX_RE, "readingsHash must be a lower-case sha256 hex digest (64 chars, no 0x prefix)")
+            .optional()
+            .describe("sha256 of the raw meter dump — the dump itself is not stored. Separate from evidenceHash, which is about delivery evidence"),
+    })
+        .describe("How the number was obtained"),
+});
+function checkMeasuredConsistency(content, ctx) {
+    const measured = content.measured;
+    if (!measured)
+        return;
+    // §5.2 — unit must sit in this assetType's row. Pure lookup.
+    const allowed = UNITS_BY_ASSET_TYPE[content.assetType];
+    if (!allowed.includes(measured.unit)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["measured", "unit"],
+            message: `unit "${measured.unit}" is not valid for assetType "${content.assetType}" (allowed: ${allowed.join(", ")})`,
+        });
+    }
+    // §5.3 — the period must be closed, i.e. it ended no later than the moment
+    // the claim was made. Two parts.
+    if (!MEASURED_TIMESTAMP_RE.test(content.timestamp) || !isRealCalendarDate(content.timestamp)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["timestamp"],
+            message: "when `measured` is present, timestamp must be a strict UTC instant YYYY-MM-DDTHH:MM:SS[.fff]Z with a real calendar date",
+        });
+        return;
+    }
+    // The 19-CHARACTER PREFIX RULE, and it has to be the prefix, not the whole
+    // string. Comparing full strings is wrong the moment `timestamp` carries
+    // fractional seconds inside the same second the period closed:
+    // "2026-09-01T08:00:00Z" <= "2026-09-01T08:00:00.102Z" is FALSE, because
+    // "." (0x2E) sorts before "Z" (0x5A). YYYY-MM-DDTHH:MM:SS is fixed-width
+    // and zero-padded, so prefix-lexicographic IS chronological, and truncating
+    // the fraction can only err conservatively (the fraction can only push the
+    // timestamp later).
+    if (measured.period.end.slice(0, 19) > content.timestamp.slice(0, 19)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["measured", "period", "end"],
+            message: "period.end must not be after timestamp (compared on the first 19 characters) — a claim covers a closed past window",
+        });
+    }
+}
+export const ClaimContentObject = z.object({
     // .transform(toLowerCase): a fuzz-and-benchmark audit found that
     // computeClaimId() hashed addresses exactly as submitted while every other
     // address comparison in this codebase (signature recovery, seller
@@ -108,20 +352,41 @@ export const ClaimContentSchema = z.object({
         .describe("x402 payment reference or on-chain tx hash for the settlement this claim is about"),
     timestamp: z
         .string()
+        // FROZEN, deliberately loose. Date.parse accepts "August 30, 2026" and
+        // date-only forms, which is far more permissive than the field's own
+        // documentation. It stays this way here so historical ledger lines remain
+        // recomputable; StrictClaimContentSchema (S-2) tightens it for everything
+        // new. This inconsistency is intentional and documented.
         .refine((v) => !Number.isNaN(Date.parse(v)), "timestamp must be a valid ISO-8601 date string")
         .describe("ISO-8601 timestamp of when this claim was made"),
+    // The one and only addition of 0.2.0. Optional, never defaulted: an absent
+    // key is absent from the preimage, so every claim recorded before 0.2.0
+    // hashes bit-for-bit identically (proven in schema.test.ts against the real
+    // production claim in data-selftest/claims.jsonl).
+    measured: MeasuredSchema.optional().describe("Optional quantitative record of how much was promised and how much was measured. Presence is the version marker; absence is the only encoding of 'not measured'"),
 });
-/** The full, stored, signed claim — ClaimContent plus its content-address and signature. */
-export const DeliveryClaimSchema = ClaimContentSchema.extend({
-    claimId: z
-        .string()
-        .regex(CLAIM_ID_RE, "claimId must be a 0x-prefixed sha256 hex digest")
-        .describe("Content-addressed id: sha256 of the canonical JSON of this claim's content fields — see computeClaimId()"),
-    signature: z
-        .string()
-        .regex(SIGNATURE_RE, "signature must be a 0x-prefixed 65-byte ECDSA signature")
-        .describe("Buyer's EIP-191 personal-sign signature over claimId"),
+const claimIdField = z
+    .string()
+    .regex(CLAIM_ID_RE, "claimId must be a 0x-prefixed sha256 hex digest")
+    .describe("Content-addressed id: sha256 of the canonical JSON of this claim's content fields — see computeClaimId()");
+const signatureField = z
+    .string()
+    .regex(SIGNATURE_RE, "signature must be a 0x-prefixed 65-byte ECDSA signature")
+    .describe("Buyer's EIP-191 personal-sign signature over claimId");
+export const DeliveryClaimObject = ClaimContentObject.extend({
+    claimId: claimIdField,
+    signature: signatureField,
 });
+// The cross-field checks are attached to each schema separately rather than
+// inherited, because zod v4's .extend() DROPS checks from the schema it
+// extends (measured directly: a .superRefine()'d object that is then
+// .extend()ed no longer runs the refinement). Attaching per schema is the
+// only shape that keeps ClaimContentSchema and DeliveryClaimSchema in
+// agreement. Both keep a working `.shape` (index.ts's MCP tool registration
+// depends on that), which .superRefine() on a ZodObject does preserve.
+export const ClaimContentSchema = ClaimContentObject.superRefine(checkMeasuredConsistency);
+/** The full, stored, signed claim — ClaimContent plus its content-address and signature. */
+export const DeliveryClaimSchema = DeliveryClaimObject.superRefine(checkMeasuredConsistency);
 /**
  * Deterministic JSON stringify: object keys sorted recursively so hashing
  * and signing are stable regardless of the original key insertion order.
@@ -160,6 +425,20 @@ function sortKeysDeep(value, depth) {
     }
     return value;
 }
+/**
+ * The EXACT bytes that get hashed for a claim, as a string.
+ *
+ * Exported because canonicalize() on its own is NOT the preimage, and that is
+ * the single most likely thing to get wrong when reimplementing this in
+ * another language: the preimage is `canonicalize(ClaimContentSchema.parse(content))`,
+ * not `canonicalize(content)`. The parse step is what lower-cases the two
+ * address fields and strips unknown top-level keys. Port only canonicalize()
+ * and you will silently produce wrong ids for any claim submitted with
+ * mixed-case addresses.
+ */
+export function claimPreimage(content) {
+    return canonicalize(ClaimContentSchema.parse(content));
+}
 /**
  * Content-addressed id for a claim: sha256 of the canonical JSON of its
  * content fields (everything except claimId and signature themselves).
@@ -167,8 +446,190 @@ function sortKeysDeep(value, depth) {
  * over a shape that wouldn't itself pass ClaimContentSchema.
  */
 export function computeClaimId(content) {
-    const parsed = ClaimContentSchema.parse(content);
-    const hash = createHash("sha256").update(canonicalize(parsed)).digest("hex");
+    const hash = createHash("sha256").update(claimPreimage(content)).digest("hex");
     return `0x${hash}`;
 }
+// ---------------------------------------------------------------------------
+// StrictClaimContentSchema — ingest hardening (S-1 .. S-6).
+//
+// None of this touches the preimage and none of it changes any existing
+// claimId. These rules apply ONLY to newly submitted claims, via
+// recordDelivery(). Historical ledger lines are always recomputed through the
+// FROZEN ClaimContentSchema above and therefore stay verifiable even when
+// they contain something (a float in promisedSpec, a loose timestamp) that
+// S-1/S-2 now refuse for new claims.
+//
+// Second reason these are refusals rather than normalizations: if the schema
+// guarantees the incoming bytes are already canonical, a verifier in Rust or
+// Go needs no arithmetic at all — no decimal library, no date parser, no ICU.
+// It hashes what it gets. The only transformation left anywhere on the hash
+// route is the ASCII lower-casing of the two address fields, which is v1
+// legacy.
+// ---------------------------------------------------------------------------
+const MAX_SAFE_SPEC_INT = Number.MAX_SAFE_INTEGER; // 2^53 - 1
+/** True if `key` contains a surrogate code unit — i.e. a lone surrogate OR any astral character (S-5). */
+function keyHasSurrogate(key) {
+    for (let i = 0; i < key.length; i++) {
+        const c = key.charCodeAt(i);
+        if (c >= 0xd800 && c <= 0xdfff)
+            return true;
+    }
+    return false;
+}
+function isPlainObject(v) {
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * S-1 + S-5 + S-6, walked iteratively (never recursively — same reasoning as
+ * exceedsMaxDepth above) over the object branch of promisedSpec.
+ *
+ * S-1 closes a REAL, MEASURED collision in 0.1.x, not a theoretical one:
+ * today NaN, Infinity, -Infinity and null in promisedSpec all produce the
+ * SAME claimId (JSON.stringify renders all four as `null`), and -0 and 0 do
+ * too. Allowed value types are therefore: string, boolean, null, array,
+ * plain object, and a number that is an INTEGER within [-(2^53-1), 2^53-1].
+ * Anything needing a fraction goes in as a decimal string.
+ *
+ * S-5 refuses object keys containing surrogate code units — lone surrogates
+ * and anything at or above U+10000. That kills the UTF-16-versus-code-point
+ * key-sorting divergence at the source for everything new: JavaScript sorts
+ * U+1F600 before U+FF01, while a code-point sort (Python `sorted()`, Go
+ * string ordering, Rust BTreeMap) gives the opposite. The sort rule stays
+ * normative for READING historical lines back.
+ *
+ * S-6 refuses LONE surrogates in promisedSpec STRINGS — both the string
+ * branch of the union and every string value inside the object branch. S-5
+ * closed this for keys only, which left the identical portability hole open
+ * one field over: a lone surrogate has no UTF-8 encoding, so a Rust/Go/Python
+ * verifier cannot reconstruct the preimage bytes even though JavaScript
+ * happily round-trips it. Note what S-6 does NOT do: astral characters
+ * (U+1F600 and friends) stay ALLOWED in string values, because they encode
+ * fine in UTF-8 and only KEY ordering was ever ambiguous; and C0 control
+ * characters stay ALLOWED in promisedSpec, unlike in settlementRef (S-4),
+ * because JSON.stringify escapes them deterministically, they cost nothing in
+ * portability, and promisedSpec is documented free text where a newline is a
+ * legitimate thing for a caller to write. Refusing them here would be
+ * unjustified scope creep with a real usability cost.
+ *
+ * Returns null when fine, or a human-readable reason.
+ */
+const LONE_SURROGATE_PROBLEM = "promisedSpec strings must not contain lone surrogates — an unpaired UTF-16 half has no UTF-8 encoding, so a verifier in another language cannot reconstruct the preimage bytes";
+function promisedSpecIngestProblem(spec) {
+    // The string branch: S-1/S-5 do not apply to it, but S-6 does.
+    if (typeof spec === "string")
+        return hasLoneSurrogate(spec) ? LONE_SURROGATE_PROBLEM : null;
+    // Depth AND visited tracking are both load-bearing, for a reason that is
+    // easy to miss: in zod v4 a failing `.refine()` is NON-ABORTING, so the
+    // MAX_DEPTH refine on promisedSpec does NOT stop this walker from also
+    // running on the same raw, already-rejected input. Without the bounds
+    // below, two ordinary inputs hang the process:
+    //   - a cyclic object: infinite stack growth, RangeError after ~20s of a
+    //     fully blocked event loop;
+    //   - an acyclic DAG of just 41 objects at depth 40 (`let n={leaf:1};
+    //     for(i<40) n={x:n,y:n}`): shared references get re-expanded once per
+    //     path, so the walker explores ~2^40 nodes and never returns.
+    // Both were measured against a real build; the frozen route rejects the
+    // second in 4ms while this walker ran past 55 seconds. Bounding depth at
+    // MAX_DEPTH costs nothing (anything deeper is rejected anyway) and the
+    // visited set collapses shared references back to one visit each.
+    const stack = [{ v: spec, d: 0 }];
+    const visited = new Set();
+    while (stack.length > 0) {
+        const { v, d } = stack.pop();
+        if (d > MAX_DEPTH)
+            continue; // the frozen route's own depth refine reports this
+        if (v === null)
+            continue;
+        if (typeof v === "object") {
+            if (visited.has(v))
+                continue;
+            visited.add(v);
+        }
+        const t = typeof v;
+        if (t === "string") {
+            // S-6, for every string value at any depth.
+            if (hasLoneSurrogate(v))
+                return LONE_SURROGATE_PROBLEM;
+            continue;
+        }
+        if (t === "boolean")
+            continue;
+        if (t === "number") {
+            const n = v;
+            if (!Number.isFinite(n))
+                return "promisedSpec must not contain NaN or Infinity (all of NaN, Infinity, -Infinity and null hash identically)";
+            if (!Number.isInteger(n))
+                return "promisedSpec numbers must be integers — use a decimal string for fractional values";
+            if (Object.is(n, -0))
+                return "promisedSpec must not contain -0 (it hashes identically to 0)";
+            if (n > MAX_SAFE_SPEC_INT || n < -MAX_SAFE_SPEC_INT)
+                return "promisedSpec integers must be within [-(2^53-1), 2^53-1]";
+            continue;
+        }
+        if (Array.isArray(v)) {
+            for (const item of v)
+                stack.push({ v: item, d: d + 1 });
+            continue;
+        }
+        if (t === "object") {
+            const obj = v;
+            if (!isPlainObject(obj))
+                return "promisedSpec must contain only plain objects and arrays (no Date, Map, Set, RegExp or class instances)";
+            if (typeof obj.toJSON === "function")
+                return "promisedSpec must not contain an object with its own toJSON";
+            for (const key of Object.keys(obj)) {
+                if (keyHasSurrogate(key)) {
+                    return "promisedSpec object keys must not contain surrogate code units (no lone surrogates and no characters at or above U+10000)";
+                }
+                stack.push({ v: obj[key], d: d + 1 });
+            }
+            continue;
+        }
+        return `promisedSpec must not contain a value of type ${t}`;
+    }
+    return null;
+}
+function checkIngestHardening(content, ctx) {
+    // S-1 + S-5 + S-6
+    const specProblem = promisedSpecIngestProblem(content.promisedSpec);
+    if (specProblem)
+        ctx.addIssue({ code: "custom", path: ["promisedSpec"], message: specProblem });
+    // S-2 — new claims must carry a strict UTC timestamp with a real calendar
+    // date. Closes the gap where "August 30, 2026" and date-only forms were
+    // accepted. Every producer in this codebase already emits
+    // new Date().toISOString(), which satisfies this unchanged.
+    if (!MEASURED_TIMESTAMP_RE.test(content.timestamp) || !isRealCalendarDate(content.timestamp)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["timestamp"],
+            message: "timestamp must be a strict UTC instant YYYY-MM-DDTHH:MM:SS[.fff]Z with a real calendar date",
+        });
+    }
+    // S-3 — hex case. evidenceHash in upper case produces a DIFFERENT claimId
+    // for the same evidence: exactly the duplicate-bypass that was closed for
+    // addresses on 2026-08-31 and left open for evidence. Closed here for new
+    // claims; the frozen schema still accepts either case so older lines keep
+    // recomputing.
+    if (!LOWER_SHA256_HEX_RE.test(content.evidenceHash)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["evidenceHash"],
+            message: "evidenceHash must be lower-case hex — upper-case hex mints a second claimId for the same evidence",
+        });
+    }
+    // S-4 — settlementRef hygiene (log-line injection); the fuzz suite already
+    // documented this gap.
+    if (hasForbiddenTextChars(content.settlementRef)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["settlementRef"],
+            message: "settlementRef must not contain C0 control characters, U+007F, or lone surrogates",
+        });
+    }
+}
+/** ClaimContentSchema plus the ingest hardening of S-1..S-6. Used by recordDelivery(), never by computeClaimId(). */
+export const StrictClaimContentSchema = ClaimContentObject.superRefine(checkMeasuredConsistency).superRefine(checkIngestHardening);
+/** DeliveryClaimSchema plus the ingest hardening of S-1..S-6. This is what record_delivery validates against. */
+export const StrictDeliveryClaimSchema = DeliveryClaimObject.superRefine(checkMeasuredConsistency).superRefine(checkIngestHardening);
 //# sourceMappingURL=schema.js.map

package/dist/schema.js.map

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

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAMA,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAItE,MAAM,MAAM,oBAAoB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjG;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA4BlF;AAED,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,aAAa,EAAE,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAG9F"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAMA,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAI5E,MAAM,MAAM,oBAAoB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjG;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA8ClF;AAED,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,aAAa,EAAE,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAG9F"}

package/dist/tools.js

@@ -3,7 +3,7 @@
 // al-yad-mcp-server's companion-client.ts vs. index.ts). This lets tests
 // and examples/demo.ts call the real logic directly without spinning up a
 // stdio JSON-RPC transport.
-import { DeliveryClaimSchema } from "./schema.js";
+import { StrictDeliveryClaimSchema } from "./schema.js";
 import { verifyClaim } from "./signing.js";
 import { appendClaim, claimsForSeller } from "./ledger.js";
 /**
@@ -18,7 +18,26 @@ import { appendClaim, claimsForSeller } from "./ledger.js";
  * exact read-check-write sequence the lock exists to make atomic.
  */
 export async function recordDelivery(input) {
-    const parsed = DeliveryClaimSchema.safeParse(input);
+    // StrictDeliveryClaimSchema, not DeliveryClaimSchema: new claims must also
+    // pass the ingest hardening of S-1..S-5 (see schema.ts). That schema is a
+    // superset of the frozen one, so it never changes a claimId — it only
+    // refuses input the frozen schema would have accepted. Historical ledger
+    // lines are still read back through the FROZEN DeliveryClaimSchema in
+    // ledger.ts, so a claim recorded before 0.2.0 with (say) a float in
+    // promisedSpec stays readable and verifiable forever.
+    // safeParse() is wrapped for the same reason verifyClaim() below is: the
+    // ingest checks walk caller-supplied data, and hostile or merely odd input
+    // (a cyclic object, a shared-reference graph) has already been shown to
+    // throw from inside a zod check rather than return a failed parse. The
+    // tool's contract is {ok:false, reason}, never an uncaught exception, so
+    // every step that touches untrusted input belongs inside a try/catch.
+    let parsed;
+    try {
+        parsed = StrictDeliveryClaimSchema.safeParse(input);
+    }
+    catch (e) {
+        return { ok: false, reason: `invalid_claim: ${e.message}` };
+    }
     if (!parsed.success) {
         return { ok: false, reason: `invalid_claim: ${parsed.error.issues.map((i) => i.message).join("; ")}` };
     }

package/dist/tools.js.map

@@ -1 +1 @@
-{"version":3,"file":"tools.js","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,uEAAuE;AACvE,yEAAyE;AACzE,0EAA0E;AAC1E,4BAA4B;AAE5B,OAAO,EAAE,mBAAmB,EAAsB,MAAM,aAAa,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAI3D;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,KAAc;IACjD,MAAM,MAAM,GAAG,mBAAmB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACpD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,kBAAkB,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;IACzG,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC;IAC1B,IAAI,OAAuC,CAAC;IAC5C,IAAI,CAAC;QACH,OAAO,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,uEAAuE;QACvE,mEAAmE;QACnE,qEAAqE;QACrE,oDAAoD;QACpD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,kBAAmB,CAAW,CAAC,OAAO,EAAE,EAAE,CAAC;IACzE,CAAC;IACD,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;QAChB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,sBAAsB,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IACvE,CAAC;IAED,IAAI,CAAC;QACH,MAAM,WAAW,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAG,CAAW,CAAC,OAAO,EAAE,CAAC;IACrD,CAAC;IAED,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;AAC9C,CAAC;AAQD;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,aAAqB;IAC5D,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,aAAa,CAAC,CAAC;IACpD,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;AACzD,CAAC"}
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,uEAAuE;AACvE,yEAAyE;AACzE,0EAA0E;AAC1E,4BAA4B;AAE5B,OAAO,EAAE,yBAAyB,EAAsB,MAAM,aAAa,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAI3D;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,KAAc;IACjD,2EAA2E;IAC3E,0EAA0E;IAC1E,sEAAsE;IACtE,yEAAyE;IACzE,sEAAsE;IACtE,oEAAoE;IACpE,sDAAsD;IACtD,yEAAyE;IACzE,2EAA2E;IAC3E,wEAAwE;IACxE,uEAAuE;IACvE,yEAAyE;IACzE,sEAAsE;IACtE,IAAI,MAA8D,CAAC;IACnE,IAAI,CAAC;QACH,MAAM,GAAG,yBAAyB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACtD,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,kBAAmB,CAAW,CAAC,OAAO,EAAE,EAAE,CAAC;IACzE,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,kBAAkB,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;IACzG,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC;IAC1B,IAAI,OAAuC,CAAC;IAC5C,IAAI,CAAC;QACH,OAAO,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,uEAAuE;QACvE,mEAAmE;QACnE,qEAAqE;QACrE,oDAAoD;QACpD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,kBAAmB,CAAW,CAAC,OAAO,EAAE,EAAE,CAAC;IACzE,CAAC;IACD,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;QAChB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,sBAAsB,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IACvE,CAAC;IAED,IAAI,CAAC;QACH,MAAM,WAAW,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAG,CAAW,CAAC,OAAO,EAAE,CAAC;IACrD,CAAC;IAED,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;AAC9C,CAAC;AAQD;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,aAAqB;IAC5D,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,aAAa,CAAC,CAAC;IACpD,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;AACzD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacity-attest",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "MCP server for capacity-delivery attestations: after an x402 payment for compute capacity (GPU-hours, storage, API credits, bandwidth), the paying agent leaves a signed, factual claim of what was actually delivered, so other agents can check a seller's delivery history before paying. No reputation score, no judgment, no financial instrument.",
   "keywords": [
     "mcp",