@pixel-point/toolcraft 0.0.16 → 0.0.18

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

@@ -1,11 +1,15 @@
-import path from "node:path";
-
 import ts from "typescript";
 
 import {
   builtInControlExportNames,
   runtimeSurfaceComponentNames,
 } from "./toolcraft-integrity-policy.mjs";
+import {
+  createToolcraftProductExportInspector,
+  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);
@@ -18,82 +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,
-  );
-
-  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 (moduleKind === "ui-control-implementation") return true;
+  if (isForbiddenToolcraftRuntimeExport(moduleKind)) return true;
   if (
     moduleKind === "runtime-model-import" ||
     moduleKind === "runtime-model-presentation"
@@ -106,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 and let runtime export actions encode 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,
@@ -116,24 +83,17 @@ function createViolation({
   sourceFile,
 }) {
   const subject = importedName ? ` ${importedName}` : "";
-  const message =
-    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,
@@ -141,6 +101,18 @@ export function inspectToolcraftProductSource({
   sourceFile,
 }) {
   const violations = [];
+  const inspectExportMechanics = createToolcraftProductExportInspector({
+    getNodeLocation,
+    repoPath,
+    sourceFile,
+  });
+  const inspectControls = createToolcraftProductControlInspector({
+    checker,
+    getNodeLocation,
+    repoPath,
+    resolveStaticString,
+    sourceFile,
+  });
 
   function report(node, moduleSpecifier, moduleKind, importedName) {
     if (importedName && !isForbiddenNamedExport(moduleKind, importedName)) {
@@ -150,16 +122,7 @@ export function inspectToolcraftProductSource({
       createViolation({
         getNodeLocation,
         importedName,
-        kind:
-          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,
@@ -169,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) {
@@ -180,6 +161,8 @@ export function inspectToolcraftProductSource({
         resolveStaticString,
         sourceFile,
       }),
+      ...inspectExportMechanics(node),
+      ...inspectControls.inspectNode(node),
     );
 
     if (
@@ -187,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) {
@@ -216,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)) {
@@ -238,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 (
@@ -266,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.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

@@ -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": `