@pixel-point/toolcraft 0.0.16 → 0.0.18

package/templates/starter/scripts/toolcraft-unavailable-resource-evidence-facade.test.mjs

@@ -1,180 +1,25 @@
 import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
 import test from "node:test";
-import { pathToFileURL } from "node:url";
 
-import ts from "typescript";
+import {
+  createArtifactAction,
+  createSession,
+  executeClosurelessObservation,
+  getHarnessState,
+  loadUnavailableResourceFacade,
+  resetHarness,
+  setActivationError,
+  setCleanupFailure,
+  setMalformedActivation,
+} from "./toolcraft-unavailable-resource-evidence-facade-test-helpers.mjs";
 
-const starterRoot = path.resolve(import.meta.dirname, "..");
-const helperPath = path.join(
-  starterRoot,
-  "e2e/browser-infinity-canvas-evidence.ts",
-);
-
-async function loadUnavailableResourceFacade(context) {
-  const outputDir = await fs.mkdtemp(
-    path.join(os.tmpdir(), "toolcraft-unavailable-resource-evidence-"),
+test("closureless observation harness rejects browser callbacks with outer references", () => {
+  const readAttribute = (root) => root.getAttribute("data-value");
+  assert.throws(
+    () => executeClosurelessObservation((root) => readAttribute(root), {}),
+    /readAttribute is not defined/u,
   );
-  context.after(() => fs.rm(outputDir, { force: true, recursive: true }));
-  const outputPath = path.join(outputDir, "browser-infinity-canvas-evidence.mjs");
-  const source = (await fs.readFile(helperPath, "utf8"))
-    .replaceAll('"@playwright/test"', '"./playwright.mjs"')
-    .replaceAll('"./browser-runtime-evidence"', '"./evidence.mjs"')
-    .replaceAll('"./browser-proof-session"', '"./proof-session.mjs"')
-    .replaceAll('"./export-artifact-helpers"', '"./artifact.mjs"');
-  const { outputText } = ts.transpileModule(source, {
-    compilerOptions: {
-      module: ts.ModuleKind.ESNext,
-      target: ts.ScriptTarget.ES2022,
-    },
-    fileName: helperPath,
-  });
-
-  await Promise.all([
-    fs.writeFile(outputPath, outputText),
-    fs.writeFile(
-      path.join(outputDir, "playwright.mjs"),
-      `
-        import assert from "node:assert/strict";
-        function partial(actual, expected, message) {
-          for (const [key, value] of Object.entries(expected)) {
-            assert.deepEqual(actual?.[key], value, message);
-          }
-        }
-        export function expect(actual, message = "Expectation failed") {
-          return {
-            not: {
-              toBe(expected) {
-                assert.notEqual(actual, expected, message);
-              },
-              toEqual(expected) {
-                assert.notDeepEqual(actual, expected, message);
-              },
-            },
-            toBe(expected) {
-              assert.equal(actual, expected, message);
-            },
-            toBeTruthy() {
-              assert.ok(actual, message);
-            },
-            toEqual(expected) {
-              assert.deepEqual(actual, expected, message);
-            },
-            toMatchObject(expected) {
-              if (expected?.status === "cleaned") {
-                globalThis.__toolcraftUnavailableEvidenceTrace.push(
-                  "assert:cleaned",
-                );
-              }
-              partial(actual, expected, message);
-            },
-          };
-        }
-      `,
-    ),
-    fs.writeFile(
-      path.join(outputDir, "evidence.mjs"),
-      `
-        export async function attachToolcraftBrowserRuntimeEvidence(evidence) {
-          globalThis.__toolcraftUnavailableEvidenceTrace.push(
-            "evidence:" + evidence.evidenceType,
-          );
-          globalThis.__toolcraftUnavailableEvidenceAttachments.push(evidence);
-        }
-      `,
-    ),
-    fs.writeFile(
-      path.join(outputDir, "proof-session.mjs"),
-      `
-        export function assertToolcraftBrowserProofSession() {
-          globalThis.__toolcraftUnavailableEvidenceSessionAssertions += 1;
-        }
-        export function getToolcraftBrowserActionTarget(action) {
-          return action.target;
-        }
-        export async function readToolcraftBrowserObservation() {
-          return globalThis.__toolcraftUnavailableEvidenceObservation;
-        }
-        export async function runToolcraftBrowserAction() {
-          globalThis.__toolcraftUnavailableEvidenceActionCalls += 1;
-          const actionName =
-            globalThis.__toolcraftUnavailableEvidenceActionCalls === 1
-              ? "activate"
-              : "cleanup";
-          globalThis.__toolcraftUnavailableEvidenceTrace.push(
-            "action:" + actionName,
-          );
-          if (
-            actionName === "cleanup" &&
-            globalThis.__toolcraftUnavailableEvidenceCleanupFailure
-          ) {
-            throw new Error("cleanup failed");
-          }
-          globalThis.__toolcraftUnavailableEvidenceObservation =
-            globalThis.__toolcraftUnavailableEvidenceActionCalls === 1
-              ? {
-                  assetId: "image-2",
-                  fileName: "unavailable.png",
-                  lifecycle: "unavailable",
-                  requestId: "unavailable-image-1",
-                  resolverAvailable: false,
-                  status: "active",
-                }
-              : {
-                  assetId: "image-2",
-                  fileName: "unavailable.png",
-                  lifecycle: "ready",
-                  requestId: "unavailable-image-1",
-                  resolverAvailable: true,
-                  status: "cleaned",
-                };
-        }
-        export async function runToolcraftBrowserValueAction(action) {
-          globalThis.__toolcraftUnavailableEvidenceTrace.push("artifact");
-          return action.result;
-        }
-      `,
-    ),
-    fs.writeFile(
-      path.join(outputDir, "artifact.mjs"),
-      `
-        export function assertToolcraftProducedArtifact(artifact) {
-          if (!artifact) throw new Error("missing artifact");
-        }
-        export function validateToolcraftExportArtifactInspection(inspection) {
-          globalThis.__toolcraftUnavailableEvidenceArtifactValidations += 1;
-          if (!inspection?.byteLength) throw new Error("invalid inspection");
-          return inspection;
-        }
-      `,
-    ),
-  ]);
-
-  return import(`${pathToFileURL(outputPath).href}?test=${Date.now()}`);
-}
-
-function createSession() {
-  return {
-    observe(read) {
-      return { read };
-    },
-    targetAction(target, run) {
-      return { run, target };
-    },
-  };
-}
-
-function resetHarness() {
-  globalThis.__toolcraftUnavailableEvidenceActionCalls = 0;
-  globalThis.__toolcraftUnavailableEvidenceArtifactValidations = 0;
-  globalThis.__toolcraftUnavailableEvidenceAttachments = [];
-  globalThis.__toolcraftUnavailableEvidenceCleanupFailure = false;
-  globalThis.__toolcraftUnavailableEvidenceObservation = { status: "missing" };
-  globalThis.__toolcraftUnavailableEvidenceSessionAssertions = 0;
-  globalThis.__toolcraftUnavailableEvidenceTrace = [];
-}
+});
 
 function createFiniteObservation(width, height) {
   return {
@@ -184,6 +29,7 @@ function createFiniteObservation(width, height) {
     finiteControlSize: { height, width },
     finiteControlsPresent: true,
     overflow: "hidden",
+    productSceneStatus: null,
     sceneRect: null,
     viewportOffset: { x: 0, y: 0 },
   };
@@ -197,6 +43,7 @@ function createInfiniteObservation() {
     finiteControlSize: null,
     finiteControlsPresent: false,
     overflow: "visible",
+    productSceneStatus: "ready",
     sceneRect: { height: 400, width: 640, x: -320, y: -200 },
     viewportOffset: { x: 0, y: 0 },
   };
@@ -230,7 +77,7 @@ test("Infinity mode recipe rejects a wrong restored dormant finite size", async
       },
     ),
   );
-  assert.deepEqual(globalThis.__toolcraftUnavailableEvidenceAttachments, []);
+  assert.deepEqual(getHarnessState().attachments, []);
 });
 
 test("Infinity mode recipe accepts exact restored dormant finite dimensions", async (context) => {
@@ -259,7 +106,7 @@ test("Infinity mode recipe accepts exact restored dormant finite dimensions", as
       target: "canvas.infinity",
     },
   );
-  assert.deepEqual(globalThis.__toolcraftUnavailableEvidenceAttachments, [
+  assert.deepEqual(getHarnessState().attachments, [
     {
       evidenceType: "viewport-side-effect",
       requirementId: "canvas.infinity.mode",
@@ -276,18 +123,20 @@ test("Infinity mode recipe accepts exact restored dormant finite dimensions", as
 test("unavailable-image export recipe proves typed fault before evidence and cleans up", async (context) => {
   const facade = await loadUnavailableResourceFacade(context);
   resetHarness();
+  const session = createSession();
   const fixture = facade.createToolcraftUnavailableImageResourceFixture(
-    createSession(),
+    session,
     {
       fileName: "unavailable.png",
       sourceTarget: "source.images",
       target: "canvas.infinity",
     },
   );
-  const exportAction = {
-    result: new Uint8Array([1, 2, 3]),
-    target: "canvas.infinity",
-  };
+  const exportAction = createArtifactAction(
+    session,
+    "canvas.infinity",
+    new Uint8Array([1, 2, 3]),
+  );
   const inspection =
     await facade.expectToolcraftInfinityCanvasUnavailableImageExportEvidence(
       fixture,
@@ -304,10 +153,12 @@ test("unavailable-image export recipe proves typed fault before evidence and cle
     height: 2004,
     width: 2048,
   });
-  assert.equal(globalThis.__toolcraftUnavailableEvidenceActionCalls, 2);
-  assert.equal(globalThis.__toolcraftUnavailableEvidenceArtifactValidations, 1);
-  assert.equal(globalThis.__toolcraftUnavailableEvidenceSessionAssertions, 1);
-  assert.deepEqual(globalThis.__toolcraftUnavailableEvidenceAttachments, [
+  const state = getHarnessState();
+  assert.equal(state.actionCalls, 2);
+  assert.equal(state.artifactValidations, 1);
+  assert.equal(state.closurelessObservationCalls, 4);
+  assert.equal(state.sessionAssertions, 1);
+  assert.deepEqual(state.attachments, [
     {
       evidenceType: "exported-artifact",
       requirementId: "canvas.infinity.image-export",
@@ -319,21 +170,40 @@ test("unavailable-image export recipe proves typed fault before evidence and cle
       target: "canvas.infinity",
     },
   ]);
-  assert.deepEqual(globalThis.__toolcraftUnavailableEvidenceTrace, [
+  assert.deepEqual(state.trace, [
     "action:activate",
+    "assert:active",
     "artifact",
+    "assert:active",
     "action:cleanup",
     "assert:cleaned",
     "evidence:exported-artifact",
     "evidence:infinity-scene-bounds-image-export",
   ]);
+  assert.deepEqual(state.bridgeActions, ["activate", "cleanup"]);
+  assert.deepEqual(state.eventNames, [
+    "toolcraft.browser-proof.unavailable-resource-request",
+    "toolcraft.browser-proof.unavailable-resource-request",
+  ]);
+  assert.deepEqual(state.selectorNames, [
+    '[data-slot="toolcraft-runtime-app"]',
+    '[data-slot="toolcraft-runtime-app"]',
+  ]);
+  assert.ok(
+    state.attributeNames.length > 0 &&
+      state.attributeNames.every(
+        (name) => name === "data-toolcraft-unavailable-resource-evidence",
+      ),
+  );
+  assert.equal(state.pollCalls, 2);
 });
 
 test("unavailable-image export recipe cleans up and emits no evidence when decoded bounds fail", async (context) => {
   const facade = await loadUnavailableResourceFacade(context);
   resetHarness();
+  const session = createSession();
   const fixture = facade.createToolcraftUnavailableImageResourceFixture(
-    createSession(),
+    session,
     {
       fileName: "unavailable.png",
       target: "canvas.infinity",
@@ -343,10 +213,11 @@ test("unavailable-image export recipe cleans up and emits no evidence when decod
   await assert.rejects(
     facade.expectToolcraftInfinityCanvasUnavailableImageExportEvidence(
       fixture,
-      {
-        result: new Uint8Array([1, 2, 3]),
-        target: "canvas.infinity",
-      },
+      createArtifactAction(
+        session,
+        "canvas.infinity",
+        new Uint8Array([1, 2, 3]),
+      ),
       async () => ({ byteLength: 3, height: 100, width: 100 }),
       {
         expectedSize: { height: 2004, width: 2048 },
@@ -355,20 +226,18 @@ test("unavailable-image export recipe cleans up and emits no evidence when decod
     ),
   );
 
-  assert.equal(globalThis.__toolcraftUnavailableEvidenceActionCalls, 2);
-  assert.deepEqual(globalThis.__toolcraftUnavailableEvidenceAttachments, []);
-  assert.equal(
-    globalThis.__toolcraftUnavailableEvidenceObservation.status,
-    "cleaned",
-  );
+  assert.equal(getHarnessState().actionCalls, 2);
+  assert.deepEqual(getHarnessState().attachments, []);
+  assert.equal(getHarnessState().observation.status, "cleaned");
 });
 
 test("unavailable-image export recipe emits no evidence when cleanup fails", async (context) => {
   const facade = await loadUnavailableResourceFacade(context);
   resetHarness();
-  globalThis.__toolcraftUnavailableEvidenceCleanupFailure = true;
+  setCleanupFailure();
+  const session = createSession();
   const fixture = facade.createToolcraftUnavailableImageResourceFixture(
-    createSession(),
+    session,
     {
       fileName: "unavailable.png",
       target: "canvas.infinity",
@@ -378,10 +247,11 @@ test("unavailable-image export recipe emits no evidence when cleanup fails", asy
   await assert.rejects(
     facade.expectToolcraftInfinityCanvasUnavailableImageExportEvidence(
       fixture,
-      {
-        result: new Uint8Array([1, 2, 3]),
-        target: "canvas.infinity",
-      },
+      createArtifactAction(
+        session,
+        "canvas.infinity",
+        new Uint8Array([1, 2, 3]),
+      ),
       async () => ({ byteLength: 3, height: 2004, width: 2048 }),
       {
         expectedSize: { height: 2004, width: 2048 },
@@ -391,14 +261,75 @@ test("unavailable-image export recipe emits no evidence when cleanup fails", asy
     /cleanup failed/u,
   );
 
-  assert.deepEqual(globalThis.__toolcraftUnavailableEvidenceAttachments, []);
-  assert.deepEqual(globalThis.__toolcraftUnavailableEvidenceTrace, [
+  assert.deepEqual(getHarnessState().attachments, []);
+  assert.deepEqual(getHarnessState().trace, [
     "action:activate",
+    "assert:active",
     "artifact",
+    "assert:active",
     "action:cleanup",
   ]);
 });
 
+test("unavailable-image export recipe surfaces bridge errors before artifact work", async (context) => {
+  const facade = await loadUnavailableResourceFacade(context);
+  resetHarness();
+  setActivationError("activation failed");
+  const session = createSession();
+  const fixture = facade.createToolcraftUnavailableImageResourceFixture(
+    session,
+    { fileName: "unavailable.png", target: "canvas.infinity" },
+  );
+
+  await assert.rejects(
+    facade.expectToolcraftInfinityCanvasUnavailableImageExportEvidence(
+      fixture,
+      createArtifactAction(
+        session,
+        "canvas.infinity",
+        new Uint8Array([1]),
+      ),
+      async () => ({ byteLength: 1, height: 1, width: 1 }),
+      {
+        expectedSize: { height: 1, width: 1 },
+        requirementId: "canvas.infinity.image-export",
+      },
+    ),
+    /activation failed/u,
+  );
+  assert.deepEqual(getHarnessState().trace, ["action:activate"]);
+  assert.deepEqual(getHarnessState().attachments, []);
+});
+
+test("unavailable-image export recipe rejects malformed bridge observations", async (context) => {
+  const facade = await loadUnavailableResourceFacade(context);
+  resetHarness();
+  setMalformedActivation();
+  const session = createSession();
+  const fixture = facade.createToolcraftUnavailableImageResourceFixture(
+    session,
+    { fileName: "unavailable.png", target: "canvas.infinity" },
+  );
+
+  await assert.rejects(
+    facade.expectToolcraftInfinityCanvasUnavailableImageExportEvidence(
+      fixture,
+      createArtifactAction(
+        session,
+        "canvas.infinity",
+        new Uint8Array([1]),
+      ),
+      async () => ({ byteLength: 1, height: 1, width: 1 }),
+      {
+        expectedSize: { height: 1, width: 1 },
+        requirementId: "canvas.infinity.image-export",
+      },
+    ),
+    /published malformed state/u,
+  );
+  assert.deepEqual(getHarnessState().attachments, []);
+});
+
 test("unavailable-image export recipe rejects forged fixtures and target mismatch", async (context) => {
   const facade = await loadUnavailableResourceFacade(context);
   resetHarness();
@@ -426,14 +357,34 @@ test("unavailable-image export recipe rejects forged fixtures and target mismatc
   await assert.rejects(
     facade.expectToolcraftInfinityCanvasUnavailableImageExportEvidence(
       fixture,
-      { result: new Uint8Array([1]), target: "actions.output" },
+      createArtifactAction(
+        session,
+        "actions.output",
+        new Uint8Array([1]),
+      ),
+      async () => ({ byteLength: 1, height: 1, width: 1 }),
+      {
+        expectedSize: { height: 1, width: 1 },
+        requirementId: "canvas.infinity.image-export",
+      },
+    ),
+  );
+  await assert.rejects(
+    facade.expectToolcraftInfinityCanvasUnavailableImageExportEvidence(
+      fixture,
+      createArtifactAction(
+        createSession(),
+        "canvas.infinity",
+        new Uint8Array([1]),
+      ),
       async () => ({ byteLength: 1, height: 1, width: 1 }),
       {
         expectedSize: { height: 1, width: 1 },
         requirementId: "canvas.infinity.image-export",
       },
     ),
+    /same browser proof session/u,
   );
-  assert.equal(globalThis.__toolcraftUnavailableEvidenceActionCalls, 0);
-  assert.deepEqual(globalThis.__toolcraftUnavailableEvidenceAttachments, []);
+  assert.equal(getHarnessState().actionCalls, 0);
+  assert.deepEqual(getHarnessState().attachments, []);
 });

package/templates/starter/scripts/toolcraft-verification-inventory.mjs

@@ -5,6 +5,7 @@ import path from "node:path";
 const ignoredDirectoryNames = new Set([
   ".agents",
   ".git",
+  ".playwright-mcp",
   ".toolcraft",
   ".vite",
   "coverage",

package/templates/starter/scripts/toolcraft-verification-receipt.test.mjs

@@ -193,6 +193,57 @@ test("ignores workflow skills, generated output, and checkpoint directories thro
   );
 });
 
+test("ignores browser-tool artifact create change and delete", async (t) => {
+  const rootDir = await createRootWideInventoryFixture();
+  t.after(() => fs.rm(rootDir, { force: true, recursive: true }));
+  const baseline = await collectToolcraftVerificationInputs(rootDir);
+  const browserArtifact = path.join(
+    rootDir,
+    ".playwright-mcp",
+    "nested",
+    "page.yml",
+  );
+
+  for (const content of ["page: initial\n", "page: updated\n"]) {
+    await fs.mkdir(path.dirname(browserArtifact), { recursive: true });
+    await fs.writeFile(browserArtifact, content);
+    const current = await collectToolcraftVerificationInputs(rootDir);
+
+    assert.equal(current.sourceHash, baseline.sourceHash);
+    assert.deepEqual(
+      getToolcraftChangedVerificationFiles(baseline.entries, current.entries),
+      [],
+    );
+  }
+
+  await fs.rm(path.join(rootDir, ".playwright-mcp"), {
+    force: true,
+    recursive: true,
+  });
+  const current = await collectToolcraftVerificationInputs(rootDir);
+
+  assert.equal(current.sourceHash, baseline.sourceHash);
+  assert.deepEqual(
+    getToolcraftChangedVerificationFiles(baseline.entries, current.entries),
+    [],
+  );
+});
+
+test("continues to hash real product raster assets", async (t) => {
+  const rootDir = await createRootWideInventoryFixture();
+  t.after(() => fs.rm(rootDir, { force: true, recursive: true }));
+  const baseline = await collectToolcraftVerificationInputs(rootDir);
+
+  await fs.writeFile(path.join(rootDir, "public", "source.png"), "updated-source-image");
+  const current = await collectToolcraftVerificationInputs(rootDir);
+
+  assert.notEqual(current.sourceHash, baseline.sourceHash);
+  assert.deepEqual(
+    getToolcraftChangedVerificationFiles(baseline.entries, current.entries),
+    ["public/source.png"],
+  );
+});
+
 test("does not report legacy workflow-skill receipt entries as product changes", async (t) => {
   const rootDir = await createRootWideInventoryFixture();
   t.after(() => fs.rm(rootDir, { force: true, recursive: true }));