cesr-ts 0.5.0 → 0.7.0

package/README.md

@@ -25,16 +25,27 @@ const annotated = annotate(text, { domainHint: "txt", pretty: true });
 ## CLI usage
 
 ```bash
-npx cesr-annotate --in mystream.cesr --pretty
+npm exec --package cesr-ts -- tephra annotate --in mystream.cesr --pretty
+npm exec --package cesr-ts -- tephra validate --in mystream.cesr
+npm exec --package cesr-ts -- tephra bench --in mystream.cesr --iterations 20 --warmup 3
 ```
 
-## Deno CLI usage (from source)
+After global install:
 
 ```bash
-deno task cesr:annotate --in mystream.cesr --pretty
+tephra annotate --in mystream.cesr --pretty
+tephra validate --in mystream.cesr
+tephra bench --in mystream.cesr --iterations 20 --warmup 3
 ```
 
-## Benchmarking (from source)
+## Deno CLI usage (from repository root)
+
+```bash
+deno task tephra:annotate --in mystream.cesr --pretty
+deno task tephra:validate --in mystream.cesr
+```
+
+## Benchmarking (from repository root)
 
 Run standard parser benchmark baselines:
 
@@ -45,8 +56,8 @@ deno task bench:cesr
 Run a benchmark on an arbitrary stream:
 
 ```bash
-deno task bench:cesr:parser --in ../../samples/cesr-streams/CESR_1_0-oor-auth-vc.cesr
-cat ../../samples/cesr-streams/CESR_1_0-oor-auth-vc.cesr | deno task bench:cesr:parser --iterations 20 --warmup 3
+deno task tephra:bench --in ../../samples/cesr-streams/CESR_1_0-oor-auth-vc.cesr
+cat ../../samples/cesr-streams/CESR_1_0-oor-auth-vc.cesr | deno task tephra:bench --iterations 20 --warmup 3
 ```
 
 ## Using cesr-ts through tufa

package/esm/mod.js

@@ -1,3 +1,4 @@
+/** cesr-ts npm package root entrypoint. */
 import "./_dnt.polyfills.js";
 export * from "./src/index.js";
 export * from "./src/version.js";

package/esm/src/annotate/render.js

@@ -251,7 +251,10 @@ function renderFrame(frame, index, options) {
     const lines = [];
     const version = frame.body.gvrsn ?? frame.body.pvrsn;
     const domain = asDomain(frame.body.raw);
-    if (domain === "txt" || domain === "bny") {
+    if (frame.body.kind === "CESR" && frame.body.ked === null) {
+        renderMessageBody(lines, frame, options);
+    }
+    else if (domain === "txt" || domain === "bny") {
         renderNativeBody(lines, frame, options, version);
     }
     else {

package/esm/src/{annotate/cli.js → cli/commands/annotate.js}

@@ -1,5 +1,7 @@
-import { annotate } from "./annotator.js";
+import { annotate } from "../../annotate/annotator.js";
 const TEXT_DECODER = new TextDecoder();
+const ANNOTATE_USAGE = "Usage: tephra annotate [--in <path>] [--out <path>] [--qb2] [--pretty]";
+/** Parse `tephra annotate` command-line flags without performing IO. */
 function parseArgs(args) {
     const out = { qb2: false, pretty: false };
     for (let i = 0; i < args.length; i++) {
@@ -28,52 +30,21 @@ function parseArgs(args) {
             i++;
             continue;
         }
-        if (arg === "--help" || arg === "-h") {
-            throw new Error("Usage: cesr-annotate [--in <path>] [--out <path>] [--qb2] [--pretty]");
-        }
         throw new Error(`Unknown argument: ${arg}`);
     }
     return out;
 }
 /**
- * Read a full `ReadableStream` into one contiguous byte buffer.
+ * Execute `tephra annotate`.
  *
- * This is the shared browser/runtime-neutral helper used by annotate CLI
- * shims that expose stdin as a web stream instead of synchronous file APIs.
+ * The command preserves the old standalone annotation behavior while moving it
+ * under the package-level dispatcher.
  */
-export async function readAllReadable(stream) {
-    const reader = stream.getReader();
-    const chunks = [];
-    let total = 0;
-    try {
-        while (true) {
-            const { value, done } = await reader.read();
-            if (done)
-                break;
-            if (value) {
-                chunks.push(value);
-                total += value.length;
-            }
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, offset);
-        offset += chunk.length;
+export async function annotateCommand(args, io) {
+    if (args.includes("--help") || args.includes("-h")) {
+        await io.writeStdout(`${ANNOTATE_USAGE}\n`);
+        return 0;
     }
-    return out;
-}
-/**
- * Execute the standalone annotate CLI against the provided IO boundary.
- *
- * Error reporting is intentionally normalized here so runtime-specific entry
- * points can stay as thin bootstraps.
- */
-export async function annotateCli(args, io) {
     try {
         const options = parseArgs(args);
         const inputBytes = options.inPath
@@ -95,7 +66,7 @@ export async function annotateCli(args, io) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        await io.writeStderr(`cesr annotate error: ${message}\n`);
+        await io.writeStderr(`tephra annotate error: ${message}\n`);
         return 1;
     }
 }

package/esm/src/cli/commands/bench.js

@@ -0,0 +1,137 @@
+import { benchmarkCesrParser } from "../../bench/parser-benchmark.js";
+const BENCH_USAGE = "Usage: tephra bench [--in <path>] [--iterations <n>] [--warmup <n>] [--chunk-size <bytes>] [--framed] [--compat] [--allow-errors] [--json]";
+/** Parse non-negative integer flags used for sizing and warmup controls. */
+function parseNonNegativeInt(argName, value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`${argName} must be a non-negative integer`);
+    }
+    return parsed;
+}
+/** Parse strictly positive integer flags used for measured iteration count. */
+function parsePositiveInt(argName, value) {
+    const parsed = parseNonNegativeInt(argName, value);
+    if (parsed <= 0) {
+        throw new Error(`${argName} must be greater than 0`);
+    }
+    return parsed;
+}
+/** Parse `tephra bench` command-line flags without performing IO. */
+function parseArgs(args) {
+    const out = {
+        iterations: 50,
+        warmupIterations: 5,
+        chunkSize: 0,
+        framed: false,
+        attachmentDispatchMode: "strict",
+        allowErrors: false,
+        json: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--in") {
+            const next = args[i + 1];
+            if (!next)
+                throw new Error("Missing value for --in");
+            out.inPath = next;
+            i++;
+            continue;
+        }
+        if (arg === "--iterations") {
+            const next = args[i + 1];
+            if (!next)
+                throw new Error("Missing value for --iterations");
+            out.iterations = parsePositiveInt("--iterations", next);
+            i++;
+            continue;
+        }
+        if (arg === "--warmup") {
+            const next = args[i + 1];
+            if (!next)
+                throw new Error("Missing value for --warmup");
+            out.warmupIterations = parseNonNegativeInt("--warmup", next);
+            i++;
+            continue;
+        }
+        if (arg === "--chunk-size") {
+            const next = args[i + 1];
+            if (!next)
+                throw new Error("Missing value for --chunk-size");
+            out.chunkSize = parseNonNegativeInt("--chunk-size", next);
+            i++;
+            continue;
+        }
+        if (arg === "--framed") {
+            out.framed = true;
+            continue;
+        }
+        if (arg === "--compat") {
+            out.attachmentDispatchMode = "compat";
+            continue;
+        }
+        if (arg === "--allow-errors") {
+            out.allowErrors = true;
+            continue;
+        }
+        if (arg === "--json") {
+            out.json = true;
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    return out;
+}
+/** Render human-readable benchmark output for terminal workflows. */
+function formatHumanReadable(sourceLabel, result) {
+    const chunkLabel = result.chunkSize === result.bytesPerIteration
+        ? "full stream"
+        : `${result.chunkSize} bytes`;
+    return [
+        "CESR parser benchmark",
+        `source: ${sourceLabel}`,
+        `iterations: ${result.iterations} (warmup: ${result.warmupIterations})`,
+        `input bytes/iteration: ${result.bytesPerIteration}`,
+        `chunk size: ${chunkLabel}`,
+        `frames/iteration: ${(result.totalFrames / result.iterations).toFixed(2)}`,
+        `errors/iteration: ${(result.totalErrors / result.iterations).toFixed(2)}`,
+        `avg iteration: ${result.avgIterationMs.toFixed(3)} ms`,
+        `throughput: ${result.throughputMiBPerSec.toFixed(3)} MiB/s`,
+        `frame rate: ${result.framesPerSec.toFixed(2)} frames/s`,
+    ].join("\n");
+}
+/** Execute `tephra bench` using the existing parser benchmark engine. */
+export async function benchCommand(args, io) {
+    if (args.includes("--help") || args.includes("-h")) {
+        await io.writeStdout(`${BENCH_USAGE}\n`);
+        return 0;
+    }
+    try {
+        const options = parseArgs(args);
+        const sourceLabel = options.inPath ? options.inPath : "stdin";
+        const inputBytes = options.inPath
+            ? await io.readFile(options.inPath)
+            : await io.readStdin();
+        const result = benchmarkCesrParser(inputBytes, {
+            iterations: options.iterations,
+            warmupIterations: options.warmupIterations,
+            chunkSize: options.chunkSize,
+            parserOptions: {
+                framed: options.framed,
+                attachmentDispatchMode: options.attachmentDispatchMode,
+            },
+            failOnParseError: !options.allowErrors,
+        });
+        if (options.json) {
+            await io.writeStdout(`${JSON.stringify({ source: sourceLabel, ...result })}\n`);
+            return 0;
+        }
+        const rendered = formatHumanReadable(sourceLabel, result);
+        await io.writeStdout(`${rendered}\n`);
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await io.writeStderr(`tephra bench error: ${message}\n`);
+        return 1;
+    }
+}

package/esm/src/cli/commands/validate.js

@@ -0,0 +1,154 @@
+import { parseBytes } from "../../core/parser-engine.js";
+const VALIDATE_USAGE = "Usage: tephra validate [--in <path>] [--framed] [--compat] [--json]";
+/** Parse `tephra validate` command-line flags without performing IO. */
+function parseArgs(args) {
+    const out = {
+        framed: false,
+        attachmentDispatchMode: "strict",
+        json: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--in") {
+            const next = args[i + 1];
+            if (!next)
+                throw new Error("Missing value for --in");
+            out.inPath = next;
+            i++;
+            continue;
+        }
+        if (arg === "--framed") {
+            out.framed = true;
+            continue;
+        }
+        if (arg === "--compat") {
+            out.attachmentDispatchMode = "compat";
+            continue;
+        }
+        if (arg === "--json") {
+            out.json = true;
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    return out;
+}
+/**
+ * Convert parser errors into stable validation report entries.
+ *
+ * Parser error classes may carry useful location fields, but the CLI should not
+ * expose entire internal error objects as JSON. This function keeps the stable
+ * public fields and includes offset/context only when the parser supplied them.
+ */
+function describeError(error) {
+    const detail = {
+        name: error.name || "Error",
+        message: error.message,
+    };
+    const maybeParserError = error;
+    if (typeof maybeParserError.offset === "number") {
+        detail.offset = maybeParserError.offset;
+    }
+    if (typeof maybeParserError.context === "string") {
+        detail.context = maybeParserError.context;
+    }
+    return detail;
+}
+/**
+ * Count frames, attachment groups, and parser errors for one input stream.
+ *
+ * `tephra validate` is strict by default because a validation command should fail
+ * on ambiguous attachment dispatch. `--compat` intentionally relaxes that mode
+ * for streams that still rely on legacy mixed-major attachment behavior.
+ *
+ * Empty input is reported as a validation failure even though the parser has no
+ * malformed bytes to diagnose. A zero-frame stream is not useful evidence that a
+ * CESR payload is valid.
+ */
+function validateBytes(bytes, source, options) {
+    const events = parseBytes(bytes, {
+        framed: options.framed,
+        attachmentDispatchMode: options.attachmentDispatchMode,
+    });
+    const frames = events.filter((event) => event.type === "frame");
+    const errors = events
+        .filter((event) => event.type === "error")
+        .map((event) => describeError(event.error));
+    const attachmentGroupCount = frames.reduce((count, event) => count + event.frame.attachments.length, 0);
+    if (frames.length === 0 && errors.length === 0) {
+        errors.push({
+            name: "NoFramesError",
+            message: "No CESR frames parsed",
+        });
+    }
+    return {
+        ok: errors.length === 0,
+        source,
+        bytes: bytes.length,
+        frameCount: frames.length,
+        attachmentGroupCount,
+        errorCount: errors.length,
+        errors,
+    };
+}
+/** Render successful human-readable validation output. */
+function formatSuccess(report) {
+    return [
+        "CESR validation passed",
+        `source: ${report.source}`,
+        `bytes: ${report.bytes}`,
+        `frames: ${report.frameCount}`,
+        `attachment groups: ${report.attachmentGroupCount}`,
+    ].join("\n");
+}
+/** Render human-readable validation failure output with per-error details. */
+function formatFailure(report) {
+    const lines = [
+        "CESR validation failed",
+        `source: ${report.source}`,
+        `bytes: ${report.bytes}`,
+        `frames: ${report.frameCount}`,
+        `attachment groups: ${report.attachmentGroupCount}`,
+        `errors: ${report.errorCount}`,
+    ];
+    for (const error of report.errors) {
+        lines.push(`- ${error.name}: ${error.message}`);
+        if (error.offset !== undefined) {
+            lines.push(`  offset: ${error.offset}`);
+        }
+        if (error.context) {
+            lines.push(`  context: ${error.context}`);
+        }
+    }
+    return lines.join("\n");
+}
+/** Execute `tephra validate` against file input or stdin. */
+export async function validateCommand(args, io) {
+    if (args.includes("--help") || args.includes("-h")) {
+        await io.writeStdout(`${VALIDATE_USAGE}\n`);
+        return 0;
+    }
+    try {
+        const options = parseArgs(args);
+        const source = options.inPath ? options.inPath : "stdin";
+        const inputBytes = options.inPath
+            ? await io.readFile(options.inPath)
+            : await io.readStdin();
+        const report = validateBytes(inputBytes, source, options);
+        if (options.json) {
+            await io.writeStdout(`${JSON.stringify(report)}\n`);
+        }
+        else if (report.ok) {
+            await io.writeStdout(`${formatSuccess(report)}\n`);
+        }
+        else {
+            await io.writeStderr(`${formatFailure(report)}\n`);
+        }
+        return report.ok ? 0 : 1;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await io.writeStderr(`tephra validate error: ${message}\n`);
+        return 1;
+    }
+}

package/esm/src/cli/io-node.js

@@ -0,0 +1,45 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { stderr, stdin, stdout } from "node:process";
+/** Read Node stdin into one contiguous byte buffer for command execution. */
+async function readNodeStdin() {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of stdin) {
+        const bytes = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+        chunks.push(bytes);
+        total += bytes.length;
+    }
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+/** Write text to a Node stream and wait for completion or backpressure error. */
+async function writeNodeStream(stream, text) {
+    await new Promise((resolve, reject) => {
+        stream.write(text, (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}
+/** Create the Node runtime IO adapter for the package-level `tephra` CLI. */
+export function createNodeCliIo() {
+    return {
+        readFile: async (path) => {
+            const data = await readFile(path);
+            return new Uint8Array(data);
+        },
+        writeTextFile: async (path, text) => {
+            await writeFile(path, text, "utf8");
+        },
+        readStdin: readNodeStdin,
+        writeStdout: (text) => writeNodeStream(stdout, text),
+        writeStderr: (text) => writeNodeStream(stderr, text),
+    };
+}

package/esm/src/cli/main.js

@@ -0,0 +1,42 @@
+import { annotateCommand } from "./commands/annotate.js";
+import { benchCommand } from "./commands/bench.js";
+import { validateCommand } from "./commands/validate.js";
+const COMMANDS = {
+    annotate: annotateCommand,
+    validate: validateCommand,
+    bench: benchCommand,
+};
+const TEPHRA_USAGE = [
+    "Usage: tephra <command> [options]",
+    "",
+    "Commands:",
+    "  annotate   Annotate a CESR stream",
+    "  validate   Validate a CESR stream",
+    "  bench      Benchmark CESR parser throughput",
+    "",
+    "Run `tephra <command> --help` for command-specific options.",
+].join("\n");
+/**
+ * Execute the package-level `tephra` CLI dispatcher.
+ *
+ * This function owns only command selection and top-level usage behavior. Each
+ * subcommand receives the already-selected argument tail plus a runtime-neutral
+ * IO adapter, so command behavior remains identical under Deno and Node.
+ */
+export async function tephraCli(args, io) {
+    const [command, ...commandArgs] = args;
+    if (command === "--help" || command === "-h") {
+        await io.writeStdout(`${TEPHRA_USAGE}\n`);
+        return 0;
+    }
+    if (!command) {
+        await io.writeStderr(`${TEPHRA_USAGE}\n`);
+        return 1;
+    }
+    const handler = COMMANDS[command];
+    if (!handler) {
+        await io.writeStderr(`Unknown tephra command: ${command}\n${TEPHRA_USAGE}\n`);
+        return 1;
+    }
+    return await handler(commandArgs, io);
+}

package/esm/src/cli/node.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * npm executable entrypoint for the package-level `tephra` CLI.
+ *
+ * The CESR npm build discovers this file by the marker text in this comment and
+ * prepends a Node shebang after DNT emits JavaScript. Keep this launcher thin so
+ * Deno-only APIs do not leak into the Node executable path.
+ */
+import "../../_dnt.polyfills.js";
+import { argv, exit } from "node:process";
+import { createNodeCliIo } from "./io-node.js";
+import { tephraCli } from "./main.js";
+const code = await tephraCli(argv.slice(2), createNodeCliIo());
+exit(code);

package/esm/src/cli/types.js

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

package/esm/src/core/parser-frame-parser.js

@@ -242,14 +242,18 @@ export class FrameParser {
             };
         }
         catch (_error) {
+            // Non-native body groups wrap one Matter primitive. If Serder hydration
+            // fails, expose the primitive body bytes only; callers that inspect the
+            // fallback should not see the surrounding group counter envelope.
+            const raw = matter.raw;
             return {
                 frame: {
                     body: {
-                        raw: matter.raw,
+                        raw,
                         ked: null,
                         proto: Protocols.keri,
                         kind: Kinds.cesr,
-                        size: matter.raw.length,
+                        size: raw.length,
                         pvrsn: version,
                         gvrsn: version,
                         ilk: null,

package/esm/src/primitives/matter.js

@@ -41,6 +41,13 @@ function matterNameForCode(code) {
     }
     return name;
 }
+/**
+ * Select the concrete variable-length Matter code for the raw payload size.
+ *
+ * Variable families encode lead bytes and soft-size width in the selector
+ * itself. Normalizing once during construction keeps generated qb64/qb2 forms
+ * deterministic without leaking that sizing policy to primitive callers.
+ */
 function normalizeVariableMatterCode(code, raw) {
     const sizage = MATTER_SIZES.get(code);
     if (!sizage || sizage.fs !== null) {

package/esm/src/tables/counter.tables.generated.js

@@ -1,3 +1,4 @@
+export { COUNTER_HARDS } from "./hard-code-tables.js";
 export const COUNTER_SIZES_V1 = new Map([
     ["-_AAA", { hs: 5, ss: 3, fs: 8 }],
     ["--L", { hs: 3, ss: 5, fs: 8 }],
@@ -84,11 +85,6 @@ export const COUNTER_SIZES_V2 = new Map([
     ["-Y", { hs: 2, ss: 2, fs: 4 }],
     ["-Z", { hs: 2, ss: 2, fs: 4 }],
 ]);
-export const COUNTER_HARDS = new Map([
-    ..."ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("").map((c) => [`-${c}`, 2]),
-    ["--", 3],
-    ["-_", 5],
-]);
 export const COUNTER_CODE_NAMES_V1 = {
     "-_AAA": "KERIACDCGenusVersion",
     "--L": "BigPathedMaterialCouples",

package/esm/src/tables/hard-code-tables.js

@@ -0,0 +1,39 @@
+/**
+ * Source-owned hard-code size tables used by generated CESR lookup modules.
+ *
+ * KERIpy derives these ranges procedurally rather than listing them alongside
+ * the generated size/name dictionaries. Keeping them here avoids embedding
+ * static table literals inside the generator while preserving the public
+ * generated-module exports.
+ */
+/** Hard-code byte counts for Matter derivation code prefixes. */
+export const MATTER_HARDS = new Map([
+    ..."ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((c) => [c, 1]),
+    ..."abcdefghijklmnopqrstuvwxyz".split("").map((c) => [c, 1]),
+    ["0", 2],
+    ["1", 4],
+    ["2", 4],
+    ["3", 4],
+    ["4", 2],
+    ["5", 2],
+    ["6", 2],
+    ["7", 4],
+    ["8", 4],
+    ["9", 4],
+]);
+/** Hard-code byte counts for Indexer derivation code prefixes. */
+export const INDEXER_HARDS = new Map([
+    ..."ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((c) => [c, 1]),
+    ..."abcdefghijklmnopqrstuvwxyz".split("").map((c) => [c, 1]),
+    ["0", 2],
+    ["1", 2],
+    ["2", 2],
+    ["3", 2],
+    ["4", 2],
+]);
+/** Hard-code byte counts for Counter code prefixes. */
+export const COUNTER_HARDS = new Map([
+    ..."ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("").map((c) => [`-${c}`, 2]),
+    ["--", 3],
+    ["-_", 5],
+]);

package/esm/src/tables/indexer.tables.generated.js

@@ -1,3 +1,4 @@
+export { INDEXER_HARDS } from "./hard-code-tables.js";
 export const INDEXER_SIZES = new Map([
     ["0A", { hs: 2, ss: 2, os: 1, fs: 156, ls: 0 }],
     ["0B", { hs: 2, ss: 2, os: 1, fs: 156, ls: 0 }],
@@ -61,12 +62,3 @@ export const INDEXER_CODES_BY_NAME = {
     "TBD1": "1z",
     "TBD4": "4z",
 };
-export const INDEXER_HARDS = new Map([
-    ..."ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((c) => [c, 1]),
-    ..."abcdefghijklmnopqrstuvwxyz".split("").map((c) => [c, 1]),
-    ["0", 2],
-    ["1", 2],
-    ["2", 2],
-    ["3", 2],
-    ["4", 2],
-]);

package/esm/src/tables/matter.tables.generated.js

@@ -1,3 +1,4 @@
+export { MATTER_HARDS } from "./hard-code-tables.js";
 export const MATTER_SIZES = new Map([
     ["0A", { hs: 2, ss: 0, xs: 0, fs: 24, ls: 0 }],
     ["0B", { hs: 2, ss: 0, xs: 0, fs: 88, ls: 0 }],
@@ -334,17 +335,3 @@ export const MATTER_CODES_BY_NAME = {
     "X448": "L",
     "Yes": "1AAM",
 };
-export const MATTER_HARDS = new Map([
-    ..."ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((c) => [c, 1]),
-    ..."abcdefghijklmnopqrstuvwxyz".split("").map((c) => [c, 1]),
-    ["0", 2],
-    ["1", 4],
-    ["2", 4],
-    ["3", 4],
-    ["4", 2],
-    ["5", 2],
-    ["6", 2],
-    ["7", 4],
-    ["8", 4],
-    ["9", 4],
-]);

package/esm/src/version.js

@@ -1,11 +1,14 @@
 /**
- * Generated by scripts/generate_versions.ts.
- * Do not edit by hand.
+ * Template used by scripts/generate_versions.ts for package version modules.
+ *
+ * The generator token-replaces the string placeholders below, then formats and
+ * compares the rendered output during version checks. Do not edit generated
+ * `src/version.ts` files by hand; edit this template instead.
  */
 /** Package semantic version copied from the owning package manifest. */
-export const PACKAGE_VERSION = "0.5.0";
+export const PACKAGE_VERSION = "0.7.0";
 /** Optional build metadata stamp injected by release/CI workflows. */
-export const BUILD_METADATA = "build.5.d6fc2b59e3bc691c9cf61654afbc3417593163ee";
+export const BUILD_METADATA = "build.7.6ebe132d252df25f649be23d4c6c62de41e23dec";
 /** User-facing version string with build metadata appended when present. */
 export const DISPLAY_VERSION = BUILD_METADATA
     ? `${PACKAGE_VERSION}+${BUILD_METADATA}`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cesr-ts",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "CESR parser, primitives, and annotation tooling for TypeScript/JavaScript",
   "homepage": "https://github.com/kentbull/keri-ts/tree/main/packages/cesr",
   "repository": {
@@ -19,12 +19,6 @@
     ".": {
       "import": "./esm/mod.js",
       "types": "./types/mod.d.ts"
-    },
-    "./src/annotate/cli-node.js": {
-      "import": {
-        "types": "./types/src/annotate/cli-node.d.ts",
-        "default": "./esm/src/annotate/cli-node.js"
-      }
     }
   },
   "scripts": {
@@ -34,7 +28,7 @@
   "type": "module",
   "sideEffects": false,
   "bin": {
-    "cesr-annotate": "./esm/src/annotate/cli-node.js"
+    "tephra": "esm/src/cli/node.js"
   },
   "files": [
     "esm",
@@ -54,4 +48,4 @@
     "libsodium-wrappers": "^0.8.2"
   },
   "_generatedBy": "dnt@dev"
-}
+}

package/types/mod.d.ts

@@ -1,3 +1,4 @@
+/** cesr-ts npm package root entrypoint. */
 import "./_dnt.polyfills.js";
 export * from "./src/index.js";
 export * from "./src/version.js";

package/types/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,OAAO,qBAAqB,CAAC;AAE7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}

package/types/src/annotate/render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../src/src/annotate/render.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAUpD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAqelE;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,GACjC,MAAM,GAAG,IAAI,CAaf;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,WAAW,EAAE,EACrB,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,GACjC,cAAc,EAAE,CAElB"}
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../src/src/annotate/render.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAUpD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAuelE;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,GACjC,MAAM,GAAG,IAAI,CAaf;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,WAAW,EAAE,EACrB,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,GACjC,cAAc,EAAE,CAElB"}

package/types/src/cli/commands/annotate.d.ts

@@ -0,0 +1,9 @@
+import type { CliIo } from "../types.js";
+/**
+ * Execute `tephra annotate`.
+ *
+ * The command preserves the old standalone annotation behavior while moving it
+ * under the package-level dispatcher.
+ */
+export declare function annotateCommand(args: string[], io: CliIo): Promise<number>;
+//# sourceMappingURL=annotate.d.ts.map

package/types/src/cli/commands/annotate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotate.d.ts","sourceRoot":"","sources":["../../../../src/src/cli/commands/annotate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AA4CzC;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CA+BhF"}

package/types/src/cli/commands/bench.d.ts

@@ -0,0 +1,4 @@
+import type { CliIo } from "../types.js";
+/** Execute `tephra bench` using the existing parser benchmark engine. */
+export declare function benchCommand(args: string[], io: CliIo): Promise<number>;
+//# sourceMappingURL=bench.d.ts.map

package/types/src/cli/commands/bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bench.d.ts","sourceRoot":"","sources":["../../../../src/src/cli/commands/bench.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AA+HzC,yEAAyE;AACzE,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAuC7E"}

package/types/src/cli/commands/validate.d.ts

@@ -0,0 +1,4 @@
+import type { CliIo } from "../types.js";
+/** Execute `tephra validate` against file input or stdin. */
+export declare function validateCommand(args: string[], io: CliIo): Promise<number>;
+//# sourceMappingURL=validate.d.ts.map

package/types/src/cli/commands/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/src/cli/commands/validate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAwKzC,6DAA6D;AAC7D,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BhF"}

package/types/src/cli/io-node.d.ts

@@ -0,0 +1,4 @@
+import type { CliIo } from "./types.js";
+/** Create the Node runtime IO adapter for the package-level `tephra` CLI. */
+export declare function createNodeCliIo(): CliIo;
+//# sourceMappingURL=io-node.d.ts.map

package/types/src/cli/io-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"io-node.d.ts","sourceRoot":"","sources":["../../../src/src/cli/io-node.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAkCxC,6EAA6E;AAC7E,wBAAgB,eAAe,IAAI,KAAK,CAavC"}

package/types/src/cli/main.d.ts

@@ -0,0 +1,10 @@
+import type { CliIo } from "./types.js";
+/**
+ * Execute the package-level `tephra` CLI dispatcher.
+ *
+ * This function owns only command selection and top-level usage behavior. Each
+ * subcommand receives the already-selected argument tail plus a runtime-neutral
+ * IO adapter, so command behavior remains identical under Deno and Node.
+ */
+export declare function tephraCli(args: string[], io: CliIo): Promise<number>;
+//# sourceMappingURL=main.d.ts.map

package/types/src/cli/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/src/cli/main.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAc,KAAK,EAAE,MAAM,YAAY,CAAC;AAmBpD;;;;;;GAMG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAkB1E"}

package/types/src/cli/node.d.ts

@@ -0,0 +1,9 @@
+/**
+ * npm executable entrypoint for the package-level `tephra` CLI.
+ *
+ * The CESR npm build discovers this file by the marker text in this comment and
+ * prepends a Node shebang after DNT emits JavaScript. Keep this launcher thin so
+ * Deno-only APIs do not leak into the Node executable path.
+ */
+import "../../_dnt.polyfills.js";
+//# sourceMappingURL=node.d.ts.map

package/types/src/cli/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/src/cli/node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,yBAAyB,CAAC"}

package/types/src/cli/types.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Runtime-neutral IO boundary for CESR CLI commands.
+ *
+ * Command modules should depend on this interface instead of importing Deno or
+ * Node APIs directly. That keeps `tephra annotate`, `tephra validate`, and
+ * `tephra bench` executable from both the Deno launcher and the npm/Node launcher.
+ */
+export interface CliIo {
+    /** Read one complete input file as raw CESR bytes. */
+    readFile(path: string): Promise<Uint8Array>;
+    /** Write command output to a text file, used by `tephra annotate --out`. */
+    writeTextFile(path: string, text: string): Promise<void>;
+    /** Read stdin as raw CESR bytes when `--in` is omitted. */
+    readStdin(): Promise<Uint8Array>;
+    /** Write terminal output intended for successful command output. */
+    writeStdout(text: string): Promise<void>;
+    /** Write terminal output intended for usage errors or validation failures. */
+    writeStderr(text: string): Promise<void>;
+}
+/** Shared command contract for package-level CESR CLI subcommands. */
+export type CliCommand = (args: string[], io: CliIo) => Promise<number>;
+//# sourceMappingURL=types.d.ts.map

package/types/src/cli/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/src/cli/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,KAAK;IACpB,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5C,4EAA4E;IAC5E,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,2DAA2D;IAC3D,SAAS,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IACjC,oEAAoE;IACpE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,8EAA8E;IAC9E,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC"}

package/types/src/core/parser-frame-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser-frame-parser.d.ts","sourceRoot":"","sources":["../../../src/src/core/parser-frame-parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AAUnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAyB3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,wEAAwE;AACxE,UAAU,kBAAkB;IAC1B,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,+BAA+B,EAAE,+BAA+B,CAAC;IACjE,gBAAgB,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,IAAI,CAAC;IAClD,0BAA0B,CAAC,EAAE,0BAA0B,CAAC;CACzD;AAED,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,UAAU,CAAC;IACpB,aAAa,EAAE,UAAU,CAAC;CAC3B;AAwED;;;;;;;GAOG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAsB;IAC1D,OAAO,CAAC,QAAQ,CAAC,+BAA+B,CAAkC;IAClF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkC;IACnE,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAAC,CAA6B;gBAE7D,OAAO,EAAE,kBAAkB;IAOvC,0EAA0E;IAC1E,oBAAoB,CAClB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,KAAK,GAAG,KAAK,GAClB,OAAO;IAKV;;;OAGG;IACH,UAAU,CACR,KAAK,EAAE,UAAU,EACjB,gBAAgB,GAAE,UAA4B,GAC7C,gBAAgB;IAKnB;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IA4G7B,2EAA2E;IAC3E,OAAO,CAAC,yBAAyB;IA2FjC,qFAAqF;IACrF,OAAO,CAAC,4BAA4B;IA6BpC;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAkD/B,4EAA4E;IAC5E,OAAO,CAAC,oBAAoB;IAuD5B;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAoCzB,0EAA0E;IAC1E,OAAO,CAAC,kBAAkB;IAuE1B,qFAAqF;IACrF,OAAO,CAAC,kBAAkB;IAqD1B,+EAA+E;IAC/E,OAAO,CAAC,oBAAoB;IAa5B,gFAAgF;IAChF,OAAO,CAAC,qBAAqB;IAoC7B,yEAAyE;IACzE,OAAO,CAAC,yBAAyB;IAuCjC,8EAA8E;IAC9E,OAAO,CAAC,6BAA6B;IAmBrC,iFAAiF;IACjF,OAAO,CAAC,sBAAsB;IA2D9B,mFAAmF;IACnF,OAAO,CAAC,0BAA0B;IAyClC,0EAA0E;IAC1E,OAAO,CAAC,kBAAkB;IAgB1B,8DAA8D;IAC9D,OAAO,CAAC,eAAe;IA6BvB,oFAAoF;IACpF,OAAO,CAAC,wBAAwB;CA8CjC"}
+{"version":3,"file":"parser-frame-parser.d.ts","sourceRoot":"","sources":["../../../src/src/core/parser-frame-parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AAUnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAyB3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,wEAAwE;AACxE,UAAU,kBAAkB;IAC1B,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,+BAA+B,EAAE,+BAA+B,CAAC;IACjE,gBAAgB,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,IAAI,CAAC;IAClD,0BAA0B,CAAC,EAAE,0BAA0B,CAAC;CACzD;AAED,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,UAAU,CAAC;IACpB,aAAa,EAAE,UAAU,CAAC;CAC3B;AAwED;;;;;;;GAOG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAsB;IAC1D,OAAO,CAAC,QAAQ,CAAC,+BAA+B,CAAkC;IAClF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkC;IACnE,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAAC,CAA6B;gBAE7D,OAAO,EAAE,kBAAkB;IAOvC,0EAA0E;IAC1E,oBAAoB,CAClB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,KAAK,GAAG,KAAK,GAClB,OAAO;IAKV;;;OAGG;IACH,UAAU,CACR,KAAK,EAAE,UAAU,EACjB,gBAAgB,GAAE,UAA4B,GAC7C,gBAAgB;IAKnB;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IA4G7B,2EAA2E;IAC3E,OAAO,CAAC,yBAAyB;IA2FjC,qFAAqF;IACrF,OAAO,CAAC,4BAA4B;IA6BpC;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAsD/B,4EAA4E;IAC5E,OAAO,CAAC,oBAAoB;IAuD5B;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAoCzB,0EAA0E;IAC1E,OAAO,CAAC,kBAAkB;IAuE1B,qFAAqF;IACrF,OAAO,CAAC,kBAAkB;IAqD1B,+EAA+E;IAC/E,OAAO,CAAC,oBAAoB;IAa5B,gFAAgF;IAChF,OAAO,CAAC,qBAAqB;IAoC7B,yEAAyE;IACzE,OAAO,CAAC,yBAAyB;IAuCjC,8EAA8E;IAC9E,OAAO,CAAC,6BAA6B;IAmBrC,iFAAiF;IACjF,OAAO,CAAC,sBAAsB;IA2D9B,mFAAmF;IACnF,OAAO,CAAC,0BAA0B;IAyClC,0EAA0E;IAC1E,OAAO,CAAC,kBAAkB;IAgB1B,8DAA8D;IAC9D,OAAO,CAAC,eAAe;IA6BvB,oFAAoF;IACpF,OAAO,CAAC,wBAAwB;CA8CjC"}

package/types/src/primitives/matter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matter.d.ts","sourceRoot":"","sources":["../../../src/src/primitives/matter.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAIjD;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AAED,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,UAAU,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AA6QD;;;;;;GAMG;AACH,qBAAa,MAAM;IACjB,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACjC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IACpC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACjC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IACrC,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAE3B,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU;IAclD,SAAS,CAAC,YAAY,IAAI,UAAU;IAUpC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,uEAAuE;IACvE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,yEAAyE;IACzE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,iEAAiE;IACjE,IAAI,IAAI,IAAI,MAAM,CAMjB;IAED;;;;;OAKG;IACH,IAAI,IAAI,IAAI,MAAM,GAAG,IAAI,CAExB;IAED,qDAAqD;IACrD,IAAI,IAAI,IAAI,MAAM,CAGjB;IAED,IAAI,GAAG,IAAI,UAAU,CAEpB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,KAAK,IAAI,UAAU,CAEtB;IAED,IAAI,GAAG,IAAI,UAAU,CAEpB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,2DAA2D;IAC3D,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,wDAAwD;IACxD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,4DAA4D;IAC5D,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,uEAAuE;IACvE,IAAI,OAAO,IAAI,OAAO,CAGrB;IAED,6EAA6E;IAC7E,IAAI,UAAU,IAAI,OAAO,CAMxB;IAED,MAAM,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO;IAIxC,QAAQ,IAAI,MAAM;IAIlB,yDAAyD;IACzD,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI3C,+DAA+D;IAC/D,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAQ5C,yDAAyD;IACzD,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAG7C;AAED,gDAAgD;AAChD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE7D;AAED,kDAAkD;AAClD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE/D;AAED,kFAAkF;AAClF,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,OAAO,CAAC,QAAQ,EAAE,KAAK,GAAG,KAAK,CAAC,GACrC,MAAM,CAIR"}
+{"version":3,"file":"matter.d.ts","sourceRoot":"","sources":["../../../src/src/primitives/matter.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAIjD;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AAED,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,UAAU,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AA8RD;;;;;;GAMG;AACH,qBAAa,MAAM;IACjB,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACjC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IACpC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACjC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IACrC,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAE3B,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU;IAclD,SAAS,CAAC,YAAY,IAAI,UAAU;IAUpC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,uEAAuE;IACvE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,yEAAyE;IACzE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,iEAAiE;IACjE,IAAI,IAAI,IAAI,MAAM,CAMjB;IAED;;;;;OAKG;IACH,IAAI,IAAI,IAAI,MAAM,GAAG,IAAI,CAExB;IAED,qDAAqD;IACrD,IAAI,IAAI,IAAI,MAAM,CAGjB;IAED,IAAI,GAAG,IAAI,UAAU,CAEpB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,KAAK,IAAI,UAAU,CAEtB;IAED,IAAI,GAAG,IAAI,UAAU,CAEpB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,2DAA2D;IAC3D,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,wDAAwD;IACxD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,4DAA4D;IAC5D,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,uEAAuE;IACvE,IAAI,OAAO,IAAI,OAAO,CAGrB;IAED,6EAA6E;IAC7E,IAAI,UAAU,IAAI,OAAO,CAMxB;IAED,MAAM,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO;IAIxC,QAAQ,IAAI,MAAM;IAIlB,yDAAyD;IACzD,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI3C,+DAA+D;IAC/D,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAQ5C,yDAAyD;IACzD,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAG7C;AAED,gDAAgD;AAChD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE7D;AAED,kDAAkD;AAClD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE/D;AAED,kFAAkF;AAClF,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,OAAO,CAAC,QAAQ,EAAE,KAAK,GAAG,KAAK,CAAC,GACrC,MAAM,CAIR"}

package/types/src/tables/counter.tables.generated.d.ts

@@ -1,7 +1,7 @@
 import type { Cizage } from "./table-types.js";
+export { COUNTER_HARDS } from "./hard-code-tables.js";
 export declare const COUNTER_SIZES_V1: Map<string, Cizage>;
 export declare const COUNTER_SIZES_V2: Map<string, Cizage>;
-export declare const COUNTER_HARDS: Map<string, number>;
 export declare const COUNTER_CODE_NAMES_V1: {
     readonly "-_AAA": "KERIACDCGenusVersion";
     readonly "--L": "BigPathedMaterialCouples";

package/types/src/tables/counter.tables.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"counter.tables.generated.d.ts","sourceRoot":"","sources":["../../../src/src/tables/counter.tables.generated.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,eAAO,MAAM,gBAAgB,qBAyB3B,CAAC;AAEH,eAAO,MAAM,gBAAgB,qBA2D3B,CAAC;AAEH,eAAO,MAAM,aAAa,qBAIxB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DxB,CAAC"}
+{"version":3,"file":"counter.tables.generated.d.ts","sourceRoot":"","sources":["../../../src/src/tables/counter.tables.generated.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,eAAO,MAAM,gBAAgB,qBAyB3B,CAAC;AAEH,eAAO,MAAM,gBAAgB,qBA2D3B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DxB,CAAC"}

package/types/src/tables/hard-code-tables.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Source-owned hard-code size tables used by generated CESR lookup modules.
+ *
+ * KERIpy derives these ranges procedurally rather than listing them alongside
+ * the generated size/name dictionaries. Keeping them here avoids embedding
+ * static table literals inside the generator while preserving the public
+ * generated-module exports.
+ */
+/** Hard-code byte counts for Matter derivation code prefixes. */
+export declare const MATTER_HARDS: Map<string, number>;
+/** Hard-code byte counts for Indexer derivation code prefixes. */
+export declare const INDEXER_HARDS: Map<string, number>;
+/** Hard-code byte counts for Counter code prefixes. */
+export declare const COUNTER_HARDS: Map<string, number>;
+//# sourceMappingURL=hard-code-tables.d.ts.map

package/types/src/tables/hard-code-tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hard-code-tables.d.ts","sourceRoot":"","sources":["../../../src/src/tables/hard-code-tables.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,iEAAiE;AACjE,eAAO,MAAM,YAAY,qBAavB,CAAC;AAEH,kEAAkE;AAClE,eAAO,MAAM,aAAa,qBAQxB,CAAC;AAEH,uDAAuD;AACvD,eAAO,MAAM,aAAa,qBAIxB,CAAC"}

package/types/src/tables/indexer.tables.generated.d.ts

@@ -1,4 +1,5 @@
 import type { Xizage } from "./table-types.js";
+export { INDEXER_HARDS } from "./hard-code-tables.js";
 export declare const INDEXER_SIZES: Map<string, Xizage>;
 export declare const INDEXER_CODE_NAMES: {
     readonly "0A": "Ed448_Sig";
@@ -42,5 +43,4 @@ export declare const INDEXER_CODES_BY_NAME: {
     readonly TBD1: "1z";
     readonly TBD4: "4z";
 };
-export declare const INDEXER_HARDS: Map<string, number>;
 //# sourceMappingURL=indexer.tables.generated.d.ts.map

package/types/src/tables/indexer.tables.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"indexer.tables.generated.d.ts","sourceRoot":"","sources":["../../../src/src/tables/indexer.tables.generated.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,eAAO,MAAM,aAAa,qBAoBxB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;CAoBrB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;CAoBxB,CAAC;AAEX,eAAO,MAAM,aAAa,qBAQxB,CAAC"}
+{"version":3,"file":"indexer.tables.generated.d.ts","sourceRoot":"","sources":["../../../src/src/tables/indexer.tables.generated.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,eAAO,MAAM,aAAa,qBAoBxB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;CAoBrB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;CAoBxB,CAAC"}

package/types/src/tables/matter.tables.generated.d.ts

@@ -1,4 +1,5 @@
 import type { Sizage } from "./table-types.js";
+export { MATTER_HARDS } from "./hard-code-tables.js";
 export declare const MATTER_SIZES: Map<string, Sizage>;
 export declare const MATTER_CODE_NAMES: {
     readonly "0A": "Salt_128";
@@ -224,5 +225,4 @@ export declare const MATTER_CODES_BY_NAME: {
     readonly X448: "L";
     readonly Yes: "1AAM";
 };
-export declare const MATTER_HARDS: Map<string, number>;
 //# sourceMappingURL=matter.tables.generated.d.ts.map

package/types/src/tables/matter.tables.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matter.tables.generated.d.ts","sourceRoot":"","sources":["../../../src/src/tables/matter.tables.generated.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,eAAO,MAAM,YAAY,qBA+GvB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+GpB,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+GvB,CAAC;AAEX,eAAO,MAAM,YAAY,qBAavB,CAAC"}
+{"version":3,"file":"matter.tables.generated.d.ts","sourceRoot":"","sources":["../../../src/src/tables/matter.tables.generated.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,eAAO,MAAM,YAAY,qBA+GvB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+GpB,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+GvB,CAAC"}

package/types/src/version.d.ts

@@ -1,11 +1,14 @@
 /**
- * Generated by scripts/generate_versions.ts.
- * Do not edit by hand.
+ * Template used by scripts/generate_versions.ts for package version modules.
+ *
+ * The generator token-replaces the string placeholders below, then formats and
+ * compares the rendered output during version checks. Do not edit generated
+ * `src/version.ts` files by hand; edit this template instead.
  */
 /** Package semantic version copied from the owning package manifest. */
-export declare const PACKAGE_VERSION = "0.5.0";
+export declare const PACKAGE_VERSION = "0.7.0";
 /** Optional build metadata stamp injected by release/CI workflows. */
-export declare const BUILD_METADATA = "build.5.d6fc2b59e3bc691c9cf61654afbc3417593163ee";
+export declare const BUILD_METADATA = "build.7.6ebe132d252df25f649be23d4c6c62de41e23dec";
 /** User-facing version string with build metadata appended when present. */
 export declare const DISPLAY_VERSION: string;
 //# sourceMappingURL=version.d.ts.map

package/types/src/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/src/version.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wEAAwE;AACxE,eAAO,MAAM,eAAe,UAAU,CAAC;AACvC,sEAAsE;AACtE,eAAO,MAAM,cAAc,qDAAqD,CAAC;AACjF,4EAA4E;AAC5E,eAAO,MAAM,eAAe,QAET,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/src/version.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wEAAwE;AACxE,eAAO,MAAM,eAAe,UAAU,CAAC;AACvC,sEAAsE;AACtE,eAAO,MAAM,cAAc,qDAAqD,CAAC;AACjF,4EAA4E;AAC5E,eAAO,MAAM,eAAe,QAET,CAAC"}

package/esm/src/annotate/cli-node.js

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-import "../../_dnt.polyfills.js";
-import { readFile, writeFile } from "node:fs/promises";
-import { argv, exit, stderr, stdin, stdout } from "node:process";
-import { annotateCli } from "./cli.js";
-async function readNodeStdin() {
-    const chunks = [];
-    let total = 0;
-    for await (const chunk of stdin) {
-        const bytes = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
-        chunks.push(bytes);
-        total += bytes.length;
-    }
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return out;
-}
-const NODE_IO = {
-    readFile: async (path) => {
-        const data = await readFile(path);
-        return new Uint8Array(data);
-    },
-    writeTextFile: async (path, text) => {
-        await writeFile(path, text, "utf8");
-    },
-    readStdin: readNodeStdin,
-    writeStdout: async (text) => {
-        await new Promise((resolve, reject) => {
-            stdout.write(text, (error) => {
-                if (error)
-                    reject(error);
-                else
-                    resolve();
-            });
-        });
-    },
-    writeStderr: async (text) => {
-        await new Promise((resolve, reject) => {
-            stderr.write(text, (error) => {
-                if (error)
-                    reject(error);
-                else
-                    resolve();
-            });
-        });
-    },
-};
-const code = await annotateCli(argv.slice(2), NODE_IO);
-exit(code);

package/types/src/annotate/cli-node.d.ts

@@ -1,2 +0,0 @@
-import "../../_dnt.polyfills.js";
-//# sourceMappingURL=cli-node.d.ts.map

package/types/src/annotate/cli-node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-node.d.ts","sourceRoot":"","sources":["../../../src/src/annotate/cli-node.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC"}

package/types/src/annotate/cli.d.ts

@@ -1,23 +0,0 @@
-/** Runtime IO boundary for the standalone annotate CLI. */
-export interface CliIo {
-    readFile(path: string): Promise<Uint8Array>;
-    writeTextFile(path: string, text: string): Promise<void>;
-    readStdin(): Promise<Uint8Array>;
-    writeStdout(text: string): Promise<void>;
-    writeStderr(text: string): Promise<void>;
-}
-/**
- * Read a full `ReadableStream` into one contiguous byte buffer.
- *
- * This is the shared browser/runtime-neutral helper used by annotate CLI
- * shims that expose stdin as a web stream instead of synchronous file APIs.
- */
-export declare function readAllReadable(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;
-/**
- * Execute the standalone annotate CLI against the provided IO boundary.
- *
- * Error reporting is intentionally normalized here so runtime-specific entry
- * points can stay as thin bootstraps.
- */
-export declare function annotateCli(args: string[], io: CliIo): Promise<number>;
-//# sourceMappingURL=cli.d.ts.map

package/types/src/annotate/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/src/annotate/cli.ts"],"names":[],"mappings":"AASA,2DAA2D;AAC3D,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5C,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,SAAS,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IACjC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAwCD;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACjC,OAAO,CAAC,UAAU,CAAC,CAwBrB;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CA0B5E"}