@charter-agreement-protocol/signer 0.2.1 → 0.3.0

package/dist/signer.js

@@ -1,180 +1,289 @@
 // CAP never authorizes.
-//
-// The holder-side companion signer for the Charter Agreement Protocol,
-// ported from the Elixir reference (charter_agreement_signer). The caller
-// owns key custody through a handle object with two callbacks:
-//
-//   keyIdentity(handle) -> { kid, publicKey }   // ONE atomic snapshot
-//   sign(message, handle) -> signature bytes    // the holder's job
-//
-// Framing, the producer claims gate, the honest-signer refusal guards
-// (R1–R3), and assembly are ALL the verifier package's producer surface —
-// exactly one implementation, exactly the reference signer's delegation.
-// This package adds the custody half: the atomic key snapshot, the sign
-// callback, the wrong-key guard against the snapshot's public key, and the
-// post-sign verification of the assembled artifact. It never verifies
-// third-party artifacts, never transports, never persists, and never sees
-// a private key.
-import { acceptanceSigningInput, algorithmRegistry, assembleCompact, descriptorSigningInput, receiptSigningInput, terminationSigningInput, verifyAcceptance, verifyChain, verifyDescriptor, verifyReceipt, verifySignature, verifyTermination, } from "@charter-agreement-protocol/verifier";
-function registryRow(algorithm) {
-    return algorithmRegistry().find((row) => row.name === algorithm) ?? null;
+// The holder supplies one key snapshot and signs the verifier's prepared
+// message. The verifier owns framing, claims, context, limits, profile,
+// key matching, assembly, and completion. This package keeps custody and
+// the wrong-key guard.
+import { DEFAULT_LIMITS, algorithmRegistry, MAXIMUM_LIMITS, defaultEmissionName, decodeCharterRevision, emissions, finishSigning, prepareSigning, verifySignature, } from "@charter-agreement-protocol/verifier";
+const COPY_LIMIT = Symbol("copy limit");
+// Read one child at a time without recursion or array constructor hooks.
+// Only ancestors are retained, so repeated objects get separate copies.
+function copyClaims(value) {
+    const limits = MAXIMUM_LIMITS;
+    const ancestors = new WeakSet();
+    const frames = [];
+    let bytes = 0;
+    const addBytes = (size) => {
+        bytes += size;
+        if (bytes > limits.max_bytes)
+            throw COPY_LIMIT;
+    };
+    const stringBytes = (text) => {
+        if (Buffer.byteLength(text) > limits.max_string_bytes)
+            throw COPY_LIMIT;
+        return Buffer.byteLength(JSON.stringify(text));
+    };
+    const copy = (item, depth) => {
+        if (item === null || typeof item === "boolean") {
+            addBytes(item === null || item === true ? 4 : 5);
+            return item;
+        }
+        if (typeof item === "string") {
+            addBytes(stringBytes(item));
+            return item;
+        }
+        if (typeof item === "number" && Number.isFinite(item)) {
+            addBytes(JSON.stringify(item).length);
+            return item;
+        }
+        if (typeof item !== "object" || ancestors.has(item))
+            throw new TypeError("invalid_type");
+        if (depth + 1 > limits.max_depth)
+            throw COPY_LIMIT;
+        const array = Array.isArray(item);
+        let keys = null;
+        if (!array) {
+            const prototype = Object.getPrototypeOf(item);
+            if ((prototype !== Object.prototype && prototype !== null) || Object.getOwnPropertySymbols(item).length > 0) {
+                throw new TypeError("invalid_type");
+            }
+            keys = Object.keys(item);
+        }
+        const size = array ? item.length : keys.length;
+        if (!Number.isSafeInteger(size) || size < 0 || array && size > 2 ** 32 - 1)
+            throw new TypeError("invalid_type");
+        if (size > (array ? limits.max_array_items : limits.max_object_members)) {
+            throw COPY_LIMIT;
+        }
+        addBytes(2 + Math.max(0, size - 1));
+        const target = array ? [] : Object.create(null);
+        ancestors.add(item);
+        frames.push({ source: item, target, keys, size, index: 0, depth: depth + 1 });
+        return target;
+    };
+    const result = copy(value, 0);
+    while (frames.length > 0) {
+        const frame = frames[frames.length - 1];
+        if (frame.index === frame.size) {
+            ancestors.delete(frame.source);
+            frames.pop();
+            continue;
+        }
+        const index = frame.index++;
+        const key = frame.keys ? frame.keys[index] : String(index);
+        if (frame.keys)
+            addBytes(stringBytes(key) + 1);
+        const child = frame.source[key];
+        const copied = copy(child, frame.depth);
+        if (Array.isArray(frame.target))
+            frame.target.push(copied);
+        else
+            frame.target[key] = copied;
+    }
+    return result;
+}
+function copyChainView(chain) {
+    const names = ["revisions", "acceptances", "descriptors", "terminations"];
+    const lists = Object.fromEntries(names.map((name) => [name, (value) => copyTextList(value, MAXIMUM_LIMITS.max_artifact_set_items + 1)]));
+    return optionMembers(chain, names, lists);
 }
 async function resolveKeyIdentity(handle) {
-    if (handle === null || typeof handle !== "object" || !("keyIdentity" in handle)) {
-        return { error: "invalid_handle" };
-    }
     try {
+        if (handle === null || typeof handle !== "object")
+            return { error: "invalid_key_handle" };
         const snapshot = await handle.keyIdentity(handle);
-        if (snapshot &&
-            typeof snapshot.kid === "string" &&
-            snapshot.kid.length > 0 &&
-            typeof snapshot.publicKey === "string" &&
-            Buffer.from(snapshot.publicKey, "base64url").length > 0) {
-            return snapshot;
+        if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot))
+            return { error: "invalid_key_handle" };
+        const { kid, publicKey } = snapshot;
+        if (typeof kid !== "string" || kid.length === 0 || typeof publicKey !== "string") {
+            return { error: "invalid_key_handle" };
         }
-        return { error: "invalid_handle" };
+        return { kid, publicKey };
     }
     catch (_fault) {
-        return { error: "invalid_handle" };
+        return { error: "invalid_key_handle" };
+    }
+}
+const OPTION_KEYS = new Set(["algorithm", "limits", "profile"]);
+const byteArrayTag = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), Symbol.toStringTag).get;
+// Read the defined shape once, including inherited and nonenumerable members.
+// Invalid member values stay opaque for the verifier to check synchronously.
+function optionMembers(value, names, nested = {}) {
+    if (value === null || typeof value !== "object" || Array.isArray(value) || value instanceof Number)
+        return value;
+    const source = value;
+    const result = Object.create(null);
+    const unknown = Object.keys(source).find((name) => !names.includes(name));
+    if (unknown !== undefined)
+        result[unknown] = null;
+    for (const name of names) {
+        const member = source[name];
+        if (member !== undefined || name in source)
+            result[name] = nested[name] ? nested[name](member) : member;
+    }
+    return result;
+}
+function optionAlgorithms(value) {
+    if (!Array.isArray(value))
+        return value;
+    const length = value.length;
+    if (!Number.isSafeInteger(length) || length < 0)
+        throw new TypeError("invalid_type");
+    // A unique registry subset cannot be longer than the registry. Retain an
+    // invalid length for the verifier without reading an unbounded caller list.
+    if (length > MAXIMUM_LIMITS.max_artifact_set_items)
+        return Array(MAXIMUM_LIMITS.max_artifact_set_items + 1);
+    if (length > algorithmRegistry().length)
+        return value;
+    const result = [];
+    for (let i = 0; i < length; i += 1)
+        result.push(value[i]);
+    return result;
+}
+function copyTextList(value, maximum = 2 ** 32 - 1) {
+    if (!Array.isArray(value))
+        return value;
+    const length = value.length;
+    // A plain array cannot represent a length above 2^32 - 1.
+    if (!Number.isSafeInteger(length) || length < 0 || length > 2 ** 32 - 1)
+        throw new TypeError("invalid_type");
+    const result = [];
+    for (let i = 0; i < Math.min(length, maximum); i += 1)
+        result.push(value[i]);
+    return result;
+}
+function checkOptions(settings) {
+    // Empty text always gives invalid_syntax after successful option checks.
+    // Every earlier code comes from the verifier, including copy failures.
+    const checked = decodeCharterRevision("", settings);
+    return !checked.ok && checked.code !== "invalid_syntax" ? { error: "invalid_input", code: checked.code } : null;
+}
+function signingOptions(opts, descriptor) {
+    try {
+        if (opts === null || typeof opts !== "object" || Array.isArray(opts) || opts instanceof Number) {
+            return { error: "invalid_input", code: "invalid_type" };
+        }
+        if (!Reflect.ownKeys(opts).every((key) => typeof key === "string" &&
+            (OPTION_KEYS.has(key) || descriptor && key === "predecessor"))) {
+            return { error: "invalid_input", code: "invalid_type" };
+        }
+        const supplied = opts;
+        const settings = {
+            limits: optionMembers(supplied.limits, Object.keys(DEFAULT_LIMITS)),
+        };
+        const limitsError = checkOptions(settings);
+        if (limitsError)
+            return limitsError;
+        settings.profile = optionMembers(supplied.profile, ["algorithms", "revisions"], {
+            algorithms: optionAlgorithms,
+            revisions: (range) => optionMembers(range, ["min", "max"]),
+        });
+        const profileError = checkOptions(settings);
+        if (profileError)
+            return profileError;
+        const algorithm = supplied.algorithm ?? defaultEmissionName();
+        if (typeof algorithm !== "string" || !Object.hasOwn(emissions(), algorithm)) {
+            return { error: "invalid_input", code: "algorithm_unsupported" };
+        }
+        if (!descriptor)
+            return { ...settings, algorithm };
+        const previous = supplied.predecessor;
+        const predecessor = optionMembers(previous, ["digest", "descriptor_digest", "lineage"], {
+            lineage: (value) => copyTextList(value),
+        });
+        return { ...settings, algorithm, predecessor: predecessor };
+    }
+    catch (fault) {
+        return { error: "invalid_input", code: fault === COPY_LIMIT ? "limit_exceeded" : "invalid_type" };
     }
 }
-// The shared custody tail (the reference signer's): identity snapshot ->
-// producer (framing, claims schema, R1-R3 refusals - one implementation,
-// in the verifier package) -> sign via the handle -> wrong-key guard.
-// A refusal or producer rejection never touches the key.
-async function signProduced(keyHandle, produce, opts) {
+function prepareError(code) {
+    switch (code) {
+        case "signing_refused":
+        case "signing_key_mismatch":
+            return { error: "refused", code };
+        case "signing_key_invalid":
+            return { error: "invalid_key_handle" };
+        case "algorithm_unsupported_on_substrate":
+            return { error: "algorithm_unsupported_on_substrate" };
+        default:
+            return { error: "invalid_input", code };
+    }
+}
+async function signPrepared(kind, claims, keyHandle, context, opts) {
+    const options = signingOptions(opts, kind === "descriptor");
+    if ("error" in options)
+        return options;
+    let retained;
+    try {
+        retained = kind === "descriptor" ? options.predecessor ?? null :
+            typeof context === "string" ? context : copyChainView(context);
+    }
+    catch (fault) {
+        return { error: "invalid_input", code: fault === COPY_LIMIT ? "limit_exceeded" : "invalid_type" };
+    }
+    try {
+        // Caller limits belong to preparation. The entry guard only stops values
+        // beyond every JSON limit the verifier can accept.
+        claims = copyClaims(claims);
+    }
+    catch (fault) {
+        return { error: "invalid_input", code: fault === COPY_LIMIT ? "signing_input_invalid" : "invalid_type" };
+    }
     const snapshot = await resolveKeyIdentity(keyHandle);
     if ("error" in snapshot)
         return snapshot;
-    const produced = produce(snapshot.kid, opts?.algorithm);
-    if (!produced.ok) {
-        // signing_refused is the honest-signer refusal; every other producer
-        // code stays caller input.
-        return produced.code === "signing_refused"
-            ? { error: "refused", code: produced.code }
-            : { error: "invalid_input", code: produced.code };
-    }
-    // The holder signs the exact message; a fault or a wrong-length result is
-    // a signing failure, never a silent pass.
+    const prepared = prepareSigning(kind, snapshot.kid, claims, snapshot.publicKey, retained, {
+        algorithm: options.algorithm,
+        limits: options.limits,
+        profile: options.profile,
+    });
+    if (!prepared.ok)
+        return prepareError(prepared.code);
+    const input = prepared.plan.input;
     let signature;
     try {
-        signature = await keyHandle.sign(produced.input.message, keyHandle);
+        signature = await keyHandle.sign(Buffer.from(input.message), keyHandle);
     }
     catch (_fault) {
         return { error: "signing_failed" };
     }
-    if (!(signature instanceof Uint8Array) || signature.length === 0) {
+    if (!ArrayBuffer.isView(signature) || byteArrayTag.call(signature) !== "Uint8Array") {
         return { error: "signing_failed" };
     }
-    const row = registryRow(produced.input.alg);
-    if (!row || signature.length !== row.signatureBytes) {
+    let checkedSignature;
+    try {
+        checkedSignature = Buffer.from(signature);
+    }
+    catch (_signature) {
         return { error: "signing_failed" };
     }
-    // The wrong-key guard: the signature MUST verify against the snapshot's
-    // public key under the minted algorithm.
-    if (!verifySignature(produced.input.message, Buffer.from(signature), snapshot.publicKey, produced.input.alg)) {
+    // The verifier's signature guard owns signature length checks.
+    if (!verifySignature(prepared.plan.input.message, checkedSignature, snapshot.publicKey, input.alg, {
+        limits: options.limits,
+        profile: options.profile,
+    })) {
         return { error: "signing_failed" };
     }
-    return { input: produced.input, signature: Buffer.from(signature) };
-}
-// Assembly goes through the verifier's assembleCompact: registry-row
-// length, framing re-decode, size gate - never a local string join.
-function compactOrInvalid(signed) {
-    const assembled = assembleCompact(signed.input, signed.signature);
-    if (!assembled.ok)
-        return { error: "invalid_input", code: assembled.code };
-    return { compact: assembled.compact };
-}
-// The view's chain is THIS package's public contract (the producer surface
-// validates its depth); the shallow shape is policed here so the closed
-// error vocabulary holds regardless of which verifier revision resolves.
-// A verifier crash past this gate stays loud - never a misleading error.
-function chainViewOrInvalid(chain) {
-    if (!chain || typeof chain !== "object" || Array.isArray(chain)) {
-        return { error: "invalid_input", code: "signing_input_invalid" };
-    }
-    return chain;
-}
-// A missing view object is caller input like a missing chain: the closed
-// error, never a dereference throw.
-function viewChainOrInvalid(view) {
-    if (!view || typeof view !== "object")
-        return { error: "invalid_input", code: "signing_input_invalid" };
-    return chainViewOrInvalid(view.chain);
+    const finished = finishSigning(prepared.plan, checkedSignature);
+    // No real-crypto path reaches this mapping after preparation and the
+    // custody guard succeed; keep it for a verifier completion error.
+    if (!finished.ok)
+        return { error: "verification_failed" };
+    return { compact: finished.compact };
 }
-// ---------------------------------------------------------------------------
-// Public signing surface
-// ---------------------------------------------------------------------------
 export async function signDescriptor(claims, keyHandle, opts = {}) {
-    const signed = await signProduced(keyHandle, (kid, algorithm) => descriptorSigningInput(kid, claims, algorithm), opts);
-    if ("error" in signed)
-        return { ok: false, ...signed };
-    const assembled = compactOrInvalid(signed);
-    if ("error" in assembled)
-        return { ok: false, ...assembled };
-    const verified = verifyDescriptor(assembled.compact);
-    if (!verified.ok)
-        return { ok: false, error: "verification_failed" };
-    return { ok: true, result: { descriptor: assembled.compact } };
+    const signed = await signPrepared("descriptor", claims, keyHandle, null, opts);
+    return "error" in signed ? { ok: false, ...signed } : { ok: true, result: { descriptor: signed.compact } };
 }
-export async function signReceipt(claims, keyHandle, chain, opts = {}) {
-    // The issuing view is REQUIRED (the reference takes ChainFacts or a
-    // CharterRevision, never none) and its discipline runs after the build,
-    // before the key - the reference's context is a verified ChainFacts by
-    // construction, so a TS view that fails the chain discipline is caller
-    // input, never a burned key operation.
-    const signed = await signProduced(keyHandle, (kid, algorithm) => {
-        const built = receiptSigningInput(kid, claims, algorithm);
-        if (!built.ok)
-            return built;
-        const resolved = chainViewOrInvalid(chain);
-        if ("error" in resolved)
-            return { ok: false, code: resolved.code };
-        if (!verifyChain(resolved).ok)
-            return { ok: false, code: "chain_invalid" };
-        return built;
-    }, opts);
-    if ("error" in signed)
-        return { ok: false, ...signed };
-    const assembled = compactOrInvalid(signed);
-    if ("error" in assembled)
-        return { ok: false, ...assembled };
-    const verified = verifyReceipt(assembled.compact, chain);
-    if (!verified.ok)
-        return { ok: false, error: "verification_failed" };
-    return { ok: true, result: { receipt: assembled.compact } };
+export async function signReceipt(claims, keyHandle, context, opts = {}) {
+    const signed = await signPrepared("receipt", claims, keyHandle, context, opts);
+    return "error" in signed ? { ok: false, ...signed } : { ok: true, result: { receipt: signed.compact } };
 }
-export async function signAcceptance(claims, keyHandle, view, opts = {}) {
-    const viewChain = viewChainOrInvalid(view);
-    const signed = await signProduced(keyHandle, (kid, algorithm) => {
-        if ("error" in viewChain)
-            return { ok: false, code: viewChain.code };
-        return acceptanceSigningInput(kid, claims, viewChain, algorithm);
-    }, opts);
-    if ("error" in signed)
-        return { ok: false, ...signed };
-    const assembled = compactOrInvalid(signed);
-    if ("error" in assembled)
-        return { ok: false, ...assembled };
-    const verified = verifyAcceptance(assembled.compact, view.revisionText, view.descriptorCompacts);
-    if (!verified.ok)
-        return { ok: false, error: "verification_failed" };
-    return { ok: true, result: { acceptance: assembled.compact } };
+export async function signAcceptance(claims, keyHandle, chain, opts = {}) {
+    const signed = await signPrepared("acceptance", claims, keyHandle, chain, opts);
+    return "error" in signed ? { ok: false, ...signed } : { ok: true, result: { acceptance: signed.compact } };
 }
-export async function signTermination(claims, keyHandle, view, opts = {}) {
-    const viewChain = viewChainOrInvalid(view);
-    const signed = await signProduced(keyHandle, (kid, algorithm) => {
-        if ("error" in viewChain)
-            return { ok: false, code: viewChain.code };
-        return terminationSigningInput(kid, claims, viewChain, algorithm);
-    }, opts);
-    if ("error" in signed)
-        return { ok: false, ...signed };
-    const assembled = compactOrInvalid(signed);
-    if ("error" in assembled)
-        return { ok: false, ...assembled };
-    const verified = verifyTermination(assembled.compact, view.revisionText, view.descriptorCompacts);
-    if (!verified.ok)
-        return { ok: false, error: "verification_failed" };
-    return { ok: true, result: { termination: assembled.compact } };
+export async function signTermination(claims, keyHandle, chain, opts = {}) {
+    const signed = await signPrepared("termination", claims, keyHandle, chain, opts);
+    return "error" in signed ? { ok: false, ...signed } : { ok: true, result: { termination: signed.compact } };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@charter-agreement-protocol/signer",
-  "version": "0.2.1",
-  "description": "Holder-side companion signer for the Charter Agreement Protocol (CAP) in TypeScript - key custody only: an atomic key snapshot, the sign callback, the wrong-key guard, and post-sign verification, with framing, the claims gate, the R1-R3 honest-signer refusals, and assembly all delegated to the @charter-agreement-protocol/verifier producer surface. CAP verifies; it never authorizes; this signer signs, it never verifies third-party artifacts or takes custody.",
+  "version": "0.3.0",
+  "description": "Holder-side companion signer for the Charter Agreement Protocol (CAP) in TypeScript - key custody only: an atomic key snapshot, the sign callback, the wrong-key guard, and post-sign verification, with framing, claims, context, key matching, limits, profile, and completion delegated to the @charter-agreement-protocol/verifier pre-sign API. CAP verifies; it never authorizes; this signer signs, it never verifies third-party artifacts or takes custody.",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,32 +15,37 @@
   },
   "files": [
     "CHANGELOG.md",
+    "CODE_OF_CONDUCT.md",
+    "CONTRIBUTING.md",
     "dist",
     "LICENSE",
     "NOTICE",
-    "README.md"
+    "README.md",
+    "SECURITY.md"
   ],
   "engines": {
     "node": ">=24.8.0"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
-    "test": "node --test --experimental-strip-types --no-warnings signer.test.ts",
+    "test": "node --test --experimental-strip-types --no-warnings signer.test.ts signer.browser.test.ts signer.cases.test.ts",
+    "test:cost": "node --test --experimental-strip-types --no-warnings signer.cost.test.ts",
+    "test:cases": "node --test --experimental-strip-types --no-warnings signer.cases.test.ts",
     "prepack": "npm run build",
     "typecheck:web": "tsc -p tsconfig.web.json",
     "build:site": "node web/build.mjs && esbuild web/main.ts --bundle --minify --format=iife --target=es2022 --outfile=site-dist/app.js --alias:node:crypto=./web/shim/node-crypto.ts --alias:node:fs=./web/shim/node-fs.ts --alias:node:path=./web/shim/node-path.ts --inject:./web/shim/buffer-global.ts"
   },
   "dependencies": {
-    "@charter-agreement-protocol/verifier": "^0.5.0"
+    "@charter-agreement-protocol/verifier": "^0.7.0"
   },
   "devDependencies": {
     "@noble/ed25519": "^3.2.0",
     "@noble/hashes": "^2.4.0",
-    "@types/node": "^26.5.1",
+    "@types/node": "^26.6.4",
     "buffer": "^6.0.3",
     "esbuild": "^0.28.2",
-    "typescript": "~5.9.0"
+    "typescript": "^7.0.2"
   },
   "repository": {
     "type": "git",