@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/test/evaluation-source-retrieval.test.js

@@ -0,0 +1,237 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { compileEvaluationEvidence } from "../evaluation-evidence.js";
+import { evaluationSourceTokens, planEvaluationSourceRetrieval, selectEvaluationEvidencePacket, selectEvaluationSourcePacket } from "../evaluation-source-retrieval.js";
+const providerDimension = {
+    id: "provider-model-execution",
+    description: "Execute requests through provider model backends and translate provider responses",
+    includes: [
+        "provider backend request execution",
+        "provider response decoding"
+    ],
+    excludes: [
+        "compositional routing",
+        "subscription account capacity",
+        "external wire protocol compatibility"
+    ]
+};
+const candidate = (path, sizeBytes = 100, sourceClass = "implementation") => ({
+    path,
+    sizeBytes,
+    sourceClass
+});
+const document = (path, content, sourceClass = "implementation") => ({
+    ...candidate(path, Buffer.byteLength(content), sourceClass),
+    content
+});
+test("tokenization preserves acronym and identifier boundaries deterministically", () => {
+    assert.deepEqual(evaluationSourceTokens("CodexResponsesBackend"), [
+        "codex",
+        "response",
+        "backend"
+    ]);
+    assert.deepEqual(evaluationSourceTokens("SSECodec provider_model"), [
+        "sse",
+        "codec",
+        "provider",
+        "model"
+    ]);
+    assert.deepEqual(evaluationSourceTokens("providers responses capabilities"), [
+        "provider",
+        "response",
+        "capability"
+    ]);
+});
+test("exclusion-only terms cannot promote a source", () => {
+    const selected = selectEvaluationSourcePacket({
+        documents: [
+            document("packages/gateway/src/providers/openai-backend.ts", "export const executeProviderModel = true;"),
+            document("packages/gateway/src/routing/compositional-routing.ts", "export const compositionalRouting = true;")
+        ],
+        targetDimensions: [providerDimension],
+        maximumFiles: 8,
+        maximumBytes: 10_000
+    });
+    assert.deepEqual(selected.map((source) => source.path), ["packages/gateway/src/providers/openai-backend.ts"]);
+});
+test("provider execution evidence outranks routing and broad documentation", () => {
+    const selected = selectEvaluationSourcePacket({
+        documents: [
+            document("packages/gateway/src/providers/openai-backend.ts", "execute provider model request and decode provider response"),
+            document("packages/gateway/src/providers/codex-responses-codec.ts", "translate provider request and provider response decoding"),
+            document("packages/gateway/src/test/provider-backends.test.ts", "test provider backend request execution and response decoding", "test"),
+            document("packages/gateway/src/test/compositional-routing.test.ts", "test compositional routing dimension selection", "test"),
+            document("docs/routekit-remote-gateways.md", "RouteKit gateway CLI daemon routing tool", "documentation")
+        ],
+        targetDimensions: [providerDimension],
+        maximumFiles: 3,
+        maximumBytes: 10_000
+    });
+    assert.deepEqual(selected.map((source) => source.path), [
+        "packages/gateway/src/providers/codex-responses-codec.ts",
+        "packages/gateway/src/providers/openai-backend.ts",
+        "packages/gateway/src/test/provider-backends.test.ts"
+    ]);
+    assert.ok(selected.every((source) => source.inclusionReason.startsWith("sparse retrieval rank ")));
+});
+test("ownership-root expansion recovers generic filenames by content", () => {
+    const candidates = [
+        candidate("packages/gateway/src/providers/openai-backend.ts"),
+        candidate("packages/gateway/src/dispatcher.ts"),
+        candidate("packages/unrelated/src/provider-catalog.ts")
+    ];
+    const planned = planEvaluationSourceRetrieval({
+        candidates,
+        targetDimensions: [providerDimension],
+        maximumFiles: 16,
+        maximumBytes: 10_000
+    });
+    assert.deepEqual(planned.map((source) => source.path), candidates.map((source) => source.path).sort());
+    const selected = selectEvaluationSourcePacket({
+        documents: planned.map((source) => ({
+            ...source,
+            content: source.path === "packages/gateway/src/dispatcher.ts"
+                ? "execute a request through the selected backend and decode its response"
+                : source.path.includes("unrelated")
+                    ? "provider names for display only"
+                    : "provider backend adapter"
+        })),
+        targetDimensions: [providerDimension],
+        maximumFiles: 2,
+        maximumBytes: 10_000
+    });
+    assert.ok(selected.some((source) => source.path === "packages/gateway/src/dispatcher.ts" &&
+        source.inclusionReason.endsWith("fields: content")));
+});
+test("selection does not force an irrelevant source class", () => {
+    const selected = selectEvaluationSourcePacket({
+        documents: [
+            document("packages/gateway/src/providers/anthropic-backend.ts", "provider backend request execution"),
+            document("docs/operations.md", "deployment rotation and incident access", "documentation"),
+            document("scripts/check-daemon.ts", "check daemon availability", "operational")
+        ],
+        targetDimensions: [providerDimension],
+        maximumFiles: 8,
+        maximumBytes: 10_000
+    });
+    assert.deepEqual(selected.map((source) => source.path), ["packages/gateway/src/providers/anthropic-backend.ts"]);
+});
+test("explicit inclusions are planned before retrieved candidates under a bound", () => {
+    const explicit = {
+        ...candidate(".routekit/incident/provider-trace.json"),
+        explicitReason: "reviewed incident evidence"
+    };
+    const planned = planEvaluationSourceRetrieval({
+        candidates: [
+            candidate("packages/gateway/src/providers/openai-backend.ts"),
+            candidate("packages/gateway/src/providers/anthropic-backend.ts"),
+            explicit
+        ],
+        targetDimensions: [providerDimension],
+        maximumFiles: 1,
+        maximumBytes: 10_000
+    });
+    assert.deepEqual(planned.map(({ pathScore: _pathScore, ...source }) => source), [explicit]);
+});
+test("planning and selection obey exact file and byte bounds", () => {
+    const candidates = [
+        candidate("packages/gateway/src/providers/a-backend.ts", 6),
+        candidate("packages/gateway/src/providers/b-backend.ts", 6),
+        candidate("packages/gateway/src/providers/c-backend.ts", 4)
+    ];
+    const planned = planEvaluationSourceRetrieval({
+        candidates,
+        targetDimensions: [providerDimension],
+        maximumFiles: 2,
+        maximumBytes: 10
+    });
+    assert.equal(planned.length, 2);
+    assert.equal(planned.reduce((total, source) => total + source.sizeBytes, 0), 10);
+    const selected = selectEvaluationSourcePacket({
+        documents: candidates.map((source) => ({
+            ...source,
+            content: "provider backend"
+        })),
+        targetDimensions: [providerDimension],
+        maximumFiles: 2,
+        maximumBytes: 10
+    });
+    assert.equal(selected.length, 2);
+    assert.equal(selected.reduce((total, source) => total + source.sizeBytes, 0), 10);
+});
+test("inventory order cannot change the retrieval result", () => {
+    const documents = [
+        document("packages/gateway/src/providers/openai-backend.ts", "provider backend request execution"),
+        document("packages/gateway/src/providers/google-backend.ts", "provider backend response decoding"),
+        document("packages/gateway/src/test/compositional-routing.test.ts", "compositional routing")
+    ];
+    const select = (values) => selectEvaluationSourcePacket({
+        documents: values,
+        targetDimensions: [providerDimension],
+        maximumFiles: 8,
+        maximumBytes: 10_000
+    });
+    assert.deepEqual(select([...documents].reverse()), select(documents));
+});
+test("block packet assembly covers positive facets without whole-file monopoly", () => {
+    const dimension = {
+        ...providerDimension,
+        includes: [
+            "provider live model catalogs and reasoning capabilities",
+            "upstream request construction and response decoding",
+            "explicit provider backend execution"
+        ]
+    };
+    const source = (path, blocks) => {
+        const content = blocks.join("\n\n");
+        return {
+            ...candidate(path, Buffer.byteLength(content)),
+            evidenceSource: compileEvaluationEvidence({
+                sources: [{ path, content }],
+                maximumBlockBytes: 80
+            })[0]
+        };
+    };
+    const selected = selectEvaluationEvidencePacket({
+        documents: [
+            source("packages/gateway/src/providers/backend.ts", [
+                "explicit provider backend execution",
+                "generic provider backend helper",
+                "generic provider backend helper"
+            ]),
+            source("packages/cli/src/catalog.ts", [
+                "live model catalog reasoning capability"
+            ]),
+            source("packages/gateway/src/providers/codex-codec.ts", [
+                "upstream request construction response decoding"
+            ])
+        ],
+        targetDimensions: [dimension],
+        maximumBlocks: 3,
+        maximumBytes: 10_000,
+        maximumBlocksPerSource: 2
+    });
+    assert.deepEqual(selected.map((selection) => selection.source.path), [
+        "packages/cli/src/catalog.ts",
+        "packages/gateway/src/providers/backend.ts",
+        "packages/gateway/src/providers/codex-codec.ts"
+    ]);
+    assert.equal(selected.reduce((total, selection) => total + selection.blocks.length, 0), 3);
+});
+test("structural provider scope lets concrete sibling transports compete", () => {
+    const candidates = [
+        candidate("packages/gateway/src/providers/backend.ts"),
+        candidate("packages/gateway/src/providers/openai-backend.ts"),
+        candidate("packages/gateway/src/routing/router.ts")
+    ];
+    const planned = planEvaluationSourceRetrieval({
+        candidates,
+        targetDimensions: [providerDimension],
+        maximumFiles: 16,
+        maximumBytes: 10_000
+    });
+    const byPath = new Map(planned.map((source) => [source.path, source]));
+    assert.ok((byPath.get("packages/gateway/src/providers/openai-backend.ts")
+        ?.pathScore ?? 0) >
+        (byPath.get("packages/gateway/src/routing/router.ts")?.pathScore ?? 0));
+});

package/dist/test/evaluation-structure-policy.test.d.ts

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

package/dist/test/evaluation-structure-policy.test.js

@@ -0,0 +1,196 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { compileEvaluationEvidence, renderEvaluationEvidenceContext } from "../evaluation-evidence.js";
+import { assertEvaluationStructure, candidateCaseProjection, hiddenOracleProjection, renderEvaluationCriteria } from "../evaluation-structure-policy.js";
+const sourceContent = [
+    "Protocol rules:",
+    "- the terminal event must be last;",
+    "- later output is invalid;",
+    "- unsupported fields are rejected.",
+    ""
+].join("\n");
+const evidenceSources = compileEvaluationEvidence({
+    sources: [{ path: "src/protocol.ts", content: sourceContent }],
+    maximumBlockBytes: 3_000
+});
+const evidenceBlock = evidenceSources[0].blocks[0];
+const compilerBackedCase = (id, overrides = {}) => {
+    const criteria = [
+        {
+            id: `${id}-critical`,
+            description: "Explain why the terminal event must be last and why later output is invalid or unsupported.",
+            importance: "critical",
+            gradingMode: "semantic"
+        }
+    ];
+    return {
+        id,
+        prompt: "Explain the protocol behavior from the supplied evidence.",
+        context: renderEvaluationEvidenceContext([evidenceBlock]),
+        rubric: renderEvaluationCriteria(criteria),
+        evidenceIds: [evidenceBlock.id],
+        criteria,
+        positiveControls: [
+            {
+                id: `${id}-positive`,
+                response: "The terminal event must be last; later output is invalid and unsupported."
+            }
+        ],
+        negativeControls: [
+            {
+                id: `${id}-missing`,
+                response: "The response discusses event streams but omits terminal ordering.",
+                targetedCriterionIds: [`${id}-critical`],
+                kind: "missing-criterion"
+            },
+            {
+                id: `${id}-forbidden`,
+                response: "Events may be emitted after the terminal event.",
+                targetedCriterionIds: [`${id}-critical`],
+                kind: "forbidden-behavior"
+            },
+            {
+                id: `${id}-non-responsive`,
+                response: "This protocol is thoughtfully designed and broadly useful.",
+                targetedCriterionIds: [`${id}-critical`],
+                kind: "non-responsive"
+            }
+        ],
+        ...overrides
+    };
+};
+const proposalWith = (dimensionCase = compilerBackedCase("dimension-case"), compositionCase = compilerBackedCase("composition-case")) => ({
+    version: 1,
+    basisDigest: "basis",
+    evaluationDigest: "evaluation",
+    candidateModels: ["provider/candidate-a", "provider/candidate-b"],
+    judgeModel: "provider/judge",
+    evidenceSources,
+    suites: [
+        {
+            version: 1,
+            dimensionId: "protocol",
+            maximumOutputTokens: 256,
+            cases: [dimensionCase]
+        }
+    ],
+    decompositionBenchmark: {
+        maximumVectorL1Error: 0.3,
+        cases: []
+    },
+    compositionSuite: {
+        maximumOutputTokens: 256,
+        minimumWinnerScoreGap: 0.05,
+        minimumWinnerAgreement: 0.8,
+        cases: [
+            {
+                ...compositionCase,
+                decomposition: {
+                    weights: [{ dimensionId: "protocol", weight: 1 }],
+                    unknownWeight: 0
+                },
+                requirements: {
+                    endpoint: "responses",
+                    requiresTools: false,
+                    requiresVision: false
+                }
+            }
+        ]
+    }
+});
+test("structure policy accepts legitimate protocol language and reports duplicate selections as facts", () => {
+    const report = assertEvaluationStructure({
+        proposal: proposalWith(),
+        sourceInventory: ["src/protocol.ts"]
+    });
+    assert.equal(report.caseCount, 2);
+    assert.deepEqual(report.duplicateEvidenceSelectionGroups, [
+        ["composition/composition-case", "protocol/dimension-case"]
+    ]);
+});
+test("candidate and hidden projections encode the visibility boundary", () => {
+    const testCase = compilerBackedCase("projection");
+    assert.deepEqual(Object.keys(candidateCaseProjection(testCase)).sort(), [
+        "context",
+        "id",
+        "prompt"
+    ]);
+    assert.deepEqual(Object.keys(hiddenOracleProjection(testCase)).sort(), [
+        "criteria",
+        "id",
+        "negativeControls",
+        "positiveControls",
+        "rubric"
+    ]);
+});
+test("structure policy rejects context and rubric not rendered by the compiler", () => {
+    assert.throws(() => assertEvaluationStructure({
+        proposal: proposalWith(compilerBackedCase("context", { context: "author-supplied context" })),
+        sourceInventory: ["src/protocol.ts"]
+    }), /context is not compiler-rendered/u);
+    assert.throws(() => assertEvaluationStructure({
+        proposal: proposalWith(compilerBackedCase("rubric", { rubric: "author-supplied rubric" })),
+        sourceInventory: ["src/protocol.ts"]
+    }), /rubric is not compiler-rendered/u);
+});
+test("structure policy rejects unknown evidence and inventory mismatches", () => {
+    assert.throws(() => assertEvaluationStructure({
+        proposal: proposalWith(compilerBackedCase("unknown", { evidenceIds: ["ev_unknown"] })),
+        sourceInventory: ["src/protocol.ts"]
+    }), /unknown evidence id/u);
+    assert.throws(() => assertEvaluationStructure({
+        proposal: proposalWith(),
+        sourceInventory: ["src/other.ts"]
+    }), /outside the project inventory/u);
+});
+test("structure policy rejects missing or invalid control topology", () => {
+    const base = compilerBackedCase("controls");
+    assert.throws(() => assertEvaluationStructure({
+        proposal: proposalWith({
+            ...base,
+            criteria: base.criteria.map((criterion) => ({
+                ...criterion,
+                importance: "supporting"
+            })),
+            rubric: renderEvaluationCriteria(base.criteria.map((criterion) => ({
+                ...criterion,
+                importance: "supporting"
+            })))
+        }),
+        sourceInventory: ["src/protocol.ts"]
+    }), /requires a critical criterion/u);
+    assert.throws(() => assertEvaluationStructure({
+        proposal: proposalWith({
+            ...base,
+            negativeControls: base.negativeControls.map((control, index) => index === 0
+                ? { ...control, targetedCriterionIds: ["unknown-criterion"] }
+                : control)
+        }),
+        sourceInventory: ["src/protocol.ts"]
+    }), /invalid negative-control target/u);
+    assert.throws(() => assertEvaluationStructure({
+        proposal: proposalWith({
+            ...base,
+            negativeControls: base.negativeControls.filter((control) => control.kind !== "non-responsive")
+        }),
+        sourceInventory: ["src/protocol.ts"]
+    }), /requires a non-responsive negative control/u);
+});
+test("structure policy rejects tampered persisted evidence metadata", () => {
+    const proposal = proposalWith();
+    const source = proposal.evidenceSources[0];
+    const block = source.blocks[0];
+    const tampered = {
+        ...proposal,
+        evidenceSources: [
+            {
+                ...source,
+                blocks: [{ ...block, text: `${block.text}tampered` }]
+            }
+        ]
+    };
+    assert.throws(() => assertEvaluationStructure({
+        proposal: tampered,
+        sourceInventory: ["src/protocol.ts"]
+    }), /source digest does not match|block identity does not match/u);
+});

package/dist/test/fixtures/repository-resource-panel.d.ts

@@ -0,0 +1,39 @@
+export declare const RESOURCE_PARENT_DEADLINE_MS = 8000;
+export declare const RESOURCE_BODY_DELAY_MS = 30000;
+export declare const RESOURCE_FRAMEWORK_TIMEOUT_MS = 45000;
+export declare const RESOURCE_OUTPUT_CHUNK_BYTES: number;
+export declare const RESOURCE_OUTPUT_CAP_BYTES: number;
+export declare const REPOSITORY_RESOURCE_CASES: readonly [{
+    readonly id: "edge-resource-clean";
+    readonly runner: "vitest";
+    readonly kind: "clean";
+    readonly expected: "pass";
+    readonly events: readonly ["module-enter", "body-enter", "body-return", ...string[]];
+}, {
+    readonly id: "edge-worker-terminated";
+    readonly runner: "vitest";
+    readonly kind: "termination";
+    readonly expected: "unknown";
+    readonly events: readonly ["module-enter", "body-enter", "signal-requested", "signal-observed", "termination-requested"];
+}, {
+    readonly id: "edge-parent-deadline";
+    readonly runner: "vitest";
+    readonly kind: "deadline";
+    readonly expected: "unknown";
+    readonly events: readonly ["module-enter", "body-enter"];
+}, {
+    readonly id: "edge-output-ordinary";
+    readonly runner: "node";
+    readonly kind: "output";
+    readonly chunks: 1;
+    readonly expected: "pass";
+    readonly events: readonly ["module-enter", "body-enter", "output-enter", "output-return", "body-return", "cleanup-enter", "cleanup-return"];
+}, {
+    readonly id: "edge-output-overflow";
+    readonly runner: "node";
+    readonly kind: "output";
+    readonly chunks: 33;
+    readonly expected: "unknown";
+    readonly events: readonly ["module-enter", "body-enter", "output-enter", "output-return", "body-return", "cleanup-enter", "cleanup-return"];
+}];
+export declare const REPOSITORY_RESOURCE_FILES: Readonly<Record<string, string>>;

package/dist/test/fixtures/repository-resource-panel.js

@@ -0,0 +1,111 @@
+import { REPOSITORY_BOUNDARY_EVENTS_SOURCE } from "./vitest-boundary-panel.js";
+// Real, bounded subprocess controls only. No candidate benchmark code, new
+// execution owner, resource-policy change, or fabricated command-result flags.
+export const RESOURCE_PARENT_DEADLINE_MS = 8000;
+export const RESOURCE_BODY_DELAY_MS = 30000;
+export const RESOURCE_FRAMEWORK_TIMEOUT_MS = 45000;
+export const RESOURCE_OUTPUT_CHUNK_BYTES = 64 * 1024;
+export const RESOURCE_OUTPUT_CAP_BYTES = 2 * 1024 * 1024;
+const cleanHooks = ["after-each-enter", "after-each-return", "after-all-enter", "after-all-return"];
+export const REPOSITORY_RESOURCE_CASES = [
+    { id: "edge-resource-clean", runner: "vitest", kind: "clean", expected: "pass",
+        events: ["module-enter", "body-enter", "body-return", ...cleanHooks] },
+    { id: "edge-worker-terminated", runner: "vitest", kind: "termination", expected: "unknown",
+        events: ["module-enter", "body-enter", "signal-requested", "signal-observed", "termination-requested"] },
+    { id: "edge-parent-deadline", runner: "vitest", kind: "deadline", expected: "unknown",
+        events: ["module-enter", "body-enter"] },
+    { id: "edge-output-ordinary", runner: "node", kind: "output", chunks: 1, expected: "pass",
+        events: ["module-enter", "body-enter", "output-enter", "output-return", "body-return",
+            "cleanup-enter", "cleanup-return"] },
+    { id: "edge-output-overflow", runner: "node", kind: "output", chunks: 33, expected: "unknown",
+        events: ["module-enter", "body-enter", "output-enter", "output-return", "body-return",
+            "cleanup-enter", "cleanup-return"] }
+];
+const vitestSource = String.raw `
+import assert from "node:assert/strict";
+import { setTimeout as delay } from "node:timers/promises";
+import { afterAll, afterEach, test } from "vitest";
+import { diagnostic, phase } from "./edge-events.mjs";
+export function register(scenario, timing) {
+  const event = (name, detail) => phase(scenario.id, name, detail);
+  event("module-enter");
+  afterEach(() => { event("after-each-enter"); event("after-each-return"); });
+  afterAll(() => { event("after-all-enter"); event("after-all-return"); });
+  // The framework timeout must outlast BOTH the finite body and the parent
+  // command deadline. A native body timeout is not the intended control.
+  test("bounded resource " + scenario.id, { timeout: timing.frameworkTimeoutMs }, async () => {
+    event("body-enter");
+    if (scenario.kind === "termination") {
+      // Vitest patches process.exit to throw. Deliver a real signal to this
+      // fresh fixture-owned worker instead; do not touch existing listeners.
+      assert.equal(process.listenerCount("SIGTERM"), 0, "unexpected fixture-worker signal listener");
+      process.once("SIGTERM", () => {
+        event("signal-observed");
+        event("termination-requested");
+        try {
+          process.kill(process.pid, "SIGKILL");
+        } catch (error) {
+          event("termination-rejected", diagnostic(error));
+          throw error;
+        }
+        event("termination-returned");
+      });
+      event("signal-requested");
+      try {
+        process.kill(process.pid, "SIGTERM");
+      } catch (error) {
+        event("signal-rejected", diagnostic(error));
+        throw error;
+      }
+      // One finite fallback ensures denial or unexpected survival is a failed
+      // causal control, never a successful "unknown" by an unrelated error.
+      await delay(1500);
+      event("worker-survived");
+      assert.fail("the fixture-owned grading worker survived its termination signal");
+    }
+    await delay(scenario.kind === "deadline" ? timing.bodyDelayMs : 25);
+    event("body-return");
+  });
+}
+`;
+const nodeSource = String.raw `
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { phase } from "./edge-events.mjs";
+export function register(scenario, chunkBytes) {
+  const event = name => phase(scenario.id, name);
+  event("module-enter");
+  test("bounded resource " + scenario.id, async context => {
+    event("body-enter");
+    context.after(() => { event("cleanup-enter"); event("cleanup-return"); });
+    // Allocate one ASCII chunk and reuse it. Each write awaits the actual
+    // stream callback/backpressure; neither loop nor buffering is unbounded.
+    const chunk = "x".repeat(chunkBytes - 1) + "\n";
+    assert.equal(Buffer.byteLength(chunk), chunkBytes);
+    let written = 0;
+    event("output-enter");
+    for (let index = 0; index < scenario.chunks; index += 1) {
+      const stream = index % 2 === 0 ? process.stdout : process.stderr;
+      await new Promise((resolve, reject) => stream.write(chunk, "utf8",
+        error => error ? reject(error) : resolve()));
+      written += chunkBytes;
+    }
+    event("output-return");
+    assert.equal(written, scenario.chunks * chunkBytes);
+    event("body-return");
+  });
+}
+`;
+export const REPOSITORY_RESOURCE_FILES = {
+    "test/edge-events.mjs": REPOSITORY_BOUNDARY_EVENTS_SOURCE,
+    "test/resource-vitest-register.mjs": vitestSource,
+    "test/resource-node-register.mjs": nodeSource,
+    ...Object.fromEntries(REPOSITORY_RESOURCE_CASES.map(scenario => [
+        `test/${scenario.id}.test.mjs`,
+        scenario.runner === "vitest"
+            ? `import { register } from "./resource-vitest-register.mjs";\nregister(${JSON.stringify(scenario)}, ${JSON.stringify({
+                frameworkTimeoutMs: RESOURCE_FRAMEWORK_TIMEOUT_MS, bodyDelayMs: RESOURCE_BODY_DELAY_MS
+            })});\n`
+            : `import { register } from "./resource-node-register.mjs";\nregister(${JSON.stringify(scenario)}, ${RESOURCE_OUTPUT_CHUNK_BYTES});\n`
+    ]))
+};

package/dist/test/fixtures/vitest-boundary-panel.d.ts

@@ -0,0 +1,84 @@
+export declare const VITEST_BOUNDARY_CASES: readonly [{
+    readonly id: "edge-hooks-clean";
+    readonly kind: "hooks";
+    readonly bodyOk: true;
+    readonly expected: "pass";
+    readonly events: string[];
+    readonly taskState: "passed";
+}, {
+    readonly id: "edge-hooks-body-only";
+    readonly kind: "hooks";
+    readonly bodyOk: false;
+    readonly expected: "fail";
+    readonly events: string[];
+    readonly taskState: "failed";
+}, {
+    readonly id: "edge-before-all";
+    readonly kind: "hooks";
+    readonly bodyOk: true;
+    readonly hookFailure: "before-all";
+    readonly expected: "unknown";
+    readonly events: readonly ["module-enter", "before-all-enter", "after-all-enter", "after-all-return"];
+    readonly taskState: "skipped";
+}, {
+    readonly id: "edge-after-each";
+    readonly kind: "hooks";
+    readonly bodyOk: true;
+    readonly hookFailure: "after-each";
+    readonly expected: "unknown";
+    readonly events: string[];
+    readonly taskState: "failed";
+}, {
+    readonly id: "edge-after-all";
+    readonly kind: "hooks";
+    readonly bodyOk: true;
+    readonly hookFailure: "after-all";
+    readonly expected: "unknown";
+    readonly events: string[];
+    readonly taskState: "passed";
+}, {
+    readonly id: "edge-import-ok";
+    readonly kind: "import-ok";
+    readonly expected: "pass";
+    readonly events: readonly ["module-enter", "imported-module-enter", "import-return", "body-enter", "body-return"];
+    readonly taskState: "passed";
+}, {
+    readonly id: "edge-import-error";
+    readonly kind: "import-error";
+    readonly expected: "unknown";
+    readonly events: readonly ["module-enter", "imported-module-enter", "import-rejected"];
+    readonly taskState: "none";
+}, {
+    readonly id: "edge-syntax-error";
+    readonly kind: "syntax-error";
+    readonly expected: "unknown";
+    readonly events: readonly ["module-enter", "import-rejected"];
+    readonly taskState: "none";
+}, {
+    readonly id: "edge-no-tests";
+    readonly kind: "no-tests";
+    readonly expected: "unknown";
+    readonly events: readonly ["module-enter"];
+    readonly taskState: "none";
+}, {
+    readonly id: "edge-all-skipped";
+    readonly kind: "all-skipped";
+    readonly expected: "unknown";
+    readonly events: readonly ["module-enter"];
+    readonly taskState: "skipped";
+}];
+export declare const VITEST_COLLECTION_FAILURE_CASES: ({
+    readonly id: "edge-import-error";
+    readonly kind: "import-error";
+    readonly expected: "unknown";
+    readonly events: readonly ["module-enter", "imported-module-enter", "import-rejected"];
+    readonly taskState: "none";
+} | {
+    readonly id: "edge-syntax-error";
+    readonly kind: "syntax-error";
+    readonly expected: "unknown";
+    readonly events: readonly ["module-enter", "import-rejected"];
+    readonly taskState: "none";
+})[];
+export declare const REPOSITORY_BOUNDARY_EVENTS_SOURCE: string;
+export declare const VITEST_BOUNDARY_FILES: Readonly<Record<string, string>>;