@timber-js/app 0.2.0-alpha.191 → 0.2.0-alpha.194

package/src/adapters/nitro.ts

@@ -6,143 +6,26 @@
 // See design/11-platform.md and design/25-production-deployments.md.
 
 import { writeFile, readFile, cp, glob } from 'node:fs/promises';
-import { execFile } from 'node:child_process';
-import { join, relative, dirname, basename } from 'node:path';
-import type { TimberPlatformAdapter, TimberConfig } from './types';
-import { generateCompressModule } from './compress-module.js';
-import { adapterBase, IMMUTABLE_CACHE, generateHeadersFile } from './shared.js';
+import { join, dirname, basename } from 'node:path';
+import type { TimberPlatformAdapter, TimberConfig } from './types.ts';
+import { generateCompressModule } from './compress-module.ts';
+import { adapterBase, IMMUTABLE_CACHE, generateHeadersFile } from './shared.ts';
 import {
   runSharedBuildSteps,
   buildStaticDirectoryOutput,
   findUnhashedStaticFiles,
   writeHeadersFile,
-} from './build-output-helper.js';
-
-// ─── Presets ─────────────────────────────────────────────────────────────────
-
-/**
- * Supported Nitro deployment presets.
- *
- * Each preset maps to a Nitro deployment target. The adapter generates
- * the appropriate configuration and entry point for the selected platform.
- */
-export type NitroPreset =
-  | 'vercel'
-  | 'vercel-edge'
-  | 'netlify'
-  | 'netlify-edge'
-  | 'aws-lambda'
-  | 'deno-deploy'
-  | 'azure-functions'
-  | 'node-server'
-  | 'bun';
-
-/** Preset-specific Nitro configuration. */
-interface PresetConfig {
-  /** Nitro preset name passed to the Nitro build. */
-  nitroPreset: string;
-  /** Output directory name within the build dir. */
-  outputDir: string;
-  /**
-   * Path to the server bundle directory relative to outputDir.
-   * Nitro places the bundled server entry + _chunks/ here.
-   * Most presets use `server`; Vercel uses `functions/__server.func`.
-   */
-  serverBundleDir: string;
-  /** Whether the runtime supports waitUntil. */
-  supportsWaitUntil: boolean;
-  /** Whether the runtime supports application-level 103 Early Hints. */
-  supportsEarlyHints: boolean;
-  /** Value for TIMBER_RUNTIME env var. See design/25-production-deployments.md. */
-  runtimeName: string;
-  /** Additional nitro.config fields for this preset. */
-  extraConfig?: Record<string, unknown>;
-}
+} from './build-output-helper.ts';
+import { PRESET_CONFIGS, LOCALLY_PREVIEWABLE, type NitroPreset } from './nitro-presets.ts';
+import {
+  generatePreviewScript,
+  generateSendResponseModule,
+  spawnNitroPreview,
+} from './nitro-preview.ts';
 
-const PRESET_CONFIGS: Record<NitroPreset, PresetConfig> = {
-  'vercel': {
-    nitroPreset: 'vercel',
-    outputDir: '.vercel/output',
-    serverBundleDir: 'functions/__server.func',
-    supportsWaitUntil: true,
-    supportsEarlyHints: false,
-    runtimeName: 'vercel',
-    extraConfig: { vercel: { functions: { maxDuration: 30 } } },
-  },
-  'vercel-edge': {
-    nitroPreset: 'vercel-edge',
-    outputDir: '.vercel/output',
-    serverBundleDir: 'functions/__server.func',
-    supportsWaitUntil: true,
-    supportsEarlyHints: false,
-    runtimeName: 'vercel-edge',
-  },
-  'netlify': {
-    nitroPreset: 'netlify',
-    outputDir: '.netlify/functions-internal',
-    serverBundleDir: 'server',
-    supportsWaitUntil: false,
-    supportsEarlyHints: false,
-    runtimeName: 'netlify',
-  },
-  'netlify-edge': {
-    nitroPreset: 'netlify-edge',
-    outputDir: '.netlify/edge-functions',
-    serverBundleDir: 'server',
-    supportsWaitUntil: true,
-    supportsEarlyHints: false,
-    runtimeName: 'netlify-edge',
-  },
-  'aws-lambda': {
-    nitroPreset: 'aws-lambda',
-    outputDir: '.output',
-    serverBundleDir: 'server',
-    supportsWaitUntil: false,
-    supportsEarlyHints: false,
-    runtimeName: 'aws-lambda',
-  },
-  'deno-deploy': {
-    nitroPreset: 'deno-deploy',
-    outputDir: '.output',
-    serverBundleDir: 'server',
-    supportsWaitUntil: true,
-    supportsEarlyHints: false,
-    runtimeName: 'deno-deploy',
-  },
-  'azure-functions': {
-    nitroPreset: 'azure-functions',
-    outputDir: '.output',
-    serverBundleDir: 'server',
-    supportsWaitUntil: false,
-    supportsEarlyHints: false,
-    runtimeName: 'azure-functions',
-  },
-  'node-server': {
-    nitroPreset: 'node-server',
-    outputDir: '.output',
-    serverBundleDir: 'server',
-    supportsWaitUntil: true,
-    // Disabled by default: most node-server deployments sit behind a
-    // reverse proxy (nginx, caddy, traefik) that doesn't support 103
-    // Early Hints over HTTP/1.1. Sending 103 causes nginx to intermittently
-    // treat the response as an error and retry after proxy_connect_timeout
-    // (~5s stalls on ~23% of requests). Link headers on the 200 response
-    // are the safe fallback — Cloudflare and other CDNs convert them to
-    // 103 automatically at the edge (over HTTP/2+ to the browser).
-    supportsEarlyHints: false,
-    runtimeName: 'node-server',
-  },
-  'bun': {
-    nitroPreset: 'bun',
-    outputDir: '.output',
-    serverBundleDir: 'server',
-    supportsWaitUntil: true,
-    // Disabled for same reason as node-server — reverse proxies choke on 103.
-    // Link headers on the 200 response are converted to 103 by CDNs.
-    supportsEarlyHints: false,
-    runtimeName: 'bun',
-  },
-};
+// NitroPreset is part of the public adapter API (NitroAdapterOptions.preset),
+// so it stays importable from this module.
+export type { NitroPreset } from './nitro-presets.ts';
 
 // ─── Options ─────────────────────────────────────────────────────────────────
 
@@ -215,7 +98,6 @@ export interface NitroAdapterOptions {
 export function nitro(options: NitroAdapterOptions = {}): TimberPlatformAdapter {
   const preset = options.preset ?? 'node-server';
   const compress = options.compress ?? true;
-  const presetConfig = PRESET_CONFIGS[preset];
   return {
     name: `nitro-${preset}`,
 
@@ -428,261 +310,88 @@ ${handlerCall}
 `;
 }
 
-// ─── Preview ─────────────────────────────────────────────────────────────────
-
-/** Presets that produce a locally-runnable server entry. */
-const LOCALLY_PREVIEWABLE = new Set<NitroPreset>(['node-server', 'bun']);
+// ─── Build Hint Filtering ────────────────────────────────────────────────────
 
 /**
- * Generate a standalone preview server script that uses Node's built-in
- * HTTP server. This bypasses Nitro entirely — the Nitro entry.ts imports
- * h3 which isn't available outside a Nitro build. For local preview we
- * just need to serve static files and route requests to the RSC handler.
- *
- * @internal Exported for testing.
+ * Prefixes of nitro build-output lines that give wrong advice for timber
+ * builds. Every nitro bundler path emits these hints via `logger.success` —
+ * the rollup path hardcodes `npx nitro preview`; rolldown and vite default
+ * to it. That command resolves `.output/nitro.json` relative to cwd, but
+ * timber's nitro build lives at `.timber/dist/nitro/.output`, so the
+ * suggested command can never work from the project root.
+ * Prefix matching degrades gracefully: if upstream rewords the line
+ * entirely, it passes through rather than being silently eaten.
  */
-export function generatePreviewScript(buildDir: string, preset: NitroPreset): string {
-  const rscEntryRelative = relative(join(buildDir, 'nitro'), join(buildDir, 'rsc', 'index.js'));
-  const rscEntry = rscEntryRelative.startsWith('.') ? rscEntryRelative : './' + rscEntryRelative;
-  const publicDir = './public';
-  const manifestInitPath = './_timber-manifest-init.js';
-  const runtimeName = PRESET_CONFIGS[preset].runtimeName;
-
-  return `// Generated by @timber-js/app — standalone preview server.
-// Uses Node's built-in HTTP server to serve static assets and route
-// dynamic requests through the RSC handler. No Nitro/h3 dependency.
+const NITRO_PREVIEW_HINT_PREFIX = 'You can preview this build using';
+const NITRO_DEPLOY_HINT_PREFIX = 'You can deploy this build using';
+const SUPPRESSED_NITRO_HINT_PREFIXES = [NITRO_PREVIEW_HINT_PREFIX, NITRO_DEPLOY_HINT_PREFIX];
 
-import { createServer } from 'node:http';
-import { readFile, stat } from 'node:fs/promises';
-import { join, extname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { existsSync } from 'node:fs';
-
-// Set runtime before importing the handler.
-process.env.TIMBER_RUNTIME = '${runtimeName}';
-
-// Load the build manifest if it exists.
-const __dirname = fileURLToPath(new URL('.', import.meta.url));
-const manifestPath = join(__dirname, '${manifestInitPath}');
-if (existsSync(manifestPath)) {
-  await import('${manifestInitPath}');
+/** @internal Exported for testing. */
+export function isSuppressedNitroHint(
+  message: unknown,
+  prefixes: readonly string[] = SUPPRESSED_NITRO_HINT_PREFIXES
+): boolean {
+  return typeof message === 'string' && prefixes.some((prefix) => message.startsWith(prefix));
 }
 
-// Import the RSC handler (default export is the fetch-like handler).
-const { default: handler, runWithEarlyHintsSender } = await import('${rscEntry}');
-
-// Import compression helper for self-hosted response compression.
-const { compressResponse } = await import('./_compress.mjs');
-
-// Web→Node response bridge with backpressure (TIM-1154).
-const { sendNodeResponse } = await import('./_send-response.mjs');
-
-const MIME_TYPES = {
-  '.html': 'text/html',
-  '.js': 'application/javascript',
-  '.mjs': 'application/javascript',
-  '.css': 'text/css',
-  '.json': 'application/json',
-  '.png': 'image/png',
-  '.jpg': 'image/jpeg',
-  '.jpeg': 'image/jpeg',
-  '.gif': 'image/gif',
-  '.svg': 'image/svg+xml',
-  '.ico': 'image/x-icon',
-  '.woff': 'font/woff',
-  '.woff2': 'font/woff2',
-  '.ttf': 'font/ttf',
-  '.otf': 'font/otf',
-  '.webp': 'image/webp',
-  '.avif': 'image/avif',
-  '.webm': 'video/webm',
-  '.mp4': 'video/mp4',
-  '.txt': 'text/plain',
-  '.xml': 'application/xml',
-  '.wasm': 'application/wasm',
-};
-
-const publicDir = join(__dirname, '${publicDir}');
-
-// Port resolution (TIM-842):
-//   - Default to 3000
-//   - If PORT env var is set, honor it strictly (fail loudly on conflict)
-//   - Otherwise auto-bump from 3000 until a free port is found
-// Mirrors the dev server behavior so timber dev/preview/production all
-// behave the same way around port selection.
-const envPort = process.env.PORT ? parseInt(process.env.PORT, 10) : null;
-const portIsExplicit = envPort != null && Number.isFinite(envPort) && envPort > 0;
-const startPort = portIsExplicit ? envPort : 3000;
-const host = process.env.HOST || 'localhost';
-
-// Set after listenWithBump() resolves so request handlers can build
-// absolute URLs from the actual bound port (which may differ from
-// startPort after an auto-bump).
-let boundPort = startPort;
-
-const server = createServer(async (req, res) => {
-  // Scheme from the socket's TLS state — a hardcoded http:// breaks CSRF
-  // origin comparison and absolute-URL construction when TLS is terminated
-  // at this server (TIM-1073; mirrors the dev-server fix in TIM-1067).
-  // X-Forwarded-Proto is intentionally not consulted here: on a direct
-  // connection it would be attacker-controlled. The CSRF layer honors it
-  // separately for reverse-proxy deployments.
-  const scheme = req.socket?.encrypted ? 'https' : 'http';
-  const url = new URL(req.url || '/', \`\${scheme}://\${host}:\${boundPort}\`);
-
-  // Try serving static files from the public directory first.
-  const filePath = join(publicDir, url.pathname);
-  // Prevent path traversal.
-  if (filePath.startsWith(publicDir)) {
-    try {
-      const fileStat = await stat(filePath);
-      if (fileStat.isFile()) {
-        const ext = extname(filePath);
-        const contentType = MIME_TYPES[ext] || 'application/octet-stream';
-        const body = await readFile(filePath);
-        // Hashed assets get immutable cache, others get short cache.
-        const isImmutable =
-          url.pathname.startsWith('/assets/') || url.pathname.startsWith('/_timber/fonts/');
-        const cacheControl = isImmutable
-          ? 'public, max-age=31536000, immutable'
-          : 'public, max-age=3600, must-revalidate';
-        res.writeHead(200, {
-          'Content-Type': contentType,
-          'Content-Length': body.length,
-          'Cache-Control': cacheControl,
-        });
-        res.end(body);
-        return;
-      }
-    } catch {
-      // File not found — fall through to the RSC handler.
-    }
-  }
-
-  // Convert Node request to Web Request.
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (value) {
-      if (Array.isArray(value)) {
-        for (const v of value) headers.append(key, v);
-      } else {
-        headers.set(key, value);
-      }
-    }
-  }
-
-  let body = undefined;
-  if (req.method !== 'GET' && req.method !== 'HEAD') {
-    body = await new Promise((resolve) => {
-      const chunks = [];
-      req.on('data', (chunk) => chunks.push(chunk));
-      req.on('end', () => resolve(Buffer.concat(chunks)));
-    });
-  }
-
-  const webRequest = new Request(url.href, {
-    method: req.method,
-    headers,
-    body,
-    duplex: body ? 'half' : undefined,
-  });
-
-  try {
-    // Support 103 Early Hints when available.
-    const earlyHintsSender = (typeof res.writeEarlyHints === 'function')
-      ? (links) => { try { res.writeEarlyHints({ link: links }); } catch {} }
-      : undefined;
-
-    const rawResponse = earlyHintsSender && runWithEarlyHintsSender
-      ? await runWithEarlyHintsSender(earlyHintsSender, () => handler(webRequest))
-      : await handler(webRequest);
-
-    // Compress the response for self-hosted deployments.
-    const webResponse = compressResponse(webRequest, rawResponse);
-
-    // Write the response to Node's ServerResponse. sendNodeResponse handles
-    // status, headers (including Set-Cookie splitting via [...headers]),
-    // body streaming with backpressure, and client disconnect cleanup.
-    // See TIM-1154.
-    await sendNodeResponse(res, webResponse);
-  } catch (err) {
-    console.error('[timber preview] Request error:', err);
-    if (!res.headersSent) {
-      res.writeHead(500, { 'Content-Type': 'text/plain' });
-    }
-    res.end('Internal Server Error');
-  }
-});
-
-function listenWithBump(port, attempt = 0) {
-  return new Promise((resolveListen, rejectListen) => {
-    const onError = (err) => {
-      server.removeListener('listening', onListening);
-      if (err && err.code === 'EADDRINUSE' && !portIsExplicit && attempt < 100) {
-        if (attempt === 0) {
-          console.log(\`  [timber] Port \${port} in use, trying \${port + 1}...\`);
-        }
-        listenWithBump(port + 1, attempt + 1).then(resolveListen, rejectListen);
-        return;
-      }
-      rejectListen(err);
-    };
-    const onListening = () => {
-      server.removeListener('error', onError);
-      resolveListen(port);
-    };
-    server.once('error', onError);
-    server.once('listening', onListening);
-    server.listen(port, host);
-  });
+/**
+ * Nitro's rolldown and vite builders render `framework.previewCommand` /
+ * `framework.deployCommand` into these hints. A user who explicitly set one
+ * via `nitroConfig` has provided valid guidance — only suppress the hints
+ * whose command is still nitro's broken default.
+ *
+ * @internal Exported for testing.
+ */
+export function selectSuppressedHintPrefixes(framework?: {
+  previewCommand?: string;
+  deployCommand?: string;
+}): string[] {
+  return [
+    ...(framework?.previewCommand ? [] : [NITRO_PREVIEW_HINT_PREFIX]),
+    ...(framework?.deployCommand ? [] : [NITRO_DEPLOY_HINT_PREFIX]),
+  ];
 }
 
-try {
-  boundPort = await listenWithBump(startPort);
-  if (boundPort !== startPort) {
-    console.log();
-    console.log(\`  [timber] Port \${startPort} in use, using \${boundPort}\`);
-  }
-  console.log();
-  console.log('  ⚡ timber preview server running at:');
-  console.log();
-  console.log(\`    ➜  http://\${host}:\${boundPort}\`);
-  console.log();
-} catch (err) {
-  if (err && err.code === 'EADDRINUSE') {
-    console.error(\`[timber] Port \${startPort} is already in use. \` +
-      'Set PORT to a free port, or unset PORT to auto-pick.');
-  } else {
-    console.error('[timber] Failed to start preview server:', err);
-  }
-  process.exit(1);
-}
-`;
+/** Minimal structural view of the nitro (consola) logger the wrap needs. */
+interface NitroBuildLogger {
+  success: (message: unknown, ...args: unknown[]) => void;
 }
 
-/** Command descriptor for Nitro preview — testable without spawning. */
-export interface NitroPreviewCommand {
-  command: string;
-  args: string[];
-  cwd: string;
+/**
+ * Wrap a nitro logger's `success` so hardcoded preview/deploy hints are
+ * dropped for this programmatic build only. Returns the original
+ * (unfiltered) success fn so timber can print its own hint — which shares
+ * the suppressed prefix on purpose, replacing nitro's wording.
+ *
+ * @internal Exported for testing.
+ */
+export function wrapNitroLoggerForBuild(
+  logger: NitroBuildLogger,
+  prefixes: readonly string[] = SUPPRESSED_NITRO_HINT_PREFIXES
+): NitroBuildLogger['success'] {
+  const originalSuccess = logger.success.bind(logger);
+  const wrapped = (message: unknown, ...args: unknown[]) => {
+    if (isSuppressedNitroHint(message, prefixes)) return;
+    originalSuccess(message, ...args);
+  };
+  // Preserve consola LogFn properties (e.g. `.raw`) on the replacement.
+  logger.success = Object.assign(wrapped, logger.success);
+  return originalSuccess;
 }
 
-/** @internal Exported for testing. */
-export function generateNitroPreviewCommand(
-  buildDir: string,
-  preset: NitroPreset
-): NitroPreviewCommand | null {
-  if (!LOCALLY_PREVIEWABLE.has(preset)) return null;
-
-  const nitroDir = join(buildDir, 'nitro');
-  const entryPath = join(nitroDir, 'entry.ts');
-
-  const command = preset === 'bun' ? 'bun' : 'node';
-  return {
-    command,
-    args: [entryPath],
-    cwd: nitroDir,
-  };
+/**
+ * Timber's own post-build hint. Locally-runnable presets are previewed via
+ * `timber preview`, which invokes this adapter's `preview()` to run the
+ * generated `_preview-server.mjs`. Serverless presets get no hint — their
+ * output lives under `.timber/dist/nitro/`, so any cwd-relative deploy
+ * command would be as wrong as the nitro hint this replaces.
+ *
+ * @internal Exported for testing.
+ */
+export function getPostBuildHint(preset: NitroPreset): string | null {
+  return LOCALLY_PREVIEWABLE.has(preset)
+    ? 'You can preview this build using `timber preview`'
+    : null;
 }
 
 /**
@@ -731,6 +440,17 @@ async function runNitroBuild(
     ...userConfig,
   });
 
+  // Drop nitro's `npx nitro preview` / `npx nitro deploy` hints —
+  // they can never work from the project root (see TIM-1375). Hints whose
+  // command the user explicitly configured via framework.previewCommand /
+  // deployCommand pass through untouched — except on the rollup builder,
+  // which ignores framework commands and unconditionally prints the broken
+  // defaults (nitro/dist/_build/rollup.mjs), so user commands are treated
+  // as absent there: defaults stay suppressed, timber's hint still prints.
+  // logSuccess is the unfiltered fn used below to print timber's hint.
+  const framework = nitro.options.builder === 'rollup' ? undefined : nitro.options.framework;
+  const logSuccess = wrapNitroLoggerForBuild(nitro.logger, selectSuppressedHintPrefixes(framework));
+
   // Read the resolved serverDir AFTER config merging — userConfig may
   // override output.dir or output.serverDir. Nitro appends a trailing
   // slash during resolution; strip it for join() compatibility.
@@ -742,100 +462,15 @@ async function runNitroBuild(
   await nitroBuild(nitro);
   await nitro.close();
 
-  return { serverDir };
-}
-
-/** Spawn a Nitro preview process and pipe stdio. */
-function spawnNitroPreview(command: string, args: string[], cwd: string): Promise<void> {
-  return new Promise<void>((resolve, reject) => {
-    const child = execFile(command, args, { cwd }, (err) => {
-      if (err) reject(err);
-      else resolve();
-    });
-    child.stdout?.pipe(process.stdout);
-    child.stderr?.pipe(process.stderr);
-  });
-}
-
-// ─── Send Response Module ───────────────────────────────────────────────────
-
-/**
- * Generate a standalone ESM module that exports sendNodeResponse.
- *
- * Mirrors srvx/node's sendNodeResponse: status + headers via writeHead,
- * body streaming with backpressure (waits for drain on write() === false),
- * and client disconnect cleanup. Written to `_send-response.mjs` during
- * buildOutput for use by the preview server script. See TIM-1154.
- *
- * @internal Exported for testing.
- */
-export function generateSendResponseModule(): string {
-  return `// Generated by @timber-js/app — Web→Node response bridge.
-// Do not edit — this file is regenerated on each build.
-// Mirrors srvx/node's sendNodeResponse with backpressure support.
+  // A user-configured previewCommand already printed via nitro's own hint —
+  // don't print a second, conflicting one.
+  const hint = framework?.previewCommand ? null : getPostBuildHint(preset);
+  if (hint) logSuccess(hint);
 
-export function sendNodeResponse(nodeRes, webRes) {
-  if (!webRes) {
-    nodeRes.statusCode = 500;
-    return new Promise((resolve) => nodeRes.end(resolve));
-  }
-  const rawHeaders = [...webRes.headers];
-  const writeHeaders = rawHeaders.flat();
-  if (!nodeRes.headersSent) {
-    if (nodeRes.req?.httpVersion === '2.0') {
-      nodeRes.writeHead(webRes.status, writeHeaders);
-    } else {
-      nodeRes.writeHead(webRes.status, webRes.statusText, writeHeaders);
-    }
-  }
-  if (!webRes.body) {
-    return new Promise((resolve) => nodeRes.end(resolve));
-  }
-  // Stream with backpressure: pause reading when the kernel buffer is
-  // full (write() returns false) and resume on 'drain'.
-  if (nodeRes.destroyed) {
-    webRes.body.cancel();
-    return;
-  }
-  const reader = webRes.body.getReader();
-  function streamCancel(error) {
-    reader.cancel(error).catch(() => {});
-    if (error) nodeRes.destroy(error);
-  }
-  function streamHandle({ done, value }) {
-    try {
-      if (done) {
-        nodeRes.end();
-      } else if (nodeRes.write(value)) {
-        reader.read().then(streamHandle, streamCancel);
-      } else {
-        nodeRes.once('drain', () => reader.read().then(streamHandle, streamCancel));
-      }
-    } catch (error) {
-      streamCancel(error instanceof Error ? error : undefined);
-    }
-  }
-  nodeRes.on('close', streamCancel);
-  nodeRes.on('error', streamCancel);
-  reader.read().then(streamHandle, streamCancel);
-  return reader.closed.catch(streamCancel).finally(() => {
-    nodeRes.off('close', streamCancel);
-    nodeRes.off('error', streamCancel);
-  });
-}
-`;
+  return { serverDir };
 }
-
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
-/**
- * Get the preset configuration for a given preset name.
- * @internal Exported for testing.
- */
-export function getPresetConfig(preset: NitroPreset): PresetConfig {
-  return PRESET_CONFIGS[preset];
-}
-
 /**
  * Resolve the destination path for prebuilt flight payloads in the Nitro
  * output directory. The RSC entry resolves `../prebuilt/` relative to its

package/src/adapters/shared.ts

@@ -10,7 +10,7 @@
 // tests/adapters/shared-no-forbidden-imports.test.ts enforces this.
 // ../shared/ is exempt: it is dependency-free by the same rule.
 
-import { withBasePath } from '../shared/base-path.js';
+import { withBasePath } from '../shared/base-path.ts';
 
 /**
  * The deployment base an adapter should write platform rules against.