@am_shork/attest 0.7.4 → 0.8.0

package/dist/core/registry-issues.js

@@ -0,0 +1,26 @@
+// The shape of a registry schema failure, and the one rendering of it
+// (design §5.1, §10).
+//
+// Separate from registry.ts because `./define` maps to that whole module, so
+// everything it exports is a public contract. What has to be public here is the
+// element type of `RegistryValidationError.issues`; the formatter does not, and
+// both of its callers are internal.
+/**
+ * The message `RegistryValidationError` carries, available without one.
+ *
+ * Three sites report `registry-invalid` — the throwing path in
+ * `defineRequirements`, and the two readers in `locate.ts` and
+ * `static-registry.ts` that report it without throwing — and their messages
+ * have to be identical rather than merely similar. Sharing this function is
+ * what makes that structural rather than a coincidence maintained by hand, so
+ * a new site formats through here and does not grow a fourth spelling.
+ */
+export function registryValidationMessage(issues) {
+    // `.map(String)` and not a bare `.join('.')`: under `PropertyKey[]` a segment
+    // can be a symbol, and `join` throws rather than converting one.
+    const fields = issues
+        .map((i) => `  - ${i.path.map(String).join('.') || '(root)'}: ${i.message}`)
+        .join('\n');
+    return `Invalid requirement registry:\n${fields}`;
+}
+//# sourceMappingURL=registry-issues.js.map

package/dist/core/registry.d.ts

@@ -1,10 +1,18 @@
-import { z } from 'zod';
 import { type RegistryInput, type RequirementInput } from './schema.js';
+import { type RegistryValidationIssue } from './registry-issues.js';
 import type { Registry, Requirement } from './types.js';
-/** Thrown when a registry fails structural validation (design §5.1). */
+export type { RegistryValidationIssue } from './registry-issues.js';
+/**
+ * Thrown when a registry fails structural validation (design §5.1).
+ *
+ * `issues` is typed as this project's own {@link RegistryValidationIssue} and
+ * not the validator's, because this class is reached through the `./define`
+ * subpath and the field is therefore a public contract — the same boundary
+ * `Issue.message` holds, with the difference that `Issue` was designed with it.
+ */
 export declare class RegistryValidationError extends Error {
-    readonly issues: z.ZodIssue[];
-    constructor(issues: z.ZodIssue[]);
+    readonly issues: RegistryValidationIssue[];
+    constructor(issues: RegistryValidationIssue[]);
 }
 /**
  * A `const` type parameter infers an array literal as a tuple, and would infer
@@ -139,5 +147,4 @@ export declare function delta<const T extends RegistryDelta>(d: T): DefinedDelta
  * caller wrote is still the literal they hold.
  */
 export declare function withProposedRequirements<T extends RegistryDelta>(d: T): T;
-export {};
 //# sourceMappingURL=registry.d.ts.map

package/dist/core/registry.js

@@ -1,22 +1,24 @@
 // Requirement registry authoring API (design §2, §5.1, §7).
 // defineRequirements validates against RegistrySchema and applies defaults;
 // delta() declares a change delta, applied by applyDelta (see apply.ts).
-import { z } from 'zod';
 import { RegistrySchema, } from './schema.js';
-/** Thrown when a registry fails structural validation (design §5.1). */
+import { registryValidationMessage, } from './registry-issues.js';
+/**
+ * Thrown when a registry fails structural validation (design §5.1).
+ *
+ * `issues` is typed as this project's own {@link RegistryValidationIssue} and
+ * not the validator's, because this class is reached through the `./define`
+ * subpath and the field is therefore a public contract — the same boundary
+ * `Issue.message` holds, with the difference that `Issue` was designed with it.
+ */
 export class RegistryValidationError extends Error {
     issues;
     constructor(issues) {
-        super(`Invalid requirement registry:\n${formatIssues(issues)}`);
+        super(registryValidationMessage(issues));
         this.issues = issues;
         this.name = 'RegistryValidationError';
     }
 }
-function formatIssues(issues) {
-    return issues
-        .map((i) => `  - ${i.path.join('.') || '(root)'}: ${i.message}`)
-        .join('\n');
-}
 /**
  * Declare a requirement registry. Validates structure against RegistrySchema
  * (SHALL/MUST keyword, non-empty rationale, well-formed IDs, scalar params) and

package/dist/core/runner.js

@@ -70,12 +70,19 @@ export async function runAndCollect(options = {}) {
         const runtimeCoverage = new Map();
         const outcomes = new Map();
         // Reconstruct coverage from the task tree (not an in-process singleton).
-        const walk = (task) => {
+        //
+        // `file` is threaded down from the file task rather than read off the suite,
+        // because it is the only level that carries a path — and it is what keeps
+        // two spec files declaring the same scenario name under one `requirement()`
+        // from collapsing into a single entry that either of them could satisfy.
+        const walk = (task, file) => {
             if (task.type === 'suite') {
                 const id = requirementIdOf(task.name);
                 if (id !== undefined) {
-                    const set = runtimeCoverage.get(id) ?? new Set();
-                    const byName = outcomes.get(id) ?? new Map();
+                    const byFile = runtimeCoverage.get(id) ?? new Map();
+                    const outcomesByFile = outcomes.get(id) ?? new Map();
+                    const set = byFile.get(file) ?? new Set();
+                    const byName = outcomesByFile.get(file) ?? new Map();
                     for (const c of scenariosUnder(task)) {
                         // A scenario counts as covered only if it actually executed —
                         // skipped/todo scenarios have no run result (enables §8's
@@ -87,12 +94,14 @@ export async function runAndCollect(options = {}) {
                         set.add(c.name);
                         byName.set(c.name, outcome);
                     }
-                    runtimeCoverage.set(id, set);
-                    outcomes.set(id, byName);
+                    byFile.set(file, set);
+                    outcomesByFile.set(file, byName);
+                    runtimeCoverage.set(id, byFile);
+                    outcomes.set(id, outcomesByFile);
                 }
             }
             for (const c of task.tasks ?? [])
-                walk(c);
+                walk(c, file);
         };
         // Assigned, never cast. `TaskLike` is the narrow view this walk needs, and
         // Vitest's `File` satisfies it structurally — so the compiler is the thing
@@ -101,12 +110,15 @@ export async function runAndCollect(options = {}) {
         // exactly the change that would silently empty the runtime coverage.
         const unloadedFiles = [];
         for (const file of vitest.state.getFiles()) {
-            walk(file);
             // Relative and POSIX for the reason everything derived from the root is
             // (`paths.ts`): this becomes an `Issue.file`, which a `--json` consumer
-            // diffs across two CI runs that may not share an operating system.
+            // diffs across two CI runs that may not share an operating system — and,
+            // since the coverage maps are keyed by it, a comparison key against a plan
+            // built the same way.
+            const relative = relativePath(options.root ?? process.cwd(), file.filepath);
+            walk(file, relative);
             if (failedToLoad(file)) {
-                unloadedFiles.push(relativePath(options.root ?? process.cwd(), file.filepath));
+                unloadedFiles.push(relative);
             }
         }
         unloadedFiles.sort(byCodeUnit);

package/dist/core/schema.d.ts

@@ -1,27 +1,17 @@
 import { z } from 'zod';
 /** A scalar param value. `null` is included: it is how an author writes "empty". */
-declare const scalar: z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
+declare const scalar: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>;
 /** Any JSON value — what a param may be. */
 export type ParamValue = z.infer<typeof scalar> | ParamValue[] | {
     [key: string]: ParamValue;
 };
 /** A single behavioural contract (design §2). */
 export declare const RequirementSchema: z.ZodObject<{
-    statement: z.ZodEffects<z.ZodString, string, string>;
+    statement: z.ZodString;
     rationale: z.ZodString;
-    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<ParamValue, z.ZodTypeDef, ParamValue>>>;
-    outOfScope: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    params: Record<string, ParamValue>;
-    statement: string;
-    rationale: string;
-    outOfScope: string[];
-}, {
-    statement: string;
-    rationale: string;
-    params?: Record<string, ParamValue> | undefined;
-    outOfScope?: string[] | undefined;
-}>;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<ParamValue, unknown, z.core.$ZodTypeInternals<ParamValue, unknown>>>>;
+    outOfScope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 /**
  * The id grammar, on its own.
  *
@@ -34,23 +24,38 @@ export declare const RequirementSchema: z.ZodObject<{
  * two grammars as soon as one of them is edited.
  */
 export declare const RequirementIdSchema: z.ZodString;
-/** The requirement registry: stable ID -> requirement (design §2, §5.1). */
-export declare const RegistrySchema: z.ZodRecord<z.ZodString, z.ZodObject<{
-    statement: z.ZodEffects<z.ZodString, string, string>;
-    rationale: z.ZodString;
-    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<ParamValue, z.ZodTypeDef, ParamValue>>>;
-    outOfScope: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    params: Record<string, ParamValue>;
+/**
+ * The requirement registry: stable ID -> requirement (design §2, §5.1).
+ *
+ * Guarded by `isPlainObject` for the same reason `jsonObject` is, and it is the
+ * *evaluating* reader this protects: `{ '__proto__': { … } }` swaps the
+ * prototype rather than creating a key, so the registry a loader builds from
+ * that file comes from the prototype and not from anything the file declares.
+ * The static reader refuses such a source outright (`registry-not-static`), and
+ * the two readers agreeing is a security property (design §5.2), not a
+ * convenience — so the schema has to refuse it rather than enumerate it.
+ *
+ * The guard is written over `RegistryRecord`'s input so `z.input` still
+ * describes the authoring shape: `defineRequirements` constrains its `const`
+ * type parameter to `RegistryInput`, and a guard typed as a bare record would
+ * erase every literal that constraint exists to capture.
+ */
+export declare const RegistrySchema: z.ZodPipe<z.ZodCustom<Record<string, {
     statement: string;
     rationale: string;
-    outOfScope: string[];
-}, {
+    params?: Record<string, unknown> | undefined;
+    outOfScope?: string[] | undefined;
+}>, Record<string, {
     statement: string;
     rationale: string;
-    params?: Record<string, ParamValue> | undefined;
+    params?: Record<string, unknown> | undefined;
     outOfScope?: string[] | undefined;
-}>>;
+}>>, z.ZodRecord<z.ZodString, z.ZodObject<{
+    statement: z.ZodString;
+    rationale: z.ZodString;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<ParamValue, unknown, z.core.$ZodTypeInternals<ParamValue, unknown>>>>;
+    outOfScope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>>;
 /** Parsed (output) shapes — defaults applied. */
 export type Requirement = z.infer<typeof RequirementSchema>;
 export type Registry = z.infer<typeof RegistrySchema>;

package/dist/core/schema.js

@@ -35,9 +35,7 @@ const jsonObject = z
     .custom(isPlainObject)
     .pipe(z.record(z.string(), z.lazy(() => paramValue)));
 const paramValue = z.lazy(() => z.union([scalar, z.array(paramValue), jsonObject], {
-    errorMap: () => ({
-        message: 'expected JSON data (no functions, dates, or class instances)',
-    }),
+    error: 'expected JSON data (no functions, dates, or class instances)',
 }));
 /** A single behavioural contract (design §2). */
 export const RequirementSchema = z.object({
@@ -80,6 +78,36 @@ export const RequirementSchema = z.object({
 export const RequirementIdSchema = z
     .string()
     .regex(/^[A-Z]+-\d+$/, 'id must look like AUTH-3');
-/** The requirement registry: stable ID -> requirement (design §2, §5.1). */
-export const RegistrySchema = z.record(RequirementIdSchema, RequirementSchema);
+/**
+ * The registry's own record, before the plain-object guard below.
+ *
+ * `error` is carried explicitly because a record reports a key failure as
+ * "Invalid key in record" and does not surface the key schema's own message —
+ * and a mistyped id is the commonest way to fail this schema, so the grammar is
+ * the one thing the author needs to be told.
+ */
+const RegistryRecord = z.record(RequirementIdSchema, RequirementSchema, {
+    error: 'id must look like AUTH-3',
+});
+/**
+ * The requirement registry: stable ID -> requirement (design §2, §5.1).
+ *
+ * Guarded by `isPlainObject` for the same reason `jsonObject` is, and it is the
+ * *evaluating* reader this protects: `{ '__proto__': { … } }` swaps the
+ * prototype rather than creating a key, so the registry a loader builds from
+ * that file comes from the prototype and not from anything the file declares.
+ * The static reader refuses such a source outright (`registry-not-static`), and
+ * the two readers agreeing is a security property (design §5.2), not a
+ * convenience — so the schema has to refuse it rather than enumerate it.
+ *
+ * The guard is written over `RegistryRecord`'s input so `z.input` still
+ * describes the authoring shape: `defineRequirements` constrains its `const`
+ * type parameter to `RegistryInput`, and a guard typed as a bare record would
+ * erase every literal that constraint exists to capture.
+ */
+export const RegistrySchema = z
+    .custom(isPlainObject, {
+    error: 'a registry must be an object literal',
+})
+    .pipe(RegistryRecord);
 //# sourceMappingURL=schema.js.map

package/dist/core/skill.js

@@ -102,6 +102,19 @@ promises is a two-stage workflow, and the stages are separate on purpose.
   rule forbids, and the distinction is the whole of it — that rule is about the
   **expectation** the system is measured against; this pin asserts what the
   **intent** is.
+- **Prefer a quantifier a scenario can iterate.** A statement that says *every*,
+  *all* or *any* has a finite set of scenarios under it and nothing holding the
+  two together — the id is covered, \`check\` is green, and whether those
+  scenarios span what the sentence claims is the part no gate looks at. What
+  decides the risk is *what* the quantifier ranges over. Over the inputs one
+  place processes, representative inputs settle it. Over a list the code itself
+  enumerates, a scenario looping that same list covers a new member by
+  construction — **this is the shape to write**, and when that list lives in
+  \`params\` rather than in the code, the pin above is what keeps it honest, since
+  an author can shorten it. Over *places in the implementation*, each needing its
+  own hand-written scenario, a new place is a new obligation and nothing
+  enumerates them: that is the one that silently stops being true. When you cannot avoid it, name the places in the statement instead
+  of quantifying over them, so a reader can count what is missing.
 
 ## Rules the engine enforces
 

package/dist/core/splice.js

@@ -25,23 +25,26 @@ import { registryInsertionPoint } from './static-registry.js';
 import { toPosixPath } from './paths.js';
 import { byCodeUnit, sortDeep } from './order.js';
 /**
- * A TypeScript single-quoted string literal holding exactly `value`.
+ * The *inside* of a TypeScript string literal quoted with `quote`, holding
+ * exactly `value`.
  *
- * Hand-escaped rather than `JSON.stringify`, for one reason that is not style:
- * the registries this writes into are single-quoted throughout, and a merged
- * entry that arrives double-quoted is a diff hunk about quotation marks in the
- * middle of a merge the reviewer is trying to read. Control characters go out as
- * `\uXXXX` rather than raw, so a statement someone pasted a newline into cannot
- * produce a file that no longer parses.
+ * Split out from `tsString` because the other site that writes into a string
+ * literal — `repointImport` — writes between quotes that are already in the
+ * file, whose character is the file's choice and not this module's. Escaping
+ * has to answer to that character: `'` needs no escape inside `"…"`, and
+ * escaping it there would be a wrong byte rather than a safe one.
+ *
+ * Control characters go out as `\uXXXX` rather than raw, so a value someone
+ * pasted a newline into cannot produce a file that no longer parses.
  */
-function tsString(value) {
-    let out = "'";
+function tsStringBody(value, quote) {
+    let out = '';
     for (const ch of value) {
         const code = ch.codePointAt(0) ?? 0;
         if (ch === '\\')
             out += '\\\\';
-        else if (ch === "'")
-            out += "\\'";
+        else if (ch === quote)
+            out += `\\${ch}`;
         else if (ch === '\n')
             out += '\\n';
         else if (ch === '\r')
@@ -53,7 +56,18 @@ function tsString(value) {
         else
             out += ch;
     }
-    return `${out}'`;
+    return out;
+}
+/**
+ * A TypeScript single-quoted string literal holding exactly `value`.
+ *
+ * Hand-escaped rather than `JSON.stringify`, for one reason that is not style:
+ * the registries this writes into are single-quoted throughout, and a merged
+ * entry that arrives double-quoted is a diff hunk about quotation marks in the
+ * middle of a merge the reviewer is trying to read.
+ */
+function tsString(value) {
+    return `'${tsStringBody(value, "'")}'`;
 }
 /**
  * Thrown when a value reaches the emitter that cannot be written as source
@@ -205,10 +219,27 @@ export function repointImport(file, source, from, to) {
         // A bare `x.reqs.js` is a package specifier, not a sibling file.
         if (!target.startsWith('.'))
             target = `./${target}`;
-        // Inside the quotes: the file's own quote style is left exactly as it was.
-        edits.push({ start: spec.getStart(sf) + 1, end: spec.getEnd() - 1, text: target });
+        // Inside the quotes, so the file's own quote style is left exactly as it
+        // was — which is why the escaping is told which quote it writes between.
+        // `to` is the registry file `--apply` chose, making this the one value in
+        // the emitter the checked repository names, and a name carrying that quote
+        // would otherwise close the literal and put what follows into a committed
+        // `*.spec.ts` as code (§7). Escaped rather than refused, unlike the
+        // `__proto__` key above: a specifier is a string, and every string has a
+        // correct spelling as one.
+        const quote = source[spec.getStart(sf)];
+        edits.push({
+            start: spec.getStart(sf) + 1,
+            end: spec.getEnd() - 1,
+            text: tsStringBody(target, quote),
+        });
     }
     let out = source;
+    // Back to front, which is what makes a correction term unnecessary: an edit
+    // cannot move an offset that lies before it, so every `start`/`end` above
+    // stays valid as the string is rewritten under them. Applying these in source
+    // order works only by carrying a running delta and adding it to each
+    // subsequent pair — the same result, one more thing to get wrong.
     for (const edit of edits.reverse()) {
         out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
     }

package/dist/core/static-registry.js

@@ -21,7 +21,8 @@
 // to "is this a literal", and those two answers must not be able to disagree.
 import ts from 'typescript';
 import { parseSource } from './compiler.js';
-import { RegistryValidationError, withProposedRequirements } from './registry.js';
+import { withProposedRequirements } from './registry.js';
+import { registryValidationMessage } from './registry-issues.js';
 import { RegistrySchema } from './schema.js';
 /** The authoring function a registry file must default-export the result of. */
 const DEFINE = 'defineRequirements';
@@ -128,12 +129,12 @@ export function readRegistrySource(file, source) {
     const result = RegistrySchema.safeParse(extracted.value);
     if (!result.success) {
         // defineRequirements throws RegistryValidationError and loadRegistry wraps
-        // it; going through the same error keeps the message identical rather than
-        // merely similar.
+        // it; sharing one formatter keeps the message identical rather than merely
+        // similar.
         return {
             ok: false,
             code: 'registry-invalid',
-            message: `Failed to load registry: ${new RegistryValidationError(result.error.issues).message}`,
+            message: `Failed to load registry: ${registryValidationMessage(result.error.issues)}`,
         };
     }
     return { ok: true, registry: result.data };

package/dist/core/status.js

@@ -49,7 +49,7 @@ export function statusRows(addedIds, plan, firstRun) {
             name: s.name,
             file: s.file,
             line: s.line,
-            firstRun: recordedOutcome(firstRun, reqId, s.name) ?? null,
+            firstRun: recordedOutcome(firstRun, { reqId, file: s.file, name: s.name }) ?? null,
         }));
         return { reqId, state: obligationState(reqId, scenarios, firstRun), scenarios };
     });
@@ -59,7 +59,7 @@ function obligationState(reqId, scenarios, firstRun) {
         return 'no-scenario';
     // Every scenario, not any: the gate raises never-red per scenario, so one
     // proven scenario beside an unproven one is still a blocked change.
-    return scenarios.every((s) => hasRecordedRed(firstRun, reqId, s.name))
+    return scenarios.every((s) => hasRecordedRed(firstRun, { reqId, file: s.file, name: s.name }))
         ? 'proven'
         : 'unproven';
 }

package/dist/core/terminal.js

@@ -12,8 +12,11 @@
 // write to the terminal of whoever is checking it. On a fork MR the author is
 // not the reviewer, and the payload is a scenario name or an exception: erase
 // the lines above, repaint a red verdict green, rewrite the window title. The
-// `--json` path was never exposed — `JSON.stringify` escapes every C0
-// character — which is precisely why this has to hold on the side people read.
+// `--json` path was recorded here as never exposed, on the grounds that
+// `JSON.stringify` escapes every C0 character — true, and narrower than the
+// class below, which also holds DEL and C1. `cli/json.ts` now applies the same
+// rule at the point that document is serialised (ATX-74); this still has to
+// hold independently, because a stream has no such point.
 //
 // **In `core/` rather than in the CLI**, though the CLI is its main caller: the
 // loader has to sanitise Vite's log output for the same reason and cannot

package/dist/core/types.d.ts

@@ -1,11 +1,22 @@
 export type { Requirement, Registry, ParamValue } from './schema.js';
 export type { IssueCode } from './docs.js';
 import type { IssueCode } from './docs.js';
-/** A scenario extracted statically from a spec file (design §5.2). */
-export interface ParsedScenario {
+/**
+ * What identifies one scenario, everywhere the engine compares one (design §5.4).
+ *
+ * All three, and as a bundle rather than three positional strings: the file was
+ * missing from the key that `declared-not-run` and the first-run record are
+ * decided by, and adding it as a fourth `string` argument beside `reqId` and
+ * `name` would have made two adjacent parameters of one type that a caller can
+ * silently transpose. The compiler cannot catch that; a field name can.
+ */
+export interface ScenarioRef {
     reqId: string;
-    name: string;
     file: string;
+    name: string;
+}
+/** A scenario extracted statically from a spec file (design §5.2). */
+export interface ParsedScenario extends ScenarioRef {
     line: number;
 }
 /**
@@ -31,15 +42,33 @@ export type Outcome = 'pass' | 'fail';
 export interface RunResult {
     /** True when no test failed. */
     passed: boolean;
-    /** reqId -> set of scenario names that actually executed (from the task tree). */
-    runtimeCoverage: Map<string, Set<string>>;
     /**
-     * reqId -> scenario name -> how it ended. The same task-tree walk that fills
-     * `runtimeCoverage` already had to tell `pass` from `fail` to decide whether a
-     * scenario executed at all; this keeps that distinction instead of discarding
-     * it, which is what §6's mechanism 2 records.
+     * reqId -> spec file -> the scenario names that actually executed (from the
+     * task tree).
+     *
+     * **The file is part of the key, and its absence was a false green.** Keyed by
+     * `(reqId, name)` alone, two spec files declaring the same scenario name under
+     * the same `requirement()` are one entry, so whichever of them executed
+     * vouched for the other and `declared-not-run` stayed silent about a scenario
+     * that never ran — the one report this tool exists to refuse. The static plan
+     * carries `file` on every `ParsedScenario` and the task tree carries it on
+     * every file task, so only this map ever forgot it.
+     *
+     * Project-relative POSIX, like `unloadedFiles` and for the same reason: it is
+     * compared against a plan built that way (`paths.ts`).
+     */
+    runtimeCoverage: Map<string, Map<string, Set<string>>>;
+    /**
+     * reqId -> spec file -> scenario name -> how it ended. The same task-tree walk
+     * that fills `runtimeCoverage` already had to tell `pass` from `fail` to
+     * decide whether a scenario executed at all; this keeps that distinction
+     * instead of discarding it, which is what §6's mechanism 2 records.
+     *
+     * Keyed identically, and for the identical reason: the same collapse reaches
+     * `mergeRedRecord`, where a base scenario's recorded `fail` satisfied a
+     * same-named proposed scenario's first-red obligation.
      */
-    outcomes: Map<string, Map<string, Outcome>>;
+    outcomes: Map<string, Map<string, Map<string, Outcome>>>;
     /**
      * Spec files that failed to *load*, as project-relative POSIX paths.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@am_shork/attest",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "TDD-native spec framework: tests are the source of truth for verification, ID-bound requirements the source of truth for intent.",
   "type": "module",
   "engines": {
@@ -48,7 +48,7 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "typescript": "^5.5.0 || ^6.0.0",
-    "zod": "^3.23.0"
+    "zod": "^4.4.3"
   },
   "peerDependencies": {
     "vite": "^8.0.0",