@prampta/sdk 0.4.0 → 0.8.0

package/dist/index.js

@@ -37,18 +37,353 @@ __export(index_exports, {
   PramptaFailClosedError: () => PramptaFailClosedError,
   PramptaNetworkError: () => PramptaNetworkError,
   PramptaRefusalError: () => PramptaRefusalError,
+  PramptaReporter: () => PramptaReporter,
   PramptaSchemaError: () => PramptaSchemaError,
   PramptaSignatureError: () => PramptaSignatureError,
   PramptaTimeoutError: () => PramptaTimeoutError,
   REFUSAL_DESCRIPTIONS: () => REFUSAL_DESCRIPTIONS,
+  RegistryDirectoryError: () => RegistryDirectoryError,
   SOFT_REFUSAL_CODES: () => SOFT_REFUSAL_CODES,
+  TrustedRegistryDirectory: () => TrustedRegistryDirectory,
   canonicalJson: () => canonicalJson,
   hashPrompt: () => hashPrompt,
+  loadPregenDirectory: () => import_verify2.loadDirectory,
   matchSubjects: () => matchSubjects,
-  normalizeForMatch: () => normalizeForMatch
+  normalizeForMatch: () => normalizeForMatch,
+  verifyLicenseSignatures: () => verifyLicenseSignatures,
+  verifyMerkleProof: () => verifyMerkleProof
 });
 module.exports = __toCommonJS(index_exports);
+var ed3 = __toESM(require("@noble/ed25519"));
+
+// src/canonical.ts
+function canonicalJson(obj) {
+  if (obj === null) return "null";
+  if (typeof obj === "number") {
+    if (!Number.isSafeInteger(obj)) throw new TypeError("Signed JSON numbers must be safe integers");
+    return JSON.stringify(obj);
+  }
+  if (typeof obj === "boolean") return JSON.stringify(obj);
+  if (typeof obj === "string") {
+    if (Array.from(obj).some((c) => c.length === 1 && c.charCodeAt(0) >= 55296 && c.charCodeAt(0) <= 57343)) {
+      throw new TypeError("Signed JSON strings must contain valid Unicode scalar values");
+    }
+    return JSON.stringify(obj);
+  }
+  if (Array.isArray(obj)) return "[" + Array.from(obj, canonicalJson).join(",") + "]";
+  if (typeof obj !== "object" || Object.getPrototypeOf(obj) !== Object.prototype && Object.getPrototypeOf(obj) !== null) {
+    throw new TypeError("Signed JSON must contain only JSON values");
+  }
+  const keys = Object.keys(obj).sort((a, b) => {
+    const ac = Array.from(a, (c) => c.codePointAt(0));
+    const bc = Array.from(b, (c) => c.codePointAt(0));
+    for (let i = 0; i < Math.min(ac.length, bc.length); i++) {
+      if (ac[i] !== bc[i]) return ac[i] - bc[i];
+    }
+    return ac.length - bc.length;
+  });
+  return "{" + keys.map((k) => canonicalJson(k) + ":" + canonicalJson(obj[k])).join(",") + "}";
+}
+
+// src/index.ts
+var import_verify = require("@pregen/verify");
+var import_verify2 = require("@pregen/verify");
+
+// src/directory.ts
 var ed = __toESM(require("@noble/ed25519"));
+var RegistryDirectoryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryDirectoryError";
+  }
+};
+var verifiedConstruction = /* @__PURE__ */ Symbol("verified-directory");
+function fail(message) {
+  throw new RegistryDirectoryError(message);
+}
+function hexBytes(value, length) {
+  if (typeof value !== "string" || value.length !== length * 2 || !/^[0-9a-fA-F]+$/.test(value)) {
+    fail("Invalid Ed25519 key or signature encoding");
+  }
+  return Uint8Array.from(value.match(/../g), (s) => parseInt(s, 16));
+}
+function apiUrl(value) {
+  if (typeof value !== "string") fail("Registry URL must be a string");
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return fail("Invalid registry URL");
+  }
+  if (url.protocol !== "https:" || url.username || url.password || url.search || url.hash) {
+    fail("Registry URL must use HTTPS without credentials, query or fragment");
+  }
+  return url.href.replace(/\/+$/, "");
+}
+async function sha256(bytes) {
+  if (globalThis.crypto?.subtle) {
+    const digest2 = await globalThis.crypto.subtle.digest("SHA-256", new Uint8Array(bytes).buffer);
+    return Array.from(new Uint8Array(digest2), (b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  const { createHash } = await import("crypto");
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function registryNamespace(code) {
+  const normalized = code.trim().toUpperCase();
+  if (!normalized.startsWith("PG-")) return null;
+  const match = /^PG-([A-Z]{4})-/.exec(normalized);
+  if (match) {
+    if (!/^[ABCDEFGHJKMNPQRSTVWXYZ]{4}$/.test(match[1])) fail("Invalid issuer prefix");
+    return match[1];
+  }
+  if (!/^PG-(?:[A-Z]{3}-)?\d/.test(normalized)) fail("Unrecognized PG namespace");
+  return "";
+}
+var TrustedRegistryDirectory = class _TrustedRegistryDirectory {
+  constructor(registries, sequence, snapshotHash, seal) {
+    this.sequence = sequence;
+    this.snapshotHash = snapshotHash;
+    if (seal !== verifiedConstruction) fail("Construct directories through signature verification");
+    this.#registries = registries;
+    Object.freeze(this);
+  }
+  sequence;
+  snapshotHash;
+  #registries;
+  static async verify(input, options) {
+    const min = options.minSequence ?? 0;
+    if (!Number.isSafeInteger(min) || min < 0) fail("minSequence must be a nonnegative safe integer");
+    const previous = options.previousSnapshot ? { ...options.previousSnapshot } : void 0;
+    if (previous && (!Number.isSafeInteger(previous.sequence) || previous.sequence < 1 || typeof previous.hash !== "string" || !/^[0-9a-f]{64}$/.test(previous.hash))) {
+      fail("Invalid persisted directory snapshot");
+    }
+    if (!input || typeof input !== "object" || Array.isArray(input)) fail("Directory must be an object");
+    let d;
+    try {
+      d = JSON.parse(canonicalJson(input));
+    } catch {
+      return fail("Directory contains noncanonical JSON values");
+    }
+    if (d.schema !== "pregen.registries.v2" || !Number.isSafeInteger(d.sequence) || d.sequence < 1) {
+      fail("Unsupported directory schema or sequence");
+    }
+    if (d.sequence < Math.max(min, previous?.sequence ?? 0)) fail("Directory rollback detected");
+    if (!Array.isArray(d.registries) || !d.registries.length) fail("Empty registry directory");
+    const prefixes = /* @__PURE__ */ new Set();
+    const endpoints = /* @__PURE__ */ new Set();
+    const fps = /* @__PURE__ */ new Set();
+    for (const r of d.registries) {
+      if (!r || typeof r !== "object" || Array.isArray(r) || typeof r.name !== "string" || !r.name.trim()) fail("Malformed registry entry");
+      if (r.prefix !== "" && (typeof r.prefix !== "string" || !/^[ABCDEFGHJKMNPQRSTVWXYZ]{4}$/.test(r.prefix))) fail("Invalid registry prefix");
+      if (prefixes.has(r.prefix)) fail("Duplicate registry namespace");
+      prefixes.add(r.prefix);
+      const endpoint = apiUrl(r.api);
+      if (endpoints.has(endpoint)) fail("Ambiguous registry endpoint");
+      endpoints.add(endpoint);
+      apiUrl(r.keys);
+      if (!Array.isArray(r.key_fingerprints) || !r.key_fingerprints.length) fail("Empty registry key list");
+      for (const fp2 of r.key_fingerprints) {
+        if (typeof fp2 !== "string" || !/^pg-ed25519:[0-9a-f]{32}$/.test(fp2)) fail("Invalid registry key fingerprint");
+        if (fps.has(fp2)) fail("Duplicate signing key across registry entries");
+        fps.add(fp2);
+      }
+    }
+    if (!prefixes.has("")) fail("Missing origin namespace");
+    const publicKey = hexBytes(options.stewardPublicKeyHex, 32);
+    const hash = await sha256(publicKey);
+    const fp = "pg-ed25519:" + hash.slice(0, 32);
+    if (d.steward_key_id !== fp) fail("Unexpected steward key");
+    const sig = hexBytes(d.signature, 64);
+    const body = { ...d };
+    delete body.signature;
+    const message = new TextEncoder().encode(canonicalJson(body));
+    let valid = false;
+    try {
+      valid = await ed.verifyAsync(sig, message, publicKey);
+    } catch {
+      fail("Invalid directory signature");
+    }
+    if (!valid) fail("Invalid directory signature");
+    const snapshotHash = await sha256(message);
+    if (previous && previous.sequence === d.sequence && previous.hash !== snapshotHash) fail("Directory equivocation detected");
+    return new _TrustedRegistryDirectory(d.registries, d.sequence, snapshotHash, verifiedConstruction);
+  }
+  registryFor(code) {
+    const prefix = registryNamespace(code);
+    if (prefix === null) return fail("A PG code is required for namespace verification");
+    return this.#registries.find((r) => r.prefix === prefix) ?? fail("Unknown registry namespace");
+  }
+  /** V-11: checked before forwarding a provider's credential to an endpoint. */
+  assertEndpoint(subject, baseUrl) {
+    const endpoint = apiUrl(baseUrl);
+    const prefix = registryNamespace(subject);
+    const owner = prefix === null ? this.#registries.find((r) => apiUrl(r.api) === endpoint) : this.registryFor(subject);
+    if (!owner || apiUrl(owner.api) !== endpoint) fail("Subject belongs to a different registry endpoint");
+  }
+  /** V-10: use only AFTER independently verifying the object's signature. */
+  assertSigner(code, keyId) {
+    if (!this.registryFor(code).key_fingerprints.includes(keyId)) fail("Registry issuer/key mismatch");
+  }
+  assertDecision(subject, license, keyId, baseUrl) {
+    this.assertEndpoint(subject, baseUrl);
+    if (registryNamespace(subject) !== null) this.assertSigner(subject, keyId);
+    else {
+      const owner = this.#registries.find((r) => apiUrl(r.api) === apiUrl(baseUrl));
+      if (!owner?.key_fingerprints.includes(keyId)) fail("Registry issuer/key mismatch");
+    }
+    if (license) {
+      this.assertEndpoint(license, baseUrl);
+      this.assertSigner(license, keyId);
+    }
+  }
+};
+
+// src/license.ts
+var ed2 = __toESM(require("@noble/ed25519"));
+async function verifyLicenseSignatures(input) {
+  const bytes = (hex, size) => {
+    if (typeof hex !== "string" || hex.length !== size * 2 || !/^[0-9a-fA-F]+$/.test(hex)) throw new TypeError("Invalid hex");
+    return Uint8Array.from(hex.match(/../g), (s) => parseInt(s, 16));
+  };
+  let body;
+  let subjectSig;
+  try {
+    if (!/^PG-[\x21-\x7e]+$/.test(input.licenseId)) throw new TypeError("Invalid license id");
+    body = new TextEncoder().encode(canonicalJson(input.body));
+    subjectSig = bytes(input.subjectSignatureHex, 64);
+  } catch {
+    return { subjectValid: false, operatorValid: false };
+  }
+  let subjectValid = false;
+  let operatorValid = false;
+  try {
+    subjectValid = await ed2.verifyAsync(subjectSig, body, bytes(input.subjectPublicKeyHex, 32));
+  } catch {
+  }
+  const id = new TextEncoder().encode(input.licenseId);
+  const counterBody = new Uint8Array(body.length + subjectSig.length + id.length);
+  counterBody.set(body);
+  counterBody.set(subjectSig, body.length);
+  counterBody.set(id, body.length + subjectSig.length);
+  try {
+    operatorValid = await ed2.verifyAsync(bytes(input.operatorSignatureHex, 64), counterBody, bytes(input.operatorPublicKeyHex, 32));
+  } catch {
+  }
+  return { subjectValid, operatorValid };
+}
+
+// src/reporting.ts
+async function digest(bytes) {
+  const { createHash } = await import("crypto");
+  return createHash("sha256").update(bytes).digest("hex");
+}
+var hashPattern = /^[a-f0-9]{64}$/;
+var idPattern = /^[A-Za-z0-9_.:-]{1,100}$/;
+var PramptaReporter = class {
+  constructor(config) {
+    this.config = config;
+    const url = new URL(config.baseUrl);
+    const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && local) || url.username || url.password || url.search || url.hash || url.pathname !== "/") {
+      throw new Error("Use an HTTPS API origin (HTTP is permitted only on loopback)");
+    }
+    if (!config.providerId || !config.token) throw new Error("Provider credential required");
+    this.timeoutMs = config.timeoutMs ?? 3e3;
+    if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0 || this.timeoutMs > 6e4) {
+      throw new Error("timeoutMs must be between 1 and 60000");
+    }
+    this.baseUrl = url.origin;
+  }
+  config;
+  baseUrl;
+  timeoutMs;
+  /** No PRAMPTA network call: hash locally and commit to the durable outbox.
+   * A storage failure is surfaced, never reported as success. Run from the
+   * provider's generation-completed job, not as an authorization gate. */
+  async report(input) {
+    if (!input.eventKey || input.eventKey.length > 1e3 || !idPattern.test(input.outputId) || input.subjectId.length < 2 || input.subjectId.length > 255) throw new Error("Invalid event identity");
+    if (!/(Z|[+-]\d{2}:\d{2})$/.test(input.occurredAt) || !Number.isFinite(Date.parse(input.occurredAt))) {
+      throw new Error("occurredAt must contain a timezone");
+    }
+    if (Date.parse(input.occurredAt) > Date.now() + 3e5) throw new Error("Event time is in the future");
+    if (input.purpose !== void 0 && !["personal", "commercial", "educational", "research", "editorial", "unknown"].includes(input.purpose)) {
+      throw new Error("Invalid declared purpose");
+    }
+    if (input.output === void 0 === (input.outputHash === void 0)) {
+      throw new Error("Provide exactly one of output or outputHash");
+    }
+    const outputHash = input.outputHash ?? await digest(typeof input.output === "string" ? new TextEncoder().encode(input.output) : input.output);
+    if (!hashPattern.test(outputHash)) throw new Error("Invalid SHA-256 output hash");
+    const type = input.eventType ?? "output.created";
+    if (!["output.created", "output.modified", "output.published", "publication.removed"].includes(type)) {
+      throw new Error("Invalid event type");
+    }
+    if (type === "output.modified") {
+      if (!input.parentOutputHash || !hashPattern.test(input.parentOutputHash) || input.parentOutputHash === outputHash) {
+        throw new Error("Modified outputs need a different parent hash");
+      }
+    } else if (input.parentOutputHash !== void 0) throw new Error("Parent hash is only for modifications");
+    if (type === "output.published" || type === "publication.removed") {
+      const url = new URL(input.publicationUrl ?? "");
+      if (url.protocol !== "https:" || url.username || url.password || url.search || url.hash || /\s/.test(input.publicationUrl) || input.publicationUrl.length > 2048) throw new Error("Unsafe publication URL");
+    } else if (input.publicationUrl !== void 0) throw new Error("URL is only for publication events");
+    const eventId = await digest(new TextEncoder().encode(JSON.stringify([input.eventKey, input.subjectId])));
+    const event = {
+      schema_version: "pg.observation.v1",
+      event_id: eventId,
+      output_id: input.outputId,
+      subject_id: input.subjectId,
+      event_type: type,
+      output_hash: outputHash,
+      occurred_at: new Date(input.occurredAt).toISOString(),
+      declared_purpose: input.purpose ?? "unknown",
+      ...input.parentOutputHash !== void 0 ? { parent_output_hash: input.parentOutputHash } : {},
+      ...input.publicationUrl !== void 0 ? { publication_url: input.publicationUrl } : {}
+    };
+    await this.config.outbox.put(event);
+    return { status: "queued", eventId };
+  }
+  /** One bounded attempt by your queue worker. Keep/retry on `retry`, quarantine
+   * on `rejected`, acknowledge only `accepted`. Never changes /verify behavior. */
+  async deliver(event) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(`${this.baseUrl}/v1/observations`, {
+        method: "POST",
+        redirect: "error",
+        signal: controller.signal,
+        headers: {
+          "Content-Type": "application/json",
+          "X-Provider-ID": this.config.providerId,
+          Authorization: `Bearer ${this.config.token}`
+        },
+        body: JSON.stringify(event)
+      });
+      if (response.status === 429 || response.status >= 500 || response.status === 408) {
+        const hint = response.headers.get("Retry-After");
+        const delay = hint ? /^\d+$/.test(hint) ? Number(hint) * 1e3 : Date.parse(hint) - Date.now() : 1e3;
+        return {
+          status: "retry",
+          httpStatus: response.status,
+          retryAfterMs: Number.isFinite(delay) ? Math.max(1e3, Math.min(delay, 864e5)) : 1e3
+        };
+      }
+      if (!response.ok) return { status: "rejected", httpStatus: response.status };
+      const body = await response.json();
+      if (typeof body.id !== "string" || !body.id || body.authorization !== "not_granted_by_this_record" || body.payload?.event_id !== event.event_id || body.provider_id !== this.config.providerId || body.payload?.subject_id !== event.subject_id || body.payload?.output_hash !== event.output_hash) {
+        return { status: "retry", httpStatus: response.status, retryAfterMs: 1e3 };
+      }
+      return { status: "accepted", observationId: body.id };
+    } catch {
+      return { status: "retry", retryAfterMs: 1e3 };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/index.ts
 var PramptaError = class extends Error {
   constructor(message) {
     super(message);
@@ -123,6 +458,9 @@ var PramptaFailClosedError = class extends PramptaError {
   cause_;
 };
 var REFUSAL_DESCRIPTIONS = {
+  PG_CAMPAIGN_REQUIRED: "This license requires a campaign_id on every generation",
+  PG_BUDGET_EXHAUSTED: "The license's prepaid balance cannot cover this generation \u2014 top up the balance",
+  PG_RECEIPTS_OVERDUE: "Too many authorized generations without receipts \u2014 submit receipts to resume",
   PG_NO_SUBJECT: "Subject not found in registry",
   PG_SUBJECT_PENDING: "Subject registration is pending approval",
   PG_SUBJECT_DISPUTED: "Subject is under dispute \u2014 generation blocked",
@@ -134,30 +472,52 @@ var REFUSAL_DESCRIPTIONS = {
   PG_IMMUTABLE_DENIAL: "Content category permanently denied by subject",
   PG_SCOPE_VIOLATION: "Intended use outside license scope",
   PG_EXTENSION_REFUSED: "License extension constraint not satisfied",
-  PG_BACKEND_UNAVAILABLE: "Backend unreachable \u2014 fail-closed"
+  PG_BACKEND_UNAVAILABLE: "Backend unreachable \u2014 fail-closed",
+  // Identity & entitlement layer (docs/PRAMPTA-Identity-Entitlement-Architecture.md §7).
+  PG_PROVIDER_NOT_ALLOWED: "This license is not portable to this provider",
+  PG_IDENTITY_REVOKED: "Underlying provider identity has been revoked \u2014 stop retrying",
+  PG_ENTITLEMENT_INACTIVE: "Source purchase is no longer active (refunded / reversed)",
+  PG_REGION_BLOCKED: "License is not valid in this territory",
+  PG_USAGE_LIMIT: "License usage cap reached",
+  PG_CONCURRENCY_LIMIT: "Too many concurrent generations under this license"
 };
 var HARD_REFUSAL_CODES = /* @__PURE__ */ new Set([
   "PG_SUBJECT_OPTED_OUT",
   "PG_IMMUTABLE_DENIAL",
   "PG_INVALID_SIGNATURE",
   "PG_SUBJECT_DISPUTED",
-  "PG_SUBJECT_WITHDRAWN"
+  "PG_SUBJECT_WITHDRAWN",
+  // A revoked identity or reversed purchase means the underlying grant is
+  // gone — the client MUST stop retrying (backing off won't help).
+  "PG_IDENTITY_REVOKED",
+  "PG_ENTITLEMENT_INACTIVE"
 ]);
 var SOFT_REFUSAL_CODES = /* @__PURE__ */ new Set([
   "PG_NO_LICENSE",
-  "PG_SCOPE_VIOLATION"
+  "PG_SCOPE_VIOLATION",
+  "PG_PROVIDER_NOT_ALLOWED",
+  "PG_REGION_BLOCKED",
+  "PG_USAGE_LIMIT",
+  "PG_CONCURRENCY_LIMIT"
 ]);
 function envVar(key) {
   if (typeof process !== "undefined" && process.env) return process.env[key] ?? "";
   return "";
 }
 async function hashPrompt(prompt) {
-  return sha256(prompt);
+  return sha2562(prompt);
 }
-async function sha256(input) {
+async function sha2562(input) {
   const data = new TextEncoder().encode(input);
   return sha256Bytes(data);
 }
+async function verifyMerkleProof(leafHash, proof, rootHash) {
+  let current = leafHash;
+  for (const step of proof) {
+    current = step.position === "right" ? await sha2562(current + step.hash) : await sha2562(step.hash + current);
+  }
+  return current === rootHash;
+}
 var TOFU_WARNING = "PRAMPTA: verifying operator signatures WITHOUT a pinned key (trust-on-first-use). This provides no protection against a malicious or compromised endpoint. Set operatorPublicKeyHex (from PRAMPTA's docs) before production.";
 function parsePins(raw) {
   return raw ? raw.split(/[\s,]+/).filter(Boolean) : [];
@@ -174,16 +534,10 @@ async function sha256Bytes(data) {
   const { createHash } = await import("crypto");
   return createHash("sha256").update(data).digest("hex");
 }
-function canonicalJson(obj) {
-  if (obj === null || obj === void 0) return "null";
-  if (typeof obj === "number" || typeof obj === "boolean") return JSON.stringify(obj);
-  if (typeof obj === "string") return JSON.stringify(obj);
-  if (Array.isArray(obj)) return "[" + obj.map(canonicalJson).join(",") + "]";
-  const keys = Object.keys(obj).sort();
-  const parts = keys.map((k) => JSON.stringify(k) + ":" + canonicalJson(obj[k]));
-  return "{" + parts.join(",") + "}";
-}
 function hexToBytes(hex) {
+  if (typeof hex !== "string" || !/^(?:[0-9a-fA-F]{2})+$/.test(hex)) {
+    throw new PramptaSignatureError("Invalid hexadecimal key or signature");
+  }
   const bytes = new Uint8Array(hex.length / 2);
   for (let i = 0; i < hex.length; i += 2) {
     bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
@@ -241,10 +595,14 @@ var Prampta = class _Prampta {
   failClosed;
   verifySignature;
   enforce;
+  requireUserBinding;
+  registryDirectory;
+  pregenDirectory;
   pinnedKeys;
   keySetCache = null;
   keySetPromise = null;
   tofuWarned = false;
+  inFlight = /* @__PURE__ */ new Map();
   constructor(config = {}) {
     this.baseUrl = (config.baseUrl || envVar("PRAMPTA_BASE_URL")).replace(/\/+$/, "");
     this.providerId = config.providerId || envVar("PRAMPTA_PROVIDER_ID");
@@ -256,11 +614,33 @@ var Prampta = class _Prampta {
     this.failClosed = config.failClosed ?? true;
     this.verifySignature = config.verifyDecisionSignature ?? true;
     this.enforce = config.enforce ?? true;
+    this.requireUserBinding = config.requireUserBinding ?? false;
+    this.registryDirectory = config.registryDirectory;
+    this.pregenDirectory = config.pregenDirectory;
     this.pinnedKeys = parsePins(config.operatorPublicKeyHex || envVar("PRAMPTA_OPERATOR_PUBLIC_KEY") || "");
     if (!this.baseUrl) throw new PramptaError("baseUrl is required (or set PRAMPTA_BASE_URL)");
     if (!this.providerId) throw new PramptaError("providerId is required (or set PRAMPTA_PROVIDER_ID)");
-    if (!this.licenseeId) throw new PramptaError("licenseeId is required (or set PRAMPTA_LICENSEE_ID)");
     if (!this.token) throw new PramptaError("token is required (or set PRAMPTA_TOKEN)");
+    if (this.registryDirectory && (!this.verifySignature || this.pinnedKeys.length === 0)) {
+      throw new PramptaError("registryDirectory requires signature verification and pinned operator keys");
+    }
+    this.registryDirectory?.assertEndpoint("", this.baseUrl);
+    if (this.pregenDirectory && !this.pregenDirectory.registries.some((r) => sameEndpoint(r.api, this.baseUrl))) {
+      throw new PramptaError(`${this.baseUrl} is not a registry listed in the PRE-GEN directory`);
+    }
+  }
+  /** V-11: a PG code is answered only by the registry that owns its namespace. */
+  assertPregenEndpoint(subjectId) {
+    if (!this.pregenDirectory) return;
+    try {
+      (0, import_verify.issuerOf)(subjectId);
+    } catch {
+      return;
+    }
+    const owner = this.pregenDirectory.registryFor(subjectId);
+    if (!owner || !sameEndpoint(owner.api, this.baseUrl)) {
+      throw new PramptaSchemaError(`${subjectId} belongs to ${owner ? owner.api : "no listed registry"}, not ${this.baseUrl}`);
+    }
   }
   // ── Key Discovery ───────────────────────────────────────────────────
   /** Fetch /keys and check it is self-signed by its current key. Cached. */
@@ -276,7 +656,7 @@ var Prampta = class _Prampta {
         if (!currentHex || !sig) throw new PramptaSignatureError("Operator key set from /keys is malformed");
         const body = { ...ks };
         delete body.signature;
-        const ok = await ed.verifyAsync(hexToBytes(sig), new TextEncoder().encode(canonicalJson(body)), hexToBytes(currentHex));
+        const ok = await ed3.verifyAsync(hexToBytes(sig), new TextEncoder().encode(canonicalJson(body)), hexToBytes(currentHex));
         if (!ok) throw new PramptaSignatureError("Operator key set signature is invalid");
         this.keySetCache = ks;
         return ks;
@@ -333,12 +713,71 @@ var Prampta = class _Prampta {
     }
     return matchSubjects(text, this.subjectIndexEntries);
   }
+  /** Record what a local text match found for a prompt, BEFORE the user
+   * answers. Purely advisory — creates no entitlement or licence. Pass the
+   * returned detectionId to confirmDetection() and optionally to verify(). */
+  async reportDetection(promptHash, candidateSubjectIds) {
+    const data = await this.post("/v1/subjects/detections/", {
+      prompt_hash: promptHash,
+      candidate_subject_ids: candidateSubjectIds
+    });
+    return {
+      detectionId: data.detection_id,
+      status: data.status,
+      candidateSubjectIds: data.candidate_subject_ids || [],
+      confirmedSubjectId: data.confirmed_subject_id ?? null,
+      createdAt: data.created_at,
+      confirmedAt: data.confirmed_at ?? null
+    };
+  }
+  /** Record what the user actually said. `subjectId` undefined/null means
+   * they rejected every candidate. Still advisory-only. */
+  async confirmDetection(detectionId, subjectId) {
+    const data = await this.post(`/v1/subjects/detections/${detectionId}/confirm`, {
+      subject_id: subjectId ?? null
+    });
+    return {
+      detectionId: data.detection_id,
+      status: data.status,
+      candidateSubjectIds: data.candidate_subject_ids || [],
+      confirmedSubjectId: data.confirmed_subject_id ?? null,
+      createdAt: data.created_at,
+      confirmedAt: data.confirmed_at ?? null
+    };
+  }
   // ── Signature Verification ──────────────────────────────────────────
   /**
    * Verify operator Ed25519 signature over decision body.
    * Fails closed on any error.
    */
   async verifyDecision(raw, decision) {
+    if (typeof raw.allowed !== "boolean") throw new PramptaSchemaError("allowed must be a boolean");
+    const disposition = raw.disposition ?? (raw.allowed ? "allow" : "deny");
+    if (!["allow", "deny", "review", "not_blocked"].includes(disposition) || raw.allowed !== (disposition === "allow")) {
+      throw new PramptaSchemaError("allowed and disposition are inconsistent or unsupported");
+    }
+    if (raw.schema_version !== void 0 && !["pg.decision.v1", "1.0"].includes(raw.schema_version)) {
+      throw new PramptaSchemaError("Unsupported decision schema_version");
+    }
+    if (typeof raw.decision_id !== "string" || !raw.decision_id.trim()) {
+      throw new PramptaSchemaError("decision_id must be a nonempty string");
+    }
+    if (raw.license_id != null && (typeof raw.license_id !== "string" || !raw.license_id.trim())) {
+      throw new PramptaSchemaError("license_id must be null or a nonempty string");
+    }
+    for (const field of ["subject_id", "provider_id", "licensee_id", "prompt_hash", "model", "modality", "generation_id", "detection_id", "provider_identity_link_id"]) {
+      if (raw[field] !== void 0 && typeof raw[field] !== "string") throw new PramptaSchemaError(`${field} must be a string`);
+    }
+    if (raw.intended_use !== void 0 && (!raw.intended_use || typeof raw.intended_use !== "object" || Array.isArray(raw.intended_use))) {
+      throw new PramptaSchemaError("intended_use must be an object");
+    }
+    for (const field of ["channel", "product_name", "project_name", "territory", "campaign_id", "use_case", "modality"]) {
+      if (raw.intended_use?.[field] !== void 0 && typeof raw.intended_use[field] !== "string") throw new PramptaSchemaError(`${field} must be a string`);
+    }
+    for (const field of ["categories", "rights"]) {
+      const value = raw.intended_use?.[field];
+      if (value !== void 0 && (!Array.isArray(value) || value.some((v) => typeof v !== "string"))) throw new PramptaSchemaError(`${field} must be an array of strings`);
+    }
     if (!this.verifySignature) return;
     const sig = decision.operatorSignature;
     if (!sig) throw new PramptaSignatureError("Decision missing operator_signature");
@@ -353,7 +792,7 @@ var Prampta = class _Prampta {
     const sigBytes = hexToBytes(sig);
     let valid;
     try {
-      valid = await ed.verifyAsync(sigBytes, messageBytes, pubKeyBytes);
+      valid = await ed3.verifyAsync(sigBytes, messageBytes, pubKeyBytes);
     } catch (e) {
       throw new PramptaSignatureError(`Ed25519 verification error: ${e}`);
     }
@@ -363,7 +802,10 @@ var Prampta = class _Prampta {
       );
     }
     const now = Math.floor(Date.now() / 1e3);
-    if (decision.expiresAt > 0 && decision.expiresAt < now) {
+    if (!Number.isSafeInteger(raw.expires_at) || raw.expires_at <= 0 || raw.issued_at !== void 0 && (!Number.isSafeInteger(raw.issued_at) || raw.issued_at <= 0 || raw.issued_at >= raw.expires_at || raw.issued_at > now + 60)) {
+      throw new PramptaSchemaError("Decision has invalid validity timestamps");
+    }
+    if (decision.expiresAt <= now) {
       throw new PramptaSignatureError(
         `Decision expired at ${decision.expiresAt}, current time ${now}`
       );
@@ -374,56 +816,69 @@ var Prampta = class _Prampta {
    * Prevents replay attacks where a valid decision for one context is used in another.
    */
   verifyContextBinding(decision, expected) {
-    if (decision.promptHash && decision.promptHash !== expected.promptHash) {
+    if ((expected.providerUserId || expected.providerIdentityLinkId) && decision.allowed && (decision.providerUserBinding !== "verified" || !decision.providerIdentityLinkId)) {
+      throw new PramptaSignatureError("Decision missing verified provider-user binding");
+    }
+    if (decision.promptHash !== expected.promptHash) {
       throw new PramptaSignatureError(
         `Decision prompt_hash mismatch: sent ${expected.promptHash}, got ${decision.promptHash}`
       );
     }
-    if (decision.subjectId && decision.subjectId !== expected.subjectId) {
+    if (decision.subjectId !== expected.subjectId) {
       throw new PramptaSignatureError(
         `Decision subject_id mismatch: sent ${expected.subjectId}, got ${decision.subjectId}`
       );
     }
-    if (decision.providerId && decision.providerId !== expected.providerId) {
+    if (decision.providerId !== expected.providerId) {
       throw new PramptaSignatureError(
         `Decision provider_id mismatch: sent ${expected.providerId}, got ${decision.providerId}`
       );
     }
-    if (decision.licenseeId && decision.licenseeId !== expected.licenseeId) {
+    if (decision.licenseeId !== expected.licenseeId) {
       throw new PramptaSignatureError(
         `Decision licensee_id mismatch: sent ${expected.licenseeId}, got ${decision.licenseeId}`
       );
     }
-    if (decision.modality && expected.modality && decision.modality !== expected.modality) {
+    if (decision.modality !== expected.modality) {
       throw new PramptaSignatureError(
         `Decision modality mismatch: sent ${expected.modality}, got ${decision.modality}`
       );
     }
-    if (decision.model && expected.model && decision.model !== expected.model) {
+    if (decision.model !== expected.model) {
       throw new PramptaSignatureError(
         `Decision model mismatch: sent ${expected.model}, got ${decision.model}`
       );
     }
+    for (const [name, got, sent] of [
+      ["generation_id", decision.generationId, expected.generationId],
+      ["detection_id", decision.detectionId, expected.detectionId],
+      ["provider_identity_link_id", decision.providerIdentityLinkId, expected.providerIdentityLinkId]
+    ]) {
+      if (sent && got !== sent) throw new PramptaSignatureError(`Decision ${name} mismatch`);
+    }
     if (expected.intendedUse) {
       const iu = decision.intendedUse || {};
       const pairs = [
         ["product_name", String(iu.product_name || ""), expected.intendedUse.productName],
         ["project_name", String(iu.project_name || ""), expected.intendedUse.projectName],
         ["channel", String(iu.channel || ""), expected.intendedUse.channel],
-        ["territory", String(iu.territory || ""), expected.intendedUse.territory]
+        ["territory", String(iu.territory || ""), expected.intendedUse.territory],
+        ["campaign_id", String(iu.campaign_id || ""), expected.intendedUse.campaignId],
+        ["use_case", String(iu.use_case || ""), expected.intendedUse.useCase || ""],
+        ["modality", String(iu.modality || ""), expected.intendedUse.modality]
       ];
       for (const [name, got, sent] of pairs) {
-        if (got && sent && got !== sent) {
+        if (got !== sent) {
           throw new PramptaSignatureError(`Decision ${name} mismatch: sent ${sent}, got ${got}`);
         }
       }
-      const gotCats = new Set((Array.isArray(iu.categories) ? iu.categories : []).map(String));
-      const sentCats = new Set(expected.intendedUse.categories || []);
-      if (gotCats.size && sentCats.size) {
+      for (const [field, sent] of [["categories", expected.intendedUse.categories], ["rights", expected.intendedUse.rights]]) {
+        const gotCats = new Set(iu[field] ?? []);
+        const sentCats = new Set(sent);
         const same = gotCats.size === sentCats.size && [...sentCats].every((c) => gotCats.has(c));
         if (!same) {
           throw new PramptaSignatureError(
-            `Decision categories mismatch: sent ${[...sentCats].sort()}, got ${[...gotCats].sort()}`
+            `Decision ${field} mismatch: sent ${[...sentCats].sort()}, got ${[...gotCats].sort()}`
           );
         }
       }
@@ -431,12 +886,24 @@ var Prampta = class _Prampta {
   }
   // ── Core API ─────────────────────────────────────────────────────────
   async verifyGeneration(request) {
-    const promptHash = request.promptHash || (request.prompt ? await sha256(request.prompt) : null);
+    request = { ...request, intendedUse: request.intendedUse ? {
+      ...request.intendedUse,
+      categories: request.intendedUse.categories?.slice(),
+      rights: request.intendedUse.rights?.slice()
+    } : void 0 };
+    this.registryDirectory?.assertEndpoint(request.subjectId, this.baseUrl);
+    this.assertPregenEndpoint(request.subjectId);
+    const promptHash = request.promptHash || (request.prompt ? await sha2562(request.prompt) : null);
     if (!promptHash) {
       throw new PramptaSchemaError(
         "Either prompt or promptHash is required. SDK does not allow empty prompt hashes to prevent unbound decisions."
       );
     }
+    if (this.requireUserBinding && !request.providerUserId && !request.providerIdentityLinkId) {
+      throw new PramptaSchemaError(
+        "requireUserBinding=true but neither providerUserId nor providerIdentityLinkId was supplied. This client is configured to always act for a specific end user \u2014 pass one of them, or construct new Prampta({ requireUserBinding: false, ... }) if this call is genuinely meant to be unbound."
+      );
+    }
     const payload = {
       subject_id: request.subjectId,
       prompt_hash: promptHash,
@@ -448,13 +915,32 @@ var Prampta = class _Prampta {
         project_name: request.intendedUse?.projectName || "",
         categories: request.intendedUse?.categories || [],
         modality: request.modality || "",
-        territory: request.intendedUse?.territory || ""
-      }
+        territory: request.intendedUse?.territory || "",
+        campaign_id: request.intendedUse?.campaignId || "",
+        use_case: request.intendedUse?.useCase || "",
+        rights: request.intendedUse?.rights || []
+      },
+      // Omitted entirely when unset: an empty string is not the same as "no
+      // end user", and sending one would make a pre-v2 caller look like it
+      // asserted an unknown identity.
+      ...request.providerUserId ? { provider_user_id: request.providerUserId } : {},
+      ...request.providerIdentityLinkId ? { provider_identity_link_id: request.providerIdentityLinkId } : {},
+      ...request.generationId ? { generation_id: request.generationId } : {},
+      ...request.idempotencyKey ? { idempotency_key: request.idempotencyKey } : {},
+      ...request.detectionId ? { detection_id: request.detectionId } : {},
+      ...request.returnUrl ? { return_url: request.returnUrl } : {}
     };
+    const extraHeaders = request.expectedSchemaVersion ? { "X-Prampta-Expected-Schema-Version": request.expectedSchemaVersion } : void 0;
     try {
-      const data = await this.post("/v1/verify/", payload);
+      const data = await this.post("/v1/verify/", payload, extraHeaders);
       const decision = this.parseDecision(data);
       await this.verifyDecision(data, decision);
+      this.registryDirectory?.assertDecision(
+        request.subjectId,
+        decision.licenseId,
+        decision.operatorKeyId,
+        this.baseUrl
+      );
       this.verifyContextBinding(decision, {
         promptHash,
         subjectId: request.subjectId,
@@ -462,14 +948,33 @@ var Prampta = class _Prampta {
         licenseeId: this.licenseeId,
         modality: request.modality || "",
         model: request.model || "",
+        generationId: request.generationId,
+        detectionId: request.detectionId,
+        providerIdentityLinkId: request.providerIdentityLinkId,
+        providerUserId: request.providerUserId,
         intendedUse: {
           productName: request.intendedUse?.productName || "",
           projectName: request.intendedUse?.projectName || "",
           channel: request.intendedUse?.channel || "",
           territory: request.intendedUse?.territory || "",
-          categories: request.intendedUse?.categories || []
+          categories: request.intendedUse?.categories || [],
+          campaignId: request.intendedUse?.campaignId || "",
+          useCase: request.intendedUse?.useCase || "",
+          modality: request.modality || "",
+          rights: request.intendedUse?.rights || []
         }
       });
+      if (this.pregenDirectory && decision.disposition === "allow") {
+        try {
+          await (0, import_verify.checkDecision)(
+            data,
+            { ...payload, provider_id: this.providerId, licensee_id: this.licenseeId || "" },
+            { directory: this.pregenDirectory }
+          );
+        } catch (e) {
+          throw new PramptaSignatureError(`PRE-GEN check failed: ${e.message}`);
+        }
+      }
       return decision;
     } catch (e) {
       if (this.failClosed) {
@@ -486,13 +991,16 @@ var Prampta = class _Prampta {
    * Either `prompt` or `promptHash` is REQUIRED — decisions are bound to
    * the prompt hash and the SDK refuses to request unbound ones. */
   async verify(subjectId, options = {}) {
-    const { categories, channel, productName, projectName, territory, intendedUse, ...rest } = options;
+    const { categories, channel, productName, projectName, territory, campaignId, useCase, rights, intendedUse, ...rest } = options;
     const iu = intendedUse ?? {
       ...channel ? { channel } : {},
       ...productName ? { productName } : {},
       ...projectName ? { projectName } : {},
       ...categories ? { categories } : {},
-      ...territory ? { territory } : {}
+      ...territory ? { territory } : {},
+      ...campaignId ? { campaignId } : {},
+      ...useCase ? { useCase } : {},
+      ...rights ? { rights } : {}
     };
     return this.verifyGeneration({
       subjectId,
@@ -502,20 +1010,123 @@ var Prampta = class _Prampta {
   }
   async assertAllowed(subjectId, options = {}) {
     const decision = await this.verifyGeneration({ subjectId, ...options });
-    if (!decision.allowed) {
+    if (!decision.allowed && decision.disposition !== "not_blocked") {
       if (this.enforce) throw new PramptaRefusalError(decision);
       console.warn(`PRAMPTA monitor mode: would REFUSE (${decision.reason}) but enforce=false \u2014 proceeding.`);
     }
     return decision;
   }
+  /** Strict license-backed path. Unlike assertAllowed, this never accepts
+   * reporting-only not_blocked, an internal no-license allow, or monitor mode.
+   * It validates an authorization; it does not prove output compliance. */
+  async assertLicensed(subjectId, options = {}) {
+    if (!this.verifySignature || this.pinnedKeys.length === 0) {
+      throw new PramptaSignatureError("assertLicensed requires signature verification and pinned operator keys");
+    }
+    if (!options.generationId) throw new PramptaSchemaError("assertLicensed requires a generationId");
+    const decision = await this.verifyGeneration({ subjectId, ...options });
+    if (!decision.allowed || decision.disposition !== "allow" || !decision.licenseId) {
+      throw new PramptaRefusalError(decision);
+    }
+    return decision;
+  }
   async withAuthorization(request, generateFn) {
     const decision = await this.assertAllowed(request.subjectId, request);
     const output = await generateFn(decision);
     const metadata = this.createOutputMetadata(decision);
     return { output, decision, metadata };
   }
+  /**
+   * The whole cycle in one call, for every subject in the output:
+   * ask PRAMPTA fresh for each subject (no cached allow is reused), require a
+   * licence-backed allow from all of them, generate, file one receipt per
+   * subject. If any subject refuses, or `generate` throws, the allows already
+   * held are released so they do not count against usage limits.
+   *
+   * `generate` must throw only when nothing was produced. With a `journal`,
+   * calling again with the same generationId after a crash never generates
+   * twice: it resends missing receipts, or refuses if the crash happened
+   * mid-generation (then check your own records, releaseDecision() if nothing
+   * was produced, and use a new generationId). Concurrent calls with the
+   * same generationId in this process share one run.
+   */
+  async generateAuthorized(request, generate, options = {}) {
+    const id = request.generationId;
+    if (!id) throw new PramptaSchemaError("generateAuthorized requires a generationId");
+    const running = this.inFlight.get(id);
+    if (running) return running;
+    const run = this.runAuthorized(request, generate, options).finally(() => this.inFlight.delete(id));
+    this.inFlight.set(id, run);
+    return run;
+  }
+  async runAuthorized(request, generate, { journal, receipt }) {
+    const { subjectIds, generationId, ...rest } = request;
+    const subjects = [...new Set(subjectIds)];
+    if (subjects.length === 0) throw new PramptaSchemaError("generateAuthorized requires at least one subjectId");
+    const saved = await journal?.get(generationId);
+    if (saved?.stage === "authorized") {
+      throw new PramptaError(`Generation ${generationId} was interrupted after it was authorized; it is not run again. If nothing was produced, releaseDecision() each decision and use a new generationId.`);
+    }
+    if (saved?.stage === "reported") {
+      return { status: "already_reported", decisions: saved.decisions, outputHash: saved.outputHash ?? "", unreported: [] };
+    }
+    if (saved?.stage === "generated") {
+      const unreported2 = await this.fileReceipts(saved.decisions, saved.outputHash ?? "", receipt);
+      if (unreported2.length === 0) await journal.put({ ...saved, stage: "reported" });
+      return { status: "recovered", decisions: saved.decisions, outputHash: saved.outputHash ?? "", unreported: unreported2 };
+    }
+    const settled = await Promise.allSettled(subjects.map((s) => this.assertLicensed(s, { ...rest, generationId })));
+    const decisions = settled.flatMap((r) => r.status === "fulfilled" ? [r.value] : []);
+    const failed = settled.find((r) => r.status === "rejected");
+    if (failed) {
+      await this.releaseAll(decisions, "another subject in the same output was refused");
+      throw failed.reason;
+    }
+    if (decisions.some((d) => d.expiresAt <= Math.floor(Date.now() / 1e3))) {
+      await this.releaseAll(decisions, "expired before generation started");
+      throw new PramptaError("An authorization expired before generation started; ask again");
+    }
+    await journal?.put({ generationId, stage: "authorized", decisions });
+    let result;
+    try {
+      result = await generate(decisions);
+    } catch (e) {
+      if (await this.releaseAll(decisions, "generation failed")) {
+        await journal?.put({ generationId, stage: "released", decisions });
+      }
+      throw e;
+    }
+    const bytes = typeof result.outputBytes === "string" ? new TextEncoder().encode(result.outputBytes) : result.outputBytes;
+    const outputHash = result.outputHash ?? (bytes ? await sha256Bytes(bytes) : "");
+    await journal?.put({ generationId, stage: "generated", decisions, outputHash });
+    const unreported = await this.fileReceipts(decisions, outputHash, receipt);
+    if (unreported.length === 0) await journal?.put({ generationId, stage: "reported", decisions, outputHash });
+    return { status: "generated", output: result.output, decisions, outputHash, unreported };
+  }
+  /** Returns the decisions whose receipt could not be filed. A receipt that
+   * already exists (an earlier attempt landed) counts as filed. */
+  async fileReceipts(decisions, outputHash, receipt) {
+    const results = await Promise.allSettled(decisions.map((d) => this.submitReceipt(d, { ...receipt, outputHash })));
+    return decisions.filter((_, i) => {
+      const r = results[i];
+      if (r.status === "fulfilled") return false;
+      return !(r.reason instanceof PramptaApiError && r.reason.status === 409 && /already exists/.test(r.reason.detail));
+    });
+  }
+  /** True when every allow was given back. */
+  async releaseAll(decisions, reason) {
+    const results = await Promise.allSettled(decisions.map((d) => this.releaseDecision(d.decisionId, reason)));
+    return results.every((r) => r.status === "fulfilled" || r.reason instanceof PramptaApiError && r.reason.status === 409 && /nothing_to_release/.test(r.reason.detail));
+  }
+  /** Give back an allow that produced nothing (failed or cancelled job), so
+   * it does not count against the licence's usage limit. Only before a
+   * receipt and within 24 hours; the release is recorded in the audit log. */
+  async releaseDecision(decisionId, reason = "") {
+    return this.post(`/v1/receipts/${encodeURIComponent(decisionId)}/release`, { reason });
+  }
   // ── Subject Resolution ───────────────────────────────────────────────
   async getSubject(subjectId) {
+    this.registryDirectory?.assertEndpoint(subjectId, this.baseUrl);
     try {
       const data = await this.get(`/v1/subjects/${encodeURIComponent(subjectId)}`);
       return {
@@ -533,6 +1144,7 @@ var Prampta = class _Prampta {
   }
   // ── License Request ──────────────────────────────────────────────────
   async requestLicense(input) {
+    this.registryDirectory?.assertEndpoint(input.subjectId, this.baseUrl);
     const data = await this.post("/v1/license-requests/", {
       subject_id: input.subjectId,
       use_case: input.useCase,
@@ -553,12 +1165,12 @@ var Prampta = class _Prampta {
     };
   }
   /**
-   * Submit a generation receipt AFTER generating — the provider's enforcement
-   * proof, bound to the decision it acted on. Records that this generation was
-   * authorized and executed under the decision's terms (verifiable post-hoc).
+   * Report an output after generation. With a registered provider signing key,
+   * opt into v3 so eventType is bound to the provider's signature. This is a
+   * provider attestation, not proof of complete reporting or actual execution.
    */
   async submitReceipt(decision, result = {}) {
-    return this.post("/v1/receipts/", {
+    const payload = {
       decision_id: decision.decisionId,
       prompt_hash: decision.promptHash,
       output_hash: result.outputHash ?? "",
@@ -566,7 +1178,72 @@ var Prampta = class _Prampta {
       watermark_embedded: result.watermarkEmbedded ?? false,
       obligations_applied: result.obligationsApplied ?? decision.obligations ?? {},
       generated_at: result.generatedAt ?? Math.floor(Date.now() / 1e3)
-    });
+    };
+    if (result.providerSigningKeyHex !== void 0) {
+      const eventType = result.eventType ?? "output_accepted";
+      const keyHex = result.providerSigningKeyHex;
+      if (!["preview", "output_accepted", "output_delivered", "output_published"].includes(eventType)) {
+        throw new PramptaError("Unsupported receipt eventType");
+      }
+      if (!/^[0-9a-fA-F]{64}$/.test(keyHex)) {
+        throw new PramptaError("providerSigningKeyHex must be a 32-byte Ed25519 private key");
+      }
+      if (!decision.subjectId || !this.providerId || !this.licenseeId) {
+        throw new PramptaError("Signed v3 receipts require a bound subject, provider, and licensee");
+      }
+      if (!String(payload.output_hash).trim()) {
+        throw new PramptaError("Signed v3 receipts require an output hash");
+      }
+      const body = {
+        v: "pg.receipt.v3",
+        ...payload,
+        subject_id: decision.subjectId,
+        licensee_id: this.licenseeId,
+        provider_id: this.providerId,
+        event_type: eventType
+      };
+      const signature = await ed3.signAsync(
+        new TextEncoder().encode(canonicalJson(body)),
+        hexToBytes(keyHex)
+      );
+      payload.schema_version = "pg.receipt.v3";
+      payload.event_type = eventType;
+      payload.provider_signature = Array.from(signature, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    } else if (result.eventType && result.eventType !== "output_accepted") {
+      throw new PramptaError("A non-default eventType requires a provider signing key and pg.receipt.v3");
+    }
+    return this.post("/v1/receipts/", payload);
+  }
+  // ── C2PA bridge (PRE-GEN v1.1 addendum §11) ─────────────────────────────
+  /**
+   * Get (issuing if needed) the signed `pg.assertion.v1` for a decision this
+   * provider/licensee pair already submitted a receipt for — embed it in
+   * your OWN C2PA manifest (PRAMPTA does not build the manifest itself).
+   * Idempotent: safe to call again for the same decisionId, always returns
+   * the same assertion. Requires `submitReceipt()` to have run first.
+   */
+  async createAssertion(decisionId) {
+    return this.post("/v1/assertions/", { decision_id: decisionId });
+  }
+  /** Fetch a previously issued assertion. Public — no auth required, since a
+   * third party checking a C2PA manifest's embedded assertion needs to
+   * verify it without going through PRAMPTA's own auth. */
+  async getAssertion(decisionId) {
+    return this.get(`/v1/assertions/${decisionId}`);
+  }
+  // ── Anchored audit log (PRE-GEN v1.1 addendum §10) ──────────────────────
+  /** The most recently published Merkle root over the audit log. Public,
+   * unauthenticated. */
+  async getMerkleRoot() {
+    return this.get("/v1/audit/merkle-root");
+  }
+  /** Proof that `eventId` is one of the leaves committed to by a Merkle
+   * root, without downloading the rest of the log. Check it offline with
+   * the standalone `verifyMerkleProof(eventHash, proof, rootHash)` — don't
+   * just trust the 200 response; the proof exists so you don't have to.
+   * Public, unauthenticated. */
+  async getInclusionProof(eventId) {
+    return this.get(`/v1/audit/inclusion-proof/${eventId}`);
   }
   // ── Utility ──────────────────────────────────────────────────────────
   async health() {
@@ -581,7 +1258,7 @@ var Prampta = class _Prampta {
     return this.get("/version");
   }
   static async hashPrompt(prompt) {
-    return sha256(prompt);
+    return sha2562(prompt);
   }
   // ── Internal ─────────────────────────────────────────────────────────
   parseDecision(data) {
@@ -609,14 +1286,25 @@ var Prampta = class _Prampta {
       operatorKeyId: data.operator_key_id || "",
       operatorSignature: data.operator_signature || "",
       subjectAuthority: data.subject_authority || "",
-      denied: !(data.allowed ?? false)
+      denied: !(data.allowed ?? false) && data.disposition !== "not_blocked",
+      disposition: data.disposition ?? (data.allowed === true ? "allow" : "deny"),
+      policyVersion: data.policy_version || "",
+      revocationEpoch: data.revocation_epoch || 0,
+      maxCacheAgeSeconds: data.max_cache_age_seconds || 0,
+      cacheScope: data.cache_scope || "not_cacheable",
+      providerUserBinding: data.provider_user_binding || "unbound",
+      providerIdentityLinkId: data.provider_identity_link_id || "",
+      generationId: data.generation_id || "",
+      detectionId: data.detection_id || "",
+      remediation: data.remediation ?? null
     };
   }
   headers() {
     return {
       "Content-Type": "application/json",
       "X-Provider-ID": this.providerId,
-      "X-Licensee-ID": this.licenseeId,
+      // Omitted without a connected user: a provider-level check.
+      ...this.licenseeId ? { "X-Licensee-ID": this.licenseeId } : {},
       Authorization: `Bearer ${this.token}`
     };
   }
@@ -640,15 +1328,16 @@ var Prampta = class _Prampta {
     }
     throw lastErr;
   }
-  async post(path, payload) {
-    return this.withRetry(() => this.postOnce(path, payload));
+  async post(path, payload, extraHeaders) {
+    return this.withRetry(() => this.postOnce(path, payload, extraHeaders));
   }
-  async postOnce(path, payload) {
+  async postOnce(path, payload, extraHeaders) {
     let resp;
     try {
       resp = await fetch(`${this.baseUrl}${path}`, {
         method: "POST",
-        headers: this.headers(),
+        headers: { ...this.headers(), ...extraHeaders },
+        redirect: "error",
         body: JSON.stringify(payload),
         signal: AbortSignal.timeout(this.timeoutMs)
       });
@@ -663,7 +1352,7 @@ var Prampta = class _Prampta {
         detail = JSON.parse(text).detail ?? text;
       } catch {
       }
-      throw new PramptaApiError(resp.status, String(detail));
+      throw new PramptaApiError(resp.status, typeof detail === "string" ? detail : JSON.stringify(detail));
     }
     return resp.json();
   }
@@ -676,6 +1365,7 @@ var Prampta = class _Prampta {
       resp = await fetch(`${this.baseUrl}${path}`, {
         method: "GET",
         headers: this.headers(),
+        redirect: "error",
         signal: AbortSignal.timeout(this.timeoutMs)
       });
     } catch (e) {
@@ -686,6 +1376,14 @@ var Prampta = class _Prampta {
     return resp.json();
   }
 };
+function sameEndpoint(a, b) {
+  try {
+    const x = new URL(a), y = new URL(b);
+    return x.origin === y.origin && x.pathname.replace(/\/+$/, "") === y.pathname.replace(/\/+$/, "");
+  } catch {
+    return false;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HARD_REFUSAL_CODES,
@@ -695,13 +1393,19 @@ var Prampta = class _Prampta {
   PramptaFailClosedError,
   PramptaNetworkError,
   PramptaRefusalError,
+  PramptaReporter,
   PramptaSchemaError,
   PramptaSignatureError,
   PramptaTimeoutError,
   REFUSAL_DESCRIPTIONS,
+  RegistryDirectoryError,
   SOFT_REFUSAL_CODES,
+  TrustedRegistryDirectory,
   canonicalJson,
   hashPrompt,
+  loadPregenDirectory,
   matchSubjects,
-  normalizeForMatch
+  normalizeForMatch,
+  verifyLicenseSignatures,
+  verifyMerkleProof
 });