litestar-vite-plugin 0.27.0 → 0.29.0

package/dist/js/install-hint.js

@@ -51,19 +51,7 @@ function resolveInstallHint(pkg = "@hey-api/openapi-ts") {
   return `npm install -D ${packageArgs}`;
 }
 function resolvePackageExecutor(pkg, executor) {
-  const runtime = executor || detectExecutor();
-  switch (runtime) {
-    case "bun":
-      return `bunx ${pkg}`;
-    case "deno":
-      return `deno run -A npm:${pkg}`;
-    case "pnpm":
-      return `pnpm dlx ${pkg}`;
-    case "yarn":
-      return `yarn dlx ${pkg}`;
-    default:
-      return `npx ${pkg}`;
-  }
+  return resolvePackageExecutorArgv(pkg.split(" "), executor).join(" ");
 }
 function getPackageNameFromSpec(packageSpec) {
   if (packageSpec.startsWith("@")) {
@@ -88,9 +76,14 @@ function resolvePackageExecutorArgv(args, executor, options = {}) {
     case "bun":
       if (requiresMultiplePackages) return [];
       return ["bunx", ...packageSpec ? [packageSpec, ...args] : args];
-    case "deno":
+    case "deno": {
       if (requiresMultiplePackages) return [];
-      return ["deno", "run", "-A", ...packageSpec ? [`npm:${resolveDenoPackageSpec(packageSpec, binName)}`, ...args] : args];
+      if (packageSpec) {
+        return ["deno", "run", "-A", `npm:${resolveDenoPackageSpec(packageSpec, binName)}`, ...args];
+      }
+      const [firstArg, ...restArgs] = args;
+      return firstArg ? ["deno", "run", "-A", `npm:${firstArg}`, ...restArgs] : ["deno", "run", "-A"];
+    }
     case "pnpm":
       if (requiresMultiplePackages && binName) {
         return ["pnpm", "dlx", ...packageSpecs.map((spec) => `--package=${spec}`), binName, ...args];

package/dist/js/nuxt.d.ts

@@ -23,138 +23,22 @@
  * @module
  */
 import type { Plugin } from "vite";
+import { type LitestarIntegrationConfig } from "./shared/integration-config.js";
+import { type TypesConfigShape } from "./shared/typegen-plugin.js";
 /**
- * Configuration for TypeScript type generation in Nuxt.
+ * Configuration for TypeScript type generation.
+ *
+ * Alias of the shared {@link TypesConfigShape} so every integration accepts an identical
+ * `types` option. Retained as a named export for backwards compatibility.
  */
-export interface NuxtTypesConfig {
-    /**
-     * Enable type generation.
-     *
-     * @default false
-     */
-    enabled?: boolean;
-    /**
-     * Path to output generated TypeScript types.
-     * Relative to the Nuxt project root.
-     *
-     * @default 'generated'
-     */
-    output?: string;
-    /**
-     * Path where the OpenAPI schema is exported by Litestar.
-     *
-     * @default `${output}/openapi.json`
-     */
-    openapiPath?: string;
-    /**
-     * Path where route metadata is exported by Litestar.
-     *
-     * @default `${output}/routes.json`
-     */
-    routesPath?: string;
-    /**
-     * Optional path for the generated schemas.ts helper file.
-     *
-     * @default `${output}/schemas.ts`
-     */
-    schemasTsPath?: string;
-    /**
-     * Path where Inertia page props metadata is exported by Litestar.
-     *
-     * @default `${output}/inertia-pages.json`
-     */
-    pagePropsPath?: string;
-    /**
-     * Generate Zod schemas in addition to TypeScript types.
-     *
-     * @default false
-     */
-    generateZod?: boolean;
-    /**
-     * Generate SDK client functions for API calls.
-     *
-     * @default true
-     */
-    generateSdk?: boolean;
-    /**
-     * Generate typed routes.ts from routes.json metadata.
-     *
-     * @default true
-     */
-    generateRoutes?: boolean;
-    /**
-     * Generate Inertia page props types from inertia-pages.json metadata.
-     *
-     * @default true
-     */
-    generatePageProps?: boolean;
-    /**
-     * Generate schemas.ts with ergonomic form/response type helpers.
-     *
-     * @default true
-     */
-    generateSchemas?: boolean;
-    /**
-     * Register route() globally on window object.
-     *
-     * @default false
-     */
-    globalRoute?: boolean;
-    /**
-     * Fail Vite when type generation fails.
-     *
-     * Defaults to true during build and false during dev.
-     */
-    failOnError?: boolean;
-    /**
-     * Debounce time in milliseconds for type regeneration.
-     *
-     * @default 300
-     */
-    debounce?: number;
-}
+export type NuxtTypesConfig = TypesConfigShape;
 /**
- * Configuration options for the Litestar Nuxt module.
+ * Configuration options for the Litestar integration.
+ *
+ * Alias of the shared {@link LitestarIntegrationConfig}. Retained as a named export for
+ * backwards compatibility.
  */
-export interface LitestarNuxtConfig {
-    /**
-     * URL of the Litestar API backend for proxying requests during development.
-     *
-     * @example 'http://127.0.0.1:8000'
-     * @default 'http://localhost:8000'
-     */
-    apiProxy?: string;
-    /**
-     * API route prefix to proxy to the Litestar backend.
-     * Requests matching this prefix will be forwarded to the apiProxy URL.
-     *
-     * @example '/api'
-     * @default '/api'
-     */
-    apiPrefix?: string;
-    /**
-     * Enable and configure TypeScript type generation.
-     *
-     * When set to `true`, enables type generation with default settings.
-     * When set to a NuxtTypesConfig object, enables type generation with custom settings.
-     *
-     * @default false
-     */
-    types?: boolean | NuxtTypesConfig;
-    /**
-     * Enable verbose logging for debugging.
-     *
-     * @default false
-     */
-    verbose?: boolean;
-    /**
-     * JavaScript runtime executor for package commands.
-     * Used when running tools like @hey-api/openapi-ts.
-     *
-     * @default undefined (uses LITESTAR_VITE_RUNTIME env or 'node')
-     */
-    executor?: "node" | "bun" | "deno" | "yarn" | "pnpm";
-}
+export type LitestarNuxtConfig = LitestarIntegrationConfig;
 /**
  * Nuxt module definition for Litestar integration.
  *

package/dist/js/nuxt.js

@@ -1,63 +1,13 @@
 import fs from "node:fs";
 import path from "node:path";
 import colors from "picocolors";
-import { readBridgeConfig } from "./shared/bridge-schema.js";
-import { normalizeHost, resolveHotFilePath, resolveLitestarPort } from "./shared/network.js";
-import { createLitestarTypeGenPlugin, resolveTypesConfig } from "./shared/typegen-plugin.js";
+import { resolveIntegrationConfig } from "./shared/integration-config.js";
+import { installManagedShutdown } from "./shared/managed-shutdown.js";
+import { normalizeHost } from "./shared/network.js";
+import { createLitestarTypeGenPlugin } from "./shared/typegen-plugin.js";
 import { hmrServerConfig } from "./shared/vite-compat.js";
 function resolveConfig(config = {}) {
-  let hotFile;
-  let proxyMode = "vite";
-  let devPort;
-  let pythonTypesConfig;
-  let hasPythonConfig = false;
-  const envPort = process.env.VITE_PORT;
-  if (envPort) {
-    devPort = Number.parseInt(envPort, 10);
-    if (Number.isNaN(devPort)) {
-      devPort = void 0;
-    }
-  }
-  let pythonExecutor;
-  let assetUrl;
-  let litestarPort;
-  const runtime = readBridgeConfig();
-  if (runtime) {
-    hasPythonConfig = true;
-    const hot = runtime.hotFile;
-    hotFile = resolveHotFilePath(runtime.bundleDir, hot);
-    proxyMode = runtime.proxyMode;
-    devPort = runtime.port;
-    pythonExecutor = runtime.executor;
-    assetUrl = runtime.assetUrl;
-    if (runtime.types) {
-      pythonTypesConfig = runtime.types;
-    }
-  }
-  const resolvedLitestarPort = resolveLitestarPort(runtime?.litestarPort, runtime?.appUrl);
-  if (resolvedLitestarPort !== null) {
-    litestarPort = resolvedLitestarPort;
-  }
-  const typesConfig = resolveTypesConfig({
-    requested: config.types,
-    pythonConfig: pythonTypesConfig ?? void 0,
-    defaultOutput: "generated",
-    mergePythonWhenTrue: true,
-    mergePythonForObject: true
-  });
-  return {
-    apiProxy: config.apiProxy ?? "http://localhost:8000",
-    apiPrefix: config.apiPrefix ?? "/api",
-    types: typesConfig,
-    verbose: config.verbose ?? false,
-    hotFile,
-    proxyMode,
-    devPort,
-    litestarPort,
-    assetUrl,
-    executor: config.executor ?? pythonExecutor,
-    hasPythonConfig
-  };
+  return resolveIntegrationConfig(config, "generated");
 }
 async function getPort() {
   return new Promise((resolve, reject) => {
@@ -80,7 +30,7 @@ function createProxyPlugin(config) {
     async config() {
       hmrPort = await getPort();
       const hmrPath = `${(config.assetUrl ?? "/static").replace(/\/$/, "")}/vite-hmr`;
-      const browserHmrPort = config.litestarPort ?? config.devPort;
+      const browserHmrPort = config.litestarPort ?? config.port;
       return {
         server: {
           // Force IPv4 binding for consistency with Python proxy configuration
@@ -88,8 +38,8 @@ function createProxyPlugin(config) {
           host: "127.0.0.1",
           // Set the port from Python config/env to ensure Nuxt uses the expected port
           // strictPort: true prevents auto-incrementing to a different port
-          ...config.devPort !== void 0 ? {
-            port: config.devPort,
+          ...config.port !== void 0 ? {
+            port: config.port,
             strictPort: true
           } : {},
           // Vite serves HMR on a separate internal port; browsers reach it through
@@ -105,6 +55,7 @@ function createProxyPlugin(config) {
       };
     },
     configureServer(server) {
+      installManagedShutdown(server);
       if (config.verbose) {
         server.middlewares.use((req, _res, next) => {
           if (req.url?.startsWith(config.apiPrefix)) {
@@ -186,26 +137,18 @@ function litestarNuxtModule(userOptions, nuxt) {
     console.log(colors.cyan("[litestar-nuxt]"), "Nitro devProxy configured:");
     console.log(JSON.stringify(nuxt.options.nitro.devProxy, null, 2));
   }
-  if (config.hotFile && config.devPort) {
-    const rawHost = process.env.NUXT_HOST || process.env.HOST || "127.0.0.1";
-    const host = normalizeHost(rawHost);
-    const url = `http://${host}:${config.devPort}`;
-    fs.mkdirSync(path.dirname(config.hotFile), { recursive: true });
-    fs.writeFileSync(config.hotFile, url);
-    if (config.verbose) {
-      console.log(colors.cyan("[litestar-nuxt]"), colors.dim(`Hotfile written: ${config.hotFile} -> ${url}`));
-    }
-  }
   if (nuxt.hook && config.hotFile) {
+    const hotFile = config.hotFile;
     nuxt.hook("listen", (_server, listener) => {
       const info = listener;
-      if (info && typeof info.port === "number") {
-        const host = normalizeHost(info.host || "127.0.0.1");
-        const url = `http://${host}:${info.port}`;
-        fs.mkdirSync(path.dirname(config.hotFile), { recursive: true });
-        fs.writeFileSync(config.hotFile, url);
+      const port = info?.address?.port ?? info?.port;
+      if (typeof port === "number") {
+        const host = normalizeHost(info.address?.address || info.host || "127.0.0.1");
+        const url = `http://${host}:${port}`;
+        fs.mkdirSync(path.dirname(hotFile), { recursive: true });
+        fs.writeFileSync(hotFile, url);
         if (config.verbose) {
-          console.log(colors.cyan("[litestar-nuxt]"), colors.dim(`Hotfile updated via listen hook: ${url}`));
+          console.log(colors.cyan("[litestar-nuxt]"), colors.dim(`Hotfile written after listen: ${hotFile} -> ${url}`));
         }
       }
     });

package/dist/js/react/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * React bindings for generic and Litestar Queues event streams.
+ *
+ * @module
+ */
+import { type EventStreamOptions, type QueueEventStreamOptions, type StreamGap } from "litestar-vite-plugin/helpers";
+export interface EventStreamState<TFrame> {
+    healthy: boolean;
+    lastEvent: TFrame | null;
+    lastGap: StreamGap | null;
+    events: TFrame[];
+}
+export type ReactEventStreamOptions<TFrame> = EventStreamOptions<TFrame> & {
+    key: string;
+    bufferSize?: number;
+};
+export type ReactQueueEventStreamOptions<TFrame> = QueueEventStreamOptions<TFrame> & {
+    key: string;
+    bufferSize?: number;
+};
+/**
+ * Subscribe a React component to a generic event stream.
+ */
+export declare function useEventStream<TFrame = unknown>(options: ReactEventStreamOptions<TFrame>): EventStreamState<TFrame>;
+/**
+ * Subscribe a React component to a Litestar Queues event stream.
+ */
+export declare function useQueueEventStream<TFrame = unknown>(options: ReactQueueEventStreamOptions<TFrame>): EventStreamState<TFrame>;

package/dist/js/react/index.js

@@ -0,0 +1,54 @@
+/**
+ * React bindings for generic and Litestar Queues event streams.
+ *
+ * @module
+ */
+import { createEventStream, createQueueEventStream } from "litestar-vite-plugin/helpers";
+import { useEffect, useRef, useState } from "react";
+function initialState() {
+    return { events: [], healthy: false, lastEvent: null, lastGap: null };
+}
+function useStream(factory, options) {
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    const [state, setState] = useState(initialState);
+    const transport = options.transport ?? "websocket";
+    useEffect(() => {
+        setState(initialState);
+        const { bufferSize: _bufferSize, key: _key, ...streamOptions } = optionsRef.current;
+        const stream = factory({
+            ...streamOptions,
+            onEvent: (frame) => {
+                optionsRef.current.onEvent(frame);
+                setState((current) => {
+                    const bufferSize = Math.max(0, optionsRef.current.bufferSize ?? 100);
+                    const events = bufferSize === 0 ? [] : [...current.events, frame].slice(-bufferSize);
+                    return { ...current, events, lastEvent: frame };
+                });
+            },
+            onGap: (gap) => {
+                optionsRef.current.onGap?.(gap);
+                setState((current) => ({ ...current, lastGap: gap }));
+            },
+            onHealthChange: (healthy) => {
+                optionsRef.current.onHealthChange?.(healthy);
+                setState((current) => ({ ...current, healthy }));
+            },
+        });
+        stream.connect();
+        return () => stream.dispose();
+    }, [factory, options.key, transport]);
+    return state;
+}
+/**
+ * Subscribe a React component to a generic event stream.
+ */
+export function useEventStream(options) {
+    return useStream(createEventStream, options);
+}
+/**
+ * Subscribe a React component to a Litestar Queues event stream.
+ */
+export function useQueueEventStream(options) {
+    return useStream(createQueueEventStream, options);
+}

package/dist/js/shared/bridge-schema.d.ts

@@ -8,9 +8,9 @@
  *
  * @module
  */
-export type BridgeMode = "spa" | "template" | "hybrid" | "framework" | "external";
-export type BridgeProxyMode = "vite" | "direct" | "proxy" | null;
-export type BridgeExecutor = "node" | "bun" | "deno" | "yarn" | "pnpm";
+type BridgeMode = "spa" | "template" | "hybrid" | "framework" | "external";
+type BridgeProxyMode = "vite" | "direct" | "proxy" | null;
+type BridgeExecutor = "node" | "bun" | "deno" | "yarn" | "pnpm";
 export interface BridgeTypesConfig {
     enabled: boolean;
     output: string;
@@ -27,7 +27,7 @@ export interface BridgeTypesConfig {
     globalRoute: boolean;
     failOnError?: boolean;
 }
-export interface BridgeSpaConfig {
+interface BridgeSpaConfig {
     /** Use script element instead of data-page attribute for Inertia page data */
     useScriptElement: boolean;
 }
@@ -35,11 +35,13 @@ export interface BridgeSchema {
     assetUrl: string;
     deployAssetUrl: string | null;
     appUrl: string | null;
+    csrfCookieName: string | null;
+    csrfHeaderName: string | null;
     /**
      * Litestar dev server port. Used by framework integrations to set
-     * `vite.server.hmr.clientPort`, ensuring the browser connects to Litestar
-     * (not the framework dev server) for HMR — preserving the single-port
-     * contract.
+     * `vite.server.ws.clientPort` on Vite 8.1+ (`vite.server.hmr.clientPort` on
+     * Vite 7 / 8.0), ensuring the browser connects to Litestar (not the framework
+     * dev server) for HMR — preserving the single-port contract.
      */
     litestarPort: number | null;
     bundleDir: string;
@@ -71,3 +73,4 @@ export interface BridgeSchema {
 }
 export declare function parseBridgeSchema(value: unknown): BridgeSchema;
 export declare function readBridgeConfig(explicitPath?: string): BridgeSchema | null;
+export {};

package/dist/js/shared/bridge-schema.js

@@ -4,6 +4,8 @@ const allowedTopLevelKeys = /* @__PURE__ */ new Set([
   "assetUrl",
   "deployAssetUrl",
   "appUrl",
+  "csrfCookieName",
+  "csrfHeaderName",
   "litestarPort",
   "bundleDir",
   "resourceDir",
@@ -174,6 +176,8 @@ function parseBridgeSchema(value) {
   const assetUrl = assertString(obj, "assetUrl");
   const deployAssetUrl = assertNullableString(obj, "deployAssetUrl");
   const appUrl = assertOptionalNullableString(obj, "appUrl");
+  const csrfCookieName = assertOptionalNullableString(obj, "csrfCookieName");
+  const csrfHeaderName = assertOptionalNullableString(obj, "csrfHeaderName");
   const litestarPort = assertOptionalNullableInteger(obj, "litestarPort");
   const bundleDir = assertString(obj, "bundleDir");
   const resourceDir = assertString(obj, "resourceDir");
@@ -195,6 +199,8 @@ function parseBridgeSchema(value) {
     assetUrl,
     deployAssetUrl,
     appUrl,
+    csrfCookieName,
+    csrfHeaderName,
     litestarPort,
     bundleDir,
     resourceDir,

package/dist/js/shared/emit-page-props-types.js

@@ -104,12 +104,8 @@ export interface FlashMessages {}
 `;
   }
   const defaultGeneratedSharedProps = {
-    errors: { type: "Record<string, string[]>", optional: true },
     csrf_token: { type: "string", optional: true },
-    ...includeDefaultAuth || includeDefaultFlash ? {
-      auth: { type: "AuthData", optional: true },
-      flash: { type: "FlashMessages", optional: true }
-    } : {}
+    ...includeDefaultAuth ? { auth: { type: "AuthData", optional: true } } : {}
   };
   const generatedSharedProps = Object.keys(json.sharedProps ?? {}).length > 0 ? json.sharedProps : defaultGeneratedSharedProps;
   const generatedSharedPropLines = Object.entries(generatedSharedProps).toSorted(([a], [b]) => a.localeCompare(b)).map(([key, def]) => {
@@ -246,7 +242,8 @@ export interface FlashMessages {}
     const propsType = rawType.includes("|") ? `(${rawType})` : rawType;
     pageEntries.push(`  "${component}": ${propsType} & FullSharedProps`);
   }
-  const body = `// AUTO-GENERATED by litestar-vite. Do not edit.
+  const flashReference = includeDefaultFlash ? '/// <reference path="./inertia.d.ts" />\n' : "";
+  const body = `${flashReference}// AUTO-GENERATED by litestar-vite. Do not edit.
 /* eslint-disable */
 
 // Import user-defined type extensions (edit page-props.user.ts to customize)
@@ -285,6 +282,25 @@ export type InertiaPageProps<C extends ComponentName> = PageProps[C]
 export type PagePropsFor<C extends ComponentName> = PageProps[C]
 `;
   const result = await writeIfChanged(outFile, body, { encoding: "utf-8" });
+  const declarationFile = path.join(outDir, "inertia.d.ts");
+  if (includeDefaultFlash) {
+    const declaration = `// AUTO-GENERATED by litestar-vite. Do not edit.
+/* eslint-disable */
+import "@inertiajs/core"
+import type { FlashMessages } from "./page-props"
+
+declare module "@inertiajs/core" {
+  interface InertiaConfig {
+    flashDataType: FlashMessages
+  }
+}
+
+export {}
+`;
+    await writeIfChanged(declarationFile, declaration, { encoding: "utf-8" });
+  } else if (fs.existsSync(declarationFile)) {
+    await fs.promises.rm(declarationFile);
+  }
   const userStubFile = path.join(outDir, "page-props.user.ts");
   if (!fs.existsSync(userStubFile)) {
     const userStub = `/**

package/dist/js/shared/emit-static-props-types.js

@@ -64,8 +64,12 @@ async function emitStaticPropsTypes(outputDir, projectRoot = process.cwd()) {
 /* eslint-disable */
 
 /**
- * Static props configured in Python ViteConfig.static_props.
- * Currently empty - add static_props to your ViteConfig to generate types.
+ * Build-time constants from Python ViteConfig.static_props, inlined into the bundle.
+ *
+ * No static props are configured, so this file is empty. This is not an error.
+ *
+ * Looking for values sent on every Inertia response? Those come from
+ * InertiaConfig.extra_static_page_props and are typed in page-props.ts, not here.
  *
  * @example
  * config = ViteConfig(

package/dist/js/shared/integration-config.d.ts

@@ -0,0 +1,75 @@
+import { type RequiredTypeGenConfig, type TypesConfigShape } from "./typegen-plugin.js";
+/** JavaScript runtime used to invoke package commands. */
+type IntegrationExecutor = "node" | "bun" | "deno" | "yarn" | "pnpm";
+/** Proxy strategy reported by the Python side in `.litestar.json`. */
+type IntegrationProxyMode = "vite" | "direct" | "proxy" | null;
+/**
+ * User-facing options accepted by every framework integration.
+ */
+export interface LitestarIntegrationConfig {
+    /**
+     * Litestar backend URL that API requests are proxied to.
+     *
+     * @default 'http://localhost:8000'
+     */
+    apiProxy?: string;
+    /**
+     * Path prefix treated as backend API routes.
+     *
+     * @default '/api'
+     */
+    apiPrefix?: string;
+    /**
+     * Type generation. `true` enables with defaults, `false` disables, or pass an object
+     * to override individual fields.
+     *
+     * @default false
+     */
+    types?: boolean | "auto" | TypesConfigShape;
+    /**
+     * Log integration activity.
+     *
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * JavaScript runtime executor for package commands. Overrides the executor reported by
+     * Python in `.litestar.json`.
+     */
+    executor?: IntegrationExecutor;
+}
+/**
+ * Integration configuration with defaults applied and bridge-file values merged in.
+ */
+export interface ResolvedIntegrationConfig {
+    apiProxy: string;
+    apiPrefix: string;
+    types: RequiredTypeGenConfig | false;
+    verbose: boolean;
+    hotFile?: string;
+    proxyMode: IntegrationProxyMode;
+    /** Preferred dev server port (provided by Python via `VITE_PORT` or the bridge file). */
+    port?: number;
+    /**
+     * Litestar dev server port. Used to set `vite.server.ws.clientPort` on Vite
+     * 8.1+ (`vite.server.hmr.clientPort` on Vite 7 / 8.0) so the browser opens HMR
+     * WebSockets against Litestar (single-port contract).
+     */
+    litestarPort?: number;
+    /** Asset URL prefix (e.g. `/static`); used to build the HMR path. */
+    assetUrl?: string;
+    /** JavaScript runtime executor for package commands. */
+    executor?: IntegrationExecutor;
+    /** Whether `.litestar.json` was found. */
+    hasPythonConfig: boolean;
+}
+/**
+ * Apply defaults and merge `.litestar.json` values into a framework integration's options.
+ *
+ * @param config - User-supplied integration options.
+ * @param defaultOutput - Framework-conventional directory for generated types, used when the
+ *   user and Python side both leave `types.output` unset.
+ * @returns The resolved configuration.
+ */
+export declare function resolveIntegrationConfig(config: LitestarIntegrationConfig, defaultOutput: string): ResolvedIntegrationConfig;
+export {};

package/dist/js/shared/integration-config.js

@@ -0,0 +1,59 @@
+import { readBridgeConfig } from "./bridge-schema.js";
+import { resolveHotFilePath, resolveLitestarPort } from "./network.js";
+import { resolveTypesConfig } from "./typegen-plugin.js";
+function resolvePortFromEnv() {
+  const envPort = process.env.VITE_PORT;
+  if (!envPort) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(envPort, 10);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function resolveIntegrationConfig(config, defaultOutput) {
+  let hotFile;
+  let proxyMode = "vite";
+  let port = resolvePortFromEnv();
+  let pythonTypesConfig;
+  let pythonExecutor;
+  let assetUrl;
+  let litestarPort;
+  let hasPythonConfig = false;
+  const runtime = readBridgeConfig();
+  if (runtime) {
+    hasPythonConfig = true;
+    hotFile = resolveHotFilePath(runtime.bundleDir, runtime.hotFile);
+    proxyMode = runtime.proxyMode;
+    port = runtime.port;
+    pythonExecutor = runtime.executor;
+    assetUrl = runtime.assetUrl;
+    if (runtime.types) {
+      pythonTypesConfig = runtime.types;
+    }
+  }
+  const resolvedLitestarPort = resolveLitestarPort(runtime?.litestarPort, runtime?.appUrl);
+  if (resolvedLitestarPort !== null) {
+    litestarPort = resolvedLitestarPort;
+  }
+  return {
+    apiProxy: config.apiProxy ?? "http://localhost:8000",
+    apiPrefix: config.apiPrefix ?? "/api",
+    types: resolveTypesConfig({
+      requested: config.types,
+      pythonConfig: pythonTypesConfig ?? void 0,
+      defaultOutput,
+      mergePythonWhenTrue: true,
+      mergePythonForObject: true
+    }),
+    verbose: config.verbose ?? false,
+    hotFile,
+    proxyMode,
+    port,
+    litestarPort,
+    assetUrl,
+    executor: config.executor ?? pythonExecutor,
+    hasPythonConfig
+  };
+}
+export {
+  resolveIntegrationConfig
+};