@prampta/sdk 0.3.2 → 0.7.0

package/dist/index.mjs

@@ -0,0 +1,1266 @@
+// src/index.ts
+import * as ed3 from "@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
+import { checkDecision as pregenCheckDecision, issuerOf as pregenIssuerOf } from "@pregen/verify";
+import { loadDirectory } from "@pregen/verify";
+
+// src/directory.ts
+import * as ed from "@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
+import * as ed2 from "@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);
+    this.name = "PramptaError";
+  }
+};
+var PramptaNetworkError = class extends PramptaError {
+  constructor(cause_) {
+    super(`PRAMPTA backend unreachable: ${cause_}`);
+    this.cause_ = cause_;
+    this.name = "PramptaNetworkError";
+  }
+  cause_;
+};
+var PramptaTimeoutError = class extends PramptaError {
+  constructor(timeoutMs) {
+    super(`PRAMPTA request timed out after ${timeoutMs}ms`);
+    this.timeoutMs = timeoutMs;
+    this.name = "PramptaTimeoutError";
+  }
+  timeoutMs;
+};
+var PramptaApiError = class extends PramptaError {
+  constructor(status, detail) {
+    super(`PRAMPTA API error ${status}: ${detail}`);
+    this.status = status;
+    this.detail = detail;
+    this.name = "PramptaApiError";
+  }
+  status;
+  detail;
+};
+var PramptaSchemaError = class extends PramptaError {
+  constructor(message) {
+    super(`PRAMPTA schema error: ${message}`);
+    this.name = "PramptaSchemaError";
+  }
+};
+var PramptaSignatureError = class extends PramptaError {
+  constructor(message) {
+    super(`PRAMPTA signature verification failed: ${message}`);
+    this.name = "PramptaSignatureError";
+  }
+};
+var PramptaRefusalError = class extends PramptaError {
+  constructor(decision) {
+    const desc = REFUSAL_DESCRIPTIONS[decision.reason || ""] || decision.reason;
+    super(`Generation refused: ${desc}`);
+    this.decision = decision;
+    this.name = "PramptaRefusalError";
+  }
+  decision;
+  get reason() {
+    return this.decision.reason || "UNKNOWN";
+  }
+  get isHardRefusal() {
+    return this.decision.isHardRefusal;
+  }
+  get decisionId() {
+    return this.decision.decisionId;
+  }
+  get licenseId() {
+    return this.decision.licenseId;
+  }
+};
+var PramptaFailClosedError = class extends PramptaError {
+  constructor(cause_) {
+    super(`PRAMPTA fail-closed: generation blocked because verification failed (${cause_})`);
+    this.cause_ = cause_;
+    this.name = "PramptaFailClosedError";
+  }
+  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",
+  PG_SUBJECT_WITHDRAWN: "Subject has been withdrawn from registry",
+  PG_SUBJECT_OPTED_OUT: "Subject has opted out of AI generation",
+  PG_NO_LICENSE: "No valid license for this subject/licensee pair",
+  PG_NO_PAIR: "Provider-licensee pair not established",
+  PG_INVALID_SIGNATURE: "License signature verification failed",
+  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",
+  // 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",
+  // 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_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 sha2562(prompt);
+}
+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) : [];
+}
+async function keyFingerprint(publicKeyHex) {
+  return `pg-ed25519:${(await sha256Bytes(hexToBytes(publicKeyHex))).slice(0, 32)}`;
+}
+async function sha256Bytes(data) {
+  if (typeof globalThis.crypto?.subtle !== "undefined") {
+    const exact = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    const hash = await globalThis.crypto.subtle.digest("SHA-256", exact);
+    return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  const { createHash } = await import("crypto");
+  return createHash("sha256").update(data).digest("hex");
+}
+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);
+  }
+  return bytes;
+}
+var LEET = { "0": "o", "1": "i", "3": "e", "4": "a", "5": "s", "7": "t", "@": "a", "$": "s" };
+var SQUEEZE_MIN = 5;
+function stripDiacritics(t) {
+  let out = "";
+  for (const ch of t.normalize("NFC")) {
+    const base = ch.normalize("NFKD")[0] || ch;
+    if (/[a-zA-Z]/.test(base)) out += base;
+    else out += ch;
+  }
+  return out;
+}
+function normalizeForMatch(text) {
+  let t = stripDiacritics(text.toLowerCase());
+  t = t.replace(/[0134578@$]/g, (c) => LEET[c] || c);
+  return t.replace(/[-_]+/g, " ").replace(/[^\p{L}\p{N} ]+/gu, " ").replace(/ +/g, " ").trim();
+}
+var squeeze = (t) => t.replace(/ /g, "");
+function matchSubjects(text, entries) {
+  const norm = normalizeForMatch(text);
+  const haystack = ` ${norm} `;
+  const squeezedHaystack = squeeze(norm);
+  const hits = [];
+  for (const entry of entries) {
+    const candidates = [entry.subject_id, ...entry.aliases || []];
+    for (const cand of candidates) {
+      const needle = normalizeForMatch(cand);
+      if (!needle) continue;
+      if (haystack.includes(` ${needle} `)) {
+        hits.push(entry);
+        break;
+      }
+      const sq = squeeze(needle);
+      if (sq.length >= SQUEEZE_MIN && squeezedHaystack.includes(sq)) {
+        hits.push(entry);
+        break;
+      }
+    }
+  }
+  return hits;
+}
+var Prampta = class _Prampta {
+  baseUrl;
+  providerId;
+  licenseeId;
+  token;
+  timeoutMs;
+  maxRetries;
+  retryBackoffMs;
+  failClosed;
+  verifySignature;
+  enforce;
+  requireUserBinding;
+  registryDirectory;
+  pregenDirectory;
+  pinnedKeys;
+  keySetCache = null;
+  keySetPromise = null;
+  tofuWarned = false;
+  constructor(config = {}) {
+    this.baseUrl = (config.baseUrl || envVar("PRAMPTA_BASE_URL")).replace(/\/+$/, "");
+    this.providerId = config.providerId || envVar("PRAMPTA_PROVIDER_ID");
+    this.licenseeId = config.licenseeId || envVar("PRAMPTA_LICENSEE_ID");
+    this.token = config.token || envVar("PRAMPTA_TOKEN");
+    this.timeoutMs = config.timeoutMs ?? 3e3;
+    this.maxRetries = Math.max(0, config.maxRetries ?? 2);
+    this.retryBackoffMs = config.retryBackoffMs ?? 200;
+    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.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 {
+      pregenIssuerOf(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. */
+  async fetchVerifiedKeySet() {
+    if (this.keySetCache) return this.keySetCache;
+    if (!this.keySetPromise) {
+      this.keySetPromise = (async () => {
+        const ks = await this.get("/keys");
+        const entries = {};
+        for (const e of ks.keys || []) entries[e.key_id] = e.public_key_hex || "";
+        const currentHex = entries[ks.current_key_id] || "";
+        const sig = ks.signature || "";
+        if (!currentHex || !sig) throw new PramptaSignatureError("Operator key set from /keys is malformed");
+        const body = { ...ks };
+        delete body.signature;
+        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;
+      })();
+    }
+    return this.keySetPromise;
+  }
+  /**
+   * Public key hex to verify a decision signed by `keyId`, enforcing the
+   * pinning trust model. A pinned match returns immediately (no network); an
+   * unpinned key id fails closed in pinned mode; unpinned/TOFU mode resolves
+   * from the self-consistent /keys set with a warning.
+   */
+  async resolveOperatorKey(keyId) {
+    for (const hex of this.pinnedKeys) {
+      if (await keyFingerprint(hex) === keyId) return hex;
+    }
+    if (this.pinnedKeys.length > 0) {
+      throw new PramptaSignatureError(
+        `Decision was signed by operator key '${keyId}', which is not in your pinned set. If PRAMPTA rotated keys, confirm the new key out of band and add it to operatorPublicKeyHex (pin current + next to rotate without downtime). Refusing to trust an unpinned key.`
+      );
+    }
+    const ks = await this.fetchVerifiedKeySet();
+    const entries = {};
+    for (const e of ks.keys || []) entries[e.key_id] = e.public_key_hex || "";
+    const match = entries[keyId];
+    if (!match) {
+      throw new PramptaSignatureError(`Decision key '${keyId}' is not present in the operator key set from /keys.`);
+    }
+    if (!this.tofuWarned) {
+      console.warn(TOFU_WARNING);
+      this.tofuWarned = true;
+    }
+    return match;
+  }
+  // ── Subject Detection ────────────────────────────────────────────────
+  subjectIndexEntries = null;
+  subjectIndexFetchedAt = 0;
+  static SUBJECT_INDEX_TTL_MS = 3e5;
+  /** Fetch the raw subject detection index (/v1/subjects/index). */
+  async fetchSubjectIndex() {
+    return this.get("/v1/subjects/index");
+  }
+  /**
+   * Detect registered subjects mentioned in `text`, using a TTL-cached
+   * copy of the subject index. Call verify()/assertAllowed() per hit.
+   */
+  async matchSubjects(text, opts) {
+    const now = Date.now();
+    if (opts?.forceRefresh || !this.subjectIndexEntries || now - this.subjectIndexFetchedAt > _Prampta.SUBJECT_INDEX_TTL_MS) {
+      const payload = await this.fetchSubjectIndex();
+      this.subjectIndexEntries = payload.subjects || [];
+      this.subjectIndexFetchedAt = now;
+    }
+    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");
+    const keyId = decision.operatorKeyId;
+    if (!keyId) throw new PramptaSignatureError("Decision missing operator_key_id");
+    const pubKeyHex = await this.resolveOperatorKey(keyId);
+    const bodyForSigning = { ...raw };
+    delete bodyForSigning.operator_signature;
+    const canonical = canonicalJson(bodyForSigning);
+    const messageBytes = new TextEncoder().encode(canonical);
+    const pubKeyBytes = hexToBytes(pubKeyHex);
+    const sigBytes = hexToBytes(sig);
+    let valid;
+    try {
+      valid = await ed3.verifyAsync(sigBytes, messageBytes, pubKeyBytes);
+    } catch (e) {
+      throw new PramptaSignatureError(`Ed25519 verification error: ${e}`);
+    }
+    if (!valid) {
+      throw new PramptaSignatureError(
+        "Operator signature is invalid \u2014 decision cannot be trusted. This may indicate a compromised backend, proxy tampering, or key mismatch."
+      );
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    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}`
+      );
+    }
+  }
+  /**
+   * Verify that the signed decision is bound to the correct request context.
+   * Prevents replay attacks where a valid decision for one context is used in another.
+   */
+  verifyContextBinding(decision, expected) {
+    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 !== expected.subjectId) {
+      throw new PramptaSignatureError(
+        `Decision subject_id mismatch: sent ${expected.subjectId}, got ${decision.subjectId}`
+      );
+    }
+    if (decision.providerId !== expected.providerId) {
+      throw new PramptaSignatureError(
+        `Decision provider_id mismatch: sent ${expected.providerId}, got ${decision.providerId}`
+      );
+    }
+    if (decision.licenseeId !== expected.licenseeId) {
+      throw new PramptaSignatureError(
+        `Decision licensee_id mismatch: sent ${expected.licenseeId}, got ${decision.licenseeId}`
+      );
+    }
+    if (decision.modality !== expected.modality) {
+      throw new PramptaSignatureError(
+        `Decision modality mismatch: sent ${expected.modality}, got ${decision.modality}`
+      );
+    }
+    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],
+        ["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) {
+          throw new PramptaSignatureError(`Decision ${name} mismatch: sent ${sent}, got ${got}`);
+        }
+      }
+      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 ${field} mismatch: sent ${[...sentCats].sort()}, got ${[...gotCats].sort()}`
+          );
+        }
+      }
+    }
+  }
+  // ── Core API ─────────────────────────────────────────────────────────
+  async verifyGeneration(request) {
+    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,
+      modality: request.modality || "",
+      model: request.model || "",
+      intended_use: {
+        channel: request.intendedUse?.channel || "",
+        product_name: request.intendedUse?.productName || "",
+        project_name: request.intendedUse?.projectName || "",
+        categories: request.intendedUse?.categories || [],
+        modality: request.modality || "",
+        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, 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,
+        providerId: this.providerId,
+        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 || [],
+          campaignId: request.intendedUse?.campaignId || "",
+          useCase: request.intendedUse?.useCase || "",
+          modality: request.modality || "",
+          rights: request.intendedUse?.rights || []
+        }
+      });
+      if (this.pregenDirectory && decision.disposition === "allow") {
+        try {
+          await pregenCheckDecision(
+            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) {
+        if (e instanceof PramptaRefusalError || e instanceof PramptaSchemaError || e instanceof PramptaSignatureError) {
+          throw e;
+        }
+        throw new PramptaFailClosedError(e);
+      }
+      throw e;
+    }
+  }
+  /** Flat convenience API mirroring the Python SDK: intended-use fields
+   * (categories, channel, productName, …) are accepted at the top level.
+   * 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, campaignId, useCase, rights, intendedUse, ...rest } = options;
+    const iu = intendedUse ?? {
+      ...channel ? { channel } : {},
+      ...productName ? { productName } : {},
+      ...projectName ? { projectName } : {},
+      ...categories ? { categories } : {},
+      ...territory ? { territory } : {},
+      ...campaignId ? { campaignId } : {},
+      ...useCase ? { useCase } : {},
+      ...rights ? { rights } : {}
+    };
+    return this.verifyGeneration({
+      subjectId,
+      ...rest,
+      ...Object.keys(iu).length ? { intendedUse: iu } : {}
+    });
+  }
+  async assertAllowed(subjectId, options = {}) {
+    const decision = await this.verifyGeneration({ subjectId, ...options });
+    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 };
+  }
+  // ── Subject Resolution ───────────────────────────────────────────────
+  async getSubject(subjectId) {
+    this.registryDirectory?.assertEndpoint(subjectId, this.baseUrl);
+    try {
+      const data = await this.get(`/v1/subjects/${encodeURIComponent(subjectId)}`);
+      return {
+        subjectId: data.subject_id,
+        status: data.status,
+        visibility: data.visibility || "public",
+        rulesText: data.rules_text || "",
+        aliases: data.aliases || [],
+        publicKeyHex: data.public_key_hex,
+        registeredAt: data.registered_at
+      };
+    } catch {
+      return null;
+    }
+  }
+  // ── 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,
+      purpose: input.purpose || "",
+      duration_days: input.durationDays || 365,
+      message: input.message || ""
+    });
+    return { requestId: data.request_id, status: data.status };
+  }
+  // ── Provenance / Output Metadata ─────────────────────────────────────
+  createOutputMetadata(decision) {
+    return {
+      prampta_decision_id: decision.decisionId,
+      prampta_license_id: decision.licenseId,
+      prampta_watermark: decision.watermarkPayload,
+      prampta_obligations: decision.obligations,
+      prampta_issued_at: decision.issuedAt
+    };
+  }
+  /**
+   * 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 = {}) {
+    const payload = {
+      decision_id: decision.decisionId,
+      prompt_hash: decision.promptHash,
+      output_hash: result.outputHash ?? "",
+      model: result.model ?? decision.model,
+      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() {
+    try {
+      await this.get("/healthz");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async version() {
+    return this.get("/version");
+  }
+  static async hashPrompt(prompt) {
+    return sha2562(prompt);
+  }
+  // ── Internal ─────────────────────────────────────────────────────────
+  parseDecision(data) {
+    if (!data.decision_id) throw new PramptaSchemaError("Response missing decision_id");
+    return {
+      schemaVersion: data.schema_version || "pg.decision.v1",
+      decisionId: data.decision_id,
+      allowed: data.allowed ?? false,
+      reason: data.reason ?? null,
+      subjectId: data.subject_id || "",
+      licenseeId: data.licensee_id || "",
+      providerId: data.provider_id || "",
+      licenseId: data.license_id ?? null,
+      promptHash: data.prompt_hash || "",
+      model: data.model || "",
+      modality: data.modality || "",
+      intendedUse: data.intended_use || {},
+      obligations: data.obligations || {},
+      rulesText: data.rules_text || "",
+      rulesTextHash: data.rules_text_hash || "",
+      watermarkPayload: data.watermark_payload ?? null,
+      isHardRefusal: data.is_hard_refusal ?? false,
+      issuedAt: data.issued_at || 0,
+      expiresAt: data.expires_at || 0,
+      operatorKeyId: data.operator_key_id || "",
+      operatorSignature: data.operator_signature || "",
+      subjectAuthority: data.subject_authority || "",
+      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,
+      // Omitted without a connected user: a provider-level check.
+      ...this.licenseeId ? { "X-Licensee-ID": this.licenseeId } : {},
+      Authorization: `Bearer ${this.token}`
+    };
+  }
+  /** Transient errors worth retrying: connectivity, timeout, 429, and 5xx. */
+  isRetryable(e) {
+    if (e instanceof PramptaNetworkError || e instanceof PramptaTimeoutError) return true;
+    if (e instanceof PramptaApiError) return e.status >= 500 || e.status === 429;
+    return false;
+  }
+  async withRetry(fn) {
+    let lastErr;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (e) {
+        lastErr = e;
+        if (attempt >= this.maxRetries || !this.isRetryable(e)) throw e;
+        const delay = this.retryBackoffMs * Math.pow(2, attempt);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    throw lastErr;
+  }
+  async post(path, payload, extraHeaders) {
+    return this.withRetry(() => this.postOnce(path, payload, extraHeaders));
+  }
+  async postOnce(path, payload, extraHeaders) {
+    let resp;
+    try {
+      resp = await fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: { ...this.headers(), ...extraHeaders },
+        redirect: "error",
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(this.timeoutMs)
+      });
+    } catch (e) {
+      if (e?.name === "TimeoutError" || e?.name === "AbortError") throw new PramptaTimeoutError(this.timeoutMs);
+      throw new PramptaNetworkError(e);
+    }
+    if (!resp.ok) {
+      const text = await resp.text();
+      let detail = text;
+      try {
+        detail = JSON.parse(text).detail ?? text;
+      } catch {
+      }
+      throw new PramptaApiError(resp.status, String(detail));
+    }
+    return resp.json();
+  }
+  async get(path) {
+    return this.withRetry(() => this.getOnce(path));
+  }
+  async getOnce(path) {
+    let resp;
+    try {
+      resp = await fetch(`${this.baseUrl}${path}`, {
+        method: "GET",
+        headers: this.headers(),
+        redirect: "error",
+        signal: AbortSignal.timeout(this.timeoutMs)
+      });
+    } catch (e) {
+      if (e?.name === "TimeoutError" || e?.name === "AbortError") throw new PramptaTimeoutError(this.timeoutMs);
+      throw new PramptaNetworkError(e);
+    }
+    if (!resp.ok) throw new PramptaApiError(resp.status, await resp.text());
+    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;
+  }
+}
+export {
+  HARD_REFUSAL_CODES,
+  Prampta,
+  PramptaApiError,
+  PramptaError,
+  PramptaFailClosedError,
+  PramptaNetworkError,
+  PramptaRefusalError,
+  PramptaReporter,
+  PramptaSchemaError,
+  PramptaSignatureError,
+  PramptaTimeoutError,
+  REFUSAL_DESCRIPTIONS,
+  RegistryDirectoryError,
+  SOFT_REFUSAL_CODES,
+  TrustedRegistryDirectory,
+  canonicalJson,
+  hashPrompt,
+  loadDirectory as loadPregenDirectory,
+  matchSubjects,
+  normalizeForMatch,
+  verifyLicenseSignatures,
+  verifyMerkleProof
+};