@pixel-point/toolcraft 0.0.17 → 0.0.19

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

@@ -0,0 +1,146 @@
+import ts from "typescript";
+
+import { createToolcraftUiInputBindingTracker } from "./toolcraft-product-control-bindings.mjs";
+
+const workspacePrivateControlModulePattern =
+  /^@repo\/ui\/(?:src\/)?(?:components\/controls(?:\/|$)|controls\/)/u;
+
+const forbiddenInputTypes = new Map([
+  ["checkbox", "checkbox or switch"],
+  ["color", "color or colorOpacity"],
+  ["file", "fileDrop"],
+  ["radio", "segmented or select"],
+  ["range", "slider or rangeSlider"],
+]);
+
+function normalizeSpecifier(value) {
+  return value.replaceAll("\\", "/");
+}
+
+export function isToolcraftPrivateControlImplementationModule({
+  moduleSpecifier,
+  resolvedSpecifier,
+}) {
+  const normalizedSpecifier = normalizeSpecifier(moduleSpecifier);
+  const normalizedResolvedSpecifier = resolvedSpecifier
+    ? normalizeSpecifier(resolvedSpecifier)
+    : "";
+
+  return (
+    workspacePrivateControlModulePattern.test(normalizedSpecifier) ||
+    /^[#@]\/toolcraft\/ui\/(?:components\/)?controls\//u.test(
+      normalizedSpecifier,
+    ) ||
+    /^[#@]\/toolcraft\/ui\/components\/controls(?:\/|$)/u.test(
+      normalizedSpecifier,
+    ) ||
+    /\/src\/toolcraft\/ui\/components\/controls(?:\/|$)/u.test(
+      normalizedResolvedSpecifier,
+    ) ||
+    /\/packages\/ui\/src\/components\/controls(?:\/|$)/u.test(
+      normalizedResolvedSpecifier,
+    )
+  );
+}
+
+function getJsxTagName(tagName) {
+  if (ts.isIdentifier(tagName)) return tagName.text;
+  if (ts.isPropertyAccessExpression(tagName)) return tagName.name.text;
+  return null;
+}
+
+export function createToolcraftProductControlInspector({
+  checker,
+  getNodeLocation,
+  repoPath,
+  resolveStaticString,
+  sourceFile,
+}) {
+  const { isTrackedInputTag } = createToolcraftUiInputBindingTracker({
+    checker,
+    resolveStaticString,
+  });
+
+  function createViolation(node, message) {
+    return {
+      ...getNodeLocation(sourceFile, node),
+      kind: "native-control-recreation",
+      message,
+      repoPath,
+    };
+  }
+
+  function getInputType(attributes) {
+    let inputType = "text";
+    for (const property of attributes.properties) {
+      if (ts.isJsxSpreadAttribute(property)) {
+        inputType = null;
+        continue;
+      }
+      if (!ts.isIdentifier(property.name) || property.name.text !== "type") {
+        continue;
+      }
+      if (!property.initializer) {
+        inputType = null;
+      } else if (ts.isStringLiteral(property.initializer)) {
+        inputType = property.initializer.text;
+      } else if (
+        ts.isJsxExpression(property.initializer) &&
+        property.initializer.expression
+      ) {
+        inputType = resolveStaticString(property.initializer.expression) ?? null;
+      } else {
+        inputType = null;
+      }
+    }
+    return inputType?.toLowerCase() ?? null;
+  }
+
+  function inspectNode(node) {
+    if (!ts.isJsxOpeningElement(node) && !ts.isJsxSelfClosingElement(node)) {
+      return [];
+    }
+
+    const tagName = getJsxTagName(node.tagName);
+    if (tagName === "select") {
+      return [
+        createViolation(
+          node.tagName,
+          "Product source must not recreate the built-in Select with a native <select>. Declare a select schema control.",
+        ),
+      ];
+    }
+    if (tagName === "textarea") {
+      return [
+        createViolation(
+          node.tagName,
+          "Product source must not recreate built-in text or code controls with a native <textarea>. Declare a text or code schema control.",
+        ),
+      ];
+    }
+
+    if (tagName !== "input" && !isTrackedInputTag(node.tagName)) return [];
+
+    const inputType = getInputType(node.attributes);
+    if (inputType === null) {
+      return [
+        createViolation(
+          node.tagName,
+          "Product Input type must be statically resolvable so the Toolcraft boundary can verify that it does not recreate a built-in control.",
+        ),
+      ];
+    }
+
+    const builtInSchemaType = forbiddenInputTypes.get(inputType);
+    if (!builtInSchemaType) return [];
+
+    return [
+      createViolation(
+        node.tagName,
+        `Product source must not recreate a built-in control with input type "${inputType}". Declare the built-in ${builtInSchemaType} schema control.`,
+      ),
+    ];
+  }
+
+  return { inspectNode };
+}

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

@@ -0,0 +1,186 @@
+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";
+
+const workspaceUiModule = ["@", "repo/ui"].join("");
+
+test("finds built-in controls through every module form", 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.deepEqual(
+    result.violations.map((violation) => violation.kind),
+    [
+      "built-in-control",
+      "built-in-control",
+      "built-in-control-implementation",
+      "built-in-control",
+    ],
+  );
+});
+
+test("rejects every deep import path into built-in control implementations", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/direct.tsx": `
+      import { ColorPickerPopover } from "@/toolcraft/ui/components/controls/color/color-picker-popover";
+      export const Direct = ColorPickerPopover;
+    `,
+    "src/features/directory-index.ts": `
+      import * as PrivateControls from "${workspaceUiModule}/components/controls";
+      export const DirectoryIndex = PrivateControls;
+    `,
+    "src/features/dynamic.ts": `
+      export const loadPrivateControl = () => import("${workspaceUiModule}/components/controls/color/color-value-utils");
+    `,
+    "src/features/namespace.ts": `
+      import * as PrivateColor from "@/toolcraft/ui/components/controls/color";
+      export const Namespace = PrivateColor;
+    `,
+    "src/features/reexport.ts": `
+      export { getCommittedHexColor } from "@/toolcraft/ui/components/controls/color/color-value-utils";
+    `,
+    "src/features/require.ts": `
+      export const privateControl = require("@/toolcraft/ui/components/controls/color/color-picker-popover");
+    `,
+    "src/features/workspace-source.ts": `
+      import { ColorPickerPopover } from "${workspaceUiModule}/src/components/controls/color/color-picker-popover";
+      export const WorkspaceSource = ColorPickerPopover;
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.equal(result.violations.length, 7);
+  assert.equal(
+    result.violations.every(
+      (violation) => violation.kind === "built-in-control-implementation",
+    ),
+    true,
+  );
+  assert.equal(
+    result.violations.every((violation) =>
+      /deep control implementation|public schema control/u.test(
+        violation.message,
+      ),
+    ),
+    true,
+  );
+});
+
+test("rejects the badge color-control copy at both private imports", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/badge-color-control.tsx": `
+      import { ColorPickerPopover } from "@/toolcraft/ui/components/controls/color/color-picker-popover";
+      import { getCommittedHexColor } from "@/toolcraft/ui/components/controls/color/color-value-utils";
+      export const BadgeColorControl = { ColorPickerPopover, getCommittedHexColor };
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.deepEqual(
+    result.violations.map(({ column, kind, line, repoPath }) => ({
+      column,
+      kind,
+      line,
+      repoPath,
+    })),
+    [
+      {
+        column: 7,
+        kind: "built-in-control-implementation",
+        line: 2,
+        repoPath: "src/features/badge-color-control.tsx",
+      },
+      {
+        column: 7,
+        kind: "built-in-control-implementation",
+        line: 3,
+        repoPath: "src/features/badge-color-control.tsx",
+      },
+    ],
+  );
+});
+
+test("rejects native and kit-primitive recreations of built-in controls", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/kit-inputs.tsx": `
+      import { Input as FieldInput } from "@/toolcraft/ui/primitives";
+      import * as Primitives from "@/toolcraft/ui/primitives";
+      const AliasedInput = FieldInput;
+      const { Input: RequiredInput } = require("@/toolcraft/ui/primitives");
+      export const Color = <FieldInput type="color" />;
+      export const File = <AliasedInput type={"file"} />;
+      export const Range = <Primitives.Input type="range" />;
+      export const Radio = <RequiredInput type="radio" />;
+      export function Dynamic({ kind }) {
+        return <FieldInput type={kind} />;
+      }
+    `,
+    "src/features/native.tsx": `
+      const rangeType = "range";
+      export const Range = <input type={rangeType} />;
+      export const Checkbox = <input type="checkbox" />;
+      export const Radio = <input type="radio" />;
+      export const Select = <select><option>One</option></select>;
+      export const Notes = <textarea />;
+    `,
+    "src/features/private-primitive.tsx": `
+      import PrimitiveInput from "${workspaceUiModule}/components/primitives/input";
+      export const PrivatePrimitiveColor = <PrimitiveInput type="color" />;
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.equal(result.violations.length, 11);
+  assert.equal(
+    result.violations.every(
+      (violation) => violation.kind === "native-control-recreation",
+    ),
+    true,
+  );
+});
+
+test("allows generic text inputs, buttons, canvas, and product components", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/safe-controls.tsx": `
+      import { Button, Input as FieldInput } from "@/toolcraft/ui/primitives";
+      function ProductInput() { return <div>Product value</div>; }
+      function ShadowedInput(FieldInput) { return <FieldInput type="color" />; }
+      export const Safe = (
+        <>
+          <FieldInput type="text" />
+          <input type="email" />
+          <input type="hidden" />
+          <Button>Run</Button>
+          <button type="button">Local action</button>
+          <canvas />
+          <ProductInput />
+          <ShadowedInput />
+        </>
+      );
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.deepEqual(result.violations, []);
+});

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

@@ -1,8 +1,4 @@
 import ts from "typescript";
-
-const forbiddenRuntimeExportNames = new Set([
-  "createToolcraftPngExportCanvas",
-]);
 const forbiddenGlobalExportConstructors = new Set([
   "MediaRecorder",
   "VideoEncoder",
@@ -12,6 +8,7 @@ const forbiddenCanvasExportMethods = new Set([
   "toBlob",
   "toDataURL",
 ]);
+const forbiddenGlobalExportFunctions = new Set(["showSaveFilePicker"]);
 
 export function getToolcraftProductExportModuleKind(
   normalizedSpecifier,
@@ -21,24 +18,17 @@ export function getToolcraftProductExportModuleKind(
     return "runtime-export-mechanics";
   }
   if (
-    normalizedSpecifier === "@repo/toolcraft-runtime" ||
-    /^[#@]\/toolcraft\/runtime\/?$/u.test(normalizedSpecifier) ||
-    /\/src\/toolcraft\/runtime$/u.test(resolvedSpecifier ?? "")
+    /^@repo\/toolcraft-runtime\/export(?:\/|$)/u.test(normalizedSpecifier) ||
+    /^[#@]\/toolcraft\/runtime\/export(?:\/|$)/u.test(normalizedSpecifier) ||
+    /\/src\/toolcraft\/runtime\/export(?:\/|$)/u.test(resolvedSpecifier ?? "")
   ) {
-    return "runtime-export-api";
+    return "runtime-export-mechanics";
   }
   return null;
 }
 
-export function isForbiddenToolcraftRuntimeExport(
-  moduleKind,
-  importedName,
-) {
-  return (
-    moduleKind === "runtime-export-mechanics" ||
-    (moduleKind === "runtime-export-api" &&
-      forbiddenRuntimeExportNames.has(importedName))
-  );
+export function isForbiddenToolcraftRuntimeExport(moduleKind) {
+  return moduleKind === "runtime-export-mechanics";
 }
 
 function getDeclarationScope(node, sourceFile) {
@@ -127,12 +117,20 @@ export function createToolcraftProductExportInspector({
     return {
       ...getNodeLocation(sourceFile, node),
       kind: "runtime-export-ownership",
-      message: `Product source must not own ${subject}. Declare exportRenderer and let runtime export actions encode and download the artifact.`,
+      message: `Product source must not own ${subject}. Declare exportRenderer for image/video or svgExportRenderer for SVG and let runtime export actions create and download the artifact.`,
       repoPath,
     };
   }
 
   return (node) => {
+    if (
+      ts.isCallExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      forbiddenGlobalExportFunctions.has(node.expression.text) &&
+      !isLexicallyDeclared(node.expression)
+    ) {
+      return [violation(node, `${node.expression.text} artifact delivery`)];
+    }
     if (
       ts.isNewExpression(node) &&
       ts.isIdentifier(node.expression) &&

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

@@ -0,0 +1,200 @@
+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("keeps artifact encoding and download mechanics runtime-owned", async (context) => {
+  const workspaceRuntimeExportSpecifier = [
+    "@repo",
+    "toolcraft-runtime",
+    "export",
+    "image-artifact-export",
+  ].join("/");
+  const rootDir = await createFixture(context, {
+    "src/features/export-mechanics.ts": `
+      import { createToolcraftVideoEncoderBackend as createAliasBackend } from "@/toolcraft/runtime/export/video-encoding-backend";
+      import { exportToolcraftImageArtifact } from "${workspaceRuntimeExportSpecifier}";
+      import { downloadToolcraftArtifact } from "../toolcraft/runtime/export/artifact-download";
+      import { Output } from "mediabunny";
+      export function exportArtifact(canvas: HTMLCanvasElement) {
+        const recorder = new MediaRecorder(canvas.captureStream());
+        const encoder = new VideoEncoder({ error() {}, output() {} });
+        canvas.toBlob(() => undefined);
+        canvas.toDataURL();
+        URL.createObjectURL(new Blob());
+        showSaveFilePicker();
+        void createAliasBackend;
+        void exportToolcraftImageArtifact;
+        void downloadToolcraftArtifact;
+        void Output;
+        void recorder;
+        void encoder;
+      }
+    `,
+    "src/features/safe-renderer.ts": `
+      import * as Runtime from "@/toolcraft/runtime";
+      import {
+        getToolcraftImageExportSize,
+        shouldIncludeToolcraftPreviewBackground,
+        validateToolcraftArtifactSize,
+      } from "@/toolcraft/runtime";
+      import type {
+        ToolcraftExportFrame,
+        ToolcraftProductExportRenderer,
+        ToolcraftProductSvgExportRenderer,
+      } from "@/toolcraft/runtime";
+      export const renderFrame = ({ context }) => context.fillRect(0, 0, 1, 1);
+      void Runtime;
+      void getToolcraftImageExportSize;
+      void shouldIncludeToolcraftPreviewBackground;
+      void validateToolcraftArtifactSize;
+      void (null as unknown as ToolcraftExportFrame);
+      void (null as unknown as ToolcraftProductExportRenderer);
+      void (null as unknown as ToolcraftProductSvgExportRenderer);
+      void new XMLSerializer();
+    `,
+    "src/features/shadowed-globals.ts": `
+      export function localNames(MediaRecorder, VideoEncoder, URL) {
+        void new MediaRecorder();
+        void new VideoEncoder();
+        URL.createObjectURL();
+      }
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.equal(result.violations.length, 11);
+  assert.equal(
+    result.violations.every(
+      (violation) => violation.kind === "runtime-export-ownership",
+    ),
+    true,
+  );
+  assert.equal(
+    result.violations.some((violation) =>
+      violation.repoPath.endsWith("shadowed-globals.ts"),
+    ),
+    false,
+  );
+  assert.equal(
+    result.violations.some((violation) =>
+      violation.repoPath.endsWith("safe-renderer.ts"),
+    ),
+    false,
+  );
+});
+
+test("classifies every runtime export mechanics module reference once", async (context) => {
+  const workspaceRuntimeExportRoot = [
+    "@repo",
+    "toolcraft-runtime",
+    "export",
+  ].join("/");
+  const rootDir = await createFixture(context, {
+    "src/features/dynamic-import.ts": `
+      export async function loadMedia() {
+        return import("mediabunny");
+      }
+    `,
+    "src/features/import-equals.ts": `
+      import Backend = require("@/toolcraft/runtime/export/video-encoding-backend");
+      void Backend;
+    `,
+    "src/features/import-type.ts": `
+      type Backend = import("@/toolcraft/runtime/export/video-encoding-backend").ToolcraftVideoEncoderBackend;
+      void (null as unknown as Backend);
+    `,
+    "src/features/regular-export.ts": `
+      export {
+        createToolcraftVideoEncoderBackend as createFirstBackend,
+        createToolcraftVideoEncoderBackend as createSecondBackend,
+      } from "@/toolcraft/runtime/export/video-encoding-backend";
+    `,
+    "src/features/regular-import.ts": `
+      import {
+        createToolcraftVideoEncoderBackend as createFirstBackend,
+        createToolcraftVideoEncoderBackend as createSecondBackend,
+      } from "@/toolcraft/runtime/export/video-encoding-backend";
+      void createFirstBackend;
+      void createSecondBackend;
+    `,
+    "src/features/require.ts": `
+      export const backend = require("${workspaceRuntimeExportRoot}/video-encoding-backend");
+    `,
+    "src/features/safe-root-type-import.ts": `
+      import type { ToolcraftExportFrame } from "@/toolcraft/runtime";
+      void (null as unknown as ToolcraftExportFrame);
+    `,
+    "src/features/side-effect-import.ts": `import "mediabunny";`,
+    "src/features/type-only-export.ts": `
+      export type {
+        ToolcraftImageArtifactExportRequest,
+        ToolcraftImageArtifactExportResult,
+      } from "${workspaceRuntimeExportRoot}/image-artifact-export";
+    `,
+    "src/features/type-only-import-equals.ts": `
+      import type Backend = require("@/toolcraft/runtime/export/video-encoding-backend");
+      void (null as unknown as Backend);
+    `,
+    "src/features/type-only-import.ts": `
+      import type {
+        ToolcraftVideoArtifactExportRequest,
+        ToolcraftVideoArtifactExportResult,
+      } from "${workspaceRuntimeExportRoot}/video-artifact-export";
+      void (null as unknown as ToolcraftVideoArtifactExportRequest);
+      void (null as unknown as ToolcraftVideoArtifactExportResult);
+    `,
+    "src/features/typeof-import-type.ts": `
+      type MediaBunny = typeof import("mediabunny");
+      void (null as unknown as MediaBunny);
+    `,
+    "src/features/export-boundary.test.ts": `
+      import type { ToolcraftVideoEncoderBackend } from "@/toolcraft/runtime/export/video-encoding-backend";
+      void (null as unknown as ToolcraftVideoEncoderBackend);
+    `,
+    "e2e/test-support/export-fixture.ts": `
+      export type { ToolcraftVideoEncoderBackend } from "@/toolcraft/runtime/export/video-encoding-backend";
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.deepEqual(
+    result.violations.map(({ repoPath }) => repoPath).sort(),
+    [
+      "src/features/dynamic-import.ts",
+      "src/features/import-equals.ts",
+      "src/features/import-type.ts",
+      "src/features/regular-export.ts",
+      "src/features/regular-import.ts",
+      "src/features/require.ts",
+      "src/features/side-effect-import.ts",
+      "src/features/type-only-export.ts",
+      "src/features/type-only-import-equals.ts",
+      "src/features/type-only-import.ts",
+      "src/features/typeof-import-type.ts",
+    ],
+  );
+  assert.equal(
+    new Set(result.violations.map(({ repoPath }) => repoPath)).size,
+    result.violations.length,
+  );
+  assert.equal(
+    result.violations.every(
+      (violation) => violation.kind === "runtime-export-ownership",
+    ),
+    true,
+  );
+  assert.equal(
+    result.violations.some(({ repoPath }) =>
+      [
+        "src/features/export-boundary.test.ts",
+        "src/features/safe-root-type-import.ts",
+        "e2e/test-support/export-fixture.ts",
+      ].includes(repoPath),
+    ),
+    false,
+  );
+});

package/templates/starter/scripts/toolcraft-product-observable-facade.test.mjs

@@ -20,7 +20,11 @@ async function loadProductObservableFacade(context) {
     .replaceAll('"@playwright/test"', '"./playwright.mjs"')
     .replaceAll('"./browser-runtime-evidence"', '"./evidence.mjs"')
     .replaceAll('"./browser-proof-session"', '"./proof-session.mjs"')
-    .replaceAll('"./stable-outcome-helpers"', '"./stable-outcome.mjs"');
+    .replaceAll('"./stable-outcome-helpers"', '"./stable-outcome.mjs"')
+    .replaceAll(
+      '"./browser-product-raster-snapshot"',
+      '"./raster-snapshot.mjs"',
+    );
   const { outputText } = ts.transpileModule(source, {
     compilerOptions: {
       module: ts.ModuleKind.ESNext,
@@ -91,6 +95,47 @@ async function loadProductObservableFacade(context) {
         }
       `,
     ),
+    fs.writeFile(
+      path.join(outputDir, "raster-snapshot.mjs"),
+      `
+        const warmedPages = new WeakSet();
+        const screenshotOptions = {
+          animations: "disabled",
+          caret: "hide",
+          scale: "css",
+          type: "png",
+        };
+
+        export async function resolveToolcraftProductRasterProbe(page, probe) {
+          const locator = page.locator(probe.selector);
+          const bounds = await locator.boundingBox();
+          if (
+            !bounds ||
+            bounds.width <= 0 ||
+            bounds.height <= 0 ||
+            bounds.width > 4096 ||
+            bounds.height > 4096 ||
+            bounds.width * bounds.height > 8_388_608
+          ) {
+            throw new Error(
+              'Raster probe exceeds the bounded visual proof limit.',
+            );
+          }
+          return {
+            bounds,
+            locator,
+            async capture() {
+              if (!warmedPages.has(page)) {
+                await locator.screenshot(screenshotOptions);
+                warmedPages.add(page);
+              }
+              const raster = await locator.screenshot(screenshotOptions);
+              return JSON.stringify(await page.evaluate(() => undefined, raster));
+            },
+          };
+        }
+      `,
+    ),
   ]);
 
   return import(`${pathToFileURL(outputPath).href}?test=${Date.now()}`);

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

@@ -35,7 +35,6 @@ const expectedVerificationReceiptExports = [
   "assertToolcraftVerificationInputsUnchanged",
   "collectToolcraftVerificationInputs",
   "readToolcraftDurablePerformanceBaseline",
-  "validateToolcraftCurrentPerformanceImpactInventory",
   "validateToolcraftPerformanceReceipt",
   "validateToolcraftVerificationReceipt",
 ];

package/templates/starter/scripts/toolcraft-source-inventory.d.mts

@@ -32,6 +32,11 @@ export type ToolcraftSourceInventoryOptions = {
 
 export const toolcraftSourceExtensions: ReadonlySet<string>;
 
+export function resolveToolcraftRootResourcePath(
+  resourcePath: string,
+  rootDir: string,
+): string;
+
 export function classifyToolcraftSourcePath(
   repoPath: string,
   options?: Omit<ToolcraftSourceInventoryOptions, "rootDir" | "sourceRoots">,