litestar-vite-plugin 0.15.0-rc.2 → 0.15.0-rc.3

package/dist/js/shared/typegen-cache.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Check if openapi-ts should run based on input cache.
+ *
+ * @param openapiPath - Path to openapi.json
+ * @param configPath - Path to config file (or null)
+ * @param options - Generator options
+ * @returns true if generation should run, false if cached
+ */
+export declare function shouldRunOpenApiTs(openapiPath: string, configPath: string | null, options: {
+    generateSdk: boolean;
+    generateZod: boolean;
+    plugins: string[];
+}): Promise<boolean>;
+/**
+ * Update cache after successful openapi-ts run.
+ *
+ * @param openapiPath - Path to openapi.json
+ * @param configPath - Path to config file (or null)
+ * @param options - Generator options
+ */
+export declare function updateOpenApiTsCache(openapiPath: string, configPath: string | null, options: {
+    generateSdk: boolean;
+    generateZod: boolean;
+    plugins: string[];
+}): Promise<void>;
+/**
+ * Compute input hash for page props generation.
+ *
+ * @param pagePropsPath - Path to inertia-pages.json
+ * @returns Hash of the input file
+ */
+export declare function computePagePropsHash(pagePropsPath: string): Promise<string>;
+/**
+ * Check if page props types should be regenerated.
+ *
+ * @param pagePropsPath - Path to inertia-pages.json
+ * @returns true if generation should run, false if cached
+ */
+export declare function shouldRegeneratePageProps(pagePropsPath: string): Promise<boolean>;
+/**
+ * Update cache after successful page props generation.
+ *
+ * @param pagePropsPath - Path to inertia-pages.json
+ */
+export declare function updatePagePropsCache(pagePropsPath: string): Promise<void>;

package/dist/js/shared/typegen-cache.js

@@ -0,0 +1,83 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+const CACHE_DIR = "node_modules/.cache/litestar-vite";
+const CACHE_FILE = "typegen-cache.json";
+async function loadCache() {
+  const cacheFilePath = path.join(CACHE_DIR, CACHE_FILE);
+  try {
+    const content = await fs.promises.readFile(cacheFilePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function saveCache(cache) {
+  const cacheFilePath = path.join(CACHE_DIR, CACHE_FILE);
+  await fs.promises.mkdir(CACHE_DIR, { recursive: true });
+  await fs.promises.writeFile(cacheFilePath, JSON.stringify(cache, null, 2), "utf-8");
+}
+async function hashFile(filePath) {
+  try {
+    const content = await fs.promises.readFile(filePath);
+    return crypto.createHash("sha256").update(content).digest("hex");
+  } catch {
+    return "";
+  }
+}
+function hashObject(obj) {
+  const sorted = JSON.stringify(obj, Object.keys(obj).sort());
+  return crypto.createHash("sha256").update(sorted).digest("hex");
+}
+async function shouldRunOpenApiTs(openapiPath, configPath, options) {
+  const cache = await loadCache();
+  const inputHash = await hashFile(openapiPath);
+  const configHash = configPath ? await hashFile(configPath) : "";
+  const optionsHash = hashObject(options);
+  const cacheKey = "openapi-ts";
+  const entry = cache[cacheKey];
+  if (entry && entry.inputHash === inputHash && entry.configHash === configHash && entry.optionsHash === optionsHash) {
+    return false;
+  }
+  return true;
+}
+async function updateOpenApiTsCache(openapiPath, configPath, options) {
+  const cache = await loadCache();
+  cache["openapi-ts"] = {
+    inputHash: await hashFile(openapiPath),
+    configHash: configPath ? await hashFile(configPath) : "",
+    optionsHash: hashObject(options),
+    timestamp: Date.now()
+  };
+  await saveCache(cache);
+}
+async function computePagePropsHash(pagePropsPath) {
+  return hashFile(pagePropsPath);
+}
+async function shouldRegeneratePageProps(pagePropsPath) {
+  const cache = await loadCache();
+  const currentHash = await hashFile(pagePropsPath);
+  const cacheKey = "page-props";
+  const entry = cache[cacheKey];
+  if (entry && entry.inputHash === currentHash) {
+    return false;
+  }
+  return true;
+}
+async function updatePagePropsCache(pagePropsPath) {
+  const cache = await loadCache();
+  cache["page-props"] = {
+    inputHash: await hashFile(pagePropsPath),
+    configHash: "",
+    optionsHash: "",
+    timestamp: Date.now()
+  };
+  await saveCache(cache);
+}
+export {
+  computePagePropsHash,
+  shouldRegeneratePageProps,
+  shouldRunOpenApiTs,
+  updateOpenApiTsCache,
+  updatePagePropsCache
+};

package/dist/js/shared/typegen-core.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Configuration for type generation.
+ */
+export interface TypeGenCoreConfig {
+    /** Project root directory */
+    projectRoot: string;
+    /** Path to openapi.json (relative or absolute) */
+    openapiPath: string;
+    /** Output directory for generated files */
+    output: string;
+    /** Path to inertia-pages.json (relative or absolute) */
+    pagePropsPath: string;
+    /** Whether to generate SDK client */
+    generateSdk: boolean;
+    /** Whether to generate Zod schemas */
+    generateZod: boolean;
+    /** Whether to generate page props types */
+    generatePageProps: boolean;
+    /** SDK client plugin (e.g., "@hey-api/client-fetch") */
+    sdkClientPlugin: string;
+    /** JS runtime executor (e.g., "bun", "pnpm") */
+    executor?: string;
+}
+/**
+ * Result of type generation.
+ */
+export interface TypeGenResult {
+    /** Whether any files were generated */
+    generated: boolean;
+    /** Files that were generated/updated */
+    generatedFiles: string[];
+    /** Files that were skipped (unchanged) */
+    skippedFiles: string[];
+    /** Total duration in milliseconds */
+    durationMs: number;
+    /** Any warnings to report */
+    warnings: string[];
+    /** Any errors encountered */
+    errors: string[];
+}
+/**
+ * Logger interface for type generation.
+ * Allows callers to inject their own logging behavior.
+ */
+export interface TypeGenLogger {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
+/**
+ * Options for running type generation.
+ */
+export interface RunTypeGenOptions {
+    /** Logger for output (optional - silent if not provided) */
+    logger?: TypeGenLogger;
+}
+/**
+ * Find user's openapi-ts config file.
+ */
+export declare function findOpenApiTsConfig(projectRoot: string): string | null;
+/**
+ * Build the list of plugins for @hey-api/openapi-ts.
+ */
+export declare function buildHeyApiPlugins(config: {
+    generateSdk: boolean;
+    generateZod: boolean;
+    sdkClientPlugin: string;
+}): string[];
+/**
+ * Run @hey-api/openapi-ts to generate TypeScript types from OpenAPI spec.
+ *
+ * @param config - Type generation configuration
+ * @param configPath - Path to user's openapi-ts config (or null for default)
+ * @param plugins - List of plugins to use
+ * @param logger - Optional logger for output
+ * @returns Path to output directory
+ */
+export declare function runHeyApiGeneration(config: TypeGenCoreConfig, configPath: string | null, plugins: string[], logger?: TypeGenLogger): Promise<string>;
+/**
+ * Run the complete type generation pipeline.
+ *
+ * This is the main entry point for type generation, handling:
+ * - OpenAPI type generation via @hey-api/openapi-ts
+ * - Page props type generation
+ *
+ * @param config - Type generation configuration
+ * @param options - Runtime options (logger, etc.)
+ * @returns Result with generated files and timing info
+ */
+export declare function runTypeGeneration(config: TypeGenCoreConfig, options?: RunTypeGenOptions): Promise<TypeGenResult>;

package/dist/js/shared/typegen-core.js

@@ -0,0 +1,122 @@
+import { exec } from "node:child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { promisify } from "node:util";
+import { resolveInstallHint, resolvePackageExecutor } from "../install-hint.js";
+import { emitPagePropsTypes } from "./emit-page-props-types.js";
+const execAsync = promisify(exec);
+const nodeRequire = createRequire(import.meta.url);
+function findOpenApiTsConfig(projectRoot) {
+  const candidates = [path.resolve(projectRoot, "openapi-ts.config.ts"), path.resolve(projectRoot, "hey-api.config.ts"), path.resolve(projectRoot, ".hey-api.config.ts")];
+  return candidates.find((p) => fs.existsSync(p)) || null;
+}
+function buildHeyApiPlugins(config) {
+  const plugins = ["@hey-api/typescript", "@hey-api/schemas"];
+  if (config.generateSdk) {
+    plugins.push("@hey-api/sdk", config.sdkClientPlugin);
+  }
+  if (config.generateZod) {
+    plugins.push("zod");
+  }
+  return plugins;
+}
+async function runHeyApiGeneration(config, configPath, plugins, logger) {
+  const { projectRoot, openapiPath, output, executor, generateZod } = config;
+  const sdkOutput = path.join(output, "api");
+  if (process.env.VITEST || process.env.VITE_TEST || process.env.NODE_ENV === "test" || process.env.CI) {
+    try {
+      nodeRequire.resolve("@hey-api/openapi-ts/package.json", { paths: [projectRoot] });
+    } catch {
+      throw new Error("@hey-api/openapi-ts not installed");
+    }
+  }
+  let args;
+  if (configPath) {
+    args = ["@hey-api/openapi-ts", "--file", configPath];
+  } else {
+    const relativeOpenapiPath = path.relative(projectRoot, path.resolve(projectRoot, openapiPath));
+    args = ["@hey-api/openapi-ts", "-i", relativeOpenapiPath, "-o", sdkOutput];
+    if (plugins.length) {
+      args.push("--plugins", ...plugins);
+    }
+  }
+  if (generateZod) {
+    try {
+      nodeRequire.resolve("zod", { paths: [projectRoot] });
+    } catch {
+      logger?.warn(`zod not installed - run: ${resolveInstallHint()} zod`);
+    }
+  }
+  const cmd = resolvePackageExecutor(args.join(" "), executor);
+  await execAsync(cmd, { cwd: projectRoot });
+  return sdkOutput;
+}
+async function runTypeGeneration(config, options = {}) {
+  const { logger } = options;
+  const startTime = Date.now();
+  const result = {
+    generated: false,
+    generatedFiles: [],
+    skippedFiles: [],
+    durationMs: 0,
+    warnings: [],
+    errors: []
+  };
+  try {
+    const { projectRoot, openapiPath, pagePropsPath, output, generateSdk, generatePageProps } = config;
+    const absoluteOpenapiPath = path.resolve(projectRoot, openapiPath);
+    const absolutePagePropsPath = path.resolve(projectRoot, pagePropsPath);
+    const configPath = findOpenApiTsConfig(projectRoot);
+    const shouldGenerateSdk = configPath || generateSdk;
+    if (fs.existsSync(absoluteOpenapiPath) && shouldGenerateSdk) {
+      const plugins = buildHeyApiPlugins(config);
+      logger?.info("Generating TypeScript types...");
+      if (configPath) {
+        const relConfigPath = path.relative(projectRoot, configPath);
+        logger?.info(`openapi-ts config: ${relConfigPath}`);
+      }
+      try {
+        const outputPath = await runHeyApiGeneration(config, configPath, plugins, logger);
+        result.generatedFiles.push(outputPath);
+        result.generated = true;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("not found") || message.includes("ENOENT") || message.includes("not installed")) {
+          const zodHint = config.generateZod ? " zod" : "";
+          const warning = `@hey-api/openapi-ts not installed - run: ${resolveInstallHint()} -D @hey-api/openapi-ts${zodHint}`;
+          result.warnings.push(warning);
+          logger?.warn(warning);
+        } else {
+          result.errors.push(message);
+          logger?.error(`Type generation failed: ${message}`);
+        }
+      }
+    }
+    if (generatePageProps && fs.existsSync(absolutePagePropsPath)) {
+      try {
+        const changed = await emitPagePropsTypes(absolutePagePropsPath, output);
+        const pagePropsOutput = path.join(output, "page-props.ts");
+        if (changed) {
+          result.generatedFiles.push(pagePropsOutput);
+          result.generated = true;
+        } else {
+          result.skippedFiles.push(pagePropsOutput);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        result.errors.push(`Page props generation failed: ${message}`);
+        logger?.error(`Page props generation failed: ${message}`);
+      }
+    }
+  } finally {
+    result.durationMs = Date.now() - startTime;
+  }
+  return result;
+}
+export {
+  buildHeyApiPlugins,
+  findOpenApiTsConfig,
+  runHeyApiGeneration,
+  runTypeGeneration
+};

package/dist/js/shared/typegen-plugin.js

@@ -1,15 +1,11 @@
-import { exec } from "node:child_process";
 import fs from "node:fs";
-import { createRequire } from "node:module";
 import path from "node:path";
-import { promisify } from "node:util";
 import colors from "picocolors";
-import { resolveInstallHint, resolvePackageExecutor } from "../install-hint.js";
 import { debounce } from "./debounce.js";
 import { emitPagePropsTypes } from "./emit-page-props-types.js";
 import { formatPath } from "./format-path.js";
-const execAsync = promisify(exec);
-const nodeRequire = createRequire(import.meta.url);
+import { shouldRunOpenApiTs, updateOpenApiTsCache } from "./typegen-cache.js";
+import { buildHeyApiPlugins, findOpenApiTsConfig, runHeyApiGeneration } from "./typegen-core.js";
 async function getFileMtime(filePath) {
   const stat = await fs.promises.stat(filePath);
   return stat.mtimeMs.toString();
@@ -21,8 +17,14 @@ function createLitestarTypeGenPlugin(typesConfig, options) {
   let server = null;
   let isGenerating = false;
   let resolvedConfig = null;
-  let _chosenConfigPath = null;
-  async function runTypeGeneration() {
+  function createViteLogger() {
+    return {
+      info: (message) => resolvedConfig?.logger.info(`${colors.cyan("\u2022")} ${message}`),
+      warn: (message) => resolvedConfig?.logger.warn(`${colors.yellow("!")} ${message}`),
+      error: (message) => resolvedConfig?.logger.error(`${colors.red("\u2717")} ${message}`)
+    };
+  }
+  async function runTypeGenerationWithCache() {
     if (isGenerating) {
       return false;
     }
@@ -30,49 +32,70 @@ function createLitestarTypeGenPlugin(typesConfig, options) {
     const startTime = Date.now();
     try {
       const projectRoot = resolvedConfig?.root ?? process.cwd();
-      const openapiPath = path.resolve(projectRoot, typesConfig.openapiPath);
-      const pagePropsPath = path.resolve(projectRoot, typesConfig.pagePropsPath);
+      const absoluteOpenapiPath = path.resolve(projectRoot, typesConfig.openapiPath);
+      const absolutePagePropsPath = path.resolve(projectRoot, typesConfig.pagePropsPath);
       let generated = false;
-      const candidates = [path.resolve(projectRoot, "openapi-ts.config.ts"), path.resolve(projectRoot, "hey-api.config.ts"), path.resolve(projectRoot, ".hey-api.config.ts")];
-      const configPath = candidates.find((p) => fs.existsSync(p)) || null;
-      _chosenConfigPath = configPath;
-      const shouldRunOpenApiTs = configPath || typesConfig.generateSdk;
-      if (fs.existsSync(openapiPath) && shouldRunOpenApiTs) {
-        resolvedConfig?.logger.info(`${colors.cyan("\u2022")} Generating TypeScript types...`);
-        if (resolvedConfig && configPath) {
-          const relConfigPath = formatPath(configPath, resolvedConfig.root);
-          resolvedConfig.logger.info(`${colors.cyan("\u2022")} openapi-ts config: ${colors.yellow(relConfigPath)}`);
-        }
-        const sdkOutput = path.join(typesConfig.output, "api");
-        let args;
-        if (configPath) {
-          args = ["@hey-api/openapi-ts", "--file", configPath];
-        } else {
-          args = ["@hey-api/openapi-ts", "-i", typesConfig.openapiPath, "-o", sdkOutput];
-          const plugins = ["@hey-api/typescript", "@hey-api/schemas"];
-          if (typesConfig.generateSdk) {
-            plugins.push("@hey-api/sdk", sdkClientPlugin);
-          }
-          if (typesConfig.generateZod) {
-            plugins.push("zod");
-          }
-          if (plugins.length) {
-            args.push("--plugins", ...plugins);
+      const logger = createViteLogger();
+      const configPath = findOpenApiTsConfig(projectRoot);
+      const shouldGenerateSdk = configPath || typesConfig.generateSdk;
+      if (fs.existsSync(absoluteOpenapiPath) && shouldGenerateSdk) {
+        const plugins = buildHeyApiPlugins({
+          generateSdk: typesConfig.generateSdk,
+          generateZod: typesConfig.generateZod,
+          sdkClientPlugin
+        });
+        const cacheOptions = {
+          generateSdk: typesConfig.generateSdk,
+          generateZod: typesConfig.generateZod,
+          plugins
+        };
+        const shouldRun = await shouldRunOpenApiTs(absoluteOpenapiPath, configPath, cacheOptions);
+        if (shouldRun) {
+          logger.info("Generating TypeScript types...");
+          if (configPath && resolvedConfig) {
+            const relConfigPath = formatPath(configPath, resolvedConfig.root);
+            logger.info(`openapi-ts config: ${colors.yellow(relConfigPath)}`);
           }
-        }
-        if (typesConfig.generateZod) {
+          const coreConfig = {
+            projectRoot,
+            openapiPath: typesConfig.openapiPath,
+            output: typesConfig.output,
+            pagePropsPath: typesConfig.pagePropsPath,
+            generateSdk: typesConfig.generateSdk,
+            generateZod: typesConfig.generateZod,
+            generatePageProps: false,
+            // Handle separately below
+            sdkClientPlugin,
+            executor
+          };
           try {
-            nodeRequire.resolve("zod", { paths: [projectRoot] });
-          } catch {
-            resolvedConfig?.logger.warn(`${colors.yellow("!")} zod not installed - run: ${resolveInstallHint()} zod`);
+            await runHeyApiGeneration(coreConfig, configPath, plugins, logger);
+            await updateOpenApiTsCache(absoluteOpenapiPath, configPath, cacheOptions);
+            generated = true;
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes("not found") || message.includes("ENOENT")) {
+              logger.warn("@hey-api/openapi-ts not installed");
+            } else {
+              logger.error(`Type generation failed: ${message}`);
+            }
           }
+        } else {
+          resolvedConfig?.logger.info(`${colors.cyan("\u2022")} TypeScript types ${colors.dim("(unchanged)")}`);
         }
-        await execAsync(resolvePackageExecutor(args.join(" "), executor), { cwd: projectRoot });
-        generated = true;
       }
-      if (typesConfig.generatePageProps && fs.existsSync(pagePropsPath)) {
-        await emitPagePropsTypes(pagePropsPath, typesConfig.output);
-        generated = true;
+      if (typesConfig.generatePageProps && fs.existsSync(absolutePagePropsPath)) {
+        try {
+          const changed = await emitPagePropsTypes(absolutePagePropsPath, typesConfig.output);
+          if (changed) {
+            generated = true;
+          } else {
+            resolvedConfig?.logger.info(`${colors.cyan("\u2022")} Page props types ${colors.dim("(unchanged)")}`);
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          logger.error(`Page props generation failed: ${message}`);
+        }
       }
       if (generated && resolvedConfig) {
         const duration = Date.now() - startTime;
@@ -91,22 +114,13 @@ function createLitestarTypeGenPlugin(typesConfig, options) {
       return true;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      if (resolvedConfig) {
-        if (message.includes("not found") || message.includes("ENOENT")) {
-          const zodHint = typesConfig.generateZod ? " zod" : "";
-          resolvedConfig.logger.warn(
-            `${colors.cyan("litestar-vite")} ${colors.yellow("@hey-api/openapi-ts not installed")} - run: ${resolveInstallHint()} -D @hey-api/openapi-ts${zodHint}`
-          );
-        } else {
-          resolvedConfig.logger.error(`${colors.cyan("litestar-vite")} ${colors.red("type generation failed:")} ${message}`);
-        }
-      }
+      resolvedConfig?.logger.error(`${colors.cyan("litestar-vite")} ${colors.red("type generation failed:")} ${message}`);
       return false;
     } finally {
       isGenerating = false;
     }
   }
-  const debouncedRunTypeGeneration = debounce(runTypeGeneration, typesConfig.debounce);
+  const debouncedRunTypeGeneration = debounce(runTypeGenerationWithCache, typesConfig.debounce);
   return {
     name: pluginName,
     enforce: "pre",
@@ -144,7 +158,7 @@ Solutions:
         const hasOpenapi = fs.existsSync(openapiPath);
         const hasPageProps = typesConfig.generatePageProps && fs.existsSync(pagePropsPath);
         if (hasOpenapi || hasPageProps) {
-          await runTypeGeneration();
+          await runTypeGenerationWithCache();
         }
       }
     },

package/dist/js/shared/write-if-changed.d.ts

@@ -0,0 +1,16 @@
+export interface WriteResult {
+    changed: boolean;
+    path: string;
+}
+/**
+ * Write file only if content differs from existing.
+ * Uses direct Buffer comparison (more efficient than hashing for small files).
+ *
+ * @param filePath - Absolute path to file
+ * @param content - Content to write
+ * @param options - Write options
+ * @returns WriteResult indicating whether file was changed
+ */
+export declare function writeIfChanged(filePath: string, content: string, options?: {
+    encoding?: BufferEncoding;
+}): Promise<WriteResult>;

package/dist/js/shared/write-if-changed.js

@@ -0,0 +1,19 @@
+import fs from "node:fs";
+import path from "node:path";
+async function writeIfChanged(filePath, content, options) {
+  const encoding = options?.encoding ?? "utf-8";
+  const newBuffer = Buffer.from(content, encoding);
+  try {
+    const existing = await fs.promises.readFile(filePath);
+    if (existing.equals(newBuffer)) {
+      return { changed: false, path: filePath };
+    }
+  } catch {
+  }
+  await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.promises.writeFile(filePath, newBuffer);
+  return { changed: true, path: filePath };
+}
+export {
+  writeIfChanged
+};

package/dist/js/typegen-cli.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import colors from "picocolors";
+import { readBridgeConfig } from "./shared/bridge-schema.js";
+import { runTypeGeneration } from "./shared/typegen-core.js";
+function parseArgs() {
+  const args = process.argv.slice(2);
+  return {
+    verbose: args.includes("--verbose")
+  };
+}
+function log(message) {
+  console.log(message);
+}
+function logError(message) {
+  console.error(message);
+}
+function createConsoleLogger() {
+  return {
+    info: (message) => log(`${colors.cyan("\u2022")} ${message}`),
+    warn: (message) => log(`${colors.yellow("!")} ${message}`),
+    error: (message) => logError(`${colors.red("\u2717")} ${message}`)
+  };
+}
+async function main() {
+  parseArgs();
+  const projectRoot = process.cwd();
+  const bridgeConfig = readBridgeConfig();
+  if (!bridgeConfig) {
+    logError(`${colors.red("\u2717")} .litestar.json not found`);
+    logError("  Run 'litestar run' or 'litestar assets generate-types' first to generate it.");
+    process.exit(1);
+  }
+  const typesConfig = bridgeConfig.types;
+  if (!typesConfig || !typesConfig.enabled) {
+    log(`${colors.yellow("!")} Type generation is disabled in configuration`);
+    process.exit(0);
+  }
+  const coreConfig = {
+    projectRoot,
+    openapiPath: typesConfig.openapiPath,
+    output: typesConfig.output,
+    pagePropsPath: typesConfig.pagePropsPath,
+    generateSdk: typesConfig.generateSdk,
+    generateZod: typesConfig.generateZod,
+    generatePageProps: typesConfig.generatePageProps,
+    sdkClientPlugin: "@hey-api/client-fetch",
+    // Default for CLI
+    executor: bridgeConfig.executor
+  };
+  const logger = createConsoleLogger();
+  const result = await runTypeGeneration(coreConfig, { logger });
+  if (result.errors.length > 0) {
+    process.exit(1);
+  }
+  for (const file of result.skippedFiles) {
+    const name = file.includes("page-props") ? "Page props types" : file;
+    log(`${colors.cyan("\u2022")} ${name} ${colors.dim("(unchanged)")}`);
+  }
+  if (result.generated) {
+    log(`${colors.green("\u2713")} TypeScript artifacts updated ${colors.dim(`(${result.durationMs}ms)`)}`);
+  }
+}
+main().catch((error) => {
+  logError(`${colors.red("\u2717")} Unexpected error: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});