@pixel-point/toolcraft 0.0.13 → 0.0.15

package/templates/starter/scripts/toolcraft-product-boundary.mjs

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { collectToolcraftFrameworkOwnedLocalPaths } from "./toolcraft-source-ownership.mjs";
+import { collectToolcraftSourceInventory } from "./toolcraft-source-inventory.mjs";
+
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+async function resolveProtectedFilePaths(rootDir, protectedFilePaths) {
+  if (protectedFilePaths) return [...protectedFilePaths];
+
+  return collectToolcraftFrameworkOwnedLocalPaths(rootDir);
+}
+
+export async function evaluateToolcraftProductBoundary({
+  allowMissingCompiler = false,
+  protectedFilePaths,
+  rootDir,
+} = {}) {
+  const resolvedRootDir =
+    rootDir ?? path.resolve(fileURLToPath(new URL("..", import.meta.url)));
+  const inventory = await collectToolcraftSourceInventory({
+    protectedFilePaths: await resolveProtectedFilePaths(
+      resolvedRootDir,
+      protectedFilePaths,
+    ),
+    rootDir: resolvedRootDir,
+    sourceRoots: ["src", "e2e"],
+  });
+  const productEntries = inventory.entries.filter(
+    (entry) => entry.owner === "product" && entry.role === "production",
+  );
+  const violations = [];
+  let collectToolcraftModuleSpecifiers;
+  let inspectToolcraftProductCss;
+  let inspectToolcraftProductSource;
+  let inspectToolcraftModuleLoading;
+  let inspectToolcraftReservedEvidenceAccess;
+
+  try {
+    ({
+      collectToolcraftModuleSpecifiers,
+      inspectToolcraftProductCss,
+      inspectToolcraftProductSource,
+    } = await import("./toolcraft-product-boundary-ast.mjs"));
+    ({
+      inspectToolcraftModuleLoading,
+      inspectToolcraftReservedEvidenceAccess,
+    } = await import("./toolcraft-product-evidence-boundary-ast.mjs"));
+  } catch (error) {
+    const isMissingTypeScript =
+      error?.code === "ERR_MODULE_NOT_FOUND" &&
+      String(error.message).includes("package 'typescript'");
+    if (!allowMissingCompiler || !isMissingTypeScript) throw error;
+
+    return {
+      filesystemViolations: inventory.filesystemViolations,
+      productSourceCount: productEntries.length,
+      skippedReason:
+        "TypeScript is not installed; product AST boundary validation is deferred until dependencies are installed.",
+      violations: [],
+    };
+  }
+
+  const entryByAbsolutePath = new Map(
+    inventory.entries.map((entry) => [path.resolve(entry.absolutePath), entry]),
+  );
+  const moduleExtensions = [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".css",
+  ];
+
+  function resolveLocalEntry(entry, moduleSpecifier) {
+    let basePath;
+    if (moduleSpecifier.startsWith("@/") || moduleSpecifier.startsWith("#/")) {
+      basePath = path.resolve(resolvedRootDir, "src", moduleSpecifier.slice(2));
+    } else if (moduleSpecifier.startsWith("/")) {
+      basePath = path.resolve(resolvedRootDir, moduleSpecifier.slice(1));
+    } else if (moduleSpecifier.startsWith(".")) {
+      basePath = path.resolve(path.dirname(entry.absolutePath), moduleSpecifier);
+    } else {
+      return {};
+    }
+
+    const candidates = [
+      basePath,
+      ...moduleExtensions.map((extension) => `${basePath}${extension}`),
+      ...moduleExtensions.map((extension) => path.join(basePath, `index${extension}`)),
+    ];
+    const importedEntry = candidates
+      .map((candidate) => entryByAbsolutePath.get(candidate))
+      .find(Boolean);
+    const unscannedSourcePath = importedEntry
+      ? undefined
+      : candidates.find(
+          (candidate) =>
+            moduleExtensions.includes(path.extname(candidate)) &&
+            fs.existsSync(candidate) &&
+            fs.statSync(candidate).isFile(),
+        );
+
+    return { importedEntry, unscannedSourcePath };
+  }
+
+  for (const entry of productEntries) {
+    if (/\.css$/u.test(entry.repoPath)) {
+      violations.push(
+        ...inspectToolcraftProductCss({
+          ...entry,
+          rawSource: await fsPromises.readFile(entry.absolutePath, "utf8"),
+        }),
+      );
+      continue;
+    }
+    if (!/\.[cm]?[jt]sx?$/u.test(entry.repoPath)) continue;
+    const rawSource = await fsPromises.readFile(entry.absolutePath, "utf8");
+    violations.push(
+      ...inspectToolcraftProductSource({
+        ...entry,
+        rawSource,
+        rootDir: resolvedRootDir,
+      }),
+      ...inspectToolcraftReservedEvidenceAccess({
+        ...entry,
+        rawSource,
+      }),
+    );
+    for (const moduleSpecifier of collectToolcraftModuleSpecifiers({
+      ...entry,
+      rawSource,
+    })) {
+      const { importedEntry, unscannedSourcePath } = resolveLocalEntry(
+        entry,
+        moduleSpecifier,
+      );
+      if (unscannedSourcePath) {
+        violations.push({
+          column: 1,
+          kind: "source-boundary-escape",
+          line: 1,
+          message: `Product production source must stay under the scanned src boundary. Move ${path.relative(resolvedRootDir, unscannedSourcePath)} under src before importing it.`,
+          repoPath: entry.repoPath,
+        });
+      }
+      if (
+        importedEntry?.role === "test" ||
+        importedEntry?.role === "test-support" ||
+        /(?:^|\/)[^/]+\.(?:test|spec)(?:\.[cm]?[jt]sx?)?$/u.test(moduleSpecifier)
+      ) {
+        violations.push({
+          column: 1,
+          kind: "production-test-import",
+          line: 1,
+          message: `Production source must not import test or test-support module ${moduleSpecifier}. Move reusable product code into an explicit production module.`,
+          repoPath: entry.repoPath,
+        });
+      }
+    }
+  }
+
+  for (const entry of inventory.entries) {
+    if (
+      entry.owner !== "product" ||
+      (entry.role !== "test" && entry.role !== "test-support") ||
+      !/\.[cm]?[jt]sx?$/u.test(entry.repoPath)
+    ) {
+      continue;
+    }
+    const rawSource = await fsPromises.readFile(entry.absolutePath, "utf8");
+    violations.push(
+      ...inspectToolcraftReservedEvidenceAccess({
+        ...entry,
+        rawSource,
+      }),
+      ...inspectToolcraftModuleLoading({
+        ...entry,
+        rawSource,
+      }),
+    );
+  }
+
+  return {
+    filesystemViolations: inventory.filesystemViolations,
+    productSourceCount: productEntries.length,
+    violations: violations.sort(
+      (left, right) =>
+        compareCodeUnits(left.repoPath, right.repoPath) ||
+        left.line - right.line ||
+        left.column - right.column,
+    ),
+  };
+}
+
+export function printToolcraftProductBoundaryResult(result, logger = console) {
+  for (const violation of result.filesystemViolations) {
+    logger.error(`- ${violation.repoPath}: ${violation.reason}`);
+  }
+  for (const violation of result.violations) {
+    logger.error(
+      `- ${violation.repoPath}:${violation.line}:${violation.column}: ${violation.message}`,
+    );
+  }
+}
+
+export function toolcraftProductBoundaryPassed(result) {
+  return (
+    result.filesystemViolations.length === 0 && result.violations.length === 0
+  );
+}
+
+const scriptPath = fileURLToPath(import.meta.url);
+const isDirectExecution =
+  process.argv[1] &&
+  fs.realpathSync(path.resolve(process.argv[1])) === fs.realpathSync(scriptPath);
+
+if (isDirectExecution) {
+  const result = await evaluateToolcraftProductBoundary({
+    allowMissingCompiler: process.argv.includes("--allow-missing-compiler"),
+  });
+  if (!toolcraftProductBoundaryPassed(result)) {
+    console.error("Toolcraft product boundary check failed.");
+    printToolcraftProductBoundaryResult(result);
+    process.exitCode = 1;
+  } else {
+    console.log(
+      result.skippedReason ??
+        `Toolcraft product boundary check passed (${result.productSourceCount} product production files).`,
+    );
+  }
+}

package/templates/starter/scripts/toolcraft-product-boundary.test.mjs

@@ -0,0 +1,289 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { evaluateToolcraftProductBoundary } from "./toolcraft-product-boundary.mjs";
+import { createToolcraftProductBoundaryFixture as createFixture } from "./toolcraft-product-boundary-test-fixtures.mjs";
+
+test("accepts an open product composition and safe primitives", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/app/app-composition.tsx": `
+      import type { ToolcraftAppComposition } from "@/toolcraft/runtime/react";
+      import { Button } from "@/toolcraft/ui/primitives";
+      import { appSchema } from "../domain/schema";
+      export const appComposition: ToolcraftAppComposition = {
+        canvasContent: <Button>Render</Button>,
+        schema: appSchema,
+      };
+    `,
+    "src/domain/schema.ts": `
+      import { defineToolcraft } from "@/toolcraft/runtime/react";
+      export const appSchema = defineToolcraft({ id: "fixture", controls: [] });
+    `,
+    "src/main.tsx": `import { appComposition } from "./app/app-composition"; void appComposition;`,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({
+    protectedFilePaths: ["src/main.tsx"],
+    rootDir,
+  });
+
+  assert.deepEqual(result.violations, []);
+  assert.equal(result.productSourceCount, 2);
+});
+
+test("finds host surfaces outside src/app through aliases and sibling shells", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/product-shell.tsx": `
+      import { CanvasShell as ProductCanvasHost, ToolcraftApp } from "@/toolcraft/runtime/react/canvas/canvas-shell";
+      export function ProductShell() {
+        return <ToolcraftApp canvasContent={<ProductCanvasHost />} schema={schema} />;
+      }
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.deepEqual(
+    result.violations.map((violation) => violation.kind),
+    ["runtime-surface", "runtime-surface"],
+  );
+  assert.match(result.violations[0].message, /CanvasShell/u);
+  assert.match(result.violations[1].message, /ToolcraftApp/u);
+});
+
+test("checks Vite root-absolute imports against the same product boundary", async (context) => {
+  const rootDir = await createFixture(context, {
+    "outside-product.ts": "export const outsideProduct = true;\n",
+    "src/features/absolute-runtime.tsx": `
+      import { CanvasShell } from "/src/toolcraft/runtime/react";
+      export const canvas = <CanvasShell />;
+    `,
+    "src/features/fixture.test.ts": "export const fixture = true;\n",
+    "src/features/production.ts": `
+      import { fixture } from "/src/features/fixture.test";
+      import { outsideProduct } from "/outside-product";
+      void fixture;
+      void outsideProduct;
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.deepEqual(
+    result.violations.map((violation) => violation.kind),
+    ["runtime-surface", "production-test-import", "source-boundary-escape"],
+  );
+});
+
+test("finds built-in controls through re-exports, aliases, namespaces, and dynamic imports", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/control-bridge.ts": `
+      export { SliderControl as ProductSlider } from "@repo/ui/controls";
+      export { Color as ProductColor } from "@/toolcraft/ui";
+    `,
+    "src/features/dynamic.ts": `
+      export async function loadControls() {
+        return import("@/toolcraft/ui/components/controls/slider");
+      }
+    `,
+    "src/features/namespace.ts": `
+      import * as Controls from "@repo/ui";
+      export const Slider = Controls.Slider;
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.equal(result.violations.length, 4);
+  assert.equal(
+    result.violations.every((violation) => violation.kind === "built-in-control"),
+    true,
+  );
+});
+
+test("ignores tests but checks a product bridge imported by production", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/bridge.ts": `
+      export { TimelinePanel as ProductTimeline } from "@/toolcraft/runtime/react";
+    `,
+    "src/features/bridge.test.tsx": `
+      import { TimelinePanel } from "@/toolcraft/runtime/react";
+      void TimelinePanel;
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.equal(result.violations.length, 1);
+  assert.equal(result.violations[0].repoPath, "src/features/bridge.ts");
+});
+
+test("rejects production imports of tests through relative and source aliases", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/renderer.test.ts": "export const fixture = 1;\n",
+    "src/product/aliased.ts": `import { fixture } from "@/features/renderer.test"; void fixture;`,
+    "src/product/relative.ts": `export { fixture } from "../features/renderer.test";`,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.deepEqual(
+    result.violations.map((violation) => violation.kind),
+    ["production-test-import", "production-test-import"],
+  );
+});
+
+test("rejects product CSS that can restyle the signed host", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/package-style.ts": `import "some-library/global.css";`,
+    "src/features/package-style-module.ts": `import "some-library/theme.module.css";`,
+    "src/features/package-style-dynamic.ts": `
+      const themePath = "some-library/" + "theme.module.css";
+      export const loadTheme = () => import(themePath);
+    `,
+    "src/features/plain-style-dynamic.ts": `
+      export const loadStyles = () => import("./unsafe.css");
+    `,
+    "src/features/bare-selector.module.css": `
+      button, [data-slot="panel-title"] { display: none; }
+    `,
+    "src/features/external-import.module.css": `
+      @import "some-library/theme.css";
+      .preview { color: white; }
+    `,
+    "src/features/product.module.css": `.preview { color: white; }`,
+    "src/features/safe-descendant.module.css": `.preview > button { color: white; }`,
+    "src/features/safe-sibling.module.css": `.preview + .caption { color: white; }`,
+    "src/features/sibling-escape.module.css": `
+      .preview + [data-slot="panel-title"] { display: none; }
+    `,
+    "src/features/runtime-override.module.css": `:global([data-slot="toolcraft-runtime-app"]) { display: none; }`,
+    "src/features/safe-root-style.ts": `import "/src/features/product.module.css";`,
+    "src/features/unsafe-global.css": `.toolcraft-runtime-app { display: none; }`,
+    "src/features/unsupported-style.ts": `import "./theme.module.scss";`,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.deepEqual(
+    result.violations.map((violation) => violation.kind),
+    [
+      "product-global-css",
+      "product-global-css",
+      "product-global-css-import",
+      "product-global-css-import",
+      "product-global-css-import",
+      "product-global-css-import",
+      "product-global-css",
+      "product-global-css",
+      "product-global-css",
+      "product-global-css-import",
+    ],
+  );
+  assert.equal(
+    result.violations.some((violation) =>
+      violation.repoPath.endsWith("product.module.css"),
+    ),
+    false,
+  );
+  assert.equal(
+    result.violations.some((violation) =>
+      violation.repoPath.endsWith("safe-descendant.module.css"),
+    ),
+    false,
+  );
+  assert.equal(
+    result.violations.some((violation) =>
+      violation.repoPath.endsWith("safe-sibling.module.css"),
+    ),
+    false,
+  );
+});
+
+test("allows functional selectors only when every anchoring branch stays local", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/safe-is.module.css": `
+      :is(.preview, .card:hover) > button { color: white; }
+    `,
+    "src/features/safe-where.module.css": `
+      :where(.preview, :is(.card, .tile)) .label { color: white; }
+      .preview :is(button, .icon) { color: white; }
+      :where(.preview + .caption) { color: white; }
+    `,
+    "src/features/unsafe-has.module.css": `
+      :has(.preview) button { display: none; }
+    `,
+    "src/features/unsafe-is.module.css": `
+      :is(.preview, button) .label { display: none; }
+    `,
+    "src/features/unsafe-not.module.css": `
+      :not(.preview) button { display: none; }
+    `,
+    "src/features/unsafe-sibling.module.css": `
+      :where(.preview + button) { display: none; }
+    `,
+    "src/features/unsafe-where.module.css": `
+      :where(.preview, [data-slot="panel-title"]) { display: none; }
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.deepEqual(
+    result.violations.map((violation) => violation.repoPath),
+    [
+      "src/features/unsafe-has.module.css",
+      "src/features/unsafe-is.module.css",
+      "src/features/unsafe-not.module.css",
+      "src/features/unsafe-sibling.module.css",
+      "src/features/unsafe-where.module.css",
+    ],
+  );
+});
+
+test("rejects product source imported from outside the scanned source roots", async (context) => {
+  const rootDir = await createFixture(context, {
+    "outside-product.tsx": `
+      import { ToolcraftApp } from "@/toolcraft/runtime/react";
+      export const outsideProduct = ToolcraftApp;
+    `,
+    "src/app/app-composition.tsx": `
+      import { outsideProduct } from "../../outside-product";
+      export const appComposition = { canvasContent: outsideProduct };
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.deepEqual(
+    result.violations.map((violation) => violation.kind),
+    ["source-boundary-escape"],
+  );
+});
+
+test("rejects global style injection from product JSX", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/app/jsx-style.tsx": `
+      export const appComposition = {
+        canvasContent: <style>{"[data-toolcraft-canvas-world] { display: none; }"}</style>,
+      };
+    `,
+    "src/app/style-element.ts": `
+      export const styleElement = document.createElement("style");
+    `,
+    "src/app/stylesheet.ts": `
+      export const stylesheet = new CSSStyleSheet();
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.deepEqual(
+    result.violations.map((violation) => violation.kind),
+    [
+      "global-style-injection",
+      "global-style-injection",
+      "global-style-injection",
+    ],
+  );
+});

package/templates/starter/scripts/toolcraft-product-dependency-graph.mjs

@@ -0,0 +1,176 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+  collectToolcraftStaticModuleSpecifiers,
+  loadToolcraftLocalModuleAliases,
+  resolveToolcraftLocalDependency,
+  toolcraftModuleExtensions,
+} from "./toolcraft-product-dependency-resolution.mjs";
+
+export { loadToolcraftLocalModuleAliases };
+
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function toPosixPath(value) {
+  return value.split(path.sep).join("/");
+}
+
+function canonicalizeCycle(cycle) {
+  const nodes = cycle.slice(0, -1);
+  const rotations = nodes.map((_, index) => {
+    const rotated = [...nodes.slice(index), ...nodes.slice(0, index)];
+    return [...rotated, rotated[0]];
+  });
+  return rotations.sort((left, right) =>
+    compareCodeUnits(left.join("\0"), right.join("\0")),
+  )[0];
+}
+
+function findStronglyConnectedComponents(adjacency) {
+  const components = [];
+  const indexByNode = new Map();
+  const lowLinkByNode = new Map();
+  const stack = [];
+  const stacked = new Set();
+  let nextIndex = 0;
+
+  function visit(node) {
+    indexByNode.set(node, nextIndex);
+    lowLinkByNode.set(node, nextIndex);
+    nextIndex += 1;
+    stack.push(node);
+    stacked.add(node);
+
+    for (const dependency of adjacency.get(node) ?? []) {
+      if (!indexByNode.has(dependency)) {
+        visit(dependency);
+        lowLinkByNode.set(
+          node,
+          Math.min(lowLinkByNode.get(node), lowLinkByNode.get(dependency)),
+        );
+      } else if (stacked.has(dependency)) {
+        lowLinkByNode.set(
+          node,
+          Math.min(lowLinkByNode.get(node), indexByNode.get(dependency)),
+        );
+      }
+    }
+
+    if (lowLinkByNode.get(node) !== indexByNode.get(node)) return;
+    const component = [];
+    let member;
+    do {
+      member = stack.pop();
+      stacked.delete(member);
+      component.push(member);
+    } while (member !== node);
+    components.push(component.sort(compareCodeUnits));
+  }
+
+  for (const node of [...adjacency.keys()].sort(compareCodeUnits)) {
+    if (!indexByNode.has(node)) visit(node);
+  }
+  return components;
+}
+
+function reconstructCycle(predecessor, current, start) {
+  const reversed = [current];
+  while (reversed.at(-1) !== start) {
+    reversed.push(predecessor.get(reversed.at(-1)));
+  }
+  return canonicalizeCycle([...reversed.reverse(), start]);
+}
+
+function findShortestCycleInComponent(adjacency, component) {
+  const members = new Set(component);
+  let shortest;
+  for (const start of component) {
+    const queue = [start];
+    const predecessor = new Map([[start, null]]);
+    for (let cursor = 0; cursor < queue.length; cursor += 1) {
+      const current = queue[cursor];
+      for (const dependency of adjacency.get(current) ?? []) {
+        if (!members.has(dependency)) continue;
+        if (dependency === start) {
+          const candidate = reconstructCycle(predecessor, current, start);
+          if (
+            !shortest ||
+            candidate.length < shortest.length ||
+            (candidate.length === shortest.length &&
+              compareCodeUnits(candidate.join("\0"), shortest.join("\0")) < 0)
+          ) {
+            shortest = candidate;
+          }
+          continue;
+        }
+        if (!predecessor.has(dependency)) {
+          predecessor.set(dependency, current);
+          queue.push(dependency);
+        }
+      }
+    }
+  }
+  return shortest;
+}
+
+function findShortestCycles(adjacency) {
+  return findStronglyConnectedComponents(adjacency)
+    .filter(
+      (component) =>
+        component.length > 1 ||
+        (adjacency.get(component[0]) ?? []).includes(component[0]),
+    )
+    .map((component) => findShortestCycleInComponent(adjacency, component))
+    .filter(Boolean)
+    .sort((left, right) => compareCodeUnits(left.join("\0"), right.join("\0")));
+}
+
+export function getToolcraftProductDependencyCycleViolations({
+  aliases = [],
+  entries,
+  ignoredFilePatterns = [],
+  includedFilePatterns = [],
+  rootDir,
+}) {
+  const productionEntries = entries.filter(
+    (entry) =>
+      entry.owner === "product" &&
+      entry.role === "production" &&
+      toolcraftModuleExtensions.includes(path.extname(entry.repoPath)) &&
+      (includedFilePatterns.length === 0 ||
+        includedFilePatterns.some((pattern) => pattern.test(entry.repoPath))) &&
+      !ignoredFilePatterns.some((pattern) => pattern.test(entry.repoPath)),
+  );
+  const entryByAbsolutePath = new Map(
+    productionEntries.map((entry) => [path.resolve(entry.absolutePath), entry]),
+  );
+  const adjacency = new Map();
+
+  for (const entry of productionEntries) {
+    const dependencies = new Set();
+    const source = fs.readFileSync(entry.absolutePath, "utf8");
+    for (const specifier of collectToolcraftStaticModuleSpecifiers(
+      entry.absolutePath,
+      source,
+    )) {
+      const resolved = resolveToolcraftLocalDependency({
+        aliases,
+        entryByAbsolutePath,
+        importer: entry,
+        rootDir,
+        specifier,
+      });
+      if (resolved) dependencies.add(entryByAbsolutePath.get(resolved).repoPath);
+    }
+    adjacency.set(entry.repoPath, [...dependencies].sort(compareCodeUnits));
+  }
+
+  return findShortestCycles(adjacency).map((cycle) => ({
+    cycle: cycle.map(toPosixPath),
+    reason: "Product production modules must form an acyclic dependency graph.",
+    repoPath: cycle[0],
+  }));
+}