@peac/schema 0.10.8 → 0.10.10

package/dist/index.mjs

@@ -0,0 +1,2577 @@
+import { ALGORITHMS, HEADERS, POLICY, ISSUER_CONFIG, DISCOVERY, WIRE_TYPE, ERROR_CATEGORIES } from '@peac/kernel';
+import { z } from 'zod';
+
+// src/errors.ts
+var ERROR_CATEGORIES_CANONICAL = ERROR_CATEGORIES;
+var ERROR_CODES = {
+  // Validation errors (400)
+  E_CONTROL_REQUIRED: "E_CONTROL_REQUIRED",
+  E_INVALID_ENVELOPE: "E_INVALID_ENVELOPE",
+  E_INVALID_CONTROL_CHAIN: "E_INVALID_CONTROL_CHAIN",
+  E_INVALID_PAYMENT: "E_INVALID_PAYMENT",
+  E_INVALID_POLICY_HASH: "E_INVALID_POLICY_HASH",
+  E_EXPIRED_RECEIPT: "E_EXPIRED_RECEIPT",
+  E_EVIDENCE_NOT_JSON: "E_EVIDENCE_NOT_JSON",
+  // Verification errors (401)
+  E_INVALID_SIGNATURE: "E_INVALID_SIGNATURE",
+  E_SSRF_BLOCKED: "E_SSRF_BLOCKED",
+  E_DPOP_REPLAY: "E_DPOP_REPLAY",
+  E_DPOP_INVALID: "E_DPOP_INVALID",
+  // Control errors (403)
+  E_CONTROL_DENIED: "E_CONTROL_DENIED",
+  // Infrastructure errors (502/503)
+  E_JWKS_FETCH_FAILED: "E_JWKS_FETCH_FAILED",
+  E_POLICY_FETCH_FAILED: "E_POLICY_FETCH_FAILED",
+  E_NETWORK_ERROR: "E_NETWORK_ERROR",
+  // Workflow errors (400)
+  E_WORKFLOW_CONTEXT_INVALID: "E_WORKFLOW_CONTEXT_INVALID",
+  E_WORKFLOW_DAG_INVALID: "E_WORKFLOW_DAG_INVALID",
+  E_WORKFLOW_LIMIT_EXCEEDED: "E_WORKFLOW_LIMIT_EXCEEDED",
+  E_WORKFLOW_ID_INVALID: "E_WORKFLOW_ID_INVALID",
+  E_WORKFLOW_STEP_ID_INVALID: "E_WORKFLOW_STEP_ID_INVALID",
+  E_WORKFLOW_PARENT_NOT_FOUND: "E_WORKFLOW_PARENT_NOT_FOUND",
+  E_WORKFLOW_SUMMARY_INVALID: "E_WORKFLOW_SUMMARY_INVALID",
+  E_WORKFLOW_CYCLE_DETECTED: "E_WORKFLOW_CYCLE_DETECTED"
+};
+function createPEACError(code, category, severity, retryable, options) {
+  return {
+    code,
+    category,
+    severity,
+    retryable,
+    ...options
+  };
+}
+function createEvidenceNotJsonError(message, path) {
+  return createPEACError(ERROR_CODES.E_EVIDENCE_NOT_JSON, "validation", "error", false, {
+    http_status: 400,
+    pointer: path ? "/" + path.join("/") : void 0,
+    remediation: "Ensure evidence contains only JSON-safe values (strings, finite numbers, booleans, null, arrays, plain objects)",
+    details: { message }
+  });
+}
+function createWorkflowContextInvalidError(details) {
+  return createPEACError(ERROR_CODES.E_WORKFLOW_CONTEXT_INVALID, "validation", "error", false, {
+    http_status: 400,
+    pointer: "/ext/org.peacprotocol~1workflow",
+    remediation: "Ensure workflow_context conforms to WorkflowContextSchema",
+    details: { message: details ?? "Invalid workflow context" }
+  });
+}
+function createWorkflowDagInvalidError(reason) {
+  const messages = {
+    self_parent: "Step cannot be its own parent",
+    duplicate_parent: "Parent step IDs must be unique",
+    cycle: "Workflow DAG contains a cycle"
+  };
+  return createPEACError(ERROR_CODES.E_WORKFLOW_DAG_INVALID, "validation", "error", false, {
+    http_status: 400,
+    pointer: "/ext/org.peacprotocol~1workflow/parent_step_ids",
+    remediation: "Ensure workflow forms a valid directed acyclic graph (DAG)",
+    details: { reason, message: messages[reason] }
+  });
+}
+
+// src/normalize.ts
+function normalizePayment(payment) {
+  const result = {
+    rail: payment.rail,
+    reference: payment.reference,
+    amount: payment.amount,
+    currency: payment.currency,
+    asset: payment.asset,
+    env: payment.env
+  };
+  if (payment.network !== void 0) {
+    result.network = payment.network;
+  }
+  if (payment.aggregator !== void 0) {
+    result.aggregator = payment.aggregator;
+  }
+  if (payment.routing !== void 0) {
+    result.routing = payment.routing;
+  }
+  return result;
+}
+function normalizeControlStep(step) {
+  return {
+    engine: step.engine,
+    result: step.result
+  };
+}
+function normalizeControl(control) {
+  return {
+    chain: control.chain.map(normalizeControlStep)
+  };
+}
+function toCoreClaims(input) {
+  if ("ok" in input && input.ok === true && "variant" in input) {
+    const parsed = input;
+    if (parsed.variant === "commerce") {
+      return commerceCoreClaims(parsed.claims);
+    }
+    return attestationCoreClaims(parsed.claims);
+  }
+  return commerceCoreClaims(input);
+}
+function commerceCoreClaims(claims) {
+  const result = {
+    iss: claims.iss,
+    aud: claims.aud,
+    rid: claims.rid,
+    iat: claims.iat,
+    ...claims.amt !== void 0 && { amt: claims.amt },
+    ...claims.cur !== void 0 && { cur: claims.cur },
+    ...claims.payment !== void 0 && { payment: normalizePayment(claims.payment) }
+  };
+  if (claims.exp !== void 0) {
+    result.exp = claims.exp;
+  }
+  if (claims.subject !== void 0) {
+    result.subject = { uri: claims.subject.uri };
+  }
+  if (claims.ext?.control !== void 0) {
+    result.control = normalizeControl(claims.ext.control);
+  }
+  return result;
+}
+function attestationCoreClaims(claims) {
+  const result = {
+    iss: claims.iss,
+    aud: claims.aud,
+    rid: claims.rid,
+    iat: claims.iat
+  };
+  if (claims.exp !== void 0) {
+    result.exp = claims.exp;
+  }
+  if (claims.sub !== void 0) {
+    result.subject = { uri: claims.sub };
+  }
+  return result;
+}
+
+// src/purpose.ts
+var PURPOSE_TOKEN_REGEX = /^[a-z](?:[a-z0-9_-]*[a-z0-9])?(?::[a-z](?:[a-z0-9_-]*[a-z0-9])?)?$/;
+var MAX_PURPOSE_TOKEN_LENGTH = 64;
+var MAX_PURPOSE_TOKENS_PER_REQUEST = 10;
+var CANONICAL_PURPOSES = [
+  "train",
+  "search",
+  "user_action",
+  "inference",
+  "index"
+];
+var PURPOSE_REASONS = [
+  "allowed",
+  "constrained",
+  "denied",
+  "downgraded",
+  "undeclared_default",
+  "unknown_preserved"
+];
+var INTERNAL_PURPOSE_UNDECLARED = "undeclared";
+function isValidPurposeToken(token) {
+  if (typeof token !== "string") return false;
+  if (token.length === 0 || token.length > MAX_PURPOSE_TOKEN_LENGTH) return false;
+  return PURPOSE_TOKEN_REGEX.test(token);
+}
+function isCanonicalPurpose(token) {
+  return CANONICAL_PURPOSES.includes(token);
+}
+function isLegacyPurpose(token) {
+  return token === "crawl" || token === "ai_input" || token === "ai_index";
+}
+function isValidPurposeReason(reason) {
+  return PURPOSE_REASONS.includes(reason);
+}
+function isUndeclaredPurpose(token) {
+  return token === INTERNAL_PURPOSE_UNDECLARED;
+}
+function normalizePurposeToken(token) {
+  return token.trim().toLowerCase();
+}
+function parsePurposeHeader(headerValue) {
+  if (!headerValue || typeof headerValue !== "string") {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const tokens = [];
+  for (const part of headerValue.split(",")) {
+    const normalized = normalizePurposeToken(part);
+    if (normalized.length > 0 && !seen.has(normalized)) {
+      seen.add(normalized);
+      tokens.push(normalized);
+    }
+  }
+  return tokens;
+}
+function validatePurposeTokens(tokens) {
+  const invalidTokens = [];
+  let undeclaredPresent = false;
+  for (const token of tokens) {
+    if (isUndeclaredPurpose(token)) {
+      undeclaredPresent = true;
+    }
+    if (!isValidPurposeToken(token)) {
+      invalidTokens.push(token);
+    }
+  }
+  return {
+    valid: invalidTokens.length === 0 && !undeclaredPresent,
+    tokens,
+    invalidTokens,
+    undeclaredPresent
+  };
+}
+function deriveKnownPurposes(declared) {
+  return declared.filter(isCanonicalPurpose);
+}
+var LEGACY_TO_CANONICAL = {
+  crawl: "index",
+  // Crawl implies indexing
+  ai_input: "inference",
+  // RAG/grounding -> inference context
+  ai_index: "index"
+  // AI-powered indexing -> index
+};
+function mapLegacyToCanonical(legacy) {
+  const canonical = LEGACY_TO_CANONICAL[legacy];
+  return {
+    canonical,
+    mapping_note: `Mapped legacy '${legacy}' to canonical '${canonical}'`
+  };
+}
+function normalizeToCanonicalOrPreserve(token) {
+  if (isCanonicalPurpose(token)) {
+    return { purpose: token, mapped: false };
+  }
+  if (isLegacyPurpose(token)) {
+    return { purpose: LEGACY_TO_CANONICAL[token], mapped: true, from: token };
+  }
+  return { purpose: token, mapped: false, unknown: true };
+}
+function determinePurposeReason(context) {
+  if (!context.declared) {
+    return "undeclared_default";
+  }
+  if (context.hasUnknownTokens) {
+    return "unknown_preserved";
+  }
+  const decision = context.decision ?? "allowed";
+  switch (decision) {
+    case "allowed":
+      return "allowed";
+    case "constrained":
+      return "constrained";
+    case "denied":
+      return "denied";
+    case "downgraded":
+      return "downgraded";
+    default:
+      return "allowed";
+  }
+}
+function hasUnknownPurposeTokens(tokens) {
+  return tokens.some((token) => !isCanonicalPurpose(token));
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+var JsonNumberSchema = z.number().finite();
+var JsonPrimitiveSchema = z.union([z.string(), JsonNumberSchema, z.boolean(), z.null()]);
+var PlainObjectSchema = z.unknown().refine(isPlainObject, {
+  message: "Expected plain object, received non-plain object (Date, Map, Set, or class instance)"
+});
+var JsonValueSchema = z.lazy(
+  () => z.union([
+    JsonPrimitiveSchema,
+    z.array(JsonValueSchema),
+    // Plain object check then record validation
+    PlainObjectSchema.transform((obj) => obj).pipe(
+      z.record(JsonValueSchema)
+    )
+  ])
+);
+var JsonObjectSchema = PlainObjectSchema.transform(
+  (obj) => obj
+).pipe(z.record(JsonValueSchema));
+var JsonArraySchema = z.array(JsonValueSchema);
+var JSON_EVIDENCE_LIMITS = {
+  /** Maximum nesting depth (default: 32) */
+  maxDepth: 32,
+  /** Maximum array length (default: 10,000) */
+  maxArrayLength: 1e4,
+  /** Maximum object keys (default: 1,000) */
+  maxObjectKeys: 1e3,
+  /** Maximum string length in bytes (default: 65,536 = 64KB) */
+  maxStringLength: 65536,
+  /** Maximum total nodes to visit (default: 100,000) */
+  maxTotalNodes: 1e5
+};
+function assertJsonSafeIterative(value, limits = {}) {
+  const maxDepth = limits.maxDepth ?? JSON_EVIDENCE_LIMITS.maxDepth;
+  const maxArrayLength = limits.maxArrayLength ?? JSON_EVIDENCE_LIMITS.maxArrayLength;
+  const maxObjectKeys = limits.maxObjectKeys ?? JSON_EVIDENCE_LIMITS.maxObjectKeys;
+  const maxStringLength = limits.maxStringLength ?? JSON_EVIDENCE_LIMITS.maxStringLength;
+  const maxTotalNodes = limits.maxTotalNodes ?? JSON_EVIDENCE_LIMITS.maxTotalNodes;
+  const pathSet = /* @__PURE__ */ new WeakSet();
+  let nodeCount = 0;
+  const stack = [{ type: "enter", value, path: [], depth: 0 }];
+  while (stack.length > 0) {
+    const entry = stack.pop();
+    if (entry.type === "exit") {
+      pathSet.delete(entry.obj);
+      continue;
+    }
+    const { value: current, path, depth } = entry;
+    nodeCount++;
+    if (nodeCount > maxTotalNodes) {
+      return {
+        ok: false,
+        error: `Maximum total nodes exceeded (limit: ${maxTotalNodes})`,
+        path
+      };
+    }
+    if (depth > maxDepth) {
+      return {
+        ok: false,
+        error: `Maximum depth exceeded (limit: ${maxDepth})`,
+        path
+      };
+    }
+    if (current === null) {
+      continue;
+    }
+    const type = typeof current;
+    if (type === "string") {
+      if (current.length > maxStringLength) {
+        return {
+          ok: false,
+          error: `String exceeds maximum length (limit: ${maxStringLength})`,
+          path
+        };
+      }
+      continue;
+    }
+    if (type === "number") {
+      if (!Number.isFinite(current)) {
+        return {
+          ok: false,
+          error: `Non-finite number: ${current}`,
+          path
+        };
+      }
+      continue;
+    }
+    if (type === "boolean") {
+      continue;
+    }
+    if (type === "undefined") {
+      return { ok: false, error: "undefined is not valid JSON", path };
+    }
+    if (type === "bigint") {
+      return { ok: false, error: "BigInt is not valid JSON", path };
+    }
+    if (type === "function") {
+      return { ok: false, error: "Function is not valid JSON", path };
+    }
+    if (type === "symbol") {
+      return { ok: false, error: "Symbol is not valid JSON", path };
+    }
+    if (type === "object") {
+      const obj = current;
+      if (pathSet.has(obj)) {
+        return { ok: false, error: "Cycle detected in object graph", path };
+      }
+      pathSet.add(obj);
+      stack.push({ type: "exit", obj });
+      if (Array.isArray(obj)) {
+        if (obj.length > maxArrayLength) {
+          return {
+            ok: false,
+            error: `Array exceeds maximum length (limit: ${maxArrayLength})`,
+            path
+          };
+        }
+        for (let i = obj.length - 1; i >= 0; i--) {
+          stack.push({ type: "enter", value: obj[i], path: [...path, i], depth: depth + 1 });
+        }
+        continue;
+      }
+      const proto = Object.getPrototypeOf(obj);
+      if (proto !== Object.prototype && proto !== null) {
+        const constructorName = obj.constructor?.name ?? "unknown";
+        return {
+          ok: false,
+          error: `Non-plain object (${constructorName}) is not valid JSON`,
+          path
+        };
+      }
+      const keys = Object.keys(obj);
+      if (keys.length > maxObjectKeys) {
+        return {
+          ok: false,
+          error: `Object exceeds maximum key count (limit: ${maxObjectKeys})`,
+          path
+        };
+      }
+      for (let i = keys.length - 1; i >= 0; i--) {
+        const key = keys[i];
+        stack.push({
+          type: "enter",
+          value: obj[key],
+          path: [...path, key],
+          depth: depth + 1
+        });
+      }
+      continue;
+    }
+    return { ok: false, error: `Unknown type: ${type}`, path };
+  }
+  return { ok: true };
+}
+
+// src/agent-identity.ts
+var ControlTypeSchema = z.enum(["operator", "user-delegated"]);
+var CONTROL_TYPES = ["operator", "user-delegated"];
+var ProofMethodSchema = z.enum([
+  "http-message-signature",
+  "dpop",
+  "mtls",
+  "jwk-thumbprint"
+]);
+var PROOF_METHODS = ["http-message-signature", "dpop", "mtls", "jwk-thumbprint"];
+var BindingDetailsSchema = z.object({
+  /** HTTP method (uppercase: GET, POST, etc.) */
+  method: z.string().min(1).max(16),
+  /** Target URI of the request */
+  target: z.string().min(1).max(2048),
+  /** Headers included in the signature (lowercase) */
+  headers_included: z.array(z.string().max(64)).max(32),
+  /** SHA-256 hash of request body (base64url), empty string if no body */
+  body_hash: z.string().max(64).optional(),
+  /** When the binding was signed (RFC 3339) */
+  signed_at: z.string().datetime()
+}).strict();
+var AgentProofSchema = z.object({
+  /** Proof method used */
+  method: ProofMethodSchema,
+  /** Key ID (matches kid in JWS header or JWKS) */
+  key_id: z.string().min(1).max(256),
+  /** Algorithm used (default: EdDSA for Ed25519) */
+  alg: z.string().max(32).default("EdDSA"),
+  /** Signature over binding message (base64url, for http-message-signature) */
+  signature: z.string().max(512).optional(),
+  /** DPoP proof JWT (for dpop method) */
+  dpop_proof: z.string().max(4096).optional(),
+  /** Certificate fingerprint (for mtls method, SHA-256 base64url) */
+  cert_thumbprint: z.string().max(64).optional(),
+  /** Binding details for http-message-signature */
+  binding: BindingDetailsSchema.optional()
+}).strict();
+var AgentIdentityEvidenceSchema = z.object({
+  /** Stable agent identifier (opaque string, REQUIRED) */
+  agent_id: z.string().min(1).max(256),
+  /** Control type: operator-verified or user-delegated (REQUIRED) */
+  control_type: ControlTypeSchema,
+  /** Agent capabilities/scopes (optional, for fine-grained access) */
+  capabilities: z.array(z.string().max(64)).max(32).optional(),
+  /** Delegation chain for user-delegated agents (optional) */
+  delegation_chain: z.array(z.string().max(256)).max(8).optional(),
+  /** Cryptographic proof of key control (optional) */
+  proof: AgentProofSchema.optional(),
+  /** Key directory URL for public key discovery (optional) */
+  key_directory_url: z.string().url().max(2048).optional(),
+  /** Agent operator/organization (optional, for operator type) */
+  operator: z.string().max(256).optional(),
+  /** User identifier (optional, for user-delegated type, should be opaque) */
+  user_id: z.string().max(256).optional(),
+  /** Additional type-specific metadata (optional) */
+  metadata: z.record(z.string(), JsonValueSchema).optional()
+}).strict();
+var AGENT_IDENTITY_TYPE = "peac/agent-identity";
+var AgentIdentityAttestationSchema = z.object({
+  /** Attestation type (MUST be 'peac/agent-identity') */
+  type: z.literal(AGENT_IDENTITY_TYPE),
+  /** Issuer of the attestation (agent operator, IdP, or platform) */
+  issuer: z.string().min(1).max(2048),
+  /** When the attestation was issued (RFC 3339) */
+  issued_at: z.string().datetime(),
+  /** When the attestation expires (RFC 3339, optional) */
+  expires_at: z.string().datetime().optional(),
+  /** Reference to external verification endpoint (optional) */
+  ref: z.string().url().max(2048).optional(),
+  /** Agent identity evidence */
+  evidence: AgentIdentityEvidenceSchema
+}).strict();
+var IdentityBindingSchema = z.object({
+  /** SHA-256 hash of the canonical binding message (base64url) */
+  binding_message_hash: z.string().min(1).max(64),
+  /** Ed25519 signature over binding message (base64url) */
+  signature: z.string().min(1).max(512),
+  /** Key ID used for signing */
+  key_id: z.string().min(1).max(256),
+  /** When the binding was created (RFC 3339) */
+  signed_at: z.string().datetime()
+}).strict();
+var AgentIdentityVerifiedSchema = z.object({
+  /** Agent ID from the verified attestation */
+  agent_id: z.string().min(1).max(256),
+  /** Control type from the verified attestation */
+  control_type: ControlTypeSchema,
+  /** When the publisher verified the identity (RFC 3339) */
+  verified_at: z.string().datetime(),
+  /** Key ID that was used for verification */
+  key_id: z.string().min(1).max(256),
+  /** SHA-256 hash of the binding message (base64url) */
+  binding_hash: z.string().min(1).max(64)
+}).strict();
+function validateAgentIdentityAttestation(data) {
+  const result = AgentIdentityAttestationSchema.safeParse(data);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  return { ok: false, error: result.error.message };
+}
+function isAgentIdentityAttestation(attestation) {
+  return attestation.type === AGENT_IDENTITY_TYPE;
+}
+function createAgentIdentityAttestation(params) {
+  const evidence = {
+    agent_id: params.agent_id,
+    control_type: params.control_type
+  };
+  if (params.capabilities) {
+    evidence.capabilities = params.capabilities;
+  }
+  if (params.delegation_chain) {
+    evidence.delegation_chain = params.delegation_chain;
+  }
+  if (params.proof) {
+    evidence.proof = params.proof;
+  }
+  if (params.key_directory_url) {
+    evidence.key_directory_url = params.key_directory_url;
+  }
+  if (params.operator) {
+    evidence.operator = params.operator;
+  }
+  if (params.user_id) {
+    evidence.user_id = params.user_id;
+  }
+  if (params.metadata) {
+    evidence.metadata = params.metadata;
+  }
+  const attestation = {
+    type: AGENT_IDENTITY_TYPE,
+    issuer: params.issuer,
+    issued_at: (/* @__PURE__ */ new Date()).toISOString(),
+    evidence
+  };
+  if (params.expires_at) {
+    attestation.expires_at = params.expires_at;
+  }
+  if (params.ref) {
+    attestation.ref = params.ref;
+  }
+  return attestation;
+}
+function validateIdentityBinding(data) {
+  const result = IdentityBindingSchema.safeParse(data);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  return { ok: false, error: result.error.message };
+}
+function isAttestationExpired(attestation, clockSkew = 3e4) {
+  if (!attestation.expires_at) {
+    return false;
+  }
+  const expiresAt = new Date(attestation.expires_at).getTime();
+  const now = Date.now();
+  return expiresAt < now - clockSkew;
+}
+function isAttestationNotYetValid(attestation, clockSkew = 3e4) {
+  const issuedAt = new Date(attestation.issued_at).getTime();
+  const now = Date.now();
+  return issuedAt > now + clockSkew;
+}
+var ATTRIBUTION_LIMITS = {
+  /** Maximum sources per attestation */
+  maxSources: 100,
+  /** Maximum chain resolution depth */
+  maxDepth: 8,
+  /** Maximum attestation size in bytes (64KB) */
+  maxAttestationSize: 65536,
+  /** Per-hop resolution timeout in milliseconds */
+  resolutionTimeout: 5e3,
+  /** Maximum receipt reference length */
+  maxReceiptRefLength: 2048,
+  /** Maximum model ID length */
+  maxModelIdLength: 256
+};
+var HashAlgorithmSchema = z.literal("sha-256");
+var HashEncodingSchema = z.literal("base64url");
+var ContentHashSchema = z.object({
+  /** Hash algorithm (REQUIRED, must be 'sha-256') */
+  alg: HashAlgorithmSchema,
+  /** Base64url-encoded hash value without padding (REQUIRED, 43 chars for SHA-256) */
+  value: z.string().min(43).max(43).regex(/^[A-Za-z0-9_-]+$/, "Invalid base64url characters"),
+  /** Encoding format (REQUIRED, must be 'base64url') */
+  enc: HashEncodingSchema
+}).strict();
+var AttributionUsageSchema = z.enum([
+  "training_input",
+  "rag_context",
+  "direct_reference",
+  "synthesis_source",
+  "embedding_source"
+]);
+var ATTRIBUTION_USAGES = [
+  "training_input",
+  "rag_context",
+  "direct_reference",
+  "synthesis_source",
+  "embedding_source"
+];
+var DerivationTypeSchema = z.enum([
+  "training",
+  "inference",
+  "rag",
+  "synthesis",
+  "embedding"
+]);
+var DERIVATION_TYPES = ["training", "inference", "rag", "synthesis", "embedding"];
+var ReceiptRefSchema = z.string().min(1).max(ATTRIBUTION_LIMITS.maxReceiptRefLength).refine(
+  (ref) => {
+    if (ref.startsWith("jti:")) return true;
+    if (ref.startsWith("https://") || ref.startsWith("http://")) return true;
+    if (ref.startsWith("urn:peac:receipt:")) return true;
+    return false;
+  },
+  { message: "Invalid receipt reference format. Must be jti:{id}, URL, or urn:peac:receipt:{id}" }
+);
+var AttributionSourceSchema = z.object({
+  /** Reference to source PEAC receipt (REQUIRED) */
+  receipt_ref: ReceiptRefSchema,
+  /**
+   * Issuer of the referenced receipt (OPTIONAL but RECOMMENDED for jti: refs).
+   *
+   * Required for cross-issuer resolution when receipt_ref is jti:{id} format.
+   * Not needed for URL-based references which are self-resolvable.
+   * Used to construct resolution URL: {receipt_issuer}/.well-known/peac/receipts/{id}
+   */
+  receipt_issuer: z.string().url().max(2048).optional(),
+  /** Hash of source content (OPTIONAL) */
+  content_hash: ContentHashSchema.optional(),
+  /** Hash of used excerpt (OPTIONAL, content-minimizing, not privacy-preserving for short text) */
+  excerpt_hash: ContentHashSchema.optional(),
+  /** How the source was used (REQUIRED) */
+  usage: AttributionUsageSchema,
+  /** Relative contribution weight 0.0-1.0 (OPTIONAL) */
+  weight: z.number().min(0).max(1).optional()
+}).strict();
+var AttributionEvidenceSchema = z.object({
+  /** Array of attribution sources (REQUIRED, 1-100 sources) */
+  sources: z.array(AttributionSourceSchema).min(1).max(ATTRIBUTION_LIMITS.maxSources),
+  /** Type of derivation (REQUIRED) */
+  derivation_type: DerivationTypeSchema,
+  /** Hash of derived output (OPTIONAL) */
+  output_hash: ContentHashSchema.optional(),
+  /** Model identifier (OPTIONAL) */
+  model_id: z.string().max(ATTRIBUTION_LIMITS.maxModelIdLength).optional(),
+  /** Inference provider URL (OPTIONAL) */
+  inference_provider: z.string().url().max(2048).optional(),
+  /** Session correlation ID (OPTIONAL) */
+  session_id: z.string().max(256).optional(),
+  /** Additional type-specific metadata (OPTIONAL) */
+  metadata: z.record(z.string(), JsonValueSchema).optional()
+}).strict();
+var ATTRIBUTION_TYPE = "peac/attribution";
+var AttributionAttestationSchema = z.object({
+  /** Attestation type (MUST be 'peac/attribution') */
+  type: z.literal(ATTRIBUTION_TYPE),
+  /** Issuer of the attestation (inference provider, platform) */
+  issuer: z.string().min(1).max(2048),
+  /** When the attestation was issued (RFC 3339) */
+  issued_at: z.string().datetime(),
+  /** When the attestation expires (RFC 3339, OPTIONAL) */
+  expires_at: z.string().datetime().optional(),
+  /** Reference to external verification endpoint (OPTIONAL) */
+  ref: z.string().url().max(2048).optional(),
+  /** Attribution evidence */
+  evidence: AttributionEvidenceSchema
+}).strict();
+function validateContentHash(data) {
+  const result = ContentHashSchema.safeParse(data);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  return { ok: false, error: result.error.message };
+}
+function validateAttributionSource(data) {
+  const result = AttributionSourceSchema.safeParse(data);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  return { ok: false, error: result.error.message };
+}
+function validateAttributionAttestation(data) {
+  const result = AttributionAttestationSchema.safeParse(data);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  return { ok: false, error: result.error.message };
+}
+function isAttributionAttestation(attestation) {
+  return attestation.type === ATTRIBUTION_TYPE;
+}
+function createAttributionAttestation(params) {
+  const evidence = {
+    sources: params.sources,
+    derivation_type: params.derivation_type
+  };
+  if (params.output_hash) {
+    evidence.output_hash = params.output_hash;
+  }
+  if (params.model_id) {
+    evidence.model_id = params.model_id;
+  }
+  if (params.inference_provider) {
+    evidence.inference_provider = params.inference_provider;
+  }
+  if (params.session_id) {
+    evidence.session_id = params.session_id;
+  }
+  if (params.metadata) {
+    evidence.metadata = params.metadata;
+  }
+  const attestation = {
+    type: ATTRIBUTION_TYPE,
+    issuer: params.issuer,
+    issued_at: (/* @__PURE__ */ new Date()).toISOString(),
+    evidence
+  };
+  if (params.expires_at) {
+    attestation.expires_at = params.expires_at;
+  }
+  if (params.ref) {
+    attestation.ref = params.ref;
+  }
+  return attestation;
+}
+function isAttributionExpired(attestation, clockSkew = 3e4) {
+  if (!attestation.expires_at) {
+    return false;
+  }
+  const expiresAt = new Date(attestation.expires_at).getTime();
+  const now = Date.now();
+  return expiresAt < now - clockSkew;
+}
+function isAttributionNotYetValid(attestation, clockSkew = 3e4) {
+  const issuedAt = new Date(attestation.issued_at).getTime();
+  const now = Date.now();
+  return issuedAt > now + clockSkew;
+}
+function computeTotalWeight(sources) {
+  const weights = sources.filter((s) => s.weight !== void 0).map((s) => s.weight);
+  if (weights.length === 0) {
+    return void 0;
+  }
+  return weights.reduce((sum, w) => sum + w, 0);
+}
+function detectCycleInSources(sources, visited = /* @__PURE__ */ new Set()) {
+  for (const source of sources) {
+    if (visited.has(source.receipt_ref)) {
+      return source.receipt_ref;
+    }
+  }
+  return void 0;
+}
+var PEAC_WIRE_TYP = WIRE_TYPE;
+var PEAC_ALG = ALGORITHMS.default;
+var PEAC_RECEIPT_HEADER = HEADERS.receipt;
+var PEAC_PURPOSE_HEADER = HEADERS.purpose;
+var PEAC_PURPOSE_APPLIED_HEADER = HEADERS.purposeApplied;
+var PEAC_PURPOSE_REASON_HEADER = HEADERS.purposeReason;
+var PEAC_POLICY_PATH = POLICY.manifestPath;
+var PEAC_POLICY_FALLBACK_PATH = POLICY.fallbackPath;
+var PEAC_POLICY_MAX_BYTES = POLICY.maxBytes;
+var PEAC_ISSUER_CONFIG_PATH = ISSUER_CONFIG.configPath;
+var PEAC_ISSUER_CONFIG_VERSION = ISSUER_CONFIG.configVersion;
+var PEAC_ISSUER_CONFIG_MAX_BYTES = ISSUER_CONFIG.maxBytes;
+var PEAC_DISCOVERY_PATH = DISCOVERY.manifestPath;
+var PEAC_DISCOVERY_MAX_BYTES = 2e3;
+var PEAC_RECEIPT_SCHEMA_URL = "https://www.peacprotocol.org/schemas/wire/0.1/peac-receipt.0.1.schema.json";
+var httpsUrl = z.string().url().refine((u) => u.startsWith("https://"), "must be https://");
+var iso4217 = z.string().regex(/^[A-Z]{3}$/);
+var uuidv7 = z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+var NormalizedPayment = z.object({
+  rail: z.string().min(1),
+  reference: z.string().min(1),
+  amount: z.number().int().nonnegative(),
+  currency: iso4217,
+  asset: z.string().optional(),
+  env: z.string().optional(),
+  evidence: JsonValueSchema.optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var Subject = z.object({ uri: httpsUrl }).strict();
+var AIPREFSnapshot = z.object({
+  url: httpsUrl,
+  hash: z.string().min(8)
+}).strict();
+var Extensions = z.object({
+  aipref_snapshot: AIPREFSnapshot.optional()
+  // control block validated via ControlBlockSchema when present
+}).catchall(z.unknown());
+var JWSHeader = z.object({
+  typ: z.literal(PEAC_WIRE_TYP),
+  alg: z.literal(PEAC_ALG),
+  kid: z.string().min(8)
+}).strict();
+var CanonicalPurposeValues = ["train", "search", "user_action", "inference", "index"];
+var PurposeReasonValues = [
+  "allowed",
+  "constrained",
+  "denied",
+  "downgraded",
+  "undeclared_default",
+  "unknown_preserved"
+];
+var ReceiptClaimsSchema = z.object({
+  iss: httpsUrl,
+  aud: httpsUrl,
+  iat: z.number().int().nonnegative(),
+  exp: z.number().int().optional(),
+  rid: uuidv7,
+  amt: z.number().int().nonnegative(),
+  cur: iso4217,
+  payment: NormalizedPayment,
+  subject: Subject.optional(),
+  ext: Extensions.optional(),
+  // Purpose claims (v0.9.24+)
+  // purpose_declared: string[] - preserves unknown tokens for forward-compat
+  purpose_declared: z.array(z.string()).optional(),
+  // purpose_enforced: CanonicalPurpose - must be one with enforcement semantics
+  purpose_enforced: z.enum(CanonicalPurposeValues).optional(),
+  // purpose_reason: PurposeReason - audit spine for enforcement decisions
+  purpose_reason: z.enum(PurposeReasonValues).optional()
+}).strict();
+var ReceiptClaims = ReceiptClaimsSchema;
+var VerifyRequest = z.object({
+  receipt_jws: z.string().min(16)
+}).strict();
+var ControlPurposeSchema = z.enum([
+  "crawl",
+  "index",
+  "train",
+  "inference",
+  "user_action",
+  "ai_input",
+  "ai_index",
+  "search"
+]);
+var ControlLicensingModeSchema = z.enum([
+  "subscription",
+  "pay_per_crawl",
+  "pay_per_inference"
+]);
+var ControlDecisionSchema = z.enum(["allow", "deny", "review"]);
+var ControlStepSchema = z.object({
+  engine: z.string().min(1),
+  version: z.string().optional(),
+  policy_id: z.string().optional(),
+  result: ControlDecisionSchema,
+  reason: z.string().optional(),
+  purpose: ControlPurposeSchema.optional(),
+  licensing_mode: ControlLicensingModeSchema.optional(),
+  scope: z.union([z.string(), z.array(z.string())]).optional(),
+  limits_snapshot: z.unknown().optional(),
+  evidence_ref: z.string().optional()
+});
+var ControlBlockSchema = z.object({
+  chain: z.array(ControlStepSchema).min(1),
+  decision: ControlDecisionSchema,
+  combinator: z.literal("any_can_veto").optional()
+}).refine(
+  (data) => {
+    const hasAnyDeny = data.chain.some((step) => step.result === "deny");
+    const allAllow = data.chain.every((step) => step.result === "allow");
+    const hasReview = data.chain.some((step) => step.result === "review");
+    if (hasAnyDeny && data.decision !== "deny") {
+      return false;
+    }
+    if (allAllow && data.decision !== "allow") {
+      return false;
+    }
+    if (hasReview && !hasAnyDeny && data.decision === "deny") {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "Control block decision must be consistent with chain results"
+  }
+);
+var PurposeTokenSchema = z.string().min(1).max(MAX_PURPOSE_TOKEN_LENGTH).refine((token) => PURPOSE_TOKEN_REGEX.test(token), {
+  message: "Invalid purpose token format. Must be lowercase, alphanumeric with underscores, optional vendor prefix."
+});
+var CanonicalPurposeSchema = z.enum([
+  "train",
+  "search",
+  "user_action",
+  "inference",
+  "index"
+]);
+var PurposeReasonSchema = z.enum([
+  "allowed",
+  "constrained",
+  "denied",
+  "downgraded",
+  "undeclared_default",
+  "unknown_preserved"
+]);
+var PaymentSplitSchema = z.object({
+  party: z.string().min(1),
+  amount: z.number().int().nonnegative().optional(),
+  currency: iso4217.optional(),
+  share: z.number().min(0).max(1).optional(),
+  rail: z.string().min(1).optional(),
+  account_ref: z.string().min(1).optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict().refine((data) => data.amount !== void 0 || data.share !== void 0, {
+  message: "At least one of amount or share must be specified"
+});
+var PaymentRoutingSchema = z.enum(["direct", "callback", "role"]);
+var PaymentEvidenceSchema = z.object({
+  rail: z.string().min(1),
+  reference: z.string().min(1),
+  amount: z.number().int().nonnegative(),
+  currency: iso4217,
+  asset: z.string().min(1),
+  env: z.enum(["live", "test"]),
+  network: z.string().min(1).optional(),
+  facilitator_ref: z.string().min(1).optional(),
+  evidence: JsonValueSchema,
+  aggregator: z.string().min(1).optional(),
+  splits: z.array(PaymentSplitSchema).optional(),
+  routing: PaymentRoutingSchema.optional()
+}).strict();
+var SubjectTypeSchema = z.enum(["human", "org", "agent"]);
+var SubjectProfileSchema = z.object({
+  id: z.string().min(1),
+  type: SubjectTypeSchema,
+  labels: z.array(z.string().min(1)).optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var SubjectProfileSnapshotSchema = z.object({
+  subject: SubjectProfileSchema,
+  captured_at: z.string().min(1),
+  source: z.string().min(1).optional(),
+  version: z.string().min(1).optional()
+}).strict();
+var ExtensionsSchema = z.record(
+  z.string().regex(/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/),
+  JsonValueSchema
+);
+var AttestationSchema = z.object({
+  issuer: z.string().min(1),
+  type: z.string().min(1),
+  issued_at: z.string().datetime(),
+  expires_at: z.string().datetime().optional(),
+  ref: z.string().url().optional(),
+  evidence: JsonValueSchema
+}).strict();
+var warnedSubjectIds = /* @__PURE__ */ new Set();
+function looksLikePII(id) {
+  if (/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(id)) {
+    return true;
+  }
+  if (/^\+?\d{10,15}$/.test(id.replace(/[\s\-()]/g, ""))) {
+    return true;
+  }
+  return false;
+}
+function validateSubjectSnapshot(snapshot) {
+  if (snapshot === void 0 || snapshot === null) {
+    return null;
+  }
+  const validated = SubjectProfileSnapshotSchema.parse(snapshot);
+  const subjectId = validated.subject.id;
+  if (looksLikePII(subjectId) && !warnedSubjectIds.has(subjectId)) {
+    warnedSubjectIds.add(subjectId);
+    console.warn(
+      `[peac:subject] Advisory: subject.id "${subjectId}" looks like PII. Prefer opaque identifiers (e.g., "user:abc123").`
+    );
+  }
+  return validated;
+}
+function validateEvidence(evidence, limits) {
+  const result = assertJsonSafeIterative(evidence, limits);
+  if (!result.ok) {
+    return {
+      ok: false,
+      error: createEvidenceNotJsonError(result.error, result.path)
+    };
+  }
+  return { ok: true, value: evidence };
+}
+var DISPUTE_LIMITS = {
+  /** Maximum grounds per dispute */
+  maxGrounds: 10,
+  /** Maximum supporting receipts */
+  maxSupportingReceipts: 50,
+  /** Maximum supporting attributions */
+  maxSupportingAttributions: 50,
+  /** Maximum supporting documents */
+  maxSupportingDocuments: 20,
+  /** Maximum description length in chars */
+  maxDescriptionLength: 4e3,
+  /** Maximum details length per ground in chars */
+  maxGroundDetailsLength: 1e3,
+  /** Maximum rationale length in chars */
+  maxRationaleLength: 4e3,
+  /** Maximum remediation details length in chars */
+  maxRemediationDetailsLength: 4e3,
+  /** Minimum description for 'other' dispute type */
+  minOtherDescriptionLength: 50
+};
+var ULID_REGEX = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+var DisputeIdSchema = z.string().regex(ULID_REGEX, "Invalid ULID format");
+var DisputeTypeSchema = z.enum([
+  "unauthorized_access",
+  "attribution_missing",
+  "attribution_incorrect",
+  "receipt_invalid",
+  "identity_spoofed",
+  "purpose_mismatch",
+  "policy_violation",
+  "other"
+]);
+var DISPUTE_TYPES = [
+  "unauthorized_access",
+  "attribution_missing",
+  "attribution_incorrect",
+  "receipt_invalid",
+  "identity_spoofed",
+  "purpose_mismatch",
+  "policy_violation",
+  "other"
+];
+var DisputeTargetTypeSchema = z.enum(["receipt", "attribution", "identity", "policy"]);
+var DISPUTE_TARGET_TYPES = ["receipt", "attribution", "identity", "policy"];
+var DisputeGroundsCodeSchema = z.enum([
+  // Evidence-based
+  "missing_receipt",
+  "expired_receipt",
+  "forged_receipt",
+  "receipt_not_applicable",
+  // Attribution-based
+  "content_not_used",
+  "source_misidentified",
+  "usage_type_wrong",
+  "weight_inaccurate",
+  // Identity-based
+  "agent_impersonation",
+  "key_compromise",
+  "delegation_invalid",
+  // Policy-based
+  "purpose_exceeded",
+  "terms_violated",
+  "rate_limit_exceeded"
+]);
+var DISPUTE_GROUNDS_CODES = [
+  "missing_receipt",
+  "expired_receipt",
+  "forged_receipt",
+  "receipt_not_applicable",
+  "content_not_used",
+  "source_misidentified",
+  "usage_type_wrong",
+  "weight_inaccurate",
+  "agent_impersonation",
+  "key_compromise",
+  "delegation_invalid",
+  "purpose_exceeded",
+  "terms_violated",
+  "rate_limit_exceeded"
+];
+var DisputeGroundsSchema = z.object({
+  /** Specific code for this ground (REQUIRED) */
+  code: DisputeGroundsCodeSchema,
+  /** Reference to supporting evidence (OPTIONAL) */
+  evidence_ref: z.string().max(2048).optional(),
+  /** Additional context for this ground (OPTIONAL) */
+  details: z.string().max(DISPUTE_LIMITS.maxGroundDetailsLength).optional()
+}).strict();
+var DisputeStateSchema = z.enum([
+  "filed",
+  "acknowledged",
+  "under_review",
+  "escalated",
+  "resolved",
+  "rejected",
+  "appealed",
+  "final"
+]);
+var DISPUTE_STATES = [
+  "filed",
+  "acknowledged",
+  "under_review",
+  "escalated",
+  "resolved",
+  "rejected",
+  "appealed",
+  "final"
+];
+var TERMINAL_STATES = ["resolved", "rejected", "final"];
+var DISPUTE_TRANSITIONS = {
+  filed: ["acknowledged", "rejected"],
+  acknowledged: ["under_review", "rejected"],
+  under_review: ["resolved", "escalated"],
+  escalated: ["resolved"],
+  resolved: ["appealed", "final"],
+  rejected: ["appealed", "final"],
+  appealed: ["under_review", "final"],
+  final: []
+  // Terminal - no transitions out
+};
+function canTransitionTo(current, next) {
+  return DISPUTE_TRANSITIONS[current].includes(next);
+}
+function isTerminalState(state) {
+  return TERMINAL_STATES.includes(state);
+}
+function getValidTransitions(current) {
+  return DISPUTE_TRANSITIONS[current];
+}
+var DisputeOutcomeSchema = z.enum(["upheld", "dismissed", "partially_upheld", "settled"]);
+var DISPUTE_OUTCOMES = ["upheld", "dismissed", "partially_upheld", "settled"];
+var RemediationTypeSchema = z.enum([
+  "attribution_corrected",
+  "receipt_revoked",
+  "access_restored",
+  "compensation",
+  "policy_updated",
+  "no_action",
+  "other"
+]);
+var REMEDIATION_TYPES = [
+  "attribution_corrected",
+  "receipt_revoked",
+  "access_restored",
+  "compensation",
+  "policy_updated",
+  "no_action",
+  "other"
+];
+var RemediationSchema = z.object({
+  /** Type of remediation (REQUIRED) */
+  type: RemediationTypeSchema,
+  /** Details of the remediation action (REQUIRED) */
+  details: z.string().min(1).max(DISPUTE_LIMITS.maxRemediationDetailsLength),
+  /** Deadline for completing remediation (OPTIONAL) */
+  deadline: z.string().datetime().optional()
+}).strict();
+var DisputeResolutionSchema = z.object({
+  /** Outcome of the dispute (REQUIRED) */
+  outcome: DisputeOutcomeSchema,
+  /** When the decision was made (REQUIRED) */
+  decided_at: z.string().datetime(),
+  /** Who made the decision (REQUIRED) */
+  decided_by: z.string().min(1).max(2048),
+  /** Explanation of the decision (REQUIRED) */
+  rationale: z.string().min(1).max(DISPUTE_LIMITS.maxRationaleLength),
+  /** Remediation action if applicable (OPTIONAL) */
+  remediation: RemediationSchema.optional()
+}).strict();
+var ContactMethodSchema = z.enum(["email", "url", "did"]);
+var DisputeContactSchema = z.object({
+  /** Contact method (REQUIRED) */
+  method: ContactMethodSchema,
+  /** Contact value (REQUIRED) */
+  value: z.string().min(1).max(2048)
+}).strict().superRefine((contact, ctx) => {
+  if (contact.method === "email") {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(contact.value)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Invalid email format",
+        path: ["value"]
+      });
+    }
+  } else if (contact.method === "did") {
+    if (!contact.value.startsWith("did:")) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'DID must start with "did:"',
+        path: ["value"]
+      });
+    }
+  } else if (contact.method === "url") {
+    try {
+      new URL(contact.value);
+    } catch {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Invalid URL format",
+        path: ["value"]
+      });
+    }
+  }
+});
+var DocumentRefSchema = z.object({
+  /** URI of the document (REQUIRED) */
+  uri: z.string().url().max(2048),
+  /** Content hash for integrity verification (OPTIONAL) */
+  content_hash: ContentHashSchema.optional(),
+  /** Brief description of the document (OPTIONAL) */
+  description: z.string().max(500).optional()
+}).strict();
+var DisputeEvidenceBaseSchema = z.object({
+  /** Type of dispute (REQUIRED) */
+  dispute_type: DisputeTypeSchema,
+  /** Reference to disputed target: jti:{id}, URL, or URN (REQUIRED) */
+  target_ref: z.string().min(1).max(2048),
+  /** Type of target being disputed (REQUIRED) */
+  target_type: DisputeTargetTypeSchema,
+  /** Grounds for the dispute (REQUIRED, at least 1) */
+  grounds: z.array(DisputeGroundsSchema).min(1).max(DISPUTE_LIMITS.maxGrounds),
+  /** Human-readable description (REQUIRED) */
+  description: z.string().min(1).max(DISPUTE_LIMITS.maxDescriptionLength),
+  /** Receipt references supporting the claim (OPTIONAL) */
+  supporting_receipts: z.array(z.string().max(2048)).max(DISPUTE_LIMITS.maxSupportingReceipts).optional(),
+  /** Attribution references supporting the claim (OPTIONAL) */
+  supporting_attributions: z.array(z.string().max(2048)).max(DISPUTE_LIMITS.maxSupportingAttributions).optional(),
+  /** External document references (OPTIONAL) */
+  supporting_documents: z.array(DocumentRefSchema).max(DISPUTE_LIMITS.maxSupportingDocuments).optional(),
+  /** Contact for dispute resolution (OPTIONAL) */
+  contact: DisputeContactSchema.optional(),
+  /** Current lifecycle state (REQUIRED) */
+  state: DisputeStateSchema,
+  /** When state was last changed (OPTIONAL) */
+  state_changed_at: z.string().datetime().optional(),
+  /** Reason for state change (OPTIONAL) */
+  state_reason: z.string().max(1e3).optional(),
+  /** Resolution details (REQUIRED for terminal states) */
+  resolution: DisputeResolutionSchema.optional(),
+  /** Advisory: filing window used by issuer in days (OPTIONAL, informative only) */
+  window_hint_days: z.number().int().positive().max(365).optional()
+}).strict();
+var DisputeEvidenceSchema = DisputeEvidenceBaseSchema.superRefine((evidence, ctx) => {
+  const terminalStates = ["resolved", "rejected", "final"];
+  if (terminalStates.includes(evidence.state) && !evidence.resolution) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `Resolution is required when state is "${evidence.state}"`,
+      path: ["resolution"]
+    });
+  }
+  if (evidence.resolution && !terminalStates.includes(evidence.state)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `Resolution is only valid for terminal states (resolved, rejected, final), not "${evidence.state}"`,
+      path: ["state"]
+    });
+  }
+  if (evidence.dispute_type === "other" && evidence.description.length < DISPUTE_LIMITS.minOtherDescriptionLength) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `Dispute type "other" requires description of at least ${DISPUTE_LIMITS.minOtherDescriptionLength} characters`,
+      path: ["description"]
+    });
+  }
+});
+var DISPUTE_TYPE = "peac/dispute";
+var DisputeAttestationSchema = z.object({
+  /** Attestation type (MUST be 'peac/dispute') */
+  type: z.literal(DISPUTE_TYPE),
+  /** Party filing the dispute (REQUIRED) */
+  issuer: z.string().min(1).max(2048),
+  /** When the dispute was filed (REQUIRED) */
+  issued_at: z.string().datetime(),
+  /** When the dispute expires (OPTIONAL) */
+  expires_at: z.string().datetime().optional(),
+  /** Unique dispute reference in ULID format (REQUIRED) */
+  ref: DisputeIdSchema,
+  /** Dispute evidence and state */
+  evidence: DisputeEvidenceSchema
+}).strict();
+function validateDisputeAttestation(data) {
+  const result = DisputeAttestationSchema.safeParse(data);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  return { ok: false, error: result.error.message };
+}
+function isValidDisputeAttestation(data) {
+  return DisputeAttestationSchema.safeParse(data).success;
+}
+function isDisputeAttestation(attestation) {
+  return attestation.type === DISPUTE_TYPE;
+}
+function validateDisputeResolution(data) {
+  const result = DisputeResolutionSchema.safeParse(data);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  return { ok: false, error: result.error.message };
+}
+function validateDisputeContact(data) {
+  const result = DisputeContactSchema.safeParse(data);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  return { ok: false, error: result.error.message };
+}
+function createDisputeAttestation(params) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const evidence = {
+    dispute_type: params.dispute_type,
+    target_ref: params.target_ref,
+    target_type: params.target_type,
+    grounds: params.grounds,
+    description: params.description,
+    state: "filed"
+  };
+  if (params.contact) {
+    evidence.contact = params.contact;
+  }
+  if (params.supporting_receipts) {
+    evidence.supporting_receipts = params.supporting_receipts;
+  }
+  if (params.supporting_attributions) {
+    evidence.supporting_attributions = params.supporting_attributions;
+  }
+  if (params.supporting_documents) {
+    evidence.supporting_documents = params.supporting_documents;
+  }
+  if (params.window_hint_days !== void 0) {
+    evidence.window_hint_days = params.window_hint_days;
+  }
+  const attestation = {
+    type: DISPUTE_TYPE,
+    issuer: params.issuer,
+    issued_at: now,
+    ref: params.ref,
+    evidence
+  };
+  if (params.expires_at) {
+    attestation.expires_at = params.expires_at;
+  }
+  return attestation;
+}
+function transitionDisputeState(dispute, newState, reason, resolution) {
+  const currentState = dispute.evidence.state;
+  if (!canTransitionTo(currentState, newState)) {
+    return {
+      ok: false,
+      error: `Invalid transition from "${currentState}" to "${newState}". Valid transitions: ${DISPUTE_TRANSITIONS[currentState].join(", ") || "none"}`,
+      code: "INVALID_TRANSITION"
+    };
+  }
+  const isTargetTerminal = isTerminalState(newState);
+  if (isTargetTerminal && !resolution) {
+    return {
+      ok: false,
+      error: `Resolution is required when transitioning to terminal state "${newState}"`,
+      code: "RESOLUTION_REQUIRED"
+    };
+  }
+  if (!isTargetTerminal && resolution) {
+    return {
+      ok: false,
+      error: `Resolution is not allowed for non-terminal state "${newState}"`,
+      code: "RESOLUTION_NOT_ALLOWED"
+    };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const { resolution: _existingResolution, ...evidenceWithoutResolution } = dispute.evidence;
+  const updatedEvidence = {
+    ...evidenceWithoutResolution,
+    state: newState,
+    state_changed_at: now
+  };
+  if (reason) {
+    updatedEvidence.state_reason = reason;
+  }
+  if (isTargetTerminal && resolution) {
+    updatedEvidence.resolution = resolution;
+  }
+  return {
+    ok: true,
+    value: {
+      ...dispute,
+      evidence: updatedEvidence
+    }
+  };
+}
+function isDisputeExpired(attestation, clockSkew = 3e4) {
+  if (!attestation.expires_at) {
+    return false;
+  }
+  const expiresAt = new Date(attestation.expires_at).getTime();
+  const now = Date.now();
+  return expiresAt < now - clockSkew;
+}
+function isDisputeNotYetValid(attestation, clockSkew = 3e4) {
+  const issuedAt = new Date(attestation.issued_at).getTime();
+  const now = Date.now();
+  return issuedAt > now + clockSkew;
+}
+var WORKFLOW_EXTENSION_KEY = "org.peacprotocol/workflow";
+var WORKFLOW_SUMMARY_TYPE = "peac/workflow-summary";
+var WORKFLOW_STATUSES = ["in_progress", "completed", "failed", "cancelled"];
+var WELL_KNOWN_FRAMEWORKS = [
+  "mcp",
+  "a2a",
+  "crewai",
+  "langgraph",
+  "autogen",
+  "custom"
+];
+var ORCHESTRATION_FRAMEWORKS = WELL_KNOWN_FRAMEWORKS;
+var FRAMEWORK_ID_PATTERN = /^[a-z][a-z0-9_-]*$/;
+var WORKFLOW_LIMITS = {
+  /** Maximum parent steps per step (DAG fan-in) */
+  maxParentSteps: 16,
+  /** Maximum workflow ID length */
+  maxWorkflowIdLength: 128,
+  /** Maximum step ID length */
+  maxStepIdLength: 128,
+  /** Maximum tool name length */
+  maxToolNameLength: 256,
+  /** Maximum framework identifier length */
+  maxFrameworkLength: 64,
+  /** Maximum agents in a workflow summary */
+  maxAgentsInvolved: 100,
+  /** Maximum receipt refs in a workflow summary */
+  maxReceiptRefs: 1e4,
+  /** Maximum error message length */
+  maxErrorMessageLength: 1024
+};
+var WORKFLOW_ID_PATTERN = /^wf_[a-zA-Z0-9_-]{20,48}$/;
+var STEP_ID_PATTERN = /^step_[a-zA-Z0-9_-]{20,48}$/;
+var WorkflowIdSchema = z.string().regex(WORKFLOW_ID_PATTERN, "Invalid workflow ID format (expected wf_{ulid|uuid})").max(WORKFLOW_LIMITS.maxWorkflowIdLength);
+var StepIdSchema = z.string().regex(STEP_ID_PATTERN, "Invalid step ID format (expected step_{ulid|uuid})").max(WORKFLOW_LIMITS.maxStepIdLength);
+var WorkflowStatusSchema = z.enum(WORKFLOW_STATUSES);
+var OrchestrationFrameworkSchema = z.string().regex(
+  FRAMEWORK_ID_PATTERN,
+  "Invalid framework identifier (must be lowercase alphanumeric with hyphens/underscores, starting with a letter)"
+).max(WORKFLOW_LIMITS.maxFrameworkLength);
+var WorkflowContextSchema = z.object({
+  // Correlation
+  /** Globally unique workflow/run ID */
+  workflow_id: WorkflowIdSchema,
+  /** This step's unique ID */
+  step_id: StepIdSchema,
+  /** DAG parent step IDs (empty array for root step) */
+  parent_step_ids: z.array(StepIdSchema).max(WORKFLOW_LIMITS.maxParentSteps).default([]),
+  // Orchestration identity
+  /** Agent identity ref of the orchestrator (optional) */
+  orchestrator_id: z.string().max(256).optional(),
+  /** Receipt ID that initiated this workflow (optional) */
+  orchestrator_receipt_ref: z.string().max(256).optional(),
+  // Sequencing (for linear workflows)
+  /** 0-based position in sequential runs (optional) */
+  step_index: z.number().int().nonnegative().optional(),
+  /** Total steps if known upfront (optional) */
+  step_total: z.number().int().positive().optional(),
+  // Metadata
+  /** Tool or skill name (MCP tool, A2A skill, etc.) */
+  tool_name: z.string().max(WORKFLOW_LIMITS.maxToolNameLength).optional(),
+  /** Orchestration framework */
+  framework: OrchestrationFrameworkSchema.optional(),
+  // Hash chain (for streaming/progressive receipts)
+  /** SHA-256 hash of previous receipt in chain (for ordering) */
+  prev_receipt_hash: z.string().regex(/^sha256:[a-f0-9]{64}$/).optional()
+}).strict();
+var WorkflowErrorContextSchema = z.object({
+  /** Step ID where failure occurred */
+  failed_step_id: StepIdSchema,
+  /** Error code (E_* format preferred) */
+  error_code: z.string().max(64),
+  /** Human-readable error message */
+  error_message: z.string().max(WORKFLOW_LIMITS.maxErrorMessageLength)
+}).strict();
+var WorkflowSummaryEvidenceSchema = z.object({
+  /** Workflow ID this summary describes */
+  workflow_id: WorkflowIdSchema,
+  /** Workflow status */
+  status: WorkflowStatusSchema,
+  /** When the workflow started (ISO 8601) */
+  started_at: z.string().datetime(),
+  /** When the workflow completed (ISO 8601, undefined if in_progress) */
+  completed_at: z.string().datetime().optional(),
+  // Receipt commitment
+  /** Ordered list of receipt IDs (for small workflows) */
+  receipt_refs: z.array(z.string().max(256)).max(WORKFLOW_LIMITS.maxReceiptRefs).optional(),
+  /** Merkle root of receipt digests (for large workflows, RFC 6962 style) */
+  receipt_merkle_root: z.string().regex(/^sha256:[a-f0-9]{64}$/).optional(),
+  /** Total receipt count (required if using Merkle root) */
+  receipt_count: z.number().int().nonnegative().optional(),
+  // Orchestration
+  /** Agent identity ref of the orchestrator */
+  orchestrator_id: z.string().max(256),
+  /** List of agent IDs involved in the workflow */
+  agents_involved: z.array(z.string().max(256)).max(WORKFLOW_LIMITS.maxAgentsInvolved),
+  // Outcome
+  /** SHA-256 hash of final output artifact (optional) */
+  final_result_hash: z.string().regex(/^sha256:[a-f0-9]{64}$/).optional(),
+  /** Error context if workflow failed */
+  error_context: WorkflowErrorContextSchema.optional()
+}).strict().refine(
+  (data) => {
+    return data.receipt_refs !== void 0 || data.receipt_merkle_root !== void 0;
+  },
+  {
+    message: "Workflow summary must include receipt_refs or receipt_merkle_root"
+  }
+).refine(
+  (data) => {
+    if (data.receipt_merkle_root !== void 0 && data.receipt_count === void 0) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "receipt_count is required when using receipt_merkle_root"
+  }
+);
+var WorkflowSummaryAttestationSchema = z.object({
+  /** Attestation type (must be 'peac/workflow-summary') */
+  type: z.literal(WORKFLOW_SUMMARY_TYPE),
+  /** Who issued this attestation (HTTPS URL) */
+  issuer: z.string().url().startsWith("https://"),
+  /** When this attestation was issued (ISO 8601) */
+  issued_at: z.string().datetime(),
+  /** When this attestation expires (ISO 8601, optional) */
+  expires_at: z.string().datetime().optional(),
+  /** The workflow summary evidence */
+  evidence: WorkflowSummaryEvidenceSchema
+}).strict();
+function validateWorkflowContextOrdered(input) {
+  if (typeof input !== "object" || input === null) {
+    return {
+      valid: false,
+      error_code: "E_WORKFLOW_CONTEXT_INVALID",
+      error: "Input must be an object"
+    };
+  }
+  const obj = input;
+  if (typeof obj.workflow_id !== "string" || !WORKFLOW_ID_PATTERN.test(obj.workflow_id) || obj.workflow_id.length > WORKFLOW_LIMITS.maxWorkflowIdLength) {
+    return {
+      valid: false,
+      error_code: "E_WORKFLOW_ID_INVALID",
+      error: "Invalid workflow ID format"
+    };
+  }
+  if (typeof obj.step_id !== "string" || !STEP_ID_PATTERN.test(obj.step_id) || obj.step_id.length > WORKFLOW_LIMITS.maxStepIdLength) {
+    return {
+      valid: false,
+      error_code: "E_WORKFLOW_STEP_ID_INVALID",
+      error: "Invalid step ID format"
+    };
+  }
+  const parentStepIds = obj.parent_step_ids;
+  if (Array.isArray(parentStepIds) && parentStepIds.length > WORKFLOW_LIMITS.maxParentSteps) {
+    return {
+      valid: false,
+      error_code: "E_WORKFLOW_LIMIT_EXCEEDED",
+      error: "Exceeds maximum parent steps"
+    };
+  }
+  if (obj.framework !== void 0) {
+    if (typeof obj.framework !== "string" || !FRAMEWORK_ID_PATTERN.test(obj.framework) || obj.framework.length > WORKFLOW_LIMITS.maxFrameworkLength) {
+      return {
+        valid: false,
+        error_code: "E_WORKFLOW_CONTEXT_INVALID",
+        error: "Invalid framework identifier grammar"
+      };
+    }
+  }
+  if (obj.prev_receipt_hash !== void 0) {
+    if (typeof obj.prev_receipt_hash !== "string" || !/^sha256:[a-f0-9]{64}$/.test(obj.prev_receipt_hash)) {
+      return {
+        valid: false,
+        error_code: "E_WORKFLOW_CONTEXT_INVALID",
+        error: "Invalid hash format"
+      };
+    }
+  }
+  if (Array.isArray(parentStepIds)) {
+    if (parentStepIds.includes(obj.step_id)) {
+      return {
+        valid: false,
+        error_code: "E_WORKFLOW_DAG_INVALID",
+        error: "Self-parent cycle detected"
+      };
+    }
+    const uniqueParents = new Set(parentStepIds);
+    if (uniqueParents.size !== parentStepIds.length) {
+      return {
+        valid: false,
+        error_code: "E_WORKFLOW_DAG_INVALID",
+        error: "Duplicate parent step IDs"
+      };
+    }
+  }
+  const result = WorkflowContextSchema.safeParse(input);
+  if (!result.success) {
+    return {
+      valid: false,
+      error_code: "E_WORKFLOW_CONTEXT_INVALID",
+      error: result.error.issues[0]?.message || "Schema validation failed"
+    };
+  }
+  return { valid: true, value: result.data };
+}
+function createWorkflowId(id) {
+  const workflowId = `wf_${id}`;
+  return WorkflowIdSchema.parse(workflowId);
+}
+function createStepId(id) {
+  const stepId = `step_${id}`;
+  return StepIdSchema.parse(stepId);
+}
+function validateWorkflowContext(context) {
+  return WorkflowContextSchema.parse(context);
+}
+function isValidWorkflowContext(context) {
+  return WorkflowContextSchema.safeParse(context).success;
+}
+function validateWorkflowSummaryAttestation(attestation) {
+  return WorkflowSummaryAttestationSchema.parse(attestation);
+}
+function isWorkflowSummaryAttestation(attestation) {
+  return WorkflowSummaryAttestationSchema.safeParse(attestation).success;
+}
+function isTerminalWorkflowStatus(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+function hasValidDagSemantics(context) {
+  if (context.parent_step_ids.includes(context.step_id)) {
+    return false;
+  }
+  const uniqueParents = new Set(context.parent_step_ids);
+  if (uniqueParents.size !== context.parent_step_ids.length) {
+    return false;
+  }
+  return true;
+}
+function createWorkflowContext(params) {
+  const context = {
+    workflow_id: params.workflow_id,
+    step_id: params.step_id,
+    parent_step_ids: params.parent_step_ids ?? [],
+    ...params.orchestrator_id && { orchestrator_id: params.orchestrator_id },
+    ...params.orchestrator_receipt_ref && {
+      orchestrator_receipt_ref: params.orchestrator_receipt_ref
+    },
+    ...params.step_index !== void 0 && { step_index: params.step_index },
+    ...params.step_total !== void 0 && { step_total: params.step_total },
+    ...params.tool_name && { tool_name: params.tool_name },
+    ...params.framework && { framework: params.framework },
+    ...params.prev_receipt_hash && { prev_receipt_hash: params.prev_receipt_hash }
+  };
+  const validated = validateWorkflowContext(context);
+  if (!hasValidDagSemantics(validated)) {
+    throw new Error(
+      "Invalid DAG semantics: step cannot be its own parent or have duplicate parents"
+    );
+  }
+  return validated;
+}
+function createWorkflowSummaryAttestation(params) {
+  const attestation = {
+    type: WORKFLOW_SUMMARY_TYPE,
+    issuer: params.issuer,
+    issued_at: params.issued_at,
+    ...params.expires_at && { expires_at: params.expires_at },
+    evidence: {
+      workflow_id: params.workflow_id,
+      status: params.status,
+      started_at: params.started_at,
+      ...params.completed_at && { completed_at: params.completed_at },
+      ...params.receipt_refs && { receipt_refs: params.receipt_refs },
+      ...params.receipt_merkle_root && { receipt_merkle_root: params.receipt_merkle_root },
+      ...params.receipt_count !== void 0 && { receipt_count: params.receipt_count },
+      orchestrator_id: params.orchestrator_id,
+      agents_involved: params.agents_involved,
+      ...params.final_result_hash && { final_result_hash: params.final_result_hash },
+      ...params.error_context && { error_context: params.error_context }
+    }
+  };
+  return validateWorkflowSummaryAttestation(attestation);
+}
+var INTERACTION_EXTENSION_KEY = "org.peacprotocol/interaction@0.1";
+var CANONICAL_DIGEST_ALGS = [
+  "sha-256",
+  // Full SHA-256
+  "sha-256:trunc-64k",
+  // First 64KB (65536 bytes)
+  "sha-256:trunc-1m"
+  // First 1MB (1048576 bytes)
+];
+var DIGEST_SIZE_CONSTANTS = {
+  k: 1024,
+  // 1 KB = 1024 bytes (binary)
+  m: 1024 * 1024,
+  // 1 MB = 1048576 bytes (binary)
+  "trunc-64k": 65536,
+  // 64 * 1024
+  "trunc-1m": 1048576
+  // 1024 * 1024
+};
+var RESULT_STATUSES = ["ok", "error", "timeout", "canceled"];
+var REDACTION_MODES = ["hash_only", "redacted", "plaintext_allowlisted"];
+var POLICY_DECISIONS = ["allow", "deny", "constrained"];
+var WELL_KNOWN_KINDS = [
+  "tool.call",
+  "http.request",
+  "fs.read",
+  "fs.write",
+  "message"
+];
+var RESERVED_KIND_PREFIXES = ["peac.", "org.peacprotocol."];
+var INTERACTION_LIMITS = {
+  /** Maximum interaction ID length */
+  maxInteractionIdLength: 256,
+  /** Maximum kind length */
+  maxKindLength: 128,
+  /** Maximum platform name length */
+  maxPlatformLength: 64,
+  /** Maximum version string length */
+  maxVersionLength: 64,
+  /** Maximum plugin ID length */
+  maxPluginIdLength: 128,
+  /** Maximum tool name length */
+  maxToolNameLength: 256,
+  /** Maximum provider length */
+  maxProviderLength: 128,
+  /** Maximum URI length */
+  maxUriLength: 2048,
+  /** Maximum method length */
+  maxMethodLength: 16,
+  /** Maximum error code length */
+  maxErrorCodeLength: 128,
+  /** Maximum payment reference length */
+  maxPaymentReferenceLength: 256,
+  /** Maximum receipt RID length */
+  maxReceiptRidLength: 128
+};
+function requiresTool(kind) {
+  return kind.startsWith("tool.");
+}
+function requiresResource(kind) {
+  return kind.startsWith("http.") || kind.startsWith("fs.");
+}
+function usesReservedPrefix(kind) {
+  return RESERVED_KIND_PREFIXES.some((prefix) => kind.startsWith(prefix));
+}
+function hasMeaningfulResource(resource) {
+  if (!resource) return false;
+  if (typeof resource.uri === "string" && resource.uri.length > 0) return true;
+  return false;
+}
+var KIND_FORMAT_PATTERN = /^[a-z][a-z0-9._:-]{0,126}[a-z0-9]$/;
+var EXTENSION_KEY_PATTERN = /^([a-z0-9-]+\.)+[a-z0-9-]+\/[a-z][a-z0-9._:-]{0,126}[a-z0-9](?:@[0-9]+(?:\.[0-9]+)*)?$/;
+var DIGEST_VALUE_PATTERN = /^[a-f0-9]{64}$/;
+var DigestAlgSchema = z.enum(CANONICAL_DIGEST_ALGS);
+var DigestSchema = z.object({
+  /** Algorithm: 'sha-256' (full) or 'sha-256:trunc-{size}' (truncated) */
+  alg: DigestAlgSchema,
+  /** 64 lowercase hex chars (SHA-256 output) */
+  value: z.string().regex(DIGEST_VALUE_PATTERN, "Must be 64 lowercase hex chars"),
+  /** Original byte length before any truncation (REQUIRED) */
+  bytes: z.number().int().nonnegative()
+}).strict();
+var PayloadRefSchema = z.object({
+  /** Content digest */
+  digest: DigestSchema,
+  /** Redaction mode */
+  redaction: z.enum(REDACTION_MODES)
+}).strict();
+var ExecutorSchema = z.object({
+  /** Platform identifier: 'openclaw', 'mcp', 'a2a', 'claude-code' */
+  platform: z.string().min(1).max(INTERACTION_LIMITS.maxPlatformLength),
+  /** Platform version */
+  version: z.string().max(INTERACTION_LIMITS.maxVersionLength).optional(),
+  /** Plugin that captured this */
+  plugin_id: z.string().max(INTERACTION_LIMITS.maxPluginIdLength).optional(),
+  /** Hash of plugin package (provenance) */
+  plugin_digest: DigestSchema.optional()
+}).strict();
+var ToolTargetSchema = z.object({
+  /** Tool name */
+  name: z.string().min(1).max(INTERACTION_LIMITS.maxToolNameLength),
+  /** Tool provider */
+  provider: z.string().max(INTERACTION_LIMITS.maxProviderLength).optional(),
+  /** Tool version */
+  version: z.string().max(INTERACTION_LIMITS.maxVersionLength).optional()
+}).strict();
+var ResourceTargetSchema = z.object({
+  /** Resource URI */
+  uri: z.string().max(INTERACTION_LIMITS.maxUriLength).optional(),
+  /** HTTP method or operation */
+  method: z.string().max(INTERACTION_LIMITS.maxMethodLength).optional()
+}).strict();
+var ResultSchema = z.object({
+  /** Result status */
+  status: z.enum(RESULT_STATUSES),
+  /** Error code (PEAC error code or namespaced) */
+  error_code: z.string().max(INTERACTION_LIMITS.maxErrorCodeLength).optional(),
+  /** Whether the operation can be retried */
+  retryable: z.boolean().optional()
+}).strict();
+var PolicyContextSchema = z.object({
+  /** Policy decision */
+  decision: z.enum(POLICY_DECISIONS),
+  /** Whether sandbox mode was enabled */
+  sandbox_enabled: z.boolean().optional(),
+  /** Whether elevated permissions were granted */
+  elevated: z.boolean().optional(),
+  /** Hash of effective policy document */
+  effective_policy_digest: DigestSchema.optional()
+}).strict();
+var RefsSchema = z.object({
+  /** Links to evidence.payment.reference */
+  payment_reference: z.string().max(INTERACTION_LIMITS.maxPaymentReferenceLength).optional(),
+  /** Correlation across receipts */
+  related_receipt_rid: z.string().max(INTERACTION_LIMITS.maxReceiptRidLength).optional()
+}).strict();
+var KindSchema = z.string().min(2).max(INTERACTION_LIMITS.maxKindLength).regex(KIND_FORMAT_PATTERN, "Invalid kind format");
+var InteractionEvidenceV01BaseSchema = z.object({
+  /** Stable ID for idempotency/dedupe (REQUIRED) */
+  interaction_id: z.string().min(1).max(INTERACTION_LIMITS.maxInteractionIdLength),
+  /** Event kind - open string, not closed enum (REQUIRED) */
+  kind: KindSchema,
+  /** Executor identity (REQUIRED) */
+  executor: ExecutorSchema,
+  /** Tool target (when kind is tool-related) */
+  tool: ToolTargetSchema.optional(),
+  /** Resource target (when kind is http/fs-related) */
+  resource: ResourceTargetSchema.optional(),
+  /** Input payload reference */
+  input: PayloadRefSchema.optional(),
+  /** Output payload reference */
+  output: PayloadRefSchema.optional(),
+  /** Start time (RFC 3339) (REQUIRED) */
+  started_at: z.string().datetime(),
+  /** Completion time (RFC 3339) */
+  completed_at: z.string().datetime().optional(),
+  /** Duration in milliseconds (OPTIONAL, non-normative) */
+  duration_ms: z.number().int().nonnegative().optional(),
+  /** Execution outcome */
+  result: ResultSchema.optional(),
+  /** Policy context at execution */
+  policy: PolicyContextSchema.optional(),
+  /** References to related evidence */
+  refs: RefsSchema.optional(),
+  /** Platform-specific extensions (MUST be namespaced) */
+  extensions: z.record(z.unknown()).optional()
+}).strict();
+var InteractionEvidenceV01Schema = InteractionEvidenceV01BaseSchema.superRefine(
+  (ev, ctx) => {
+    if (ev.completed_at && ev.started_at) {
+      const startedAt = new Date(ev.started_at).getTime();
+      const completedAt = new Date(ev.completed_at).getTime();
+      if (completedAt < startedAt) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "completed_at must be >= started_at",
+          path: ["completed_at"]
+        });
+      }
+    }
+    if (ev.output && !ev.result?.status) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "result.status is required when output is present",
+        path: ["result"]
+      });
+    }
+    if (ev.result?.status === "error") {
+      const hasErrorCode = Boolean(ev.result.error_code);
+      const hasNonEmptyExtensions = ev.extensions !== void 0 && Object.keys(ev.extensions).length > 0;
+      if (!hasErrorCode && !hasNonEmptyExtensions) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "error_code or non-empty extensions required when status is error",
+          path: ["result", "error_code"]
+        });
+      }
+    }
+    if (ev.extensions) {
+      for (const key of Object.keys(ev.extensions)) {
+        if (!EXTENSION_KEY_PATTERN.test(key)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Invalid extension key format: ${key} (must be reverse-DNS/name[@version])`,
+            path: ["extensions", key]
+          });
+        }
+      }
+    }
+    if (usesReservedPrefix(ev.kind) && !WELL_KNOWN_KINDS.includes(ev.kind)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `kind "${ev.kind}" uses reserved prefix`,
+        path: ["kind"]
+      });
+    }
+    if (requiresTool(ev.kind) && !ev.tool) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `kind "${ev.kind}" requires tool field`,
+        path: ["tool"]
+      });
+    }
+    if (requiresResource(ev.kind)) {
+      if (!ev.resource) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `kind "${ev.kind}" requires resource field`,
+          path: ["resource"]
+        });
+      } else if (!hasMeaningfulResource(ev.resource)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `kind "${ev.kind}" requires resource.uri to be non-empty`,
+          path: ["resource", "uri"]
+        });
+      }
+    }
+  }
+);
+function validateInteractionOrdered(input) {
+  const errors = [];
+  const warnings = [];
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          code: "E_INTERACTION_INVALID_FORMAT",
+          message: "Input must be an object"
+        }
+      ],
+      warnings: []
+    };
+  }
+  const obj = input;
+  if (typeof obj.interaction_id !== "string" || obj.interaction_id.length === 0) {
+    errors.push({
+      code: "E_INTERACTION_MISSING_ID",
+      message: "interaction_id is required",
+      field: "interaction_id"
+    });
+  } else if (obj.interaction_id.length > INTERACTION_LIMITS.maxInteractionIdLength) {
+    errors.push({
+      code: "E_INTERACTION_INVALID_FORMAT",
+      message: `interaction_id exceeds max length (${INTERACTION_LIMITS.maxInteractionIdLength})`,
+      field: "interaction_id"
+    });
+  }
+  if (typeof obj.kind !== "string" || obj.kind.length === 0) {
+    errors.push({
+      code: "E_INTERACTION_MISSING_KIND",
+      message: "kind is required",
+      field: "kind"
+    });
+  } else if (obj.kind.length < 2 || obj.kind.length > INTERACTION_LIMITS.maxKindLength) {
+    errors.push({
+      code: "E_INTERACTION_INVALID_KIND_FORMAT",
+      message: `kind must be 2-${INTERACTION_LIMITS.maxKindLength} characters`,
+      field: "kind"
+    });
+  } else if (!KIND_FORMAT_PATTERN.test(obj.kind)) {
+    errors.push({
+      code: "E_INTERACTION_INVALID_KIND_FORMAT",
+      message: "kind must match pattern: lowercase, start with letter, end with alphanumeric",
+      field: "kind"
+    });
+  } else {
+    for (const prefix of RESERVED_KIND_PREFIXES) {
+      if (obj.kind.startsWith(prefix) && !WELL_KNOWN_KINDS.includes(obj.kind)) {
+        errors.push({
+          code: "E_INTERACTION_KIND_RESERVED",
+          message: `kind "${obj.kind}" uses reserved prefix "${prefix}"`,
+          field: "kind"
+        });
+        break;
+      }
+    }
+    if (errors.length === 0 && !WELL_KNOWN_KINDS.includes(obj.kind)) {
+      warnings.push({
+        code: "W_INTERACTION_KIND_UNREGISTERED",
+        message: `kind "${obj.kind}" is not in the well-known registry`,
+        field: "kind"
+      });
+    }
+  }
+  if (typeof obj.started_at !== "string") {
+    errors.push({
+      code: "E_INTERACTION_MISSING_STARTED_AT",
+      message: "started_at is required",
+      field: "started_at"
+    });
+  } else {
+    const startedAtDate = new Date(obj.started_at);
+    if (isNaN(startedAtDate.getTime())) {
+      errors.push({
+        code: "E_INTERACTION_MISSING_STARTED_AT",
+        message: "started_at must be a valid ISO 8601 datetime",
+        field: "started_at"
+      });
+    }
+  }
+  if (typeof obj.executor !== "object" || obj.executor === null) {
+    errors.push({
+      code: "E_INTERACTION_MISSING_EXECUTOR",
+      message: "executor is required",
+      field: "executor"
+    });
+  } else {
+    const executor = obj.executor;
+    if (typeof executor.platform !== "string" || executor.platform.length === 0) {
+      errors.push({
+        code: "E_INTERACTION_MISSING_EXECUTOR",
+        message: "executor.platform is required",
+        field: "executor.platform"
+      });
+    } else if (executor.platform.length > INTERACTION_LIMITS.maxPlatformLength) {
+      errors.push({
+        code: "E_INTERACTION_INVALID_FORMAT",
+        message: `executor.platform exceeds max length (${INTERACTION_LIMITS.maxPlatformLength})`,
+        field: "executor.platform"
+      });
+    }
+  }
+  if (errors.length > 0) {
+    return { valid: false, errors, warnings };
+  }
+  const validateDigest = (digest, fieldPath) => {
+    const digestErrors = [];
+    if (typeof digest !== "object" || digest === null) {
+      digestErrors.push({
+        code: "E_INTERACTION_INVALID_DIGEST",
+        message: "digest must be an object",
+        field: fieldPath
+      });
+      return { errors: digestErrors, valid: false };
+    }
+    const d = digest;
+    if (!CANONICAL_DIGEST_ALGS.includes(d.alg)) {
+      digestErrors.push({
+        code: "E_INTERACTION_INVALID_DIGEST_ALG",
+        message: `digest.alg must be one of: ${CANONICAL_DIGEST_ALGS.join(", ")}`,
+        field: `${fieldPath}.alg`
+      });
+    }
+    if (typeof d.value !== "string" || !DIGEST_VALUE_PATTERN.test(d.value)) {
+      digestErrors.push({
+        code: "E_INTERACTION_INVALID_DIGEST",
+        message: "digest.value must be 64 lowercase hex chars",
+        field: `${fieldPath}.value`
+      });
+    }
+    if (typeof d.bytes !== "number" || !Number.isInteger(d.bytes) || d.bytes < 0) {
+      digestErrors.push({
+        code: "E_INTERACTION_INVALID_DIGEST",
+        message: "digest.bytes must be a non-negative integer",
+        field: `${fieldPath}.bytes`
+      });
+    }
+    return { errors: digestErrors, valid: digestErrors.length === 0 };
+  };
+  if (obj.input !== void 0) {
+    const inputObj = obj.input;
+    if (inputObj.digest !== void 0) {
+      const result = validateDigest(inputObj.digest, "input.digest");
+      errors.push(...result.errors);
+    }
+  }
+  if (obj.output !== void 0) {
+    const outputObj = obj.output;
+    if (outputObj.digest !== void 0) {
+      const result = validateDigest(outputObj.digest, "output.digest");
+      errors.push(...result.errors);
+    }
+  }
+  if (typeof obj.completed_at === "string" && typeof obj.started_at === "string") {
+    const startedAt = new Date(obj.started_at).getTime();
+    const completedAt = new Date(obj.completed_at).getTime();
+    if (!isNaN(startedAt) && !isNaN(completedAt) && completedAt < startedAt) {
+      errors.push({
+        code: "E_INTERACTION_INVALID_TIMING",
+        message: "completed_at must be >= started_at",
+        field: "completed_at"
+      });
+    }
+  }
+  if (obj.output !== void 0) {
+    const result = obj.result;
+    if (!result?.status) {
+      errors.push({
+        code: "E_INTERACTION_MISSING_RESULT",
+        message: "result.status is required when output is present",
+        field: "result"
+      });
+    }
+  }
+  if (obj.result !== void 0) {
+    const result = obj.result;
+    if (result.status === "error") {
+      const hasErrorCode = Boolean(result.error_code);
+      const hasNonEmptyExtensions = obj.extensions !== void 0 && typeof obj.extensions === "object" && obj.extensions !== null && Object.keys(obj.extensions).length > 0;
+      if (!hasErrorCode && !hasNonEmptyExtensions) {
+        errors.push({
+          code: "E_INTERACTION_MISSING_ERROR_DETAIL",
+          message: "error_code or non-empty extensions required when result.status is error",
+          field: "result.error_code"
+        });
+      }
+    }
+  }
+  if (obj.extensions !== void 0) {
+    if (typeof obj.extensions !== "object" || obj.extensions === null) {
+      errors.push({
+        code: "E_INTERACTION_INVALID_FORMAT",
+        message: "extensions must be an object",
+        field: "extensions"
+      });
+    } else {
+      for (const key of Object.keys(obj.extensions)) {
+        if (!EXTENSION_KEY_PATTERN.test(key)) {
+          errors.push({
+            code: "E_INTERACTION_INVALID_EXTENSION_KEY",
+            message: `Invalid extension key format: "${key}" (must be reverse-DNS/name[@version])`,
+            field: `extensions.${key}`
+          });
+        }
+      }
+    }
+  }
+  const kind = obj.kind;
+  const hasTool = obj.tool !== void 0;
+  const hasResource = obj.resource !== void 0;
+  if (requiresTool(kind) && !hasTool) {
+    errors.push({
+      code: "E_INTERACTION_MISSING_TARGET",
+      message: `kind "${kind}" requires tool field`,
+      field: "tool"
+    });
+  }
+  if (requiresResource(kind)) {
+    if (!hasResource) {
+      errors.push({
+        code: "E_INTERACTION_MISSING_TARGET",
+        message: `kind "${kind}" requires resource field`,
+        field: "resource"
+      });
+    } else if (!hasMeaningfulResource(obj.resource)) {
+      errors.push({
+        code: "E_INTERACTION_MISSING_TARGET",
+        message: `kind "${kind}" requires resource.uri to be non-empty`,
+        field: "resource.uri"
+      });
+    }
+  }
+  if (!hasTool && !hasResource && errors.length === 0) {
+    warnings.push({
+      code: "W_INTERACTION_MISSING_TARGET",
+      message: "Neither tool nor resource field is present",
+      field: "tool"
+    });
+  }
+  if (errors.length > 0) {
+    return { valid: false, errors, warnings };
+  }
+  const zodResult = InteractionEvidenceV01Schema.safeParse(input);
+  if (!zodResult.success) {
+    return {
+      valid: false,
+      errors: [
+        {
+          code: "E_INTERACTION_INVALID_FORMAT",
+          message: zodResult.error.issues[0]?.message || "Schema validation failed",
+          field: zodResult.error.issues[0]?.path.join(".")
+        }
+      ],
+      warnings
+    };
+  }
+  return { valid: true, value: zodResult.data, warnings };
+}
+function validateInteraction(input) {
+  const result = validateInteractionOrdered(input);
+  if (result.valid) {
+    return { valid: true };
+  }
+  const firstError = result.errors[0];
+  return {
+    valid: false,
+    error_code: firstError?.code,
+    error_field: firstError?.field
+  };
+}
+function validateInteractionEvidence(evidence) {
+  return InteractionEvidenceV01Schema.parse(evidence);
+}
+function isValidInteractionEvidence(evidence) {
+  return InteractionEvidenceV01Schema.safeParse(evidence).success;
+}
+function isWellKnownKind(kind) {
+  return WELL_KNOWN_KINDS.includes(kind);
+}
+function isReservedKindPrefix(kind) {
+  return RESERVED_KIND_PREFIXES.some((prefix) => kind.startsWith(prefix));
+}
+function isDigestTruncated(digest) {
+  return digest.alg.startsWith("sha-256:trunc-");
+}
+function getInteraction(receipt) {
+  return receipt.evidence?.extensions?.[INTERACTION_EXTENSION_KEY];
+}
+function setInteraction(receipt, interaction) {
+  if (!receipt.evidence) {
+    receipt.evidence = {};
+  }
+  if (!receipt.evidence.extensions) {
+    receipt.evidence.extensions = {};
+  }
+  receipt.evidence.extensions[INTERACTION_EXTENSION_KEY] = interaction;
+}
+function hasInteraction(receipt) {
+  return receipt.evidence?.extensions?.[INTERACTION_EXTENSION_KEY] !== void 0;
+}
+function createReceiptView(envelope) {
+  const interaction = getInteraction(envelope);
+  const workflow = envelope.auth?.extensions?.["org.peacprotocol/workflow"];
+  return {
+    envelope,
+    interaction,
+    interactions: interaction ? [interaction] : [],
+    workflow
+  };
+}
+function createInteractionEvidence(params) {
+  const evidence = {
+    interaction_id: params.interaction_id,
+    kind: params.kind,
+    executor: {
+      platform: params.executor.platform,
+      ...params.executor.version && { version: params.executor.version },
+      ...params.executor.plugin_id && { plugin_id: params.executor.plugin_id },
+      ...params.executor.plugin_digest && { plugin_digest: params.executor.plugin_digest }
+    },
+    ...params.tool && { tool: params.tool },
+    ...params.resource && { resource: params.resource },
+    ...params.input && { input: params.input },
+    ...params.output && { output: params.output },
+    started_at: params.started_at,
+    ...params.completed_at && { completed_at: params.completed_at },
+    ...params.duration_ms !== void 0 && { duration_ms: params.duration_ms },
+    ...params.result && { result: params.result },
+    ...params.policy && { policy: params.policy },
+    ...params.refs && { refs: params.refs },
+    ...params.extensions && { extensions: params.extensions }
+  };
+  return validateInteractionEvidence(evidence);
+}
+var CreditMethodSchema = z.enum(["inline", "references", "model-card"]);
+var CREDIT_METHODS = ["inline", "references", "model-card"];
+var ContributionTypeSchema = z.enum(["direct", "ecosystem", "open"]);
+var CONTRIBUTION_TYPES = ["direct", "ecosystem", "open"];
+var CreditObligationSchema = z.object({
+  /** Whether credit is required (REQUIRED) */
+  required: z.boolean(),
+  /** URL for citation/attribution (OPTIONAL) */
+  citation_url: z.string().url().max(2048).optional(),
+  /** How credit should be provided (OPTIONAL, defaults to implementation choice) */
+  method: CreditMethodSchema.optional(),
+  /** Human-readable credit text template (OPTIONAL) */
+  credit_text: z.string().max(1024).optional()
+}).strict().superRefine((data, ctx) => {
+  if (data.required && !data.citation_url && !data.credit_text && !data.method) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "When credit is required, at least one of citation_url, credit_text, or method must be specified",
+      path: ["required"]
+    });
+  }
+});
+var ContributionObligationSchema = z.object({
+  /** Type of contribution (REQUIRED) */
+  type: ContributionTypeSchema,
+  /** Destination for contributions (OPTIONAL, e.g., fund URL, wallet address) */
+  destination: z.string().max(2048).optional(),
+  /** Minimum contribution amount in minor units (OPTIONAL) */
+  min_amount: z.number().int().min(0).optional(),
+  /** Currency for min_amount (OPTIONAL, ISO 4217 or crypto symbol like USDC) */
+  currency: z.string().min(3).max(8).regex(/^[A-Z0-9]{3,8}$/).optional()
+}).strict().superRefine((data, ctx) => {
+  if ((data.type === "direct" || data.type === "ecosystem") && !data.destination) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `Destination is required when contribution type is '${data.type}'`,
+      path: ["destination"]
+    });
+  }
+  if (data.min_amount !== void 0 && !data.currency) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Currency is required when min_amount is specified",
+      path: ["currency"]
+    });
+  }
+});
+var OBLIGATIONS_EXTENSION_KEY = "peac/obligations";
+var ObligationsExtensionSchema = z.object({
+  /** Credit/attribution obligations (OPTIONAL) */
+  credit: CreditObligationSchema.optional(),
+  /** Contribution/payment model (OPTIONAL) */
+  contribution: ContributionObligationSchema.optional()
+}).strict();
+function validateCreditObligation(data) {
+  const result = CreditObligationSchema.safeParse(data);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  return { ok: false, error: result.error.message };
+}
+function validateContributionObligation(data) {
+  const result = ContributionObligationSchema.safeParse(data);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  return { ok: false, error: result.error.message };
+}
+function validateObligationsExtension(data) {
+  const result = ObligationsExtensionSchema.safeParse(data);
+  if (result.success) {
+    return { ok: true, value: result.data };
+  }
+  return { ok: false, error: result.error.message };
+}
+function extractObligationsExtension(extensions) {
+  if (!extensions || !(OBLIGATIONS_EXTENSION_KEY in extensions)) {
+    return void 0;
+  }
+  const result = validateObligationsExtension(extensions[OBLIGATIONS_EXTENSION_KEY]);
+  if (result.ok) {
+    return result.value;
+  }
+  return void 0;
+}
+function isCreditRequired(obligations) {
+  return obligations?.credit?.required === true;
+}
+function isContributionRequired(obligations) {
+  const type = obligations?.contribution?.type;
+  return type === "direct" || type === "ecosystem";
+}
+function createCreditObligation(params) {
+  const credit = { required: params.required };
+  if (params.citation_url) credit.citation_url = params.citation_url;
+  if (params.method) credit.method = params.method;
+  if (params.credit_text) credit.credit_text = params.credit_text;
+  return { credit };
+}
+function createContributionObligation(params) {
+  const contribution = { type: params.type };
+  if (params.destination) contribution.destination = params.destination;
+  if (params.min_amount !== void 0) contribution.min_amount = params.min_amount;
+  if (params.currency) contribution.currency = params.currency;
+  return { contribution };
+}
+function createObligationsExtension(credit, contribution) {
+  const result = {};
+  if (credit) {
+    result.credit = { required: credit.required };
+    if (credit.citation_url) result.credit.citation_url = credit.citation_url;
+    if (credit.method) result.credit.method = credit.method;
+    if (credit.credit_text) result.credit.credit_text = credit.credit_text;
+  }
+  if (contribution) {
+    result.contribution = { type: contribution.type };
+    if (contribution.destination) result.contribution.destination = contribution.destination;
+    if (contribution.min_amount !== void 0)
+      result.contribution.min_amount = contribution.min_amount;
+    if (contribution.currency) result.contribution.currency = contribution.currency;
+  }
+  return result;
+}
+var ATTESTATION_RECEIPT_TYPE = "peac/attestation-receipt";
+var MIDDLEWARE_INTERACTION_KEY = "org.peacprotocol/middleware-interaction@0.1";
+var ATTESTATION_LIMITS = {
+  /** Maximum issuer URL length */
+  maxIssuerLength: 2048,
+  /** Maximum audience URL length */
+  maxAudienceLength: 2048,
+  /** Maximum subject length */
+  maxSubjectLength: 256,
+  /** Maximum path length in interaction binding */
+  maxPathLength: 2048,
+  /** Maximum method length */
+  maxMethodLength: 16,
+  /** Maximum HTTP status code */
+  maxStatusCode: 599,
+  /** Minimum HTTP status code */
+  minStatusCode: 100
+};
+var httpsUrl2 = z.string().url().max(ATTESTATION_LIMITS.maxIssuerLength).refine((url) => url.startsWith("https://"), "Must be HTTPS URL");
+var uuidv72 = z.string().regex(
+  /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  "Must be UUIDv7 format"
+);
+var MinimalInteractionBindingSchema = z.object({
+  /** HTTP method (uppercase, e.g., GET, POST) */
+  method: z.string().min(1).max(ATTESTATION_LIMITS.maxMethodLength).transform((m) => m.toUpperCase()),
+  /** Request path (no query string by default) */
+  path: z.string().min(1).max(ATTESTATION_LIMITS.maxPathLength),
+  /** HTTP response status code */
+  status: z.number().int().min(ATTESTATION_LIMITS.minStatusCode).max(ATTESTATION_LIMITS.maxStatusCode)
+}).strict();
+var AttestationExtensionsSchema = z.record(z.string(), z.unknown());
+var AttestationReceiptClaimsSchema = z.object({
+  /** Issuer URL (normalized, no trailing slash) */
+  iss: httpsUrl2,
+  /** Audience URL */
+  aud: httpsUrl2,
+  /** Issued at (Unix seconds) */
+  iat: z.number().int().nonnegative(),
+  /** Expiration (Unix seconds) */
+  exp: z.number().int().nonnegative(),
+  /** Receipt ID (UUIDv7) */
+  rid: uuidv72,
+  /** Subject identifier (optional) */
+  sub: z.string().max(ATTESTATION_LIMITS.maxSubjectLength).optional(),
+  /** Extensions (optional) */
+  ext: AttestationExtensionsSchema.optional()
+}).strict();
+function validateAttestationReceiptClaims(input) {
+  const result = AttestationReceiptClaimsSchema.safeParse(input);
+  if (result.success) {
+    return { valid: true };
+  }
+  const firstIssue = result.error.issues[0];
+  return {
+    valid: false,
+    error_code: "E_ATTESTATION_INVALID_CLAIMS",
+    error_message: firstIssue?.message || "Invalid attestation receipt claims"
+  };
+}
+function isAttestationReceiptClaims(claims) {
+  return AttestationReceiptClaimsSchema.safeParse(claims).success;
+}
+function validateMinimalInteractionBinding(input) {
+  const result = MinimalInteractionBindingSchema.safeParse(input);
+  if (result.success) {
+    return { valid: true };
+  }
+  const firstIssue = result.error.issues[0];
+  return {
+    valid: false,
+    error_code: "E_ATTESTATION_INVALID_INTERACTION",
+    error_message: firstIssue?.message || "Invalid interaction binding"
+  };
+}
+function isMinimalInteractionBinding(binding) {
+  return MinimalInteractionBindingSchema.safeParse(binding).success;
+}
+function createAttestationReceiptClaims(params) {
+  const now = Math.floor(Date.now() / 1e3);
+  const expiresIn = params.expiresIn ?? 300;
+  let normalizedIssuer = params.issuer;
+  while (normalizedIssuer.endsWith("/")) {
+    normalizedIssuer = normalizedIssuer.slice(0, -1);
+  }
+  const ext = { ...params.extensions };
+  if (params.interaction) {
+    ext[MIDDLEWARE_INTERACTION_KEY] = params.interaction;
+  }
+  const claims = {
+    iss: normalizedIssuer,
+    aud: params.audience,
+    iat: now,
+    exp: now + expiresIn,
+    rid: params.rid,
+    ...params.sub && { sub: params.sub },
+    ...Object.keys(ext).length > 0 && { ext }
+  };
+  return AttestationReceiptClaimsSchema.parse(claims);
+}
+function isAttestationOnly(claims) {
+  return !("amt" in claims) && !("cur" in claims) && !("payment" in claims);
+}
+function isPaymentReceipt(claims) {
+  return "amt" in claims && "cur" in claims && "payment" in claims;
+}
+
+// src/receipt-parser.ts
+function classifyReceipt(obj) {
+  if ("amt" in obj || "cur" in obj || "payment" in obj) {
+    return "commerce";
+  }
+  return "attestation";
+}
+function parseReceiptClaims(input, _opts) {
+  if (input === null || input === void 0 || typeof input !== "object" || Array.isArray(input)) {
+    return {
+      ok: false,
+      error: {
+        code: "E_PARSE_INVALID_INPUT",
+        message: "Input must be a non-null object"
+      }
+    };
+  }
+  const obj = input;
+  const variant = classifyReceipt(obj);
+  if (variant === "commerce") {
+    const result2 = ReceiptClaimsSchema.safeParse(obj);
+    if (!result2.success) {
+      return {
+        ok: false,
+        error: {
+          code: "E_PARSE_COMMERCE_INVALID",
+          message: `Commerce receipt validation failed: ${result2.error.issues.map((i) => i.message).join("; ")}`,
+          issues: result2.error.issues
+        }
+      };
+    }
+    return {
+      ok: true,
+      variant: "commerce",
+      claims: result2.data
+    };
+  }
+  const result = AttestationReceiptClaimsSchema.safeParse(obj);
+  if (!result.success) {
+    return {
+      ok: false,
+      error: {
+        code: "E_PARSE_ATTESTATION_INVALID",
+        message: `Attestation receipt validation failed: ${result.error.issues.map((i) => i.message).join("; ")}`,
+        issues: result.error.issues
+      }
+    };
+  }
+  return {
+    ok: true,
+    variant: "attestation",
+    claims: result.data
+  };
+}
+
+export { AGENT_IDENTITY_TYPE, AIPREFSnapshot as AIPREFSnapshotSchema, ATTESTATION_LIMITS, ATTESTATION_RECEIPT_TYPE, ATTRIBUTION_LIMITS, ATTRIBUTION_TYPE, ATTRIBUTION_USAGES, AgentIdentityAttestationSchema, AgentIdentityEvidenceSchema, AgentIdentityVerifiedSchema, AgentProofSchema, AttestationExtensionsSchema, AttestationReceiptClaimsSchema, AttestationSchema, AttributionAttestationSchema, AttributionEvidenceSchema, AttributionSourceSchema, AttributionUsageSchema, BindingDetailsSchema, CANONICAL_DIGEST_ALGS, CANONICAL_PURPOSES, CONTRIBUTION_TYPES, CONTROL_TYPES, CREDIT_METHODS, CanonicalPurposeSchema, ContactMethodSchema, ContentHashSchema, ContributionObligationSchema, ContributionTypeSchema, ControlBlockSchema, ControlDecisionSchema, ControlLicensingModeSchema, ControlPurposeSchema, ControlStepSchema, ControlTypeSchema, CreditMethodSchema, CreditObligationSchema, DERIVATION_TYPES, DIGEST_SIZE_CONSTANTS, DIGEST_VALUE_PATTERN, DISPUTE_GROUNDS_CODES, DISPUTE_LIMITS, DISPUTE_OUTCOMES, DISPUTE_STATES, DISPUTE_TARGET_TYPES, DISPUTE_TRANSITIONS, DISPUTE_TYPE, DISPUTE_TYPES, DerivationTypeSchema, DigestAlgSchema, DigestSchema, DisputeAttestationSchema, DisputeContactSchema, DisputeEvidenceSchema, DisputeGroundsCodeSchema, DisputeGroundsSchema, DisputeIdSchema, DisputeOutcomeSchema, DisputeResolutionSchema, DisputeStateSchema, DisputeTargetTypeSchema, DisputeTypeSchema, DocumentRefSchema, ERROR_CATEGORIES_CANONICAL, ERROR_CODES, EXTENSION_KEY_PATTERN, ExecutorSchema, Extensions, ExtensionsSchema, HashAlgorithmSchema, HashEncodingSchema, INTERACTION_EXTENSION_KEY, INTERACTION_LIMITS, INTERNAL_PURPOSE_UNDECLARED, IdentityBindingSchema, InteractionEvidenceV01Schema, JSON_EVIDENCE_LIMITS, JWSHeader, JsonArraySchema, JsonObjectSchema, JsonPrimitiveSchema, JsonValueSchema, KIND_FORMAT_PATTERN, KindSchema, MAX_PURPOSE_TOKENS_PER_REQUEST, MAX_PURPOSE_TOKEN_LENGTH, MIDDLEWARE_INTERACTION_KEY, MinimalInteractionBindingSchema, NormalizedPayment, OBLIGATIONS_EXTENSION_KEY, ORCHESTRATION_FRAMEWORKS, ObligationsExtensionSchema, OrchestrationFrameworkSchema, PEAC_ALG, PEAC_DISCOVERY_MAX_BYTES, PEAC_DISCOVERY_PATH, PEAC_ISSUER_CONFIG_MAX_BYTES, PEAC_ISSUER_CONFIG_PATH, PEAC_ISSUER_CONFIG_VERSION, PEAC_POLICY_FALLBACK_PATH, PEAC_POLICY_MAX_BYTES, PEAC_POLICY_PATH, PEAC_PURPOSE_APPLIED_HEADER, PEAC_PURPOSE_HEADER, PEAC_PURPOSE_REASON_HEADER, PEAC_RECEIPT_HEADER, PEAC_RECEIPT_SCHEMA_URL, PEAC_WIRE_TYP, POLICY_DECISIONS, PROOF_METHODS, PURPOSE_REASONS, PURPOSE_TOKEN_REGEX, PayloadRefSchema, PaymentEvidenceSchema, PaymentRoutingSchema, PaymentSplitSchema, PolicyContextSchema, ProofMethodSchema, PurposeReasonSchema, PurposeTokenSchema, REDACTION_MODES, REMEDIATION_TYPES, RESERVED_KIND_PREFIXES, RESULT_STATUSES, ReceiptClaims, ReceiptClaimsSchema, RefsSchema, RemediationSchema, RemediationTypeSchema, ResourceTargetSchema, ResultSchema, STEP_ID_PATTERN, StepIdSchema, SubjectProfileSchema, SubjectProfileSnapshotSchema, Subject as SubjectSchema, SubjectTypeSchema, TERMINAL_STATES, ToolTargetSchema, VerifyRequest as VerifyRequestSchema, WELL_KNOWN_KINDS, WORKFLOW_EXTENSION_KEY, WORKFLOW_ID_PATTERN, WORKFLOW_LIMITS, WORKFLOW_STATUSES, WORKFLOW_SUMMARY_TYPE, WorkflowContextSchema, WorkflowErrorContextSchema, WorkflowIdSchema, WorkflowStatusSchema, WorkflowSummaryAttestationSchema, WorkflowSummaryEvidenceSchema, assertJsonSafeIterative, canTransitionTo, computeTotalWeight, createAgentIdentityAttestation, createAttestationReceiptClaims, createAttributionAttestation, createContributionObligation, createCreditObligation, createDisputeAttestation, createEvidenceNotJsonError, createInteractionEvidence, createObligationsExtension, createPEACError, createReceiptView, createStepId, createWorkflowContext, createWorkflowContextInvalidError, createWorkflowDagInvalidError, createWorkflowId, createWorkflowSummaryAttestation, deriveKnownPurposes, detectCycleInSources, determinePurposeReason, extractObligationsExtension, getInteraction, getValidTransitions, hasInteraction, hasUnknownPurposeTokens, hasValidDagSemantics, isAgentIdentityAttestation, isAttestationExpired, isAttestationNotYetValid, isAttestationOnly, isAttestationReceiptClaims, isAttributionAttestation, isAttributionExpired, isAttributionNotYetValid, isCanonicalPurpose, isContributionRequired, isCreditRequired, isDigestTruncated, isDisputeAttestation, isDisputeExpired, isDisputeNotYetValid, isLegacyPurpose, isMinimalInteractionBinding, isPaymentReceipt, isReservedKindPrefix, isTerminalState, isTerminalWorkflowStatus, isUndeclaredPurpose, isValidDisputeAttestation, isValidInteractionEvidence, isValidPurposeReason, isValidPurposeToken, isValidWorkflowContext, isWellKnownKind, isWorkflowSummaryAttestation, mapLegacyToCanonical, normalizePurposeToken, normalizeToCanonicalOrPreserve, parsePurposeHeader, parseReceiptClaims, setInteraction, toCoreClaims, transitionDisputeState, validateAgentIdentityAttestation, validateAttestationReceiptClaims, validateAttributionAttestation, validateAttributionSource, validateContentHash, validateContributionObligation, validateCreditObligation, validateDisputeAttestation, validateDisputeContact, validateDisputeResolution, validateEvidence, validateIdentityBinding, validateInteraction, validateInteractionEvidence, validateInteractionOrdered, validateMinimalInteractionBinding, validateObligationsExtension, validatePurposeTokens, validateSubjectSnapshot, validateWorkflowContext, validateWorkflowContextOrdered, validateWorkflowSummaryAttestation };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map