# Framework Integrations API
URL: /runtime/api/frameworks



Framework helpers package Tau's required build, header, worker, and host-process invariants behind stable configuration seams that hold across every qualified framework version.

## Vite and React Router [#vite-and-react-router]

`tauRuntime(options?){:ts}` returns an array of Vite plugins. Vite flattens nested plugin arrays, so place the result directly in `plugins` without spreading it:

```typescript
import { reactRouter } from '@react-router/dev/vite';
import { tauRuntime } from '@taucad/runtime/vite';
import { defineConfig } from 'vite';

export default defineConfig({
  plugins: [tauRuntime(), reactRouter()],
});
```

**`RuntimePluginOptions`** — Options for the {@link tauRuntime} Vite plugin.

- **`crossOriginIsolation`** (`boolean | undefined`, optional) — Skip the cross-origin-isolation middleware. Set to `false` when the host already serves COOP/COEP headers (e.g. via Express middleware or platform headers). Defaults to `true`.

**`RuntimeVitePlugin`** — Version-neutral public shape of a Vite plugin returned by Tau factories. Hook types remain internal so consumers can use the same factory with every supported Vite major without importing Tau's development-time Vite types.

- **`name`** (`string`, required)

`tauRuntime()` includes cross-origin-isolation middleware by default. Set `crossOriginIsolation: false` only when the production host owns those headers; the lower-level `crossOriginIsolation()` export installs only Vite dev/preview headers.

React Router SSR response code applies the canonical headers:

```typescript
import { applyHandleRequestHeaders } from '@taucad/runtime/react-router';

export function applyRuntimeHeaders(responseHeaders: Headers): void {
  applyHandleRequestHeaders(responseHeaders);
}
```

Express and Connect hosts mount the server adapter without a cast:

```typescript
import express from 'express';
import { coiMiddleware } from '@taucad/runtime/cross-origin-isolation/express';

const app = express();
app.use(coiMiddleware());
```

`@taucad/runtime/cross-origin-isolation` also exports the raw header maps and appliers — `documentHeaders`, `subresourceHeaders`, `applyDocumentHeaders`, `applySubresourceHeaders` — plus the `IsolationStatus` / `IsolationFailureReason` diagnostic types for custom hosts.

## Next.js [#nextjs]

`withTauRuntime()` composes application headers and bundler configuration into a `NextRuntimeConfig`. The same call configures Next.js 15's supported Webpack production path and Next.js 16's Turbopack path.

```typescript
import { withTauRuntime } from '@taucad/runtime/nextjs/config';

export default withTauRuntime({
  output: 'standalone',
});
```

**`NextConfig`**

- **`allowedDevOrigins`** (`string[] | undefined`, optional)
- **`exportPathMap`** (`((defaultMap: ExportPathMap, ctx: { dev: boolean; dir: string; outDir: string | null; distDir: string; buildId: string; }) => Promise<ExportPathMap> | ExportPathMap) | undefined`, optional)
- **`i18n`** (`I18NConfig | null | undefined`, optional) — Internationalization configuration

  Tags: @see [Internationalization docs](https://nextjs.org/docs/advanced-features/i18n-routing)
- **`typescript`** (`TypeScriptConfig | undefined`, optional)

  Tags: @see [Next.js TypeScript documentation](https://nextjs.org/docs/app/api-reference/config/typescript)
- **`typedRoutes`** (`boolean | undefined`, optional) — Enable type checking for Link and Router.push, etc. This feature requires TypeScript in your project.

  Tags: @see [Typed Links documentation](https://nextjs.org/docs/app/api-reference/config/typescript#statically-typed-links)
- **`headers`** (`(() => Promise<Header[]> | Header[]) | undefined`, optional) — Headers allow you to set custom HTTP headers for an incoming request path.

  Tags: @see [Headers configuration documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/headers)
- **`rewrites`** (`(() => Promise<Rewrite[] | { beforeFiles?: Rewrite[]; afterFiles?: Rewrite[]; fallback?: Rewrite[]; }> | Rewrite[] | { beforeFiles?: Rewrite[]; afterFiles?: Rewrite[]; fallback?: Rewrite[]; }) | undefined`, optional) — Rewrites allow you to map an incoming request path to a different destination path.

  Tags: @see [Rewrites configuration documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites)
- **`redirects`** (`(() => Promise<Redirect[]> | Redirect[]) | undefined`, optional) — Redirects allow you to redirect an incoming request path to a different destination path.

  Tags: @see [Redirects configuration documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/redirects)
- **`excludeDefaultMomentLocales`** (`boolean | undefined`, optional)

  Tags: @see [Moment.js locales excluded by default](https://nextjs.org/docs/upgrading#momentjs-locales-excluded-by-default)
- **`webpack`** (`NextJsWebpackConfig | null | undefined`, optional) — Before continuing to add custom webpack configuration to your application make sure Next.js doesn't already support your use-case

  Tags: @see [Custom Webpack Config documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/webpack)
- **`trailingSlash`** (`boolean | undefined`, optional, default `false`) — By default Next.js will redirect urls with trailing slashes to their counterpart without a trailing slash.

  Tags: @see [Trailing Slash Configuration](https://nextjs.org/docs/app/api-reference/config/next-config-js/trailingSlash)
- **`env`** (`Record<string, string | undefined> | undefined`, optional) — Next.js comes with built-in support for environment variables

  Tags: @see [Environment Variables documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/env)
- **`distDir`** (`string | undefined`, optional) — Destination directory (defaults to `.next`)
- **`cleanDistDir`** (`boolean | undefined`, optional) — The build output directory (defaults to `.next`) is now cleared by default except for the Next.js caches.
- **`assetPrefix`** (`string | undefined`, optional) — To set up a CDN, you can set up an asset prefix and configure your CDN's origin to resolve to the domain that Next.js is hosted on.

  Tags: @see [CDN Support with Asset Prefix](https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix)
- **`cacheHandler`** (`string | undefined`, optional) — The default cache handler for the Pages and App Router uses the filesystem cache. This requires no configuration, however, you can customize the cache handler if you prefer.

  Tags: @see [Configuring Caching](https://nextjs.org/docs/app/building-your-application/deploying#configuring-caching) and the [API Reference](https://nextjs.org/docs/app/api-reference/next-config-js/incrementalCacheHandlerPath).
- **`adapterPath`** (`string | undefined`, optional) — Path to a custom adapter module for deployment platform integration. Can also be set via the `NEXT_ADAPTER_PATH` environment variable.
- **`cacheHandlers`** (`{ [handlerName: string]: string | undefined; default?: string; remote?: string; static?: string; } | undefined`, optional)
- **`cacheMaxMemorySize`** (`number | undefined`, optional) — Configure the in-memory cache size in bytes. Defaults to 50 MB. If `cacheMaxMemorySize: 0`, this disables in-memory caching entirely.

  Tags: @see [Configuring Caching](https://nextjs.org/docs/app/building-your-application/deploying#configuring-caching).
- **`useFileSystemPublicRoutes`** (`boolean | undefined`, optional, default `true`) — By default, `Next` will serve each file in the `pages` folder under a pathname matching the filename. To disable this behavior and prevent routing based set this to `true`.

  Tags: @see [Disabling file-system routing](https://nextjs.org/docs/advanced-features/custom-server#disabling-file-system-routing)
- **`generateBuildId`** (`(() => string | null | Promise<string | null>) | undefined`, optional)

  Tags: @see [Configuring the build ID](https://nextjs.org/docs/app/api-reference/config/next-config-js/generateBuildId)
- **`generateEtags`** (`boolean | undefined`, optional)

  Tags: @see [Disabling ETag Configuration](https://nextjs.org/docs/app/api-reference/config/next-config-js/generateEtags)
- **`pageExtensions`** (`string[] | undefined`, optional)

  Tags: @see [Including non-page files in the pages directory](https://nextjs.org/docs/app/api-reference/config/next-config-js/pageExtensions)
- **`instrumentationClientInject`** (`string[] | undefined`, optional) — Module specifiers that are required for side effects on the client before hydration, in array order, ahead of the user's `instrumentation-client.{ts,js}`. Each entry may be a bare npm package name or a path relative to the project root.
- **`compress`** (`boolean | undefined`, optional)

  Tags: @see [Compression documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/compress)
- **`poweredByHeader`** (`boolean | undefined`, optional)

  Tags: @see [Disabling x-powered-by](https://nextjs.org/docs/app/api-reference/config/next-config-js/poweredByHeader)
- **`images`** (`Partial<ImageConfigComplete> | undefined`, optional)

  Tags: @see [Using the Image Component](https://nextjs.org/docs/app/api-reference/next-config-js/images)
- **`devIndicators`** (`false | { position?: "top-left" | "top-right" | "bottom-left" | "bottom-right"; } | undefined`, optional) — Configure indicators in development environment
- **`onDemandEntries`** (`{ maxInactiveAge?: number; pagesBufferLength?: number; } | undefined`, optional) — Next.js exposes some options that give you some control over how the server will dispose or keep in memory built pages in development.

  Tags: @see [Configuring `onDemandEntries`](https://nextjs.org/docs/app/api-reference/config/next-config-js/onDemandEntries)
- **`deploymentId`** (`string | undefined`, optional) — A unique identifier for a deployment that will be included in each request's query string or header.
- **`supportsImmutableAssets`** (`boolean | undefined`, optional) — Whether the deployment environment supports immutable assets (assets deployed to `_next/static/immutable` don't need a `?dpl` parameter and can be safely requested across deployments.)
- **`basePath`** (`string | undefined`, optional) — Deploy a Next.js application under a sub-path of a domain

  Tags: @see [Base path configuration](https://nextjs.org/docs/app/api-reference/config/next-config-js/basePath)
- **`sassOptions`** (`{ [key: string]: any; implementation?: string; } | undefined`, optional)

  Tags: @see [Customizing sass options](https://nextjs.org/docs/app/api-reference/next-config-js/sassOptions)
- **`productionBrowserSourceMaps`** (`boolean | undefined`, optional) — Enable browser source map generation during the production build

  Tags: @see [Source Maps](https://nextjs.org/docs/advanced-features/source-maps)
- **`reactCompiler`** (`boolean | ReactCompilerOptions | undefined`, optional) — Enable {@link https://nextjs.org/docs/app/api-reference/config/next-config-js/reactCompiler React Compiler in Next.js}. Configuration accepts partial config object of the Compiler. If provided, the Compiler will be enabled.
- **`reactProductionProfiling`** (`boolean | undefined`, optional) — Enable react profiling in production
- **`reactStrictMode`** (`boolean | null | undefined`, optional) — The Next.js runtime is Strict Mode-compliant.

  Tags: @see [React Strict Mode](https://nextjs.org/docs/app/api-reference/config/next-config-js/reactStrictMode)
- **`reactMaxHeadersLength`** (`number | undefined`, optional) — The maximum length of the headers that are emitted by React and added to the response.

  Tags: @see [React Max Headers Length](https://nextjs.org/docs/app/api-reference/config/next-config-js/reactMaxHeadersLength)
- **`httpAgentOptions`** (`{ keepAlive?: boolean; } | undefined`, optional) — Next.js enables HTTP Keep-Alive by default. You may want to disable HTTP Keep-Alive for certain `fetch()` calls or globally.

  Tags: @see [Disabling HTTP Keep-Alive](https://nextjs.org/docs/app/api-reference/next-config-js/httpAgentOptions)
- **`staticPageGenerationTimeout`** (`number | undefined`, optional, default `60`) — Timeout after waiting to generate static pages in seconds
- **`crossOrigin`** (`"anonymous" | "use-credentials" | undefined`, optional) — Add `"crossorigin"` attribute to generated `<script>` elements generated by `<Head />` or `<NextScript />` components

  Tags: @see [`crossorigin` attribute documentation](https://developer.mozilla.org/docs/Web/HTML/Attributes/crossorigin)
- **`compiler`** (`{ reactRemoveProperties?: boolean | { properties?: string[]; }; relay?: { src: string; artifactDirectory?: string; language?: "typescript" | "javascript" | "flow"; eagerEsModules?: boolean; }; removeConsole?: boolean | { exclude?: string[]; }; styledComponents?: boolean | StyledComponentsConfig; emotion?: boolean | EmotionConfig; styledJsx?: boolean | { useLightningcss?: boolean; }; define?: Record<string, string | number | boolean>; defineServer?: Record<string, string | number | boolean>; runAfterProductionCompile?: (metadata: { projectDir: string; distDir: string; }) => Promise<void>; } | undefined`, optional) — Optionally enable compiler transforms

  Tags: @see [Supported Compiler Options](https://nextjs.org/docs/advanced-features/compiler#supported-features)
- **`output`** (`"standalone" | "export" | undefined`, optional) — The type of build output. - `undefined`: The default build output, `.next` directory, that works with production mode `next start` or a hosting provider like Vercel - `'standalone'`: A standalone build output, `.next/standalone` directory, that only includes necessary files/dependencies. Useful for self-hosting in a Docker container. - `'export'`: An exported build output, `out` directory, that only includes static HTML/CSS/JS. Useful for self-hosting without a Node.js server.

  Tags: @see [Output File Tracing](https://nextjs.org/docs/advanced-features/output-file-tracing), @see [Static HTML Export](https://nextjs.org/docs/advanced-features/static-html-export)
- **`transpilePackages`** (`string[] | undefined`, optional) — Automatically transpile and bundle dependencies from local packages (like monorepos) or from external dependencies (`node_modules`). This replaces the `next-transpile-modules` package.

  Tags: @see [transpilePackages](https://nextjs.org/docs/advanced-features/compiler#module-transpilation)
- **`turbopack`** (`TurbopackOptions | undefined`, optional) — Options for Turbopack. Temporarily also available as `experimental.turbo` for compatibility.
- **~~`skipMiddlewareUrlNormalize`~~** (`boolean | undefined`, optional)

  Tags: @deprecated Use `skipProxyUrlNormalize` instead.
- **`skipProxyUrlNormalize`** (`boolean | undefined`, optional)
- **`skipTrailingSlashRedirect`** (`boolean | undefined`, optional)
- **`modularizeImports`** (`Record<string, { transform: string | Record<string, string>; preventFullImport?: boolean; skipDefaultConversion?: boolean; }> | undefined`, optional)
- **`logging`** (`false | LoggingConfig | undefined`, optional) — Logging configuration. Set to `false` to disable logging.
- **`enablePrerenderSourceMaps`** (`boolean | undefined`, optional) — Enables source maps while generating static pages. Helps with errors during the prerender phase in `next build`. Defaults to `true`. Set to `false` to disable.
- **`cacheComponents`** (`boolean | undefined`, optional) — When enabled, routes can combine a prerendered shell with dynamic content streamed into it, rather than being either fully static or fully dynamic. You can mark data and parts of your UI as cacheable using the `use cache` directive, which includes them in the pre-render pass alongside static parts of the page. Also enables `cacheLife` and `cacheTag` APIs, and includes Partial Prerendering support.

  Tags: @see [Cache Components documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheComponents)
- **`partialPrefetching`** (`boolean | "unstable_eager" | undefined`, optional) — Opts the whole app into Partial Prefetching: `<Link prefetch={true}>` prefetches only the static parts of a route, never its dynamic data. When `true`, the default segment-level `prefetch` becomes `'partial'`; per-segment `prefetch` exports still win. Requires `cacheComponents: true`.

  When `false` or omitted, this does nothing (the legacy behavior, where dynamic data is included in the prefetch).

  `'unstable_eager'` is like `true`, except the default becomes `'unstable_eager'` instead of `'partial'`: every Link has an implied prefetch={true}. Internal migration aid; not part of the public API.
- **`cacheLife`** (`{ [profile: string]: { stale?: number; revalidate?: number; expire?: number; }; } | undefined`, optional)
- **`expireTime`** (`number | undefined`, optional) — period (in seconds) where the server allow to serve stale cache
- **`agentRules`** (`boolean | undefined`, optional, default `true`) — When `next dev` detects an AI coding agent and no managed agent-rules block is present, Next.js auto-generates `AGENTS.md` and `CLAUDE.md` at the project root so the agent reads version-matched docs from `node_modules/next/dist/docs/` instead of stale training data. Set to `false` to disable this behavior.
- **`experimental`** (`ExperimentalConfig | undefined`, optional) — Enable experimental features. Note that all experimental features are subject to breaking changes in the future.
- **`bundlePagesRouterDependencies`** (`boolean | undefined`, optional) — Enables the bundling of node_modules packages (externals) for pages server-side bundles.

  Tags: @see https://nextjs.org/docs/pages/api-reference/next-config-js/bundlePagesRouterDependencies
- **`serverExternalPackages`** (`string[] | undefined`, optional) — A list of packages that should be treated as external in the server build.

  Tags: @see https://nextjs.org/docs/app/api-reference/next-config-js/serverExternalPackages
- **`outputFileTracingRoot`** (`string | undefined`, optional) — This is the repo root usually and only files above this directory are traced and included.
- **`outputFileTracingExcludes`** (`Record<string, string[]> | undefined`, optional) — This allows manually excluding traced files if too many are included incorrectly on a per-page basis.
- **`outputFileTracingIncludes`** (`Record<string, string[]> | undefined`, optional) — This allows manually including traced files if some were not detected on a per-page basis.
- **`outputHashSalt`** (`string | undefined`, optional) — A string that is incorporated into content-addressed output filenames (chunks, assets) for both Webpack and Turbopack. Changing this value forces all output hashes to change, which is useful for invalidating cached assets across deployments without modifying source files.

  When `NEXT_HASH_SALT` environment variable is also set, the two values are concatenated (`outputHashSalt + NEXT_HASH_SALT`) to form the effective salt.
- **`watchOptions`** (`{ pollIntervalMs?: number; } | undefined`, optional)
- **`htmlLimitedBots`** (`RegExp | undefined`, optional, default `/Mediapartners-Google|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview/i`) — User Agent of bots that can handle streaming metadata. Besides the default behavior, Next.js act differently on serving metadata to bots based on their capability.

**`NextRuntimeHeadersOptions`** — Options for `nextRuntimeHeaders`.

- **`document`** (`string | readonly string[] | undefined`, optional) — Route pattern(s) for document responses that must be cross-origin isolated. Defaults to every route.
- **`subresource`** (`string | readonly string[] | undefined`, optional) — Same-origin subresource route pattern(s). Defaults to no extra rules because most Next apps serve same-origin assets through the document rule.

**`NextRuntimeHeaderRule`** — Minimal shape accepted by Next.js `headers()`.

- **`source`** (`string`, required)
- **`headers`** (`{ key: string; value: string; }[]`, required)

Use `nextRuntimeHeaders(options?){:ts}` only as the low-level header-rule escape hatch; it configures neither browser-worker assets nor Node builtin aliases.

`@taucad/runtime/nextjs/browser-node-builtins` is the browser alias target `withTauRuntime()` wires for Node builtins; its stubs (`accessSync`, `createReadStream`, `createWriteStream`, `dirname`, `existsSync`, `fileURLToPath`, `mkdirSync`, `readFileSync`, `readdirSync`, `statSync`, `unlink`, `unlinkSync`, `writeFileSync`, `webcrypto`, …) are not for direct use.

## Electron config [#electron-config]

`electronRuntimeConfig()` composes electron-vite's main, preload, and renderer config, supporting electron-vite 5/Vite 7 and electron-vite 6 beta/Vite 8 through the same call:

```typescript
import { electronRuntimeConfig } from '@taucad/runtime/electron/vite';

export default electronRuntimeConfig({
  main: {},
  preload: {},
  renderer: {},
});
```

**`ElectronRuntimeUserConfig`** — Stable electron-vite configuration fields composed by {@link electronRuntimeConfig}.

- **`main`** (`ElectronRuntimeNodeConfig | undefined`, optional)
- **`preload`** (`ElectronRuntimeNodeConfig | undefined`, optional)
- **`renderer`** (`ElectronRuntimeRendererConfig | undefined`, optional)

The adapter installs Tau's Vite invariants in main and renderer and the native dependency externalizer in main and preload. See [Bundling](/runtime/guides/bundling#electron) for utility-process entries.

## Electron process boundaries [#electron-process-boundaries]

The public Electron topology has one helper at each process boundary:

| Process  | Import                              | Helper                                                         |
| -------- | ----------------------------------- | -------------------------------------------------------------- |
| Main     | `@taucad/runtime/electron/main`     | `installElectronRuntimeHeaders`, `registerElectronRuntimeMain` |
| Preload  | `@taucad/runtime/electron/preload`  | `exposeElectronRuntime`                                        |
| Utility  | `@taucad/runtime/electron/utility`  | `serveElectronRuntime`                                         |
| Renderer | `@taucad/runtime/electron/renderer` | `createElectronClientOptions`                                  |

**`ElectronRuntimeHeadersOptions`** — Options for {@link installElectronRuntimeHeaders}.

- **`session`** (`Electron.Session | undefined`, optional) — Electron session whose responses receive COOP and COEP headers.

**`RegisterElectronRuntimeMainOptions`** — Options for {@link registerElectronRuntimeMain}.

- **`compute`** (`ComputeBinding | undefined`, optional) — Host-owned compute binding transferred privately to each utility.
- **`channel`** (`string | undefined`, optional) — IPC channel shared with preload. Defaults to {@link electronRuntimeChannel}.
- **`env`** (`NodeJS.ProcessEnv | undefined`, optional) — Environment passed to each spawned utility process.
- **`forkEnvAllowlist`** (`readonly string[] | undefined`, optional) — Environment names {@link RegisterElectronRuntimeMainOptions.resolveFork} may return. Empty by default: an application names every key a resolver is allowed to set, so a resolver bug cannot reach `ELECTRON_RUN_AS_NODE` or `NODE_OPTIONS`. Static `env` is not filtered — it is the application's own.
- **`execArgv`** (`readonly string[] | undefined`, optional) — Executable arguments for each spawned utility process — canonically `['--max-old-space-size=8192']` to raise the utility's V8 heap for large assemblies. Omitted entirely when unset, so Electron's default applies.

  Caveat: Electron documents `execArgv` only as "arguments passed to the executable" and says nothing about V8 flags. The utility process is a Node environment that parses them, but that is unverified here; if a flag does not take effect, pass it as `NODE_OPTIONS` through `env` instead.
- **`maxUtilities`** (`number | undefined`, optional) — Runaway-fork guard: most utility processes this broker may hold at once, spare included. The (N+1)th request is refused with an {@link ElectronRuntimeUtilityLimitError}. Unset, the broker forks as many as the application asks for.

  This is not a concurrency policy. How many projects or agents may be live at once belongs to the application that admits them — on the Tau desktop that is the sessions registry (`apps/ui/app/services/sessions-store.ts`), whose budget is memory rather than a count — so set this an order of magnitude above anything that admission can legitimately ask for.
- **`ipcMain`** (`Electron.IpcMain | undefined`, optional) — Electron IPC main implementation, primarily for alternate hosts and tests. Also the admission seam: a view that filters before delegating to the real `ipcMain` gates which frames may fork a utility.
- **`onError`** (`((error: Error) => void) | undefined`, optional) — Receives utility-spawn, relay, and fork-refusal failures.
- **`onUtilityExit`** (`((exit: ElectronRuntimeUtilityExit) => void) | undefined`, optional) — Receives every utility exit, whether main released it or the process died on its own.
- **`onUtilityFork`** (`((fork: { readonly hostId: string; readonly entry: string; }) => void) | undefined`, optional) — Receives every fork, with the entry that was actually forked for it.
- **`onUtilityStderr`** (`((output: { readonly hostId: string; readonly chunk: string; }) => void) | undefined`, optional) — Receives every stderr chunk a utility writes, as it is written.
- **`resolveFork`** (`ElectronRuntimeForkResolver | undefined`, optional) — Per-request fork resolution from the renderer's sanitized context. Omitted entirely, every request forks `utilityEntry` with the static `env`.
- **`serviceName`** (`string | undefined`, optional) — Operating-system service name assigned to the utility process.
- **`stdio`** (`string | ("pipe" | "ignore" | "inherit")[] | undefined`, optional) — Utility-process standard I/O routing. Defaults to `'pipe'` so the broker reads each utility's stderr; an inherited stream goes nowhere in a packaged app and takes every boot stack with it.
- **`utilityEntry`** (`string | URL`, required) — Built utility-process module that calls `serveElectronRuntime`.

**`ElectronRuntimeMainHandle`** — Disposable main-process runtime broker registration.

- **`connect`** (`(input: ElectronRuntimeMainConnectInput) => ElectronRuntimeMainConnection`, required) — Mint one runtime port for a trusted main-process caller.

  Unlike the IPC listener, this input is application-owned rather than renderer-supplied. It still passes through the same resolver validation, fork and lease path so the two clients cannot drift.
- **`dispose`** (`() => void`, required) — Unregister IPC listeners and terminate every utility host owned by this broker.
- **`prewarm`** (`() => void`, required) — Fork the idle spare for the statically configured entry and environment, so the first request that resolves to them is served by a process that is already past its module graph. A no-op once a spare exists or the cap is reached; a request whose resolved environment differs forks its own.

**`ExposeElectronRuntimeOptions`** — Options for {@link exposeElectronRuntime}.

- **`channel`** (`string | undefined`, optional) — IPC channel shared with the main-process broker.
- **`debugGlobalName`** (`string | undefined`, optional) — Renderer global used for the debug flag.
- **`globalName`** (`string | undefined`, optional) — Renderer global used for the request/release bridge.

**`ElectronRuntimePreloadBridge`** — Narrow preload bridge exposed to an Electron renderer.

- **`relayTag`** (`{ readonly hostExit: string; readonly runtime: string; }`, required) — Relay tags exposed to the renderer.
- **`requestRuntimePort`** (`(requestId: string, context?: Record<string, string>) => void`, required) — Ask the main process to spawn one utility runtime and relay its port.

  Tags: @param requestId - Opaque request identity echoed with the relayed port., @param context - Optional flat string record the main-process broker sanitizes and hands to its application fork resolver (e.g. `projectRoot`)., @returns Nothing.
- **`releaseRuntimeHost`** (`(hostId: string, reason: "requested" | "operation-timeout") => void`, required) — Release exactly one opaque utility host lease.

  Tags: @param hostId - Opaque lease received with the relayed runtime port., @param reason - Requested shutdown or hard operation-timeout recovery., @returns Nothing.

**`ServeElectronRuntimeOptions`** — Options for {@link serveElectronRuntime} in an Electron utility entry.

- **`fileSystem`** (`RuntimeFileSystem | undefined`, optional) — Rooted static filesystem, omitted when main transfers one in the boot frame.
- **`installProcessTeardown`** (`boolean | undefined`, optional) — Install a process-exit disposer. Defaults to true.
- **`runtime`** (`AnyRuntimeDefinition`, required) — Executable runtime definition owned by this utility host.

**`ElectronClientOptionsInput`** — Options for {@link createElectronClientOptions}.

- **`bridge`** (`ElectronRuntimeRendererBridge | undefined`, optional) — Explicit preload bridge, primarily for alternate globals and tests.
- **`context`** (`Record<string, string> | undefined`, optional) — Flat string record describing which utility this client wants — e.g. `{ projectRoot, definition }`. The main-process broker sanitizes it and hands it to the application's fork resolver; the runtime assigns no meaning to the keys.
- **`globalName`** (`string | undefined`, optional) — Name of the preload bridge on `window`. Defaults to `taucad`.
- **`target`** (`ElectronRuntimeMessageTarget | undefined`, optional) — Message target that receives the relayed utility-process port.
- **`operationTimeout`** (`number | undefined`, optional) — Wall-clock deadline applied independently to each operation. Milliseconds. Zero disables timeout enforcement.
- **`machines`** (`{ available: true; connect: () => MachineChannelClient; } | { available: false; reason: "unsupported" | "not-granted"; } | undefined`, optional) — Authenticated machines service brokered beside the runtime port, in the WebSocket transport's `machines` shape. Absent, the client negotiates `{ available: false, reason: 'unsupported' }`.
- **`config`** (`RuntimeConfigProvider<Runtime> | undefined`, optional)

**`ElectronRuntimeRendererBridge`** — Renderer-facing view of the bridge exposed by Electron preload.

- **`relayTag`** (`{ readonly hostExit?: string; readonly runtime: string; }`, required) — Relay tags exposed by preload for Electron runtime messages.
- **`requestRuntimePort`** (`(requestId: string, context?: Record<string, string>) => void`, required) — Ask the main process to spawn one utility runtime and relay its port, optionally carrying the fork context the main-process resolver reads.
- **`releaseRuntimeHost`** (`(hostId: string, reason: "requested" | "operation-timeout") => void`, required) — Release exactly one opaque utility host lease. Called by the transport; application code should normally use `RuntimeClient.terminate()`.

**`RequestElectronRuntimePortOptions`** — Options for requesting a leased Electron utility-process port.

- **`bridge`** (`ElectronRuntimeRendererBridge | undefined`, optional) — Explicit preload bridge, primarily for alternate globals and tests.
- **`context`** (`Record<string, string> | undefined`, optional) — Flat string record describing which utility this client wants — e.g. `{ projectRoot, definition }`. The main-process broker sanitizes it and hands it to the application's fork resolver; the runtime assigns no meaning to the keys.
- **`globalName`** (`string | undefined`, optional) — Name of the preload bridge on `window`. Defaults to `taucad`.
- **`target`** (`ElectronRuntimeMessageTarget | undefined`, optional) — Message target that receives the relayed utility-process port.

Application renderer code needs only the high-level options provider:

```typescript
import { createRuntimeClient } from '@taucad/runtime/client';
import { createElectronClientOptions } from '@taucad/runtime/electron/renderer';

const provideClientOptions = createElectronClientOptions();
const client = createRuntimeClient({ ...(await provideClientOptions()), operationTimeout: 60_000 });
```

`requestElectronRuntimePort()`, `getElectronRuntimeBridge()`, `awaitElectronRuntimePort()`, and the bridge types are escape hatches for alternate globals or host adapters, as are the wire pieces `electronRuntimeChannel`, `electronUtilityTransport` (`ElectronUtilityTransportOptions`), `electronUtilityClient`, `electronUtilityClientDescribe`, and `electronUtilityHost` (`ElectronUtilityHostOptions`). Application code should not handle opaque host IDs or call `releaseRuntimeHost()` directly.

## Browser-worker transport [#browser-worker-transport]

Use the paired high-level helpers for the app-owned Web Worker topology:

```typescript
import { createRuntimeClient } from '@taucad/runtime/client';
import { createWebWorkerClientOptions } from '@taucad/runtime/transport/web';

const clientOptions = createWebWorkerClientOptions({
  createWorker: () => new Worker(new URL('./runtime.worker.ts', import.meta.url), { type: 'module' }),
});

const client = createRuntimeClient({ ...clientOptions, operationTimeout: 60_000 });
```

**`WebWorkerClientOptionsInput`** — Options for {@link createWebWorkerClientOptions}.

- **`url`** (`string | URL | undefined`, optional) — URL of the worker module entry. Must resolve to a `type: 'module'` worker that composes `createRuntimeWorker({ runtime })` with `webWorkerHost(...)`. Required unless `createWorker` is supplied.
- **`workerCtor`** (`{ new (scriptURL: string | URL, options?: WorkerOptions): Worker; prototype: Worker; } | undefined`, optional) — Override for the global `Worker` constructor — primary use is unit-test injection of a fake worker.
- **`createWorker`** (`(() => WebWorkerLike) | undefined`, optional) — Create an app-owned worker instance. Use this in frameworks whose bundler requires the native worker expression at the app callsite, for example `new Worker(new URL('./runtime.worker.ts', import.meta.url), { type: 'module' })` in Next/Turbopack.
- **`sharedMemory`** (`{ readonly geometry?: { readonly bytes: number; }; } | undefined`, optional)
- **`devtoolsTelemetry`** (`boolean | undefined`, optional) — Mirror runtime spans into the worker Performance Timeline for DevTools.
- **`compiledWasmModules`** (`readonly CompiledWasmModuleHandle[] | undefined`, optional) — Host-compiled WASM modules cloned into the worker during initialization.
- **`compute`** (`ComputeBinding | undefined`, optional)
- **`files`** (`Record<string, string> | undefined`, optional) — Optional runtime-path-to-content map for the transport-owned in-memory filesystem. Omitting this still creates an empty memory filesystem for inline source staging. Pass `fileSystem` for custom FS authority.
- **`fileSystem`** (`RuntimeFileSystem | undefined`, optional) — Explicit rooted filesystem exposed to plugins by this transport. Mutually exclusive with `files`.
- **`operationTimeout`** (`number | undefined`, optional) — Wall-clock deadline applied independently to each preview. Milliseconds. Zero disables timeout enforcement.
- **`config`** (`RuntimeConfigProvider<Runtime> | undefined`, optional)

The app-owned worker entry serves its executable runtime definition:

```typescript
import { esbuild } from '@taucad/esbuild';
import { replicad } from '@taucad/replicad';
import { defineRuntime } from '@taucad/runtime/worker';
import { serveWebWorkerRuntime } from '@taucad/runtime/worker/web';

const runtime = defineRuntime({
  plugins: [replicad(), esbuild()],
});

await serveWebWorkerRuntime({ runtime });
```

**`ServeWebWorkerRuntimeOptions`** — Options for serving a runtime from an app-owned browser module worker.

- **`runtime`** (`AnyRuntimeDefinition`, required)

Use `webWorkerTransport` and `webWorkerHost` directly only when authoring a custom host composition — see [Transport API](/runtime/api/transport).

## Related [#related]

* [Bundling](/runtime/guides/bundling)
* [Cross-Origin Isolation](/runtime/guides/cross-origin-isolation)
* [Embedding in a Host](/runtime/guides/embedding-in-a-host)
* [Transport API](/runtime/api/transport)