@pixel-point/toolcraft 0.0.18 → 0.0.19

package/templates/starter/scripts/toolcraft-verification-input-roles.test.mjs

@@ -1,225 +0,0 @@
-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 { createToolcraftLocalDependencyGraph } from "./toolcraft-local-dependency-graph.mjs";
-import { collectToolcraftSourceInventory } from "./toolcraft-source-inventory.mjs";
-import {
-  classifyToolcraftVerificationInputRoles,
-  toolcraftVerificationInputRootFamilies,
-} from "./toolcraft-verification-input-roles.mjs";
-
-async function writeFixture(
-  t,
-  familyName = "generated",
-  extraFiles = {},
-) {
-  const rootDir = await fs.mkdtemp(
-    path.join(os.tmpdir(), "toolcraft-verification-roles-"),
-  );
-  t.after(() => fs.rm(rootDir, { force: true, recursive: true }));
-  const family = toolcraftVerificationInputRootFamilies[familyName];
-  const files = {
-    [family.compositionPath]:
-      "import '../features/output.tsx'; import '../features/shared.ts';\n",
-    [family.schemaPath]: "export const schema = true;\n",
-    [family.acceptanceDataPath]:
-      "import './acceptance/reference.ts'; import '../features/shared.ts';\n",
-    [family.performancePath]:
-      "import './performance/reference.ts';\n",
-    [family.impactInventoryPath]: "{\"owners\":[],\"version\":3}\n",
-    "src/app/acceptance/reference.ts": "export const acceptance = true;\n",
-    "src/app/performance/reference.ts": "export const performance = true;\n",
-    "src/features/output.tsx":
-      "import './shared.ts'; import './surface.module.css'; export const output = true;\n",
-    "src/features/shared.ts": "export const shared = true;\n",
-    "src/features/surface.module.css":
-      ".surface { background: url('./material.png'); }\n",
-    "src/features/material.png": "texture\n",
-    "src/features/output.test.tsx":
-      "import './test-utils.ts'; import './output.tsx';\n",
-    "src/features/test-utils.ts": "export const support = true;\n",
-    "e2e/product-material.spec.ts":
-      "import './shared-browser-helper.ts';\n",
-    "e2e/shared-browser-helper.ts": "export const browser = true;\n",
-    "public/material.glb": "model\n",
-    ...extraFiles,
-  };
-  for (const [repoPath, contents] of Object.entries(files)) {
-    const absolutePath = path.join(rootDir, repoPath);
-    await fs.mkdir(path.dirname(absolutePath), { recursive: true });
-    await fs.writeFile(absolutePath, contents);
-  }
-  const sourceInventory = await collectToolcraftSourceInventory({
-    includeResourceFiles: true,
-    rootDir,
-    sourceRoots: ["src", "e2e", "public"],
-  });
-  const graph = await createToolcraftLocalDependencyGraph({
-    aliases: [
-      { prefix: "@/", replacement: path.join(rootDir, "src") },
-      { prefix: "#/", replacement: path.join(rootDir, "src") },
-    ],
-    entries: sourceInventory.entries,
-    rootDir,
-  });
-  return { graph, rootDir, sourceInventory };
-}
-
-function normalizeFamilyPaths(paths, family) {
-  const labelsByPath = new Map([
-    [family.acceptanceDataPath, "root:acceptance-data"],
-    [family.compositionPath, "root:composition"],
-    [family.impactInventoryPath, "root:verification-impact"],
-    [family.performancePath, "root:performance"],
-    [family.schemaPath, "root:schema"],
-  ]);
-  return paths.map((repoPath) => labelsByPath.get(repoPath) ?? repoPath);
-}
-
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
-
-test("classifies runtime, proof, tests, support, and resources from one graph", async (t) => {
-  const { graph } = await writeFixture(t);
-  const roles = classifyToolcraftVerificationInputRoles(graph);
-
-  assert.equal(roles.rootFamily, "generated");
-  assert.equal(
-    roles.roleByPath["src/features/output.tsx"],
-    "runtime-production",
-  );
-  assert.equal(
-    roles.roleByPath["src/app/acceptance/reference.ts"],
-    "proof-model",
-  );
-  assert.equal(
-    roles.roleByPath["src/app/performance/reference.ts"],
-    "proof-model",
-  );
-  assert.equal(
-    roles.roleByPath["src/features/shared.ts"],
-    "runtime-production",
-  );
-  assert.equal(
-    roles.roleByPath["src/features/output.test.tsx"],
-    "product-test",
-  );
-  assert.equal(
-    roles.roleByPath["src/features/test-utils.ts"],
-    "product-test",
-  );
-  assert.equal(
-    roles.roleByPath["e2e/product-material.spec.ts"],
-    "product-test",
-  );
-  assert.equal(
-    roles.roleByPath["e2e/shared-browser-helper.ts"],
-    "product-test",
-  );
-  for (const resourcePath of [
-    "public/material.glb",
-    "src/features/material.png",
-    "src/features/surface.module.css",
-  ]) {
-    assert.equal(roles.roleByPath[resourcePath], "product-resource");
-  }
-  assert.equal(
-    roles.roleByPath["src/app/app-verification-impact.json"],
-    "proof-model",
-  );
-  assert.deepEqual(roles.semanticProofRootPaths, [
-    "src/app/app-acceptance-data.ts",
-    "src/app/app-performance.ts",
-    "src/app/app-verification-impact.json",
-  ]);
-  assert.equal(Object.isFrozen(roles), true);
-  assert.equal(Object.isFrozen(roles.roleByPath), true);
-  assert.equal(Object.isFrozen(roles.runtimeProductionPaths), true);
-  assert.equal(Object.isFrozen(roles.semanticProofRootPaths), true);
-});
-
-test("classifies starter and generated canonical families identically", async (t) => {
-  const generated = classifyToolcraftVerificationInputRoles(
-    (await writeFixture(t, "generated")).graph,
-  );
-  const starter = classifyToolcraftVerificationInputRoles(
-    (await writeFixture(t, "starter")).graph,
-  );
-  const families = toolcraftVerificationInputRootFamilies;
-
-  assert.equal(starter.rootFamily, "starter");
-  for (const key of [
-    "runtimeProductionPaths",
-    "proofModelPaths",
-    "productTestPaths",
-    "productResourcePaths",
-    "semanticProofRootPaths",
-  ]) {
-    assert.deepEqual(
-      normalizeFamilyPaths(starter[key], families.starter).sort(),
-      normalizeFamilyPaths(generated[key], families.generated).sort(),
-    );
-  }
-});
-
-test("rejects partial and mixed root families with exact paths", async (t) => {
-  const partial = await writeFixture(t);
-  const families = toolcraftVerificationInputRootFamilies;
-  await fs.rm(path.join(partial.rootDir, families.generated.performancePath));
-  const partialInventory = await collectToolcraftSourceInventory({
-    includeResourceFiles: true,
-    rootDir: partial.rootDir,
-    sourceRoots: ["src", "e2e", "public"],
-  });
-  const partialGraph = await createToolcraftLocalDependencyGraph({
-    entries: partialInventory.entries,
-    rootDir: partial.rootDir,
-  });
-  assert.throws(
-    () => classifyToolcraftVerificationInputRoles(partialGraph),
-    new RegExp(
-      `partial.*${escapeRegExp(families.generated.performancePath)}`,
-      "iu",
-    ),
-  );
-
-  const mixed = await writeFixture(t, "generated", {
-    [families.starter.compositionPath]:
-      "export const mixed = true;\n",
-  });
-  assert.throws(
-    () => classifyToolcraftVerificationInputRoles(mixed.graph),
-    new RegExp(
-      `mixed.*${escapeRegExp(families.starter.compositionPath)}`,
-      "iu",
-    ),
-  );
-});
-
-test("rejects an orphan product production module by exact path", async (t) => {
-  const { graph } = await writeFixture(t, "generated", {
-    "src/features/orphan.ts": "export const orphan = true;\n",
-  });
-  assert.throws(
-    () => classifyToolcraftVerificationInputRoles(graph),
-    /orphaned product production module "src\/features\/orphan\.ts"/iu,
-  );
-});
-
-test("rejects production code reachable only from product tests", async (t) => {
-  const { graph } = await writeFixture(t, "generated", {
-    "src/features/orphan-module.ts":
-      "export const testOnlyProduction = true;\n",
-    "src/features/output.test.tsx":
-      "import './test-utils.ts'; import './orphan-module.ts';\n",
-  });
-
-  assert.throws(
-    () => classifyToolcraftVerificationInputRoles(graph),
-    /orphaned product production module "src\/features\/orphan-module\.ts"/iu,
-  );
-});

package/templates/starter/src/app/acceptance/video-reference-study.ts

@@ -1,217 +0,0 @@
-import type {
-  ToolcraftComponentAcceptance,
-  ToolcraftTransferMode,
-  ToolcraftVideoReferenceStudyEvidence,
-} from "./types";
-
-export const videoReferenceEvidencePattern =
-  /\b(?:reference\s+(?:video|gif)|screen\s*recording|contact[-\s]*sheet|storyboard|frame[-\s]*by[-\s]*frame|extracted[-\s]*frames?|ffprobe)\b|(?:^|[\\/"'\s])[^\\/"'\s]+\.(?:mp4|mov|webm|gif)\b/i;
-
-function getToolcraftTransferModeEvidenceText(
-  transferMode: ToolcraftTransferMode,
-): string {
-  return JSON.stringify(transferMode);
-}
-
-export function getToolcraftVideoReferenceStudyErrors({
-  acceptance,
-  transferMode,
-}: {
-  acceptance: readonly ToolcraftComponentAcceptance[];
-  transferMode: ToolcraftTransferMode;
-}): string[] {
-  const errors: string[] = [];
-  const transferModeEvidenceText = getToolcraftTransferModeEvidenceText(transferMode);
-
-  if (
-    videoReferenceEvidencePattern.test(transferModeEvidenceText) &&
-    !transferMode.videoReferenceStudy
-  ) {
-    errors.push(
-      "starterTransferMode cites a video reference, screen recording, GIF, extracted frames, or contact sheet; declare videoReferenceStudy with storyboard frames, frame-to-frame transition analysis, behavior decomposition, and acceptance mapping before implementation.",
-    );
-  }
-
-  if (transferMode.videoReferenceStudy) {
-    errors.push(
-      ...validateToolcraftVideoReferenceStudy(
-        transferMode.videoReferenceStudy,
-        acceptance,
-      ),
-    );
-  }
-
-  return errors;
-}
-
-export function validateToolcraftVideoReferenceStudy(
-  study: ToolcraftVideoReferenceStudyEvidence,
-  acceptance: readonly ToolcraftComponentAcceptance[],
-): string[] {
-  const errors: string[] = [];
-  const acceptanceById = new Map(acceptance.map((entry) => [entry.id, entry]));
-  const frameIds = new Set<string>();
-
-  if (!study.referenceLocation.trim()) {
-    errors.push(
-      "videoReferenceStudy.referenceLocation must name the inspected video, GIF, screen recording, contact sheet, or extracted-frame folder.",
-    );
-  }
-
-  if (!study.extractionEvidence.trim()) {
-    errors.push(
-      "videoReferenceStudy.extractionEvidence must explain how frames were inspected or extracted before implementation.",
-    );
-  }
-
-  if (!study.behaviorDecomposition.trim()) {
-    errors.push(
-      "videoReferenceStudy.behaviorDecomposition must decompose the observed frame-to-frame changes into product behavior to preserve.",
-    );
-  }
-
-  if (study.storyboard.length < 4) {
-    errors.push(
-      "videoReferenceStudy.storyboard must include at least four timecoded frames so the reference is studied as motion, not a single screenshot.",
-    );
-  }
-
-  for (const [index, frame] of study.storyboard.entries()) {
-    const frameLabel = frame.frameId.trim() || `#${index + 1}`;
-
-    if (!frame.frameId.trim()) {
-      errors.push(`videoReferenceStudy.storyboard frame ${index + 1} must include a stable frameId.`);
-    } else if (frameIds.has(frame.frameId)) {
-      errors.push(
-        `videoReferenceStudy.storyboard frameId "${frame.frameId}" is duplicated; each sampled frame needs a stable id.`,
-      );
-    } else {
-      frameIds.add(frame.frameId);
-    }
-
-    if (!Number.isFinite(frame.timeSeconds) || frame.timeSeconds < 0) {
-      errors.push(
-        `videoReferenceStudy.storyboard "${frameLabel}" must include a non-negative finite timeSeconds value.`,
-      );
-    }
-
-    if (!frame.frameSource.trim()) {
-      errors.push(
-        `videoReferenceStudy.storyboard "${frameLabel}" must cite the frame image, contact sheet cell, or source timecode inspected.`,
-      );
-    }
-
-    if (!frame.visualObservation.trim()) {
-      errors.push(
-        `videoReferenceStudy.storyboard "${frameLabel}" must describe the visible frame state.`,
-      );
-    }
-
-    if (!frame.behaviorObservation.trim()) {
-      errors.push(
-        `videoReferenceStudy.storyboard "${frameLabel}" must describe the behavior inferred from that frame.`,
-      );
-    }
-  }
-
-  if (study.transitionAnalysis.length < 3) {
-    errors.push(
-      "videoReferenceStudy.transitionAnalysis must include at least three frame-to-frame deltas proving how behavior changes between sampled frames.",
-    );
-  }
-
-  for (const [index, transition] of study.transitionAnalysis.entries()) {
-    const transitionLabel = transition.id.trim() || `#${index + 1}`;
-
-    if (!transition.id.trim()) {
-      errors.push(
-        `videoReferenceStudy.transitionAnalysis item ${index + 1} must include a stable id.`,
-      );
-    }
-
-    if (!frameIds.has(transition.fromFrameId)) {
-      errors.push(
-        `videoReferenceStudy.transitionAnalysis "${transitionLabel}" fromFrameId "${transition.fromFrameId}" must point to a storyboard frameId.`,
-      );
-    }
-
-    if (!frameIds.has(transition.toFrameId)) {
-      errors.push(
-        `videoReferenceStudy.transitionAnalysis "${transitionLabel}" toFrameId "${transition.toFrameId}" must point to a storyboard frameId.`,
-      );
-    }
-
-    if (!transition.behaviorDelta.trim()) {
-      errors.push(
-        `videoReferenceStudy.transitionAnalysis "${transitionLabel}" must describe the behavior delta between frames.`,
-      );
-    }
-  }
-
-  if (study.acceptanceMapping.length === 0) {
-    errors.push(
-      "videoReferenceStudy.acceptanceMapping must map observed video behaviors to acceptance rows.",
-    );
-  }
-
-  for (const [index, mapping] of study.acceptanceMapping.entries()) {
-    const mappingLabel = mapping.behavior.trim() || `#${index + 1}`;
-
-    if (!mapping.behavior.trim()) {
-      errors.push(
-        `videoReferenceStudy.acceptanceMapping item ${index + 1} must name the observed behavior.`,
-      );
-    }
-
-    if (mapping.frameIds.length === 0) {
-      errors.push(
-        `videoReferenceStudy.acceptanceMapping "${mappingLabel}" must cite storyboard frameIds that prove the behavior.`,
-      );
-    }
-
-    for (const frameId of mapping.frameIds) {
-      if (!frameIds.has(frameId)) {
-        errors.push(
-          `videoReferenceStudy.acceptanceMapping "${mappingLabel}" frameId "${frameId}" must point to a storyboard frameId.`,
-        );
-      }
-    }
-
-    const acceptanceId = mapping.acceptanceId.trim();
-    const entry = acceptanceById.get(acceptanceId);
-
-    if (!acceptanceId) {
-      errors.push(
-        `videoReferenceStudy.acceptanceMapping "${mappingLabel}" must include acceptanceId for the test proving the copied behavior.`,
-      );
-      continue;
-    }
-
-    if (!entry) {
-      errors.push(
-        `videoReferenceStudy.acceptanceMapping "${mappingLabel}" points to missing acceptanceId "${acceptanceId}".`,
-      );
-      continue;
-    }
-
-    if (!entry.automated || !entry.automatedTestName.trim()) {
-      errors.push(
-        `${acceptanceId} must have automated coverage proving video reference behavior "${mappingLabel}".`,
-      );
-    }
-
-    if (!entry.browser || !entry.browserTestName.trim()) {
-      errors.push(
-        `${acceptanceId} must have browser coverage proving video reference behavior "${mappingLabel}".`,
-      );
-    }
-
-    if (!entry.expectedObservable.trim()) {
-      errors.push(
-        `${acceptanceId} must describe the observable result for video reference behavior "${mappingLabel}".`,
-      );
-    }
-  }
-
-  return errors;
-}

package/templates/starter/src/app/starter-verification-impact.json

@@ -1,15 +0,0 @@
-{
-  "version": 3,
-  "owners": [
-    {
-      "acceptanceIds": ["persistence.reload"],
-      "kind": "functional",
-      "path": "src/app/starter-composition.tsx"
-    },
-    {
-      "acceptanceIds": ["persistence.reload"],
-      "kind": "functional",
-      "path": "src/app/starter-schema.ts"
-    }
-  ]
-}