@pixel-point/toolcraft 0.0.16 → 0.0.17

package/templates/starter/scripts/toolcraft-delivery-plan-authority.test.mjs

@@ -239,6 +239,66 @@ test("creates a changed authorized iteration with exact affected proof", () => {
   assert.equal(getToolcraftDeliveryDiagnosticTier(plan), 3);
 });
 
+test("creates an authorized iteration for a passless viewport path", () => {
+  const passlessPathId =
+    "performance-path:%5B%22interactive-continuous%22%2C%22viewport-drag%22%2C%5B%5D%2C%5B%5D%2C%5B%5D%5D";
+  const testName = `browser perf: toolcraft path ${passlessPathId}`;
+  const source = {
+    heading: "Delivery 2 - Slow viewport drag",
+    pathIds: [passlessPathId],
+    request: "The canvas is slow while panning.",
+    requestEvidence: "The canvas is slow while panning.",
+  };
+  const planningInputs = inputs({
+    requestAuthority: {
+      hash: createToolcraftPerformanceRequestAuthorityHash(source),
+      ...source,
+    },
+  });
+  planningInputs.catalog = {
+    ...catalog,
+    performance: [{ passIds: [], pathId: passlessPathId, testName }],
+  };
+  planningInputs.changeSet.impact.performanceCandidates = {
+    passIds: [],
+    pathIds: [passlessPathId],
+    testNames: [testName],
+  };
+
+  const plan = createToolcraftDeliveryPlan(planningInputs);
+
+  assert.equal(plan.kind, "performance-iteration");
+  assert.deepEqual(
+    plan.steps.find(({ kind }) => kind === "browser-performance"),
+    {
+      kind: "browser-performance",
+      passIds: [],
+      pathIds: [passlessPathId],
+      testNames: [testName],
+    },
+  );
+});
+
+test("keeps performance-adapter-only changes functional without inferred measurement", () => {
+  const planningInputs = inputs();
+  planningInputs.changeSet.impact = {
+    acceptanceIds: [],
+    browserTestNames: [],
+    buildRequired: false,
+    performanceCandidates: {
+      passIds: ["preview-composite"],
+      pathIds: [pathId],
+      testNames: [performanceTestName],
+    },
+    productTestFiles: [],
+  };
+
+  const plan = createToolcraftDeliveryPlan(planningInputs);
+
+  assert.equal(plan.kind, "functional");
+  assert.deepEqual(plan.steps, [{ kind: "code-health" }]);
+});
+
 test("rejects malformed basis and functional performance proof", () => {
   const valid = createToolcraftDeliveryPlan(inputs());
   for (const basis of [

package/templates/starter/scripts/toolcraft-delivery-plan-errors.test.mjs

@@ -203,14 +203,19 @@ test("rejects malformed catalogs and inconsistent exact impact relations", () =>
   }
 });
 
-test("performance impact cannot omit functional acceptance proof", () => {
+test("impact cannot omit both functional and performance proof", () => {
   const value = inputs();
   value.changeSet.impact.acceptanceIds = [];
   value.changeSet.impact.browserTestNames = [];
   value.changeSet.impact.productTestFiles = [];
+  value.changeSet.impact.performanceCandidates = {
+    passIds: [],
+    pathIds: [],
+    testNames: [],
+  };
   assert.throws(
     () => createToolcraftDeliveryPlan(value),
-    /functional proof/iu,
+    /functional or performance proof/iu,
   );
 });
 

package/templates/starter/scripts/toolcraft-delivery-plan.mjs

@@ -124,8 +124,9 @@ function impactError(impact, catalog, allTests) {
     impact.acceptanceIds.includes(row.acceptanceId));
   const performance = catalog.performance.filter((row) =>
     impact.performanceCandidates.pathIds.includes(row.pathId));
-  if (!impact.browserTestNames.length && !impact.productTestFiles.length)
-    return "Verification impact does not select functional proof.";
+  if (!impact.browserTestNames.length && !impact.productTestFiles.length &&
+    !impact.performanceCandidates.pathIds.length)
+    return "Verification impact does not select functional or performance proof.";
   if (acceptance.length !== impact.acceptanceIds.length ||
     !same(acceptance.map((row) => row.testName).sort(compare), impact.browserTestNames) ||
     performance.length !== impact.performanceCandidates.pathIds.length ||
@@ -227,7 +228,10 @@ function stepError(step) {
   if (step.kind === "dependencies" && !managers.has(step.packageManager))
     return "Dependency proof has an invalid package manager.";
   const badTarget = ["files", "testNames", "pathIds", "passIds"].find((key) =>
-    Object.hasOwn(step, key) && !targets(step[key], { paths: key === "files" }));
+    Object.hasOwn(step, key) && !targets(step[key], {
+      empty: step.kind === "browser-performance" && key === "passIds",
+      paths: key === "files",
+    }));
   if (badTarget)
     return `Delivery proof ${badTarget} must be nonempty, sorted, and unique.`;
 }

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

@@ -6,6 +6,11 @@ import {
   builtInControlExportNames,
   runtimeSurfaceComponentNames,
 } from "./toolcraft-integrity-policy.mjs";
+import {
+  createToolcraftProductExportInspector,
+  getToolcraftProductExportModuleKind,
+  isForbiddenToolcraftRuntimeExport,
+} from "./toolcraft-product-export-boundary.mjs";
 import { inspectToolcraftProductStyleNode } from "./toolcraft-product-style-boundary.mjs";
 
 const runtimeSurfaceNames = new Set(runtimeSurfaceComponentNames);
@@ -42,6 +47,11 @@ function getSensitiveModuleKind(sourceFilePath, moduleSpecifier, rootDir) {
     normalizedSpecifier,
     rootDir,
   );
+  const exportModuleKind = getToolcraftProductExportModuleKind(
+    normalizedSpecifier,
+    resolvedSpecifier,
+  );
+  if (exportModuleKind) return exportModuleKind;
 
   if (
     /^@repo\/toolcraft-runtime\/react\/model-rendering(?:\/|$)/u.test(
@@ -94,6 +104,7 @@ function getSensitiveModuleKind(sourceFilePath, moduleSpecifier, rootDir) {
 }
 
 function isForbiddenNamedExport(moduleKind, importedName) {
+  if (isForbiddenToolcraftRuntimeExport(moduleKind, importedName)) return true;
   if (
     moduleKind === "runtime-model-import" ||
     moduleKind === "runtime-model-presentation"
@@ -117,7 +128,9 @@ function createViolation({
 }) {
   const subject = importedName ? ` ${importedName}` : "";
   const message =
-    kind === "runtime-surface"
+    kind === "runtime-export-ownership"
+      ? `Product source must not own artifact encoding, recording, or download mechanics${subject} from ${moduleSpecifier}. Declare exportRenderer and let runtime export actions encode and download the artifact.`
+      : kind === "runtime-surface"
       ? `Product source must not import or re-export host-owned runtime surface${subject} from ${moduleSpecifier}. Use ToolcraftAppComposition, schema, canvasContent, controlRenderers, onPanelAction, and runtime commands.`
       : kind === "runtime-model-presentation-ownership"
         ? `Product source must not import raw model render hosts or standard model canvas internals${subject} from ${moduleSpecifier}. Declare modelPresentation and use useToolcraftModelPresentationConsumer for visible custom model output.`
@@ -141,6 +154,11 @@ export function inspectToolcraftProductSource({
   sourceFile,
 }) {
   const violations = [];
+  const inspectExportMechanics = createToolcraftProductExportInspector({
+    getNodeLocation,
+    repoPath,
+    sourceFile,
+  });
 
   function report(node, moduleSpecifier, moduleKind, importedName) {
     if (importedName && !isForbiddenNamedExport(moduleKind, importedName)) {
@@ -151,7 +169,10 @@ export function inspectToolcraftProductSource({
         getNodeLocation,
         importedName,
         kind:
-          moduleKind === "runtime-model-presentation"
+          moduleKind === "runtime-export-api" ||
+          moduleKind === "runtime-export-mechanics"
+            ? "runtime-export-ownership"
+            : moduleKind === "runtime-model-presentation"
             ? "runtime-model-presentation-ownership"
             : moduleKind === "runtime-react"
             ? runtimeModelPresentationInternalNames.has(importedName)
@@ -180,6 +201,7 @@ export function inspectToolcraftProductSource({
         resolveStaticString,
         sourceFile,
       }),
+      ...inspectExportMechanics(node),
     );
 
     if (

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

@@ -4,6 +4,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { createToolcraftPrivateEvidenceImportViolation } from "./toolcraft-product-evidence-import-policy.mjs";
 import { isToolcraftTypeScriptCompilerAvailable } from "./toolcraft-typescript-source-evidence.mjs";
 
 function compareCodeUnits(left, right) {
@@ -94,6 +95,15 @@ export async function evaluateToolcraftProductBoundary({
     importerEvidence.push(evidence);
     importsByImporter.set(evidence.importerRepoPath, importerEvidence);
   }
+  const appendPrivateEvidenceImportViolations = (entry) => {
+    for (const moduleImport of importsByImporter.get(entry.repoPath) ?? []) {
+      const violation = createToolcraftPrivateEvidenceImportViolation({
+        importerRepoPath: entry.repoPath,
+        moduleImport,
+      });
+      if (violation) violations.push(violation);
+    }
+  };
 
   for (const entry of productEntries) {
     const sourceRecord = localDependencyGraph.sourceRecords.get(entry.repoPath);
@@ -113,6 +123,7 @@ export async function evaluateToolcraftProductBoundary({
       ...boundaryEvidence.reservedEvidenceViolations,
       ...boundaryEvidence.playwrightAuthorityViolations,
     );
+    appendPrivateEvidenceImportViolations(entry);
     for (const evidence of importsByImporter.get(entry.repoPath) ?? []) {
       if (evidence.resolution === "outside-inventory") {
         violations.push({
@@ -165,6 +176,7 @@ export async function evaluateToolcraftProductBoundary({
       ...boundaryEvidence.playwrightAuthorityViolations,
       ...boundaryEvidence.moduleLoadingViolations,
     );
+    appendPrivateEvidenceImportViolations(entry);
   }
 
   return {

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

@@ -143,6 +143,52 @@ test("keeps model import, topology, and repair infrastructure runtime-owned", as
   );
 });
 
+test("keeps artifact encoding and download mechanics runtime-owned", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/export-mechanics.ts": `
+      import { createToolcraftPngExportCanvas } from "@/toolcraft/runtime";
+      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());
+        void createToolcraftPngExportCanvas;
+        void Output;
+        void recorder;
+        void encoder;
+      }
+    `,
+    "src/features/safe-renderer.ts": `
+      export const renderFrame = ({ context }) => context.fillRect(0, 0, 1, 1);
+    `,
+    "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, 8);
+  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,
+  );
+});
+
 test("ignores tests but checks a product bridge imported by production", async (context) => {
   const rootDir = await createFixture(context, {
     "src/features/bridge.ts": `

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

@@ -12,6 +12,44 @@ const starterRoot = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
   "..",
 );
+const unavailableImageEvidenceFacadePath =
+  "e2e/browser-infinity-canvas-evidence.ts";
+const unavailableImageEvidencePrivatePath =
+  "e2e/browser-infinity-canvas-unavailable-image-evidence.ts";
+
+async function evaluateUnavailableImageEvidenceImport(context, specifier) {
+  const rootDir = await createFixture(context, {
+    "e2e/app-canvas.spec.ts": `
+      import { createToolcraftUnavailableImageResourceFixture } from "${specifier}";
+      void createToolcraftUnavailableImageResourceFixture;
+    `,
+    [unavailableImageEvidenceFacadePath]: `
+      export {
+        createToolcraftUnavailableImageResourceFixture,
+      } from "./browser-infinity-canvas-unavailable-image-evidence";
+    `,
+    [unavailableImageEvidencePrivatePath]: `
+      export function createToolcraftUnavailableImageResourceFixture() {}
+    `,
+    "tsconfig.json": JSON.stringify({
+      compilerOptions: {
+        baseUrl: ".",
+        paths: {
+          "@private-proof": [`./${unavailableImageEvidencePrivatePath}`],
+          "@public-proof": [`./${unavailableImageEvidenceFacadePath}`],
+        },
+      },
+    }),
+  });
+
+  return evaluateToolcraftProductBoundary({
+    protectedFilePaths: [
+      unavailableImageEvidenceFacadePath,
+      unavailableImageEvidencePrivatePath,
+    ],
+    rootDir,
+  });
+}
 
 test("protects every starter helper that writes reserved runtime evidence", async () => {
   const e2eRoot = path.join(starterRoot, "e2e");
@@ -201,27 +239,54 @@ test("allows product layer specs to use the public proof facade without reserved
   assert.deepEqual(result.violations, []);
 });
 
-test("allows product specs to use the unavailable-resource facade but rejects its reserved bridge", async (context) => {
-  const allowedRoot = await createFixture(context, {
-    "e2e/app-canvas.spec.ts": `
-      import {
-        createToolcraftUnavailableImageResourceFixture,
-        expectToolcraftInfinityCanvasUnavailableImageExportEvidence,
-      } from "./browser-infinity-canvas-evidence";
-      void createToolcraftUnavailableImageResourceFixture;
-      void expectToolcraftInfinityCanvasUnavailableImageExportEvidence;
-    `,
-    "e2e/browser-infinity-canvas-evidence.ts": `
-      export function createToolcraftUnavailableImageResourceFixture() {}
-      export async function expectToolcraftInfinityCanvasUnavailableImageExportEvidence() {}
-    `,
-  });
-  const allowed = await evaluateToolcraftProductBoundary({
-    protectedFilePaths: ["e2e/browser-infinity-canvas-evidence.ts"],
-    rootDir: allowedRoot,
-  });
-  assert.deepEqual(allowed.violations, []);
+test("rejects relative and configured-alias imports of private unavailable-image evidence", async (context) => {
+  const results = await Promise.all(
+    [
+      "./browser-infinity-canvas-unavailable-image-evidence",
+      "@private-proof",
+    ].map((specifier) =>
+      evaluateUnavailableImageEvidenceImport(context, specifier),
+    ),
+  );
+  assert.deepEqual(
+    results.map((result) =>
+      result.violations.map((violation) => violation.kind),
+    ),
+    [
+      ["reserved-runtime-evidence"],
+      ["reserved-runtime-evidence"],
+    ],
+  );
+  for (const result of results) {
+    assert.match(result.violations[0].message, /browser-infinity-canvas-evidence/u);
+  }
+});
+
+test("allows relative and configured-alias imports of the public unavailable-image facade", async (context) => {
+  for (const specifier of [
+    "./browser-infinity-canvas-evidence",
+    "@public-proof",
+  ]) {
+    const result = await evaluateUnavailableImageEvidenceImport(
+      context,
+      specifier,
+    );
+    assert.deepEqual(result.violations, []);
+  }
+});
+
+test("normalizes private unavailable-image evidence import paths before enforcing policy", async (context) => {
+  const result = await evaluateUnavailableImageEvidenceImport(
+    context,
+    "./nested/../browser-infinity-canvas-unavailable-image-evidence",
+  );
+  assert.deepEqual(
+    result.violations.map((violation) => violation.kind),
+    ["reserved-runtime-evidence"],
+  );
+});
 
+test("rejects product access to the reserved unavailable-resource bridge", async (context) => {
   const rejectedRoot = await createFixture(context, {
     "e2e/app-canvas.spec.ts": `
       const fixtureEvent =

package/templates/starter/scripts/toolcraft-product-evidence-import-policy.mjs

@@ -0,0 +1,43 @@
+const PRIVATE_EVIDENCE_MESSAGE =
+  "Product-owned source must use the protected public evidence facade instead of importing its private implementation module.";
+
+export const toolcraftProductEvidenceModulePolicies = Object.freeze([
+  Object.freeze({
+    capability: "unavailable-image-resource-evidence",
+    privateModuleRepoPath:
+      "e2e/browser-infinity-canvas-unavailable-image-evidence.ts",
+    publicFacadeRepoPath: "e2e/browser-infinity-canvas-evidence.ts",
+  }),
+]);
+
+const privateEvidencePolicyByRepoPath = new Map(
+  toolcraftProductEvidenceModulePolicies.map((policy) => [
+    policy.privateModuleRepoPath,
+    policy,
+  ]),
+);
+
+function normalizeRepoPath(repoPath) {
+  return String(repoPath).replaceAll("\\", "/").replace(/^\.\//u, "");
+}
+
+export function createToolcraftPrivateEvidenceImportViolation({
+  importerRepoPath,
+  moduleImport,
+}) {
+  if (moduleImport.resolution !== "resolved") return null;
+  const policy = privateEvidencePolicyByRepoPath.get(
+    normalizeRepoPath(moduleImport.resolvedRepoPath),
+  );
+  if (!policy) return null;
+
+  return {
+    column: moduleImport.column,
+    kind: "reserved-runtime-evidence",
+    line: moduleImport.line,
+    message:
+      `${PRIVATE_EVIDENCE_MESSAGE} Import ${policy.publicFacadeRepoPath} ` +
+      `for ${policy.capability}.`,
+    repoPath: importerRepoPath,
+  };
+}

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

@@ -0,0 +1,168 @@
+import ts from "typescript";
+
+const forbiddenRuntimeExportNames = new Set([
+  "createToolcraftPngExportCanvas",
+]);
+const forbiddenGlobalExportConstructors = new Set([
+  "MediaRecorder",
+  "VideoEncoder",
+]);
+const forbiddenCanvasExportMethods = new Set([
+  "captureStream",
+  "toBlob",
+  "toDataURL",
+]);
+
+export function getToolcraftProductExportModuleKind(
+  normalizedSpecifier,
+  resolvedSpecifier,
+) {
+  if (/^mediabunny(?:\/|$)/u.test(normalizedSpecifier)) {
+    return "runtime-export-mechanics";
+  }
+  if (
+    normalizedSpecifier === "@repo/toolcraft-runtime" ||
+    /^[#@]\/toolcraft\/runtime\/?$/u.test(normalizedSpecifier) ||
+    /\/src\/toolcraft\/runtime$/u.test(resolvedSpecifier ?? "")
+  ) {
+    return "runtime-export-api";
+  }
+  return null;
+}
+
+export function isForbiddenToolcraftRuntimeExport(
+  moduleKind,
+  importedName,
+) {
+  return (
+    moduleKind === "runtime-export-mechanics" ||
+    (moduleKind === "runtime-export-api" &&
+      forbiddenRuntimeExportNames.has(importedName))
+  );
+}
+
+function getDeclarationScope(node, sourceFile) {
+  let current = node.parent;
+  while (current) {
+    if (
+      ts.isSourceFile(current) ||
+      ts.isFunctionLike(current) ||
+      ts.isBlock(current) ||
+      ts.isCatchClause(current)
+    ) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return sourceFile;
+}
+
+function collectLexicalDeclarations(sourceFile) {
+  const declarations = [];
+
+  function collectBindingNames(name, scope) {
+    if (ts.isIdentifier(name)) {
+      declarations.push({ name: name.text, scope });
+    } else if (
+      ts.isObjectBindingPattern(name) ||
+      ts.isArrayBindingPattern(name)
+    ) {
+      for (const element of name.elements) {
+        if (ts.isBindingElement(element)) collectBindingNames(element.name, scope);
+      }
+    }
+  }
+
+  function visit(node) {
+    if (ts.isImportClause(node) && node.name) {
+      collectBindingNames(node.name, sourceFile);
+    } else if (ts.isImportSpecifier(node) || ts.isNamespaceImport(node)) {
+      collectBindingNames(node.name, sourceFile);
+    } else if (ts.isVariableDeclaration(node)) {
+      collectBindingNames(node.name, getDeclarationScope(node, sourceFile));
+    } else if (ts.isParameter(node)) {
+      collectBindingNames(node.name, node.parent);
+    } else if (
+      (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) &&
+      node.name
+    ) {
+      collectBindingNames(node.name, getDeclarationScope(node, sourceFile));
+    }
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return declarations;
+}
+
+export function createToolcraftProductExportInspector({
+  getNodeLocation,
+  repoPath,
+  sourceFile,
+}) {
+  const lexicalDeclarations = collectLexicalDeclarations(sourceFile);
+
+  function isLexicallyDeclared(identifier) {
+    const ancestorScopes = new Set();
+    let current = identifier.parent;
+    while (current) {
+      if (
+        ts.isSourceFile(current) ||
+        ts.isFunctionLike(current) ||
+        ts.isBlock(current) ||
+        ts.isCatchClause(current)
+      ) {
+        ancestorScopes.add(current);
+      }
+      current = current.parent;
+    }
+    return lexicalDeclarations.some(
+      (declaration) =>
+        declaration.name === identifier.text &&
+        ancestorScopes.has(declaration.scope),
+    );
+  }
+
+  function violation(node, subject) {
+    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.`,
+      repoPath,
+    };
+  }
+
+  return (node) => {
+    if (
+      ts.isNewExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      forbiddenGlobalExportConstructors.has(node.expression.text) &&
+      !isLexicallyDeclared(node.expression)
+    ) {
+      return [
+        violation(
+          node,
+          `${node.expression.text} encoder or recorder construction`,
+        ),
+      ];
+    }
+    if (
+      ts.isCallExpression(node) &&
+      ts.isPropertyAccessExpression(node.expression)
+    ) {
+      const propertyName = node.expression.name.text;
+      if (forbiddenCanvasExportMethods.has(propertyName)) {
+        return [violation(node, `canvas.${propertyName}() export mechanics`)];
+      }
+      if (
+        propertyName === "createObjectURL" &&
+        ts.isIdentifier(node.expression.expression) &&
+        node.expression.expression.text === "URL" &&
+        !isLexicallyDeclared(node.expression.expression)
+      ) {
+        return [violation(node, "URL.createObjectURL() artifact delivery")];
+      }
+    }
+    return [];
+  };
+}

package/templates/starter/scripts/toolcraft-typescript-analysis.d.mts

@@ -0,0 +1,73 @@
+import type ts from "typescript";
+
+export type ToolcraftTypeScriptImportedBinding = Readonly<{
+  importedName: string;
+  localName: string;
+  specifier: string;
+}>;
+
+export type ToolcraftTypeScriptImportedCallTarget = Readonly<{
+  callerCallableId: string | null;
+  callerExportNames: readonly string[];
+  importedName: string;
+  localName: string;
+  memberPath: string;
+  operation: string;
+  specifier: string;
+}>;
+
+export type ToolcraftTypeScriptModuleBindings = Readonly<{
+  callables: unknown;
+  exportedCallableBindings: readonly Readonly<{
+    callableId: string;
+    exportedName: string;
+  }>[];
+  exportedRuntimeBindings: readonly string[];
+  importedBindingSymbols: readonly Readonly<{
+    binding: ToolcraftTypeScriptImportedBinding;
+    symbol: ts.Symbol;
+  }>[];
+  importedRuntimeBindings: readonly ToolcraftTypeScriptImportedBinding[];
+}>;
+
+export function createToolcraftTypeScriptChecker(
+  sourceFile: ts.SourceFile,
+  typescript: typeof ts,
+): ts.TypeChecker;
+
+export function collectToolcraftTypeScriptModuleBindings(
+  sourceFile: ts.SourceFile,
+  typescript: typeof ts,
+  checker?: ts.TypeChecker,
+  callables?: unknown,
+): ToolcraftTypeScriptModuleBindings;
+
+export function collectToolcraftTypeScriptCallTargets(input: Readonly<{
+  bindings: ToolcraftTypeScriptModuleBindings;
+  checker: ts.TypeChecker;
+  sourceFile: ts.SourceFile;
+  ts: typeof ts;
+}>): Readonly<{
+  importedCallTargets: readonly ToolcraftTypeScriptImportedCallTarget[];
+  localCallTargets: readonly Readonly<{
+    calleeCallableId: string;
+    callerCallableId: string;
+  }>[];
+}>;
+
+export function getToolcraftTypeScriptImportedCallTarget(input: Readonly<{
+  bindings: ToolcraftTypeScriptModuleBindings;
+  checker: ts.TypeChecker;
+  expression: ts.Expression;
+  ts: typeof ts;
+}>):
+  | Omit<
+      ToolcraftTypeScriptImportedCallTarget,
+      "callerCallableId" | "callerExportNames"
+    >
+  | undefined;
+
+export function unwrapToolcraftTypeScriptExpression(
+  node: ts.Expression,
+  typescript: typeof ts,
+): ts.Expression;