@manyoars/oars 0.2.0 → 0.4.0

package/dist/sessions/pool-wire.js

@@ -0,0 +1,1100 @@
+// What crosses the wire between `oars pool` and the pool server (recall spec Sections 2.5, 4, and 5). A skeleton is one session as a closed list of fields, each value redacted first: the records a cell is
+// computed from, with every class A field left out, so any later derivation can run over old data while nothing private leaves. The client builds a skeleton and checks it before
+// sending, and the server parses it again, field by field, because a live URL takes anything from anyone. This file imports nothing from the file system: the Worker bundles it.
+import { ACTION_TABLES, CANONICAL_ACTIONS, mcpOf } from './actions.js';
+import { CUSTOM_AGENT, FRAMEWORKS, isPublicMcpTool, isRegistryVersion, LANGUAGES, LITERAL, PRIVATE, publicEffort, publicVersion, PUBLIC_PACKAGES, projectedAgentType, PUBLIC_FLAGS, REPO_SIZES, TOOL_INPUT_KEYS, VOCAB_VERSION } from './public-vocabulary.js';
+import { ARG_CLASSES, TARGET_CLASSES } from './call-shape.js';
+import { recoveryCallsOf, RECOVERY_CALLS } from './recovery-calls.js';
+import { projectLanguage, projectLanguageShare } from './strata.js';
+import { ERROR_CODES, LANGUAGE_SHARES, PROMPT_INTERVENTIONS } from './schema.js';
+// Format 3 (step 1 of the wire): a tool carries its `errorCode` and, for a failed call, what followed it (`recoveryCalls`). Formats 1 and 2 are refused by name; nothing is deployed, so nothing is migrated.
+export const SKELETON_FORMAT = 3;
+/**
+ * The version of the field list: every field name a batch can hold (`BATCH_FIELDS` in `pool-outbox.ts`). It moves with any field added, so a server told the version knows which names a batch may carry,
+ * and a test pins the list to it (`pool-wire-additive.test.ts`). A field is deprecated and left on the list, never removed (conclusion section 17, rule 3).
+ */
+export const FIELD_LIST_VERSION = 8;
+export const BUNDLE_FORMAT = 1;
+/** One constant: the pool serves only the vocabulary version the client holds. */
+export { VOCAB_VERSION };
+/**
+ * Section 7's edges. A bucket is the count of edges a value reaches, so bucket 0 is under the first edge and the last is the first edge's doubling past the cap. `tokens`: under 1k, then
+ * doubling to 1.024M and over. `ms`: under 100 ms, then doubling to 6,553.6 s and over. `seconds`: under 1 s, then doubling to 65,536 s and over. `count`: 0, 1, 2, 3-4, 5-8, 9-16, 17-32, over 32.
+ */
+const EDGES = {
+    tokens: Array.from({ length: 11 }, (_, power) => 1000 * 2 ** power),
+    ms: Array.from({ length: 17 }, (_, power) => 100 * 2 ** power),
+    seconds: Array.from({ length: 17 }, (_, power) => 2 ** power),
+    count: [1, 2, 3, 5, 9, 17, 33],
+    // A call count of a session: the `count` edges, then each edge doubling its width up to over 4,096 (spec Section 7), because a long session passes 32 routinely.
+    calls: [1, 2, 3, 5, 9, 17, 33, 65, 129, 257, 513, 1025, 2049, 4097],
+};
+/** The bucket a value falls in. */
+export const bucketOf = (kind, value) => EDGES[kind].filter((edge) => value >= edge).length;
+/** A stored `explore` count as it pools: its `calls` bucket, or null for a value no count holds (a record captured before the strata has none). The exact count never leaves. */
+export const projectExplore = (stored) => (stored !== undefined && Number.isSafeInteger(stored) && stored >= 0 ? bucketOf('calls', stored) : null);
+/** The lowest value of a bucket, which is what a derivation counts a bucketed value as: it never reads above what the sender held. */
+export const floorOf = (kind, bucket) => EDGES[kind][bucket - 1] ?? 0;
+/** The closed list of how a step came about (`schema.ts` `StepEdge`). */
+export const EDGE_KINDS = ['next', 'spawned', 'retried', 'after-error'];
+/** How many people the operator's organization has (an operator's setting, read locally, never looked up). */
+export const ORG_SIZES = ['solo', '2-10', '11-100', '101-1000', 'over-1000', 'unknown'];
+/** Whether the repository's local git log shows one commit author or several (distinct authors, counted and then dropped). */
+export const TEAMS = ['solo', 'team', 'unknown'];
+/** Whether the repository is public or private (an operator's setting, read locally, never looked up). */
+export const REPO_VISIBILITIES = ['public', 'private', 'unknown'];
+export const NO_COVERAGE = { orgSize: 'unknown', team: 'unknown', repoVisibility: 'unknown' };
+/** A repo key is the store-salted hash a session record holds of its repository's identity: sixteen lowercase hex characters. */
+const REPO_KEY = /^[0-9a-f]{16}$/;
+/** The UTC hour of day, 0 to 23, of a timestamp, whatever offset it was written in; null when there is none or it does not parse. */
+export const hourOf = (ts) => {
+    if (ts === null || ts === undefined || ts === '')
+        return null;
+    const millis = Date.parse(ts);
+    return Number.isNaN(millis) ? null : new Date(millis).getUTCHours();
+};
+/** A usage category's `tokens` bucket, or null when the record says the source never recorded it. A record that predates `usageObserved` reads every category as observed. */
+const observedBucket = (value, observed, field) => (observed === undefined || observed.includes(field) ? bucketOf('tokens', value) : null);
+/** W's minimum for a timing print (deposit-weighting spec, layer 5): fewer timed calls than this say too little to tell sessions apart. */
+export const MIN_TIMED_CALLS = 50;
+/** A session has ended once no transcript of it has gained a line for this long (`session_idle_hours`, spec Section 7). */
+export const SESSION_IDLE_HOURS = 6;
+const HOUR_MS = 60 * 60 * 1000;
+/**
+ * Whether a session's batch may be built at `now`: no transcript of it, main or subagent, has gained a line for `SESSION_IDLE_HOURS`. A transcript gains a line when capture sees it change, which
+ * stamps a new `rev` in epoch milliseconds, but a transcript can grow after the last capture, so `written` (the newest write to any raw file of the session, 0 when none is known) counts too: the
+ * session was last active at the later of the two. A subagent that died without an end marker holds its session back at most that long.
+ */
+export const hasEnded = (records, now, written) => now - Math.max(written, ...records.transcripts.map(({ session }) => session.rev)) >= SESSION_IDLE_HOURS * HOUR_MS;
+const groupBy = (items, keyOf) => {
+    const groups = new Map();
+    for (const item of items) {
+        const key = keyOf(item);
+        const group = groups.get(key);
+        if (group === undefined)
+            groups.set(key, [item]);
+        else
+            group.push(item);
+    }
+    return groups;
+};
+/** Every main session of a store, with its records. */
+export const sessionsOf = (store, roots) => {
+    // Grouped once: a fleet's store holds thousands of sessions over hundreds of thousands of rows, and a scan per session would be quadratic.
+    const prompts = groupBy(store.prompts, (prompt) => prompt.session);
+    const tools = groupBy(store.tools, (tool) => tool.session);
+    const subagents = groupBy(store.subagents, (subagent) => subagent.parent);
+    const recordsOf = (session) => ({ session, prompts: prompts.get(session.session) ?? [], tools: tools.get(session.session) ?? [], root: roots.get(session.session) ?? null });
+    // A subagent whose main transcript the store does not hold is in no group: it cannot be folded, and counting it alone would raise `n`.
+    return store.sessions.map((main) => ({ main, transcripts: [main, ...[...(subagents.get(main.session) ?? [])].sort((a, b) => (a.session < b.session ? -1 : 1))].map(recordsOf) }));
+};
+/** The most characters a name may hold on the wire. A longer value is not a name: it counts as redacted. */
+export const NAME_MAX = 128;
+// A name is a word: letters, digits, and a few joiners, with an optional leading `@` for a scope. A mis-parsed command line, a path, an email, or a quoted string fails it. A `/` is not a joiner here: a name holding one is a path (`src/acme/plan.md`).
+const WIRE_NAME = /^@?[A-Za-z0-9_][A-Za-z0-9_.+-]*(?::[A-Za-z0-9_.+-]+)*$/;
+// A pull's package `name` is the one place a `/` belongs: a scope (`@scope/pkg`) or a Go module path (`golang.org/x/tools`).
+const WIRE_PULL_NAME = /^@?[A-Za-z0-9_][A-Za-z0-9_.+-]*(?:[/:][A-Za-z0-9_.+-]+)*$/;
+/** Whether a value has the shape of a name (and so can be told from a command line, a path, or an email) and is within `NAME_MAX`. */
+export const isWireName = (name) => name.length <= NAME_MAX && WIRE_NAME.test(name);
+/** The shape of a pull's package name: a name, or a scope or module path with `/` in it. */
+export const isWirePullName = (name) => name.length <= NAME_MAX && WIRE_PULL_NAME.test(name);
+/** No redaction and no terms: the name shape and the length limit still apply. A local read, which sends nothing, uses it. */
+export const OPEN_GATE = { redact: (text) => text, terms: [] };
+/** The redactor leaves the name and each of its underscore-delimited parts as they are: `_` is a word character to it, so a host inside `mcp__git.acme.internal__run` is invisible to a pass over the whole name. */
+const unchanged = (gate, name) => gate.redact(name) === name && name.split(/_+/).every((part) => gate.redact(part) === part);
+/**
+ * A name as the wire holds it: the value itself, or `private` when it counts as redacted. A value counts as redacted when the redactor changes it, it holds an exclusion term, it fails the name shape, or it is over
+ * `NAME_MAX` characters, because a secret, an employer's name, or a mis-parsed command is not a name and nothing downstream can take it back. `keys` (t870) sends its names through this same function.
+ */
+export const wireName = (gate, name, hasShape = isWireName) => {
+    const lower = name.toLowerCase();
+    return hasShape(name) && unchanged(gate, name) && !gate.terms.some((term) => term !== '' && lower.includes(term.toLowerCase())) ? name : PRIVATE;
+};
+const FLAG_DASHES = /^-{1,2}/;
+const SHORT_FLAG = /^-[A-Za-z]$/;
+// The long form has its own shape, with no `:` (the joiner `WIRE_NAME` allows for `scope:name`), because `--password:hunter2` is a value joined to its flag and no part of it is a name.
+const LONG_FLAG = /^--[A-Za-z0-9][A-Za-z0-9_.+-]*$/;
+/**
+ * The shape of a flag name: a long flag (two dashes, then a name with no `:`) or a short one (one dash, one letter), or a single-dash token longer than one letter only when the public flag list holds it (`-NoProfile`, `-Command`). A value joined to its flag
+ * fails it: `--token=abc`, `--password:hunter2`, and a short flag with its value attached (`-psecret123`, `-uuser:pass`), which no list holds.
+ */
+const isWireFlag = (flag) => SHORT_FLAG.test(flag) || PUBLIC_FLAGS.has(flag) || (flag.length <= NAME_MAX && LONG_FLAG.test(flag));
+/** A multi-letter single-dash flag no public list holds (`go test -race`, `-psecret123`): the client before t900 dropped it, so this one does too, and an old and a new client key one motif for one command. */
+const isDroppedFlag = (flag) => flag.length > 2 && flag.startsWith('-') && !flag.startsWith('--') && !PUBLIC_FLAGS.has(flag);
+/** A flag name as the wire holds it: the name after the one gate, or `private` when it counts as redacted. Only the name is ever read, never a value. */
+const wireFlag = (gate, flag) => (isWireFlag(flag) && wireName(gate, flag.replace(FLAG_DASHES, '')) !== PRIVATE ? flag : PRIVATE);
+/**
+ * A call's key names as the wire holds them (t870): names only, never a value. A public tool (one with a pinned input list) sends the names on its list and counts the rest; any other tool sends a name only when it passes the
+ * name gate, and a tool that went as `private` sends none, so a private tool's keys name no private work. `dropped` counts the distinct names not sent.
+ */
+const wireKeys = (stored, native, gate) => {
+    const distinct = [...new Set(stored)];
+    const listed = native === undefined ? undefined : TOOL_INPUT_KEYS.get(native);
+    const kept = native === undefined || native === PRIVATE ? [] : distinct.filter((name) => (listed === undefined ? wireName(gate, name) !== PRIVATE : listed.has(name)));
+    return { keys: kept.sort(), dropped: distinct.length - kept.length };
+};
+/** A stored closed-list member, else dropped: a hand-edited record never puts a value off the list on the wire. */
+const memberOf = (list, value) => list.find((entry) => entry === value);
+/** The basename of a program as capture read it: a path never goes on the wire. */
+const basenameOf = (program) => program.replace(/^.*[\\/]/, '');
+/**
+ * A projected command as the server's parser reads it: the program as its basename after the gate (the stored identity reads `<literal>` for a program off the curated list, so the name comes from the call's segments),
+ * and the subcommand and flag names the reader gives, each through the same gate and never a flag value. Which of them the reader holds for a program is capture's; the wire adds no list of its own.
+ */
+const wireCommand = ({ program, subcommand, flags }, raw, gate) => {
+    const named = program !== PRIVATE ? program : raw;
+    if (named === undefined)
+        return { program: PRIVATE, sub: null, flags: [] };
+    const sent = wireName(gate, basenameOf(named));
+    // A private program holds no subcommand or flag: the parser refuses one that does.
+    if (sent === PRIVATE)
+        return { program: PRIVATE, sub: null, flags: [] };
+    return { program: sent, sub: subcommand === null ? null : wireName(gate, subcommand), flags: flags.filter((flag) => !isDroppedFlag(flag)).map((flag) => wireFlag(gate, flag)) };
+};
+/** A pull in the wire's spelling: its package name after the gate. A version beside a name that is not on the public list could identify it, so it goes as `<literal>` (null stays null), the rule capture applies. */
+const wirePull = (pull, gate) => {
+    const name = wireName(gate, pull.name, isWirePullName);
+    return { ...pull, name, version: !PUBLIC_PACKAGES.has(name) && pull.version !== null ? LITERAL : pull.version };
+};
+/** A non-shell step's identity in the wire's spelling; a shell step's comes from `wireCommand`. `raw` is the harness's own tool name, class A, which an MCP call's masked identity is read back from. */
+const wireIdentity = (identity, harness, raw, gate) => {
+    if (identity === null || 'program' in identity)
+        return identity;
+    if ('server' in identity) {
+        const table = ACTION_TABLES[harness];
+        const parsed = mcpOf(table, raw);
+        const server = wireName(gate, identity.server === LITERAL ? (parsed?.server ?? LITERAL) : identity.server);
+        // A tool beside a masked server has no server to belong to, and a harness that does not delimit the server cannot split the tool from it: both go as the literal.
+        const name = identity.tool === LITERAL ? parsed?.tool : identity.tool;
+        const tool = server === PRIVATE || !table.toolDelimited || name === undefined ? PRIVATE : wireName(gate, name);
+        return { server, tool: tool === PRIVATE ? LITERAL : tool };
+    }
+    if ('skill' in identity)
+        return { skill: wireName(gate, identity.skill) };
+    return { host: identity.host === null ? null : wireName(gate, identity.host) };
+};
+/**
+ * A stored tool's steps as the wire holds them: each shell step's identity is replaced by the projected command, and every long-tail name (a native name, MCP server, skill, host, program, or pull name) is
+ * sent as it is after the gate, or `private` when it counts as redacted. A `private` program holds no pull. The one place a deposit and a local read take it from.
+ */
+export const projectedSteps = (tool, read, harness, gate = OPEN_GATE) => {
+    const commands = read(tool);
+    const steps = tool.steps ?? [];
+    // `segments` pair with the steps when their counts agree (`projectLiteralStep`): segment `at` is step `at`, and its `run` starts with the program's basename.
+    const segments = tool.segments?.length === steps.length ? tool.segments : undefined;
+    return steps.map((step, at) => {
+        const native = admittedNative(harness, step.native) ? step.native : wireName(gate, step.native === LITERAL ? tool.tool : step.native);
+        if (step.action !== 'shell.exec')
+            return { ...step, native, identity: wireIdentity(step.identity, harness, tool.tool, gate) };
+        const command = wireCommand(commands[at] ?? { program: PRIVATE, subcommand: null, flags: [] }, segments?.[at]?.run.split(' ')[0], gate);
+        const pulls = step.identity !== null && 'program' in step.identity ? step.identity.pulls : undefined;
+        return { ...step, native, identity: pulls === undefined || command.program === PRIVATE ? command : { ...command, pulls: pulls.map((pull) => wirePull(pull, gate)) } };
+    });
+};
+/** A failed call's stored `errorCode` as the wire holds it: a member of the closed list, else `other`; null for a call that did not fail and for one captured without a code (the wire does not guess one). */
+const wireErrorCode = ({ status, errorCode }) => (status !== 'error' || errorCode === undefined ? null : ERROR_CODES.has(errorCode) ? errorCode : 'other');
+/** A transcript's calls in the order they ran, which is the order a skeleton holds them in. */
+const byCall = (tools) => [...tools].sort((a, b) => a.n - b.n);
+const placesOf = (tools) => {
+    const calls = new Map();
+    const steps = new Map();
+    for (const [position, { n, steps: held }] of byCall(tools).entries()) {
+        calls.set(n, position);
+        for (const step of held ?? [])
+            steps.set(`${String(n)}/${String(step.seg)}`, steps.size);
+    }
+    return { calls, steps };
+};
+/** The step of a call that carries the runs it spawned: its first spawn step, else its first step. A call with no step carries none. */
+const carrier = (steps) => Math.max(0, steps.findIndex(({ action }) => action === 'agent.spawn'));
+/**
+ * A model or harness version string as the wire holds it: the string after the gate (`wireName`), null staying null. The pool assigns its class. Capture's closed value (`<literal>`) goes as it is, the form a client before
+ * t900 sent, so an old and a new client key one closed frame to one pool cell; the parser accepts it.
+ */
+const wireString = (gate, value) => (value === null || value === LITERAL ? value : wireName(gate, value));
+/**
+ * A stored frame with the UTC hour of `ts` beside its day, and its stack's language shares: each stored share is read through its projection, so a share outside the list is dropped and its language stays in `languages`. A stored
+ * language outside the pinned list is `other`, and `other` holds the first share a record gives it. A record captured before the strata holds none.
+ */
+const wireFrame = (frame, strata, gate, ts) => {
+    const shares = new Map();
+    for (const { language, share } of strata?.languages ?? []) {
+        const held = projectLanguageShare(share);
+        const name = projectLanguage(language);
+        if (held !== null && !shares.has(name))
+            shares.set(name, held);
+    }
+    const hour = hourOf(ts);
+    return { ...frame, harnessVersion: wireString(gate, frame.harnessVersion), model: wireString(gate, frame.model), stack: { ...frame.stack, languageShares: [...shares].map(([language, languageShare]) => ({ language, languageShare })) }, ...(hour === null ? {} : { hour }) };
+};
+/** Each of `names` after the gate (a name that counts as redacted reads `private`), sorted. */
+const listedAll = (gate, names) => [...new Set(names)].map((name) => wireName(gate, name)).sort();
+/**
+ * The reach a session's record shows (t867): the servers of the tools its `funnel` offered or loaded and of the MCP tools it called, the skills it called, and the plugins its `setup` names. A record
+ * with neither `setup` nor `funnel` is unfilled (a harness that records none, or a capture before version 12) and lists nothing, so the absence is not read as no tools.
+ */
+const reachOf = (session, tools, harness, gate) => {
+    if (session.setup === undefined && session.funnel === undefined)
+        return { filled: false, mcp: [], skills: [], plugins: [] };
+    const table = ACTION_TABLES[harness];
+    const servers = new Set();
+    const skills = new Set();
+    for (const name of [...(session.funnel?.offered ?? []), ...(session.funnel?.loaded ?? [])]) {
+        const server = mcpOf(table, name)?.server;
+        if (server !== undefined)
+            servers.add(server);
+    }
+    for (const { steps, skill } of tools) {
+        if (skill !== undefined)
+            skills.add(skill);
+        for (const { identity } of steps ?? []) {
+            if (identity !== null && 'server' in identity)
+                servers.add(identity.server);
+            if (identity !== null && 'skill' in identity)
+                skills.add(identity.skill);
+        }
+    }
+    return { filled: true, mcp: listedAll(gate, servers), skills: listedAll(gate, skills), plugins: (session.setup?.plugins ?? []).map(() => PRIVATE) };
+};
+const transcriptOf = ({ session, prompts, tools, root }, spawner, spawned, agentType, read, gate, coverage) => {
+    if (session.frame === undefined || root === null)
+        return null;
+    const harness = session.harness ?? 'claude-code';
+    const framedPrompts = [];
+    const promptAt = new Map();
+    for (const { index, cls, errors, wallSec, usage, usageObserved, usageResponses, frame, strata, ts, intervention } of [...prompts].sort((a, b) => a.index - b.index)) {
+        if (frame === undefined)
+            return null;
+        promptAt.set(index, framedPrompts.length);
+        framedPrompts.push({
+            cls,
+            errors: bucketOf('count', errors),
+            wallSec: wallSec === null ? null : bucketOf('seconds', wallSec),
+            usage: {
+                input: observedBucket(usage.input, usageObserved, 'input'),
+                cacheWrite: observedBucket(usage.cacheWrite, usageObserved, 'cacheWrite'),
+                cacheRead: observedBucket(usage.cacheRead, usageObserved, 'cacheRead'),
+                output: observedBucket(usage.output, usageObserved, 'output'),
+                thinking: observedBucket(usage.thinking, usageObserved, 'thinking'),
+            },
+            explore: projectExplore(strata?.explore),
+            ...(usageResponses === undefined ? {} : { usageResponses: bucketOf('count', usageResponses) }),
+            ...(intervention === undefined ? {} : { intervention }),
+            frame: wireFrame(frame, strata, gate, ts),
+        });
+    }
+    // The frames the steps ran in: the transcript's own first, then one for each distinct (prompt frame, call model, call harness version) a call shows, so a model that changes in the middle of a prompt
+    // reaches the steps that ran on it. A call that recorded neither takes its prompt's frame, or the transcript's before the first prompt.
+    const reach = reachOf(session, tools, harness, gate);
+    // The repo key and the bands describe the session, not a prompt, so they sit where the reach does. A session in no repository sends no key, and so does one whose record holds anything but a key's shape: the emitter is the privacy control.
+    const where = { reach, ...(session.repo !== null && REPO_KEY.test(session.repo) ? { repoKey: session.repo } : {}), ...coverage };
+    const transcriptFrame = { ...wireFrame(session.frame, session.strata, gate, session.tsFirst), ...where };
+    const frames = [transcriptFrame];
+    const frameAtKey = new Map([[JSON.stringify(transcriptFrame), 0]]);
+    const frameOfCall = ({ model, harnessVersion }, promptPosition) => {
+        const base = promptPosition === null ? undefined : framedPrompts[promptPosition]?.frame;
+        const held = {
+            ...(base ?? transcriptFrame),
+            ...(model === undefined ? {} : { model: wireString(gate, model) }),
+            ...(harnessVersion === null ? {} : { harnessVersion: wireString(gate, harnessVersion) }),
+            ...where,
+        };
+        const key = JSON.stringify(held);
+        const found = frameAtKey.get(key);
+        if (found !== undefined)
+            return found;
+        frames.push(held);
+        frameAtKey.set(key, frames.length - 1);
+        return frames.length - 1;
+    };
+    const steppedTools = [];
+    const own = placesOf(tools);
+    // The exact tokens of every step, by call and step, which the `remainingTokens` buckets below are computed from: a bucket of a sum is not a sum of buckets.
+    const exact = [];
+    let unrecorded = 0;
+    const ordered = byCall(tools);
+    for (const [at, tool] of ordered.entries()) {
+        if (tool.steps === undefined)
+            return null;
+        const { side, prompt, status, durationMs } = tool;
+        const errorCode = wireErrorCode(tool);
+        const recoveryCalls = recoveryCallsOf(ordered, at);
+        // A subagent's call names the prompt that spawned it, which its own transcript holds no record of: such a number takes the next position past the prompts, one per distinct number, so
+        // the calls that shared a prompt still share one, and no position reads as a prompt.
+        if (prompt !== null && !promptAt.has(prompt))
+            promptAt.set(prompt, framedPrompts.length + unrecorded++);
+        const promptPosition = prompt === null ? null : (promptAt.get(prompt) ?? null);
+        const projected = projectedSteps(tool, read, harness, gate);
+        exact.push(projected.map(({ cost }) => cost.tokens));
+        const frame = frameOfCall(tool, promptPosition);
+        const steps = projected.map(({ action, native, identity, status: reported, cost, parent, edges }) => {
+            // An edge names a step by its position in the transcript it sits in; a `spawned` edge sits in the spawner, and one with no spawner in the batch goes unsent, since it names nothing here.
+            const arriving = edges.flatMap(({ kind, n: from, seg: fromSeg }) => {
+                const target = (kind === 'spawned' ? spawner?.places : own)?.steps.get(`${String(from)}/${String(fromSeg)}`);
+                return target === undefined ? [] : [{ kind, target }];
+            });
+            return {
+                action,
+                native,
+                identity,
+                status: reported,
+                tokens: cost.tokens === null ? null : bucketOf('tokens', cost.tokens),
+                ms: cost.durationMs === null ? null : bucketOf('ms', cost.durationMs),
+                ...(cost.allocated === true ? { allocated: true } : {}),
+                remainingTokens: 0,
+                agentType,
+                parent: parent === null || spawner === null ? null : (spawner.places.calls.get(parent) ?? null),
+                frame,
+                ...(arriving.length === 0 ? {} : { edges: arriving }),
+                ...(tool.skill === undefined ? {} : { skill: wireName(gate, tool.skill) }),
+            };
+        });
+        const { keys, dropped } = wireKeys(tool.keys, steps[0]?.native, gate);
+        const targetClass = memberOf(TARGET_CLASSES, tool.targetClass);
+        const stored = tool.argClass;
+        const argClass = stored === undefined ? undefined : ARG_CLASSES.filter((kind) => stored.includes(kind));
+        steppedTools.push({
+            side,
+            prompt: promptPosition,
+            status,
+            durationMs,
+            errorCode,
+            ...(recoveryCalls === null ? {} : { recoveryCalls }),
+            ...(keys.length === 0 ? {} : { keys }),
+            ...(dropped === 0 ? {} : { keysDropped: bucketOf('count', dropped) }),
+            ...(targetClass === undefined ? {} : { targetClass }),
+            ...(argClass === undefined ? {} : { argClass: argClass.sort() }),
+            steps,
+        });
+    }
+    // A step's remaining tokens are those of the steps after it in its own run; a main-run step also counts the subagent runs its later steps spawned (a run belongs to the spawning call's carrier step).
+    // `later` sums the steps that reported tokens; `laterKnown` is how many did, so a run whose later steps all reported nothing stays null instead of reading as zero.
+    let later = 0;
+    let laterSteps = 0;
+    let laterKnown = 0;
+    for (let call = steppedTools.length - 1; call >= 0; call -= 1) {
+        const steps = steppedTools[call]?.steps ?? [];
+        const held = carrier(steps);
+        for (let at = steps.length - 1; at >= 0; at -= 1) {
+            const step = steps[at];
+            if (step === undefined)
+                continue;
+            step.remainingTokens = laterSteps > 0 && laterKnown === 0 ? null : bucketOf('tokens', later);
+            const own = exact[call]?.[at] ?? null;
+            const spawnedTokens = at === held ? (spawned.get(call) ?? 0) : 0;
+            later += (own ?? 0) + spawnedTokens;
+            laterSteps += 1;
+            if (own !== null || spawnedTokens > 0)
+                laterKnown += 1;
+        }
+    }
+    return { merkleRoot: root.merkleRoot, leaves: root.leaves, harness, frame: transcriptFrame, frames, spawnedIn: spawner?.index ?? null, prompts: framedPrompts, tools: steppedTools };
+};
+/**
+ * The skeleton of a session; null when any record of it was captured before steps and frames, or a transcript of it has no root, which holds no closed reading to send. The batch holds the main
+ * transcript's run first, then each subagent's as its own run; its `id` is the main session's, and its one `timingPrint` is over the main transcript's calls alone.
+ */
+export const skeletonOf = (records, id, read, print, deltas = [], gate = OPEN_GATE, coverage = NO_COVERAGE) => {
+    const mainTools = byCall(records.transcripts[0]?.tools ?? []);
+    const places = records.transcripts.map(({ tools }) => placesOf(tools));
+    const spawners = places[0]?.calls ?? new Map();
+    // A subagent's step names the call that spawned it by that call's `n` in the transcript its session record names as `spawnedIn`, which the skeleton holds as a position in the batch: that transcript's, and the call's within it.
+    // A record that names none the batch holds, or itself, or lies on a cycle of spawners, sends no link; one whose spawner sits on a cycle it is not on keeps its link.
+    const spawnerOf = records.transcripts.map(({ session }, index) => {
+        const at = index === 0 || session.spawnedIn === null ? -1 : records.transcripts.findIndex((held) => held.session.session === session.spawnedIn);
+        return at === -1 ? null : at;
+    });
+    const cyclic = (index) => {
+        let at = spawnerOf[index] ?? null;
+        for (let hop = 0; hop < spawnerOf.length && at !== null && at !== index; hop += 1)
+            at = spawnerOf[at] ?? null;
+        return at === index;
+    };
+    // The exact tokens of the runs each main-run call spawned. A run a subagent spawned names a call of that other transcript, so it joins no main-run step.
+    const spawned = new Map();
+    for (const [index, entry] of records.transcripts.entries()) {
+        if (spawnerOf[index] !== 0)
+            continue;
+        for (const tool of entry.tools) {
+            for (const { cost, parent } of tool.steps ?? []) {
+                const position = parent === null ? undefined : spawners.get(parent);
+                if (position !== undefined)
+                    spawned.set(position, (spawned.get(position) ?? 0) + (cost.tokens ?? 0));
+            }
+        }
+    }
+    const transcripts = [];
+    for (const [index, entry] of records.transcripts.entries()) {
+        const at = spawnerOf[index] ?? null;
+        const spawnerPlaces = at === null || cyclic(index) ? undefined : places[at];
+        const transcript = transcriptOf(entry, at === null || spawnerPlaces === undefined ? null : { index: at, places: spawnerPlaces }, index === 0 ? spawned : new Map(), index === 0 ? null : projectedAgentType(entry.session.agentType ?? CUSTOM_AGENT), read, gate, coverage);
+        if (transcript === null)
+            return null;
+        transcripts.push(transcript);
+    }
+    const durations = mainTools.flatMap(({ durationMs }) => (durationMs === null ? [] : [durationMs]));
+    return { format: SKELETON_FORMAT, vocabVersion: VOCAB_VERSION, fieldsVersion: FIELD_LIST_VERSION, id, transcripts, timingPrint: durations.length < MIN_TIMED_CALLS ? null : print(durations), deltas: [...deltas] };
+};
+/**
+ * The version bucket of a session that recorded none: Cursor, Gemini, and Grok Build keep no harness version in their local files, and neither does a VS Code Copilot Chat session whose requests carry no `agent.extensionVersion`, so their cells are
+ * `<harness>/unknown/<model>`. It is the one non-numeric word a bundle can be asked for, so those harnesses are served the cells they have.
+ */
+export const UNKNOWN_VERSION = 'unknown';
+/** A harness version a bundle can be asked for: public, so the request carries nothing private, or `unknown` for a harness with none on record. The admitted list replaces this shape rule when it ships. */
+export const isBundleVersion = (version) => version === UNKNOWN_VERSION || (version !== LITERAL && publicVersion(version) === version);
+/** Whether `name` is a harness the schema names. */
+export const isHarness = (name) => HARNESSES.some((harness) => harness === name);
+class Refused extends Error {
+    field;
+    reason;
+    constructor(field, reason) {
+        super(`${field}: ${reason}`);
+        this.field = field;
+        this.reason = reason;
+    }
+}
+const isFields = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const under = (at, key) => (at === '' ? key : `${at}.${key}`);
+/** The value a reader gives an enumerated field whose value it does not know (conclusion section 17, rule 3). */
+export const OTHER = 'other';
+/** The one way into the bag: an entry over `MAX_EXTENSION_BYTES` (as JSON, in UTF-8) is refused as too large at its path, whatever kind it is and whatever the deposit's own cap is. */
+const bagged = (held, entry) => {
+    if (new TextEncoder().encode(JSON.stringify(entry.value)).length > MAX_EXTENSION_BYTES)
+        throw new Refused(entry.at, 'too large');
+    held.extensions.push(entry);
+};
+/**
+ * A value no vocabulary of this reader holds: counted, kept as sent in the bag, and read as `other`. The bag is the stored form of what the reader does not serve; the client's projection is the gate on what it
+ * sends (lead 194), so the pool keeps the value and serves nothing from it.
+ */
+const unknownValue = (held, at, sent) => {
+    held.others += 1;
+    bagged(held, { at, kind: 'value', value: sent });
+    return OTHER;
+};
+/** The fields a client may send a literal beside (`<field>Literal`) when the field itself says `other`: the enumerated fields, whose values a closed list holds. */
+export const ENUMERATED_FIELDS = new Set(['harness', 'harnessVersion', 'model', 'effort', 'platform', 'shell', 'size', 'languages', 'frameworks', 'language', 'languageShare', 'cls', 'status', 'action', 'native', 'agentType', 'program', 'sub', 'flags', 'registry', 'name', 'version', 'server', 'tool', 'skill', 'host', 'deltaKind', 'field', 'metric', 'intervention']);
+/**
+ * The fields that may be absent at format 3, by the level of the batch that holds them. An absent one reads as null, or as empty for a list, exactly as a sent null does, so a batch with all of them left out is
+ * served from what remains. A field the cells need to be sound (a harness, a status, a bucket of tokens) is never here.
+ */
+export const OPTIONAL = {
+    batch: ['timingPrint', 'deltas'],
+    frame: ['harnessVersion', 'model', 'effort', 'day', 'shell', 'reach', 'repoKey', 'orgSize', 'team', 'repoVisibility', 'hour'],
+    stack: ['size', 'languageShares'],
+    prompt: ['wallSec', 'explore', 'usageResponses', 'intervention'],
+    tool: ['prompt', 'durationMs', 'errorCode', 'recoveryCalls', 'keys', 'keysDropped', 'targetClass', 'argClass'],
+    step: ['tokens', 'ms', 'allocated', 'parent', 'skill', 'edges', 'remainingTokens'],
+    transcript: ['spawnedIn'],
+};
+/** The most bytes (as JSON) one field this reader does not know, or one literal, may hold: an enumerated value or a literal never needs more, and a newer client's larger structure belongs in a new format version. The deposit's own cap is no part of this. */
+export const MAX_EXTENSION_BYTES = 8 * 1024;
+const LITERAL_SUFFIX = 'Literal';
+const FIELD_NAME = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+/**
+ * The object at `at`, holding every field of `known` and, of the rest, any of `optional`. A name that is neither is not refused: it goes to the bag as it came (rule 3), so a newer client loses nothing
+ * against this reader. The emitter is what keeps a class A field out of a batch, not this check. A shape error still refuses: a name that is no field name, a missing field, a literal that is not text.
+ */
+const fieldsOf = (held, value, at, known, optional = []) => {
+    if (!isFields(value))
+        throw new Refused(at === '' ? 'skeleton' : at, 'not an object');
+    for (const key of known)
+        if (!Object.hasOwn(value, key))
+            throw new Refused(under(at, key), 'missing');
+    for (const key of Object.keys(value)) {
+        if (known.includes(key) || optional.includes(key))
+            continue;
+        if (!FIELD_NAME.test(key))
+            throw new Refused(under(at, key), 'not a field name');
+        const entry = value[key];
+        const stem = key.endsWith(LITERAL_SUFFIX) ? key.slice(0, -LITERAL_SUFFIX.length) : undefined;
+        // A literal sits beside an `other` and nowhere else; beside a value this reader knows it is a field it does not know.
+        const literal = stem !== undefined && ENUMERATED_FIELDS.has(stem) && (known.includes(stem) || optional.includes(stem)) && value[stem] === OTHER;
+        if (literal)
+            textOf(entry, under(at, key));
+        bagged(held, { at: under(at, key), kind: literal ? 'literal' : 'field', value: entry });
+    }
+    return value;
+};
+const listOf = (value, at, item) => {
+    if (!Array.isArray(value))
+        throw new Refused(at, 'not a list');
+    const entries = value;
+    return entries.map((entry, index) => item(entry, `${at}[${String(index)}]`));
+};
+const textOf = (value, at) => {
+    if (typeof value !== 'string')
+        throw new Refused(at, 'not text');
+    return value;
+};
+/** Whole and safe: a depositor's value is added into cells every account is served, and one huge number would turn a sum into Infinity, which JSON writes as null. */
+const countOf = (value, at) => {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
+        throw new Refused(at, 'not a count');
+    return value;
+};
+/** The allocation marker is `true` or absent: a depositor cannot say `false`, since an unmarked step is the measured one. */
+const allocatedOf = (value, at) => {
+    if (value !== true)
+        throw new Refused(at, 'not true');
+    return true;
+};
+/** An absent field reads as null: an optional field is absent or null alike. */
+const orNull = (value, at, item) => (value === null || value === undefined ? null : item(value, at));
+/** An absent list reads as empty. */
+const listOrEmpty = (value, at, item) => (value === undefined ? [] : listOf(value, at, item));
+const booleanOf = (value, at) => {
+    if (typeof value !== 'boolean')
+        throw new Refused(at, 'not a boolean');
+    return value;
+};
+/** A value from a closed list, or `other` for a text the list does not hold; the list narrows the type, so no caller needs a cast. A value that is no text is a shape error. */
+const oneOf = (held, list, value, at) => {
+    const name = textOf(value, at);
+    return list.find((entry) => entry === name) ?? (name === OTHER ? OTHER : unknownValue(held, at, name));
+};
+const inSet = (held, allowed, value, at) => {
+    const name = textOf(value, at);
+    return name === PRIVATE || name === OTHER || allowed.has(name) ? name : unknownValue(held, at, name);
+};
+/** A long-tail name field: `private`, `other`, or a name (the pool assigns its class, `packages/pool/src/field-classes.ts`). A value that is no name is refused: a client that sends one has not run its gate. */
+const nameIn = (value, at, hasShape = isWireName) => {
+    const name = textOf(value, at);
+    if (name === PRIVATE || name === OTHER || hasShape(name))
+        return name;
+    throw new Refused(at, 'not a name');
+};
+/** A model or harness version: null, or a long-tail name (`private`, `other`, the older client's literal, or a name). A value that is no name is set aside, as a native name is. */
+const nameOrNull = (held, value, at) => {
+    if (value === null || value === undefined)
+        return null;
+    const name = textOf(value, at);
+    return name === LITERAL ? name : nameValue(held, name, at);
+};
+/** A long-tail name in a field whose value the pool classes: `private`, `other`, or a name; a value that is no name is set aside. */
+const nameValue = (held, name, at) => (name === PRIVATE || name === OTHER || isWireName(name) ? name : unknownValue(held, at, name));
+const exactlyIn = (held, allowed) => (value, at) => {
+    const name = textOf(value, at);
+    return allowed.has(name) || name === OTHER ? name : unknownValue(held, at, name);
+};
+/** `publicEffort` and its like hand back what is public and the literal for what is not, so only a value they return unchanged is in the vocabulary. */
+const heldTo = (held, isHeld, value, at) => {
+    if (value === null || value === undefined)
+        return null;
+    const name = textOf(value, at);
+    return name === OTHER || isHeld(name) === name ? name : unknownValue(held, at, name);
+};
+// `satisfies` checks every entry is a `Harness` but not that every `Harness` is listed; this refuses a list that leaves one out at compile time.
+const allHarnesses = (list) => list;
+export const HARNESSES = allHarnesses(['claude-code', 'cursor', 'codex', 'copilot', 'gemini', 'grok', 'opencode', 'pi', 'vscode-copilot', 'otel']);
+const PROMPT_CLASSES = ['no-tools', 'orchestration', 'research', 'edit-verify', 'edit-only', 'explore-only', 'shell-only', 'mixed'];
+const STATUSES = ['ok', 'error', 'none'];
+const PLATFORMS = new Set(['aix', 'android', 'cygwin', 'darwin', 'freebsd', 'haiku', 'linux', 'netbsd', 'openbsd', 'sunos', 'win32']);
+const SHELLS = new Set(Object.values(ACTION_TABLES).flatMap((table) => Object.values(table.shells)));
+/** The registries a package comes from; a pull may also come from a skill, plugin, or MCP registry. */
+export const PACKAGE_REGISTRIES = ['npm', 'pypi', 'crates', 'go', 'rubygems', 'homebrew'];
+const NO_NAME = new Set();
+const REGISTRIES = [...PACKAGE_REGISTRIES, 'skill', 'plugin', 'mcp'];
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+const ID = /^[0-9a-f]{16}$/;
+/** A real date, not just its shape. `Date.parse` rolls 2026-02-31 over to March instead of failing, so the day must also survive the trip back to text. */
+const isCalendarDay = (text) => {
+    if (!DAY.test(text))
+        return false;
+    const parsed = Date.parse(text);
+    return !Number.isNaN(parsed) && new Date(parsed).toISOString().slice(0, 10) === text;
+};
+/** The languages a share can name: the pinned list and `other`, which `projectLanguage` gives any language off the list. The frame's own `languages` stay closed to the list. */
+const SHARE_LANGUAGES = new Set([...LANGUAGES, 'other']);
+const parseLanguageShare = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['language', 'languageShare']);
+    return { language: exactlyIn(held, SHARE_LANGUAGES)(raw.language, under(at, 'language')), languageShare: oneOf(held, LANGUAGE_SHARES, raw.languageShare, under(at, 'languageShare')) };
+};
+/** A reach, each list held to its own row; an unfilled reach lists nothing. A plugin has no pinned list, so only the word `private` stands for one. */
+const parseReach = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['filled', 'mcp', 'skills', 'plugins']);
+    const filled = booleanOf(raw.filled, under(at, 'filled'));
+    const reach = {
+        filled,
+        mcp: listOf(raw.mcp, under(at, 'mcp'), (entry, entryAt) => nameIn(entry, entryAt)),
+        skills: listOf(raw.skills, under(at, 'skills'), (entry, entryAt) => nameIn(entry, entryAt)),
+        plugins: listOf(raw.plugins, under(at, 'plugins'), (entry, entryAt) => inSet(held, NO_NAME, entry, entryAt)),
+    };
+    if (!filled && reach.mcp.length + reach.skills.length + reach.plugins.length > 0)
+        throw new Refused(at, 'an unfilled reach lists nothing');
+    return reach;
+};
+/** Sixteen lowercase hex characters and nothing else, so no path or remote text can ride in a repo key. */
+const parseRepoKey = (value, at) => {
+    const text = textOf(value, at);
+    if (!REPO_KEY.test(text))
+        throw new Refused(at, 'outside the vocabulary');
+    return text;
+};
+const parseHour = (value, at) => {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > 23)
+        throw new Refused(at, 'not an hour');
+    return value;
+};
+const parseFrame = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['harness', 'platform', 'stack'], OPTIONAL.frame);
+    const stackAt = under(at, 'stack');
+    const stack = fieldsOf(held, raw.stack, stackAt, ['languages', 'frameworks'], OPTIONAL.stack);
+    const day = orNull(raw.day, under(at, 'day'), (entry, entryAt) => {
+        const text = textOf(entry, entryAt);
+        if (!isCalendarDay(text))
+            throw new Refused(entryAt, 'not a UTC day');
+        return text;
+    });
+    return {
+        harness: oneOf(held, HARNESSES, raw.harness, under(at, 'harness')),
+        harnessVersion: nameOrNull(held, raw.harnessVersion, under(at, 'harnessVersion')),
+        model: nameOrNull(held, raw.model, under(at, 'model')),
+        effort: heldTo(held, publicEffort, raw.effort, under(at, 'effort')),
+        day,
+        platform: exactlyIn(held, PLATFORMS)(raw.platform, under(at, 'platform')),
+        shell: orNull(raw.shell, under(at, 'shell'), exactlyIn(held, SHELLS)),
+        stack: {
+            languages: listOf(stack.languages, under(stackAt, 'languages'), exactlyIn(held, LANGUAGES)),
+            frameworks: listOf(stack.frameworks, under(stackAt, 'frameworks'), exactlyIn(held, FRAMEWORKS)),
+            size: orNull(stack.size, under(stackAt, 'size'), (entry, entryAt) => oneOf(held, REPO_SIZES, entry, entryAt)),
+            languageShares: listOrEmpty(stack.languageShares, under(stackAt, 'languageShares'), (entry, entryAt) => parseLanguageShare(held, entry, entryAt)),
+        },
+        ...(raw.reach === undefined ? {} : { reach: parseReach(held, raw.reach, under(at, 'reach')) }),
+        ...(raw.repoKey === undefined ? {} : { repoKey: parseRepoKey(raw.repoKey, under(at, 'repoKey')) }),
+        ...(raw.orgSize === undefined ? {} : { orgSize: oneOf(held, ORG_SIZES, raw.orgSize, under(at, 'orgSize')) }),
+        ...(raw.team === undefined ? {} : { team: oneOf(held, TEAMS, raw.team, under(at, 'team')) }),
+        ...(raw.repoVisibility === undefined ? {} : { repoVisibility: oneOf(held, REPO_VISIBILITIES, raw.repoVisibility, under(at, 'repoVisibility')) }),
+        ...(raw.hour === undefined ? {} : { hour: parseHour(raw.hour, under(at, 'hour')) }),
+    };
+};
+const bucketIn = (kind, value, at) => {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > EDGES[kind].length)
+        throw new Refused(at, 'not a bucket');
+    return value;
+};
+const parseUsage = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['input', 'cacheWrite', 'cacheRead', 'output', 'thinking']);
+    const bucket = (field) => orNull(raw[field], under(at, field), (entry, entryAt) => bucketIn('tokens', entry, entryAt));
+    return { input: bucket('input'), cacheWrite: bucket('cacheWrite'), cacheRead: bucket('cacheRead'), output: bucket('output'), thinking: bucket('thinking') };
+};
+const parsePull = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['registry', 'name', 'version']);
+    const name = nameIn(raw.name, under(at, 'name'), isWirePullName);
+    const version = orNull(raw.version, under(at, 'version'), (entry, entryAt) => {
+        const text = textOf(entry, entryAt);
+        // A version beside a masked name could identify it: capture masks the two together.
+        if (!PUBLIC_PACKAGES.has(name) && text !== LITERAL)
+            throw new Refused(entryAt, 'a name off the public list holds no version');
+        return text === LITERAL || text === OTHER || isRegistryVersion(text) ? text : unknownValue(held, entryAt, text);
+    });
+    return { registry: oneOf(held, REGISTRIES, raw.registry, under(at, 'registry')), name, version };
+};
+const parseFlag = (held, value, at) => {
+    const flag = textOf(value, at);
+    return flag === PRIVATE || flag === OTHER || isWireFlag(flag) ? flag : unknownValue(held, at, flag);
+};
+/** What a reader sets aside whole: a part of a step it cannot read against a vocabulary. Its place is noted and its content kept as sent, as for any value it does not know (see `unknownValue`). */
+const setAside = (held, at, sent) => {
+    bagged(held, { at, kind: 'value', value: sent });
+};
+const parseIdentity = (held, harness, action, value, at) => {
+    if (value === null)
+        return null;
+    // An action this reader does not know holds an identity it cannot read: the step goes without one and the place of what it held is noted.
+    if (action === OTHER) {
+        setAside(held, at, value);
+        return null;
+    }
+    if (action === 'shell.exec') {
+        const raw = fieldsOf(held, value, at, ['program', 'sub', 'flags'], ['pulls']);
+        // A program is a name, `private`, or `other`; only `other` holds no subcommand, flag, or pull here.
+        const program = textOf(raw.program, under(at, 'program'));
+        nameIn(program, under(at, 'program'));
+        // The subcommands, flags, and pulls of a program this reader does not know cannot be read against its lists: it takes none, and notes what it left.
+        if (program === OTHER) {
+            for (const key of ['sub', 'flags', 'pulls'])
+                if (raw[key] !== undefined && !(raw[key] === null || (Array.isArray(raw[key]) && raw[key].length === 0)))
+                    setAside(held, under(at, key), raw[key]);
+            return { program: OTHER, sub: null, flags: [] };
+        }
+        if (program === PRIVATE) {
+            if (!(Array.isArray(raw.flags) && raw.flags.length === 0))
+                throw new Refused(under(at, 'flags'), 'a private program holds no flags');
+            if (raw.pulls !== undefined)
+                throw new Refused(under(at, 'pulls'), 'a private program holds no pulls');
+        }
+        // A private program holds no subcommand, so one it sends is set aside, as its flags are refused.
+        const sub = orNull(raw.sub, under(at, 'sub'), (entry, entryAt) => (program === PRIVATE ? unknownValue(held, entryAt, textOf(entry, entryAt)) : nameValue(held, textOf(entry, entryAt), entryAt)));
+        const flags = listOf(raw.flags, under(at, 'flags'), (entry, entryAt) => parseFlag(held, entry, entryAt));
+        return raw.pulls === undefined ? { program, sub, flags } : { program, sub, flags, pulls: listOf(raw.pulls, under(at, 'pulls'), (entry, entryAt) => parsePull(held, entry, entryAt)) };
+    }
+    if (action === 'mcp.call') {
+        const raw = fieldsOf(held, value, at, ['server', 'tool']);
+        const server = nameIn(raw.server, under(at, 'server'));
+        const tool = textOf(raw.tool, under(at, 'tool'));
+        // The same rule capture applies (`callIdentity`), so a name it would have masked is refused here rather than stored.
+        if (harness === OTHER) {
+            // The name crosses as the literal, and what the client sent is kept in the bag.
+            if (tool !== OTHER && tool !== LITERAL)
+                setAside(held, under(at, 'tool'), tool);
+            return { server, tool: tool === OTHER ? tool : LITERAL };
+        }
+        const admitted = tool === LITERAL || tool === OTHER || (server !== PRIVATE && ACTION_TABLES[harness].toolDelimited && (isPublicMcpTool(server, tool) || isWireName(tool)));
+        return { server, tool: admitted ? tool : unknownValue(held, under(at, 'tool'), tool) };
+    }
+    if (action === 'skill.run')
+        return { skill: nameIn(fieldsOf(held, value, at, ['skill']).skill, under(at, 'skill')) };
+    if (action === 'web.fetch' || action === 'web.search') {
+        const { host } = fieldsOf(held, value, at, ['host']);
+        return { host: orNull(host, under(at, 'host'), (entry, entryAt) => nameIn(entry, entryAt)) };
+    }
+    throw new Refused(at, 'this action has no identity');
+};
+/** Whether the harness's table names this native, so it can cross as itself; anything else (including the literal) crosses as `private`. */
+const admittedNative = (harness, native) => {
+    if (native === PRIVATE)
+        return true;
+    if (harness === OTHER)
+        return false;
+    const table = ACTION_TABLES[harness];
+    if (Object.hasOwn(table.rows, native))
+        return true;
+    const mcp = mcpOf(table, native);
+    return mcp !== undefined && table.toolDelimited && isPublicMcpTool(mcp.server, mcp.tool);
+};
+const parseNative = (held, harness, value, at) => {
+    const native = textOf(value, at);
+    // The tools of a harness this reader does not know are off any table it holds, so they cross as `private`, the way capture masks a name its table lacks.
+    if (harness === OTHER)
+        return native === OTHER || isWireName(native) ? native : unknownValue(held, at, native);
+    return native === OTHER || admittedNative(harness, native) || isWireName(native) ? native : unknownValue(held, at, native);
+};
+/** A subagent type as the projection leaves it: a built-in of a harness, or `custom`; a custom agent's own name is private and never admitted. */
+const parseAgentType = (held, value, at) => {
+    const name = textOf(value, at);
+    return name === OTHER || projectedAgentType(name) === name ? name : unknownValue(held, at, name);
+};
+const parseEdge = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['kind', 'target']);
+    return { kind: oneOf(held, EDGE_KINDS, raw.kind, under(at, 'kind')), target: countOf(raw.target, under(at, 'target')) };
+};
+const parseStep = (held, harness, value, at) => {
+    const raw = fieldsOf(held, value, at, ['action', 'native', 'identity', 'status', 'agentType', 'frame'], OPTIONAL.step);
+    const action = oneOf(held, CANONICAL_ACTIONS, raw.action, under(at, 'action'));
+    return {
+        action,
+        native: parseNative(held, harness, raw.native, under(at, 'native')),
+        identity: parseIdentity(held, harness, action, raw.identity, under(at, 'identity')),
+        status: oneOf(held, STATUSES, raw.status, under(at, 'status')),
+        tokens: orNull(raw.tokens, under(at, 'tokens'), (entry, entryAt) => bucketIn('tokens', entry, entryAt)),
+        ms: orNull(raw.ms, under(at, 'ms'), (entry, entryAt) => bucketIn('ms', entry, entryAt)),
+        ...(raw.allocated === undefined ? {} : { allocated: allocatedOf(raw.allocated, under(at, 'allocated')) }),
+        remainingTokens: orNull(raw.remainingTokens, under(at, 'remainingTokens'), (entry, entryAt) => bucketIn('tokens', entry, entryAt)),
+        agentType: orNull(raw.agentType, under(at, 'agentType'), (entry, entryAt) => parseAgentType(held, entry, entryAt)),
+        parent: orNull(raw.parent, under(at, 'parent'), countOf),
+        frame: countOf(raw.frame, under(at, 'frame')),
+        ...(raw.edges === undefined ? {} : { edges: listOf(raw.edges, under(at, 'edges'), (entry, entryAt) => parseEdge(held, entry, entryAt)) }),
+        ...(raw.skill === undefined ? {} : { skill: nameIn(raw.skill, under(at, 'skill')) }),
+    };
+};
+/** A call's `errorCode`: absent or null is none; otherwise a member of the closed list (a value off it reads as `other` and goes to the bag), and only on a call that did not succeed or sit out. */
+const parseErrorCode = (held, status, value, at) => {
+    if (value === undefined || value === null)
+        return null;
+    const code = exactlyIn(held, ERROR_CODES)(value, at);
+    if (status === 'ok' || status === 'none')
+        throw new Refused(at, 'only a failed call has one');
+    return code;
+};
+/** A call's `recoveryCalls`: absent is none; otherwise at most 5 actions (a value off the list reads as `other`) and a flag, and only on a call that did not succeed or sit out; the transcript parse then refuses one on a call whose status is not `error`. */
+const parseRecovery = (held, status, value, at) => {
+    if (value === undefined)
+        return undefined;
+    if (status === 'ok' || status === 'none')
+        throw new Refused(at, 'only a failed call has one');
+    const raw = fieldsOf(held, value, at, ['next', 'editFollowed']);
+    const next = listOf(raw.next, under(at, 'next'), (entry, entryAt) => oneOf(held, CANONICAL_ACTIONS, entry, entryAt));
+    if (next.length > RECOVERY_CALLS)
+        throw new Refused(under(at, 'next'), `more than ${String(RECOVERY_CALLS)} calls`);
+    return { next, editFollowed: booleanOf(raw.editFollowed, under(at, 'editFollowed')) };
+};
+/**
+ * A call's `keys`: absent is none. A tool with a pinned input list sends names on it, and a name off it reads as `other` and goes to the bag; any other tool's names must have the shape of a name. Key names
+ * only, so a value that is no name shape is not a key.
+ */
+const parseKeys = (held, native, value, at) => {
+    if (value === undefined)
+        return undefined;
+    const listed = native === undefined ? undefined : TOOL_INPUT_KEYS.get(native);
+    return listOf(value, at, (entry, entryAt) => {
+        const name = textOf(entry, entryAt);
+        return (listed === undefined ? isWireName(name) : listed.has(name)) ? name : unknownValue(held, entryAt, name);
+    });
+};
+const parseTool = (held, harness, value, at) => {
+    const raw = fieldsOf(held, value, at, ['side', 'status', 'steps'], OPTIONAL.tool);
+    const status = oneOf(held, STATUSES, raw.status, under(at, 'status'));
+    const errorCode = parseErrorCode(held, status, raw.errorCode, under(at, 'errorCode'));
+    const recoveryCalls = parseRecovery(held, status, raw.recoveryCalls, under(at, 'recoveryCalls'));
+    const steps = listOf(raw.steps, under(at, 'steps'), (entry, entryAt) => parseStep(held, harness, entry, entryAt));
+    const keys = parseKeys(held, steps[0]?.native, raw.keys, under(at, 'keys'));
+    const keysDropped = raw.keysDropped === undefined ? undefined : bucketIn('count', raw.keysDropped, under(at, 'keysDropped'));
+    const targetClass = raw.targetClass === undefined ? undefined : oneOf(held, TARGET_CLASSES, raw.targetClass, under(at, 'targetClass'));
+    const argClass = raw.argClass === undefined ? undefined : listOf(raw.argClass, under(at, 'argClass'), (entry, entryAt) => oneOf(held, ARG_CLASSES, entry, entryAt));
+    return {
+        side: booleanOf(raw.side, under(at, 'side')),
+        prompt: orNull(raw.prompt, under(at, 'prompt'), countOf),
+        status,
+        durationMs: orNull(raw.durationMs, under(at, 'durationMs'), countOf),
+        errorCode,
+        ...(recoveryCalls === undefined ? {} : { recoveryCalls }),
+        ...(keys === undefined ? {} : { keys }),
+        ...(keysDropped === undefined ? {} : { keysDropped }),
+        ...(targetClass === undefined ? {} : { targetClass }),
+        ...(argClass === undefined ? {} : { argClass }),
+        steps,
+    };
+};
+const parsePrompt = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['cls', 'errors', 'usage', 'frame'], OPTIONAL.prompt);
+    return {
+        cls: oneOf(held, PROMPT_CLASSES, raw.cls, under(at, 'cls')),
+        errors: bucketIn('count', raw.errors, under(at, 'errors')),
+        wallSec: orNull(raw.wallSec, under(at, 'wallSec'), (entry, entryAt) => bucketIn('seconds', entry, entryAt)),
+        usage: parseUsage(held, raw.usage, under(at, 'usage')),
+        explore: orNull(raw.explore, under(at, 'explore'), (entry, entryAt) => bucketIn('calls', entry, entryAt)),
+        ...(raw.usageResponses === undefined ? {} : { usageResponses: bucketIn('count', raw.usageResponses, under(at, 'usageResponses')) }),
+        // A sent null reads as an absent field, the way every optional field does.
+        ...(raw.intervention === undefined || raw.intervention === null ? {} : { intervention: oneOf(held, PROMPT_INTERVENTIONS, raw.intervention, under(at, 'intervention')) }),
+        frame: parseFrame(held, raw.frame, under(at, 'frame')),
+    };
+};
+const ROOT = /^[0-9a-f]{64}$/;
+const PRINT = /^[0-9a-f]{16}$/;
+const parseRoot = (value, at) => {
+    const root = textOf(value, at);
+    if (!ROOT.test(root))
+        throw new Refused(at, 'not a SHA-256');
+    return root;
+};
+const parseTranscript = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['merkleRoot', 'leaves', 'harness', 'frame', 'frames', 'prompts', 'tools'], OPTIONAL.transcript);
+    const harness = oneOf(held, HARNESSES, raw.harness, under(at, 'harness'));
+    const merkleRoot = parseRoot(raw.merkleRoot, under(at, 'merkleRoot'));
+    const leaves = countOf(raw.leaves, under(at, 'leaves'));
+    // Read in the order the fields are met, so the bag holds what was set aside in that order.
+    const frame = parseFrame(held, raw.frame, under(at, 'frame'));
+    const frames = listOf(raw.frames, under(at, 'frames'), (entry, entryAt) => parseFrame(held, entry, entryAt));
+    // Absent reads as null: a client that names no spawner sends none.
+    const spawnedIn = orNull(raw.spawnedIn, under(at, 'spawnedIn'), countOf);
+    const prompts = listOf(raw.prompts, under(at, 'prompts'), (entry, entryAt) => parsePrompt(held, entry, entryAt));
+    const tools = listOf(raw.tools, under(at, 'tools'), (entry, entryAt) => parseTool(held, harness, entry, entryAt));
+    // What followed a call is read off the calls themselves, so a list that disagrees with them is a wrong deposit, not a new reading.
+    tools.forEach((tool, index) => {
+        if (tool.recoveryCalls !== undefined && JSON.stringify(tool.recoveryCalls) !== JSON.stringify(recoveryCallsOf(tools, index)))
+            throw new Refused(`${at}.tools[${String(index)}].recoveryCalls`, 'not what followed the call');
+    });
+    return { merkleRoot, leaves, harness, frame, frames, spawnedIn, prompts, tools };
+};
+const DELTA_FIELDS = ['plugin', 'package', 'permissionMode', 'effort'];
+/** The kinds each field can take: a plugin comes or goes, a package only goes (an addition is adoption, which `pool` reads from the calls), and a mode or an effort changes. */
+const KINDS_OF = { plugin: ['added', 'removed'], package: ['removed'], permissionMode: ['changed'], effort: ['changed'] };
+/** The one metric each field's change is measured in, and the bucket edges that metric is held to. */
+const METRIC_OF = { plugin: 'callsPerSession', package: 'callsPerSession', permissionMode: 'callsPerSession', effort: 'thinking' };
+const METRIC_EDGES = { callsPerSession: 'count', thinking: 'tokens' };
+const ALL_KINDS = ['added', 'removed', 'changed'];
+const ALL_METRICS = ['callsPerSession', 'thinking'];
+const nullOnly = (value, at) => {
+    if (value !== null)
+        throw new Refused(at, 'outside the vocabulary');
+    return null;
+};
+/**
+ * The entry of a delta, held to its field's own row. A plugin has no registry to pass, so only the word `private` stands for one; a package is a public name with its registry, or `private` with none; a mode
+ * and an effort are named by their field and carry no name. The change is a signed bucket of the field's metric.
+ */
+const parseDelta = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['deltaKind', 'field', 'name', 'registry', 'metric', 'change']);
+    const field = oneOf(held, DELTA_FIELDS, raw.field, under(at, 'field'));
+    // A field this reader does not know has no row to hold its kind, metric, name, or registry to: the first two read against every kind and metric, and the last two are kept as sent.
+    const kinds = field === OTHER ? ALL_KINDS : KINDS_OF[field];
+    const deltaKind = oneOf(held, kinds, raw.deltaKind, under(at, 'deltaKind'));
+    const metric = oneOf(held, field === OTHER ? ALL_METRICS : [METRIC_OF[field]], raw.metric, under(at, 'metric'));
+    const named = field === 'plugin' || field === 'package';
+    if (field === OTHER) {
+        for (const key of ['name', 'registry'])
+            if (raw[key] !== null)
+                setAside(held, under(at, key), raw[key]);
+    }
+    const name = named ? inSet(held, field === 'package' ? PUBLIC_PACKAGES : NO_NAME, raw.name, under(at, 'name')) : field === OTHER ? null : nullOnly(raw.name, under(at, 'name'));
+    const registry = field === 'package' && name !== PRIVATE ? oneOf(held, PACKAGE_REGISTRIES, raw.registry, under(at, 'registry')) : field === OTHER ? null : nullOnly(raw.registry, under(at, 'registry'));
+    const change = raw.change;
+    const limit = metric === OTHER ? Math.max(...ALL_METRICS.map((kind) => EDGES[METRIC_EDGES[kind]].length)) : EDGES[METRIC_EDGES[metric]].length;
+    if (typeof change !== 'number' || !Number.isInteger(change) || Math.abs(change) > limit)
+        throw new Refused(under(at, 'change'), 'not a signed bucket');
+    return { deltaKind, field, name, registry, metric, change };
+};
+const VOCAB_TEXT = /^[0-9A-Za-z._-]{1,32}$/;
+/** The skeleton in `value`, rebuilt from the fields read, with the bag of what was set aside; else the first field that is a shape error, and why. */
+export const parseSkeleton = (value) => {
+    const held = { extensions: [], others: 0 };
+    try {
+        // The earlier forms are named, since their fields would otherwise read as a list of strangers; any other format is a form this reader does not know.
+        if (isFields(value) && typeof value.format === 'number' && value.format < SKELETON_FORMAT)
+            throw new Refused('format', `the format ${String(value.format)} form is no longer read; send format ${String(SKELETON_FORMAT)}`);
+        const raw = fieldsOf(held, value, '', ['format', 'vocabVersion', 'fieldsVersion', 'id', 'transcripts'], OPTIONAL.batch);
+        if (raw.format !== SKELETON_FORMAT)
+            throw new Refused('format', 'not a format this version reads');
+        const vocabVersion = textOf(raw.vocabVersion, 'vocabVersion');
+        if (!VOCAB_TEXT.test(vocabVersion))
+            throw new Refused('vocabVersion', 'not a version');
+        const fieldsVersion = countOf(raw.fieldsVersion, 'fieldsVersion');
+        const id = textOf(raw.id, 'id');
+        if (!ID.test(id))
+            throw new Refused('id', 'not a hash');
+        const deltas = listOrEmpty(raw.deltas, 'deltas', (entry, entryAt) => parseDelta(held, entry, entryAt));
+        const transcripts = listOf(raw.transcripts, 'transcripts', (entry, entryAt) => parseTranscript(held, entry, entryAt));
+        if (transcripts.length === 0)
+            throw new Refused('transcripts', 'empty');
+        // A counting batch is what lifts the fetch cap, so a deposit has to hold something to derive from.
+        if (transcripts.every(({ prompts, tools }) => prompts.length === 0 && tools.length === 0))
+            throw new Refused('transcripts', 'holds no prompt and no tool');
+        // The main run's calls make the one print, so it exists exactly when the main run holds enough timed calls; a subagent's calls never decide it.
+        const timed = (transcripts[0]?.tools ?? []).filter(({ durationMs }) => durationMs !== null).length;
+        const timingPrint = orNull(raw.timingPrint, 'timingPrint', (entry, entryAt) => {
+            const text = textOf(entry, entryAt);
+            if (!PRINT.test(text))
+                throw new Refused(entryAt, 'not a hash');
+            return text;
+        });
+        if ((timingPrint === null) !== (timed < MIN_TIMED_CALLS))
+            throw new Refused('timingPrint', timingPrint === null ? 'missing: the main run holds enough timed calls' : 'not allowed: the main run holds too few timed calls');
+        // A step carries the type of the subagent whose run holds it, so the main run's steps carry none and every subagent step carries one.
+        transcripts.forEach(({ tools }, index) => {
+            tools.forEach(({ steps }, call) => {
+                steps.forEach(({ agentType }, position) => {
+                    if ((agentType === null) !== (index === 0))
+                        throw new Refused(`transcripts[${String(index)}].tools[${String(call)}].steps[${String(position)}].agentType`, index === 0 ? 'a main-run step has no subagent type' : 'a subagent step needs its type');
+                });
+            });
+        });
+        // Positions are the only ordinals on the wire, so each must name something the batch holds.
+        // A spawner is another transcript of the batch whose own spawners lead to a run with none, so the batch is a forest and the main run is its first root.
+        transcripts.forEach(({ spawnedIn }, index) => {
+            if (spawnedIn === null)
+                return;
+            const spawnedAt = `transcripts[${String(index)}].spawnedIn`;
+            if (index === 0)
+                throw new Refused(spawnedAt, 'the main run has no spawner');
+            if (spawnedIn >= transcripts.length || spawnedIn === index)
+                throw new Refused(spawnedAt, 'no such transcript');
+            let above = spawnedIn;
+            for (let hop = 0; hop < transcripts.length && above !== null; hop += 1)
+                above = transcripts[above]?.spawnedIn ?? null;
+            if (above !== null)
+                throw new Refused(spawnedAt, 'a spawner cycle');
+        });
+        const stepsOf = transcripts.map(({ tools }) => tools.reduce((all, { steps }) => all + steps.length, 0));
+        transcripts.forEach(({ prompts, tools, frames, spawnedIn }, index) => {
+            if (frames.length === 0)
+                throw new Refused(`transcripts[${String(index)}].frames`, 'empty');
+            // The call and prompt of every step in the transcript's order, which an edge's target is a position in.
+            const placed = tools.flatMap(({ prompt, steps }) => steps.map(() => ({ prompt })));
+            let before = 0;
+            tools.forEach(({ prompt, steps }, call) => {
+                const callAt = `transcripts[${String(index)}].tools[${String(call)}]`;
+                // Past the prompts it names a prompt with no record, numbered in order of appearance: no more of those than calls.
+                if (prompt !== null && prompt >= prompts.length + tools.length)
+                    throw new Refused(`${callAt}.prompt`, 'no such prompt position');
+                steps.forEach(({ parent, frame, edges }, position) => {
+                    const stepAt = `${callAt}.steps[${String(position)}]`;
+                    if (parent !== null && (spawnedIn === null || parent >= (transcripts[spawnedIn]?.tools.length ?? 0)))
+                        throw new Refused(`${stepAt}.parent`, 'no such call in the spawning transcript');
+                    if (frame >= frames.length)
+                        throw new Refused(`${stepAt}.frame`, 'no such frame position');
+                    const here = before + position;
+                    (edges ?? []).forEach(({ kind, target }, edge) => {
+                        const edgeAt = `${stepAt}.edges[${String(edge)}]`;
+                        if (kind === OTHER)
+                            return;
+                        if (kind === 'spawned') {
+                            if (spawnedIn === null)
+                                throw new Refused(`${edgeAt}.kind`, 'a spawned edge needs a spawning transcript');
+                            if (target >= (stepsOf[spawnedIn] ?? 0))
+                                throw new Refused(`${edgeAt}.target`, 'no such step in the spawning transcript');
+                            return;
+                        }
+                        // The other kinds name an earlier step of the same transcript; a next stays inside one prompt.
+                        if (target >= here)
+                            throw new Refused(`${edgeAt}.target`, 'not an earlier step of this transcript');
+                        if (kind === 'next' && placed[target]?.prompt !== prompt)
+                            throw new Refused(`${edgeAt}.target`, 'a next edge crosses a prompt');
+                    });
+                });
+                before += steps.length;
+            });
+        });
+        return { ok: true, skeleton: { format: SKELETON_FORMAT, vocabVersion, fieldsVersion, id, transcripts, timingPrint, deltas }, extensions: held.extensions, others: held.others };
+    }
+    catch (error) {
+        if (error instanceof Refused)
+            return { ok: false, field: error.field, reason: error.reason };
+        throw error;
+    }
+};
+const isSignedBundle = (value) => isFields(value) && typeof value.payload === 'string' && typeof value.signature === 'string';
+const isFloor = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 1;
+/** The floors a bundle states, or none: a client prints what is here, so a value that is not a whole number of at least 1 is refused and not shown, while a family this client does not know is carried (in `--json`) and not printed, since `floorSentence` prints only the families this client knows (additive, section 17 rule 3). */
+const isFloors = (value) => isFields(value) && isFloor(value.public) && isFloor(value.disclosure) && (value.families === undefined || (isFields(value.families) && Object.values(value.families).every(isFloor)));
+const isSourced = (value) => isFields(value) && ((value.state === 'value' && typeof value.value === 'number') || (value.state === 'no source yet' && typeof value.reason === 'string'));
+const isCount = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+/** The set of four a bundle may carry: every field the `books` read prints is present and of its type, with its format, vocabulary version, and the two served lists checked as well, so a signed bundle with a malformed block reads as not a bundle, not as a crash in the printer. */
+const isBooks = (value) => isFields(value) &&
+    isFloor(value.floor) &&
+    value.format === BUNDLE_FORMAT &&
+    typeof value.vocabVersion === 'string' &&
+    isFields(value.asOf) &&
+    (value.asOf.day === null || typeof value.asOf.day === 'string') &&
+    isFields(value.served) &&
+    isCount(value.served.total) &&
+    Array.isArray(value.served.byWeek) &&
+    Array.isArray(value.served.byTuple) &&
+    isCount(value.backlog) &&
+    isSourced(value.panel) &&
+    (value.panelDay === null || typeof value.panelDay === 'string') &&
+    isFields(value.demand) &&
+    isSourced(value.demand.comparisonReadOwners) &&
+    isSourced(value.demand.followOnReads) &&
+    isFields(value.goal) &&
+    isSourced(value.goal.readYield) &&
+    isSourced(value.goal.costPerServedCell) &&
+    isSourced(value.goal.yieldPerServedCell);
+// A bundle states the floor it applied (`floor`), and a client cannot tell which floor a bundle without one applied, so a format 1 bundle with no `floor` is refused as not a bundle this version reads.
+const isBundle = (value) => isFields(value) && value.format === BUNDLE_FORMAT && typeof value.harness === 'string' && isHarness(value.harness) && typeof value.harnessVersion === 'string' && typeof value.vocabVersion === 'string' && typeof value.floor === 'number' && isFields(value.asOf) && Array.isArray(value.cells) && Array.isArray(value.motifs) && Array.isArray(value.reads) && Array.isArray(value.strata) && (value.floors === undefined || isFloors(value.floors)) && (value.books === undefined || isBooks(value.books));
+const signatureHolds = async ({ payload, signature }, key) => {
+    try {
+        const verifier = await crypto.subtle.importKey('jwk', { kty: key.kty, crv: key.crv, x: key.x }, 'Ed25519', false, ['verify']);
+        return await crypto.subtle.verify('Ed25519', verifier, Uint8Array.from(atob(signature), (char) => char.charCodeAt(0)), new TextEncoder().encode(payload));
+    }
+    catch {
+        return false;
+    }
+};
+/** The bundle, only when the pinned key signed these bytes for the harness and version that were asked for: another harness's or version's bundle, under a good signature, is still the wrong answer. */
+export const verifyBundle = async (signed, key, harness, harnessVersion) => {
+    if (!isSignedBundle(signed))
+        return { ok: false, reason: 'not a signed bundle' };
+    if (!(await signatureHolds(signed, key)))
+        return { ok: false, reason: 'the signature does not match the key pinned at login' };
+    const bundle = JSON.parse(signed.payload);
+    if (!isBundle(bundle))
+        return { ok: false, reason: 'not a signed bundle this version reads' };
+    if (bundle.vocabVersion !== VOCAB_VERSION)
+        return { ok: false, reason: `this bundle is for vocabulary version ${bundle.vocabVersion}, not ${VOCAB_VERSION}` };
+    if (bundle.harness !== harness)
+        return { ok: false, reason: `this bundle is for harness ${bundle.harness}, not ${harness}` };
+    if (bundle.harnessVersion !== harnessVersion)
+        return { ok: false, reason: `this bundle is for harness version ${bundle.harnessVersion}, not ${harnessVersion}` };
+    return { ok: true, bundle };
+};