@chitmark/sdk 0.7.0 → 0.8.0

package/dist/index.js

@@ -1,3 +1,94 @@
+// src/attribution.ts
+function attributionEvidence(options, mode) {
+  const { request, agentProof, session, piiMode = mode } = options;
+  const headers = request.headers;
+  const header = typeof headers.get === "function" ? headers.get("chitmark-agent-proof") : Object.entries(headers).find(
+    ([name]) => name.toLowerCase() === "chitmark-agent-proof"
+  )?.[1];
+  let site = options.site;
+  if (!site && request.url?.startsWith("https://")) site = new URL(request.url).origin;
+  let proof = agentProof;
+  if (!proof && typeof header === "string" && header.length <= 2048 && site) {
+    try {
+      proof = JSON.parse(header);
+    } catch {
+    }
+  }
+  return { site, session, piiMode, agentProof: proof };
+}
+
+// src/credentials.ts
+var encode = (bytes) => btoa(String.fromCharCode(...bytes)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+var json = (value) => encode(new TextEncoder().encode(JSON.stringify(value)));
+async function boundedCredential(work, signal) {
+  signal.throwIfAborted();
+  let abort;
+  const aborted = new Promise((_, reject) => {
+    abort = () => reject(new Error("Credential deadline exceeded"));
+    signal.addEventListener("abort", abort, { once: true });
+  });
+  try {
+    return await Promise.race([work, aborted]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+function createDPoPCredentialProvider(options) {
+  const { privateKey, publicJwk } = options;
+  if (publicJwk.d || publicJwk.kty !== "EC" || publicJwk.crv !== "P-256" || !publicJwk.x || !publicJwk.y)
+    throw new Error("DPoP requires a public P-256 JWK");
+  const jwk = { kty: "EC", crv: "P-256", x: publicJwk.x, y: publicJwk.y };
+  let cached;
+  let pending;
+  const valid = (c) => !!c && typeof c.accessToken === "string" && /^[\w-]+\.[\w-]+\.[\w-]+$/.test(c.accessToken) && [c.expiresAt, c.trustExpiresAt, c.revocationValidUntil].every(
+    (v) => Number.isSafeInteger(v) && v > Date.now() / 1e3 + 1
+  );
+  return {
+    async headers({ url, method, signal }) {
+      signal.throwIfAborted();
+      const target = new URL(url);
+      if (target.protocol !== "https:" || target.username || target.password)
+        throw new Error("DPoP requires HTTPS");
+      if (!valid(cached)) {
+        if (!pending) {
+          const refreshSignal = AbortSignal.timeout(options.refreshTimeoutMs ?? 500);
+          pending = Promise.resolve().then(() => options.load(refreshSignal)).then((c) => {
+            if (!valid(c) || refreshSignal.aborted) throw new Error("Stale credential");
+            cached = { ...c };
+            return cached;
+          }).finally(() => {
+            pending = void 0;
+          });
+        }
+        await boundedCredential(
+          pending,
+          AbortSignal.any([signal, AbortSignal.timeout(options.refreshTimeoutMs ?? 500)])
+        );
+      }
+      if (!valid(cached)) throw new Error("Stale credential");
+      const credential = cached;
+      const token = credential.accessToken;
+      const ath = encode(
+        new Uint8Array(
+          await crypto.subtle.digest("SHA-256", new TextEncoder().encode(token))
+        )
+      );
+      const payload = `${json({ typ: "dpop+jwt", alg: "ES256", jwk })}.${json({ jti: crypto.randomUUID(), iat: Math.floor(Date.now() / 1e3), htm: method.toUpperCase(), htu: `${target.origin}${target.pathname}`, ath })}`;
+      const signature = await crypto.subtle.sign(
+        { name: "ECDSA", hash: "SHA-256" },
+        privateKey,
+        new TextEncoder().encode(payload)
+      );
+      signal.throwIfAborted();
+      if (!valid(credential)) throw new Error("Stale credential");
+      return {
+        Authorization: `DPoP ${token}`,
+        DPoP: `${payload}.${encode(new Uint8Array(signature))}`
+      };
+    }
+  };
+}
+
 // src/errors.ts
 var ChitmarkError = class extends Error {
   name = "ChitmarkError";
@@ -60,7 +151,7 @@ var DEFAULT_BASE_URLS = {
 };
 var DEFAULT_TIMEOUT_MS = 800;
 var LOCAL_TIMEOUT_MS = 2e3;
-var SDK_VERSION = "0.7.0";
+var SDK_VERSION = "0.8.0";
 function defaultTimeoutMs(baseUrl) {
   try {
     const host = new URL(baseUrl).hostname.replace(/^\[|\]$/g, "").toLowerCase();
@@ -123,11 +214,11 @@ function minimizeFormData(formData) {
 }
 function bufferToHex(buffer) {
   const bytes = new Uint8Array(buffer);
-  let hex = "";
+  let hex2 = "";
   for (const b of bytes) {
-    hex += b.toString(16).padStart(2, "0");
+    hex2 += b.toString(16).padStart(2, "0");
   }
-  return hex;
+  return hex2;
 }
 
 // src/internal/prepare.ts
@@ -203,6 +294,46 @@ var VerdictTokenError = class extends ChitmarkError {
 var DEFAULT_JWKS_URL = "https://api.chitmark.com/.well-known/jwks.json";
 var DEFAULT_LEEWAY_SECONDS = 30;
 async function verifyVerdictToken(token, options) {
+  return verifyReceipt(token, options, "JWT");
+}
+var SENSITIVE_RECEIPT_ACTIONS = [
+  "api_key",
+  "data_export",
+  "session_establish",
+  "privilege_elevate",
+  "authenticator_replace",
+  "recovery_contact_change",
+  "session_use",
+  "privilege_change",
+  "release_deploy",
+  "bulk_mutation",
+  "commitment_change",
+  "agent_effect",
+  "agent_escalation",
+  "quote_generate",
+  "queue_priority"
+];
+async function verifyActionReceipt(token, options) {
+  const claims = await verifyReceipt(
+    token,
+    {
+      ...options,
+      aud: options.audience,
+      issuer: VERDICT_TOKEN_ISSUER,
+      leewaySeconds: 0
+    },
+    "chitmark-action+jwt"
+  );
+  const now = Math.floor((options.nowMs ?? Date.now()) / 1e3);
+  if (!options.audience || !options.session || !options.tenantId || !options.policy || !/^[a-f0-9]{64}$/.test(options.digest) || !(options.action === "trial_activation" ? options.proof === "none" || options.proof === "pow_severe" : SENSITIVE_RECEIPT_ACTIONS.includes(options.action) && options.proof === "tenant_step_up" && typeof options.subject === "string" && /^[A-Za-z0-9_-]{1,128}$/.test(options.subject) && claims.subject === options.subject) || claims.action !== options.action || options.environment !== "test" && options.environment !== "live" || claims.environment !== options.environment || !options.surface || claims.surface !== options.surface || claims.digest !== options.digest || claims.policy !== options.policy || claims.proof !== options.proof || claims.enforcementMode !== "enforce" || claims.decision !== "allow" || claims.degraded !== false || typeof claims.eventId !== "string" || !claims.eventId || !Number.isSafeInteger(claims.iat) || !Number.isSafeInteger(claims.exp) || claims.iat > now || claims.exp <= now || claims.exp - claims.iat !== 60) {
+    throw new VerdictTokenError(
+      "wrong_action_binding",
+      "Receipt cannot authorize this operation"
+    );
+  }
+  return claims;
+}
+async function verifyReceipt(token, options, expectedType) {
   const nowMs = options.nowMs ?? Date.now();
   const leewaySeconds = options.leewaySeconds ?? DEFAULT_LEEWAY_SECONDS;
   const parts = token.split(".");
@@ -224,10 +355,10 @@ async function verifyVerdictToken(token, options) {
       `verdictToken must use ES256, got ${String(header["alg"])}`
     );
   }
-  if (header["typ"] !== "JWT") {
+  if (header["typ"] !== expectedType) {
     throw new VerdictTokenError(
       "wrong_type",
-      `verdictToken must be a JWT, got ${String(header["typ"])}`
+      `verdictToken must have type ${expectedType}, got ${String(header["typ"])}`
     );
   }
   const kid = typeof header["kid"] === "string" ? header["kid"] : "";
@@ -273,6 +404,12 @@ async function verifyVerdictToken(token, options) {
   if (!jwk) {
     throw new VerdictTokenError("unknown_kid", `JWKS has no key for kid ${kid}`);
   }
+  if (jwk["kty"] !== "EC" || jwk["crv"] !== "P-256" || jwk["alg"] !== void 0 && jwk["alg"] !== "ES256") {
+    throw new VerdictTokenError(
+      "wrong_algorithm",
+      "Verification requires an ES256 P-256 key"
+    );
+  }
   let publicKey;
   try {
     publicKey = await crypto.subtle.importKey(
@@ -345,7 +482,27 @@ function decodeBase64UrlBytes(value) {
 
 // src/client.ts
 var Chitmark = class {
+  attribution = {
+    resolve: (input) => this.request("/v1/attributions/resolve", {
+      method: "POST",
+      body: attributionEvidence(input, this.piiMode),
+      idempotencyKey: input.idempotencyKey
+    }),
+    get: (id2) => this.request(`/v1/attributions/${encodeURIComponent(id2)}`, { method: "GET" }),
+    createLink: (input, idempotencyKey) => this.request("/v1/identity-links", { method: "POST", body: input, idempotencyKey }),
+    revokeLink: (id2) => this.request(`/v1/identity-links/${encodeURIComponent(id2)}`, { method: "DELETE" })
+  };
+  /** Paid access lifecycle. Transport uncertainty must be resumed, never treated as payment. */
+  async charge(request) {
+    return this.request("/v1/charge", {
+      method: "POST",
+      body: request,
+      idempotencyKey: request.idempotencyKey,
+      timeoutMs: Math.max(this.timeoutMs, 15e3)
+    });
+  }
   apiKey;
+  credentialProvider;
   baseUrl;
   timeoutMs;
   piiMode;
@@ -353,7 +510,7 @@ var Chitmark = class {
   fetchImpl;
   clientName;
   constructor(options) {
-    if (!options.apiKey) {
+    if (!!options.apiKey === !!options.credentialProvider) {
       throw new ChitmarkError("Chitmark apiKey is required");
     }
     if (options.onDegraded && options.onDegraded !== "challenge") {
@@ -362,6 +519,7 @@ var Chitmark = class {
       );
     }
     this.apiKey = options.apiKey;
+    this.credentialProvider = options.credentialProvider;
     this.baseUrl = resolveBaseUrl(options.env, options.baseUrl ?? envBaseUrl());
     this.timeoutMs = options.timeoutMs ?? defaultTimeoutMs(this.baseUrl);
     this.piiMode = options.piiMode ?? "hashed";
@@ -454,7 +612,8 @@ var Chitmark = class {
   /**
    * Complete a challenge by submitting its solved proof. Clears only the bound
    * session, once. Does not authorize the action: re-verify with
-   * `context.challengeId` and proceed only on non-degraded allow.
+   * `context.challengeId` for standalone challenges or the original action
+   * binding plus the challenge and event IDs for operation-bound challenges.
    */
   async completeChallenge(request) {
     return this.request("/v1/challenge", {
@@ -482,15 +641,35 @@ var Chitmark = class {
    */
   async request(path, init) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    const timeoutMs = init.timeoutMs ?? this.timeoutMs;
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
       const headers = {
-        Authorization: `Bearer ${this.apiKey}`,
+        ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {},
         "Content-Type": "application/json",
         Accept: "application/json",
         "User-Agent": this.clientName,
         "X-Chitmark-Client": this.clientName
       };
+      if (this.credentialProvider) {
+        try {
+          Object.assign(
+            headers,
+            await boundedCredential(
+              this.credentialProvider.headers({
+                url: `${this.baseUrl}${path}`,
+                method: init.method,
+                signal: controller.signal
+              }),
+              controller.signal
+            )
+          );
+        } catch {
+          throw new ChitmarkError("Credential unavailable", { code: "credential" });
+        }
+        if (!headers.Authorization?.startsWith("DPoP ") || !headers.DPoP)
+          throw new ChitmarkError("Invalid DPoP credentials");
+      }
       if (init.idempotencyKey) {
         headers["Idempotency-Key"] = init.idempotencyKey;
       }
@@ -498,7 +677,8 @@ var Chitmark = class {
         method: init.method,
         headers,
         body: init.body !== void 0 ? JSON.stringify(init.body) : void 0,
-        signal: controller.signal
+        signal: controller.signal,
+        redirect: "error"
       });
       const text = await res.text();
       let parsed = void 0;
@@ -522,7 +702,7 @@ var Chitmark = class {
     } catch (err) {
       if (err instanceof ChitmarkApiError) throw err;
       if (err instanceof Error && err.name === "AbortError") {
-        throw new ChitmarkError(`Request timed out after ${this.timeoutMs}ms`, {
+        throw new ChitmarkError(`Request timed out after ${timeoutMs}ms`, {
           code: "timeout"
         });
       }
@@ -548,6 +728,38 @@ function isWellFormedVerdict(value) {
   return typeof v.decision === "string" && VERDICT_DECISIONS.has(v.decision) && typeof v.eventId === "string" && v.eventId.length > 0 && typeof v.degraded === "boolean";
 }
 
+// src/charge.ts
+function summarizeCharge(p, now = Date.now(), sellerCostCents) {
+  if (sellerCostCents !== void 0 && (!Number.isSafeInteger(sellerCostCents) || sellerCostCents < 0))
+    throw new Error("Invalid seller cost");
+  const deliveredUnits = p.delivery.executions.reduce(
+    (n, e) => n + (e.state === "delivered" ? e.usedUnits : 0),
+    0
+  );
+  const unresolvedUnits = p.delivery.executions.reduce(
+    (n, e) => n + (e.state === "reserved" || e.state === "unknown" ? e.units : 0),
+    0
+  );
+  const net = p.payment.providerFee === null ? null : p.payment.capturedAmount - p.payment.refundedAmount - p.payment.providerFee;
+  return {
+    paidCompletion: p.payment.state === "settled" && p.payment.capturedAmount > 0 && p.payment.refundedAmount === 0 && p.payment.disputedAmount === 0 && deliveredUnits === p.quote.quantity,
+    billedCents: p.payment.capturedAmount - p.payment.refundedAmount,
+    sellerReportedDeliveredCents: deliveredUnits * p.quote.resource.unitAmount,
+    deliveredUnits,
+    unresolvedUnits,
+    unresolvedAgeUpperBoundMs: p.payment.state === "pending" || p.payment.refundState === "pending" || p.payment.refundState === "unknown" || p.payment.state === "unknown" || unresolvedUnits > 0 ? Math.max(0, now - p.createdAt) : null,
+    refundedCents: p.payment.refundedAmount,
+    disputedCents: p.payment.disputedAmount,
+    captureFeeCents: p.payment.providerFee,
+    sellerNetAfterCaptureFeeCents: net,
+    sellerMarginCents: net === null || sellerCostCents === void 0 ? null : net - sellerCostCents,
+    // Provider/application reconciliation must supply duplicate evidence; retries alone do not prove absence.
+    duplicateCharges: null,
+    duplicateEffects: null,
+    observedElapsedMs: Math.max(0, p.updatedAt - p.createdAt)
+  };
+}
+
 // src/http-status.ts
 var CHITMARK_HTTP_STATUS = {
   ok: 200,
@@ -585,6 +797,32 @@ function verdictToHttpStatus(verdict) {
   return CHITMARK_HTTP_STATUS.ok;
 }
 
+// src/action-binding.ts
+var opaqueId = /^[A-Za-z0-9_.:-]{1,128}$/;
+async function trialCreditOperationDigest(operation) {
+  const { operationId, target, quota, recipient } = operation;
+  if (Object.keys(operation).some(
+    (key) => !["operationId", "target", "quota", "recipient"].includes(key)
+  ) || typeof operationId !== "string" || !opaqueId.test(operationId) || typeof target !== "string" || !opaqueId.test(target) || !Number.isSafeInteger(quota) || quota < 1 || recipient !== void 0 && (typeof recipient !== "string" || !opaqueId.test(recipient))) {
+    throw new TypeError("Invalid trial credit operation");
+  }
+  const bytes = new TextEncoder().encode(
+    JSON.stringify([
+      "chitmark-action-v1",
+      "trial_activation",
+      operationId,
+      target,
+      quota,
+      recipient ?? null
+    ])
+  );
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(
+    new Uint8Array(digest),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+}
+
 // src/trusted-ip.ts
 function getTrustedClientIp(req) {
   const platform = req.headers.get("cf-connecting-ip")?.trim() || req.headers.get("x-real-ip")?.trim() || req.headers.get("x-vercel-forwarded-for")?.split(",")[0]?.trim() || "";
@@ -647,6 +885,345 @@ async function verifyNextRequest(client, req, options) {
   });
 }
 
-export { CHITMARK_HTTP_STATUS, CHITMARK_HTTP_STATUS_MEANING, Chitmark, ChitmarkApiError, ChitmarkError, VERDICT_TOKEN_ISSUER, VerdictTokenError, chitmarkGate, degradedChallengeVerdict, enforceDegradedNeverAllow, getTrustedClientIp, hashEmailSha256, isEligibleAllow, minimizeFormData, truncateIp, verdictToHttpStatus, verifyNextRequest, verifyVerdictToken };
+// src/evidence.ts
+var EvidenceError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "EvidenceError";
+  }
+  code;
+};
+function evidenceAssert(value, code) {
+  if (!value) throw new EvidenceError(code);
+}
+function canonicalEvidence(value) {
+  if (value === null || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number") {
+    evidenceAssert(
+      Number.isSafeInteger(value) && !Object.is(value, -0),
+      "noncanonical_number"
+    );
+    return String(value);
+  }
+  if (typeof value === "string") {
+    evidenceAssert(/^[\x20-\x7e]*$/.test(value), "noncanonical_string");
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `[${value.map(canonicalEvidence).join(",")}]`;
+  evidenceAssert(
+    value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype,
+    "noncanonical_object"
+  );
+  const obj = value;
+  return `{${Object.keys(obj).sort().map((key) => `${canonicalEvidence(key)}:${canonicalEvidence(obj[key])}`).join(",")}}`;
+}
+async function evidenceHash(value) {
+  return Array.from(
+    new Uint8Array(
+      await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value))
+    ),
+    (b) => b.toString(16).padStart(2, "0")
+  ).join("");
+}
+var encode2 = (bytes) => btoa(Array.from(bytes, (b) => String.fromCharCode(b)).join("")).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+var decode = (part) => Uint8Array.from(
+  atob(part.replace(/-/g, "+").replace(/_/g, "/")),
+  (c) => c.charCodeAt(0)
+);
+function evidenceKeyAt(history, kid, at) {
+  const matches = history.filter((key2) => key2.kid === kid);
+  evidenceAssert(matches.length === 1, "unknown_trust_root");
+  const key = matches[0];
+  evidenceAssert(
+    key.jwk.kty === "EC" && key.jwk.crv === "P-256" && (!key.jwk.alg || key.jwk.alg === "ES256") && !key.jwk.d,
+    "unsupported_key"
+  );
+  evidenceAssert(
+    Number.isSafeInteger(at) && Number.isSafeInteger(key.notBefore) && Number.isSafeInteger(key.notAfter) && key.notBefore <= at && at < key.notAfter,
+    "key_outside_validity"
+  );
+  evidenceAssert(key.revokedAt === void 0, "revoked_key");
+  return key;
+}
+async function verifyEvidenceSignature(token, typ, history, at) {
+  evidenceAssert(
+    typeof token === "string" && token.length <= 8e6 && /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(token),
+    "malformed_signature"
+  );
+  const [h, p, s] = token.split(".");
+  let head, payload;
+  try {
+    head = JSON.parse(
+      new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(decode(h))
+    );
+    payload = JSON.parse(
+      new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(decode(p))
+    );
+  } catch {
+    throw new EvidenceError("malformed_signature");
+  }
+  evidenceAssert(
+    head?.alg === "ES256" && head.typ === typ && Object.keys(head).length === 3,
+    "unsupported_profile"
+  );
+  const trusted = evidenceKeyAt(history, head.kid, at);
+  const key = await crypto.subtle.importKey(
+    "jwk",
+    trusted.jwk,
+    { name: "ECDSA", namedCurve: "P-256" },
+    false,
+    ["verify"]
+  );
+  evidenceAssert(
+    await crypto.subtle.verify(
+      { name: "ECDSA", hash: "SHA-256" },
+      key,
+      decode(s),
+      new TextEncoder().encode(`${h}.${p}`)
+    ),
+    "invalid_signature"
+  );
+  evidenceAssert(
+    payload && typeof payload === "object" && !Array.isArray(payload),
+    "malformed_payload"
+  );
+  return payload;
+}
+async function signEvidence(payload, typ, kid, jwk) {
+  evidenceAssert(
+    jwk.kty === "EC" && jwk.crv === "P-256" && (!jwk.alg || jwk.alg === "ES256"),
+    "unsupported_key"
+  );
+  const input = `${encode2(new TextEncoder().encode(canonicalEvidence({ alg: "ES256", kid, typ })))}.${encode2(new TextEncoder().encode(canonicalEvidence(payload)))}`;
+  evidenceAssert(input.length + 87 <= 8e6, "bundle_too_large");
+  const key = await crypto.subtle.importKey(
+    "jwk",
+    jwk,
+    { name: "ECDSA", namedCurve: "P-256" },
+    false,
+    ["sign"]
+  );
+  return `${input}.${encode2(new Uint8Array(await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, key, new TextEncoder().encode(input))))}`;
+}
+var id = /^[A-Za-z0-9_.:/-]{1,160}$/;
+function validateManifest(value, tenantId) {
+  evidenceAssert(
+    Object.keys(value).sort().join(",") === "completeness,createdAt,endAt,gaps,issuer,purpose,records,retention,sourceAsOf,startAt,tenantId,timeBasis,version" && Object.keys(value.retention).sort().join(",") === "deleteAfter,exportedCopies,recipient,redaction",
+    "unminimized_manifest"
+  );
+  canonicalEvidence(value);
+  evidenceAssert(
+    value.version === 1 && value.issuer === "https://portal.chitmark.com" && value.purpose === "historical_evidence" && value.tenantId === tenantId && id.test(tenantId),
+    "wrong_bundle_scope"
+  );
+  evidenceAssert(
+    [
+      value.startAt,
+      value.endAt,
+      value.createdAt,
+      value.sourceAsOf,
+      value.retention.deleteAfter
+    ].every(Number.isSafeInteger) && value.startAt < value.endAt && value.endAt <= value.sourceAsOf && value.sourceAsOf <= value.createdAt && value.createdAt < value.retention.deleteAfter,
+    "invalid_window"
+  );
+  evidenceAssert(
+    value.completeness === "unknown" && value.timeBasis === "issuer_and_ingestion_clocks_not_independent_time" && value.retention.redaction === "minimized" && value.retention.exportedCopies === "recipient_controlled" && id.test(value.retention.recipient) && Array.isArray(value.gaps) && value.gaps.every((gap) => id.test(gap)),
+    "invalid_manifest"
+  );
+  evidenceAssert(
+    Array.isArray(value.records) && value.records.length <= 1e4,
+    "record_limit"
+  );
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of value.records) {
+    evidenceAssert(
+      Object.keys(row).sort().join(",") === "eventId,id,kind,occurredAt,policyRevision,receipt,recordedAt,result,source",
+      "unminimized_record"
+    );
+    evidenceAssert(
+      id.test(row.id) && id.test(row.eventId) && ["decision", "execution", "outcome"].includes(row.kind) && id.test(row.result) && (row.policyRevision === null || id.test(row.policyRevision)) && (row.receipt === null || typeof row.receipt === "string" && row.receipt.length <= 8192),
+      "invalid_record"
+    );
+    evidenceAssert(
+      Number.isSafeInteger(row.occurredAt) && Number.isSafeInteger(row.recordedAt) && value.startAt <= row.occurredAt && row.occurredAt < value.endAt && row.recordedAt <= value.sourceAsOf && row.recordedAt >= row.occurredAt && row.source === (row.kind === "decision" ? "decision_service" : "customer_report"),
+      "invalid_provenance"
+    );
+    const identity = `${row.kind}:${row.id}`;
+    evidenceAssert(!seen.has(identity), "duplicate_record");
+    seen.add(identity);
+  }
+}
+async function verifyEvidenceBundle(bundle, options) {
+  validateManifest(bundle.manifest, options.tenantId);
+  evidenceAssert(
+    bundle.manifest.retention.recipient === options.recipient,
+    "wrong_recipient"
+  );
+  evidenceAssert(
+    options.now < bundle.manifest.retention.deleteAfter && options.now >= bundle.manifest.createdAt,
+    "retention_expired"
+  );
+  const signed = await verifyEvidenceSignature(
+    bundle.signature,
+    "chitmark-evidence+jwt",
+    options.trustedKeys,
+    bundle.manifest.createdAt
+  );
+  evidenceAssert(
+    canonicalEvidence(signed) === canonicalEvidence(bundle.manifest),
+    "manifest_mismatch"
+  );
+  const head = JSON.parse(
+    new TextDecoder().decode(decode(bundle.signature.split(".")[0]))
+  );
+  evidenceAssert(
+    evidenceKeyAt(options.trustedKeys, head.kid, bundle.manifest.createdAt).compromisedAt === void 0,
+    "compromised_bundle_key"
+  );
+  return {
+    purpose: "historical_evidence",
+    executionAuthorized: false,
+    integrity: "valid",
+    completeness: "unknown",
+    outcomeTruth: "not_established",
+    gaps: bundle.manifest.gaps
+  };
+}
+async function verifyHistoricalReceipt(token, options) {
+  evidenceAssert(
+    typeof token === "string" && token.length <= 8192,
+    "malformed_signature"
+  );
+  let claims, head;
+  try {
+    const parts = token.split(".");
+    head = JSON.parse(new TextDecoder().decode(decode(parts[0])));
+    claims = JSON.parse(new TextDecoder().decode(decode(parts[1])));
+  } catch {
+    throw new EvidenceError("malformed_signature");
+  }
+  evidenceAssert(
+    head.typ === "JWT" || head.typ === "chitmark-action+jwt",
+    "unsupported_profile"
+  );
+  evidenceAssert(
+    Number.isSafeInteger(claims.iat) && Number.isSafeInteger(claims.exp) && Number(claims.iat) < Number(claims.exp) && Number(claims.exp) - Number(claims.iat) <= (head.typ === "JWT" ? 300 : 60),
+    "invalid_receipt_time"
+  );
+  const at = Number(claims.iat);
+  evidenceAssert(
+    typeof claims.eventId === "string" && /^[A-Za-z0-9_-]{1,160}$/.test(claims.eventId),
+    "invalid_receipt_context"
+  );
+  const trusted = evidenceKeyAt(options.trustedKeys, String(head.kid), at);
+  claims = await verifyEvidenceSignature(
+    token,
+    String(head.typ),
+    options.trustedKeys,
+    at
+  );
+  evidenceAssert(
+    claims.tid === options.tenantId && claims.sub === options.session && claims.iss === "https://api.chitmark.com",
+    "wrong_receipt_scope"
+  );
+  const witnessed = options.witness && Number.isSafeInteger(options.witness.observedAt) && options.witness.observedAt >= at && options.witness.tokenHash === await evidenceHash(token);
+  const beforeCompromise = witnessed && (trusted.compromisedAt === void 0 || options.witness.observedAt < trusted.compromisedAt);
+  return {
+    purpose: "historical_evidence",
+    executionAuthorized: false,
+    eventId: String(claims.eventId),
+    policyRevision: typeof claims.policy === "string" ? claims.policy : null,
+    timeIntegrity: beforeCompromise ? "independently_checkpointed" : trusted.compromisedAt !== void 0 ? "uncertain_after_compromise" : "self_asserted"
+  };
+}
+
+// src/evidence-checkpoint.ts
+var hex = /^[a-f0-9]{64}$/;
+function scope(checkpoint, tenantId, now) {
+  evidenceAssert(
+    checkpoint.version === 1 && checkpoint.tenantId === tenantId && /^[A-Za-z0-9_-]{16,128}$/.test(checkpoint.epoch) && Number.isSafeInteger(checkpoint.expiresAt) && now < checkpoint.expiresAt && Number.isSafeInteger(checkpoint.observedAt) && checkpoint.observedAt <= now && checkpoint.observedAt < checkpoint.expiresAt && Number.isSafeInteger(checkpoint.size) && checkpoint.size >= 0 && checkpoint.size <= 1e4 && hex.test(checkpoint.root),
+    "checkpoint_scope_or_expiry"
+  );
+}
+var genesis = (cp) => evidenceHash(
+  canonicalEvidence(["chitmark-private-chain-v1", cp.tenantId, cp.epoch, cp.expiresAt])
+);
+var evidenceCommitment = (cp, record, salt) => {
+  evidenceAssert(hex.test(salt), "invalid_commitment_salt");
+  return evidenceHash(
+    canonicalEvidence([
+      "chitmark-record-v1",
+      cp.tenantId,
+      cp.epoch,
+      cp.expiresAt,
+      salt,
+      record
+    ])
+  );
+};
+var advance = (root, leaf, index) => evidenceHash(canonicalEvidence(["chitmark-append-v1", index, root, leaf]));
+async function checkpointFromCommitments(input) {
+  evidenceAssert(
+    input.commitments.length <= 1e4 && input.commitments.every((leaf) => hex.test(leaf)),
+    "invalid_commitments"
+  );
+  let root = await genesis(input);
+  for (let index = 0; index < input.commitments.length; index++)
+    root = await advance(root, input.commitments[index], index);
+  const cp = {
+    version: 1,
+    tenantId: input.tenantId,
+    epoch: input.epoch,
+    expiresAt: input.expiresAt,
+    observedAt: input.observedAt,
+    size: input.commitments.length,
+    root
+  };
+  scope(cp, input.tenantId, input.observedAt);
+  return cp;
+}
+async function verifyCheckpointAppend(older, newer, appended, options) {
+  scope(older, options.tenantId, options.now);
+  scope(newer, options.tenantId, options.now);
+  if (older.size === 0)
+    evidenceAssert(older.root === await genesis(older), "invalid_empty_checkpoint");
+  evidenceAssert(
+    older.epoch === newer.epoch && older.expiresAt === newer.expiresAt && older.observedAt <= newer.observedAt && older.size <= newer.size,
+    "inconsistent_checkpoint"
+  );
+  if (older.size === newer.size)
+    evidenceAssert(older.root === newer.root, "divergent_history");
+  if (appended === null)
+    return { status: "unavailable", completeness: "unknown" };
+  evidenceAssert(
+    appended.length === newer.size - older.size && appended.every((leaf) => hex.test(leaf)),
+    "invalid_append_proof"
+  );
+  let root = older.root;
+  for (let index = 0; index < appended.length; index++)
+    root = await advance(root, appended[index], older.size + index);
+  evidenceAssert(root === newer.root, "divergent_history");
+  return { status: "consistent", completeness: "unknown" };
+}
+async function verifyCheckpointInclusion(checkpoint, proof, options) {
+  scope(checkpoint, options.tenantId, options.now);
+  if (!proof) return { status: "unavailable", completeness: "unknown" };
+  evidenceAssert(
+    Number.isSafeInteger(proof.index) && proof.index >= 0 && proof.index < checkpoint.size && proof.commitments.length === checkpoint.size,
+    "invalid_inclusion_proof"
+  );
+  const rebuilt = await checkpointFromCommitments({
+    ...checkpoint,
+    commitments: proof.commitments
+  });
+  evidenceAssert(
+    rebuilt.root === checkpoint.root && await evidenceCommitment(checkpoint, proof.record, proof.salt) === proof.commitments[proof.index],
+    "changed_record"
+  );
+  return { status: "included", completeness: "unknown" };
+}
+
+export { CHITMARK_HTTP_STATUS, CHITMARK_HTTP_STATUS_MEANING, Chitmark, ChitmarkApiError, ChitmarkError, EvidenceError, SENSITIVE_RECEIPT_ACTIONS, VERDICT_TOKEN_ISSUER, VerdictTokenError, canonicalEvidence, checkpointFromCommitments, chitmarkGate, createDPoPCredentialProvider, degradedChallengeVerdict, enforceDegradedNeverAllow, evidenceAssert, evidenceCommitment, evidenceHash, evidenceKeyAt, getTrustedClientIp, hashEmailSha256, isEligibleAllow, minimizeFormData, signEvidence, summarizeCharge, trialCreditOperationDigest, truncateIp, validateManifest, verdictToHttpStatus, verifyActionReceipt, verifyCheckpointAppend, verifyCheckpointInclusion, verifyEvidenceBundle, verifyEvidenceSignature, verifyHistoricalReceipt, verifyNextRequest, verifyVerdictToken };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map