@e-sig/core 0.4.0

package/CONSUMING.md

@@ -0,0 +1,97 @@
+# Consuming `@e-sig/core`
+
+How to install and use this package in another project. It is a self-contained,
+dependency-light PKCS#7 PDF signing core — no SaaS, no metering, no per-document
+fees — extracted from the Opendelphi production e-signature pipeline.
+
+## Install
+
+Published to the public npm registry — no auth or registry config needed:
+
+```sh
+npm install @e-sig/core
+```
+
+Runtime requirements: Node ≥ 20, ESM. The only crypto dependencies are
+`node-forge` and the `@signpdf/*` packages (declared as dependencies).
+`@sparticuz/chromium` is an optional peer (only needed for `renderHtmlToPdf` on
+Lambda/Vercel).
+
+## Minimal sign + verify
+
+```ts
+import { generateSelfSignedCert, signPdf, verifyPdfStructure } from "@e-sig/core";
+
+const { keyPem, certPem } = generateSelfSignedCert({ subjectName: "Acme" });
+const { signedPdf } = await signPdf({
+  pdf, keyPem, certPem,
+  reason: "Agreement", location: "example.org",
+  contactInfo: "legal@acme.org", name: "Acme",
+});
+const v = verifyPdfStructure(signedPdf); // { ok, signerCommonName, ... }
+```
+
+## RFC 3161 trusted timestamps (CAdES-T)
+
+Pass a `tsa` transport to upgrade the signature from CAdES-B to CAdES-T by
+embedding an RFC 3161 TimeStampToken (`id-aa-timeStampToken`,
+OID `1.2.840.113549.1.9.16.2.14`) over the SignerInfo signatureValue.
+
+**The consumer injects the network POST.** The package never performs egress
+itself, which keeps it dependency-free and keeps egress under your control. The
+TSA only ever receives a **SHA-256 hash** — never the document, never any PHI.
+
+```ts
+import type { TsaTransport } from "@e-sig/core";
+
+const tsa: TsaTransport = {
+  required: false, // false → degrade to CAdES-B on failure; true → throw
+  fetch: async (reqDerBytes) => {
+    const res = await fetch("http://timestamp.digicert.com", {
+      method: "POST",
+      headers: { "Content-Type": "application/timestamp-query" },
+      body: reqDerBytes,
+    });
+    if (!res.ok) throw new Error(`TSA HTTP ${res.status}`);
+    return new Uint8Array(await res.arrayBuffer());
+  },
+};
+
+const { signedPdf, timestamped, tsaError } = await signPdf({
+  pdf, keyPem, certPem,
+  reason: "Agreement", location: "example.org",
+  contactInfo: "legal@acme.org", name: "Acme",
+  tsa,
+});
+
+const v = verifyPdfStructure(signedPdf);
+// v.timestamped, v.timestampTime (ISO 8601), v.tsaCommonName
+```
+
+### What you need to know
+
+- **Placeholder budget.** When `tsa` is provided and you do not set
+  `signatureLength`, the `/Contents` budget defaults to **30720** bytes (vs
+  `8192` without a TSA) to fit the TimeStampToken plus the TSA certificate
+  chain. If the signed PKCS#7 would overflow the placeholder, `signPdf` throws
+  rather than producing a silently-truncated signature. Override
+  `signatureLength` only if your TSA's chain is unusually large.
+- **Privacy.** The request sent to the TSA is an RFC 3161 `TimeStampReq` whose
+  `messageImprint` is `sha256(SignerInfo.signature)`. No document bytes, no
+  identifiers, no PHI leave your process beyond that single hash.
+- **Failure modes.** With `required: false` (default) a TSA error yields a valid
+  CAdES-B signature and populates `tsaError`; `timestamped` is `false`. With
+  `required: true` the error is rethrown and no signature is returned.
+- **Verification.** `verifyPdfStructure` enforces the RFC 3161 §2.4.2 binding:
+  the token's `messageImprint` must equal `sha256(SignerInfo.signature)`. A
+  mismatch sets `ok:false` with `"timestamp messageImprint does not match
+  signature value"`. A PDF with no timestamp verifies normally with
+  `timestamped:false` (backward compatible).
+
+### Choosing a TSA
+
+Any RFC 3161 TSA works. Free public TSAs include
+`http://timestamp.digicert.com` and `http://timestamp.sectigo.com`. For
+HIPAA/regulated contexts, prefer a TSA you have a relationship with; remember
+the TSA only sees a hash, so a BAA is generally not required for the hash
+itself — confirm with your compliance owner.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Opendelphi contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,298 @@
+# `@e-sig/core` — Portable In-Platform E-Signature
+
+> Self-contained PKCS#7 PDF signing — no SaaS, no metering, no per-doc fees.
+> Battle-tested in production at [opendelphi.org](https://opendelphi.org).
+
+This directory is the **portable core** of the Opendelphi e-signature pipeline. Drop it (plus a tiny adapter you write) into any TypeScript / Node.js project to add real cryptographic signing of PDFs.
+
+---
+
+## What it does
+
+Given an HTML document and a person who wants to sign it, this library:
+
+1. Renders the HTML to a PDF (headless Chromium via `puppeteer-core`; scripting disabled by default).
+2. Generates or reuses a self-signed RSA-2048 X.509 cert for the signing tenant.
+3. Embeds a PKCS#7 detached signature under the **ETSI.CAdES.detached** subfilter, with the ESS **signing-certificate-v2** attribute binding the signer cert into the signed data. Pass `padesStrict: true` for strict **PAdES B-B** (also drops the PAdES-forbidden `signing-time` attribute).
+4. Produces a PDF that opens cleanly in Preview / Adobe Reader with a valid signature panel — any post-signing edit invalidates the signature. `verifyPdfSignature()` checks this cryptographically (recomputes the digest over the signed ByteRange and RSA-verifies the signature).
+
+> **Trust vs. validity.** The signature is cryptographically *valid*, but the cert is *self-issued* — stock Adobe Reader shows "validity unknown" until the cert is trusted (org trust-store import, or plug in an AATL/CA signer). This verifies the signature math and integrity, not third-party trust. See the compliance notes below.
+
+That's the **whole thing**. It's ~600 lines of TypeScript with zero runtime dependencies on Supabase, Next.js, or any SaaS.
+
+---
+
+## What it does NOT do
+
+By design — these are wrapper concerns:
+
+- **Storage of the signed PDF.** You decide where (S3, local disk, Supabase Storage, …).
+- **Auth / authorization.** You decide who's allowed to sign.
+- **UI.** You build the signature-capture surface.
+- **Persistence of the cert pool.** Implement the `CertStore` adapter interface.
+- **Audit logging.** Implement the `AuditLogStore` adapter interface.
+
+The library gives you **crypto + rendering**. You bring **persistence + UI + auth**.
+
+---
+
+## Files
+
+| File | Purpose | Project-agnostic? |
+|---|---|---|
+| `pem-signer.ts` | Custom `@signpdf` `Signer` driven by raw PEM key+cert (bypasses node-forge's broken P12 round-trip — see Background below) | ✅ |
+| `cert-issuer.ts` | Generate self-signed RSA-2048 X.509; AES-256-GCM-wrap private keys for at-rest storage | ✅ |
+| `render-pdf.ts` | HTML → PDF via puppeteer-core; auto-detects Lambda vs local Chrome | ✅ |
+| `sign-pdf.ts` | Combine placeholder injection + PKCS#7 sign (ETSI.CAdES) | ✅ |
+| `verify-pdf.ts` | Structural verifier (parses /ByteRange + PKCS#7 blob, returns diagnostics) | ✅ |
+| `signature-block.ts` | HTML helper to render N signature blocks for multi-party flows | ✅ |
+| `types.ts` | Shared TS types (`Signer`, `SigningCertPem`, …) | ✅ |
+| `index.ts` | Public re-export barrel | ✅ |
+
+---
+
+## Install
+
+```sh
+npm install \
+  @signpdf/signpdf \
+  @signpdf/utils \
+  @signpdf/placeholder-plain \
+  node-forge \
+  puppeteer-core \
+  @sparticuz/chromium  # only on Lambda; skip for local-only
+```
+
+Plus `@types/node-forge` if you're using TypeScript.
+
+If you're on Next.js, you MUST externalize the binary-adjacent packages in `next.config.ts`:
+
+```ts
+const nextConfig = {
+  serverExternalPackages: [
+    "@sparticuz/chromium",
+    "puppeteer-core",
+    "node-forge",
+    "@signpdf/signpdf",
+    "@signpdf/utils",
+    "@signpdf/placeholder-plain",
+  ],
+  // The chromium binary tarball is a static asset; tell file-tracing to
+  // include it in your e-sig route's bundle.
+  outputFileTracingIncludes: {
+    "/api/your-esig-route": [
+      "./node_modules/@sparticuz/chromium/bin/**",
+    ],
+  },
+};
+```
+
+---
+
+## 30-second example
+
+```ts
+import {
+  generateSelfSignedCert,
+  renderHtmlToPdf,
+  signPdf,
+  verifyPdfStructure,
+} from "@e-sig/core";
+
+// 1. Issue a one-off cert (in real life, persist + reuse).
+const cert = generateSelfSignedCert({ subjectName: "Acme Corp" });
+
+// 2. Render HTML → unsigned PDF.
+const unsigned = await renderHtmlToPdf({
+  html: `<h1>Service Agreement</h1><p>Signed by Jane Doe at ${new Date().toISOString()}.</p>`,
+});
+
+// 3. Sign it.
+const { signedPdf } = await signPdf({
+  pdf: unsigned,
+  keyPem: cert.keyPem,
+  certPem: cert.certPem,
+  reason: "Service Agreement acceptance",
+  location: "https://acme.example",
+  contactInfo: "jane@example.com",
+  name: "Jane Doe",
+});
+
+// 4. Verify the result cryptographically (also exported as verifyPdfSignature).
+//    ok === true only when structure + document digest + RSA signature all pass;
+//    a single flipped byte under the signature makes ok=false / digestValid=false.
+const verify = verifyPdfStructure(signedPdf);
+console.log(verify.ok, verify.digestValid, verify.signatureValid, verify.signerCommonName);
+// → true, true, true, "E-sig (Acme Corp)"
+
+// 5. Persist + serve. Up to you.
+require("fs").writeFileSync("./signed.pdf", signedPdf);
+```
+
+That's it. Open `signed.pdf` in Preview — signature panel shows valid (self-signed).
+
+---
+
+## RFC 3161 trusted timestamps (CAdES-T)
+
+Pass a `tsa` transport to `signPdf` to embed an RFC 3161 TimeStampToken,
+upgrading the signature from CAdES-B to CAdES-T. The token is added as the
+`id-aa-timeStampToken` unsigned attribute (OID `1.2.840.113549.1.9.16.2.14`)
+computed over the SignerInfo signatureValue (RFC 3161 §2.4.1).
+
+The package performs **no network egress** — you inject the POST so the package
+stays dependency-free. The TSA only ever receives a **SHA-256 hash**, never the
+document or any PHI:
+
+```ts
+import type { TsaTransport } from "@e-sig/core";
+
+const tsa: TsaTransport = {
+  required: false, // false = degrade to CAdES-B on TSA failure; true = throw
+  fetch: async (reqDerBytes) => {
+    const res = await fetch("http://timestamp.digicert.com", {
+      method: "POST",
+      headers: { "Content-Type": "application/timestamp-query" },
+      body: reqDerBytes,
+    });
+    return new Uint8Array(await res.arrayBuffer());
+  },
+};
+
+const { signedPdf, timestamped, tsaError } = await signPdf({
+  pdf, keyPem, certPem,
+  reason: "DUA acceptance", location: "opendelphi.org",
+  contactInfo: "legal@acme.org", name: "Acme Research Institute",
+  tsa,
+});
+
+const v = verifyPdfStructure(signedPdf);
+// v.timestamped, v.timestampTime (ISO), v.tsaCommonName
+// v.ok is false if the §2.4.2 binding check fails (imprint != sha256(sigValue))
+```
+
+Notes:
+
+- **Budget**: when `tsa` is supplied and `signatureLength` is omitted, the
+  `/Contents` placeholder budget defaults to **30720** (vs `8192` without a TSA)
+  to fit the TimeStampToken plus the TSA certificate chain. An overflow is
+  rejected, never silently truncated.
+- **Degradation**: with `required: false` (default), a TSA error produces a
+  valid CAdES-B signature and sets `tsaError`; with `required: true` the error
+  is rethrown.
+- **Verification** enforces the RFC 3161 §2.4.2 binding: the token's
+  `messageImprint` must equal `sha256(SignerInfo.signature)`, else `ok:false`.
+
+See `CONSUMING.md` for the full consumer guide.
+
+---
+
+## Persisting certs + audit logs across requests
+
+For real usage you need to:
+- **Cache certs per tenant** so you don't regenerate on every sign.
+- **Encrypt private keys at rest** so a DB leak doesn't compromise signing authority.
+- **Log every sign** for ESIGN / UETA / 21 CFR §11 compliance evidence.
+
+The library provides adapter **interfaces** (`CertStore`, `AuditLogStore` — see `../adapters/types.ts`). Implement them against your DB.
+
+A reference Supabase implementation lives at `../adapters/supabase.ts` (~150 lines). It works against any schema with these two tables — copy the migration from `supabase/migrations/00106_esig_self_contained.sql` for the canonical shape, or write your own.
+
+### CertStore interface
+
+```ts
+interface CertStore {
+  findActive(tenantId: string): Promise<StoredCert | null>;
+  insert(input: { tenantId; generated; keyPemEncrypted; rotatedFromId? }): Promise<StoredCert>;
+  deactivate(id: string): Promise<void>;
+  findExpiring(withinDays: number): Promise<StoredCert[]>;
+}
+```
+
+### AuditLogStore interface
+
+```ts
+interface AuditLogStore {
+  insert(entry: AuditLogEntry): Promise<AuditLogRow>;
+}
+```
+
+Then use the convenience helper `ensureActiveCert` from `../adapters/supabase.ts` as a template:
+
+```ts
+const result = await ensureActiveCert({
+  store: new YourCertStore(...),
+  tenantId: "acme-corp",
+  subjectName: "Acme Corp",
+  passphrase: process.env.ESIG_CERT_PASSPHRASE!,
+});
+// result.certPem + result.keyPem ready to feed into signPdf()
+```
+
+---
+
+## Compliance posture
+
+The Opendelphi production wire-up uses this library for HIPAA-bound Data Use Agreements and is mapped against:
+
+- **ESIGN Act § 7001 (R1–R5)** — Intent, Consent to electronic, Attribution, Integrity, Retention. R4 Integrity is fully covered by the crypto core; R1/R2/R3/R5 are wrapper concerns.
+- **UETA § 9 + § 13** — Attribution + system attribution log.
+- **21 CFR § 11.50 / § 11.70** — FDA-grade requirements where applicable.
+
+See `.planning/phases/19-esig-primitives-spike/19-04-ESIGN-GAPS.md` for the full mapping.
+
+**Not legal advice.** Talk to your lawyer about whether this satisfies the regulatory framework for your specific use case.
+
+---
+
+## Background — why this exists
+
+### Why not DocuSign / DocuSeal / Documenso?
+
+Per-document metering (~$0.20/sig) made the unit economics painful at scale. And every signed PDF flowed through a third-party processor — making HIPAA + GDPR compliance harder than it had to be.
+
+This library is what you reach for when "no SaaS, no metering, no fees" is a hard requirement.
+
+### Why not `pdf-lib`?
+
+[`pdf-lib`](https://github.com/Hopding/pdf-lib) is the most popular Node PDF library, but it hasn't shipped a release since 2021. Documenso uses [`@libpdf/core`](https://github.com/libpdf/libpdf) instead — same conclusion here. (Neither is actually used by this core — we drive `puppeteer` for rendering and `@signpdf` + `node-forge` for signing, both actively maintained.)
+
+### Why not PKCS#12?
+
+We tried. `node-forge.pkcs12.toPkcs12Asn1` produces P12 bundles whose MAC neither node-forge **nor openssl** can verify. Looks like a long-standing BMPString-password-derivation bug. We bypass it entirely — the PemSigner takes raw PEM and drives `forge.pkcs7` directly.
+
+### Bugs to avoid (we hit these so you don't have to)
+
+1. **Don't use `node-forge.pkcs12.toPkcs12Asn1`** — see above.
+2. **ASCII-only cert subject names** — `forge.pki.certificateFromPem` mis-counts bytes for non-ASCII (em-dash in OU breaks PEM round-trip with "Too few bytes to parse DER").
+3. **`@signpdf/signpdf` v3 ESM default import is opaque** — use the named export: `import { SignPdf } from "@signpdf/signpdf"` and `new SignPdf().sign(...)`.
+4. **`@sparticuz/chromium` is Lambda-only** — locally, use system Chrome via the `executablePath` override.
+5. **Storing key + cert in one PEM file is fragile** — `forge.pem.decode` extracts blocks correctly, but re-encoding the cert block from a multi-block buffer doesn't survive `certificateFromPem` round-trip. Store them as separate files / DB columns.
+
+---
+
+## Performance
+
+End-to-end on Vercel Lambda (cold start), tested against [opendelphi.org](https://opendelphi.org/api/esig/dua-self-sign) in production:
+
+- Render HTML → unsigned PDF: ~2.5 s (cold) / ~0.5 s (warm)
+- Generate cert (first sign per tenant): ~0.8 s (RSA-2048 keygen dominates)
+- PKCS#7 sign: ~0.1 s
+- Upload + audit + DB row flip: ~0.3 s
+- **Total cold-start round-trip: ~4.5 s**
+
+Subsequent signs reuse the cached cert → ~1–1.5 s warm.
+
+---
+
+## License
+
+Same as the parent project. The `core/` directory is intentionally self-contained so it can be vendored under your own license.
+
+---
+
+## Acknowledgments
+
+- **[@signpdf](https://github.com/vbuch/node-signpdf)** for the PKCS#7 placeholder + signing infrastructure.
+- **[node-forge](https://github.com/digitalbazaar/forge)** for the X.509 + PKCS#7 + crypto primitives.
+- **[Documenso](https://github.com/documenso/documenso)** + **[DocuSeal CE](https://github.com/docusealco/docuseal)** as reference implementations (read-only — no code copied — see `.planning/phases/19-esig-primitives-spike/19-02-PATTERNS-OBSERVED.md` for the lessons borrowed).

package/dist/adapters.d.ts

@@ -0,0 +1,79 @@
+import type { GeneratedCert } from "./cert-issuer.js";
+export interface StoredCert {
+    id: string;
+    tenantId: string;
+    certPem: string;
+    /** Encrypted PEM key (whatever your at-rest encryption produces). */
+    keyPemEncrypted: Uint8Array;
+    certFingerprint: string;
+    notBefore: Date;
+    notAfter: Date;
+    active: boolean;
+    /** Optional: id of the cert this one replaced on rotation. */
+    rotatedFromId?: string | null;
+    createdAt: Date;
+}
+export interface CertStore {
+    /**
+     * Find the active (non-expired, not rotated) cert for a tenant.
+     * Return null if no active cert exists.
+     */
+    findActive(tenantId: string): Promise<StoredCert | null>;
+    /**
+     * Insert a new cert. Implementations should ensure only one cert per tenant
+     * is `active=true` at any time (handle the "deactivate old + insert new"
+     * transaction yourself or in a single SQL statement).
+     */
+    insert(input: {
+        tenantId: string;
+        generated: GeneratedCert;
+        keyPemEncrypted: Uint8Array;
+        rotatedFromId?: string | null;
+    }): Promise<StoredCert>;
+    /** Mark a cert as inactive (used during rotation). */
+    deactivate(id: string): Promise<void>;
+    /** Find all active certs whose notAfter is within `withinDays` of now. Used by a rotation cron. */
+    findExpiring(withinDays: number): Promise<StoredCert[]>;
+}
+/**
+ * Standard action vocabulary. Implementations should allow these at minimum
+ * but may extend the set (caller passes the action string through).
+ */
+export type EsigAuditAction = "cert.created" | "cert.rotated" | "cert.deactivated" | "pdf.rendered" | "pdf.signed" | "pdf.verified" | "consent.recorded";
+export interface AuditLogEntry {
+    tenantId: string;
+    action: EsigAuditAction | string;
+    actorUserId?: string | null;
+    targetTable?: string;
+    targetId?: string;
+    certId?: string;
+    certFingerprint?: string;
+    ip?: string;
+    userAgent?: string;
+    sessionId?: string;
+    signedPdfUrl?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AuditLogRow {
+    id: string;
+    createdAt: Date;
+}
+export interface AuditLogStore {
+    /** Append one row. Returns the new row id + timestamp for FK references. */
+    insert(entry: AuditLogEntry): Promise<AuditLogRow>;
+}
+/**
+ * Persists signed PDFs (and optionally signature images). The `signDocument()`
+ * orchestrator uses this to store the signed bytes and return a URL/path key.
+ */
+export interface PdfStorageStore {
+    /** Upload bytes at the given path. Returns the canonical URL or path key. */
+    upload(input: {
+        path: string;
+        bytes: Uint8Array;
+        contentType: string;
+    }): Promise<{
+        url: string;
+    }>;
+}
+//# sourceMappingURL=adapters.d.ts.map

package/dist/adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../src/adapters.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAItD,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,eAAe,EAAE,UAAU,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,IAAI,CAAC;IAChB,QAAQ,EAAE,IAAI,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,8DAA8D;IAC9D,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IAEzD;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE;QACZ,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,aAAa,CAAC;QACzB,eAAe,EAAE,UAAU,CAAC;QAC5B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC/B,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAExB,sDAAsD;IACtD,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtC,mGAAmG;IACnG,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;CACzD;AAID;;;GAGG;AACH,MAAM,MAAM,eAAe,GACvB,cAAc,GACd,cAAc,GACd,kBAAkB,GAClB,cAAc,GACd,YAAY,GACZ,cAAc,GACd,kBAAkB,CAAC;AAEvB,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,eAAe,GAAG,MAAM,CAAC;IACjC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CACpD;AAID;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,MAAM,CAAC,KAAK,EAAE;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,UAAU,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;KACrB,GAAG,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC9B"}

package/dist/adapters.js

@@ -0,0 +1,10 @@
+// adapters.ts
+//
+// Pluggable persistence interfaces. Implement these against your project's
+// DB/storage to plug the portable signing engine into any stack. Two stores are
+// required (CertStore + AuditLogStore); PdfStorageStore is optional but lets the
+// `signDocument()` orchestrator persist the signed PDF for you.
+//
+// A Supabase reference implementation ships as `@e-sig/supabase`.
+export {};
+//# sourceMappingURL=adapters.js.map

package/dist/adapters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.js","sourceRoot":"","sources":["../src/adapters.ts"],"names":[],"mappings":"AAAA,cAAc;AACd,EAAE;AACF,2EAA2E;AAC3E,gFAAgF;AAChF,iFAAiF;AACjF,gEAAgE;AAChE,EAAE;AACF,kEAAkE"}

package/dist/cert-issuer.d.ts

@@ -0,0 +1,47 @@
+import forge from "node-forge";
+export interface GenerateCertOptions {
+    /** Subject CN seed — embedded in the cert's commonName + organizationName. ASCII-only. */
+    subjectName: string;
+    /** Validity period in days. Default 365. */
+    validityDays?: number;
+    /**
+     * Override the OID extensions — defaults to a digital-signature-capable
+     * end-entity cert suitable for PKCS#7 detached PDF signing.
+     */
+    extensions?: Parameters<ReturnType<typeof forge.pki.createCertificate>["setExtensions"]>[0];
+    /** Override the prefix added to commonName. Default: "E-sig". */
+    commonNamePrefix?: string;
+}
+export interface GeneratedCert {
+    keyPem: string;
+    certPem: string;
+    /** SHA-256 hex of the DER-encoded cert. */
+    fingerprint: string;
+    notBefore: Date;
+    notAfter: Date;
+}
+/**
+ * Generate a self-signed RSA-2048 X.509 certificate suitable for PDF e-signing.
+ *
+ * ASCII-only subject — node-forge's `certificateFromPem` mis-counts byte length
+ * for non-ASCII values when round-tripping (concrete bug: em-dash in OU breaks
+ * parsing with "Too few bytes to parse DER"). The guard here prevents that.
+ */
+export declare function generateSelfSignedCert(opts: GenerateCertOptions): GeneratedCert;
+/**
+ * AES-256-GCM-encrypt a PEM-encoded private key for at-rest persistence.
+ * Layout: version(2) | salt(16) | iv(12) | authTag(16) | ciphertext.
+ *
+ * @param keyPem  PEM-encoded private key string.
+ * @param passphrase  ≥24 char high-entropy secret. Derived via scrypt with
+ *                    per-call random salt.
+ */
+export declare function encryptKeyPem(keyPem: string, passphrase: string): Uint8Array;
+/**
+ * Inverse of encryptKeyPem. Throws on:
+ *   - unknown version prefix (future-compat detection)
+ *   - wrong passphrase (AES-GCM auth-tag mismatch surfaces as error)
+ *   - tampered ciphertext (same as above)
+ */
+export declare function decryptKeyPem(blob: Uint8Array, passphrase: string): string;
+//# sourceMappingURL=cert-issuer.d.ts.map

package/dist/cert-issuer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cert-issuer.d.ts","sourceRoot":"","sources":["../src/cert-issuer.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,MAAM,YAAY,CAAC;AAe/B,MAAM,WAAW,mBAAmB;IAClC,0FAA0F;IAC1F,WAAW,EAAE,MAAM,CAAC;IACpB,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,KAAK,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5F,iEAAiE;IACjE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,IAAI,CAAC;IAChB,QAAQ,EAAE,IAAI,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,mBAAmB,GAAG,aAAa,CAuD/E;AAaD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,UAAU,CAW5E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAiB1E"}