@prampta/sdk 0.9.0 → 0.10.0

package/README.md

@@ -13,7 +13,7 @@ support is not claimed: CommonJS loads the ESM-only crypto dependency through
 [`require(esm)`](https://nodejs.org/en/blog/release/v20.19.0). Local ESM/CommonJS
 smoke tests run on Node 22.20; a wider runtime/browser matrix is still a release gate.
 
-This README describes SDK 0.7.0.
+This README describes SDK 0.10.0; sections name the version that added them.
 In older 0.4.0, `assertAllowed` throws on
 personal-use `not_blocked` and `PramptaReporter` is unavailable. Use `verify()`
 and inspect `disposition` when supporting older installations;
@@ -36,6 +36,86 @@ 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.
 
+## PRE-GEN v5: one setup, one call (0.10.0, `/v2`)
+
+`createPregen` speaks the simplified PRE-GEN v5 formats at `/v2`: signed
+answers bound to your request, signed reports, signed acknowledgements. Set it
+up once; wrap each generation in one call.
+
+```typescript
+import pg from "pg";
+import { createPregen, postgresStore } from "@prampta/sdk";
+
+const pregen = createPregen({
+  baseUrl: "https://api2.prampta.com",
+  providerId: "my-ai",
+  token: process.env.PRAMPTA_TOKEN!,                      // your exchange_secret, server-side only
+  providerSigningKeyHex: process.env.PREGEN_SIGNING_KEY!, // your Ed25519 private key (32 bytes hex): signs your reports
+  operatorPublicKeyHex: process.env.PRAMPTA_OPERATOR_PUBLIC_KEY!, // obtained independently, not from the API
+  store: postgresStore(new pg.Pool()),                    // shared by all your workers; creates table pregen_jobs
+});
+
+await pregen.registerKey();                    // once: registers your public key with the registry
+setInterval(() => pregen.flush(), 60_000);     // and at startup: resends reports still waiting
+
+const result = await pregen.generate(
+  { jobId: task.id,                            // YOUR stable task id: a retry reuses it, a new generation gets a new one
+    subjects: ["PGXX-..."],                    // everyone in the output
+    prompt, model: "my-model", modality: "image", use: { purpose: "commercial" },
+    licenseeId },                              // the connected user, or omit for a provider-level request
+  async ({ obligations }) => {
+    const image = await render(prompt, obligations);   // YOU apply the obligations (watermark, disclosure...)
+    return { output: image, outputBytes: image.bytes, obligationsApplied: obligations.map((o) => o.id) };
+  },
+);
+```
+
+**What one call does.** Asks the registry about every subject under one job
+hash; verifies every answer (your pinned key, bound to your request, times);
+in `enforce` mode generates only when **all** subjects allow, re-checking
+right before your function runs; stores the outcome and the signed reports
+**before** sending them; counts a report as filed only when the registry's
+signed acknowledgement of exactly it verifies. Refused, or your function
+threw: nothing is generated and every allow is given back.
+
+**The result tells you where the job stands:**
+
+| `status` | Meaning | What you do |
+|---|---|---|
+| `confirmed` | Finished; every report acknowledged. `generated` says whether it generated. | Nothing. |
+| `report_pending` | Finished; a report has not been acknowledged yet (network, outage). | Nothing: `flush()` resends it, byte for byte. |
+| `needs_check` | The outcome is unknown: the job was interrupted after it may have started generating, or is running in another worker; or the registry refused a report for good. | Check your generator for this `jobId`, then `pregen.resolve(jobId, { generated: true, outputBytes })` or `{ generated: false }`. |
+
+The same `jobId` never generates twice: calling again returns where the job
+stands. The same `jobId` with a different generation is refused
+(`PG_JOB_CONFLICT`). The SDK never guesses whether an interrupted generation
+finished; only your generator knows, so it asks you.
+
+**Obligations** are handed to your function and listed in the report as you
+declare them in `obligationsApplied`; any you did not apply come back in
+`unmetObligations`. How to apply a watermark or a disclosure depends on your
+medium (image, video, audio) and is yours to implement.
+
+**Which subjects.** You name them. Matching names in a prompt
+(`matchSubjects`) only suggests candidates; faces, voices and uploaded
+references are for your own pipeline to identify.
+
+**`observe` mode** (`mode: "observe"`): generates whatever the answers say and
+reports every generation. Nothing is blocked and nothing is granted: use it
+to trial the integration, then switch to `enforce`; nothing else changes.
+
+**Your signing key.** Reports must be signed. `registerKey()` sends a `first`
+keyset signed by the key it names. After that, the registry also requires
+your `/v1` receipts to be signed with the same key (`providerSigningKeyHex`
+in `submitReceipt`). Rotation is not available yet.
+
+**Stores.** `postgresStore(pool)` takes any node-postgres `Pool` or `Client`
+(the `pg` package is yours; the SDK does not depend on it). `memoryStore()`
+is for tests and a single process: it is lost on restart.
+
+Not in this release: Python, other stores, several registries in one job,
+key rotation.
+
 ## Quick Start: the safe setup (0.9.0)
 
 One configuration turns on every check: the signed PRE-GEN directory, your
@@ -147,8 +227,11 @@ const decision = await pg.assertLicensed(subjectCode, {
 - 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;
+- takes its own copy of the request before doing anything, so changing your
+  object afterwards cannot change the job;
+- stores the output hash and the **exact receipts** (signed, if you sign)
+  before sending them, and after a failure resends those receipts byte for
+  byte — receipt options passed on a later call do not replace them;
 - 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

package/dist/index.d.mts

@@ -122,6 +122,159 @@ declare class PramptaReporter {
     deliver(event: Observation): Promise<DeliveryResult>;
 }
 
+type Envelope = {
+    type: string;
+    body: Record<string, any>;
+    signatures: string[];
+};
+type Purpose = "personal" | "educational" | "research" | "editorial" | "commercial";
+interface Obligation {
+    subject: string;
+    id: string;
+    params: Record<string, unknown>;
+}
+interface PregenConfig {
+    baseUrl: string;
+    providerId: string;
+    /** Your runtime credential (`exchange_secret`). */
+    token: string;
+    /** Your Ed25519 private key, 32 bytes hex. Signs reports; register its public key once with `registerKey()`. */
+    providerSigningKeyHex: string;
+    /** The registry's public key(s), hex, obtained from its documentation, not from its API. */
+    operatorPublicKeyHex: string | string[];
+    store: PregenStore;
+    /** `enforce` (default): generate only when every subject allows. `observe`: generate anyway and report; nothing is blocked or granted. */
+    mode?: "enforce" | "observe";
+    timeoutMs?: number;
+}
+interface PregenJobInput {
+    /** Your own stable id for this generation, e.g. your task id. Calling again with the same id
+     * never generates twice; a new generation needs a new id. */
+    jobId: string;
+    /** PRE-GEN codes of everyone in the output. Name matching can suggest them; you decide. */
+    subjects: string[];
+    /** Hashed locally; never sent. */
+    prompt?: string;
+    promptHash?: string;
+    model: string;
+    modality: string;
+    use: {
+        purpose: Purpose;
+        rights?: string[];
+        territory?: string;
+        channel?: string;
+    };
+    /** The connected end user's licensee id; empty for a provider-level request. */
+    licenseeId?: string;
+}
+type GenerateFn<T> = (ctx: {
+    obligations: Obligation[];
+}) => Promise<{
+    output: T;
+    /** One of these is required: the SHA-256 of the output, or the bytes to hash. */
+    outputHash?: string;
+    outputBytes?: Uint8Array | string;
+    /** Ids of the obligations you applied (watermark, disclosure...). */
+    obligationsApplied?: string[];
+}>;
+interface AskResult {
+    subject: string;
+    status: "allow" | "deny" | "review" | "not_blocked" | null;
+    reason?: string;
+    /** Why the answer is missing or unusable: PG_UNREACHABLE, PG_SIGNATURE, PG_TIME, PG_BINDING... */
+    error?: string;
+}
+interface PregenResult<T = unknown> {
+    jobId: string;
+    /** confirmed: finished, every report acknowledged. report_pending: finished, a report waits
+     * for acknowledgement; `flush()` resends it. needs_check: the outcome is unknown (interrupted,
+     * or running in another worker) or the registry holds a different report; check, then `resolve()`. */
+    status: "confirmed" | "report_pending" | "needs_check";
+    /** null while the outcome is unknown. */
+    generated: boolean | null;
+    /** Only from the call that generated. */
+    output?: T;
+    outputHash?: string;
+    answers: AskResult[];
+    /** Obligations the answers set that `obligationsApplied` did not list. */
+    unmetObligations: Obligation[];
+    detail?: string;
+}
+/** One job as the store keeps it. */
+interface PregenJob {
+    providerId: string;
+    jobId: string;
+    /** SHA-256 of the manifest; the same job id with another manifest is refused. */
+    jobHash: string;
+    /** claimed: one worker owns it. asked: answers stored, generation may have started.
+     * finished: outcome and signed reports stored, some not acknowledged. done: nothing left to send. */
+    stage: "claimed" | "asked" | "finished" | "done";
+    asks: {
+        request: Record<string, any>;
+        answer: Envelope | null;
+        error?: string;
+    }[];
+    generated?: boolean;
+    outputHash?: string;
+    unmetObligations?: Obligation[];
+    /** `rejected`: the registry refused this report for good (it holds a different one, or found it malformed). */
+    reports: {
+        report: Envelope;
+        ack?: Envelope;
+        rejected?: boolean;
+        error?: string;
+    }[];
+}
+interface PregenStore {
+    /** ATOMIC across every worker: store `job` if none exists for (providerId, jobId) and return
+     * null; otherwise change nothing and return the existing job. */
+    claim(job: PregenJob): Promise<PregenJob | null>;
+    /** Replace the job. Resolve only after a durable write. */
+    put(job: PregenJob): Promise<void>;
+    get(providerId: string, jobId: string): Promise<PregenJob | null>;
+    /** Jobs in stage `finished`, oldest first. */
+    pending(providerId: string): Promise<PregenJob[]>;
+}
+declare class PregenError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+declare function signingInput(type: string, body: Record<string, unknown>): Uint8Array;
+/** The id of a message: covers type and body, not signatures. */
+declare function messageId(type: string, body: Record<string, unknown>): Promise<string>;
+declare function createPregen(config: PregenConfig): {
+    /** Ask, verify, generate (only when permitted), report. See the module comment. */
+    generate<T>(input: PregenJobInput, fn: GenerateFn<T>): Promise<PregenResult<T>>;
+    /** Resend every report still waiting (after a restart, an outage). Run at startup and every minute or so. */
+    flush(): Promise<PregenResult[]>;
+    /** Where a job stands, or null if this store never saw it. */
+    status(jobId: string): Promise<PregenResult | null>;
+    /** After `needs_check`: record what your generator actually did with this job. */
+    resolve(jobId: string, outcome: {
+        generated: false;
+    } | {
+        generated: true;
+        outputHash?: string;
+        outputBytes?: Uint8Array | string;
+        obligationsApplied?: string[];
+    }): Promise<PregenResult>;
+    /** Register this provider's signing key with the registry, once (a `first` keyset, §4.9). */
+    registerKey(): Promise<{
+        keyId: string;
+    }>;
+};
+type Pregen = ReturnType<typeof createPregen>;
+/** In memory. Correct for ONE process only, and lost on restart: tests and trials. */
+declare function memoryStore(): PregenStore;
+/** Anything with node-postgres' `query(text, values)`: a `pg` Pool or Client. */
+interface PgQueryable {
+    query(text: string, values?: unknown[]): Promise<{
+        rows: any[];
+    }>;
+}
+/** Postgres, shared by every worker. Creates its table `pregen_jobs` on first use. */
+declare function postgresStore(pool: PgQueryable): PregenStore;
+
 /**
  * PRAMPTA SDK for TypeScript / Node.js
  *
@@ -398,8 +551,10 @@ interface GenerationJournalEntry {
     stage: "claimed" | "authorized" | "generated" | "reported" | "released";
     decisions: SignedDecision[];
     outputHash?: string;
-    /** Kept so a resent receipt is byte-identical to the first. */
     generatedAt?: number;
+    /** The exact receipt bodies (signed, if a key was given), stored before the
+     * first send and resent unchanged. No private key is stored. */
+    receipts?: Record<string, Record<string, unknown>>;
 }
 interface GenerationJournal {
     /** ATOMIC across every worker: store `entry` if no entry exists for its
@@ -666,6 +821,8 @@ declare class Prampta {
         /** 32-byte Ed25519 private key, hex; keep server-side. Never sent to PRAMPTA. */
         providerSigningKeyHex?: string;
     }): Promise<Record<string, unknown>>;
+    /** The exact receipt body submitReceipt() would send, signed if a key is given. */
+    buildReceipt(decision: SignedDecision, result?: NonNullable<Parameters<Prampta["submitReceipt"]>[1]>): Promise<Record<string, unknown>>;
     /**
      * Get (issuing if needed) the signed `pg.assertion.v1` for a decision this
      * provider/licensee pair already submitted a receipt for — embed it in
@@ -701,4 +858,4 @@ declare class Prampta {
     private getOnce;
 }
 
-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 };
+export { type AskResult, type AuthorizedGeneration, type AuthorizedRequest, type DeliveryResult, type Envelope, type GenerateFn, type GenerationJournal, type GenerationJournalEntry, HARD_REFUSAL_CODES, type LicenseRequestInput, type LicenseRequestResult, type LicenseSignatureInput, type Obligation, type Observation, type ObservationOutbox, type OutputMetadata, type PgQueryable, Prampta, PramptaApiError, type PramptaConfig, PramptaError, PramptaFailClosedError, PramptaJobConflictError, PramptaNetworkError, PramptaRefusalError, PramptaReporter, PramptaSchemaError, PramptaSignatureError, PramptaTimeoutError, type Pregen, type PregenConfig, PregenError, type PregenJob, type PregenJobInput, type PregenResult, type PregenStore, type Purpose, REFUSAL_DESCRIPTIONS, type ReceiptOptions, RegistryDirectoryError, type RegistryDirectoryOptions, type ReportInput, SOFT_REFUSAL_CODES, type SignedDecision, type SubjectIndexEntry, type SubjectInfo, TrustedRegistryDirectory, type VerifyOptions, type VerifyRequest, canonicalJson, createPregen, hashPrompt, matchSubjects, memoryStore, messageId, normalizeForMatch, postgresStore, signingInput, singleProcessJournal, verifyLicenseSignatures, verifyMerkleProof };

package/dist/index.d.ts

@@ -122,6 +122,159 @@ declare class PramptaReporter {
     deliver(event: Observation): Promise<DeliveryResult>;
 }
 
+type Envelope = {
+    type: string;
+    body: Record<string, any>;
+    signatures: string[];
+};
+type Purpose = "personal" | "educational" | "research" | "editorial" | "commercial";
+interface Obligation {
+    subject: string;
+    id: string;
+    params: Record<string, unknown>;
+}
+interface PregenConfig {
+    baseUrl: string;
+    providerId: string;
+    /** Your runtime credential (`exchange_secret`). */
+    token: string;
+    /** Your Ed25519 private key, 32 bytes hex. Signs reports; register its public key once with `registerKey()`. */
+    providerSigningKeyHex: string;
+    /** The registry's public key(s), hex, obtained from its documentation, not from its API. */
+    operatorPublicKeyHex: string | string[];
+    store: PregenStore;
+    /** `enforce` (default): generate only when every subject allows. `observe`: generate anyway and report; nothing is blocked or granted. */
+    mode?: "enforce" | "observe";
+    timeoutMs?: number;
+}
+interface PregenJobInput {
+    /** Your own stable id for this generation, e.g. your task id. Calling again with the same id
+     * never generates twice; a new generation needs a new id. */
+    jobId: string;
+    /** PRE-GEN codes of everyone in the output. Name matching can suggest them; you decide. */
+    subjects: string[];
+    /** Hashed locally; never sent. */
+    prompt?: string;
+    promptHash?: string;
+    model: string;
+    modality: string;
+    use: {
+        purpose: Purpose;
+        rights?: string[];
+        territory?: string;
+        channel?: string;
+    };
+    /** The connected end user's licensee id; empty for a provider-level request. */
+    licenseeId?: string;
+}
+type GenerateFn<T> = (ctx: {
+    obligations: Obligation[];
+}) => Promise<{
+    output: T;
+    /** One of these is required: the SHA-256 of the output, or the bytes to hash. */
+    outputHash?: string;
+    outputBytes?: Uint8Array | string;
+    /** Ids of the obligations you applied (watermark, disclosure...). */
+    obligationsApplied?: string[];
+}>;
+interface AskResult {
+    subject: string;
+    status: "allow" | "deny" | "review" | "not_blocked" | null;
+    reason?: string;
+    /** Why the answer is missing or unusable: PG_UNREACHABLE, PG_SIGNATURE, PG_TIME, PG_BINDING... */
+    error?: string;
+}
+interface PregenResult<T = unknown> {
+    jobId: string;
+    /** confirmed: finished, every report acknowledged. report_pending: finished, a report waits
+     * for acknowledgement; `flush()` resends it. needs_check: the outcome is unknown (interrupted,
+     * or running in another worker) or the registry holds a different report; check, then `resolve()`. */
+    status: "confirmed" | "report_pending" | "needs_check";
+    /** null while the outcome is unknown. */
+    generated: boolean | null;
+    /** Only from the call that generated. */
+    output?: T;
+    outputHash?: string;
+    answers: AskResult[];
+    /** Obligations the answers set that `obligationsApplied` did not list. */
+    unmetObligations: Obligation[];
+    detail?: string;
+}
+/** One job as the store keeps it. */
+interface PregenJob {
+    providerId: string;
+    jobId: string;
+    /** SHA-256 of the manifest; the same job id with another manifest is refused. */
+    jobHash: string;
+    /** claimed: one worker owns it. asked: answers stored, generation may have started.
+     * finished: outcome and signed reports stored, some not acknowledged. done: nothing left to send. */
+    stage: "claimed" | "asked" | "finished" | "done";
+    asks: {
+        request: Record<string, any>;
+        answer: Envelope | null;
+        error?: string;
+    }[];
+    generated?: boolean;
+    outputHash?: string;
+    unmetObligations?: Obligation[];
+    /** `rejected`: the registry refused this report for good (it holds a different one, or found it malformed). */
+    reports: {
+        report: Envelope;
+        ack?: Envelope;
+        rejected?: boolean;
+        error?: string;
+    }[];
+}
+interface PregenStore {
+    /** ATOMIC across every worker: store `job` if none exists for (providerId, jobId) and return
+     * null; otherwise change nothing and return the existing job. */
+    claim(job: PregenJob): Promise<PregenJob | null>;
+    /** Replace the job. Resolve only after a durable write. */
+    put(job: PregenJob): Promise<void>;
+    get(providerId: string, jobId: string): Promise<PregenJob | null>;
+    /** Jobs in stage `finished`, oldest first. */
+    pending(providerId: string): Promise<PregenJob[]>;
+}
+declare class PregenError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+declare function signingInput(type: string, body: Record<string, unknown>): Uint8Array;
+/** The id of a message: covers type and body, not signatures. */
+declare function messageId(type: string, body: Record<string, unknown>): Promise<string>;
+declare function createPregen(config: PregenConfig): {
+    /** Ask, verify, generate (only when permitted), report. See the module comment. */
+    generate<T>(input: PregenJobInput, fn: GenerateFn<T>): Promise<PregenResult<T>>;
+    /** Resend every report still waiting (after a restart, an outage). Run at startup and every minute or so. */
+    flush(): Promise<PregenResult[]>;
+    /** Where a job stands, or null if this store never saw it. */
+    status(jobId: string): Promise<PregenResult | null>;
+    /** After `needs_check`: record what your generator actually did with this job. */
+    resolve(jobId: string, outcome: {
+        generated: false;
+    } | {
+        generated: true;
+        outputHash?: string;
+        outputBytes?: Uint8Array | string;
+        obligationsApplied?: string[];
+    }): Promise<PregenResult>;
+    /** Register this provider's signing key with the registry, once (a `first` keyset, §4.9). */
+    registerKey(): Promise<{
+        keyId: string;
+    }>;
+};
+type Pregen = ReturnType<typeof createPregen>;
+/** In memory. Correct for ONE process only, and lost on restart: tests and trials. */
+declare function memoryStore(): PregenStore;
+/** Anything with node-postgres' `query(text, values)`: a `pg` Pool or Client. */
+interface PgQueryable {
+    query(text: string, values?: unknown[]): Promise<{
+        rows: any[];
+    }>;
+}
+/** Postgres, shared by every worker. Creates its table `pregen_jobs` on first use. */
+declare function postgresStore(pool: PgQueryable): PregenStore;
+
 /**
  * PRAMPTA SDK for TypeScript / Node.js
  *
@@ -398,8 +551,10 @@ interface GenerationJournalEntry {
     stage: "claimed" | "authorized" | "generated" | "reported" | "released";
     decisions: SignedDecision[];
     outputHash?: string;
-    /** Kept so a resent receipt is byte-identical to the first. */
     generatedAt?: number;
+    /** The exact receipt bodies (signed, if a key was given), stored before the
+     * first send and resent unchanged. No private key is stored. */
+    receipts?: Record<string, Record<string, unknown>>;
 }
 interface GenerationJournal {
     /** ATOMIC across every worker: store `entry` if no entry exists for its
@@ -666,6 +821,8 @@ declare class Prampta {
         /** 32-byte Ed25519 private key, hex; keep server-side. Never sent to PRAMPTA. */
         providerSigningKeyHex?: string;
     }): Promise<Record<string, unknown>>;
+    /** The exact receipt body submitReceipt() would send, signed if a key is given. */
+    buildReceipt(decision: SignedDecision, result?: NonNullable<Parameters<Prampta["submitReceipt"]>[1]>): Promise<Record<string, unknown>>;
     /**
      * Get (issuing if needed) the signed `pg.assertion.v1` for a decision this
      * provider/licensee pair already submitted a receipt for — embed it in
@@ -701,4 +858,4 @@ declare class Prampta {
     private getOnce;
 }
 
-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 };
+export { type AskResult, type AuthorizedGeneration, type AuthorizedRequest, type DeliveryResult, type Envelope, type GenerateFn, type GenerationJournal, type GenerationJournalEntry, HARD_REFUSAL_CODES, type LicenseRequestInput, type LicenseRequestResult, type LicenseSignatureInput, type Obligation, type Observation, type ObservationOutbox, type OutputMetadata, type PgQueryable, Prampta, PramptaApiError, type PramptaConfig, PramptaError, PramptaFailClosedError, PramptaJobConflictError, PramptaNetworkError, PramptaRefusalError, PramptaReporter, PramptaSchemaError, PramptaSignatureError, PramptaTimeoutError, type Pregen, type PregenConfig, PregenError, type PregenJob, type PregenJobInput, type PregenResult, type PregenStore, type Purpose, REFUSAL_DESCRIPTIONS, type ReceiptOptions, RegistryDirectoryError, type RegistryDirectoryOptions, type ReportInput, SOFT_REFUSAL_CODES, type SignedDecision, type SubjectIndexEntry, type SubjectInfo, TrustedRegistryDirectory, type VerifyOptions, type VerifyRequest, canonicalJson, createPregen, hashPrompt, matchSubjects, memoryStore, messageId, normalizeForMatch, postgresStore, signingInput, singleProcessJournal, verifyLicenseSignatures, verifyMerkleProof };