@promigence/sdk 0.1.0-beta.12

package/dist/caller.d.ts

@@ -0,0 +1,73 @@
+/**
+ * `setCaller` — first-party attribution of SDK traffic.
+ *
+ * A caller is a short label naming the framework, harness or adapter driving this SDK: `cli`,
+ * `harbor`, `inspect`, or whatever you set yourself. It rides on one request header and on the
+ * `user-agent`, so we can see which integrations are actually used and build the next one where
+ * it is wanted.
+ *
+ * ## Nothing is ever auto-detected
+ *
+ * This module does not look at your process, your packages, your paths or your code, and it
+ * never will. There is no scan of `node_modules`, no walk of the module cache, no read of
+ * `argv`, no inspection of the process tree — nothing that could turn "which framework is this?"
+ * into a report about a customer's machine. Scanning a customer's process and phoning home about
+ * what is installed there is a reputational risk we are not taking, and a label we guessed would
+ * be worth less than one we were given. We only ever report a label we ship ourselves or one the
+ * customer sets on purpose.
+ *
+ * What is sent: a name, and optionally a version. That is the whole payload.
+ *
+ * ## Precedence (highest first)
+ *
+ *   1. `caller` in the client options
+ *   2. `setCaller(name, version)`
+ *   3. `PROMIGENCE_CALLER` (`name` or `name/version`)
+ *   4. the default an adapter package set with `setCaller(name, version, { default: true })`
+ *   5. none — and none is the default, so an SDK nobody configured sends no label at all
+ *
+ * ## Validation
+ *
+ * `name` must match `^[a-z0-9][a-z0-9._-]{0,31}$` after trimming and lower-casing; `version` must
+ * match `^[A-Za-z0-9.+_~-]{0,31}$`. Anything else is dropped silently — an invalid name sends no
+ * label, an invalid version sends the name alone. Telemetry never raises, never logs to stdout
+ * and never stops a request: the work is what matters, the label is not.
+ */
+/** The request header the label rides on. */
+export declare const CALLER_HEADER = "promigence-caller";
+/** `PROMIGENCE_CALLER=harbor` or `PROMIGENCE_CALLER=harbor/0.1.0`. */
+export declare const CALLER_ENV = "PROMIGENCE_CALLER";
+export declare const CALLER_NAME_RE: RegExp;
+export declare const CALLER_VERSION_RE: RegExp;
+export declare const RESERVED_CALLERS: readonly string[];
+/**
+ * The token for `name` (+ `version`), or `undefined` when the name is not a valid label.
+ * An invalid version is dropped on its own, leaving the name.
+ */
+export declare function callerToken(name: string, version?: string): string | undefined;
+/** `harbor` or `harbor/0.1.0` as one string (the env var, the `caller` option). */
+export declare function parseCallerToken(raw: string | undefined): string | undefined;
+/**
+ * Name the framework or harness driving this SDK.
+ *
+ * ```ts
+ * import { setCaller } from "promigence";
+ * setCaller("my-harness", "2.1.0");
+ * ```
+ *
+ * `{ default: true }` is for a package that ships an integration: it sets the label only for a
+ * customer who has not set one of their own, and `PROMIGENCE_CALLER` still wins over it.
+ *
+ * An unusable name is ignored. This never throws.
+ */
+export declare function setCaller(name: string, version?: string, options?: {
+    default?: boolean;
+}): void;
+/** The label that would be sent, ignoring any per-client `caller` option. */
+export declare function getCaller(): string | undefined;
+/** Everything unset again (tests). */
+export declare function clearCaller(): void;
+/** The label one client sends: its own option first, then everything `getCaller` considers. */
+export declare function resolveCaller(explicit?: string): string | undefined;
+/** `promigence/0.1.0 node/22.0.0` + ` (harbor/0.1.0)`, when there is a label to add. */
+export declare function userAgentWithCaller(userAgent: string, caller: string | undefined): string;

package/dist/caller.js

@@ -0,0 +1,47 @@
+export const CALLER_HEADER = "promigence-caller";
+export const CALLER_ENV = "PROMIGENCE_CALLER";
+export const CALLER_NAME_RE = /^[a-z0-9][a-z0-9._-]{0,31}$/;
+export const CALLER_VERSION_RE = /^[A-Za-z0-9.+_~-]{0,31}$/;
+export const RESERVED_CALLERS = [
+    "cli", "harbor", "inspect", "e2b-compat", "computesdk", "mcp",
+];
+let globalCaller;
+let defaultCaller;
+export function callerToken(name, version) {
+    const n = typeof name === "string" ? name.trim().toLowerCase() : "";
+    if (!CALLER_NAME_RE.test(n))
+        return undefined;
+    const v = typeof version === "string" ? version.trim() : "";
+    if (!v || !CALLER_VERSION_RE.test(v))
+        return n;
+    return `${n}/${v}`;
+}
+export function parseCallerToken(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    const t = raw.trim();
+    if (!t)
+        return undefined;
+    const slash = t.indexOf("/");
+    return slash < 0 ? callerToken(t) : callerToken(t.slice(0, slash), t.slice(slash + 1));
+}
+export function setCaller(name, version, options) {
+    const token = callerToken(name, version);
+    if (options?.default)
+        defaultCaller = token;
+    else
+        globalCaller = token;
+}
+export function getCaller() {
+    return globalCaller ?? parseCallerToken(process.env[CALLER_ENV]) ?? defaultCaller;
+}
+export function clearCaller() {
+    globalCaller = undefined;
+    defaultCaller = undefined;
+}
+export function resolveCaller(explicit) {
+    return parseCallerToken(explicit) ?? getCaller();
+}
+export function userAgentWithCaller(userAgent, caller) {
+    return caller ? `${userAgent} (${caller})` : userAgent;
+}

package/dist/cjs/blake3.d.ts

@@ -0,0 +1,10 @@
+/**
+ * BLAKE3, hand-rolled.
+ *
+ * Scope: unkeyed hashing, 32-byte output. No keyed mode, no derive-key, no XOF — nothing in the
+ * bundle format needs them.
+ */
+/** 32-byte digest, lowercase hex. */
+export declare function blake3Hex(input: Uint8Array): string;
+/** `blake3:<hex>` of a UTF-8 string — the digest form the manifest uses everywhere. */
+export declare const blake3Ref: (text: string) => string;

package/dist/cjs/blake3.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blake3Ref = void 0;
+exports.blake3Hex = blake3Hex;
+const IV = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+const PERM = [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8];
+const CHUNK_START = 1, CHUNK_END = 2, PARENT = 4, ROOT = 8;
+const BLOCK_LEN = 64, CHUNK_LEN = 1024;
+const rotr = (x, n) => ((x >>> n) | (x << (32 - n))) >>> 0;
+function g(s, a, b, c, d, mx, my) {
+    s[a] = (s[a] + s[b] + mx) >>> 0;
+    s[d] = rotr(s[d] ^ s[a], 16);
+    s[c] = (s[c] + s[d]) >>> 0;
+    s[b] = rotr(s[b] ^ s[c], 12);
+    s[a] = (s[a] + s[b] + my) >>> 0;
+    s[d] = rotr(s[d] ^ s[a], 8);
+    s[c] = (s[c] + s[d]) >>> 0;
+    s[b] = rotr(s[b] ^ s[c], 7);
+}
+function compress(cv, m, counter, blockLen, flags) {
+    const s = new Uint32Array(16);
+    for (let i = 0; i < 8; i++)
+        s[i] = cv[i];
+    for (let i = 0; i < 4; i++)
+        s[8 + i] = IV[i];
+    s[12] = counter >>> 0;
+    s[13] = Math.floor(counter / 0x100000000) >>> 0;
+    s[14] = blockLen >>> 0;
+    s[15] = flags >>> 0;
+    let x = m;
+    for (let r = 0; r < 7; r++) {
+        g(s, 0, 4, 8, 12, x[0], x[1]);
+        g(s, 1, 5, 9, 13, x[2], x[3]);
+        g(s, 2, 6, 10, 14, x[4], x[5]);
+        g(s, 3, 7, 11, 15, x[6], x[7]);
+        g(s, 0, 5, 10, 15, x[8], x[9]);
+        g(s, 1, 6, 11, 12, x[10], x[11]);
+        g(s, 2, 7, 8, 13, x[12], x[13]);
+        g(s, 3, 4, 9, 14, x[14], x[15]);
+        if (r < 6) {
+            const y = new Uint32Array(16);
+            for (let i = 0; i < 16; i++)
+                y[i] = x[PERM[i]];
+            x = y;
+        }
+    }
+    for (let i = 0; i < 8; i++) {
+        s[i] = (s[i] ^ s[i + 8]) >>> 0;
+        s[i + 8] = (s[i + 8] ^ cv[i]) >>> 0;
+    }
+    return s;
+}
+function words(b, off, len) {
+    const m = new Uint32Array(16);
+    for (let i = 0; i < len; i++)
+        m[i >> 2] |= b[off + i] << ((i & 3) * 8);
+    for (let i = 0; i < 16; i++)
+        m[i] = m[i] >>> 0;
+    return m;
+}
+const chainingValue = (o) => compress(o.cv, o.m, o.counter, o.blockLen, o.flags).slice(0, 8);
+function chunkOutput(b, off, len, counter) {
+    let cv = IV;
+    const blocks = Math.max(1, Math.ceil(len / BLOCK_LEN));
+    for (let i = 0; i < blocks - 1; i++) {
+        const flags = i === 0 ? CHUNK_START : 0;
+        cv = compress(cv, words(b, off + i * BLOCK_LEN, BLOCK_LEN), counter, BLOCK_LEN, flags).slice(0, 8);
+    }
+    const last = (blocks - 1) * BLOCK_LEN;
+    return {
+        cv,
+        m: words(b, off + last, len - last),
+        counter,
+        blockLen: len - last,
+        flags: (blocks === 1 ? CHUNK_START : 0) | CHUNK_END,
+    };
+}
+function parentOutput(l, r) {
+    const m = new Uint32Array(16);
+    m.set(l, 0);
+    m.set(r, 8);
+    return { cv: IV, m, counter: 0, blockLen: BLOCK_LEN, flags: PARENT };
+}
+function leftLen(n) {
+    let l = CHUNK_LEN;
+    while (l * 2 < n)
+        l *= 2;
+    return l;
+}
+function subtree(b, off, len, counter) {
+    if (len <= CHUNK_LEN)
+        return chainingValue(chunkOutput(b, off, len, counter));
+    const ll = leftLen(len);
+    return chainingValue(parentOutput(subtree(b, off, ll, counter), subtree(b, off + ll, len - ll, counter + ll / CHUNK_LEN)));
+}
+function blake3Hex(input) {
+    const n = input.length;
+    const root = n <= CHUNK_LEN
+        ? chunkOutput(input, 0, n, 0)
+        : (() => {
+            const ll = leftLen(n);
+            return parentOutput(subtree(input, 0, ll, 0), subtree(input, ll, n - ll, ll / CHUNK_LEN));
+        })();
+    const s = compress(root.cv, root.m, 0, root.blockLen, root.flags | ROOT);
+    let out = "";
+    for (let i = 0; i < 8; i++) {
+        const w = s[i];
+        for (let k = 0; k < 4; k++)
+            out += (((w >>> (k * 8)) & 0xff) | 0x100).toString(16).slice(1);
+    }
+    return out;
+}
+const blake3Ref = (text) => `blake3:${blake3Hex(new TextEncoder().encode(text))}`;
+exports.blake3Ref = blake3Ref;

package/dist/cjs/bundle.d.ts

@@ -0,0 +1,96 @@
+export declare const BUNDLE_SCHEMA: "promigence.bundle/v1";
+export declare const MANIFEST_SCHEMA: "promigence.snapshot/v1";
+export declare const BUNDLE_EXT = ".promigence";
+export type Json = null | boolean | number | string | Json[] | {
+    [k: string]: Json;
+};
+/** Section digests: `provenance` and `verification` always; a full or citation bundle records one per section it has. */
+export interface Digests {
+    provenance: string;
+    verification: string;
+    [section: string]: string;
+}
+/** The sealed sections of a bundle: the digests of the sections the API did not disclose. */
+export interface Sealed {
+    platform: string;
+    machine: string;
+    layers: string;
+}
+/** On a citation bundle: the digest of the one section it leaves out. */
+export interface LayersRef {
+    digest: string;
+    [extra: string]: unknown;
+}
+export interface Bundle {
+    schema: string;
+    snap_id: string;
+    manifest_hash: string;
+    alias?: string;
+    digests: Digests;
+    /** Empty on a sealed bundle. */
+    layers: Json[];
+    /** Present only on a citation bundle. */
+    layers_ref?: LayersRef;
+    /** Present only on a sealed bundle. */
+    sealed?: Sealed;
+    provenance: Record<string, Json>;
+    verification: Record<string, Json>;
+    /** A full or citation bundle's other sections, each covered by a digest. */
+    [section: string]: unknown;
+}
+export type Form = "full" | "citation" | "sealed";
+/**
+ * Canonical JSON (RFC 8785): what every digest in a bundle is computed over.
+ *
+ * Two rules come free in JavaScript and are used deliberately rather than re-implemented:
+ * `<` on strings compares UTF-16 code units, which is exactly RFC 8785's key ordering; and
+ * `String(n)` *is* ECMAScript's `Number.prototype.toString`, which is exactly its number form. `JSON.stringify`
+ * of a string is its escaping (only `"` `\` and controls, short forms, lowercase `\u00xx`).
+ */
+export declare function canonicalize(v: unknown): string;
+/** `blake3:<hex>` of a value's canonical JSON. */
+export declare const digestOf: (v: unknown) => string;
+/**
+ * Insert insignificant whitespace into canonical JSON. A whitespace transform rather than a
+ * second serializer, so key order, number form and escaping are canonical by construction and
+ * `strip` recovers the exact bytes that were hashed.
+ */
+export declare function pretty(canonical: string): string;
+/** The exact inverse of `pretty`: drop every whitespace byte outside a string. */
+export declare function strip(text: string): string;
+export interface BuildOpts {
+    alias?: string | undefined;
+}
+/**
+ * Build a bundle from a snapshot's manifest as the API serves it (`snapshots.manifest`): the
+ * sealed form, which names exactly one environment. The id is the head of `manifest_hash`, which
+ * `verifyBundle` checks.
+ */
+export declare function buildBundle(manifest: Record<string, unknown>, opts?: BuildOpts): Bundle;
+/** RFC 8785 canonical bytes: what every digest is computed over. */
+export declare const canonicalBundle: (b: Bundle) => string;
+/** The file: the canonical bytes with whitespace put back, plus a final newline. */
+export declare const renderBundle: (b: Bundle) => string;
+/** `sealed` (what an export writes), `citation` (one section left out, pinned by its digest) or `full`. */
+export declare function bundleForm(b: Bundle): Form;
+/** The digest that names the platform a sealed bundle's environment runs on; `undefined` on any other form. */
+export declare const platformOf: (b: Bundle) => string | undefined;
+export type BundleErrorKind = "schema" | "snap_id_format" | "hash_format" | "id_mismatch" | "section_digest" | "manifest_hash" | "canonical";
+export declare class BundleVerifyError extends Error {
+    readonly kind: BundleErrorKind;
+    readonly detail: Record<string, unknown>;
+    constructor(kind: BundleErrorKind, message: string, detail?: Record<string, unknown>);
+}
+/**
+ * Everything checkable without the network, in the order that makes each failure specific: a
+ * changed section is a `section_digest` failure naming that section, a changed `manifest_hash` is
+ * a `manifest_hash` failure (a full bundle) or an `id_mismatch`, and a rewritten `snap_id` with
+ * intact content is `id_mismatch`.
+ *
+ * A sealed bundle's provenance and verification digests and its identity are verified here; the
+ * sealed sections are the API's to answer. A full or citation bundle has every section it carries
+ * checked against its recorded digest, and a full one its `manifest_hash` against its content.
+ */
+export declare function verifyBundle(b: Bundle): Form;
+/** Parse a `.promigence` file. Refuses anything that is not JSON or not a bundle; `verifyBundle` does the rest. */
+export declare function parseBundle(text: string): Bundle;

package/dist/cjs/bundle.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleVerifyError = exports.platformOf = exports.renderBundle = exports.canonicalBundle = exports.digestOf = exports.BUNDLE_EXT = exports.MANIFEST_SCHEMA = exports.BUNDLE_SCHEMA = void 0;
+exports.canonicalize = canonicalize;
+exports.pretty = pretty;
+exports.strip = strip;
+exports.buildBundle = buildBundle;
+exports.bundleForm = bundleForm;
+exports.verifyBundle = verifyBundle;
+exports.parseBundle = parseBundle;
+const blake3_js_1 = require("./blake3.js");
+exports.BUNDLE_SCHEMA = "promigence.bundle/v1";
+exports.MANIFEST_SCHEMA = "promigence.snapshot/v1";
+exports.BUNDLE_EXT = ".promigence";
+function canonicalize(v) {
+    if (v === null)
+        return "null";
+    switch (typeof v) {
+        case "boolean": return v ? "true" : "false";
+        case "number":
+            if (!Number.isFinite(v))
+                throw new TypeError(`non-finite number cannot be canonicalised: ${v}`);
+            return Object.is(v, -0) ? "0" : String(v);
+        case "string": return JSON.stringify(v);
+        case "object": break;
+        default: throw new TypeError(`cannot canonicalise ${typeof v}`);
+    }
+    if (Array.isArray(v))
+        return `[${v.map(canonicalize).join(",")}]`;
+    const o = v;
+    const keys = Object.keys(o).filter((k) => o[k] !== undefined).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalize(o[k])}`).join(",")}}`;
+}
+const digestOf = (v) => (0, blake3_js_1.blake3Ref)(canonicalize(v));
+exports.digestOf = digestOf;
+function pretty(canonical) {
+    let out = "";
+    let depth = 0, inStr = false, esc = false;
+    for (let i = 0; i < canonical.length; i++) {
+        const c = canonical[i];
+        if (inStr) {
+            out += c;
+            if (esc)
+                esc = false;
+            else if (c === "\\")
+                esc = true;
+            else if (c === '"')
+                inStr = false;
+            continue;
+        }
+        if (c === '"') {
+            inStr = true;
+            out += c;
+            continue;
+        }
+        if (c === "{" || c === "[") {
+            const close = c === "{" ? "}" : "]";
+            if (canonical[i + 1] === close) {
+                out += c + close;
+                i++;
+                continue;
+            }
+            depth++;
+            out += c + "\n" + "  ".repeat(depth);
+            continue;
+        }
+        if (c === "}" || c === "]") {
+            depth = Math.max(0, depth - 1);
+            out += "\n" + "  ".repeat(depth) + c;
+            continue;
+        }
+        if (c === ",") {
+            out += ",\n" + "  ".repeat(depth);
+            continue;
+        }
+        if (c === ":") {
+            out += ": ";
+            continue;
+        }
+        out += c;
+    }
+    return out;
+}
+function strip(text) {
+    let out = "";
+    let inStr = false, esc = false;
+    for (const c of text) {
+        if (inStr) {
+            out += c;
+            if (esc)
+                esc = false;
+            else if (c === "\\")
+                esc = true;
+            else if (c === '"')
+                inStr = false;
+            continue;
+        }
+        if (c === '"') {
+            inStr = true;
+            out += c;
+            continue;
+        }
+        if (c === " " || c === "\t" || c === "\n" || c === "\r")
+            continue;
+        out += c;
+    }
+    return out;
+}
+const idOf = (hash) => `snap_${hash.slice(7, 7 + 24)}`;
+function buildBundle(manifest, opts = {}) {
+    const sealedIn = manifest?.["sealed"];
+    if (!sealedIn || typeof sealedIn !== "object" || Array.isArray(sealedIn)) {
+        throw new BundleVerifyError("schema", "a bundle is built from a sealed manifest, and this one is not sealed");
+    }
+    const alias = opts.alias ?? manifest["alias"] ?? undefined;
+    const s = sealedIn;
+    const hash = String(manifest["manifest_hash"] ?? "");
+    return {
+        schema: exports.BUNDLE_SCHEMA,
+        snap_id: idOf(hash),
+        manifest_hash: hash,
+        ...(alias ? { alias } : {}),
+        digests: {
+            provenance: (0, exports.digestOf)(manifest["provenance"]),
+            verification: (0, exports.digestOf)(manifest["verification"]),
+        },
+        layers: [],
+        sealed: { platform: String(s["platform"] ?? ""), machine: String(s["machine"] ?? ""), layers: String(s["layers"] ?? "") },
+        provenance: manifest["provenance"],
+        verification: manifest["verification"],
+    };
+}
+const canonicalBundle = (b) => canonicalize(b);
+exports.canonicalBundle = canonicalBundle;
+const renderBundle = (b) => pretty(canonicalize(b)) + "\n";
+exports.renderBundle = renderBundle;
+function bundleForm(b) {
+    if (b.sealed !== undefined)
+        return "sealed";
+    return b.layers_ref !== undefined ? "citation" : "full";
+}
+const platformOf = (b) => b.sealed?.platform;
+exports.platformOf = platformOf;
+class BundleVerifyError extends Error {
+    kind;
+    detail;
+    constructor(kind, message, detail = {}) {
+        super(message);
+        this.name = "BundleVerifyError";
+        this.kind = kind;
+        this.detail = detail;
+    }
+}
+exports.BundleVerifyError = BundleVerifyError;
+const HEX = (s, n) => new RegExp(`^[0-9a-f]{${n}}$`).test(s);
+function checkHash(field, h) {
+    const s = String(h ?? "");
+    if (!s.startsWith("blake3:") || !HEX(s.slice(7), 64)) {
+        throw new BundleVerifyError("hash_format", `${field} ${JSON.stringify(s)} is not blake3:<64 lowercase hex>`, { field, found: s });
+    }
+}
+function section(name, recorded, v) {
+    const computed = (0, exports.digestOf)(v);
+    if (computed !== recorded) {
+        throw new BundleVerifyError("section_digest", `section \`${name}\` does not match its recorded digest: recorded ${recorded}, computed ${computed}`, { section: name, recorded, computed });
+    }
+}
+function checkId(b) {
+    const derived = idOf(b.manifest_hash);
+    if (derived !== b.snap_id) {
+        throw new BundleVerifyError("id_mismatch", `snap_id ${b.snap_id} does not match manifest_hash (which names ${derived}): the identity and the content of this bundle disagree`, { snap_id: b.snap_id, derived });
+    }
+}
+function verifyBundle(b) {
+    if (b?.schema !== exports.BUNDLE_SCHEMA) {
+        throw new BundleVerifyError("schema", `not a ${exports.BUNDLE_SCHEMA} document: schema is ${JSON.stringify(b?.schema ?? null)}`, { found: b?.schema });
+    }
+    if (!/^snap_[0-9a-f]{24}$/.test(b.snap_id ?? "")) {
+        throw new BundleVerifyError("snap_id_format", `snap_id ${JSON.stringify(b.snap_id ?? null)} is not snap_<24 lowercase hex>`, { found: b.snap_id });
+    }
+    checkHash("manifest_hash", b.manifest_hash);
+    const form = bundleForm(b);
+    if (form === "sealed") {
+        for (const k of ["platform", "machine", "layers"])
+            checkHash(`sealed.${k}`, b.sealed?.[k]);
+        for (const k of ["provenance", "verification"])
+            checkHash(`digests.${k}`, b.digests?.[k]);
+        section("provenance", b.digests.provenance, b.provenance);
+        section("verification", b.digests.verification, b.verification);
+        checkId(b);
+        return form;
+    }
+    const digests = b.digests && typeof b.digests === "object" ? { ...b.digests } : {};
+    const names = Object.keys(digests).sort();
+    for (const k of ["provenance", "verification"]) {
+        if (!names.includes(k))
+            throw new BundleVerifyError("schema", `digests.${k} is missing`, { form });
+    }
+    for (const k of names)
+        checkHash(`digests.${k}`, digests[k]);
+    let omitted;
+    if (form === "citation") {
+        const pinned = String(b.layers_ref?.digest ?? "");
+        checkHash("layers_ref.digest", pinned);
+        omitted = names.find((k) => digests[k] === pinned);
+        if (omitted === undefined) {
+            throw new BundleVerifyError("section_digest", `layers_ref.digest ${pinned} pins no section this bundle records`, { recorded: pinned });
+        }
+    }
+    for (const k of names) {
+        if (k === omitted)
+            continue;
+        if (b[k] === undefined)
+            throw new BundleVerifyError("schema", `section \`${k}\` is missing`, { section: k });
+        section(k, digests[k], b[k]);
+    }
+    if (form === "full") {
+        const content = { schema: exports.MANIFEST_SCHEMA };
+        for (const k of names)
+            content[k] = b[k];
+        const computed = (0, blake3_js_1.blake3Ref)(canonicalize(content));
+        if (computed !== b.manifest_hash) {
+            throw new BundleVerifyError("manifest_hash", `manifest_hash mismatch: the bundle records ${b.manifest_hash}, its own contents hash to ${computed}`, { recorded: b.manifest_hash, computed });
+        }
+    }
+    checkId(b);
+    return form;
+}
+function parseBundle(text) {
+    let v;
+    try {
+        v = JSON.parse(text);
+    }
+    catch (e) {
+        throw new BundleVerifyError("canonical", `not JSON: ${e.message}`);
+    }
+    const b = v;
+    if (b?.schema !== exports.BUNDLE_SCHEMA) {
+        throw new BundleVerifyError("schema", `not a ${exports.BUNDLE_SCHEMA} document: schema is ${JSON.stringify(b?.schema ?? null)}`, { found: b?.schema });
+    }
+    return b;
+}

package/dist/cjs/ca-guard.d.ts

@@ -0,0 +1 @@
+export {};