@elench/testkit 0.1.65 → 0.1.67

package/lib/cli/command-helpers.mjs

@@ -1,6 +1,6 @@
 import path from "path";
 import { Flags } from "@oclif/core";
-import { loadConfigs } from "../config/index.mjs";
+import { loadManagedConfigs } from "../app/configs.mjs";
 import {
   parseFileTimeoutOption,
   parseShardOption,
@@ -73,15 +73,7 @@ export const runFlags = {
 };
 
 export async function resolveConfigsForCommand(flags) {
-  const allConfigs = await loadConfigs({ dir: flags.dir });
-  const configs = flags.service
-    ? allConfigs.filter((config) => config.name === flags.service)
-    : allConfigs;
-  if (flags.service && configs.length === 0) {
-    const available = allConfigs.map((config) => config.name).join(", ");
-    throw new Error(`Service "${flags.service}" not found. Available: ${available}`);
-  }
-  return { allConfigs, configs };
+  return loadManagedConfigs({ dir: flags.dir, service: flags.service });
 }
 
 export async function executeRunCommand(command, flags, positionalType = null) {

package/lib/cli/commands/browser/serve.mjs

@@ -1,8 +1,6 @@
 import { Command, Flags } from "@oclif/core";
 import { startBrowserBridgeServer } from "@elench/testkit-bridge";
-import { loadConfigContext, resolveProductDir } from "../../../config/index.mjs";
-import { discoverTests } from "../../../discovery/index.mjs";
-import { loadCurrentRunArtifact } from "../../viewer.mjs";
+import { loadBrowserBridgeContext } from "../../../app/browser-bridge.mjs";
 
 export default class BrowserServeCommand extends Command {
   static summary = "Serve the local browser bridge for the current testkit product";
@@ -25,59 +23,10 @@ export default class BrowserServeCommand extends Command {
 
   async run() {
     const { flags } = await this.parse(BrowserServeCommand);
-    const productDir = resolveProductDir(process.cwd(), flags.dir);
+    const { productDir, context } = await loadBrowserBridgeContext({ dir: flags.dir });
 
     const adapter = {
-      loadProductContext: async () => {
-        const [configContext, discovery] = await Promise.all([
-          loadConfigContext({
-            dir: productDir,
-            discoveryOptions: { strict: false },
-          }),
-          discoverTests({
-            dir: productDir,
-            diagnostics: "report",
-          }),
-        ]);
-
-        return {
-          product: {
-            name: discovery.product.name,
-            directory: discovery.product.directory,
-          },
-          services: configContext.configs
-            .map((config) => {
-              const baseUrl = config.testkit.local?.baseUrl || null;
-              const browserOrigins = config.testkit.browser?.origins || [];
-              if (!baseUrl && browserOrigins.length === 0) return null;
-              const serviceEntries = [];
-              if (baseUrl && !baseUrl.includes("{port}")) {
-                try {
-                  const parsed = new URL(baseUrl);
-                  serviceEntries.push({
-                    name: config.name,
-                    baseUrl,
-                    origin: parsed.origin,
-                  });
-                } catch {
-                  // Ignore invalid local.baseUrl templates here; explicit browser origins still work.
-                }
-              }
-              for (const origin of browserOrigins) {
-                serviceEntries.push({
-                  name: config.name,
-                  baseUrl: origin,
-                  origin,
-                });
-              }
-              return serviceEntries;
-            })
-            .flat()
-            .filter(Boolean),
-          discovery,
-          runArtifact: loadRunArtifactIfPresent(productDir),
-        };
-      },
+      loadProductContext: async () => context,
     };
 
     const serverRef = await startBrowserBridgeServer(adapter, {
@@ -102,11 +51,3 @@ export default class BrowserServeCommand extends Command {
     return payload;
   }
 }
-
-function loadRunArtifactIfPresent(productDir) {
-  try {
-    return loadCurrentRunArtifact(productDir);
-  } catch {
-    return null;
-  }
-}

package/lib/cli/commands/doctor.mjs

@@ -0,0 +1,39 @@
+import { Command, Flags } from "@oclif/core";
+import { runDoctor } from "../../app/doctor.mjs";
+
+export default class DoctorCommand extends Command {
+  static summary = "Run built-in setup, discovery, and hygiene checks";
+
+  static enableJsonFlag = true;
+
+  static flags = {
+    dir: Flags.string({
+      description: "Product directory",
+    }),
+    typecheck: Flags.boolean({
+      description: "Include generated TypeScript checks",
+      default: true,
+      allowNo: true,
+    }),
+  };
+
+  async run() {
+    const { flags } = await this.parse(DoctorCommand);
+    const result = await runDoctor({ dir: flags.dir, typecheck: flags.typecheck });
+
+    if (!this.jsonEnabled()) {
+      this.log(`testkit doctor ${result.ok ? "passed" : "failed"} for ${result.productDir}`);
+      for (const check of result.checks) {
+        this.log(`${check.level.toUpperCase()} ${check.code} ${check.message}`);
+      }
+    }
+
+    if (!result.ok) {
+      const error = new Error("testkit doctor failed");
+      error.result = result;
+      throw error;
+    }
+
+    return result;
+  }
+}

package/lib/cli/commands/typecheck.mjs

@@ -0,0 +1,28 @@
+import { Command, Flags } from "@oclif/core";
+import { runTestkitTypecheck } from "../../app/typecheck.mjs";
+
+export default class TypecheckCommand extends Command {
+  static summary = "Typecheck testkit setup, helpers, and suites";
+
+  static enableJsonFlag = true;
+
+  static flags = {
+    dir: Flags.string({
+      description: "Product directory",
+    }),
+  };
+
+  async run() {
+    const { flags } = await this.parse(TypecheckCommand);
+    const result = await runTestkitTypecheck({ dir: flags.dir });
+
+    if (!this.jsonEnabled()) {
+      this.log(`Typechecked ${result.results.length} testkit program(s) in ${result.productDir}`);
+      for (const entry of result.results) {
+        this.log(`PASS ${entry.label} ${entry.tsconfigPath}`);
+      }
+    }
+
+    return result;
+  }
+}

package/lib/cli/db.mjs

@@ -1,7 +1,8 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
-import { loadConfigs, resolveProductDir } from "../config/index.mjs";
+import { loadManagedConfigs, resolveTargetConfig, collectRequiredConfigs, topologicallySortConfigs } from "../app/configs.mjs";
+import { resolveProductDir } from "../config/index.mjs";
 import { captureDatabaseTemplateSnapshot, prepareDatabaseRuntime } from "../database/index.mjs";
 import { createRunReporter } from "./presentation/run-reporter.mjs";
 import { createRunLogRegistry } from "../runner/logs.mjs";
@@ -10,7 +11,7 @@ import { resolveRuntimeInstanceConfigs } from "../runner/template.mjs";
 
 export async function runDatabaseSnapshotCaptureCommand(options = {}) {
   const productDir = resolveProductDir(process.cwd(), options.dir);
-  const configs = await loadConfigs({ dir: productDir });
+  const { configs } = await loadManagedConfigs({ dir: productDir });
   const target = resolveTargetConfig(configs, options.service);
   const outputPath = normalizeOptionalString(options.output);
   if (!outputPath) {
@@ -57,74 +58,8 @@ export async function runDatabaseSnapshotCaptureCommand(options = {}) {
   }
 }
 
-function resolveTargetConfig(configs, serviceName) {
-  if (serviceName) {
-    const match = configs.find((config) => config.name === serviceName);
-    if (!match) {
-      const available = configs.map((config) => config.name).join(", ");
-      throw new Error(`Service "${serviceName}" not found. Available: ${available}`);
-    }
-    return match;
-  }
-
-  if (configs.length === 1) return configs[0];
-  const withLocalDb = configs.filter((config) => config.testkit.database?.provider === "local");
-  if (withLocalDb.length === 1) return withLocalDb[0];
-
-  const available = configs.map((config) => config.name).join(", ");
-  throw new Error(`Multiple services available. Pass --service. Available: ${available}`);
-}
-
 function normalizeOptionalString(value) {
   if (typeof value !== "string") return null;
   const normalized = value.trim();
   return normalized.length > 0 ? normalized : null;
 }
-
-function collectRequiredConfigs(configs, targetName) {
-  const byName = new Map(configs.map((config) => [config.name, config]));
-  const required = new Set();
-
-  const visit = (name) => {
-    if (required.has(name)) return;
-    const config = byName.get(name);
-    if (!config) {
-      throw new Error(`Missing config for dependency "${name}"`);
-    }
-    required.add(name);
-    for (const depName of config.testkit.dependsOn || []) {
-      visit(depName);
-    }
-  };
-
-  visit(targetName);
-  return configs.filter((config) => required.has(config.name));
-}
-
-function topologicallySortConfigs(configs) {
-  const byName = new Map(configs.map((config) => [config.name, config]));
-  const visited = new Set();
-  const visiting = new Set();
-  const ordered = [];
-
-  const visit = (config) => {
-    if (visited.has(config.name)) return;
-    if (visiting.has(config.name)) {
-      throw new Error(`Dependency cycle while resolving snapshot capture for "${config.name}"`);
-    }
-    visiting.add(config.name);
-    for (const depName of config.testkit.dependsOn || []) {
-      const dependency = byName.get(depName);
-      if (dependency) visit(dependency);
-    }
-    visiting.delete(config.name);
-    visited.add(config.name);
-    ordered.push(config);
-  };
-
-  for (const config of configs) {
-    visit(config);
-  }
-
-  return ordered;
-}

package/lib/cli/entrypoint.mjs

@@ -9,6 +9,8 @@ export function normalizeCliArgs(argv) {
     "artifacts",
     "watch",
     "discover",
+    "typecheck",
+    "doctor",
     "browser",
     "known-failures",
     "db",

package/lib/config/binaries.mjs

@@ -0,0 +1,34 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const TESTKIT_K6_BIN = "TESTKIT_K6_BIN";
+
+export function resolveK6Binary() {
+  const override = process.env[TESTKIT_K6_BIN]?.trim();
+  if (override) {
+    const isPathLike =
+      path.isAbsolute(override) ||
+      override.includes(path.sep) ||
+      override.includes(path.posix.sep) ||
+      override.includes(path.win32.sep);
+    const overridePath = isPathLike ? path.resolve(process.cwd(), override) : override;
+
+    if (isPathLike && !fs.existsSync(overridePath)) {
+      throw new Error(`${TESTKIT_K6_BIN} points to a missing file: ${overridePath}`);
+    }
+
+    return overridePath;
+  }
+
+  const thisFile = fileURLToPath(import.meta.url);
+  const abs = path.resolve(path.dirname(thisFile), "..", "..", "vendor", "k6");
+  if (!fs.existsSync(abs)) {
+    throw new Error(`Bundled k6 binary not found: ${abs}`);
+  }
+  return abs;
+}
+
+export function resolveDalBinary() {
+  return resolveK6Binary();
+}

package/lib/config/database.mjs

@@ -1,5 +1,8 @@
-import { normalizeDatabaseBinding } from "../runner/execution-config.mjs";
-import { normalizeOptionalString, normalizeTemplateInputs, normalizeTemplateLifecycleSteps } from "./runtime.mjs";
+import { normalizeDatabaseBinding } from "../shared/execution-schema.mjs";
+import {
+  normalizeConfiguredInputs,
+  normalizeConfiguredSteps,
+} from "../shared/configured-steps.mjs";
 
 const DEFAULT_LOCAL_IMAGE = "pgvector/pgvector:pg16";
 const DEFAULT_LOCAL_USER = "testkit";
@@ -45,9 +48,9 @@ export function normalizeDatabaseTemplateConfig(value, serviceName) {
   }
 
   return {
-    inputs: normalizeTemplateInputs(value.inputs, `Service "${serviceName}" database.template`),
-    migrate: normalizeTemplateLifecycleSteps(value.migrate, `Service "${serviceName}" database.template.migrate`),
-    seed: normalizeTemplateLifecycleSteps(value.seed, `Service "${serviceName}" database.template.seed`),
-    verify: normalizeTemplateLifecycleSteps(value.verify, `Service "${serviceName}" database.template.verify`),
+    inputs: normalizeConfiguredInputs(value.inputs, `Service "${serviceName}" database.template`),
+    migrate: normalizeConfiguredSteps(value.migrate, `Service "${serviceName}" database.template.migrate`),
+    seed: normalizeConfiguredSteps(value.seed, `Service "${serviceName}" database.template.seed`),
+    verify: normalizeConfiguredSteps(value.verify, `Service "${serviceName}" database.template.verify`),
   };
 }

package/lib/config/index.mjs

@@ -1,13 +1,14 @@
 import fs from "fs";
 import path from "path";
-import { fileURLToPath } from "url";
 import { discoverProject } from "./discovery.mjs";
 import { loadTestkitSetup } from "./setup-loader.mjs";
 import { normalizeToolchainRegistry } from "../toolchains/index.mjs";
+import { loadTestFileMetadataMap } from "../discovery/file-metadata.mjs";
 import { mergeDiscoveryConfigs } from "../discovery/path-policy.mjs";
 import { normalizeDatabaseConfig } from "./database.mjs";
 import { normalizeRepoDiscoveryConfig, normalizeServiceDiscoveryConfig } from "./discovery-config.mjs";
 import { inferEnvFiles, loadServiceEnv, parseDotenv } from "./env.mjs";
+import { resolveDalBinary, resolveK6Binary } from "./binaries.mjs";
 import { ensureExistingPath, resolveProductDir, resolveServiceCwd } from "./paths.mjs";
 import {
   detectNextApp,
@@ -22,8 +23,6 @@ import { normalizeServiceRequirements, normalizeSkipConfig } from "./skip-config
 import { normalizeTelemetryConfig } from "./telemetry.mjs";
 import { validateConfigCoverage, validateServiceConfig } from "./validation.mjs";
 
-const TESTKIT_K6_BIN = "TESTKIT_K6_BIN";
-
 export { parseDotenv, resolveProductDir, resolveServiceCwd };
 
 export async function loadConfigContext(opts = {}) {
@@ -39,6 +38,7 @@ export async function loadConfigContext(opts = {}) {
     ...(opts.discoveryOptions || {}),
     discovery: discoveryConfig,
   });
+  const fileMetadataByPath = loadTestFileMetadataMap(productDir, discovery.suitesByService);
   const serviceNames = new Set([
     ...Object.keys(explicitServices),
     ...Object.keys(discovery.suitesByService),
@@ -59,6 +59,7 @@ export async function loadConfigContext(opts = {}) {
         explicitService: explicitServices[name] || {},
         discoveredService: discovery.services[name] || null,
         suites: discovery.suitesByService[name] || {},
+        fileMetadataByPath,
       })
     );
 
@@ -92,34 +93,7 @@ export async function loadConfigs(opts = {}) {
   return filtered;
 }
 
-export function resolveK6Binary() {
-  const override = process.env[TESTKIT_K6_BIN]?.trim();
-  if (override) {
-    const isPathLike =
-      path.isAbsolute(override) ||
-      override.includes(path.sep) ||
-      override.includes(path.posix.sep) ||
-      override.includes(path.win32.sep);
-    const overridePath = isPathLike ? path.resolve(process.cwd(), override) : override;
-
-    if (isPathLike && !fs.existsSync(overridePath)) {
-      throw new Error(`${TESTKIT_K6_BIN} points to a missing file: ${overridePath}`);
-    }
-
-    return overridePath;
-  }
-
-  const thisFile = fileURLToPath(import.meta.url);
-  const abs = path.resolve(path.dirname(thisFile), "..", "..", "vendor", "k6");
-  if (!fs.existsSync(abs)) {
-    throw new Error(`Bundled k6 binary not found: ${abs}`);
-  }
-  return abs;
-}
-
-export function resolveDalBinary() {
-  return resolveK6Binary();
-}
+export { resolveDalBinary, resolveK6Binary } from "./binaries.mjs";
 
 function normalizeServiceConfig({
   name,
@@ -133,6 +107,7 @@ function normalizeServiceConfig({
   explicitService,
   discoveredService,
   suites,
+  fileMetadataByPath,
 }) {
   const local = normalizeLocalConfig(name, explicitService, discoveredService, productDir);
   const envFiles = inferEnvFiles(productDir, explicitService, local);
@@ -154,6 +129,12 @@ function normalizeServiceConfig({
   const runtime = normalizeRuntimeConfig(explicitService.runtime, name, toolchains);
   const skip = normalizeSkipConfig(explicitService.skip, { name, suites });
   const requirements = normalizeServiceRequirements(explicitService.requirements, { name, suites });
+  const serviceFilePaths = new Set(
+    Object.values(suites || {}).flatMap((suiteList) => suiteList.flatMap((suite) => suite.files || []))
+  );
+  const serviceFileMetadata = new Map(
+    [...fileMetadataByPath.entries()].filter(([filePath]) => serviceFilePaths.has(filePath))
+  );
 
   validateServiceConfig({
     name,
@@ -186,6 +167,7 @@ function normalizeServiceConfig({
       skip,
       runtime,
       browser,
+      fileMetadataByPath: serviceFileMetadata,
       local,
     },
   };

package/lib/config/runtime.mjs

@@ -1,16 +1,24 @@
 import fs from "fs";
 import path from "path";
-import { DEFAULT_FILE_TIMEOUT_SECONDS, normalizeExecutionConfig, normalizeRuntimeMaxConcurrentTasks, normalizeRuntimeInstances } from "../runner/execution-config.mjs";
+import {
+  DEFAULT_FILE_TIMEOUT_SECONDS,
+  normalizeExecutionConfig,
+  normalizeRuntimeMaxConcurrentTasks,
+  normalizeRuntimeInstances,
+} from "../shared/execution-schema.mjs";
+import {
+  normalizeConfiguredInputs,
+  normalizeConfiguredStep,
+  normalizeConfiguredStepInputs,
+  normalizeConfiguredSteps,
+  normalizeOptionalString,
+  parseModuleSpecifier,
+} from "../shared/configured-steps.mjs";
+import { buildConfigToPrepare, normalizeBuildConfig } from "../shared/build-config.mjs";
 import { normalizeKnownFailureIssueValidationConfig } from "../known-failures/github.mjs";
 import { normalizeRuntimeToolchain } from "../toolchains/index.mjs";
 import { resolveServiceCwd } from "./paths.mjs";
 
-export function normalizeOptionalString(value) {
-  if (typeof value !== "string") return null;
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : null;
-}
-
 export function normalizeReportingConfig(value) {
   if (!value) return null;
 
@@ -70,6 +78,7 @@ export function inferLocalRuntime(productDir, cwd) {
 export function normalizeRuntimeConfig(value, serviceName, toolchains) {
   if (!value) {
     return {
+      build: null,
       instances: 1,
       maxConcurrentTasks: Number.POSITIVE_INFINITY,
       prepare: {
@@ -80,13 +89,21 @@ export function normalizeRuntimeConfig(value, serviceName, toolchains) {
     };
   }
 
+  const build = normalizeBuildConfig(value.build, `Service "${serviceName}" runtime.build`);
+  const prepare = normalizeRuntimePrepareConfig(value.prepare, serviceName);
+  const buildPrepare = buildConfigToPrepare(build);
+
   return {
+    build,
     instances: normalizeRuntimeInstances(value.instances ?? 1, `Service "${serviceName}" runtime.instances`),
     maxConcurrentTasks: normalizeRuntimeMaxConcurrentTasks(
       value.maxConcurrentTasks,
       `Service "${serviceName}" runtime.maxConcurrentTasks`
     ),
-    prepare: normalizeRuntimePrepareConfig(value.prepare, serviceName),
+    prepare: {
+      inputs: [...new Set([...(buildPrepare.inputs || []), ...(prepare.inputs || [])])],
+      steps: [...(buildPrepare.steps || []), ...(prepare.steps || [])],
+    },
     toolchain: normalizeRuntimeToolchain(
       value.toolchain,
       `Service "${serviceName}" runtime.toolchain`,
@@ -107,90 +124,11 @@ export function normalizeRuntimePrepareConfig(value, serviceName) {
   }
 
   return {
-    inputs: normalizeTemplateInputs(value.inputs, `Service "${serviceName}" runtime.prepare`),
-    steps: normalizeTemplateLifecycleSteps(value.steps, `Service "${serviceName}" runtime.prepare.steps`),
+    inputs: normalizeConfiguredInputs(value.inputs, `Service "${serviceName}" runtime.prepare`),
+    steps: normalizeConfiguredSteps(value.steps, `Service "${serviceName}" runtime.prepare.steps`),
   };
 }
 
-export function normalizeTemplateInputs(value, label) {
-  if (value == null) return [];
-  if (!Array.isArray(value)) {
-    throw new Error(`${label}.inputs must be an array`);
-  }
-
-  return value.map((entry, index) => {
-    const normalized = normalizeOptionalString(entry);
-    if (!normalized) {
-      throw new Error(`${label}.inputs[${index}] must be a non-empty string`);
-    }
-    return normalized;
-  });
-}
-
-export function normalizeTemplateLifecycleSteps(value, label) {
-  if (value == null) return [];
-  if (!Array.isArray(value)) {
-    throw new Error(`${label} must be an array`);
-  }
-
-  return value.map((step, index) => normalizeTemplateLifecycleStep(step, `${label}[${index}]`));
-}
-
-export function normalizeTemplateLifecycleStep(step, label) {
-  if (!step || typeof step !== "object") {
-    throw new Error(`${label} must be an object`);
-  }
-
-  const kind = normalizeOptionalString(step.kind);
-  if (kind === "command") {
-    const cmd = normalizeOptionalString(step.cmd);
-    if (!cmd) throw new Error(`${label}.cmd must be a non-empty string`);
-    return {
-      kind,
-      cmd,
-      cwd: normalizeOptionalString(step.cwd),
-      inputs: normalizeTemplateStepInputs(step.inputs, label),
-    };
-  }
-  if (kind === "sql-file") {
-    const filePath = normalizeOptionalString(step.path);
-    if (!filePath) throw new Error(`${label}.path must be a non-empty string`);
-    return {
-      kind,
-      path: filePath,
-      cwd: normalizeOptionalString(step.cwd),
-      inputs: normalizeTemplateStepInputs(step.inputs, label),
-    };
-  }
-  if (kind === "module") {
-    const specifier = normalizeOptionalString(step.specifier);
-    if (!specifier) throw new Error(`${label}.specifier must be a non-empty string`);
-    return {
-      kind,
-      specifier,
-      cwd: normalizeOptionalString(step.cwd),
-      inputs: normalizeTemplateStepInputs(step.inputs, label),
-    };
-  }
-
-  throw new Error(`${label}.kind must be one of: command, sql-file, module`);
-}
-
-export function normalizeTemplateStepInputs(value, label) {
-  if (value == null) return [];
-  if (!Array.isArray(value)) {
-    throw new Error(`${label}.inputs must be an array`);
-  }
-
-  return value.map((entry, index) => {
-    const normalized = normalizeOptionalString(entry);
-    if (!normalized) {
-      throw new Error(`${label}.inputs[${index}] must be a non-empty string`);
-    }
-    return normalized;
-  });
-}
-
 export function normalizeBrowserServiceConfig(value, serviceName) {
   if (!value) return undefined;
   if (typeof value !== "object" || Array.isArray(value)) {
@@ -232,10 +170,11 @@ export function detectNextApp(cwd) {
   );
 }
 
-export function parseModuleSpecifier(specifier) {
-  const [modulePath, exportName] = String(specifier).split("#", 2);
-  return {
-    modulePath,
-    exportName: exportName || "default",
-  };
-}
+export {
+  normalizeConfiguredInputs as normalizeTemplateInputs,
+  normalizeConfiguredStep as normalizeTemplateLifecycleStep,
+  normalizeConfiguredStepInputs as normalizeTemplateStepInputs,
+  normalizeConfiguredSteps as normalizeTemplateLifecycleSteps,
+  normalizeOptionalString,
+  parseModuleSpecifier,
+} from "../shared/configured-steps.mjs";

package/lib/config/runtime.test.mjs

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 import {
   normalizeBrowserServiceConfig,
+  normalizeRuntimeConfig,
   normalizeRuntimePrepareConfig,
   normalizeTemplateLifecycleStep,
   normalizeTemplateStepInputs,
@@ -45,6 +46,31 @@ describe("config runtime helpers", () => {
     });
   });
 
+  it("folds declarative runtime.build into runtime.prepare", () => {
+    expect(
+      normalizeRuntimeConfig(
+        {
+          build: {
+            kind: "tsc",
+            entry: "src/server.ts",
+          },
+        },
+        "api",
+        {}
+      )
+    ).toMatchObject({
+      build: {
+        kind: "tsc",
+        entry: "src/server.ts",
+        tsconfig: "tsconfig.json",
+        outDir: "dist",
+      },
+      prepare: {
+        inputs: ["tsconfig.json", "package.json", "src"],
+      },
+    });
+  });
+
   it("rejects malformed lifecycle steps and empty step inputs", () => {
     expect(() => normalizeTemplateLifecycleStep({ kind: "module" }, "runtime.prepare.steps[0]")).toThrow(
       /specifier must be a non-empty string/