counterfact 2.5.1 → 2.7.0

package/bin/counterfact.js

@@ -1,21 +1,49 @@
 #!/usr/bin/env node
 
+/**
+ * bin/counterfact.js — CLI entry point for the `counterfact` command.
+ *
+ * Responsibilities:
+ *  1. Parse CLI arguments and build a `Config` object via Commander.
+ *  2. Run any pending migrations (paths → routes directory layout).
+ *  3. Delegate to `counterfact()` from `src/app.ts` to start the server,
+ *     code generator, transpiler, module loader, and optional REPL.
+ *  4. Print the startup banner and open the browser when requested.
+ *  5. Check for available updates against the npm registry.
+ *
+ * Architecture (high-level data flow):
+ *
+ *   CLI args  ──▶  Commander  ──▶  Config
+ *                                     │
+ *                         ┌───────────▼───────────┐
+ *                         │      counterfact()     │
+ *                         │   (src/app.ts)         │
+ *                         │                        │
+ *                         │  CodeGenerator         │  reads OpenAPI spec, emits .ts route/type files
+ *                         │  Transpiler            │  compiles .ts → .cjs and watches for changes
+ *                         │  ModuleLoader          │  loads compiled modules into Registry
+ *                         │  Dispatcher + KoaApp   │  handles HTTP requests
+ *                         │  REPL (optional)       │  interactive terminal session
+ *                         └────────────────────────┘
+ */
+
 import fs from "node:fs";
 import { readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import nodePath from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { randomUUID } from "node:crypto";
 
 import { program } from "commander";
 import createDebug from "debug";
 import open from "open";
-
-import { counterfact } from "../dist/app.js";
-import { pathsToRoutes } from "../dist/migrate/paths-to-routes.js";
-import { updateRouteTypes } from "../dist/migrate/update-route-types.js";
+import { PostHog } from "posthog-node";
 
 const MIN_NODE_VERSION = 17;
 
-if (Number.parseInt(process.versions.node.split("."), 10) < MIN_NODE_VERSION) {
+if (
+  Number.parseInt(process.versions.node.split(".")[0], 10) < MIN_NODE_VERSION
+) {
   process.stdout.write(
     `Counterfact works with Node version ${MIN_NODE_VERSION}+. You are running version ${process.version}`,
   );
@@ -23,28 +51,117 @@ if (Number.parseInt(process.versions.node.split("."), 10) < MIN_NODE_VERSION) {
   process.exit(1);
 }
 
+const __binDir = nodePath.dirname(fileURLToPath(import.meta.url));
+
 const packageJson = JSON.parse(
-  await readFile(
-    nodePath.join(
-      nodePath.dirname(fileURLToPath(import.meta.url)),
-      "../package.json",
-    ),
-    "utf8",
-  ),
+  await readFile(nodePath.join(__binDir, "../package.json"), "utf8"),
 );
 
 const CURRENT_VERSION = packageJson.version;
 
+// Telemetry — fire-and-forget, never blocks startup
+const POSTHOG_API_KEY = "phc_msXmBxiL8FVugNMLCx9bnPQGqfEMqmyBjnVkKhHkN3m7";
+const POSTHOG_HOST = "https://us.i.posthog.com";
+
+const telemetryKey = process.env.POSTHOG_API_KEY ?? POSTHOG_API_KEY;
+const telemetryHost = process.env.POSTHOG_HOST ?? POSTHOG_HOST;
+
+const isCI = Boolean(process.env.CI);
+const isBeforeRollout = new Date() < new Date("2026-05-01");
+const telemetryDisabledEnv = process.env.COUNTERFACT_TELEMETRY_DISABLED;
+
+const isTelemetryDisabled =
+  isCI ||
+  telemetryDisabledEnv === "true" ||
+  (isBeforeRollout && telemetryDisabledEnv !== "false");
+
+if (!isTelemetryDisabled) {
+  try {
+    const posthog = new PostHog(telemetryKey, { host: telemetryHost });
+
+    posthog.capture({
+      distinctId: randomUUID(),
+      event: "counterfact_started",
+      properties: {
+        version: CURRENT_VERSION,
+        nodeVersion: process.version,
+        platform: process.platform,
+        arch: process.arch,
+        source: "counterfact-cli",
+      },
+    });
+
+    posthog.shutdownAsync().catch(() => {
+      // ignore errors — telemetry is best-effort
+    });
+  } catch {
+    // ignore errors — telemetry must never surface to the user
+  }
+}
+
 const taglinesFile = await readFile(
-  nodePath.join(
-    nodePath.dirname(fileURLToPath(import.meta.url)),
-    "taglines.txt",
-  ),
+  nodePath.join(__binDir, "taglines.txt"),
   "utf8",
 );
 
 const taglines = taglinesFile.split("\n").slice(0, -1);
 
+// Probe whether the current runtime can natively execute TypeScript with
+// erasable type annotations AND resolve .js imports to .ts files (tsx-style).
+async function runtimeCanExecuteErasableTs() {
+  const dir = fs.mkdtempSync(nodePath.join(tmpdir(), "ts-probe-"));
+  // helper.ts is imported via .js extension — the TypeScript convention used
+  // throughout this codebase. If the runtime resolves helper.js → helper.ts,
+  // it is fully capable of running the TypeScript source tree.
+  fs.writeFileSync(
+    nodePath.join(dir, "helper.ts"),
+    'export const value: string = "ok";\n',
+    "utf8",
+  );
+  fs.writeFileSync(
+    nodePath.join(dir, "main.ts"),
+    'import { value } from "./helper.js"; export default value;\n',
+    "utf8",
+  );
+  try {
+    const mod = await import(pathToFileURL(nodePath.join(dir, "main.ts")).href);
+    return mod?.default === "ok";
+  } catch {
+    return false;
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+const nativeTs = await runtimeCanExecuteErasableTs();
+
+const resolve = (rel) => pathToFileURL(nodePath.join(__binDir, rel)).href;
+
+const { counterfact } = await import(
+  resolve(nativeTs ? "../src/app.ts" : "../dist/app.js")
+);
+const { pathsToRoutes } = await import(
+  resolve(
+    nativeTs
+      ? "../src/migrate/paths-to-routes.js"
+      : "../dist/migrate/paths-to-routes.js",
+  )
+);
+const { updateRouteTypes } = await import(
+  resolve(
+    nativeTs
+      ? "../src/migrate/update-route-types.js"
+      : "../dist/migrate/update-route-types.js",
+  )
+);
+const { loadConfigFile } = await import(
+  resolve(
+    nativeTs
+      ? "../src/util/load-config-file.js"
+      : "../dist/util/load-config-file.js",
+  )
+);
+
 const DEFAULT_PORT = 3100;
 
 const debug = createDebug("counterfact:bin:counterfact");
@@ -161,6 +278,31 @@ async function main(source, destination) {
       ? Promise.resolve()
       : checkForUpdates(CURRENT_VERSION);
 
+  // Load the config file (counterfact.yaml by default, or --config <path>).
+  // CLI options always take precedence over config file settings.
+  const configFilePath = nodePath.resolve(options.config ?? "counterfact.yaml");
+  const fileConfig = await loadConfigFile(
+    configFilePath,
+    options.config !== undefined,
+  );
+  debug("fileConfig: %o", fileConfig);
+
+  // Apply config file values for any option that was not explicitly set on the
+  // command line (i.e. its source is "default" or it was never defined).
+  for (const [key, value] of Object.entries(fileConfig)) {
+    const optionSource = program.getOptionValueSource(key);
+
+    if (optionSource !== "cli") {
+      options[key] = value;
+    }
+  }
+
+  // If the config file specifies a destination and none was given on the CLI,
+  // use it (destination has no Commander option — it's a positional argument).
+  if (fileConfig.destination !== undefined && destination === ".") {
+    destination = String(fileConfig.destination);
+  }
+
   // --spec takes precedence over the positional [openapi.yaml] argument.
   // When --spec is provided, the [openapi.yaml] positional slot shifts to
   // become the [destination] argument (so `counterfact --spec api.yaml ./api`
@@ -234,6 +376,8 @@ async function main(source, destination) {
     startRepl: options.repl,
     startServer: options.serve,
     buildCache: options.buildCache || false,
+    validateRequests: options.validateRequest !== false,
+    validateResponses: options.validateResponse !== false,
 
     watch: {
       routes: options.watch || options.watchRoutes,
@@ -248,6 +392,14 @@ async function main(source, destination) {
 
   debug("loading counterfact (%o)", configForLogging);
 
+  if (config.startAdminApi && !config.adminApiToken) {
+    process.stderr.write(
+      "⚠️  WARNING: The admin API is enabled without an authentication token.\n" +
+        "   Any process on this machine can read and modify server state via /_counterfact/api/*.\n" +
+        "   Set --admin-api-token or COUNTERFACT_ADMIN_API_TOKEN to restrict access.\n\n",
+    );
+  }
+
   let didMigrate = false;
   let didMigrateRouteTypes;
 
@@ -266,7 +418,16 @@ async function main(source, destination) {
     didMigrate = true;
   }
 
-  const { start, startRepl } = await counterfact(config);
+  let start;
+  let startRepl;
+  try {
+    ({ start, startRepl } = await counterfact(config));
+  } catch (error) {
+    process.stderr.write(
+      `\n❌ ${error instanceof Error ? error.message : String(error)}\n\n`,
+    );
+    process.exit(1);
+  }
 
   debug("loaded counterfact", configForLogging);
 
@@ -280,6 +441,14 @@ async function main(source, destination) {
 
   const watchMessage = createWatchMessage(config);
 
+  const telemetryWarning = isTelemetryDisabled
+    ? []
+    : [
+        "⚠️  Telemetry will be enabled by default starting May 1, 2026.",
+        "   Learn more and how to disable: https://counterfact.dev/telemetry-discussion",
+        "",
+      ];
+
   const introduction = [
     "   ____ ____ _  _ _ _ ___ ____ ____ ____ ____ ____ ___",
     String.raw`   |___ [__] |__| |\|  |  |=== |--< |--- |--| |___  | `,
@@ -292,11 +461,7 @@ async function main(source, destination) {
     "   Instructions  https://counterfact.dev/docs/usage.html",
     "   Help/feedback https://github.com/pmcelhaney/counterfact/issues",
     "",
-    "",
-    "🔔 PLEASE READ: Feedback, Telemetry, and Privacy Discussion (10 March 2026)",
-    "   https://counterfact.dev/telemetry-discussion",
-    "",
-    "",
+    ...telemetryWarning,
     watchMessage,
     config.startServer ? "   Starting server" : undefined,
     config.startRepl
@@ -311,7 +476,14 @@ async function main(source, destination) {
   process.stdout.write("\n\n");
 
   debug("starting server");
-  await start(config);
+  try {
+    await start(config);
+  } catch (error) {
+    process.stderr.write(
+      `\n❌ ${error instanceof Error ? error.message : String(error)}\n\n`,
+    );
+    process.exit(1);
+  }
   debug("started server");
 
   await updateCheckPromise;
@@ -409,5 +581,17 @@ program
     "path or URL to OpenAPI document (alternative to the positional [openapi.yaml] argument)",
   )
   .option("--no-update-check", "disable the npm update check on startup")
+  .option(
+    "--no-validate-request",
+    "disable request validation against the OpenAPI spec",
+  )
+  .option(
+    "--no-validate-response",
+    "disable response validation against the OpenAPI spec",
+  )
+  .option(
+    "--config <path>",
+    "path to a counterfact.yaml config file (default: counterfact.yaml in the current directory)",
+  )
   .action(main)
   .parse(process.argv);

package/bin/register-ts-loader.mjs

@@ -0,0 +1,17 @@
+/**
+ * Register the ts-loader hook using Node's modern module.register() API.
+ *
+ * Usage (replaces deprecated --loader flag):
+ *   node --experimental-strip-types --import ./bin/register-ts-loader.mjs bin/counterfact.js ...
+ */
+
+// module.register() was added in Node 20.6 / 22; this file is only used when
+// running counterfact under a TypeScript-capable Node runtime (22.6+).
+// eslint-disable-next-line n/no-unsupported-features/node-builtins
+import { register } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+register("./ts-loader.mjs", pathToFileURL(join(__dirname, "/")));

package/bin/ts-loader.mjs

@@ -0,0 +1,31 @@
+/**
+ * Node.js custom loader that remaps .js import specifiers to .ts when a
+ * corresponding .ts file exists alongside the importer.
+ *
+ * Usage:
+ *   node --experimental-strip-types --loader ./bin/ts-loader.mjs bin/counterfact.js ...
+ *
+ * Why: Node's built-in --experimental-strip-types handles type annotation
+ * removal, but it does not remap .js → .ts import specifiers. This codebase
+ * uses the TypeScript convention of writing .js extensions in import paths
+ * (which resolve to .ts files at authoring time). This loader bridges that gap.
+ */
+
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+export function resolve(specifier, context, nextResolve) {
+  if (specifier.endsWith(".js") && context.parentURL) {
+    const tsSpecifier = specifier.slice(0, -3) + ".ts";
+    try {
+      const resolved = new URL(tsSpecifier, context.parentURL);
+      if (existsSync(fileURLToPath(resolved))) {
+        return nextResolve(tsSpecifier, context);
+      }
+    } catch {
+      // If URL construction fails, fall through to default resolution
+    }
+  }
+
+  return nextResolve(specifier, context);
+}

package/dist/app.js

@@ -1,16 +1,21 @@
 import fs, { rm } from "node:fs/promises";
 import nodePath from "node:path";
-import { dereference } from "@apidevtools/json-schema-ref-parser";
 import { createHttpTerminator } from "http-terminator";
 import { startRepl as startReplServer } from "./repl/repl.js";
 import { ContextRegistry } from "./server/context-registry.js";
 import { createKoaApp } from "./server/create-koa-app.js";
-import { Dispatcher, } from "./server/dispatcher.js";
+import { Dispatcher } from "./server/dispatcher.js";
 import { koaMiddleware } from "./server/koa-middleware.js";
+import { loadOpenApiDocument } from "./server/load-openapi-document.js";
 import { ModuleLoader } from "./server/module-loader.js";
+import { OpenApiWatcher } from "./server/openapi-watcher.js";
 import { Registry } from "./server/registry.js";
+import { ScenarioRegistry } from "./server/scenario-registry.js";
 import { Transpiler } from "./server/transpiler.js";
 import { CodeGenerator } from "./typescript-generator/code-generator.js";
+import { writeApplyContextType } from "./typescript-generator/generate.js";
+import { runtimeCanExecuteErasableTs } from "./util/runtime-can-execute-erasable-ts.js";
+export { loadOpenApiDocument } from "./server/load-openapi-document.js";
 const allowedMethods = [
     "all",
     "head",
@@ -21,14 +26,6 @@ const allowedMethods = [
     "patch",
     "options",
 ];
-export async function loadOpenApiDocument(source) {
-    try {
-        return (await dereference(source));
-    }
-    catch {
-        return undefined;
-    }
-}
 const mswHandlers = {};
 export async function handleMswRequest(request) {
     const { method, rawPath } = request;
@@ -44,9 +41,6 @@ export async function createMswHandlers(config, ModuleLoaderClass = ModuleLoader
     // If we "pre-read" the file here it works. This is a workaround to avoid the issue.
     await fs.readFile(config.openApiPath);
     const openApiDocument = await loadOpenApiDocument(config.openApiPath);
-    if (openApiDocument === undefined) {
-        throw new Error(`Could not load OpenAPI document from ${config.openApiPath}`);
-    }
     const modulesPath = config.basePath;
     const compiledPathsDirectory = nodePath
         .join(modulesPath, ".cache")
@@ -75,29 +69,43 @@ export async function createMswHandlers(config, ModuleLoaderClass = ModuleLoader
 }
 export async function counterfact(config) {
     const modulesPath = config.basePath;
+    const nativeTs = await runtimeCanExecuteErasableTs();
     const compiledPathsDirectory = nodePath
-        .join(modulesPath, ".cache")
+        .join(modulesPath, nativeTs ? "routes" : ".cache")
         .replaceAll("\\", "/");
-    await rm(compiledPathsDirectory, { force: true, recursive: true });
+    if (!nativeTs) {
+        await rm(compiledPathsDirectory, { force: true, recursive: true });
+    }
     const registry = new Registry();
     const contextRegistry = new ContextRegistry();
+    const scenarioRegistry = new ScenarioRegistry();
     const codeGenerator = new CodeGenerator(config.openApiPath, config.basePath, config.generate);
-    const dispatcher = new Dispatcher(registry, contextRegistry, await loadOpenApiDocument(config.openApiPath), config);
+    const openApiDocument = config.openApiPath === "_"
+        ? undefined
+        : await loadOpenApiDocument(config.openApiPath);
+    const dispatcher = new Dispatcher(registry, contextRegistry, openApiDocument, config);
     const transpiler = new Transpiler(nodePath.join(modulesPath, "routes").replaceAll("\\", "/"), compiledPathsDirectory, "commonjs");
-    const moduleLoader = new ModuleLoader(compiledPathsDirectory, registry, contextRegistry);
+    const moduleLoader = new ModuleLoader(compiledPathsDirectory, registry, contextRegistry, nodePath.join(modulesPath, "scenarios").replaceAll("\\", "/"), scenarioRegistry);
+    contextRegistry.addEventListener("context-changed", () => {
+        void writeApplyContextType(modulesPath);
+    });
     const middleware = koaMiddleware(dispatcher, config);
     const koaApp = createKoaApp(registry, middleware, config, contextRegistry);
+    const openApiWatcher = new OpenApiWatcher(config.openApiPath, dispatcher);
     async function start(options) {
         const { generate, startServer, watch, buildCache } = options;
-        if (generate.routes || generate.types) {
+        if (config.openApiPath !== "_" && (generate.routes || generate.types)) {
             await codeGenerator.generate();
         }
-        if (watch.routes || watch.types) {
+        if (config.openApiPath !== "_" && (watch.routes || watch.types)) {
             await codeGenerator.watch();
         }
         let httpTerminator;
         if (startServer) {
-            await transpiler.watch();
+            await openApiWatcher.watch();
+            if (!nativeTs) {
+                await transpiler.watch();
+            }
             await moduleLoader.load();
             await moduleLoader.watch();
             const server = koaApp.listen({
@@ -117,6 +125,7 @@ export async function counterfact(config) {
                 await codeGenerator.stopWatching();
                 await transpiler.stopWatching();
                 await moduleLoader.stopWatching();
+                await openApiWatcher.stopWatching();
                 await httpTerminator?.terminate();
             },
         };
@@ -127,6 +136,7 @@ export async function counterfact(config) {
         koaMiddleware: middleware,
         registry,
         start,
-        startRepl: () => startReplServer(contextRegistry, registry, config),
+        startRepl: () => startReplServer(contextRegistry, registry, config, undefined, // use the default print function (stdout)
+        openApiDocument, scenarioRegistry),
     };
 }

package/dist/counterfact-types/cookie-options.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/counterfact-response.js

@@ -0,0 +1,7 @@
+/**
+ * A unique symbol used as a brand for the `COUNTERFACT_RESPONSE` type.
+ * This prevents arbitrary objects from being accidentally treated as a
+ * completed response value.
+ */
+const counterfactResponse = Symbol("Counterfact Response");
+export {};

package/dist/counterfact-types/example-names.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/example.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/generic-response-builder.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/http-status-code.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/if-has-key.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/index.js

@@ -1,2 +1 @@
-const counterfactResponse = Symbol("Counterfact Response");
 export {};

package/dist/counterfact-types/maybe-promise.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/media-type.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/omit-all.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/omit-value-when-never.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/open-api-content.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/open-api-operation.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/open-api-parameters.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/open-api-response.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/random-function.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/response-builder-factory.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/response-builder.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/wide-operation-argument.js

@@ -0,0 +1 @@
+export {};

package/dist/counterfact-types/wide-response-builder.js

@@ -0,0 +1 @@
+export {};

package/dist/migrate/update-route-types.js

@@ -13,6 +13,23 @@ const HTTP_METHODS = [
     "HEAD",
     "OPTIONS",
 ];
+// Pre-compile regex patterns derived from HTTP_METHODS
+const HTTP_METHOD_ALTERNATION = HTTP_METHODS.join("|");
+// eslint-disable-next-line security/detect-non-literal-regexp
+const NEEDS_MIGRATION_REGEX = new RegExp(`import\\s+type\\s+\\{[^}]*HTTP_(?:${HTTP_METHOD_ALTERNATION})[^}]*\\}`, "iu");
+// eslint-disable-next-line security/detect-non-literal-regexp
+const HTTP_TYPE_NAME_REGEX = new RegExp(`^HTTP_(?<method>${HTTP_METHOD_ALTERNATION})$`, "u");
+// Pre-build import/export replacement patterns for each HTTP method type name
+const IMPORT_REPLACE_PATTERNS = new Map(HTTP_METHODS.map((method) => [
+    `HTTP_${method}`,
+    // eslint-disable-next-line security/detect-non-literal-regexp
+    new RegExp(`(import\\s+type\\s+\\{[^}]*\\b)HTTP_${method}(\\b[^}]*\\}\\s+from)`, "g"),
+]));
+const EXPORT_REPLACE_PATTERNS = new Map(HTTP_METHODS.map((method) => [
+    `HTTP_${method}`,
+    // eslint-disable-next-line security/detect-non-literal-regexp
+    new RegExp(`(export\\s+const\\s+${method}\\s*:\\s*)HTTP_${method}(\\b)`, "g"),
+]));
 /**
  * Converts an OpenAPI path to a file system path
  * e.g., "/hello/{name}" -> "hello/{name}"
@@ -71,9 +88,7 @@ async function buildTypeNameMapping(specification) {
  * @param content - The file content
  */
 function needsMigration(content) {
-    const methodAlternation = HTTP_METHODS.map((method) => method.toUpperCase()).join("|");
-    const pattern = new RegExp(`import\\s+type\\s+\\{[^}]*HTTP_(?:${methodAlternation})[^}]*\\}`, "iu");
-    return pattern.test(content);
+    return NEEDS_MIGRATION_REGEX.test(content);
 }
 /**
  * Updates a single route file with the correct type names
@@ -102,7 +117,7 @@ async function updateRouteFile(filePath, methodToTypeName) {
             .filter((t) => t.length > 0);
         for (const importedType of importedTypes) {
             // Check if this is an HTTP_ type
-            const httpMethodMatch = importedType.match(new RegExp(`^HTTP_(?<method>${HTTP_METHODS.join("|")})$`, "u"));
+            const httpMethodMatch = importedType.match(HTTP_TYPE_NAME_REGEX);
             if (httpMethodMatch) {
                 const method = httpMethodMatch.groups?.["method"] ?? "";
                 const newTypeName = methodToTypeName.get(method);
@@ -120,15 +135,20 @@ async function updateRouteFile(filePath, methodToTypeName) {
     // Apply replacements
     for (const [oldName, newName] of replacements.entries()) {
         // Replace in import statement
-        const importPattern = new RegExp(`(import\\s+type\\s+\\{[^}]*\\b)${oldName}(\\b[^}]*\\}\\s+from)`, "g");
-        content = content.replace(importPattern, `$1${newName}$2`);
+        const importPattern = IMPORT_REPLACE_PATTERNS.get(oldName);
+        if (importPattern) {
+            importPattern.lastIndex = 0;
+            content = content.replace(importPattern, `$1${newName}$2`);
+        }
         // Replace in export statement (e.g., "export const GET: HTTP_GET")
         // Match the method from the old type name
-        const methodMatch = oldName.match(new RegExp(`^HTTP_(?<method>${HTTP_METHODS.join("|")})$`, "u"));
+        const methodMatch = oldName.match(HTTP_TYPE_NAME_REGEX);
         if (methodMatch) {
-            const method = methodMatch.groups?.["method"] ?? "";
-            const exportPattern = new RegExp(`(export\\s+const\\s+${method}\\s*:\\s*)${oldName}(\\b)`, "g");
-            content = content.replace(exportPattern, `$1${newName}$2`);
+            const exportPattern = EXPORT_REPLACE_PATTERNS.get(oldName);
+            if (exportPattern) {
+                exportPattern.lastIndex = 0;
+                content = content.replace(exportPattern, `$1${newName}$2`);
+            }
         }
         modified = true;
     }