@prampta/sdk 0.8.1 → 0.9.0

package/README.md

@@ -36,7 +36,48 @@ production PRAMPTA deployment running the v1.0.0-default trust posture
 refuses it with `PG_NO_PAIR`. Don't build a new integration against it; it
 exists solely so an already-connected provider keeps working mid-migration.
 
-## Quick Start
+## Quick Start: the safe setup (0.9.0)
+
+One configuration turns on every check: the signed PRE-GEN directory, your
+pinned operator key, and a journal in your own database that lets exactly
+one worker run each job.
+
+```typescript
+import { Prampta, loadPregenDirectory } from "@prampta/sdk";
+
+const pregenDirectory = await loadPregenDirectory({ previous: saved }); // PRE-GEN steward key built in
+const pg = new Prampta({
+  baseUrl: "https://api2.prampta.com", providerId, licenseeId,
+  token: process.env.PRAMPTA_TOKEN,                              // server-side only
+  operatorPublicKeyHex: process.env.PRAMPTA_OPERATOR_PUBLIC_KEY, // obtained independently
+  pregenDirectory,
+});
+
+// The journal's claim must be ATOMIC across all your servers, e.g. in Postgres:
+//   INSERT INTO pg_jobs (id, entry) VALUES ($1, $2) ON CONFLICT (id) DO NOTHING RETURNING id
+//   -- no row returned: SELECT entry FROM pg_jobs WHERE id = $1 and return it
+const journal = {
+  claim: async (entry) => (await db.insertIfAbsent(entry.generationId, entry)) ? null : db.get(entry.generationId),
+  put: async (entry) => db.update(entry.generationId, entry),
+};
+
+const result = await pg.generateAuthorized(
+  { subjectIds: [subjectCode], generationId: jobId, promptHash, model, modality: "image",
+    intendedUse: { useCase: "commercial" } },
+  async (decisions) => {
+    const image = await render(prompt); // apply every decision's obligations
+    return { output: image, outputBytes: image.bytes };
+  },
+  { journal },
+);
+```
+
+`verify`, `assertAllowed` and `assertLicensed` below are lower-level calls:
+they check one decision and leave the job (claiming, retries, receipts) to
+you. Without `pregenDirectory` they check the signature against your pinned
+key, but not the PRE-GEN directory (namespace, revocation).
+
+### Lower-level calls
 
 ```typescript
 import { Prampta } from "@prampta/sdk";
@@ -95,38 +136,30 @@ const decision = await pg.assertLicensed(subjectCode, {
 // Apply the decision's obligations, generate, then submit a receipt.
 ```
 
-## The whole cycle in one call (0.8.0)
-
-`generateAuthorized` does what every integration otherwise writes by hand:
-
-- asks fresh for **every subject in the output** (a person, a voice, a brand…)
-  and generates only if **all** of them return a licence-backed `allow`;
-- never reuses a stored allow, and checks each is still live right before it
-  starts, so a pause or revocation stops the next generation;
-- files one receipt per subject;
+## The whole cycle in one call (0.9.0)
+
+`generateAuthorized` binds one `generationId` to one unchanging request:
+
+- **one worker per job**: the journal's atomic `claim` lets exactly one
+  worker, on any of your servers, run a job; the others get an error;
+- **same id, same request**: a different request under a used
+  `generationId` throws `PramptaJobConflictError`, while running or after;
+- asks fresh for **every subject in the output** and generates only if
+  **all** of them return a licence-backed `allow`;
+- re-checks every allow **immediately before** your `generate` runs;
+- stores the output hash **before** sending receipts, and resends the
+  byte-identical receipt after a failure;
+- a receipt counts as filed only when the registry accepted exactly it:
+  `unreported` lists receipts to resend (call again with the same id and
+  request), `conflicts` lists decisions for which the registry holds a
+  different receipt;
 - gives the allows back (`releaseDecision`) when a subject refuses or your
-  `generate` throws, so a failed job does not use up a licence limit;
-- with a `journal` (your own database), never generates twice after a crash:
-  a repeat call resends missing receipts, or refuses a job that crashed
-  midway instead of rerunning it.
-
-```typescript
-const result = await pg.generateAuthorized(
-  { subjectIds: [personCode, voiceCode], generationId: jobId, promptHash,
-    modality: "video", model: modelName,
-    intendedUse: { useCase: "commercial", rights: ["output_generation"] } },
-  async (decisions) => {
-    // Apply every decision's obligations here. Throw only if nothing was produced.
-    const video = await render(prompt);
-    return { output: video, outputBytes: video.bytes };
-  },
-  { journal: { get: (id) => db.jobs.get(id), put: (e) => db.jobs.put(e) } },
-);
-if (result.unreported.length) retryLater(jobId); // receipts are resent by calling again
-```
+  `generate` throws; that job is then closed, use a new `generationId`;
+- never reruns a job that may have started generating.
 
-It uses `assertLicensed` (pinned operator keys required). The journal needs
-`put` to resolve only after a durable write.
+`singleProcessJournal()` is an in-memory journal for tests and a single
+process; two servers each holding one can both run a job. 0.9.0 replaced the
+journal's `get` with `claim` and made the journal required.
 
 ## Check answers against PRE-GEN (recommended)
 
@@ -180,9 +213,10 @@ Persisted `previousSnapshot` detects rollback and signed different-content
 snapshots at the same sequence. `minSequence` is also available for a sequence
 floor alone. Storage and concurrent update serialization belong to the host.
 
-The public steward key is still pending: do not obtain a trust anchor from
-the directory itself or invent a production key. An authenticated directory
-snapshot does not prove freshness, key non-revocation or rights-holder consent;
+The PRE-GEN steward key is published (pregen.org, DNS) and built into
+`@pregen/verify`; for that directory use `loadPregenDirectory()` above. With
+your own root, never take the trust anchor from the directory itself. An
+authenticated directory snapshot does not prove freshness or rights-holder consent;
 `minSequence` alone does not prevent stale first-boot snapshots. Full live
 federation needs the separately specified trust-management work.
 

package/dist/index.d.mts

@@ -383,23 +383,37 @@ interface LicenseRequestResult {
     requestId: string;
     status: string;
 }
-/** One generation as `generateAuthorized` records it. Stored by the
- * provider, in its own database, so a crash never leads to generating twice. */
+type AuthorizedRequest = Omit<VerifyRequest, "subjectId" | "generationId"> & {
+    subjectIds: string[];
+    generationId: string;
+};
+/** One job as `generateAuthorized` records it in the provider's own database. */
 interface GenerationJournalEntry {
     generationId: string;
-    /** authorized: allows held, generation may have started.
-     * generated: output exists, receipts may be missing.
-     * reported: receipts filed. released: nothing produced, allows given back. */
-    stage: "authorized" | "generated" | "reported" | "released";
+    /** SHA-256 of the request; the same generationId with another request is an error. */
+    requestHash: string;
+    /** claimed: one worker owns the job. authorized: allows held, generation may
+     * have started. generated: output exists, receipts may be missing.
+     * reported: receipts accepted. released: nothing produced, allows given back. */
+    stage: "claimed" | "authorized" | "generated" | "reported" | "released";
     decisions: SignedDecision[];
     outputHash?: string;
+    /** Kept so a resent receipt is byte-identical to the first. */
+    generatedAt?: number;
 }
 interface GenerationJournal {
-    get(generationId: string): Promise<GenerationJournalEntry | null>;
-    /** Resolve only after a durable write. */
+    /** ATOMIC across every worker: store `entry` if no entry exists for its
+     * generationId and return null; otherwise change nothing and return the
+     * existing entry. E.g. INSERT ... ON CONFLICT DO NOTHING, then SELECT.
+     * A read followed by a write is not enough. */
+    claim(entry: GenerationJournalEntry): Promise<GenerationJournalEntry | null>;
+    /** Replace the entry for its generationId. Resolve only after a durable write. */
     put(entry: GenerationJournalEntry): Promise<void>;
 }
-type ReceiptOptions = Omit<NonNullable<Parameters<Prampta["submitReceipt"]>[1]>, "outputHash">;
+/** An in-memory journal. Correct for ONE process only: two servers each
+ * holding one can both run the same job. Use your shared database otherwise. */
+declare function singleProcessJournal(): GenerationJournal;
+type ReceiptOptions = Omit<NonNullable<Parameters<Prampta["submitReceipt"]>[1]>, "outputHash" | "generatedAt">;
 interface AuthorizedGeneration<T> {
     /** generated: ran now. recovered: output existed from an earlier run, only
      * receipts were sent. already_reported: nothing left to do. */
@@ -409,9 +423,12 @@ interface AuthorizedGeneration<T> {
     output?: T;
     decisions: SignedDecision[];
     outputHash: string;
-    /** Receipts that could not be filed yet. Call again with the same
-     * generationId (needs a journal) or submitReceipt() for each. */
+    /** Receipts not filed yet (network, server error). Call again with the same
+     * generationId and request to resend them. */
     unreported: SignedDecision[];
+    /** The registry already holds a DIFFERENT receipt for these decisions.
+     * Resending will not help; find out why. */
+    conflicts: SignedDecision[];
 }
 interface OutputMetadata {
     prampta_decision_id: string;
@@ -451,6 +468,11 @@ declare class PramptaRefusalError extends PramptaError {
     get decisionId(): string;
     get licenseId(): string | null;
 }
+/** The same generationId was used for a different request. */
+declare class PramptaJobConflictError extends PramptaError {
+    readonly generationId: string;
+    constructor(generationId: string);
+}
 declare class PramptaFailClosedError extends PramptaError {
     readonly cause_: unknown;
     constructor(cause_: unknown);
@@ -593,36 +615,35 @@ declare class Prampta {
         metadata: OutputMetadata;
     }>;
     /**
-     * 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.
+     * The whole cycle in one call, for every subject in the output (PRE-GEN P-9):
+     * ask fresh for each subject, require a licence-backed allow from all of
+     * them, generate, file one receipt per subject.
      *
-     * `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.
+     * One `generationId` is bound to one unchanging request. The journal's
+     * atomic `claim` lets exactly one worker run a job, across every server
+     * that shares the journal; a different request under a used id is an
+     * error. Every allow is re-checked immediately before `generate` runs. The
+     * output hash is stored before receipts are sent, and a receipt counts as
+     * filed only when the registry accepted exactly it. A job that may have
+     * started generating is never run again: check your own records,
+     * releaseDecision() if nothing was produced, and use a new generationId.
+     * If a subject refuses or `generate` throws, the allows are given back.
+     * `generate` must throw only when nothing was produced.
      */
-    generateAuthorized<T>(request: Omit<VerifyRequest, "subjectId" | "generationId"> & {
-        subjectIds: string[];
-        generationId: string;
-    }, generate: (decisions: SignedDecision[]) => Promise<{
+    generateAuthorized<T>(request: AuthorizedRequest, generate: (decisions: SignedDecision[]) => Promise<{
         output: T;
         outputHash?: string;
         outputBytes?: Uint8Array | string;
-    }>, options?: {
-        journal?: GenerationJournal;
+    }>, options: {
+        journal: GenerationJournal;
         receipt?: ReceiptOptions;
     }): Promise<AuthorizedGeneration<T>>;
+    /** SHA-256 of everything that defines the job. Same id + different hash = a different job. */
+    private requestHash;
     private runAuthorized;
-    /** Returns the decisions whose receipt could not be filed. A receipt that
-     * already exists (an earlier attempt landed) counts as filed. */
-    private fileReceipts;
-    /** True when every allow was given back. */
-    private releaseAll;
+    private report;
+    /** Release every allow; the job is marked released only when all of them were given back. */
+    private giveBack;
     /** 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. */
@@ -680,4 +701,4 @@ declare class Prampta {
     private getOnce;
 }
 
-export { type AuthorizedGeneration, type DeliveryResult, type GenerationJournal, type GenerationJournalEntry, HARD_REFUSAL_CODES, type LicenseRequestInput, type LicenseRequestResult, type LicenseSignatureInput, type Observation, type ObservationOutbox, type OutputMetadata, Prampta, PramptaApiError, type PramptaConfig, PramptaError, PramptaFailClosedError, PramptaNetworkError, PramptaRefusalError, PramptaReporter, PramptaSchemaError, PramptaSignatureError, PramptaTimeoutError, REFUSAL_DESCRIPTIONS, type ReceiptOptions, RegistryDirectoryError, type RegistryDirectoryOptions, type ReportInput, SOFT_REFUSAL_CODES, type SignedDecision, type SubjectIndexEntry, type SubjectInfo, TrustedRegistryDirectory, type VerifyOptions, type VerifyRequest, canonicalJson, hashPrompt, matchSubjects, normalizeForMatch, verifyLicenseSignatures, verifyMerkleProof };
+export { type AuthorizedGeneration, type AuthorizedRequest, type DeliveryResult, type GenerationJournal, type GenerationJournalEntry, HARD_REFUSAL_CODES, type LicenseRequestInput, type LicenseRequestResult, type LicenseSignatureInput, type Observation, type ObservationOutbox, type OutputMetadata, Prampta, PramptaApiError, type PramptaConfig, PramptaError, PramptaFailClosedError, PramptaJobConflictError, PramptaNetworkError, PramptaRefusalError, PramptaReporter, PramptaSchemaError, PramptaSignatureError, PramptaTimeoutError, REFUSAL_DESCRIPTIONS, type ReceiptOptions, RegistryDirectoryError, type RegistryDirectoryOptions, type ReportInput, SOFT_REFUSAL_CODES, type SignedDecision, type SubjectIndexEntry, type SubjectInfo, TrustedRegistryDirectory, type VerifyOptions, type VerifyRequest, canonicalJson, hashPrompt, matchSubjects, normalizeForMatch, singleProcessJournal, verifyLicenseSignatures, verifyMerkleProof };

package/dist/index.d.ts

@@ -383,23 +383,37 @@ interface LicenseRequestResult {
     requestId: string;
     status: string;
 }
-/** One generation as `generateAuthorized` records it. Stored by the
- * provider, in its own database, so a crash never leads to generating twice. */
+type AuthorizedRequest = Omit<VerifyRequest, "subjectId" | "generationId"> & {
+    subjectIds: string[];
+    generationId: string;
+};
+/** One job as `generateAuthorized` records it in the provider's own database. */
 interface GenerationJournalEntry {
     generationId: string;
-    /** authorized: allows held, generation may have started.
-     * generated: output exists, receipts may be missing.
-     * reported: receipts filed. released: nothing produced, allows given back. */
-    stage: "authorized" | "generated" | "reported" | "released";
+    /** SHA-256 of the request; the same generationId with another request is an error. */
+    requestHash: string;
+    /** claimed: one worker owns the job. authorized: allows held, generation may
+     * have started. generated: output exists, receipts may be missing.
+     * reported: receipts accepted. released: nothing produced, allows given back. */
+    stage: "claimed" | "authorized" | "generated" | "reported" | "released";
     decisions: SignedDecision[];
     outputHash?: string;
+    /** Kept so a resent receipt is byte-identical to the first. */
+    generatedAt?: number;
 }
 interface GenerationJournal {
-    get(generationId: string): Promise<GenerationJournalEntry | null>;
-    /** Resolve only after a durable write. */
+    /** ATOMIC across every worker: store `entry` if no entry exists for its
+     * generationId and return null; otherwise change nothing and return the
+     * existing entry. E.g. INSERT ... ON CONFLICT DO NOTHING, then SELECT.
+     * A read followed by a write is not enough. */
+    claim(entry: GenerationJournalEntry): Promise<GenerationJournalEntry | null>;
+    /** Replace the entry for its generationId. Resolve only after a durable write. */
     put(entry: GenerationJournalEntry): Promise<void>;
 }
-type ReceiptOptions = Omit<NonNullable<Parameters<Prampta["submitReceipt"]>[1]>, "outputHash">;
+/** An in-memory journal. Correct for ONE process only: two servers each
+ * holding one can both run the same job. Use your shared database otherwise. */
+declare function singleProcessJournal(): GenerationJournal;
+type ReceiptOptions = Omit<NonNullable<Parameters<Prampta["submitReceipt"]>[1]>, "outputHash" | "generatedAt">;
 interface AuthorizedGeneration<T> {
     /** generated: ran now. recovered: output existed from an earlier run, only
      * receipts were sent. already_reported: nothing left to do. */
@@ -409,9 +423,12 @@ interface AuthorizedGeneration<T> {
     output?: T;
     decisions: SignedDecision[];
     outputHash: string;
-    /** Receipts that could not be filed yet. Call again with the same
-     * generationId (needs a journal) or submitReceipt() for each. */
+    /** Receipts not filed yet (network, server error). Call again with the same
+     * generationId and request to resend them. */
     unreported: SignedDecision[];
+    /** The registry already holds a DIFFERENT receipt for these decisions.
+     * Resending will not help; find out why. */
+    conflicts: SignedDecision[];
 }
 interface OutputMetadata {
     prampta_decision_id: string;
@@ -451,6 +468,11 @@ declare class PramptaRefusalError extends PramptaError {
     get decisionId(): string;
     get licenseId(): string | null;
 }
+/** The same generationId was used for a different request. */
+declare class PramptaJobConflictError extends PramptaError {
+    readonly generationId: string;
+    constructor(generationId: string);
+}
 declare class PramptaFailClosedError extends PramptaError {
     readonly cause_: unknown;
     constructor(cause_: unknown);
@@ -593,36 +615,35 @@ declare class Prampta {
         metadata: OutputMetadata;
     }>;
     /**
-     * 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.
+     * The whole cycle in one call, for every subject in the output (PRE-GEN P-9):
+     * ask fresh for each subject, require a licence-backed allow from all of
+     * them, generate, file one receipt per subject.
      *
-     * `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.
+     * One `generationId` is bound to one unchanging request. The journal's
+     * atomic `claim` lets exactly one worker run a job, across every server
+     * that shares the journal; a different request under a used id is an
+     * error. Every allow is re-checked immediately before `generate` runs. The
+     * output hash is stored before receipts are sent, and a receipt counts as
+     * filed only when the registry accepted exactly it. A job that may have
+     * started generating is never run again: check your own records,
+     * releaseDecision() if nothing was produced, and use a new generationId.
+     * If a subject refuses or `generate` throws, the allows are given back.
+     * `generate` must throw only when nothing was produced.
      */
-    generateAuthorized<T>(request: Omit<VerifyRequest, "subjectId" | "generationId"> & {
-        subjectIds: string[];
-        generationId: string;
-    }, generate: (decisions: SignedDecision[]) => Promise<{
+    generateAuthorized<T>(request: AuthorizedRequest, generate: (decisions: SignedDecision[]) => Promise<{
         output: T;
         outputHash?: string;
         outputBytes?: Uint8Array | string;
-    }>, options?: {
-        journal?: GenerationJournal;
+    }>, options: {
+        journal: GenerationJournal;
         receipt?: ReceiptOptions;
     }): Promise<AuthorizedGeneration<T>>;
+    /** SHA-256 of everything that defines the job. Same id + different hash = a different job. */
+    private requestHash;
     private runAuthorized;
-    /** Returns the decisions whose receipt could not be filed. A receipt that
-     * already exists (an earlier attempt landed) counts as filed. */
-    private fileReceipts;
-    /** True when every allow was given back. */
-    private releaseAll;
+    private report;
+    /** Release every allow; the job is marked released only when all of them were given back. */
+    private giveBack;
     /** 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. */
@@ -680,4 +701,4 @@ declare class Prampta {
     private getOnce;
 }
 
-export { type AuthorizedGeneration, type DeliveryResult, type GenerationJournal, type GenerationJournalEntry, HARD_REFUSAL_CODES, type LicenseRequestInput, type LicenseRequestResult, type LicenseSignatureInput, type Observation, type ObservationOutbox, type OutputMetadata, Prampta, PramptaApiError, type PramptaConfig, PramptaError, PramptaFailClosedError, PramptaNetworkError, PramptaRefusalError, PramptaReporter, PramptaSchemaError, PramptaSignatureError, PramptaTimeoutError, REFUSAL_DESCRIPTIONS, type ReceiptOptions, RegistryDirectoryError, type RegistryDirectoryOptions, type ReportInput, SOFT_REFUSAL_CODES, type SignedDecision, type SubjectIndexEntry, type SubjectInfo, TrustedRegistryDirectory, type VerifyOptions, type VerifyRequest, canonicalJson, hashPrompt, matchSubjects, normalizeForMatch, verifyLicenseSignatures, verifyMerkleProof };
+export { type AuthorizedGeneration, type AuthorizedRequest, type DeliveryResult, type GenerationJournal, type GenerationJournalEntry, HARD_REFUSAL_CODES, type LicenseRequestInput, type LicenseRequestResult, type LicenseSignatureInput, type Observation, type ObservationOutbox, type OutputMetadata, Prampta, PramptaApiError, type PramptaConfig, PramptaError, PramptaFailClosedError, PramptaJobConflictError, PramptaNetworkError, PramptaRefusalError, PramptaReporter, PramptaSchemaError, PramptaSignatureError, PramptaTimeoutError, REFUSAL_DESCRIPTIONS, type ReceiptOptions, RegistryDirectoryError, type RegistryDirectoryOptions, type ReportInput, SOFT_REFUSAL_CODES, type SignedDecision, type SubjectIndexEntry, type SubjectInfo, TrustedRegistryDirectory, type VerifyOptions, type VerifyRequest, canonicalJson, hashPrompt, matchSubjects, normalizeForMatch, singleProcessJournal, verifyLicenseSignatures, verifyMerkleProof };

package/dist/index.js

@@ -35,6 +35,7 @@ __export(index_exports, {
   PramptaApiError: () => PramptaApiError,
   PramptaError: () => PramptaError,
   PramptaFailClosedError: () => PramptaFailClosedError,
+  PramptaJobConflictError: () => PramptaJobConflictError,
   PramptaNetworkError: () => PramptaNetworkError,
   PramptaRefusalError: () => PramptaRefusalError,
   PramptaReporter: () => PramptaReporter,
@@ -50,6 +51,7 @@ __export(index_exports, {
   loadPregenDirectory: () => import_verify2.loadDirectory,
   matchSubjects: () => matchSubjects,
   normalizeForMatch: () => normalizeForMatch,
+  singleProcessJournal: () => singleProcessJournal,
   verifyLicenseSignatures: () => verifyLicenseSignatures,
   verifyMerkleProof: () => verifyMerkleProof
 });
@@ -409,6 +411,20 @@ var PramptaReporter = class {
 };
 
 // src/index.ts
+function singleProcessJournal() {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    async claim(entry) {
+      const found = entries.get(entry.generationId);
+      if (found) return structuredClone(found);
+      entries.set(entry.generationId, structuredClone(entry));
+      return null;
+    },
+    async put(entry) {
+      entries.set(entry.generationId, structuredClone(entry));
+    }
+  };
+}
 var PramptaError = class extends Error {
   constructor(message) {
     super(message);
@@ -474,6 +490,14 @@ var PramptaRefusalError = class extends PramptaError {
     return this.decision.licenseId;
   }
 };
+var PramptaJobConflictError = class extends PramptaError {
+  constructor(generationId) {
+    super(`generationId ${generationId} was already used for a different request`);
+    this.generationId = generationId;
+    this.name = "PramptaJobConflictError";
+  }
+  generationId;
+};
 var PramptaFailClosedError = class extends PramptaError {
   constructor(cause_) {
     super(`PRAMPTA fail-closed: generation blocked because verification failed (${cause_})`);
@@ -609,6 +633,42 @@ function matchSubjects(text, entries) {
   }
   return hits;
 }
+var UNDERSTOOD_DECISION_MEMBERS = /* @__PURE__ */ new Set([
+  "schema_version",
+  "decision_id",
+  "nonce",
+  "disposition",
+  "allowed",
+  "reason",
+  "policy_version",
+  "subject_id",
+  "licensee_id",
+  "provider_id",
+  "license_id",
+  "prompt_hash",
+  "model",
+  "modality",
+  "intended_use",
+  "obligations",
+  "generation_id",
+  "issued_at",
+  "expires_at",
+  "critical",
+  "operator_key_id",
+  "operator_signature",
+  "subject_authority",
+  "rules_text",
+  "rules_text_hash",
+  "watermark_payload",
+  "is_hard_refusal",
+  "revocation_epoch",
+  "max_cache_age_seconds",
+  "cache_scope",
+  "provider_user_binding",
+  "provider_identity_link_id",
+  "detection_id",
+  "remediation"
+]);
 var Prampta = class _Prampta {
   baseUrl;
   providerId;
@@ -777,6 +837,11 @@ var Prampta = class _Prampta {
    */
   async verifyDecision(raw, decision) {
     if (typeof raw.allowed !== "boolean") throw new PramptaSchemaError("allowed must be a boolean");
+    if (raw.critical !== void 0) {
+      if (!Array.isArray(raw.critical)) throw new PramptaSchemaError("critical must be an array");
+      const unknown = raw.critical.filter((m) => typeof m !== "string" || !UNDERSTOOD_DECISION_MEMBERS.has(m));
+      if (unknown.length) throw new PramptaSchemaError(`Decision lists critical members this SDK does not understand: ${unknown.join(", ")}`);
+    }
     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");
@@ -827,7 +892,7 @@ var Prampta = class _Prampta {
       );
     }
     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)) {
+    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) {
       throw new PramptaSchemaError("Decision has invalid validity timestamps");
     }
     if (decision.expiresAt <= now) {
@@ -1062,86 +1127,101 @@ var Prampta = class _Prampta {
     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.
+   * The whole cycle in one call, for every subject in the output (PRE-GEN P-9):
+   * ask fresh for each subject, require a licence-backed allow from all of
+   * them, generate, file one receipt per subject.
    *
-   * `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.
+   * One `generationId` is bound to one unchanging request. The journal's
+   * atomic `claim` lets exactly one worker run a job, across every server
+   * that shares the journal; a different request under a used id is an
+   * error. Every allow is re-checked immediately before `generate` runs. The
+   * output hash is stored before receipts are sent, and a receipt counts as
+   * filed only when the registry accepted exactly it. A job that may have
+   * started generating is never run again: check your own records,
+   * releaseDecision() if nothing was produced, and use a new generationId.
+   * If a subject refuses or `generate` throws, the allows are given back.
+   * `generate` must throw only when nothing was produced.
    */
-  async generateAuthorized(request, generate, options = {}) {
+  async generateAuthorized(request, generate, options) {
     const id = request.generationId;
     if (!id) throw new PramptaSchemaError("generateAuthorized requires a generationId");
+    if (!options?.journal) throw new PramptaSchemaError("generateAuthorized requires a journal (singleProcessJournal() for one process)");
+    const requestHash = await this.requestHash(request);
     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);
+    if (running) {
+      if (running.requestHash !== requestHash) throw new PramptaJobConflictError(id);
+      return running.run;
+    }
+    const run = this.runAuthorized(request, requestHash, generate, options).finally(() => this.inFlight.delete(id));
+    this.inFlight.set(id, { requestHash, run });
     return run;
   }
-  async runAuthorized(request, generate, { journal, receipt }) {
+  /** 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({
+      ...rest,
+      generationId,
+      subjectIds: [...new Set(subjectIds)].sort(),
+      promptHash: promptHash ?? (prompt !== void 0 ? await hashPrompt(prompt) : ""),
+      providerId: this.providerId,
+      licenseeId: this.licenseeId
+    }))));
+  }
+  async runAuthorized(request, requestHash, 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 existing = await journal.claim({ generationId, requestHash, stage: "claimed", decisions: [] });
+    if (existing) {
+      if (existing.requestHash !== requestHash) throw new PramptaJobConflictError(generationId);
+      if (existing.stage === "reported") {
+        return { status: "already_reported", decisions: existing.decisions, outputHash: existing.outputHash ?? "", unreported: [], conflicts: [] };
+      }
+      if (existing.stage === "generated") return this.report(journal, existing, "recovered", void 0, receipt);
+      throw new PramptaError(existing.stage === "released" ? `Generation ${generationId} produced nothing and its allows were given back; use a new generationId` : `Generation ${generationId} is running elsewhere or was interrupted after it was claimed; it is not run again. If nothing was produced, releaseDecision() each decision and use a new generationId.`);
     }
     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");
+      await this.giveBack(journal, { generationId, requestHash, stage: "claimed", decisions }, "another subject in the same output was refused");
       throw failed.reason;
     }
+    const entry = { generationId, requestHash, stage: "authorized", decisions };
+    await journal.put(entry);
     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 this.giveBack(journal, entry, "expired before generation started");
+      throw new PramptaError("An authorization expired before generation started; ask again with a new generationId");
     }
-    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 });
-      }
+      await this.giveBack(journal, entry, "generation failed");
       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));
+    const generated = { ...entry, stage: "generated", outputHash, generatedAt: Math.floor(Date.now() / 1e3) };
+    await journal.put(generated);
+    return this.report(journal, generated, "generated", result.output, receipt);
+  }
+  async report(journal, entry, status, output, receipt) {
+    const results = await Promise.allSettled(entry.decisions.map((d) => this.submitReceipt(d, { ...receipt, outputHash: entry.outputHash ?? "", generatedAt: entry.generatedAt })));
+    const unreported = [], conflicts = [];
+    results.forEach((r, i) => {
+      if (r.status === "fulfilled") return;
+      (r.reason instanceof PramptaApiError && r.reason.status === 409 ? conflicts : unreported).push(entry.decisions[i]);
     });
+    if (!unreported.length && !conflicts.length) await journal.put({ ...entry, stage: "reported" });
+    return { status, output, decisions: entry.decisions, outputHash: entry.outputHash ?? "", unreported, conflicts };
   }
-  /** 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));
+  /** Release every allow; the job is marked released only when all of them were given back. */
+  async giveBack(journal, entry, reason) {
+    const results = await Promise.allSettled(entry.decisions.map((d) => this.releaseDecision(d.decisionId, reason)));
+    const all = results.every((r) => r.status === "fulfilled" || r.reason instanceof PramptaApiError && r.reason.status === 409 && /nothing_to_release/.test(r.reason.detail));
+    if (all) await journal.put({ ...entry, stage: "released" });
   }
   /** 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
@@ -1416,6 +1496,7 @@ function sameEndpoint(a, b) {
   PramptaApiError,
   PramptaError,
   PramptaFailClosedError,
+  PramptaJobConflictError,
   PramptaNetworkError,
   PramptaRefusalError,
   PramptaReporter,
@@ -1431,6 +1512,7 @@ function sameEndpoint(a, b) {
   loadPregenDirectory,
   matchSubjects,
   normalizeForMatch,
+  singleProcessJournal,
   verifyLicenseSignatures,
   verifyMerkleProof
 });

package/dist/index.mjs

@@ -354,6 +354,20 @@ var PramptaReporter = class {
 };
 
 // src/index.ts
+function singleProcessJournal() {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    async claim(entry) {
+      const found = entries.get(entry.generationId);
+      if (found) return structuredClone(found);
+      entries.set(entry.generationId, structuredClone(entry));
+      return null;
+    },
+    async put(entry) {
+      entries.set(entry.generationId, structuredClone(entry));
+    }
+  };
+}
 var PramptaError = class extends Error {
   constructor(message) {
     super(message);
@@ -419,6 +433,14 @@ var PramptaRefusalError = class extends PramptaError {
     return this.decision.licenseId;
   }
 };
+var PramptaJobConflictError = class extends PramptaError {
+  constructor(generationId) {
+    super(`generationId ${generationId} was already used for a different request`);
+    this.generationId = generationId;
+    this.name = "PramptaJobConflictError";
+  }
+  generationId;
+};
 var PramptaFailClosedError = class extends PramptaError {
   constructor(cause_) {
     super(`PRAMPTA fail-closed: generation blocked because verification failed (${cause_})`);
@@ -554,6 +576,42 @@ function matchSubjects(text, entries) {
   }
   return hits;
 }
+var UNDERSTOOD_DECISION_MEMBERS = /* @__PURE__ */ new Set([
+  "schema_version",
+  "decision_id",
+  "nonce",
+  "disposition",
+  "allowed",
+  "reason",
+  "policy_version",
+  "subject_id",
+  "licensee_id",
+  "provider_id",
+  "license_id",
+  "prompt_hash",
+  "model",
+  "modality",
+  "intended_use",
+  "obligations",
+  "generation_id",
+  "issued_at",
+  "expires_at",
+  "critical",
+  "operator_key_id",
+  "operator_signature",
+  "subject_authority",
+  "rules_text",
+  "rules_text_hash",
+  "watermark_payload",
+  "is_hard_refusal",
+  "revocation_epoch",
+  "max_cache_age_seconds",
+  "cache_scope",
+  "provider_user_binding",
+  "provider_identity_link_id",
+  "detection_id",
+  "remediation"
+]);
 var Prampta = class _Prampta {
   baseUrl;
   providerId;
@@ -722,6 +780,11 @@ var Prampta = class _Prampta {
    */
   async verifyDecision(raw, decision) {
     if (typeof raw.allowed !== "boolean") throw new PramptaSchemaError("allowed must be a boolean");
+    if (raw.critical !== void 0) {
+      if (!Array.isArray(raw.critical)) throw new PramptaSchemaError("critical must be an array");
+      const unknown = raw.critical.filter((m) => typeof m !== "string" || !UNDERSTOOD_DECISION_MEMBERS.has(m));
+      if (unknown.length) throw new PramptaSchemaError(`Decision lists critical members this SDK does not understand: ${unknown.join(", ")}`);
+    }
     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");
@@ -772,7 +835,7 @@ var Prampta = class _Prampta {
       );
     }
     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)) {
+    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) {
       throw new PramptaSchemaError("Decision has invalid validity timestamps");
     }
     if (decision.expiresAt <= now) {
@@ -1007,86 +1070,101 @@ var Prampta = class _Prampta {
     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.
+   * The whole cycle in one call, for every subject in the output (PRE-GEN P-9):
+   * ask fresh for each subject, require a licence-backed allow from all of
+   * them, generate, file one receipt per subject.
    *
-   * `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.
+   * One `generationId` is bound to one unchanging request. The journal's
+   * atomic `claim` lets exactly one worker run a job, across every server
+   * that shares the journal; a different request under a used id is an
+   * error. Every allow is re-checked immediately before `generate` runs. The
+   * output hash is stored before receipts are sent, and a receipt counts as
+   * filed only when the registry accepted exactly it. A job that may have
+   * started generating is never run again: check your own records,
+   * releaseDecision() if nothing was produced, and use a new generationId.
+   * If a subject refuses or `generate` throws, the allows are given back.
+   * `generate` must throw only when nothing was produced.
    */
-  async generateAuthorized(request, generate, options = {}) {
+  async generateAuthorized(request, generate, options) {
     const id = request.generationId;
     if (!id) throw new PramptaSchemaError("generateAuthorized requires a generationId");
+    if (!options?.journal) throw new PramptaSchemaError("generateAuthorized requires a journal (singleProcessJournal() for one process)");
+    const requestHash = await this.requestHash(request);
     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);
+    if (running) {
+      if (running.requestHash !== requestHash) throw new PramptaJobConflictError(id);
+      return running.run;
+    }
+    const run = this.runAuthorized(request, requestHash, generate, options).finally(() => this.inFlight.delete(id));
+    this.inFlight.set(id, { requestHash, run });
     return run;
   }
-  async runAuthorized(request, generate, { journal, receipt }) {
+  /** 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({
+      ...rest,
+      generationId,
+      subjectIds: [...new Set(subjectIds)].sort(),
+      promptHash: promptHash ?? (prompt !== void 0 ? await hashPrompt(prompt) : ""),
+      providerId: this.providerId,
+      licenseeId: this.licenseeId
+    }))));
+  }
+  async runAuthorized(request, requestHash, 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 existing = await journal.claim({ generationId, requestHash, stage: "claimed", decisions: [] });
+    if (existing) {
+      if (existing.requestHash !== requestHash) throw new PramptaJobConflictError(generationId);
+      if (existing.stage === "reported") {
+        return { status: "already_reported", decisions: existing.decisions, outputHash: existing.outputHash ?? "", unreported: [], conflicts: [] };
+      }
+      if (existing.stage === "generated") return this.report(journal, existing, "recovered", void 0, receipt);
+      throw new PramptaError(existing.stage === "released" ? `Generation ${generationId} produced nothing and its allows were given back; use a new generationId` : `Generation ${generationId} is running elsewhere or was interrupted after it was claimed; it is not run again. If nothing was produced, releaseDecision() each decision and use a new generationId.`);
     }
     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");
+      await this.giveBack(journal, { generationId, requestHash, stage: "claimed", decisions }, "another subject in the same output was refused");
       throw failed.reason;
     }
+    const entry = { generationId, requestHash, stage: "authorized", decisions };
+    await journal.put(entry);
     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 this.giveBack(journal, entry, "expired before generation started");
+      throw new PramptaError("An authorization expired before generation started; ask again with a new generationId");
     }
-    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 });
-      }
+      await this.giveBack(journal, entry, "generation failed");
       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));
+    const generated = { ...entry, stage: "generated", outputHash, generatedAt: Math.floor(Date.now() / 1e3) };
+    await journal.put(generated);
+    return this.report(journal, generated, "generated", result.output, receipt);
+  }
+  async report(journal, entry, status, output, receipt) {
+    const results = await Promise.allSettled(entry.decisions.map((d) => this.submitReceipt(d, { ...receipt, outputHash: entry.outputHash ?? "", generatedAt: entry.generatedAt })));
+    const unreported = [], conflicts = [];
+    results.forEach((r, i) => {
+      if (r.status === "fulfilled") return;
+      (r.reason instanceof PramptaApiError && r.reason.status === 409 ? conflicts : unreported).push(entry.decisions[i]);
     });
+    if (!unreported.length && !conflicts.length) await journal.put({ ...entry, stage: "reported" });
+    return { status, output, decisions: entry.decisions, outputHash: entry.outputHash ?? "", unreported, conflicts };
   }
-  /** 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));
+  /** Release every allow; the job is marked released only when all of them were given back. */
+  async giveBack(journal, entry, reason) {
+    const results = await Promise.allSettled(entry.decisions.map((d) => this.releaseDecision(d.decisionId, reason)));
+    const all = results.every((r) => r.status === "fulfilled" || r.reason instanceof PramptaApiError && r.reason.status === 409 && /nothing_to_release/.test(r.reason.detail));
+    if (all) await journal.put({ ...entry, stage: "released" });
   }
   /** 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
@@ -1360,6 +1438,7 @@ export {
   PramptaApiError,
   PramptaError,
   PramptaFailClosedError,
+  PramptaJobConflictError,
   PramptaNetworkError,
   PramptaRefusalError,
   PramptaReporter,
@@ -1375,6 +1454,7 @@ export {
   loadDirectory as loadPregenDirectory,
   matchSubjects,
   normalizeForMatch,
+  singleProcessJournal,
   verifyLicenseSignatures,
   verifyMerkleProof
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prampta/sdk",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "PRAMPTA SDK — authorization before generation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "@noble/ed25519": "^3.1.0",
-    "@pregen/verify": "^0.5.0"
+    "@pregen/verify": "^0.6.0"
   },
   "repository": {
     "type": "git",