@prampta/sdk 0.9.1 → 0.10.0

package/dist/index.js

@@ -42,21 +42,27 @@ __export(index_exports, {
   PramptaSchemaError: () => PramptaSchemaError,
   PramptaSignatureError: () => PramptaSignatureError,
   PramptaTimeoutError: () => PramptaTimeoutError,
+  PregenError: () => PregenError,
   REFUSAL_DESCRIPTIONS: () => REFUSAL_DESCRIPTIONS,
   RegistryDirectoryError: () => RegistryDirectoryError,
   SOFT_REFUSAL_CODES: () => SOFT_REFUSAL_CODES,
   TrustedRegistryDirectory: () => TrustedRegistryDirectory,
   canonicalJson: () => canonicalJson,
+  createPregen: () => createPregen,
   hashPrompt: () => hashPrompt,
   loadPregenDirectory: () => import_verify2.loadDirectory,
   matchSubjects: () => matchSubjects,
+  memoryStore: () => memoryStore,
+  messageId: () => messageId,
   normalizeForMatch: () => normalizeForMatch,
+  postgresStore: () => postgresStore,
+  signingInput: () => signingInput,
   singleProcessJournal: () => singleProcessJournal,
   verifyLicenseSignatures: () => verifyLicenseSignatures,
   verifyMerkleProof: () => verifyMerkleProof
 });
 module.exports = __toCommonJS(index_exports);
-var ed3 = __toESM(require("@noble/ed25519"));
+var ed4 = __toESM(require("@noble/ed25519"));
 
 // src/canonical.ts
 function canonicalJson(obj) {
@@ -268,9 +274,9 @@ var TrustedRegistryDirectory = class _TrustedRegistryDirectory {
 // 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));
+  const bytes = (hex2, size) => {
+    if (typeof hex2 !== "string" || hex2.length !== size * 2 || !/^[0-9a-fA-F]+$/.test(hex2)) throw new TypeError("Invalid hex");
+    return Uint8Array.from(hex2.match(/../g), (s) => parseInt(s, 16));
   };
   let body;
   let subjectSig;
@@ -410,6 +416,376 @@ var PramptaReporter = class {
   }
 };
 
+// src/pregen.ts
+var ed3 = __toESM(require("@noble/ed25519"));
+var PregenError = class extends Error {
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.code = code;
+    this.name = "PregenError";
+  }
+  code;
+};
+var PROFILE = "likeness/1";
+var MAX_LIFETIME = 900;
+var CLOCK_TOLERANCE = 60;
+var JOB_ID = /^[A-Za-z0-9_.:-]{1,100}$/;
+var HEX64 = /^[0-9a-f]{64}$/;
+var STATUSES = /* @__PURE__ */ new Set(["allow", "deny", "review", "not_blocked"]);
+var enc = new TextEncoder();
+var now = () => Math.floor(Date.now() / 1e3);
+var hex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+var unhex = (s) => {
+  if (!/^(?:[0-9a-fA-F]{2})+$/.test(s)) throw new PregenError("PG_MALFORMED", "not hex");
+  return Uint8Array.from(s.match(/../g), (h) => parseInt(h, 16));
+};
+async function sha2562(data) {
+  return hex(new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", data)));
+}
+function signingInput(type, body) {
+  return enc.encode(`PREGEN-V5\0${type}\0${canonicalJson(body)}`);
+}
+function messageId(type, body) {
+  return sha2562(enc.encode(`PREGEN-V5-ID\0${type}\0${canonicalJson(body)}`));
+}
+var keyIdOf = async (pub) => "pg-ed25519:" + (await sha2562(pub)).slice(0, 32);
+async function verifyEnvelope(env, type, role, keys) {
+  const e = env;
+  if (!e || typeof e !== "object" || Object.keys(e).sort().join() !== "body,signatures,type" || e.type !== type || !e.body || typeof e.body !== "object" || !Array.isArray(e.signatures)) {
+    throw new PregenError("PG_MALFORMED", `not a ${type}`);
+  }
+  const s = e.body.signers;
+  const pub = Array.isArray(s) && s.length === 1 && s[0]?.role === role && e.signatures.length === 1 ? keys.get(s[0].key_id) : void 0;
+  if (!pub) throw new PregenError("PG_SIGNATURE", `not signed by a pinned ${role} key`);
+  let ok = false;
+  try {
+    ok = await ed3.verifyAsync(unhex(e.signatures[0]), signingInput(type, e.body), pub);
+  } catch {
+  }
+  if (!ok) throw new PregenError("PG_SIGNATURE", `${type} signature does not verify`);
+  return e.body;
+}
+async function checkAnswer(body, request, at) {
+  if (Array.isArray(body.critical) && body.critical.length) throw new PregenError("PG_CRITICAL", body.critical.join());
+  if (!(body.expires_at - body.issued_at > 0 && body.expires_at - body.issued_at <= MAX_LIFETIME)) throw new PregenError("PG_TIME", "lifetime");
+  if (body.issued_at > at + CLOCK_TOLERANCE) throw new PregenError("PG_TIME", "issued in the future");
+  if (body.request_id !== await messageId("pg.request.v1", request)) throw new PregenError("PG_BINDING", "answer is for another request");
+  if (body.profile !== request.profile) throw new PregenError("PG_BINDING", "profile");
+  if (!STATUSES.has(body.status)) throw new PregenError("PG_MALFORMED", "status");
+  const shaped = body.status === "allow" ? "basis" in body && !("reason" in body) : "reason" in body && !("basis" in body);
+  if (!shaped) throw new PregenError("PG_MALFORMED", "an allow has a basis and no reason; a refusal the reverse");
+}
+function createPregen(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)) throw new PregenError("PG_CONFIG", "use an HTTPS registry URL");
+  if (!config.providerId || !config.token) throw new PregenError("PG_CONFIG", "providerId and token are required");
+  if (!config.store) throw new PregenError("PG_CONFIG", "a store is required (postgresStore(pool), or memoryStore() for one process)");
+  const base = url.origin, mode = config.mode ?? "enforce", timeoutMs = config.timeoutMs ?? 5e3;
+  const providerId = config.providerId, store = config.store;
+  const secret = unhex(config.providerSigningKeyHex);
+  if (secret.length !== 32) throw new PregenError("PG_CONFIG", "providerSigningKeyHex must be a 32-byte Ed25519 private key");
+  const pins = (Array.isArray(config.operatorPublicKeyHex) ? config.operatorPublicKeyHex : config.operatorPublicKeyHex.split(/[\s,]+/)).filter(Boolean);
+  if (!pins.length) throw new PregenError("PG_CONFIG", "operatorPublicKeyHex is required");
+  const ready = (async () => {
+    const registry = /* @__PURE__ */ new Map();
+    for (const p of pins) registry.set(await keyIdOf(unhex(p)), unhex(p));
+    const pub = await ed3.getPublicKeyAsync(secret);
+    return { registry, pub, keyId: await keyIdOf(pub) };
+  })();
+  async function post(path, payload) {
+    const resp = await fetch(base + path, {
+      method: "POST",
+      redirect: "error",
+      signal: AbortSignal.timeout(timeoutMs),
+      body: JSON.stringify(payload),
+      headers: { "Content-Type": "application/json", "X-Provider-ID": providerId, Authorization: `Bearer ${config.token}` }
+    });
+    let data = null;
+    try {
+      data = await resp.json();
+    } catch {
+    }
+    return { status: resp.status, data };
+  }
+  const errorCode = (r) => r.data?.detail?.error ?? `HTTP_${r.status}`;
+  async function seal(type, body) {
+    const { keyId } = await ready;
+    body = { ...body, signers: [{ role: "provider", key_id: keyId }] };
+    return { type, body, signatures: [hex(await ed3.signAsync(signingInput(type, body), secret))] };
+  }
+  async function ask(request) {
+    const { registry } = await ready;
+    let r = null;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      if (attempt) await new Promise((ok) => setTimeout(ok, 200 * 2 ** attempt));
+      try {
+        r = await post("/v2/requests", { type: "pg.request.v1", body: request, signatures: [] });
+      } catch {
+        r = null;
+        continue;
+      }
+      if (r.status !== 429 && r.status < 500) break;
+    }
+    if (!r) return { request, answer: null, error: "PG_UNREACHABLE" };
+    if (r.status !== 200) return { request, answer: null, error: errorCode(r) };
+    const answer = r.data?.answer;
+    try {
+      await verifyEnvelope(answer, "pg.answer.v1", "registry", registry);
+    } catch (e) {
+      return { request, answer: null, error: e instanceof PregenError ? e.code : "PG_MALFORMED" };
+    }
+    try {
+      await checkAnswer(answer.body, request, now());
+      return { request, answer };
+    } catch (e) {
+      const code = e.code;
+      return code === "PG_BINDING" ? { request, answer: null, error: code } : { request, answer, error: code };
+    }
+  }
+  const usableAllow = (a, at) => !a.error && a.answer?.body.status === "allow" && a.answer.body.expires_at > at;
+  async function report(a, outcome, outputHash, applied) {
+    const answer = a.answer ? await messageId("pg.answer.v1", a.answer.body) : null;
+    const required = new Set((a.answer?.body.obligations ?? []).map((o) => o.id));
+    const body = {
+      request_id: await messageId("pg.request.v1", a.request),
+      answer,
+      mode: a.request.mode,
+      job_id: a.request.job_id,
+      outcome,
+      output_hash: outcome === "generated" ? outputHash : "",
+      obligations_applied: outcome === "generated" ? [...new Set(applied)].filter((id) => required.has(id)).sort() : [],
+      occurred_at: now()
+    };
+    if (answer === null) body.request = a.request;
+    return { report: await seal("pg.report.v1", body) };
+  }
+  async function send(job) {
+    const { registry } = await ready;
+    for (const r of job.reports) {
+      if (r.ack || r.rejected) continue;
+      let res;
+      try {
+        res = await post("/v2/reports", r.report);
+      } catch {
+        r.error = "PG_UNREACHABLE";
+        continue;
+      }
+      if (res.status === 409 || res.status === 422) {
+        r.rejected = true;
+        r.error = errorCode(res);
+        continue;
+      }
+      if (res.status !== 200) {
+        r.error = errorCode(res);
+        continue;
+      }
+      try {
+        const ack = await verifyEnvelope(res.data?.ack, "pg.report_ack.v1", "registry", registry);
+        if (ack.report !== await messageId("pg.report.v1", r.report.body)) throw new PregenError("PG_BINDING", "ack for another report");
+        r.ack = res.data.ack;
+        delete r.error;
+      } catch (e) {
+        r.error = e.code ?? "PG_MALFORMED";
+      }
+    }
+    if (job.reports.every((r) => r.ack || r.rejected)) job.stage = "done";
+    await store.put(job);
+    return job;
+  }
+  function result(job, output, detail) {
+    const unknown = job.stage === "claimed" || job.stage === "asked";
+    const conflict = job.reports.some((r) => r.rejected);
+    return {
+      jobId: job.jobId,
+      status: unknown || conflict ? "needs_check" : job.stage === "done" ? "confirmed" : "report_pending",
+      generated: unknown ? null : !!job.generated,
+      ...output !== void 0 ? { output } : {},
+      ...job.outputHash ? { outputHash: job.outputHash } : {},
+      answers: job.asks.map((a) => ({
+        subject: a.request.subject_ref,
+        status: a.answer?.body.status ?? null,
+        ...a.answer?.body.reason ? { reason: a.answer.body.reason } : {},
+        ...a.error ? { error: a.error } : {}
+      })),
+      unmetObligations: job.unmetObligations ?? [],
+      detail: detail ?? (unknown ? "running in another worker, or interrupted: check your generator, then resolve()" : conflict ? "the registry refused a report: see its error" : void 0)
+    };
+  }
+  async function finish(job, generated, outputHash = "", applied = []) {
+    const asks = generated ? job.asks : job.asks.filter((a) => a.answer?.body.status === "allow");
+    job.reports = await Promise.all(asks.map((a) => report(a, generated ? "generated" : "not_generated", outputHash, applied)));
+    job.unmetObligations = generated ? obligationsOf(job).filter((o) => !applied.includes(o.id)) : [];
+    Object.assign(job, { stage: "finished", generated, ...generated ? { outputHash } : {} });
+    await store.put(job);
+    return send(job);
+  }
+  const obligationsOf = (job) => job.asks.flatMap((a) => a.answer && (mode === "observe" || a.answer.body.status === "allow") ? (a.answer.body.obligations ?? []).map((o) => ({ subject: a.request.subject_ref, id: o.id, params: o.params ?? {} })) : []);
+  async function outputHashOf(r) {
+    if (r.outputHash !== void 0) {
+      if (!HEX64.test(r.outputHash)) throw new PregenError("PG_MALFORMED", "outputHash must be 64 lowercase hex characters");
+      return r.outputHash;
+    }
+    if (r.outputBytes === void 0) throw new PregenError("PG_MALFORMED", "return outputHash or outputBytes");
+    return sha2562(typeof r.outputBytes === "string" ? enc.encode(r.outputBytes) : r.outputBytes);
+  }
+  async function run(input, fn) {
+    const subjects = [...new Set(input.subjects)].sort();
+    const promptHash = input.promptHash ?? (input.prompt !== void 0 ? await sha2562(enc.encode(input.prompt)) : "");
+    if (!HEX64.test(promptHash)) throw new PregenError("PG_MALFORMED", "give prompt or a 64-hex promptHash");
+    const use = JSON.parse(JSON.stringify(input.use));
+    const manifest = {
+      job_id: input.jobId,
+      provider_id: providerId,
+      licensee_id: input.licenseeId ?? "",
+      prompt_hash: promptHash,
+      model: input.model,
+      modality: input.modality,
+      mode,
+      asks: subjects.map((s) => ({ subject_ref: s, registry: "", profile: PROFILE, use }))
+    };
+    const jobHash = await sha2562(enc.encode(canonicalJson(manifest)));
+    const fresh = { providerId, jobId: input.jobId, jobHash, stage: "claimed", asks: [], reports: [] };
+    const existing = await store.claim(fresh);
+    if (existing) {
+      if (existing.jobHash !== jobHash) throw new PregenError("PG_JOB_CONFLICT", `job ${input.jobId} was used for another generation`);
+      return result(existing.stage === "finished" ? await send(existing) : existing);
+    }
+    const job = fresh;
+    job.asks = await Promise.all(subjects.map((s) => ask({
+      job_id: input.jobId,
+      job_hash: jobHash,
+      subject_ref: s,
+      provider_id: providerId,
+      licensee_id: manifest.licensee_id,
+      prompt_hash: promptHash,
+      model: input.model,
+      modality: input.modality,
+      profile: PROFILE,
+      use,
+      mode
+    })));
+    job.stage = "asked";
+    await store.put(job);
+    const at = now();
+    if (mode === "enforce" && !job.asks.every((a) => usableAllow(a, at))) return result(await finish(job, false));
+    let out;
+    try {
+      out = await fn({ obligations: obligationsOf(job) });
+    } catch (e) {
+      await finish(job, false);
+      throw e;
+    }
+    const outputHash = await outputHashOf(out);
+    return result(await finish(job, true, outputHash, out.obligationsApplied ?? []), out.output);
+  }
+  return {
+    /** Ask, verify, generate (only when permitted), report. See the module comment. */
+    async generate(input, fn) {
+      if (!JOB_ID.test(input?.jobId ?? "")) throw new PregenError("PG_MALFORMED", "jobId: 1-100 of A-Z a-z 0-9 _ . : -");
+      if (!Array.isArray(input.subjects) || !input.subjects.length) {
+        throw new PregenError("PG_MALFORMED", "subjects: name at least one; with no registered person there is nothing to ask");
+      }
+      return run(input, fn);
+    },
+    /** Resend every report still waiting (after a restart, an outage). Run at startup and every minute or so. */
+    async flush() {
+      const out = [];
+      for (const job of await store.pending(providerId)) out.push(result(await send(job)));
+      return out;
+    },
+    /** Where a job stands, or null if this store never saw it. */
+    async status(jobId) {
+      const job = await store.get(providerId, jobId);
+      return job && result(job);
+    },
+    /** After `needs_check`: record what your generator actually did with this job. */
+    async resolve(jobId, outcome) {
+      const job = await store.get(providerId, jobId);
+      if (!job) throw new PregenError("PG_UNKNOWN_JOB", jobId);
+      if (job.stage === "finished" || job.stage === "done") return result(job.stage === "finished" ? await send(job) : job);
+      if (!outcome.generated) {
+        if (job.stage === "claimed") {
+          Object.assign(job, { stage: "done", generated: false });
+          await store.put(job);
+          return result(job);
+        }
+        return result(await finish(job, false));
+      }
+      if (job.stage === "claimed") throw new PregenError("PG_JOB", "generation cannot have started before the answers were stored");
+      return result(await finish(job, true, await outputHashOf(outcome), outcome.obligationsApplied ?? []));
+    },
+    /** Register this provider's signing key with the registry, once (a `first` keyset, §4.9). */
+    async registerKey() {
+      const { pub, keyId } = await ready;
+      const keyset = await seal("pg.keyset.v1", {
+        kind: "first",
+        provider_id: providerId,
+        previous: null,
+        recovery_registry: "",
+        keys: [{ key_id: keyId, public_key_hex: hex(pub), status: "current" }]
+      });
+      const r = await post("/v2/keys", keyset);
+      if (r.status !== 200) throw new PregenError(errorCode(r), r.data?.detail?.error_description ?? "key not registered");
+      return { keyId };
+    }
+  };
+}
+function memoryStore() {
+  const jobs = /* @__PURE__ */ new Map();
+  const k = (p, j) => `${p}\0${j}`;
+  return {
+    async claim(job) {
+      const found = jobs.get(k(job.providerId, job.jobId));
+      if (found) return structuredClone(found);
+      jobs.set(k(job.providerId, job.jobId), structuredClone(job));
+      return null;
+    },
+    async put(job) {
+      jobs.set(k(job.providerId, job.jobId), structuredClone(job));
+    },
+    async get(p, j) {
+      const f = jobs.get(k(p, j));
+      return f ? structuredClone(f) : null;
+    },
+    async pending(p) {
+      return [...jobs.values()].filter((j) => j.providerId === p && j.stage === "finished").map((j) => structuredClone(j));
+    }
+  };
+}
+function postgresStore(pool) {
+  let ready = null;
+  const q = async (text, values) => {
+    ready ??= pool.query(`CREATE TABLE IF NOT EXISTS pregen_jobs (
+      provider_id text NOT NULL, job_id text NOT NULL, stage text NOT NULL, job jsonb NOT NULL,
+      updated_at timestamptz NOT NULL DEFAULT now(), PRIMARY KEY (provider_id, job_id))`).catch((e) => {
+      ready = null;
+      throw e;
+    });
+    await ready;
+    return (await pool.query(text, values)).rows;
+  };
+  const one = async (p, j) => (await q("SELECT job FROM pregen_jobs WHERE provider_id = $1 AND job_id = $2", [p, j]))[0]?.job ?? null;
+  return {
+    async claim(job) {
+      const won = await q(`INSERT INTO pregen_jobs (provider_id, job_id, stage, job) VALUES ($1, $2, $3, $4)
+        ON CONFLICT DO NOTHING RETURNING job_id`, [job.providerId, job.jobId, job.stage, JSON.stringify(job)]);
+      return won.length ? null : one(job.providerId, job.jobId);
+    },
+    async put(job) {
+      await q(
+        "UPDATE pregen_jobs SET stage = $3, job = $4, updated_at = now() WHERE provider_id = $1 AND job_id = $2",
+        [job.providerId, job.jobId, job.stage, JSON.stringify(job)]
+      );
+    },
+    get: one,
+    async pending(p) {
+      return (await q(`SELECT job FROM pregen_jobs WHERE provider_id = $1 AND stage = 'finished'
+        ORDER BY updated_at LIMIT 100`, [p])).map((r) => r.job);
+    }
+  };
+}
+
 // src/index.ts
 function singleProcessJournal() {
   const entries = /* @__PURE__ */ new Map();
@@ -554,16 +930,16 @@ function envVar(key) {
   return "";
 }
 async function hashPrompt(prompt) {
-  return sha2562(prompt);
+  return sha2563(prompt);
 }
-async function sha2562(input) {
+async function sha2563(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);
+    current = step.position === "right" ? await sha2563(current + step.hash) : await sha2563(step.hash + current);
   }
   return current === rootHash;
 }
@@ -583,13 +959,13 @@ async function sha256Bytes(data) {
   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)) {
+function hexToBytes(hex2) {
+  if (typeof hex2 !== "string" || !/^(?:[0-9a-fA-F]{2})+$/.test(hex2)) {
     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);
+  const bytes = new Uint8Array(hex2.length / 2);
+  for (let i = 0; i < hex2.length; i += 2) {
+    bytes[i / 2] = parseInt(hex2.substring(i, i + 2), 16);
   }
   return bytes;
 }
@@ -741,7 +1117,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 ed3.verifyAsync(hexToBytes(sig), new TextEncoder().encode(canonicalJson(body)), hexToBytes(currentHex));
+        const ok = await ed4.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;
@@ -756,8 +1132,8 @@ var Prampta = class _Prampta {
    * 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;
+    for (const hex2 of this.pinnedKeys) {
+      if (await keyFingerprint(hex2) === keyId) return hex2;
     }
     if (this.pinnedKeys.length > 0) {
       throw new PramptaSignatureError(
@@ -790,11 +1166,11 @@ var Prampta = class _Prampta {
    * 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 now2 = Date.now();
+    if (opts?.forceRefresh || !this.subjectIndexEntries || now2 - this.subjectIndexFetchedAt > _Prampta.SUBJECT_INDEX_TTL_MS) {
       const payload = await this.fetchSubjectIndex();
       this.subjectIndexEntries = payload.subjects || [];
-      this.subjectIndexFetchedAt = now;
+      this.subjectIndexFetchedAt = now2;
     }
     return matchSubjects(text, this.subjectIndexEntries);
   }
@@ -882,7 +1258,7 @@ var Prampta = class _Prampta {
     const sigBytes = hexToBytes(sig);
     let valid;
     try {
-      valid = await ed3.verifyAsync(sigBytes, messageBytes, pubKeyBytes);
+      valid = await ed4.verifyAsync(sigBytes, messageBytes, pubKeyBytes);
     } catch (e) {
       throw new PramptaSignatureError(`Ed25519 verification error: ${e}`);
     }
@@ -891,13 +1267,13 @@ var Prampta = class _Prampta {
         "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) || !Number.isSafeInteger(raw.issued_at) || raw.issued_at <= 0 || raw.expires_at <= raw.issued_at || raw.expires_at - raw.issued_at > 900 || raw.issued_at > now + 60) {
+    const now2 = Math.floor(Date.now() / 1e3);
+    if (!Number.isSafeInteger(raw.expires_at) || !Number.isSafeInteger(raw.issued_at) || raw.issued_at <= 0 || raw.expires_at <= raw.issued_at || raw.expires_at - raw.issued_at > 900 || raw.issued_at > now2 + 60) {
       throw new PramptaSchemaError("Decision has invalid validity timestamps");
     }
-    if (decision.expiresAt <= now) {
+    if (decision.expiresAt <= now2) {
       throw new PramptaSignatureError(
-        `Decision expired at ${decision.expiresAt}, current time ${now}`
+        `Decision expired at ${decision.expiresAt}, current time ${now2}`
       );
     }
   }
@@ -983,7 +1359,7 @@ var Prampta = class _Prampta {
     } : void 0 };
     this.registryDirectory?.assertEndpoint(request.subjectId, this.baseUrl);
     this.assertPregenEndpoint(request.subjectId);
-    const promptHash = request.promptHash || (request.prompt ? await sha2562(request.prompt) : null);
+    const promptHash = request.promptHash || (request.prompt ? await sha2563(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."
@@ -1160,7 +1536,7 @@ var Prampta = class _Prampta {
   /** SHA-256 of everything that defines the job. Same id + different hash = a different job. */
   async requestHash(request) {
     const { generationId, subjectIds, prompt, promptHash, idempotencyKey, returnUrl, detectionId, ...rest } = request;
-    return sha2562(canonicalJson(JSON.parse(JSON.stringify({
+    return sha2563(canonicalJson(JSON.parse(JSON.stringify({
       ...rest,
       generationId,
       subjectIds: [...new Set(subjectIds)].sort(),
@@ -1318,7 +1694,7 @@ var Prampta = class _Prampta {
         provider_id: this.providerId,
         event_type: eventType
       };
-      const signature = await ed3.signAsync(
+      const signature = await ed4.signAsync(
         new TextEncoder().encode(canonicalJson(body)),
         hexToBytes(keyHex)
       );
@@ -1374,7 +1750,7 @@ var Prampta = class _Prampta {
     return this.get("/version");
   }
   static async hashPrompt(prompt) {
-    return sha2562(prompt);
+    return sha2563(prompt);
   }
   // ── Internal ─────────────────────────────────────────────────────────
   parseDecision(data) {
@@ -1514,15 +1890,21 @@ function sameEndpoint(a, b) {
   PramptaSchemaError,
   PramptaSignatureError,
   PramptaTimeoutError,
+  PregenError,
   REFUSAL_DESCRIPTIONS,
   RegistryDirectoryError,
   SOFT_REFUSAL_CODES,
   TrustedRegistryDirectory,
   canonicalJson,
+  createPregen,
   hashPrompt,
   loadPregenDirectory,
   matchSubjects,
+  memoryStore,
+  messageId,
   normalizeForMatch,
+  postgresStore,
+  signingInput,
   singleProcessJournal,
   verifyLicenseSignatures,
   verifyMerkleProof