eval-quality 0.1.0 → 0.2.0

package/dist/core/seal/derived-reference.js

@@ -83,22 +83,170 @@ function canonicalizeForDisplay(value) {
 function formatLiteral(literal) {
     return JSON.stringify(canonicalizeForDisplay(literal));
 }
-// Base rendering: `type-violating` always names the input malformed.
-// `any` and, at the 'generic' level, `literal` share the same generic wording
-// on purpose; the escalation ladder below tells them apart once two steps
-// would otherwise collide.
+// Base rendering, one arm per tagged form. `type-violating` always names the
+// input malformed. `any` and, at the 'generic' level, every other form share
+// the same generic wording on purpose; the escalation ladder below tells them
+// apart once two steps would otherwise collide.
+//
+// `captured` escalates to a real derived reference at the 'literal' rung: the
+// local phrase for the pointer's channel and tail, then the referenced step
+// rendered through `stepReferenceAtLevel`, which is the same phrase
+// `fullTargetPhrase` already prints for an evidence target. Naming the
+// referenced OPERATION alone was tried and dropped: two predecessors sharing
+// one operation and one body key then render identically, so two siblings
+// capturing from them collide at every rung and `renderStepReference` throws
+// out of `seal()` on a contract that compiles clean. Recursing into the
+// predecessor separates them by its own binding clause. Two predecessors that
+// are themselves irreducible still tie, and the throw there is correct: the
+// declared structure does not distinguish them, which is the same answer
+// `irreducibleCollisionPair` already gets. That throw is a bare `TypeError`
+// rather than a coded failure, which is a pre-existing gap this widens; the
+// deferred-work entry names hoisting the collision check to compile time.
+//
+// It does NOT call `renderStepReference`, so none of that function's
+// constraints apply: no direction-scoped sibling list is consulted, so AD-16's
+// scoping stays intact, and there is no tie to throw on. A step identifier
+// never appears, which is the property AD-16 actually requires.
+//
+// `rendering` holds the steps already on the render path, and a capture back
+// into one of them falls back to the level-independent phrase. A fixed depth
+// bound was tried and dropped: at depth one, a two-link chain whose every link
+// is genuinely distinguishable still collides, because only the immediate
+// predecessor's binding shows and that is the half the two siblings share.
+// Following the chain as far as it goes is what separates them, and the
+// on-path set is what makes that terminate. Each recursion adds one step id, so
+// the depth is bounded by the plan; `plan-exceeds-scripting-bound` bounds that
+// too. Same guard the score module uses for an `after` chain, for the same
+// reason: `binding-cycle` rejects a capture cycle at compile time, so this only
+// covers a plan driven straight into the renderer.
+//
+// A pointer whose step or operation the index cannot resolve falls back to the
+// 'kind' phrase. `seal()` runs after `compile`, which rejects such a pointer
+// under `unreachable-check-evidence`, so this is a fallback for a
+// directly-driven caller and adds no throw path.
+//
+// One thing a grep for step identifiers will find and should not be surprised
+// by: `localTargetPhrase` prints the pointer's tail, and a response-body key
+// the author happened to name the same as a step prints with it. That is the
+// author's own declared key rather than a plan identifier, and it is what every
+// ordinary evidence target has always printed.
+//
+// `principal` tops out at the declared name, which AD-18 keeps an opaque label
+// and is therefore safe on the brief.
+// One or more entries of a step's clause that capture from the same earlier
+// step, rendered together so that step's phrase is expanded once. Expanding it
+// per entry made the clause's size multiply down a capture chain: a step with k
+// entries pointing at its predecessor expanded that predecessor k times, and the
+// predecessor did the same to its own, so a sixteen-step chain with four keys a
+// link produced a phrase past V8's maximum string length. Grouping makes the
+// clause linear in keys and reads better besides.
+//
+// Grouping alone bounds one axis of three, and the size is their product. The
+// other two are the number of DISTINCT predecessors a step references, which
+// doubles per level on a complete capture DAG, and the length of one step's own
+// clause text, which nothing bounds: `formatLiteral` prints a `JsonValue` with
+// no length cap and a binding channel is a record with a minimum of one entry
+// and no maximum. Measured on a sixteen-step complete DAG that passes every
+// plan-side check, the multiplier is 8,192, so a single 65,536-character
+// literal on the seed step, or two hundred ordinary forty-character ones,
+// reaches `RangeError: Invalid string length`.
+//
+// `budget` is what bounds all three at once. Each expansion spends the
+// characters it produced, and once the budget is gone a capture renders as the
+// level-independent phrase it already had. Every `stepReferenceAtLevel` call
+// from `renderStepReference` starts a fresh budget, so one sibling's expansion
+// never degrades another's and the distinctness test stays order-independent.
+//
+// The budget is charged after an expansion rather than before, so the bound is
+// the budget plus whatever one step's own clause text costs; a step binding a
+// single 200,000-character literal renders about 204,000. That is the point of
+// charging late: an expansion cannot be priced before its nested expansions are
+// known, and stopping the NEXT one is what keeps the product finite. Measured
+// on the sixteen-step complete DAG that reached `RangeError` before: 36 KB with
+// a minimal seed, 75 KB with two hundred forty-character literals, 135 KB with
+// a 65,536-character one, and, with a one-million-character literal on every one
+// of its fourteen nodes, 1,000,564. All in single-digit milliseconds. That last
+// row is the one that pins the bound: one literal's worth of overshoot rather
+// than fourteen, which is why the exhaustion test sits in the render pass below
+// rather than where the slots are built.
+//
+// A budget alone would couple things that have nothing to do with each other:
+// growing a literal on a step neither sibling references can starve the
+// expansion that separates them, so an unrelated field decides whether a
+// contract seals. `renderStepReference`'s retry at the ceiling is what removes
+// that, and it fires only when a collision came of a suppressed expansion. What
+// remains is the honest case: siblings the declared structure does not
+// distinguish still throw the precondition `TypeError`, which is the
+// pre-existing failure mode `deferred-work.md` already carries.
+// The ordinary limit, then the ceiling a starved render retries at. No
+// realistic contract reaches the first; only one that would otherwise fail to
+// render at all pays for the second.
+const RENDER_BUDGET_LIMITS = [100_000, 4_000_000];
+const newBudget = (limit) => ({
+    remaining: limit,
+    spent: false,
+});
+const unexpandedGroup = (group) => `the ${joinWithAnd(group.entries.map(entryName))} you obtained earlier`;
+function renderCaptureGroup(group, level, index, rendering, budget) {
+    const names = joinWithAnd(group.entries.map(entryName));
+    const locals = joinWithAnd(group.targets.map(localTargetPhrase));
+    const step = index.stepOf(group.stepId);
+    const operation = step === undefined ? undefined : index.operationOf(step.operationId);
+    if (step === undefined || operation === undefined) {
+        return unexpandedGroup(group);
+    }
+    const source = stepReferenceAtLevel(step, operation, level, index, rendering, budget);
+    // Charged after the fact, so a nested expansion pays before its parent does
+    // and an inner blowup is what stops the outer one.
+    budget.remaining -= source.length;
+    return `the ${names} you obtained as ${locals} from ${source}`;
+}
+// Records that an expansion was suppressed, which is what `renderStepReference`
+// reads before deciding whether a collision is worth retrying at the ceiling.
+function exhausted(budget) {
+    if (budget.remaining > 0)
+        return false;
+    budget.spent = true;
+    return true;
+}
+// Whether this entry expands into a group, or renders as the level-independent
+// phrase on its own.
+function expandableCapture(entry, level, index, rendering, budget) {
+    if (level !== 'literal' || !('captured' in entry.value))
+        return null;
+    if (exhausted(budget))
+        return null;
+    const target = parseEvidenceTarget(entry.value.captured);
+    if (rendering.has(target.stepId))
+        return null;
+    const step = index.stepOf(target.stepId);
+    if (step === undefined)
+        return null;
+    return index.operationOf(step.operationId) === undefined ? null : target;
+}
+// Renders one entry on its own. Every captured entry that expands lands in a
+// group instead, so the arm here is the level-independent fallback.
 function renderBindingValue(entry, level) {
     const name = entryName(entry);
-    if (isTypeViolating(entry.value)) {
-        return `a malformed ${name} value`;
+    const { value } = entry;
+    if ('matcher' in value) {
+        return value.matcher === 'type-violating'
+            ? `a malformed ${name} value`
+            : `the supplied ${name}`;
     }
-    if (level === 'generic' || 'matcher' in entry.value) {
+    if (level === 'generic') {
         return `the supplied ${name}`;
     }
+    if ('principal' in value) {
+        return `the ${name} of the ${value.principal} account`;
+    }
+    if ('captured' in value) {
+        return `the ${name} you obtained earlier`;
+    }
     if (level === 'kind') {
         return `the stated ${name}`;
     }
-    return `the ${name} ${formatLiteral(entry.value.literal)}`;
+    return `the ${name} ${formatLiteral(value.literal)}`;
 }
 // Every declared binding key escalates together: narrowing to only the
 // discriminating key would make one step's shown detail depend on which
@@ -108,13 +256,49 @@ function renderBindingValue(entry, level) {
 //
 // When a type-violating binding is present, the clause names only that one:
 // it is the semantically salient binding, matching AD-16's worked example.
-function bindingClause(step, level) {
+function bindingClause(step, level, index, rendering, budget) {
     const entries = bindingEntries(step);
     if (entries.length === 0)
         return null;
     const malformed = entries.filter((entry) => isTypeViolating(entry.value));
     const chosen = malformed.length > 0 ? malformed : entries;
-    return `with ${joinWithAnd(chosen.map((entry) => renderBindingValue(entry, level)))}`;
+    // Each expandable capture joins the group for the step it references, held
+    // at the position that step was first referenced from, so the clause's order
+    // still comes from `bindingEntries`'s sort rather than from a map's keys.
+    const slots = [];
+    const groups = new Map();
+    for (const entry of chosen) {
+        const target = expandableCapture(entry, level, index, rendering, budget);
+        if (target === null) {
+            slots.push(entry);
+            continue;
+        }
+        const existing = groups.get(target.stepId);
+        if (existing !== undefined) {
+            existing.entries.push(entry);
+            existing.targets.push(target);
+            continue;
+        }
+        const group = {
+            stepId: target.stepId,
+            entries: [entry],
+            targets: [target],
+        };
+        groups.set(target.stepId, group);
+        slots.push(group);
+    }
+    // Tested here rather than while the slots are built: a clause commits to its
+    // groups in one pass and renders them in the next, so an entry-time test let
+    // every group of an already-committed clause render in full, and the bound
+    // grew by the group count rather than by one expansion.
+    const phrases = slots.map((slot) => {
+        if (!('stepId' in slot))
+            return renderBindingValue(slot, level);
+        return exhausted(budget)
+            ? unexpandedGroup(slot)
+            : renderCaptureGroup(slot, level, index, rendering, budget);
+    });
+    return `with ${joinWithAnd(phrases)}`;
 }
 // Parenthesized rather than comma-joined onto the operation reference: a
 // step reference can itself be joined with other phrases at a higher level
@@ -122,9 +306,11 @@ function bindingClause(step, level) {
 // already carries its own internal ", and" separators. A second comma layer
 // on top would produce indistinguishable comma soup once two or more
 // phrases are joined.
-function stepReferenceAtLevel(step, operation, level) {
+function stepReferenceAtLevel(step, operation, level, index, rendering = new Set(), budget = newBudget(RENDER_BUDGET_LIMITS[0])) {
     const base = operationReference(operation);
-    const clause = bindingClause(step, level);
+    // The step being rendered joins the path before its own clause is built, so
+    // a self-capture falls back on the first hop.
+    const clause = bindingClause(step, level, index, new Set([...rendering, step.stepId]), budget);
     return clause === null ? base : `${base} (${clause})`;
 }
 /**
@@ -140,12 +326,34 @@ function stepReferenceAtLevel(step, operation, level) {
  * duplicate `stepId` check if two siblings still collide after full
  * escalation.
  */
-export function renderStepReference(step, operation, siblings) {
-    for (const level of ESCALATION_LEVELS) {
-        const phrases = siblings.map((sibling) => stepReferenceAtLevel(sibling, operation, level));
-        if (new Set(phrases).size === phrases.length) {
-            return stepReferenceAtLevel(step, operation, level);
+export function renderStepReference(step, operation, siblings, index) {
+    // Two passes over the ladder, at the ordinary budget and then at the ceiling.
+    // The retry fires only when every level collided AND some render had an
+    // expansion suppressed, which is what breaks the coupling the budget would
+    // otherwise introduce: without it, growing a literal on a step unrelated to
+    // either sibling can starve the expansion that separates them and make an
+    // otherwise-sealable contract throw. A collision with nothing suppressed is
+    // the declared structure's own tie, and a larger budget renders the same
+    // text, so that case leaves the loop rather than paying for a second pass.
+    for (const limit of RENDER_BUDGET_LIMITS) {
+        let starved = false;
+        for (const level of ESCALATION_LEVELS) {
+            const rendered = siblings.map((sibling) => {
+                const budget = newBudget(limit);
+                return {
+                    phrase: stepReferenceAtLevel(sibling, operation, level, index, new Set(), budget),
+                    spent: budget.spent,
+                };
+            });
+            const phrases = rendered.map((entry) => entry.phrase);
+            if (new Set(phrases).size === phrases.length) {
+                return stepReferenceAtLevel(step, operation, level, index, new Set(), newBudget(limit));
+            }
+            if (rendered.some((entry) => entry.spent))
+                starved = true;
         }
+        if (!starved)
+            break;
     }
     throw new TypeError(`two or more steps invoking operation "${operation.operationId}" that this direction references render to the same derived reference even fully escalated; the declared structure does not distinguish them`);
 }
@@ -216,9 +424,9 @@ function localTargetPhrase(target) {
                 : 'the standard error you obtained';
     }
 }
-function fullTargetPhrase(resolved, siblingsOf) {
+function fullTargetPhrase(resolved, siblingsOf, index) {
     const local = localTargetPhrase(resolved.target);
-    const stepRef = renderStepReference(resolved.step, resolved.operation, siblingsOf(resolved.operation.operationId));
+    const stepRef = renderStepReference(resolved.step, resolved.operation, siblingsOf(resolved.operation.operationId), index);
     const preposition = resolved.target.channel === 'call-inputs' ? 'to' : 'from';
     return `${local} ${preposition} ${stepRef}`;
 }
@@ -236,7 +444,7 @@ function channelSignature(target) {
 // never degenerates to argument order, since colliding same-operation
 // siblings already throw in `renderStepReference`, and different operations
 // always humanize to different names.
-function sentFirstOrder(a, b, siblingsOf) {
+function sentFirstOrder(a, b, siblingsOf, index) {
     const rank = (r) => r.target.channel === 'call-inputs' ? 0 : 1;
     const rankA = rank(a);
     const rankB = rank(b);
@@ -246,8 +454,8 @@ function sentFirstOrder(a, b, siblingsOf) {
     const signatureB = channelSignature(b.target);
     if (signatureA !== signatureB)
         return signatureA < signatureB ? [a, b] : [b, a];
-    const referenceA = renderStepReference(a.step, a.operation, siblingsOf(a.operation.operationId));
-    const referenceB = renderStepReference(b.step, b.operation, siblingsOf(b.operation.operationId));
+    const referenceA = renderStepReference(a.step, a.operation, siblingsOf(a.operation.operationId), index);
+    const referenceB = renderStepReference(b.step, b.operation, siblingsOf(b.operation.operationId), index);
     return referenceA <= referenceB ? [a, b] : [b, a];
 }
 // Two evidence targets whose steps are declared in an `after` relationship
@@ -340,19 +548,19 @@ function groupResolvedTargets(resolved) {
     }
     return groups;
 }
-function renderPhraseGroup(group, siblingsOf) {
+function renderPhraseGroup(group, siblingsOf, index) {
     if (group.kind === 'temporal-pair') {
-        const [first, second] = sentFirstOrder(group.a, group.b, siblingsOf);
-        return `${fullTargetPhrase(first, siblingsOf)}, compared with ${fullTargetPhrase(second, siblingsOf)}`;
+        const [first, second] = sentFirstOrder(group.a, group.b, siblingsOf, index);
+        return `${fullTargetPhrase(first, siblingsOf, index)}, compared with ${fullTargetPhrase(second, siblingsOf, index)}`;
     }
     const first = group.resolved[0];
     if (first === undefined) {
         throw new TypeError('evidence-target group is empty');
     }
     if (group.resolved.length === 1) {
-        return fullTargetPhrase(first, siblingsOf);
+        return fullTargetPhrase(first, siblingsOf, index);
     }
-    const stepRef = renderStepReference(first.step, first.operation, siblingsOf(first.operation.operationId));
+    const stepRef = renderStepReference(first.step, first.operation, siblingsOf(first.operation.operationId), index);
     // Sorted, so a same-step group's field order is permutation-invariant like
     // the top-level join below; in declaration order, permuting
     // `evidenceTargets` would change which field is named first here.
@@ -378,6 +586,6 @@ export function renderEvidenceReferences(pointers, index) {
     const siblings = siblingsByOperation(resolved);
     const siblingsOf = (operationId) => siblings.get(operationId) ?? [];
     const groups = groupResolvedTargets(resolved);
-    const phrases = groups.map((group) => renderPhraseGroup(group, siblingsOf));
+    const phrases = groups.map((group) => renderPhraseGroup(group, siblingsOf, index));
     return joinWithAnd([...phrases].sort());
 }

package/dist/core/seal/seal.js

@@ -75,8 +75,10 @@ export function seal(contract) {
         // and stateless with no "prior brief" argument (AD-12), so the only
         // honest artifact is a lineage root: `parentDigest` null,
         // `revisionCount` 0, independent of the contract's own lineage.
-        // `schemaVersion` is the brief schema's current version.
-        schemaVersion: 1,
+        // `schemaVersion` is the brief schema's current version; 2 since owed
+        // item 3 added `principals` as a required field, which AD-11 counts as
+        // a breaking change.
+        schemaVersion: 2,
         parentDigest: null,
         revisionCount: 0,
         // A plain digest of the literal input: two differently-ordered
@@ -98,8 +100,11 @@ export function seal(contract) {
         // Copied rather than aliased, for the same reason as `behaviors` above.
         budgets: { ...contract.budgets },
         // Sorted lexicographically; sort-key duplicates are impossible here
-        // since equal strings are interchangeable, so no duplicate guard.
+        // since equal strings are interchangeable, so no duplicate guard. The
+        // principal names are sorted the same way rather than through
+        // `sortedByKey`, for the same reason: there is no key to guard.
         safetyLimits: [...contract.safetyLimits].sort(),
+        principals: Object.keys(contract.testData.principals ?? {}).sort(),
         probeStepBound: contract.probeStepBound,
     };
     // The parse returns Zod's own deep clone, so the freeze lands on the

package/dist/core/stage-contracts.d.ts

@@ -1,7 +1,9 @@
 /**
  * AD-34's stage-shape vocabulary. Two conformance types pin the exact shapes
- * of `compile` and `seal`; two generic types record the conditional
- * plan/reduce pair, which `preflight` implements.
+ * of `compile` and `seal`; four generic types cover the rest -- the
+ * conditional plan/reduce pair, which `preflight` implements, `IngestStage`,
+ * generic over the one product it owns, and `ScoreStage`, generic over both
+ * the trial set's element type and the product it owns.
  *
  * AD-24's six-stage input/output/owner/lineage table lives in
  * `core/lineage/stage-table.ts`. This file holds the stage *shapes* TypeScript
@@ -9,7 +11,15 @@
  * Neither imports the other.
  */
 import type { EvalContract } from './schemas/eval-contract.ts';
+import type { EvaluatorConfiguration } from './schemas/evaluator-configuration.ts';
+import type { EvidenceArtifact } from './schemas/evidence-artifact.ts';
+import type { IsolationManifest } from './schemas/isolation-manifest.ts';
+import type { PreflightVerdict } from './schemas/preflight-verdict.ts';
+import type { Probe } from './schemas/probe.ts';
+import type { ScoringPolicy } from './schemas/scoring-policy.ts';
 import type { SealedEvaluatorBrief } from './schemas/sealed-evaluator-brief.ts';
+import type { SealedRunRecord } from './schemas/sealed-run-record.ts';
+import type { WaiverStateValue } from './score/outcome.ts';
 /** The core compile stage's one runtime option. Core behavior never depends on an implicit configuration source (AD-1), so this is required; `application/compile.ts` is the only caller that supplies a default. */
 export type CompileOptions = {
     readonly strict: boolean;
@@ -28,3 +38,53 @@ export type SealStage = (contract: EvalContract) => SealedEvaluatorBrief;
 export type PlanStage<InputArtifact, RequestDescription> = (input: InputArtifact) => RequestDescription;
 /** A stage's pure reducing half: the plan plus the observations a port produced, reduced to the next artifact. */
 export type ReduceStage<RequestDescription, Observation, OutputArtifact> = (plan: RequestDescription, observations: Observation) => OutputArtifact;
+/**
+ * The ingest stage: the three artifacts AD-24's table declares as its inputs,
+ * validated into the internal product it owns. `core/ingest/ingest.ts`
+ * implements it.
+ *
+ * Three parameters and no fourth. AD-24 names `mode` as a value input and the
+ * sealed run record is where mode is read from, so restating it as an argument
+ * would create a disagreement case the design has no rule for.
+ *
+ * The manifest and the evaluator configuration both admit `null` because AD-16
+ * and AD-24 each make an absent artifact a condition this stage records rather
+ * than a shape a caller may not present. Their other shared clause, incomplete,
+ * is a schema rejection raised before this stage sees anything.
+ *
+ * Generic over the product for the same reason `ReduceStage` is: a concrete
+ * return type would import from `core/ingest/`, which imports this file back.
+ */
+export type IngestStage<Product> = (record: SealedRunRecord, manifest: IsolationManifest | null, configuration: EvaluatorConfiguration | null) => Product;
+/**
+ * The score stage: `STAGE_SIGNATURES.score`'s five declared artifact inputs,
+ * plus the two caller-supplied value parameters neither the trial set nor
+ * any declared input carries a source for (`score.ts`'s own Boundaries:
+ * `waiver` mirrors `outcome.ts:58-61`'s AD-5 expiry citation, and
+ * `evaluationFault` has no citation anywhere and is recorded as a genuine
+ * gap this parameter closes).
+ *
+ * Generic over both the trial set's element type and the owned product, for
+ * the same reason `IngestStage` is generic over its product: a concrete
+ * `ValidatedObservations` here would import `core/ingest/ingest.ts`, and a
+ * concrete `ScoredOutcomesAndVerdict` would import `core/score/score.ts`,
+ * either of which imports this file back to type itself.
+ */
+export type ScoreStage<Trials, Product> = (contract: EvalContract, trials: readonly Trials[], probe: Probe, preflightVerdict: PreflightVerdict, policy: ScoringPolicy, waiver: WaiverStateValue, evaluationFault: boolean) => Product;
+/**
+ * The emit stage: `STAGE_SIGNATURES.emit`'s one declared artifact input plus
+ * the three caller-attested AD-11 digests, minting the `EvidenceArtifact`
+ * neither `score` nor any earlier stage can construct alone. One generic
+ * parameter, not two: `EvidenceArtifact` is imported concretely here, the
+ * same way this file already imports several other concrete schema types
+ * above, so importing one more from the same directory opens no cycle;
+ * only the input (`ScoredOutcomesAndVerdict`, defined in
+ * `core/score/score.ts`) needs genericity, for the same import-cycle reason
+ * `IngestStage`/`ScoreStage` are generic over theirs.
+ *
+ * The three digests are plain `string` rather than a `Digest` type: no
+ * `core/schemas` module exports a bare TypeScript `Digest` type, only the
+ * Zod schema, and `EvidenceArtifact`'s own parse is where their AD-27 shape
+ * is actually enforced.
+ */
+export type EmitStage<Input> = (scored: Input, corpusDigest: string, fixtureDigest: string, evaluatorConfigurationDigest: string) => EvidenceArtifact;

package/dist/index.d.ts

@@ -12,4 +12,4 @@ export type { ScoringPolicy } from './core/schemas/scoring-policy.ts';
 export type { SealedEvaluatorBrief } from './core/schemas/sealed-evaluator-brief.ts';
 export type { SealedRunRecord } from './core/schemas/sealed-run-record.ts';
 export type { FixtureReset, ManifestationWitness, SensitivityWitness, SensitivityWitnessLeg, WitnessChannel, WitnessInputs, } from './core/schemas/sensitivity-witness.ts';
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.2.0";

package/dist/index.js

@@ -19,4 +19,4 @@
 // subpath, where AD-37 puts the conformance definition an adapter author
 // reads; the reference adapters stay at `eval-quality/adapters`.
 export * from './application/index.js';
-export const VERSION = '0.1.0';
+export const VERSION = '0.2.0';

package/dist/testing/index.d.ts

@@ -10,6 +10,8 @@
  * Type re-exports use `export type`; `biome.json` sets
  * `style.useExportType: "error"`.
  */
+export type { RuntimeFaultCode } from '../core/schemas/faults.ts';
+export { RUNTIME_FAULT_CODES, RuntimeFault } from '../core/schemas/faults.ts';
 export type { ClockReadRequest, ClockReadResponse, CorpusResolveRequest, CorpusResolveResponse, FileReadRequest, FileReadResponse, FileWriteRequest, FileWriteResponse, ProbeObservation, ProbeObservedBody, ProbeRequest, ProbeRequestBody, } from '../core/schemas/port-messages.ts';
 export type { ProbeTargetAuthorization, ProbeTargetPolicy, } from '../core/schemas/probe-policy.ts';
 export type { ClockPort } from '../ports/clock-port.ts';

package/dist/testing/index.js

@@ -10,6 +10,7 @@
  * Type re-exports use `export type`; `biome.json` sets
  * `style.useExportType: "error"`.
  */
+export { RUNTIME_FAULT_CODES, RuntimeFault } from '../core/schemas/faults.js';
 export { clockReadParsers } from '../ports/clock-port.js';
 export { corpusResolveParsers } from '../ports/corpus-port.js';
 export { probeParsers } from '../ports/environment-probe-port.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eval-quality",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Compile disciplined Behavioral Evaluation Contracts and score their ability to catch known defects.",
   "author": "Murat Ozcan",
   "license": "Apache-2.0",
@@ -87,11 +87,17 @@
     "check:ad28-registry": "node scripts/check-ad28-registry.ts",
     "generate:ad31-table": "node scripts/generate-ad31-table.ts",
     "check:ad31-table": "node scripts/check-ad31-table.ts",
+    "generate:ad33-table": "node scripts/generate-ad33-table.ts",
+    "check:ad33-table": "node scripts/check-ad33-table.ts",
+    "generate:ad21-table": "node scripts/generate-ad21-table.ts",
+    "check:ad21-table": "node scripts/check-ad21-table.ts",
     "check:layers": "node scripts/check-dependency-direction.ts",
     "check:lineage": "node scripts/check-lineage-ownership.ts",
     "check:boundary": "node scripts/check-package-boundary.ts",
     "generate:dev-corpus": "node scripts/generate-dev-corpus.ts",
     "check:corpus": "node scripts/check-dev-corpus.ts",
+    "generate:worked-example": "node scripts/generate-worked-example.ts",
+    "check:worked-example": "node scripts/check-worked-example.ts",
     "check:website-deps": "node scripts/audit-lockfile-age.mjs --lockfile website/package-lock.json && node scripts/check-licenses.mjs --lockfile website/package-lock.json",
     "check:shareable": "node scripts/check-shareable.mjs",
     "bench:digest": "node scripts/bench-digest.ts",
@@ -99,9 +105,12 @@
     "docs:build": "node tools/build-docs.mjs",
     "docs:preview": "npm --prefix website run preview",
     "docs:validate-links": "node tools/validate-doc-links.js",
+    "release:patch": "gh workflow run publish.yml --ref main -f bump=patch",
+    "release:minor": "gh workflow run publish.yml --ref main -f bump=minor",
+    "release:major": "gh workflow run publish.yml --ref main -f bump=major",
     "release:prepare": "node scripts/release-prepare.mjs",
-    "release:publish": "gh workflow run publish.yml --ref main",
-    "validate": "npm run build && npm run typecheck && npm run lint && npm run check:docs && npm run check:doc-invocations && npm run check:shareable && npm run lint:spine && npm run check:vectors && npm run check:schemas && npm run check:ad5-registry && npm run check:ad28-registry && npm run check:ad31-table && npm run check:layers && npm run check:lineage && npm run check:boundary && npm run check:corpus && npm run check:website-deps && npm run test:coverage",
+    "release:publish": "gh workflow run publish.yml --ref main -f bump=none",
+    "validate": "npm run build && npm run typecheck && npm run lint && npm run check:docs && npm run check:doc-invocations && npm run check:shareable && npm run lint:spine && npm run check:vectors && npm run check:schemas && npm run check:ad5-registry && npm run check:ad28-registry && npm run check:ad31-table && npm run check:ad33-table && npm run check:ad21-table && npm run check:layers && npm run check:lineage && npm run check:boundary && npm run check:corpus && npm run check:worked-example && npm run check:website-deps && npm run test:coverage",
     "prepack": "npm run clean && npm run build",
     "prepublishOnly": "node scripts/assert-publish-authorized.mjs"
   },