@volter/twin-standard 1.0.158 → 1.0.160

package/dist/src/protocol-3.js

@@ -25,6 +25,7 @@ import ts from 'typescript';
 import { fileURLToPath } from 'node:url';
 import { sharingLanesIn } from "./lanes.js";
 import { isPackArtifact } from "./pack-files.js";
+import { credentialIssuerImports } from "./credential-issuer-import.js";
 // A path relative to another with '/' between its parts on every platform: git lists files that way, and every rule
 // here compares and splits on '/'; Windows' relative() joins with '\', which hid every lane's files and spec.
 const rel = (from, to) => relative(from, to).split(sep).join('/');
@@ -190,7 +191,7 @@ function noReport(unit) {
 /** An operation's family: the first segment of its path after a version (`/v1/organizations/{id}` is `organizations`), a
  *  dotted RPC method's first part (`chat.postMessage` is `chat`), a line command's name (architecture, "Pack layout"). */
 function familyOf(path) {
-    // the interim rule ("What an author writes"), until derive-pack writes the spec's own grouping on each operation
+    // the interim rule ("What an author writes"), until the derivation writes the spec's own grouping on each operation
     const segs = path.split('/').filter((x) => x && !/^v?\d+(\.\d+)?$|^\d{4}-\d{2}-\d{2}$/.test(x) && !x.startsWith('{'));
     if (!segs.length)
         return 'operations'; // named in a header: every path is `/`
@@ -289,7 +290,7 @@ const criteria = [
     },
     {
         id: 'derived-reproducible', section: 'form',
-        asks: 'derive-pack regenerates src/generated/ byte for byte',
+        asks: 'twin-standard derive regenerates src/generated/ byte for byte',
         check(unit) {
             const gen = join(unit.dir, 'src', 'generated');
             if (!existsSync(gen))
@@ -309,10 +310,10 @@ const criteria = [
             // a standing written from one checkout reads the same from any other
             if (run.status === null || run.signal !== null || run.error)
                 return { pass: false, cacheable: false,
-                    reason: `derive-pack interrupted: status=${run.status} signal=${run.signal} error=${run.error?.message ?? ''}` };
+                    reason: `derive interrupted: status=${run.status} signal=${run.signal} error=${run.error?.message ?? ''}` };
             if (run.status !== 0)
-                return { ...fail(`derive-pack refused: ${String(run.stderr || run.stdout).split(unit.dir).join('.').split(tmp).join('<out>').trim().split('\n').slice(-2).join(' ').slice(0, 200)}`), cacheable: run.status === 2 };
-            return changed.length ? fail(`derive-pack writes differently: ${changed.slice(0, 5).join(', ')}${changed.length > 5 ? ` and ${changed.length - 5} more` : ''}`) : pass(`${filesUnder(gen).length} files reproduced`);
+                return { ...fail(`derive refused: ${String(run.stderr || run.stdout).split(unit.dir).join('.').split(tmp).join('<out>').trim().split('\n').slice(-2).join(' ').slice(0, 200)}`), cacheable: run.status === 2 };
+            return changed.length ? fail(`derive writes differently: ${changed.slice(0, 5).join(', ')}${changed.length > 5 ? ` and ${changed.length - 5} more` : ''}`) : pass(`${filesUnder(gen).length} files reproduced`);
         },
     },
     {
@@ -387,7 +388,7 @@ const criteria = [
     },
     {
         id: 'handler-contract', section: 'form',
-        asks: 'every file in semantics/ reaches no randomness, clock, environment, network or module but the kernel, the states and the shared helpers; each handler file is its family\'s and exports only its operations, named by the fixed rule',
+        asks: 'every file in semantics/ reaches no randomness, clock, environment, network or module but the kernel, the states, the shared helpers and a public subpath of its declared credential issuer pinned at an exact version as a direct runtime dependency; each handler file is its family\'s and exports only its operations, named by the fixed rule',
         check(unit) {
             const dir = join(unit.dir, 'src', 'semantics');
             if (!existsSync(dir))
@@ -395,6 +396,7 @@ const criteria = [
             const ops = operationsOf(unit);
             const families = new Set(ops.values());
             const found = [];
+            const issuerImport = credentialIssuerImports(unit.dir, packageOf(unit));
             for (const f of filesUnder(dir).filter((x) => /\.tsx?$/.test(x) && !TEST_FILE.test(x))) {
                 const text = stripComments(readFileSync(join(dir, f), 'utf8'));
                 const raw = readFileSync(join(dir, f), 'utf8');
@@ -413,7 +415,7 @@ const criteria = [
                     const engineModule = /^\.\.\/engine\/[A-Za-z0-9_-]+\.ts$/.test(from) || vendorPath(unit, from, 3, /^engine\/[A-Za-z0-9_-]+\.ts$/);
                     // a lane over its vendor's state takes the vendor's states and shared helpers ("Pack layout")
                     const vendorShared = vendorPath(unit, from, 3, /^(semantics\/(states|shared)|manifest)\.ts$/);
-                    if (from !== '@volter/world-core' && !/^\.\/(states|shared)\.ts$/.test(from) && !mapImport && !engineModule && !vendorShared)
+                    if (from !== '@volter/world-core' && !/^\.\/(states|shared)\.ts$/.test(from) && !mapImport && !engineModule && !vendorShared && !issuerImport(from))
                         found.push(`${f} imports ${from}`);
                 }
                 // the handler map is typed over the narrow context, so the compiler holds every handler it names to the contract
@@ -546,12 +548,13 @@ const criteria = [
     },
     {
         id: 'kernel-contract', section: 'form',
-        asks: "every file of src/ imports the kernel through its root, the pack contract, and nothing past it: no `@volter/world-core/runtime` or other entry (cli.ts alone takes args and lifecycle), no node builtin, no other package but @volter/world-ui and the generated GraphQL library loader",
+        asks: "every file of src/ imports the kernel through its root, the pack contract, and nothing past it: no `@volter/world-core/runtime` or other entry (cli.ts alone takes args and lifecycle), no node builtin, no other package but @volter/world-ui, a public subpath of its declared credential issuer pinned at an exact version as a direct runtime dependency, and the generated GraphQL library loader",
         check(unit) {
             const src = join(unit.dir, 'src');
             if (!existsSync(src))
                 return fail('src/ is missing');
             const found = [];
+            const issuerImport = credentialIssuerImports(unit.dir, packageOf(unit));
             for (const f of filesUnder(src).filter((x) => /\.tsx?$/.test(x) && !TEST_FILE.test(x) && !x.startsWith('generated/'))) {
                 // the file's imports, re-exports and dynamic imports as TypeScript reads them (a string that only reads like one,
                 // an error message's "from '<name>'", is none)
@@ -596,6 +599,8 @@ const criteria = [
                         continue;
                     if (from === '@volter/world-core' || from === '@volter/world-ui')
                         continue;
+                    if (issuerImport(from))
+                        continue;
                     if (f === 'cli.ts' && (from === '@volter/world-core/args' || from === '@volter/world-core/lifecycle'))
                         continue;
                     found.push(`${f} imports ${from}`);

package/dist/src/spec-documents.d.ts

@@ -4,6 +4,10 @@ export type SpecDocuments = {
 };
 /** The documents of `spec/openapi/`, by name, or undefined when the pack vendors one spec file. */
 export declare function readSpecDocuments(specDir: string): SpecDocuments | undefined;
+/** Response declarations as served, independent of their representation media or generated surface version. */
+export declare function declaredResponseStatuses(specDir: string): Map<string, Set<string>>;
+/** Declared schema fields, including nested objects that are not inferred as generated resources. */
+export declare function schemaFieldNames(specDir: string): Set<string>;
 /** The union of the documents as one OpenAPI document; each contradiction left unpatched is named, by pointer. */
 export declare function mergeDocuments(docs: SpecDocuments): {
     doc: Json;

package/dist/src/spec-documents.js

@@ -9,6 +9,13 @@ import { parse as parseYaml } from 'yaml';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { gunzipSync } from 'node:zlib';
+import { applySpecPatch } from "./spec-patches.js";
+import { slug } from "./spec-ir.js";
+function readDocument(file) {
+    const bytes = readFileSync(file);
+    const text = (file.endsWith('.gz') ? gunzipSync(bytes) : bytes).toString('utf8');
+    return /\.ya?ml(\.gz)?$/.test(file) ? parseExactJson(JSON.stringify(parseYaml(text, { intAsBigInt: true }), (_, value) => typeof value === 'bigint' ? exactInteger(String(value)) : value)) : parseExactJson(text);
+}
 /** The documents of `spec/openapi/`, by name, or undefined when the pack vendors one spec file. */
 export function readSpecDocuments(specDir) {
     const dir = join(specDir, 'openapi');
@@ -16,14 +23,114 @@ export function readSpecDocuments(specDir) {
         return undefined;
     const documents = {};
     for (const f of readdirSync(dir).filter((f) => /\.(json|ya?ml)(\.gz)?$/.test(f)).sort()) {
-        const bytes = readFileSync(join(dir, f));
-        const text = (f.endsWith('.gz') ? gunzipSync(bytes) : bytes).toString('utf8');
-        documents[f.replace(/\.(json|ya?ml)(\.gz)?$/, '')] = /\.ya?ml(\.gz)?$/.test(f) ? parseExactJson(JSON.stringify(parseYaml(text, { intAsBigInt: true }), (_, v) => typeof v === 'bigint' ? exactInteger(String(v)) : v)) : parseExactJson(text);
+        documents[f.replace(/\.(json|ya?ml)(\.gz)?$/, '')] = readDocument(join(dir, f));
     }
     if (Object.keys(documents).length < 2)
         throw new Error(`${dir}: one API in several documents needs at least two; a single document is spec/openapi.{json,yaml}`);
     return { documents };
 }
+const openapiFiles = ['openapi.json.gz', 'openapi.json', 'openapi.yaml.gz', 'openapi.yaml'];
+function readPatchedDocument(specDir, filenames) {
+    const file = filenames.map((name) => join(specDir, name)).find(existsSync);
+    const documents = file === undefined ? readSpecDocuments(specDir) : undefined;
+    let doc = file === undefined ? documents : readDocument(file);
+    if (doc === undefined)
+        return undefined;
+    const patches = join(specDir, 'patches.json');
+    if (existsSync(patches))
+        for (const patch of readDocument(patches).patches)
+            applySpecPatch(doc, patch);
+    if (documents !== undefined) {
+        const merged = mergeDocuments(doc);
+        if (merged.contradictions.length)
+            throw new Error(`OpenAPI response declarations conflict: ${merged.contradictions.join('; ')}`);
+        doc = merged.doc;
+    }
+    return doc;
+}
+/** Response declarations as served, independent of their representation media or generated surface version. */
+export function declaredResponseStatuses(specDir) {
+    const doc = readPatchedDocument(specDir, openapiFiles);
+    const statuses = new Map();
+    if (doc === undefined)
+        return statuses;
+    for (const [path, item] of Object.entries(doc.paths ?? {})) {
+        for (const [method, operation] of Object.entries(item)) {
+            if (!operation || typeof operation !== 'object' || !operation.responses)
+                continue;
+            statuses.set(operation.operationId || slug(method, path), new Set(Object.keys(operation.responses)));
+        }
+    }
+    return statuses;
+}
+/** Declared schema fields, including nested objects that are not inferred as generated resources. */
+export function schemaFieldNames(specDir) {
+    const doc = readPatchedDocument(specDir, ['smithy.json.gz', 'smithy.json', ...openapiFiles, 'discovery.json.gz', 'discovery.json']);
+    const fields = new Set();
+    if (doc === undefined)
+        return fields;
+    for (const shape of Object.values(doc.shapes ?? {})) {
+        if (shape.type !== 'structure' && shape.type !== 'union')
+            continue;
+        for (const [name, member] of Object.entries(shape.members ?? {})) {
+            fields.add(name);
+            for (const trait of ['smithy.api#jsonName', 'smithy.api#xmlName']) {
+                const wireName = member.traits?.[trait];
+                if (typeof wireName === 'string')
+                    fields.add(wireName);
+            }
+        }
+    }
+    const schema = (node) => {
+        if (Array.isArray(node)) {
+            for (const item of node)
+                schema(item);
+            return;
+        }
+        if (!node || typeof node !== 'object')
+            return;
+        for (const [name, property] of Object.entries(node.properties ?? {})) {
+            fields.add(name);
+            if (typeof property?.xml?.name === 'string')
+                fields.add(property.xml.name);
+            schema(property);
+        }
+        for (const keyword of ['$defs', 'definitions', 'patternProperties', 'dependentSchemas']) {
+            for (const child of Object.values(node[keyword] ?? {}))
+                schema(child);
+        }
+        for (const keyword of ['items', 'additionalItems', 'additionalProperties', 'unevaluatedProperties', 'unevaluatedItems', 'not', 'contains', 'propertyNames', 'if', 'then', 'else', 'allOf', 'anyOf', 'oneOf', 'prefixItems'])
+            schema(node[keyword]);
+    };
+    for (const catalog of [doc.components?.schemas, doc.definitions, doc.schemas]) {
+        for (const node of Object.values(catalog ?? {}))
+            schema(node);
+    }
+    const body = (node) => {
+        schema(node?.schema);
+        for (const media of Object.values(node?.content ?? {}))
+            schema(media?.schema);
+    };
+    for (const catalog of [doc.components?.responses, doc.components?.requestBodies, doc.components?.parameters, doc.components?.headers, doc.responses, doc.parameters]) {
+        for (const node of Object.values(catalog ?? {}))
+            body(node);
+    }
+    for (const paths of [doc.paths, doc.webhooks, doc.components?.pathItems]) {
+        for (const item of Object.values(paths ?? {})) {
+            for (const parameter of item.parameters ?? [])
+                body(parameter);
+            for (const method of ['get', 'put', 'post', 'delete', 'patch', 'head', 'options', 'trace']) {
+                const operation = item[method];
+                for (const parameter of operation?.parameters ?? [])
+                    body(parameter);
+                body(operation?.requestBody);
+                for (const response of Object.values(operation?.responses ?? {}))
+                    body(response);
+            }
+        }
+    }
+    return fields;
+}
 /** A node without its words (description, summary, examples, and the tags a document files it under): what two
  *  documents must agree on. */
 const substance = (n) => JSON.stringify(n, (k, v) => (['description', 'summary', 'example', 'examples', 'x-mint', 'tags'].includes(k) ? undefined : v && typeof v === 'object' && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => a.localeCompare(b))) : v));

package/dist/src/spec-ir-client.js

@@ -6,7 +6,7 @@
 // `spec/`, Creating a pack, step 2): its method, its URL as the client
 // builds it (a label is the Python expression the client interpolates), the query keys it sends (literal, or the keys
 // of the dict it urlencodes) and its body's keys, each typed by the client's own annotation of the value (`null`
-// where the client does not say). A spec patch corrects the table as it corrects a JSON spec (derive-pack): what the
+// where the client does not say). A spec patch corrects the table as it corrects a JSON spec (twin-standard derive): what the
 // client builds as a raw string (a token's scopes) comes from the vendor's reference page that way.
 //
 // The calls at one method and path are one operation, their query and body keys together. The client says nothing

package/dist/src/spec-ir-commands.js

@@ -3,7 +3,7 @@
 // its group, the version it arrived in, its arity, its arguments, its flags and its reply's schema); a pack whose wire
 // carries Redis commands (Upstash's REST API: a command and its arguments in the path or the body) vendors the files of
 // the commands its vendor serves and derives its command surface from them, as a line protocol's surface is its RFC's
-// command table (spec-ir-lines.ts). A spec patch corrects the data as it corrects a JSON spec (derive-pack).
+// command table (spec-ir-lines.ts). A spec patch corrects the data as it corrects a JSON spec (twin-standard derive).
 function argumentOf(a) {
     return {
         name: String(a.name),

package/dist/src/spec-ir-lines.js

@@ -1,6 +1,6 @@
 // A line protocol's spec as data: the commands a client sends and the replies each may be answered,
 // read from the RFC's own table of them. The IR a byte-stream pack derives its surface from, as an HTTP
-// pack derives its from an OpenAPI document; a spec patch corrects it the same way (derive-pack).
+// pack derives its from an OpenAPI document; a spec patch corrects it the same way (twin-standard derive).
 //
 // SMTP's table is RFC 5321 §4.3.2 "Command-Reply Sequences": each command, then its intermediate (I),
 // success (S) and error (E) codes, where `I: 354 -> data -> S: 250` says what answers the lines that

package/dist/src/spec-ir-proto.d.ts

@@ -40,7 +40,7 @@ export type ProtoFile = {
 };
 /** One `.proto` file's declarations. */
 export declare function parseProto(path: string, text: string): ProtoFile;
-/** The vendored tree (path → text) as data, so a spec patch corrects it as it corrects a JSON spec (derive-pack). */
+/** The vendored tree (path → text) as data, so a spec patch corrects it as it corrects a JSON spec (twin-standard derive). */
 export type ProtoSpec = {
     format: 'proto';
     files: ProtoFile[];

package/dist/src/spec-patches.js

@@ -1,6 +1,6 @@
 // A pack's corrections to its vendor's spec (spec/patches.json): RFC 6902 operations (add, replace, remove, move, copy),
-// applied to the parsed spec so the vendored file stays the vendor's own bytes. derive-pack.ts applies them before the
-// IR; vendor-examples.ts reads the patched schemas, which are what the twin is derived from.
+// applied to the parsed spec so the vendored file stays the vendor's own bytes. the derivation applies them before the
+// IR; `twin-standard examples` reads the patched schemas, which are what the twin is derived from.
 /** Apply one patch to `doc` in place. */
 export function applySpecPatch(doc, p) {
     const at = (pointer) => {

package/dist/src/tools/judge-brief.js

@@ -3,8 +3,7 @@
 // runtime). The verdict names its judge and the authors; the grade refuses one whose judge is an author
 // (packages/twin-standard/src/verdict.ts). One judging per pack: the verdict stands through later changes.
 //
-//   twin-standard judge-brief <vendor> --authors <author name>[,<agent>...]   (from the pack repository's root; twin-world's
-//   bun scripts/judge-brief.ts runs the same)
+//   twin-standard judge-brief <vendor> --authors <author name>[,<agent>...]   (from the pack repository's root)
 import { attributionName } from "../verdict.js";
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';

package/dist/src/tools/life-coverage-walk.js

@@ -16,7 +16,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { listActions, observeTransitions, stateOf } from '@volter/world-core/runtime';
 import { inMemoryWorld, walk, usePacks } from "../walk/behavior-journey.js";
-import { lanesOf, shapeChecker } from "../walk/shape.js";
+import { lanesOf, lineShape, shapeChecker } from "../walk/shape.js";
 import { sharingLanesIn } from "../lanes.js";
 /** Registers, in the `bun test` run that imports it, the walks of `vendor` in the pack repository at `PACKS`. */
 export async function coverageWalks(PACKS, vendor) {
@@ -36,9 +36,12 @@ export async function coverageWalks(PACKS, vendor) {
             const { manifest } = (await import(__rewriteRelativeImportExtension(join(PACKS, vendor, 'src', 'manifest.ts'))));
             // the lanes over the vendor's state its serve factory serves are walked by this life, their machines with the vendor's
             // ("Pack layout"); two manifests naming one resource's field would collide in the keys below, so that refuses
-            const laneManifests = await Promise.all(sharingLanes(vendor).map(async (l) => (await import(__rewriteRelativeImportExtension(join(PACKS, vendor, l, 'src', 'manifest.ts')))).manifest));
+            const units = [{ dir: join(PACKS, vendor), manifest, lane: undefined }, ...await Promise.all(sharingLanes(vendor).map(async (l) => {
+                    const dir = join(PACKS, vendor, l);
+                    return { dir, lane: l, manifest: (await import(__rewriteRelativeImportExtension(join(dir, 'src', 'manifest.ts')))).manifest };
+                }))];
             // a vendor of lanes' root (a VendorManifest) declares no resources of its own: its lanes do
-            const allResources = [manifest, ...laneManifests].flatMap((mf) => Object.entries(mf.resources ?? {}));
+            const allResources = units.flatMap(({ manifest: mf }) => Object.entries(mf.resources ?? {}));
             const machines = new Map();
             for (const [resource, decl] of allResources)
                 for (const [field, machine] of Object.entries(decl.state ?? {})) {
@@ -50,23 +53,28 @@ export async function coverageWalks(PACKS, vendor) {
                     machines.set(name, machine);
                 }
             const where = new Map();
-            for (const mf of [manifest, ...laneManifests])
+            const httpTransitions = new Set();
+            for (const { dir, manifest: mf } of units) {
+                const http = !lineShape(dir);
                 for (const [resource, decl] of Object.entries(mf.resources ?? {})) {
                     for (const [field, m] of Object.entries(decl.state ?? {}))
                         m.transitions.forEach((t, i) => {
+                            if (http)
+                                httpTransitions.add(t);
                             const place = { at: `${resource}.${field}#${i}`, field, type: decl.storedAs ?? resource, service: mf.service ?? mf.vendor };
                             const places = where.get(t) ?? [];
                             if (!places.some((p) => p.at === place.at && p.type === place.type && p.service === place.service))
                                 where.set(t, [...places, place]);
                         });
                 }
+            }
             const moves = new Map();
             const subjectKey = (service, type, id) => JSON.stringify([service, type, id]);
             observeTransitions((_decl, t, outcome, from, entry) => {
                 const places = where.get(t) ?? [];
                 if (outcome === 'refused') {
-                    // A failed check on an already committed write is no refusal the application received.
-                    if (entry)
+                    // HTTP refusals are credited from their received status and body; a line protocol owns its session's replies.
+                    if (entry || httpTransitions.has(t))
                         return;
                     const groups = new Set(places.map((p) => JSON.stringify([p.service, p.type, p.field])));
                     if (groups.size === 1)
@@ -100,11 +108,14 @@ export async function coverageWalks(PACKS, vendor) {
             const shape = await shapeChecker(join(PACKS, vendor));
             const answered = [];
             try {
-                await walk(life, root, failures, { beats: w.beats, hooks: { after: (step, path, answer) => {
+                await walk(life, root, failures, { beats: w.beats, hooks: { after: (_step, _path, answer) => {
                             // a line step's refusals are the machine's own (observeTransitions); a request's are read off its answer
-                            const op = 'method' in step ? shape?.operationOf(step.method, path, { ...(life.headers ?? {}), ...(step.headers ?? {}) })?.op.id : undefined;
-                            if (op)
-                                answered.push({ op, text: JSON.stringify(answer.body ?? ''), body: answer.body });
+                            const request = answer.request;
+                            if (!request)
+                                return;
+                            const hit = shape?.operationOf(request.method, request.url, request.headers);
+                            if (hit)
+                                answered.push({ op: hit.op.id, lane: hit.lane, status: answer.status, body: answer.wireBody });
                         } } });
                 // a declared refusal is reached when a step on its operation was answered with it: its code, or its message
                 // up to the first placeholder
@@ -112,26 +123,27 @@ export async function coverageWalks(PACKS, vendor) {
                 const holds = (value, code) => (value !== null && typeof value === 'object'
                     ? Object.values(value).some((v) => holds(v, code))
                     : (typeof value === 'string' || typeof value === 'number') && String(value) === code);
-                const answers = (a, r) => r.code !== undefined ? holds(a.body, String(r.code)) : a.text.includes(r.message.split('{')[0].trim());
-                for (const [resource, decl] of allResources) {
-                    for (const [field, m] of Object.entries(decl.state ?? {})) {
-                        m.transitions.forEach((t, i) => {
-                            if (!t.operation)
-                                return;
-                            const on = answered.filter((a) => a.op === t.operation);
-                            if (t.refusal && on.some((a) => answers(a, t.refusal)))
-                                seen.add(`${resource}.${field}#${i}|refused|*`);
-                            for (const [from, r] of Object.entries(t.refusals ?? {}))
-                                if (on.some((a) => answers(a, r)))
-                                    seen.add(`${resource}.${field}#${i}|refused|${from}`);
-                        });
+                const answers = (a, r) => a.status === r.status && (r.code !== undefined ? holds(a.body, String(r.code)) : JSON.stringify(a.body)?.includes(r.message.split('{')[0].trim()) === true);
+                for (const { manifest: mf, lane } of units)
+                    for (const [resource, decl] of Object.entries(mf.resources ?? {})) {
+                        for (const [field, m] of Object.entries(decl.state ?? {})) {
+                            m.transitions.forEach((t, i) => {
+                                if (!t.operation)
+                                    return;
+                                const on = answered.filter((a) => a.op === t.operation && a.lane === lane);
+                                if (t.refusal && on.some((a) => answers(a, t.refusal)))
+                                    seen.add(`${resource}.${field}#${i}|refused|*`);
+                                for (const [from, r] of Object.entries(t.refusals ?? {}))
+                                    if (on.some((a) => answers(a, r)))
+                                        seen.add(`${resource}.${field}#${i}|refused|${from}`);
+                            });
+                        }
                     }
-                }
                 // every change the life made to a declared state field, from the World's log in order: a move is the declared
                 // transition that allows it (from its state to the next, by its operation when both name one); a change no
                 // transition allows is an undeclared move
                 const fieldsOf = new Map();
-                for (const mf of [manifest, ...laneManifests])
+                for (const { manifest: mf } of units)
                     for (const [resource, decl] of Object.entries(mf.resources ?? {})) {
                         const key = JSON.stringify([mf.service ?? mf.vendor, decl.storedAs ?? resource]);
                         for (const [field, m] of Object.entries(decl.state ?? {}))
@@ -139,7 +151,7 @@ export async function coverageWalks(PACKS, vendor) {
                     }
                 const current = new Map();
                 // the services the life wrote: the vendor's, or its lanes' (a vendor of lanes' root names none of its own)
-                const services = [...new Set([manifest, ...laneManifests].map((mf) => mf.service).filter((x) => typeof x === 'string'))];
+                const services = [...new Set(units.map(({ manifest: mf }) => mf.service).filter((x) => typeof x === 'string'))];
                 if (!services.length)
                     services.push(manifest.vendor);
                 for (const a of services.flatMap((service) => listActions(service, root))) {

package/dist/src/tools/life-coverage.js

@@ -32,8 +32,8 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 // A walk that fails, and a file in scope (the pack's src/ on disk, its sharing lanes' too) that declares code yet
 // measures no line, stop the measurement: neither is a file with nothing to reach.
 //
-// Usage: twin-standard coverage <vendor> [--write | --out <file>] [--prune]   (from the pack repository's root; twin-world's
-//        bun scripts/life-coverage.ts runs the same)   (--prune removes the stale records)   (--write keeps journeys/coverage.json)
+// Usage: twin-standard coverage <vendor> [--write | --out <file>] [--prune]   (from the pack repository's root)
+//        (--prune removes the stale records)   (--write keeps journeys/coverage.json)
 import { spawnSync } from 'node:child_process';
 import ts from 'typescript';
 import { existsSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';

package/dist/src/tools/packs-root.js

@@ -1,8 +1,8 @@
 // Where the contributor's tools (walk, examples, coverage, judge-brief) find the pack they are given: a vendor's directory
 // under the pack repository they run from. A contributor runs them from their own repository's root (`twin-standard walk
-// <vendor>`), so that root is the working directory; twin-world's scripts, which find Volter's pack repository beside
-// their checkout, name it before loading a tool (setPacksRoot), and the kernel checkout a walk must measure
-// (setKernelCheckout). Each tool reads both once, when it loads.
+// <vendor>`), so that root is the working directory; a tool that runs another in a process of its own (run-tool.ts)
+// names it before loading the tool (setPacksRoot), with the kernel checkout a walk must measure (setKernelCheckout).
+// Each tool reads both once, when it loads.
 import { join } from 'node:path';
 let packs = process.cwd();
 let kernel;

package/dist/src/tools/score-pack.js

@@ -3,7 +3,7 @@
 // life per pack is walked through the pack's own fetch on the in-memory World, and the report says:
 //   - the life: whether a judge's plausible verdict names its current content (a verdict its author wrote is not one);
 //   - correctness: every check on every step (status, expectations, captures, SHAPE, the beats) and the life
-//     answering byte for byte the same on a second fresh World;
+//     answering the same on a second fresh World under its declared engine outputs;
 //   - coverage: the hand-written code the life and the vendor's published examples run and the declared state logic
 //     they reach (life-coverage.ts), with what they never reach;
 //   - the vendor's published examples: replayed and judged (vendor-examples.ts);
@@ -12,8 +12,7 @@
 // This is source-journey evidence, not installed readiness or pack completion. pack-done owns completion and consumes
 // this report alongside the exact artifact's installed customer assessment in the one final run.
 //
-// Usage: twin-standard walk <vendor> [--write] [--report <path>]   (from the pack repository's root; twin-world's
-//        bun scripts/score-pack.ts <vendor> runs the same)
+// Usage: twin-standard walk <vendor> [--write] [--report <path>]   (from the pack repository's root)
 //   --write keeps journeys/score.json and journeys/coverage.json; --report writes the report and what it lacks for done
 //   to <path> as JSON and changes nothing in the checkout
 import { parseExactJson } from '@volter/world-core/exact-json';
@@ -26,6 +25,7 @@ import { dirname, join, sep } from 'node:path';
 import { inMemoryWorld, walk, withPinnedWorldDraws, usePacks } from "../walk/behavior-journey.js";
 import { expandFills, waitMs } from "../walk/journey-kit.js";
 import { vendorFetch, vendorStream } from "../walk/vendor-fetch.js";
+import { compareReplays } from "../walk/replay.js";
 import { existenceProbe } from "../walk/journey-kit.js";
 import { kernelCheckout, packsRoot, toolPath } from "./packs-root.js";
 const PACKS = packsRoot();
@@ -85,7 +85,7 @@ await walk(life, world.root(), failures, { beats: true });
 const answers = async () => {
     const seen = [];
     // the World's own draws (its seed, its keys) are the same in both: two Worlds differ only by what is beyond them (R9)
-    await withPinnedWorldDraws(() => walk(life, world.root(), [], { beats: false, hooks: { after: (step, p, a) => seen.push(`${step.name ?? ''}\u0000${p} ${a.status} ${JSON.stringify(a.body)}`) } }));
+    await withPinnedWorldDraws(() => walk(life, world.root(), failures, { beats: false, hooks: { after: (step, path, answer) => seen.push({ name: step.name ?? '', path, status: answer.status, body: answer.body, ...(answer.sql ? { sql: answer.sql } : {}), ...(answer.connection ? { connection: answer.connection } : {}) }) } }));
     return seen;
 };
 const [first, second] = [await answers(), await answers()];
@@ -184,9 +184,9 @@ const flags = [];
         }
     }
 }
-const differs = first.findIndex((line, i) => line !== second[i]);
-if (differs >= 0 || first.length !== second.length)
-    failures.push({ step: '(whole life)', beat: 'REPLAYABLE', detail: `a second fresh World answered differently at "${(first[differs] ?? second[differs] ?? first.at(-1) ?? '').split('\u0000')[0]}" (the ${differs + 1}th answered step; waits are not counted)` });
+const replayComparison = compareReplays(first, second);
+for (const detail of replayComparison.diagnostics)
+    failures.push({ step: '(whole life)', beat: 'REPLAYABLE', detail });
 // ── breadth ──────────────────────────────────────────────────────────────────────────────────
 const factory = await vendorFetch(PACKS, vendor);
 const fetch = factory?.(world.root());