@pixel-point/toolcraft 0.0.17 → 0.0.19

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

@@ -1,5 +1,3 @@
-import path from "node:path";
-
 import ts from "typescript";
 
 import {
@@ -8,9 +6,10 @@ import {
 } from "./toolcraft-integrity-policy.mjs";
 import {
   createToolcraftProductExportInspector,
-  getToolcraftProductExportModuleKind,
   isForbiddenToolcraftRuntimeExport,
 } from "./toolcraft-product-export-boundary.mjs";
+import { createToolcraftProductControlInspector } from "./toolcraft-product-control-boundary.mjs";
+import { getToolcraftSensitiveModuleKind } from "./toolcraft-product-boundary-module-policy.mjs";
 import { inspectToolcraftProductStyleNode } from "./toolcraft-product-style-boundary.mjs";
 
 const runtimeSurfaceNames = new Set(runtimeSurfaceComponentNames);
@@ -23,88 +22,9 @@ const runtimeModelPresentationInternalNames = new Set([
   "useToolcraftModelRenderHost",
 ]);
 
-function toPosixPath(value) {
-  return value.split(path.sep).join("/");
-}
-
-function resolveSpecifierPath(sourceFilePath, moduleSpecifier, rootDir) {
-  if (moduleSpecifier.startsWith("@/") || moduleSpecifier.startsWith("#/")) {
-    return toPosixPath(path.resolve(rootDir, "src", moduleSpecifier.slice(2)));
-  }
-  if (moduleSpecifier.startsWith("/")) {
-    return toPosixPath(path.resolve(rootDir, moduleSpecifier.slice(1)));
-  }
-  if (moduleSpecifier.startsWith(".")) {
-    return toPosixPath(path.resolve(path.dirname(sourceFilePath), moduleSpecifier));
-  }
-  return null;
-}
-
-function getSensitiveModuleKind(sourceFilePath, moduleSpecifier, rootDir) {
-  const normalizedSpecifier = moduleSpecifier.replaceAll("\\", "/");
-  const resolvedSpecifier = resolveSpecifierPath(
-    sourceFilePath,
-    normalizedSpecifier,
-    rootDir,
-  );
-  const exportModuleKind = getToolcraftProductExportModuleKind(
-    normalizedSpecifier,
-    resolvedSpecifier,
-  );
-  if (exportModuleKind) return exportModuleKind;
-
-  if (
-    /^@repo\/toolcraft-runtime\/react\/model-rendering(?:\/|$)/u.test(
-      normalizedSpecifier,
-    ) ||
-    /^[#@]\/toolcraft\/runtime\/react\/model-rendering(?:\/|$)/u.test(
-      normalizedSpecifier,
-    ) ||
-    resolvedSpecifier?.includes("/src/toolcraft/runtime/react/model-rendering")
-  ) {
-    return "runtime-model-presentation";
-  }
-
-  if (
-    /^three\/(?:addons|examples\/jsm)\/loaders(?:\/|$)/u.test(
-      normalizedSpecifier,
-    ) ||
-    /^@gltf-transform(?:\/|$)/u.test(normalizedSpecifier) ||
-    /^@repo\/toolcraft-runtime\/model-import(?:\/|$)/u.test(
-      normalizedSpecifier,
-    ) ||
-    /^[#@]\/toolcraft\/runtime\/model-import(?:\/|$)/u.test(
-      normalizedSpecifier,
-    ) ||
-    resolvedSpecifier?.includes("/src/toolcraft/runtime/model-import")
-  ) {
-    return "runtime-model-import";
-  }
-
-  if (
-    /^@repo\/toolcraft-runtime\/react(?:\/|$)/u.test(normalizedSpecifier) ||
-    /^[#@]\/toolcraft\/runtime\/react(?:\/|$)/u.test(normalizedSpecifier) ||
-    resolvedSpecifier?.includes("/src/toolcraft/runtime/react")
-  ) {
-    return "runtime-react";
-  }
-
-  if (
-    /^@repo\/ui(?:\/controls(?:\/|$)|$)/u.test(normalizedSpecifier) ||
-    /^[#@]\/toolcraft\/ui(?:\/components\/controls(?:\/|$)|\/controls(?:\/|$)|$)/u.test(
-      normalizedSpecifier,
-    ) ||
-    resolvedSpecifier?.includes("/src/toolcraft/ui/components/controls") ||
-    /\/src\/toolcraft\/ui$/u.test(resolvedSpecifier ?? "")
-  ) {
-    return "ui-controls";
-  }
-
-  return null;
-}
-
 function isForbiddenNamedExport(moduleKind, importedName) {
-  if (isForbiddenToolcraftRuntimeExport(moduleKind, importedName)) return true;
+  if (moduleKind === "ui-control-implementation") return true;
+  if (isForbiddenToolcraftRuntimeExport(moduleKind)) return true;
   if (
     moduleKind === "runtime-model-import" ||
     moduleKind === "runtime-model-presentation"
@@ -117,6 +37,42 @@ function isForbiddenNamedExport(moduleKind, importedName) {
           importedName !== "createControlHistoryGroupId");
 }
 
+function getImportViolationKind(moduleKind, importedName) {
+  switch (moduleKind) {
+    case "runtime-export-mechanics":
+      return "runtime-export-ownership";
+    case "runtime-model-presentation":
+      return "runtime-model-presentation-ownership";
+    case "runtime-react":
+      return runtimeModelPresentationInternalNames.has(importedName)
+        ? "runtime-model-presentation-ownership"
+        : "runtime-surface";
+    case "runtime-model-import":
+      return "runtime-model-import-ownership";
+    case "ui-control-implementation":
+      return "built-in-control-implementation";
+    default:
+      return "built-in-control";
+  }
+}
+
+function getViolationMessage(kind, subject, moduleSpecifier) {
+  switch (kind) {
+    case "runtime-export-ownership":
+      return `Product source must not own artifact encoding, recording, or download mechanics${subject} from ${moduleSpecifier}. Declare exportRenderer for image/video or svgExportRenderer for SVG and let runtime export actions create and download the artifact.`;
+    case "runtime-surface":
+      return `Product source must not import or re-export host-owned runtime surface${subject} from ${moduleSpecifier}. Use ToolcraftAppComposition, schema, canvasContent, controlRenderers, onPanelAction, and runtime commands.`;
+    case "runtime-model-presentation-ownership":
+      return `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.`;
+    case "runtime-model-import-ownership":
+      return `Product source must not import or re-export model loaders, topology/repair infrastructure, or runtime model-import internals${subject} from ${moduleSpecifier}. Declare a model fileDrop in schema and use the runtime-owned import, analysis, repair, persistence, preview, and export pipeline.`;
+    case "built-in-control-implementation":
+      return `Product source must not import or re-export a deep control implementation${subject} from ${moduleSpecifier}. Use the public schema control instead of copying or composing its private mechanics.`;
+    default:
+      return `Product source must not import or re-export built-in control${subject} from ${moduleSpecifier}. Declare it through schema or justify a true custom controlRenderer.`;
+  }
+}
+
 function createViolation({
   getNodeLocation,
   importedName,
@@ -127,26 +83,17 @@ function createViolation({
   sourceFile,
 }) {
   const subject = importedName ? ` ${importedName}` : "";
-  const message =
-    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.`
-      : kind === "runtime-model-import-ownership"
-        ? `Product source must not import or re-export model loaders, topology/repair infrastructure, or runtime model-import internals${subject} from ${moduleSpecifier}. Declare a model fileDrop in schema and use the runtime-owned import, analysis, repair, persistence, preview, and export pipeline.`
-        : `Product source must not import or re-export built-in control${subject} from ${moduleSpecifier}. Declare it through schema or justify a true custom controlRenderer.`;
   return {
     ...getNodeLocation(sourceFile, node),
     kind,
-    message,
+    message: getViolationMessage(kind, subject, moduleSpecifier),
     repoPath,
   };
 }
 
 export function inspectToolcraftProductSource({
   absolutePath,
+  checker,
   getNodeLocation,
   repoPath,
   resolveStaticString,
@@ -159,6 +106,13 @@ export function inspectToolcraftProductSource({
     repoPath,
     sourceFile,
   });
+  const inspectControls = createToolcraftProductControlInspector({
+    checker,
+    getNodeLocation,
+    repoPath,
+    resolveStaticString,
+    sourceFile,
+  });
 
   function report(node, moduleSpecifier, moduleKind, importedName) {
     if (importedName && !isForbiddenNamedExport(moduleKind, importedName)) {
@@ -168,19 +122,7 @@ export function inspectToolcraftProductSource({
       createViolation({
         getNodeLocation,
         importedName,
-        kind:
-          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)
-              ? "runtime-model-presentation-ownership"
-              : "runtime-surface"
-            : moduleKind === "runtime-model-import"
-              ? "runtime-model-import-ownership"
-              : "built-in-control",
+        kind: getImportViolationKind(moduleKind, importedName),
         moduleSpecifier,
         node,
         repoPath,
@@ -190,7 +132,25 @@ export function inspectToolcraftProductSource({
   }
 
   function getModuleKind(moduleSpecifier) {
-    return getSensitiveModuleKind(absolutePath, moduleSpecifier, rootDir);
+    return getToolcraftSensitiveModuleKind({
+      moduleSpecifier,
+      rootDir,
+      sourceFilePath: absolutePath,
+    });
+  }
+
+  function inspectModuleSpecifier(node, moduleSpecifier) {
+    const moduleKind = getModuleKind(moduleSpecifier);
+    if (!moduleKind) return null;
+    if (moduleKind === "ui-control-implementation") {
+      report(node, moduleSpecifier, moduleKind);
+      return null;
+    }
+    if (isForbiddenToolcraftRuntimeExport(moduleKind)) {
+      report(node, moduleSpecifier, moduleKind);
+      return null;
+    }
+    return moduleKind;
   }
 
   function visit(node) {
@@ -202,6 +162,7 @@ export function inspectToolcraftProductSource({
         sourceFile,
       }),
       ...inspectExportMechanics(node),
+      ...inspectControls.inspectNode(node),
     );
 
     if (
@@ -209,7 +170,7 @@ export function inspectToolcraftProductSource({
       ts.isStringLiteralLike(node.moduleSpecifier)
     ) {
       const moduleSpecifier = node.moduleSpecifier.text;
-      const moduleKind = getModuleKind(moduleSpecifier);
+      const moduleKind = inspectModuleSpecifier(node, moduleSpecifier);
       const importClause = node.importClause;
 
       if (moduleKind && importClause && !importClause.isTypeOnly) {
@@ -238,7 +199,7 @@ export function inspectToolcraftProductSource({
       ts.isStringLiteralLike(node.moduleSpecifier)
     ) {
       const moduleSpecifier = node.moduleSpecifier.text;
-      const moduleKind = getModuleKind(moduleSpecifier);
+      const moduleKind = inspectModuleSpecifier(node, moduleSpecifier);
 
       if (moduleKind && !node.isTypeOnly) {
         if (!node.exportClause || ts.isNamespaceExport(node.exportClause)) {
@@ -260,14 +221,23 @@ export function inspectToolcraftProductSource({
 
     if (
       ts.isImportEqualsDeclaration(node) &&
-      !node.isTypeOnly &&
       ts.isExternalModuleReference(node.moduleReference) &&
       node.moduleReference.expression &&
       ts.isStringLiteralLike(node.moduleReference.expression)
     ) {
       const moduleSpecifier = node.moduleReference.expression.text;
-      const moduleKind = getModuleKind(moduleSpecifier);
-      if (moduleKind) report(node, moduleSpecifier, moduleKind);
+      const moduleKind = inspectModuleSpecifier(node, moduleSpecifier);
+      if (moduleKind && !node.isTypeOnly) {
+        report(node, moduleSpecifier, moduleKind);
+      }
+    }
+
+    if (
+      ts.isImportTypeNode(node) &&
+      ts.isLiteralTypeNode(node.argument) &&
+      ts.isStringLiteralLike(node.argument.literal)
+    ) {
+      inspectModuleSpecifier(node, node.argument.literal.text);
     }
 
     if (
@@ -288,7 +258,7 @@ export function inspectToolcraftProductSource({
         ts.forEachChild(node, visit);
         return;
       }
-      const moduleKind = getModuleKind(moduleSpecifier);
+      const moduleKind = inspectModuleSpecifier(node, moduleSpecifier);
       if (moduleKind) report(node, moduleSpecifier, moduleKind);
     }
 

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

@@ -0,0 +1,101 @@
+import path from "node:path";
+
+import {
+  getToolcraftProductExportModuleKind,
+} from "./toolcraft-product-export-boundary.mjs";
+import {
+  isToolcraftPrivateControlImplementationModule,
+} from "./toolcraft-product-control-boundary.mjs";
+
+function toPosixPath(value) {
+  return value.split(path.sep).join("/");
+}
+
+function resolveSpecifierPath(sourceFilePath, moduleSpecifier, rootDir) {
+  if (moduleSpecifier.startsWith("@/") || moduleSpecifier.startsWith("#/")) {
+    return toPosixPath(path.resolve(rootDir, "src", moduleSpecifier.slice(2)));
+  }
+  if (moduleSpecifier.startsWith("/")) {
+    return toPosixPath(path.resolve(rootDir, moduleSpecifier.slice(1)));
+  }
+  if (moduleSpecifier.startsWith(".")) {
+    return toPosixPath(path.resolve(path.dirname(sourceFilePath), moduleSpecifier));
+  }
+  return null;
+}
+
+export function getToolcraftSensitiveModuleKind({
+  moduleSpecifier,
+  rootDir,
+  sourceFilePath,
+}) {
+  const normalizedSpecifier = moduleSpecifier.replaceAll("\\", "/");
+  const resolvedSpecifier = resolveSpecifierPath(
+    sourceFilePath,
+    normalizedSpecifier,
+    rootDir,
+  );
+  const exportModuleKind = getToolcraftProductExportModuleKind(
+    normalizedSpecifier,
+    resolvedSpecifier,
+  );
+  if (exportModuleKind) return exportModuleKind;
+
+  if (
+    isToolcraftPrivateControlImplementationModule({
+      moduleSpecifier: normalizedSpecifier,
+      resolvedSpecifier,
+    })
+  ) {
+    return "ui-control-implementation";
+  }
+
+  if (
+    /^@repo\/toolcraft-runtime\/react\/model-rendering(?:\/|$)/u.test(
+      normalizedSpecifier,
+    ) ||
+    /^[#@]\/toolcraft\/runtime\/react\/model-rendering(?:\/|$)/u.test(
+      normalizedSpecifier,
+    ) ||
+    resolvedSpecifier?.includes("/src/toolcraft/runtime/react/model-rendering")
+  ) {
+    return "runtime-model-presentation";
+  }
+
+  if (
+    /^three\/(?:addons|examples\/jsm)\/loaders(?:\/|$)/u.test(
+      normalizedSpecifier,
+    ) ||
+    /^@gltf-transform(?:\/|$)/u.test(normalizedSpecifier) ||
+    /^@repo\/toolcraft-runtime\/model-import(?:\/|$)/u.test(
+      normalizedSpecifier,
+    ) ||
+    /^[#@]\/toolcraft\/runtime\/model-import(?:\/|$)/u.test(
+      normalizedSpecifier,
+    ) ||
+    resolvedSpecifier?.includes("/src/toolcraft/runtime/model-import")
+  ) {
+    return "runtime-model-import";
+  }
+
+  if (
+    /^@repo\/toolcraft-runtime\/react(?:\/|$)/u.test(normalizedSpecifier) ||
+    /^[#@]\/toolcraft\/runtime\/react(?:\/|$)/u.test(normalizedSpecifier) ||
+    resolvedSpecifier?.includes("/src/toolcraft/runtime/react")
+  ) {
+    return "runtime-react";
+  }
+
+  if (
+    /^@repo\/ui(?:\/controls(?:\/|$)|$)/u.test(normalizedSpecifier) ||
+    /^[#@]\/toolcraft\/ui(?:\/components\/controls(?:\/|$)|\/controls(?:\/|$)|$)/u.test(
+      normalizedSpecifier,
+    ) ||
+    resolvedSpecifier?.includes("/src/toolcraft/ui/components/controls") ||
+    /\/src\/toolcraft\/ui$/u.test(resolvedSpecifier ?? "")
+  ) {
+    return "ui-controls";
+  }
+
+  return null;
+}

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

@@ -75,32 +75,6 @@ test("checks Vite root-absolute imports against the same product boundary", asyn
   );
 });
 
-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("keeps model import, topology, and repair infrastructure runtime-owned", async (context) => {
   const rootDir = await createFixture(context, {
     "src/features/direct-loaders.ts": `
@@ -143,52 +117,6 @@ 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-control-bindings.mjs

@@ -0,0 +1,182 @@
+import ts from "typescript";
+
+const workspaceUiPrimitiveModulePattern =
+  /^@repo\/ui(?:$|\/(?:src\/)?(?:components\/)?primitives(?:\/|$))/u;
+
+function isToolcraftPublicUiPrimitiveModule(moduleSpecifier) {
+  const normalizedSpecifier = moduleSpecifier.replaceAll("\\", "/");
+
+  return (
+    workspaceUiPrimitiveModulePattern.test(normalizedSpecifier) ||
+    /^[#@]\/toolcraft\/ui$/u.test(normalizedSpecifier) ||
+    /^[#@]\/toolcraft\/ui\/primitives(?:\/|$)/u.test(normalizedSpecifier) ||
+    /^[#@]\/toolcraft\/ui\/components\/primitives(?:\/|$)/u.test(
+      normalizedSpecifier,
+    )
+  );
+}
+
+function unwrapExpression(node) {
+  let current = node;
+
+  while (
+    ts.isAwaitExpression(current) ||
+    ts.isParenthesizedExpression(current) ||
+    ts.isAsExpression(current) ||
+    ts.isTypeAssertionExpression(current) ||
+    ts.isSatisfiesExpression(current) ||
+    ts.isNonNullExpression(current)
+  ) {
+    current = current.expression;
+  }
+
+  return current;
+}
+
+function getImportModuleSpecifier(declaration) {
+  if (ts.isImportSpecifier(declaration)) {
+    const importDeclaration = declaration.parent.parent.parent;
+    return ts.isImportDeclaration(importDeclaration) &&
+      ts.isStringLiteralLike(importDeclaration.moduleSpecifier)
+      ? importDeclaration.moduleSpecifier.text
+      : null;
+  }
+
+  if (ts.isNamespaceImport(declaration)) {
+    const importDeclaration = declaration.parent.parent;
+    return ts.isImportDeclaration(importDeclaration) &&
+      ts.isStringLiteralLike(importDeclaration.moduleSpecifier)
+      ? importDeclaration.moduleSpecifier.text
+      : null;
+  }
+
+  if (ts.isImportClause(declaration)) {
+    const importDeclaration = declaration.parent;
+    return ts.isImportDeclaration(importDeclaration) &&
+      ts.isStringLiteralLike(importDeclaration.moduleSpecifier)
+      ? importDeclaration.moduleSpecifier.text
+      : null;
+  }
+
+  return null;
+}
+
+export function createToolcraftUiInputBindingTracker({
+  checker,
+  resolveStaticString,
+}) {
+  const bindingKinds = new Map();
+  const resolvingSymbols = new Set();
+
+  function classifyExpression(expression) {
+    const current = unwrapExpression(expression);
+
+    if (ts.isIdentifier(current)) {
+      const symbol = checker.getSymbolAtLocation(current);
+      return symbol ? classifySymbol(symbol) : null;
+    }
+
+    if (
+      ts.isPropertyAccessExpression(current) &&
+      current.name.text === "Input" &&
+      classifyExpression(current.expression) === "namespace"
+    ) {
+      return "input";
+    }
+
+    if (
+      ts.isCallExpression(current) &&
+      current.arguments.length > 0 &&
+      (current.expression.kind === ts.SyntaxKind.ImportKeyword ||
+        (ts.isIdentifier(current.expression) &&
+          current.expression.text === "require"))
+    ) {
+      const moduleSpecifier = resolveStaticString(current.arguments[0]);
+      return moduleSpecifier &&
+        isToolcraftPublicUiPrimitiveModule(moduleSpecifier)
+        ? "namespace"
+        : null;
+    }
+
+    return null;
+  }
+
+  function classifyDeclaration(declaration) {
+    if (ts.isImportSpecifier(declaration)) {
+      const importedName = declaration.propertyName?.text ?? declaration.name.text;
+      const moduleSpecifier = getImportModuleSpecifier(declaration);
+      return importedName === "Input" &&
+        moduleSpecifier &&
+        isToolcraftPublicUiPrimitiveModule(moduleSpecifier)
+        ? "input"
+        : null;
+    }
+
+    if (ts.isNamespaceImport(declaration)) {
+      const moduleSpecifier = getImportModuleSpecifier(declaration);
+      return moduleSpecifier &&
+        isToolcraftPublicUiPrimitiveModule(moduleSpecifier)
+        ? "namespace"
+        : null;
+    }
+
+    if (ts.isImportClause(declaration)) {
+      const moduleSpecifier = getImportModuleSpecifier(declaration);
+      return moduleSpecifier &&
+        isToolcraftPublicUiPrimitiveModule(moduleSpecifier) &&
+        /(?:^|\/)input(?:\.[cm]?[jt]sx?)?$/iu.test(moduleSpecifier)
+        ? "input"
+        : null;
+    }
+
+    if (
+      ts.isImportEqualsDeclaration(declaration) &&
+      ts.isExternalModuleReference(declaration.moduleReference) &&
+      declaration.moduleReference.expression &&
+      ts.isStringLiteralLike(declaration.moduleReference.expression) &&
+      isToolcraftPublicUiPrimitiveModule(declaration.moduleReference.expression.text)
+    ) {
+      return "namespace";
+    }
+
+    if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+      return classifyExpression(declaration.initializer);
+    }
+
+    if (
+      ts.isBindingElement(declaration) &&
+      !declaration.dotDotDotToken &&
+      (declaration.propertyName?.getText() ?? declaration.name.getText()) ===
+        "Input"
+    ) {
+      const variableDeclaration = declaration.parent.parent;
+      return ts.isVariableDeclaration(variableDeclaration) &&
+        variableDeclaration.initializer &&
+        classifyExpression(variableDeclaration.initializer) === "namespace"
+        ? "input"
+        : null;
+    }
+
+    return null;
+  }
+
+  function classifySymbol(symbol) {
+    if (bindingKinds.has(symbol)) return bindingKinds.get(symbol);
+    if (resolvingSymbols.has(symbol)) return null;
+
+    resolvingSymbols.add(symbol);
+    const bindingKind =
+      symbol.declarations
+        ?.map(classifyDeclaration)
+        .find((candidate) => candidate !== null) ?? null;
+    resolvingSymbols.delete(symbol);
+    bindingKinds.set(symbol, bindingKind);
+    return bindingKind;
+  }
+
+  function isTrackedInputTag(tagName) {
+    return classifyExpression(tagName) === "input";
+  }
+
+  return { isTrackedInputTag };
+}