@pixel-point/toolcraft 0.0.17 → 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/condition-exclusivity.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { areToolcraftConditionsProvablyExclusive } from "./condition-exclusivity";
-
-describe("Toolcraft condition exclusivity", () => {
-  it("proves disjoint finite value gates", () => {
-    expect(
-      areToolcraftConditionsProvablyExclusive(
-        { equals: "first", target: "model.active" },
-        { equals: "second", target: "model.active" },
-      ),
-    ).toBe(true);
-    expect(
-      areToolcraftConditionsProvablyExclusive(
-        { oneOf: ["first", "second"], target: "model.active" },
-        { equals: "second", target: "model.active" },
-      ),
-    ).toBe(false);
-    expect(
-      areToolcraftConditionsProvablyExclusive(
-        { notEquals: "hidden", target: "model.active" },
-        { equals: "second", target: "model.active" },
-      ),
-    ).toBe(false);
-  });
-
-  it("proves non-overlapping numeric intervals without guessing across targets", () => {
-    expect(
-      areToolcraftConditionsProvablyExclusive(
-        { lessThan: 0, target: "model.index" },
-        { greaterThanOrEqual: 0, target: "model.index" },
-      ),
-    ).toBe(true);
-    expect(
-      areToolcraftConditionsProvablyExclusive(
-        { equals: "first", target: "first.mode" },
-        { equals: "second", target: "second.mode" },
-      ),
-    ).toBe(false);
-  });
-
-  it("stays conservative for primitive JSON collisions and invalid numeric bounds", () => {
-    expect(
-      areToolcraftConditionsProvablyExclusive(
-        { equals: Number.NaN, target: "model.mode" },
-        { notEquals: null, target: "model.mode" },
-      ),
-    ).toBe(false);
-    expect(
-      areToolcraftConditionsProvablyExclusive(
-        {
-          equals: 1,
-          greaterThan: Number.NaN,
-          target: "model.mode",
-        },
-        { equals: 1, target: "model.mode" },
-      ),
-    ).toBe(false);
-  });
-});

package/templates/starter/src/app/acceptance/condition-exclusivity.ts

@@ -1,221 +0,0 @@
-import type { ToolcraftControlConditionSchema } from "@repo/toolcraft-runtime";
-
-function valuesEqual(left: unknown, right: unknown): boolean {
-  if (Object.is(left, right)) {
-    return true;
-  }
-
-  if (
-    (typeof left !== "object" || left === null) &&
-    (typeof right !== "object" || right === null)
-  ) {
-    return false;
-  }
-
-  try {
-    return JSON.stringify(left) === JSON.stringify(right);
-  } catch {
-    return false;
-  }
-}
-
-function readComparableNumber(value: unknown): number | null {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-
-  if (typeof value === "string") {
-    const numberValue = Number(value.trim());
-
-    return Number.isFinite(numberValue) ? numberValue : null;
-  }
-
-  return null;
-}
-
-function conditionMatchesValue(
-  condition: ToolcraftControlConditionSchema,
-  value: unknown,
-): boolean {
-  const matches: boolean[] = [];
-
-  if ("equals" in condition) {
-    matches.push(valuesEqual(value, condition.equals));
-  }
-  if ("notEquals" in condition) {
-    matches.push(!valuesEqual(value, condition.notEquals));
-  }
-  if (condition.oneOf) {
-    matches.push(condition.oneOf.some((item) => valuesEqual(value, item)));
-  }
-  if (condition.notOneOf) {
-    matches.push(!condition.notOneOf.some((item) => valuesEqual(value, item)));
-  }
-
-  const numberValue = readComparableNumber(value);
-  for (const [expected, compare] of [
-    [condition.greaterThan, (left: number, right: number) => left > right],
-    [
-      condition.greaterThanOrEqual,
-      (left: number, right: number) => left >= right,
-    ],
-    [condition.lessThan, (left: number, right: number) => left < right],
-    [
-      condition.lessThanOrEqual,
-      (left: number, right: number) => left <= right,
-    ],
-  ] as const) {
-    if (typeof expected === "number" && Number.isFinite(expected)) {
-      matches.push(numberValue !== null && compare(numberValue, expected));
-    }
-  }
-
-  return matches.length > 0 && matches.every(Boolean);
-}
-
-function getFiniteConditionValues(
-  condition: ToolcraftControlConditionSchema,
-): readonly unknown[] | null {
-  const candidates =
-    "equals" in condition
-      ? [condition.equals]
-      : condition.oneOf
-        ? [...condition.oneOf]
-        : null;
-
-  return candidates?.filter((value) => conditionMatchesValue(condition, value)) ?? null;
-}
-
-type NumericBoundary = {
-  inclusive: boolean;
-  value: number;
-};
-
-type NumericInterval = {
-  lower: NumericBoundary | null;
-  upper: NumericBoundary | null;
-};
-
-function stricterLowerBoundary(
-  current: NumericBoundary | null,
-  candidate: NumericBoundary,
-): NumericBoundary {
-  if (
-    !current ||
-    candidate.value > current.value ||
-    (candidate.value === current.value && !candidate.inclusive)
-  ) {
-    return candidate;
-  }
-
-  return current;
-}
-
-function stricterUpperBoundary(
-  current: NumericBoundary | null,
-  candidate: NumericBoundary,
-): NumericBoundary {
-  if (
-    !current ||
-    candidate.value < current.value ||
-    (candidate.value === current.value && !candidate.inclusive)
-  ) {
-    return candidate;
-  }
-
-  return current;
-}
-
-function getNumericInterval(
-  condition: ToolcraftControlConditionSchema,
-): NumericInterval | null {
-  let lower: NumericBoundary | null = null;
-  let upper: NumericBoundary | null = null;
-
-  if (condition.greaterThan !== undefined) {
-    lower = stricterLowerBoundary(lower, {
-      inclusive: false,
-      value: condition.greaterThan,
-    });
-  }
-  if (condition.greaterThanOrEqual !== undefined) {
-    lower = stricterLowerBoundary(lower, {
-      inclusive: true,
-      value: condition.greaterThanOrEqual,
-    });
-  }
-  if (condition.lessThan !== undefined) {
-    upper = stricterUpperBoundary(upper, {
-      inclusive: false,
-      value: condition.lessThan,
-    });
-  }
-  if (condition.lessThanOrEqual !== undefined) {
-    upper = stricterUpperBoundary(upper, {
-      inclusive: true,
-      value: condition.lessThanOrEqual,
-    });
-  }
-
-  return lower || upper ? { lower, upper } : null;
-}
-
-function intervalEndsBefore(
-  upper: NumericBoundary | null,
-  lower: NumericBoundary | null,
-): boolean {
-  if (!upper || !lower) {
-    return false;
-  }
-
-  return (
-    upper.value < lower.value ||
-    (upper.value === lower.value && (!upper.inclusive || !lower.inclusive))
-  );
-}
-
-export function areToolcraftConditionsProvablyExclusive(
-  left: ToolcraftControlConditionSchema,
-  right: ToolcraftControlConditionSchema,
-): boolean {
-  if (left.target !== right.target) {
-    return false;
-  }
-
-  const leftValues = getFiniteConditionValues(left);
-  if (
-    leftValues &&
-    leftValues.every((value) => !conditionMatchesValue(right, value))
-  ) {
-    return true;
-  }
-
-  const rightValues = getFiniteConditionValues(right);
-  if (
-    rightValues &&
-    rightValues.every((value) => !conditionMatchesValue(left, value))
-  ) {
-    return true;
-  }
-
-  const leftInterval = getNumericInterval(left);
-  const rightInterval = getNumericInterval(right);
-
-  return Boolean(
-    leftInterval &&
-      rightInterval &&
-      (intervalEndsBefore(leftInterval.upper, rightInterval.lower) ||
-        intervalEndsBefore(rightInterval.upper, leftInterval.lower)),
-  );
-}
-
-export function areToolcraftConditionSetsProvablyExclusive(
-  left: readonly ToolcraftControlConditionSchema[],
-  right: readonly ToolcraftControlConditionSchema[],
-): boolean {
-  return left.some((leftCondition) =>
-    right.some((rightCondition) =>
-      areToolcraftConditionsProvablyExclusive(leftCondition, rightCondition),
-    ),
-  );
-}