@pixel-point/toolcraft 0.0.15 → 0.0.17

package/templates/starter/scripts/check-toolcraft-code-health.test.mjs

@@ -9,6 +9,8 @@ import {
   codeHealthPassed,
   getLineBudgetViolations,
 } from "./toolcraft-code-health-core.mjs";
+import { createToolcraftLocalDependencyGraph } from "./toolcraft-local-dependency-graph.mjs";
+import { collectToolcraftSourceInventory } from "./toolcraft-source-inventory.mjs";
 
 async function withFixture(files, assertion, prepare = async () => undefined) {
   const fixtureRoot = await fs.mkdtemp(
@@ -152,6 +154,39 @@ test("generated code health ignores immutable copied runtime source", async () =
   );
 });
 
+test("generated code health rejects unsigned ownership manifest claims", async () => {
+  await withFixture(
+    {
+      "scripts/platform-runner.mjs": "export const platform = 1;\n".repeat(501),
+      "src/app/product.ts": "export const product = 1;\n",
+    },
+    (result) => {
+      assert.equal(result.sourceFileCount, 2);
+      assert.deepEqual(
+        result.lineBudgetViolations.map(({ repoPath, scope }) => ({
+          repoPath,
+          scope,
+        })),
+        [{ repoPath: "scripts/platform-runner.mjs", scope: "scripts/" }],
+      );
+      assert.deepEqual(result.forbiddenPatternViolations, []);
+    },
+    async (rootDir) => {
+      const manifestPath = path.join(
+        rootDir,
+        "src/toolcraft/.toolcraft-manifest.json",
+      );
+      await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+      await fs.writeFile(
+        manifestPath,
+        JSON.stringify({
+          protectedFiles: { "scripts/platform-runner.mjs": "signed" },
+        }),
+      );
+    },
+  );
+});
+
 test("generated code health rejects product cycles resolved through tsconfig aliases", async () => {
   await withFixture(
     {
@@ -178,6 +213,122 @@ test("generated code health rejects product cycles resolved through tsconfig ali
   );
 });
 
+test("generated code health includes the product boundary in the shared proof", async () => {
+  await withFixture(
+    {
+      "src/app/product.ts":
+        'import { fixture } from "@/app/product.test";\nvoid fixture;\n',
+      "src/app/product.test.ts": "export const fixture = true;\n",
+    },
+    (result) => {
+      assert.deepEqual(
+        result.productBoundary.violations.map(({ kind }) => kind),
+        ["production-test-import"],
+      );
+      assert.equal(codeHealthPassed(result), false);
+    },
+  );
+});
+
+test("shared proof resolves copied runtime imports without checking framework budgets", async () => {
+  await withFixture(
+    {
+      "src/app/product.ts":
+        'import { runtime } from "@/toolcraft/runtime";\nvoid runtime;\n',
+      "src/toolcraft/runtime/index.ts":
+        "export const runtime = true;\n".repeat(1500),
+    },
+    (result) => {
+      assert.equal(result.sourceFileCount, 1);
+      assert.deepEqual(result.lineBudgetViolations, []);
+      assert.deepEqual(result.forbiddenPatternViolations, []);
+      assert.deepEqual(result.productBoundary.violations, []);
+    },
+  );
+});
+
+test("generated proof constructs and shares one inventory and one graph", async () => {
+  const scriptsDir = import.meta.dirname;
+  const generatedCheckSource = await fs.readFile(
+    path.join(scriptsDir, "check-toolcraft-code-health.mjs"),
+    "utf8",
+  );
+  assert.equal(
+    generatedCheckSource.match(/collectToolcraftSourceInventory\(\{/gu)?.length,
+    1,
+  );
+  assert.equal(
+    generatedCheckSource.match(/createToolcraftLocalDependencyGraph\(\{/gu)
+      ?.length,
+    1,
+  );
+  assert.equal(
+    generatedCheckSource.match(/\binventory,\n\s+localDependencyGraph,/gu)
+      ?.length,
+    2,
+  );
+
+  const boundarySource = await fs.readFile(
+    path.join(scriptsDir, "toolcraft-product-boundary.mjs"),
+    "utf8",
+  );
+  assert.doesNotMatch(
+    boundarySource,
+    /collectToolcraftModuleSpecifiers|createSourceFile|fsPromises|readFile|resolveToolcraftLocalDependency/u,
+  );
+  const graphSource = await fs.readFile(
+    path.join(scriptsDir, "toolcraft-local-dependency-graph.mjs"),
+    "utf8",
+  );
+  assert.match(
+    graphSource,
+    /createToolcraftDependencySourceRecord/u,
+  );
+  const dependencySource = await fs.readFile(
+    path.join(scriptsDir, "toolcraft-dependency-source-record.mjs"),
+    "utf8",
+  );
+  assert.equal(dependencySource.match(/await fs\.readFile\(/gu)?.length, 1);
+  assert.equal(
+    dependencySource.match(
+      /createToolcraftTypeScriptSourceRecord\(\{/gu,
+    )?.length,
+    1,
+  );
+});
+
+test("legacy graph and private product-boundary resolver are removed", async () => {
+  const scriptsDir = import.meta.dirname;
+  const legacyGraphName = ["toolcraft-product", "dependency-graph.mjs"].join(
+    "-",
+  );
+  await assert.rejects(
+    fs.access(path.join(scriptsDir, legacyGraphName)),
+    { code: "ENOENT" },
+  );
+  const boundarySource = await fs.readFile(
+    path.join(scriptsDir, "toolcraft-product-boundary.mjs"),
+    "utf8",
+  );
+  assert.doesNotMatch(boundarySource, /resolveLocalEntry/u);
+  const rootDir = path.resolve(scriptsDir, "..");
+  const inventory = await collectToolcraftSourceInventory({
+    rootDir,
+    sourceRoots: ["scripts"],
+  });
+  const graph = await createToolcraftLocalDependencyGraph({
+    entries: inventory.entries,
+    rootDir,
+  });
+  const legacyImporters = graph.moduleImports
+    .filter(
+      ({ specifier }) =>
+        specifier && path.posix.basename(specifier) === legacyGraphName,
+    )
+    .map(({ importerRepoPath }) => importerRepoPath);
+  assert.deepEqual(legacyImporters, []);
+});
+
 test("generated code health scans supported JavaScript and TypeScript module extensions", async () => {
   await withFixture(
     { "src/features/oversized.jsx": "export const value = 1;\n".repeat(1001) },

package/templates/starter/scripts/check-toolcraft-docs.mjs

@@ -61,9 +61,8 @@ const requiredWorkflowTerms = [
   "Verification Tier Classifier",
   "Verification tier: Tier N",
   "Open exactly one listed document per terminal or tool read",
-  "pnpm verify:quick",
-  "pnpm verify:perf",
-  "pnpm verify:final",
+  "coherent user-visible delivery batch",
+  "pnpm verify:delivery",
 ];
 
 const repoScope = "@repo";
@@ -76,6 +75,18 @@ const forbiddenTextPatterns = [
   /\bAI Assembly\b/,
   /How AI/,
 ];
+const forbiddenModelContractPatterns = [
+  /\bgeometry-only (?:3D )?model(?:s| bundle| bundles| app| apps| default)?\b/iu,
+];
+const forbiddenPerformanceRoutingPatterns = [
+  /for a performance complaint only,\s+an exact request quote and the canonical affected performance path ids/iu,
+  /(?:\*\*)?performance complaint(?::\*\*|\.\*\*)[^\n]*(?:canonical affected path ids|targeted iteration)/iu,
+  /\ba performance complaint records[^\n]*(?:canonical affected path ids|targeted iteration)/iu,
+  /unresolved\s+`?needs-agent-judgment`?[^\n]*(?:creates neither|records neither|no `?performance intent)/iu,
+  /for unresolved\s+`?needs-agent-judgment`?[^\n]*no `?performance intent/iu,
+  /direct reports that the app lags[^\n]*select one performance iteration/iu,
+  /independent complaint still selects an iteration/iu,
+];
 
 async function readText(relativePath) {
   return fs.readFile(path.join(projectRoot, relativePath), "utf8");
@@ -145,6 +156,10 @@ for (const fileName of [...requiredDocs, ...requiredCoreDocs]) {
 
 const combinedSource = docsSources.join("\n");
 const workflowSource = await readText("docs/toolcraft/workflow.md");
+const mediaUploadSource = await readText("docs/toolcraft/core/media-upload.md");
+const runtimeBoundarySource = await readText("docs/toolcraft/core/runtime-boundary.md");
+const rendererTechniqueSource = await readText("docs/toolcraft/renderer-technique.md");
+const acceptanceSource = await readText("docs/toolcraft/acceptance-testing.md");
 
 failures.push(
   ...(await getToolcraftWorkflowRouteFailures({
@@ -160,6 +175,54 @@ for (const pattern of forbiddenTextPatterns) {
   }
 }
 
+for (const pattern of forbiddenModelContractPatterns) {
+  if (pattern.test(combinedSource)) {
+    failures.push(`local Toolcraft docs contain obsolete model contract ${pattern}`);
+  }
+}
+
+for (const pattern of forbiddenPerformanceRoutingPatterns) {
+  if (pattern.test(combinedSource)) {
+    failures.push(
+      `local Toolcraft docs contain unconditional complaint routing ${pattern}`,
+    );
+  }
+}
+
+for (const term of [
+  "bounded ZIP",
+  "Blender-compatible fallback",
+  "modelPresentation",
+]) {
+  if (!mediaUploadSource.includes(term)) {
+    failures.push(`docs/toolcraft/core/media-upload.md must mention "${term}"`);
+  }
+}
+
+if (!runtimeBoundarySource.includes("modelPresentation")) {
+  failures.push("docs/toolcraft/core/runtime-boundary.md must define modelPresentation");
+}
+if (!runtimeBoundarySource.includes("does not suppress runtime model layers")) {
+  failures.push(
+    "docs/toolcraft/core/runtime-boundary.md must state that renderDefaultCanvasMedia does not suppress runtime model layers",
+  );
+}
+if (!rendererTechniqueSource.includes("useToolcraftModelPresentationConsumer")) {
+  failures.push(
+    "docs/toolcraft/renderer-technique.md must show the checked custom model presentation consumer",
+  );
+}
+for (const term of [
+  "package-extraction",
+  "appearance-preservation",
+  "presentation-consumer-readiness",
+  "pixel-output",
+]) {
+  if (!acceptanceSource.includes(term)) {
+    failures.push(`docs/toolcraft/acceptance-testing.md must mention "${term}"`);
+  }
+}
+
 for (const localDoc of requiredAgentsEntryLinks) {
   if (!agentsSource.includes(`docs/toolcraft/${localDoc}`)) {
     failures.push(`AGENTS.md must link docs/toolcraft/${localDoc}`);

package/templates/starter/scripts/check-toolcraft-integrity.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import crypto from "node:crypto";
+import { realpathSync } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -12,11 +13,13 @@ import {
   requiredProtectedTrustRootFilePaths,
   reservedGeneratedVerificationConfigPatterns,
 } from "./toolcraft-integrity-policy.mjs";
+import {
+  assertToolcraftVerificationInventoryProvenance,
+  collectToolcraftVerificationInputs,
+} from "./toolcraft-verification-inventory.mjs";
 
 const appRoot = path.resolve(fileURLToPath(new URL("..", import.meta.url)));
-const platformOnly = process.argv.includes("--platform-only");
-const toolcraftRoot = path.join(appRoot, "src/toolcraft");
-const manifestPath = path.join(toolcraftRoot, ".toolcraft-manifest.json");
+const manifestRepoPath = "src/toolcraft/.toolcraft-manifest.json";
 
 async function pathExists(filePath) {
   try {
@@ -27,9 +30,12 @@ async function pathExists(filePath) {
   }
 }
 
+function sha256(value) {
+  return crypto.createHash("sha256").update(value).digest("hex");
+}
+
 async function hashFile(filePath) {
-  const buffer = await fs.readFile(filePath);
-  return crypto.createHash("sha256").update(buffer).digest("hex");
+  return sha256(await fs.readFile(filePath));
 }
 
 function reportIntegrityFailures(failures) {
@@ -44,8 +50,6 @@ function reportIntegrityFailures(failures) {
   for (const failure of failures) {
     console.error(`- ${failure}`);
   }
-
-  process.exit(1);
 }
 
 async function collectToolcraftInventory(rootDir) {
@@ -83,147 +87,255 @@ async function collectToolcraftInventory(rootDir) {
   };
 }
 
-if (!(await pathExists(toolcraftRoot))) {
-  reportIntegrityFailures([
-    "Missing generated Toolcraft source tree src/toolcraft.",
-  ]);
-}
+async function collectIntegrityFailures({ platformOnly, rootDir }) {
+  const toolcraftRoot = path.join(rootDir, "src/toolcraft");
+  const manifestPath = path.join(rootDir, ...manifestRepoPath.split("/"));
 
-if (!(await pathExists(manifestPath))) {
-  reportIntegrityFailures([
-    "Missing src/toolcraft/.toolcraft-manifest.json; generated apps must preserve the integrity manifest.",
-  ]);
-}
+  if (!(await pathExists(toolcraftRoot))) {
+    return {
+      failures: ["Missing generated Toolcraft source tree src/toolcraft."],
+    };
+  }
 
-const manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
-const manifestValidation = validateIntegrityManifest({
-  appRoot,
-  manifest,
-  requiredPackageScriptNames,
-  requiredProtectedTrustRootFilePaths,
-  toolcraftRoot,
-});
+  if (!(await pathExists(manifestPath))) {
+    return {
+      failures: [
+        "Missing src/toolcraft/.toolcraft-manifest.json; generated apps must preserve the integrity manifest.",
+      ],
+    };
+  }
 
-if (manifestValidation.failures.length > 0) {
-  reportIntegrityFailures(manifestValidation.failures);
-}
+  const manifestBuffer = await fs.readFile(manifestPath);
+  const manifestHash = sha256(manifestBuffer);
+  const manifest = JSON.parse(manifestBuffer.toString("utf8"));
+  const manifestValidation = validateIntegrityManifest({
+    appRoot: rootDir,
+    manifest,
+    requiredPackageScriptNames,
+    requiredProtectedTrustRootFilePaths,
+    toolcraftRoot,
+  });
 
-const {
-  expectedPackageScripts,
-  resolvedExpectedFiles,
-  resolvedProtectedFiles,
-} = manifestValidation;
-
-const toolcraftInventory = await collectToolcraftInventory(toolcraftRoot);
-const actualFiles = toolcraftInventory.files;
-const actualFileSet = new Set(actualFiles);
-const failures = toolcraftInventory.unsupportedEntries.map(
-  (relativePath) => `unsupported Toolcraft entry ${relativePath}`,
-);
-
-const rootEntries = await fs.readdir(appRoot, { withFileTypes: true });
-for (const entry of rootEntries) {
-  if (
-    reservedGeneratedVerificationConfigPatterns.some((pattern) =>
-      pattern.test(entry.name),
-    ) &&
-    !resolvedProtectedFiles.has(entry.name)
-  ) {
-    failures.push(`unapproved verification config ${entry.name}`);
+  if (manifestValidation.failures.length > 0) {
+    return {
+      failures: manifestValidation.failures,
+      manifestHash,
+    };
   }
-}
 
-try {
-  const packageJson = JSON.parse(
-    await fs.readFile(path.join(appRoot, "package.json"), "utf8"),
+  const {
+    expectedPackageScripts,
+    resolvedExpectedFiles,
+    resolvedProtectedFiles,
+  } = manifestValidation;
+
+  const toolcraftInventory = await collectToolcraftInventory(toolcraftRoot);
+  const actualFiles = toolcraftInventory.files;
+  const actualFileSet = new Set(actualFiles);
+  const failures = toolcraftInventory.unsupportedEntries.map(
+    (relativePath) => `unsupported Toolcraft entry ${relativePath}`,
   );
-  const actualPackageScripts = packageJson.scripts ?? {};
 
-  for (const [scriptName, expectedCommand] of expectedPackageScripts) {
-    if (actualPackageScripts[scriptName] !== expectedCommand) {
-      failures.push(`modified package script ${scriptName}`);
+  const rootEntries = await fs.readdir(rootDir, { withFileTypes: true });
+  for (const entry of rootEntries) {
+    if (
+      reservedGeneratedVerificationConfigPatterns.some((pattern) =>
+        pattern.test(entry.name),
+      ) &&
+      !resolvedProtectedFiles.has(entry.name)
+    ) {
+      failures.push(`unapproved verification config ${entry.name}`);
     }
   }
 
-  for (const scriptName of Object.keys(actualPackageScripts)) {
-    const lifecycleTarget = scriptName.startsWith("pre")
-      ? scriptName.slice("pre".length)
-      : scriptName.startsWith("post")
-        ? scriptName.slice("post".length)
-        : "";
+  try {
+    const packageJson = JSON.parse(
+      await fs.readFile(path.join(rootDir, "package.json"), "utf8"),
+    );
+    const actualPackageScripts = packageJson.scripts ?? {};
+
+    for (const [scriptName, expectedCommand] of expectedPackageScripts) {
+      if (actualPackageScripts[scriptName] !== expectedCommand) {
+        failures.push(`modified package script ${scriptName}`);
+      }
+    }
 
-    if (
-      expectedPackageScripts.has(lifecycleTarget) &&
-      !expectedPackageScripts.has(scriptName)
-    ) {
-      failures.push(`added package lifecycle script ${scriptName}`);
+    for (const scriptName of Object.keys(actualPackageScripts)) {
+      const lifecycleTarget = scriptName.startsWith("pre")
+        ? scriptName.slice("pre".length)
+        : scriptName.startsWith("post")
+          ? scriptName.slice("post".length)
+          : "";
+
+      if (
+        expectedPackageScripts.has(lifecycleTarget) &&
+        !expectedPackageScripts.has(scriptName)
+      ) {
+        failures.push(`added package lifecycle script ${scriptName}`);
+      }
     }
+  } catch {
+    failures.push("missing or invalid package.json");
   }
-} catch {
-  failures.push("missing or invalid package.json");
-}
-
-if (!platformOnly) {
-  const {
-    evaluateToolcraftProductBoundary,
-    printToolcraftProductBoundaryResult,
-    toolcraftProductBoundaryPassed,
-  } = await import("./toolcraft-product-boundary.mjs");
-  const productBoundaryResult = await evaluateToolcraftProductBoundary({
-    protectedFilePaths: resolvedProtectedFiles.keys(),
-    rootDir: appRoot,
-  });
 
-  if (!toolcraftProductBoundaryPassed(productBoundaryResult)) {
-    const boundaryMessages = [];
-    printToolcraftProductBoundaryResult(productBoundaryResult, {
-      error(message) {
-        boundaryMessages.push(message.replace(/^- /u, ""));
-      },
+  if (!platformOnly) {
+    const {
+      evaluateToolcraftProductBoundary,
+      printToolcraftProductBoundaryResult,
+      toolcraftProductBoundaryPassed,
+    } = await import("./toolcraft-product-boundary.mjs");
+    const productBoundaryResult = await evaluateToolcraftProductBoundary({
+      protectedFilePaths: [...resolvedProtectedFiles.keys()],
+      rootDir,
     });
-    failures.push(...boundaryMessages);
+
+    if (!toolcraftProductBoundaryPassed(productBoundaryResult)) {
+      const boundaryMessages = [];
+      printToolcraftProductBoundaryResult(productBoundaryResult, {
+        error(message) {
+          boundaryMessages.push(message.replace(/^- /u, ""));
+        },
+      });
+      failures.push(...boundaryMessages);
+    }
   }
-}
 
-for (const [relativePath, { expectedHash, filePath }] of resolvedExpectedFiles) {
-  if (!actualFileSet.has(relativePath)) {
-    failures.push(`deleted ${relativePath}`);
-    continue;
+  for (const [
+    relativePath,
+    { expectedHash, filePath },
+  ] of resolvedExpectedFiles) {
+    if (!actualFileSet.has(relativePath)) {
+      failures.push(`deleted ${relativePath}`);
+      continue;
+    }
+
+    const actualHash = await hashFile(filePath);
+
+    if (actualHash !== expectedHash) {
+      failures.push(`modified ${relativePath}`);
+    }
+  }
+
+  for (const relativePath of actualFiles) {
+    if (!resolvedExpectedFiles.has(relativePath)) {
+      failures.push(`added ${relativePath}`);
+    }
   }
 
-  const actualHash = await hashFile(filePath);
+  for (const [
+    relativePath,
+    { expectedHash, filePath },
+  ] of resolvedProtectedFiles) {
+    if (!(await pathExists(filePath))) {
+      failures.push(`deleted ${relativePath}`);
+      continue;
+    }
 
-  if (actualHash !== expectedHash) {
-    failures.push(`modified ${relativePath}`);
+    if ((await hashFile(filePath)) !== expectedHash) {
+      failures.push(`modified ${relativePath}`);
+    }
   }
+
+  failures.push(
+    ...(await getToolcraftContractDocIntegrityFailures({
+      appRoot: rootDir,
+      protectedRelativePaths: resolvedProtectedFiles.keys(),
+    })),
+  );
+
+  return { failures, manifestHash };
 }
 
-for (const relativePath of actualFiles) {
-  if (!resolvedExpectedFiles.has(relativePath)) {
-    failures.push(`added ${relativePath}`);
+export class ToolcraftIntegrityError extends Error {
+  constructor(failures) {
+    super(failures.join("\n"));
+    this.failures = Object.freeze([...failures]);
+    this.name = "ToolcraftIntegrityError";
   }
 }
 
-for (const [relativePath, { expectedHash, filePath }] of resolvedProtectedFiles) {
-  if (!(await pathExists(filePath))) {
-    failures.push(`deleted ${relativePath}`);
-    continue;
+export async function evaluateToolcraftIntegrity({
+  inventory,
+  platformOnly = false,
+  rootDir = appRoot,
+}) {
+  const resolvedRoot = path.resolve(rootDir);
+  try {
+    assertToolcraftVerificationInventoryProvenance({
+      inventory,
+      rootDir: resolvedRoot,
+    });
+  } catch (error) {
+    throw new ToolcraftIntegrityError([
+      error instanceof Error ? error.message : String(error),
+    ]);
   }
-
-  if ((await hashFile(filePath)) !== expectedHash) {
-    failures.push(`modified ${relativePath}`);
+  const result = await collectIntegrityFailures({
+    platformOnly,
+    rootDir: resolvedRoot,
+  });
+  if (result.failures.length > 0) {
+    throw new ToolcraftIntegrityError(result.failures);
+  }
+  const manifestInventoryEntry = inventory.entries.find(
+    (entry) => entry.path === manifestRepoPath,
+  );
+  if (
+    manifestInventoryEntry === undefined ||
+    manifestInventoryEntry.sha256 !== result.manifestHash
+  ) {
+    throw new ToolcraftIntegrityError([
+      "Toolcraft integrity manifest does not match the authoritative verification inventory.",
+    ]);
   }
+  return Object.freeze({
+    manifestHash: result.manifestHash,
+    sourceHash: inventory.sourceHash,
+  });
 }
 
-failures.push(
-  ...(await getToolcraftContractDocIntegrityFailures({
-    appRoot,
-    protectedRelativePaths: resolvedProtectedFiles.keys(),
-  })),
-);
+async function runCli() {
+  let inventory;
+  try {
+    inventory = await collectToolcraftVerificationInputs(appRoot);
+  } catch (error) {
+    throw new ToolcraftIntegrityError([
+      error instanceof Error ? error.message : String(error),
+    ]);
+  }
+  await evaluateToolcraftIntegrity({
+    inventory,
+    platformOnly: process.argv.includes("--platform-only"),
+  });
+  const toolcraftFileCount = inventory.entries.filter(
+    (entry) =>
+      entry.path.startsWith("src/toolcraft/") &&
+      entry.path !== manifestRepoPath,
+  ).length;
+  console.log(
+    `Toolcraft integrity check passed (${toolcraftFileCount} files).`,
+  );
+}
 
-if (failures.length > 0) {
-  reportIntegrityFailures(failures);
+function isDirectCliInvocation(argvEntry) {
+  if (!argvEntry) return false;
+  try {
+    return (
+      realpathSync(path.resolve(argvEntry)) ===
+      realpathSync(fileURLToPath(import.meta.url))
+    );
+  } catch {
+    return false;
+  }
 }
 
-console.log(`Toolcraft integrity check passed (${actualFiles.length} files).`);
+if (isDirectCliInvocation(process.argv[1])) {
+  runCli().catch((error) => {
+    if (error instanceof ToolcraftIntegrityError) {
+      reportIntegrityFailures(error.failures);
+    } else {
+      console.error(error instanceof Error ? error.message : error);
+    }
+    process.exitCode = 1;
+  });
+}