@kodycodes/cli 1.25.0 → 1.26.0

package/dist/local-runtime-source.js

@@ -42,21 +42,136 @@ export function createRuntimeFlatAliasSource() {
     const runtime = JSON.stringify(localWorkerModuleNames.runtime);
     return `export * from ${runtime};\nexport { default } from ${runtime};\n`;
 }
-export function createLocalRuntimeModuleSource() {
+/** Workerd-side `kody.gatewayFetchStream` + bridge install helpers (shared shape). */
+export function localGatewayFetchStreamRuntimeSource(options) {
     return `
-import { AsyncLocalStorage } from 'node:async_hooks';
-
 let __kodyBridge = null;
 
 export function __kodyInstallLocalBridge(bridge) {
-	__kodyBridge = bridge;
+	// Object form: { call, gatewayFetch }. Legacy function form still works for /call.
+	__kodyBridge =
+		typeof bridge === 'function' ? { call: bridge, gatewayFetch: null } : bridge;
 }
 
 function __kodyCall(path, args) {
-	if (__kodyBridge === null) {
-		throw new Error('kody:runtime is only available while an execute --local run is in progress.');
+	if (__kodyBridge === null || typeof __kodyBridge.call !== 'function') {
+		throw new Error(${JSON.stringify(options.callUnavailableMessage)});
 	}
-	return __kodyBridge(path, args);
+	return __kodyBridge.call(path, args);
+}
+
+const __kodyGatewayNullBodyStatuses = new Set([101, 103, 204, 205, 304]);
+const __kodySecretResolutionHeader = 'x-kody-secret-resolution';
+
+/**
+ * Streaming CapabilityProxy hop (POST /v1/capability-proxy/gateway-fetch via the
+ * loopback bridge). Returns a real Response — not the JSON gatewayFetch envelope.
+ * See kentcdodds/kody docs/contributing/contracts/cli-streaming-gateway-fetch.md.
+ */
+async function gatewayFetchStream(input) {
+	if (__kodyBridge === null || typeof __kodyBridge.gatewayFetch !== 'function') {
+		throw new Error(
+			'Local execute needs kody.gatewayFetchStream on the host runtime to stream a secret-aware fetch body (multipart, large, or ReadableStream). Upgrade @kodycodes/cli, or buffer the body under 4 MiB for the JSON gatewayFetch hop.',
+		);
+	}
+	const record = input != null && typeof input === 'object' && !Array.isArray(input) ? input : null;
+	if (!record) {
+		throw new Error('gatewayFetchStream requires a single object argument: { request, packageId? }.');
+	}
+	const requestValue = record.request;
+	if (requestValue == null || typeof requestValue !== 'object' || Array.isArray(requestValue)) {
+		throw new Error('gatewayFetchStream requires request: { url, method?, headers?, body? }.');
+	}
+	const url = typeof requestValue.url === 'string' ? requestValue.url.trim() : '';
+	if (!url) {
+		throw new Error('gatewayFetchStream request.url must be a non-empty absolute URL.');
+	}
+	const method =
+		typeof requestValue.method === 'string' && requestValue.method.trim()
+			? requestValue.method.trim()
+			: 'GET';
+	const packageId =
+		typeof record.packageId === 'string' && record.packageId.trim()
+			? record.packageId.trim()
+			: undefined;
+	const rawHeaders =
+		requestValue.headers != null &&
+		typeof requestValue.headers === 'object' &&
+		!Array.isArray(requestValue.headers)
+			? { ...requestValue.headers }
+			: {};
+	const outboundHeaders = {};
+	let contentType = null;
+	let secretResolution = null;
+	for (const [key, value] of Object.entries(rawHeaders)) {
+		if (typeof value !== 'string') continue;
+		const lower = key.toLowerCase();
+		if (lower === 'content-type') {
+			contentType = value;
+			continue;
+		}
+		if (lower === __kodySecretResolutionHeader) {
+			secretResolution = value;
+			continue;
+		}
+		outboundHeaders[key] = value;
+	}
+	const headers = {
+		'X-Kody-Gateway-Url': url,
+		'X-Kody-Gateway-Method': method,
+	};
+	if (packageId) headers['X-Kody-Gateway-Package-Id'] = packageId;
+	if (Object.keys(outboundHeaders).length > 0) {
+		headers['X-Kody-Gateway-Headers'] = JSON.stringify(outboundHeaders);
+	}
+	if (contentType) headers['Content-Type'] = contentType;
+	if (secretResolution) headers[__kodySecretResolutionHeader] = secretResolution;
+	const body = Object.hasOwn(requestValue, 'body') ? requestValue.body : null;
+	const init = {
+		method: 'POST',
+		headers,
+	};
+	const upper = method.toUpperCase();
+	if (body != null && upper !== 'GET' && upper !== 'HEAD') {
+		init.body = body;
+		init.duplex = 'half';
+	}
+	if (requestValue.signal != null) init.signal = requestValue.signal;
+	if (requestValue.redirect != null) init.redirect = requestValue.redirect;
+	const response = await __kodyBridge.gatewayFetch(init);
+	const cacheControl = response.headers.get('cache-control') ?? '';
+	const contentTypeHeader = response.headers.get('content-type') ?? '';
+	if (response.status === 413 && !contentTypeHeader.includes('application/json')) {
+		throw new Error(
+			'Request body exceeds the Worker upload limit of 104857600 bytes (100 MiB).',
+		);
+	}
+	if (cacheControl.includes('no-store') && contentTypeHeader.includes('application/json')) {
+		const text = await response.clone().text();
+		try {
+			const parsed = JSON.parse(text);
+			if (parsed != null && typeof parsed === 'object' && parsed.error != null) {
+				const err = parsed.error;
+				const message =
+					typeof err === 'string'
+						? err
+						: typeof err?.message === 'string'
+							? err.message
+							: 'gatewayFetchStream failed.';
+				throw new Error(message);
+			}
+		} catch (error) {
+			if (!(error instanceof SyntaxError)) throw error;
+		}
+	}
+	if (__kodyGatewayNullBodyStatuses.has(response.status)) {
+		return new Response(null, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers,
+		});
+	}
+	return response;
 }
 
 function __kodyNamespace(path) {
@@ -67,6 +182,13 @@ function __kodyNamespace(path) {
 				return undefined;
 			}
 			if (property === 'toString' || property === 'inspect') return () => label;
+			if (
+				path.length === 1 &&
+				path[0] === 'kody' &&
+				property === 'gatewayFetchStream'
+			) {
+				return gatewayFetchStream;
+			}
 			return __kodyNamespace([...path, property]);
 		},
 		apply(_target, _thisArg, args) {
@@ -74,6 +196,15 @@ function __kodyNamespace(path) {
 		},
 	});
 }
+`.trimStart();
+}
+export function createLocalRuntimeModuleSource() {
+    return `
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+${localGatewayFetchStreamRuntimeSource({
+        callUnavailableMessage: 'kody:runtime is only available while an execute --local run is in progress.',
+    })}
 
 export const kody = __kodyNamespace(['kody']);
 
@@ -303,15 +434,26 @@ export default {
 		}
 		__kodyClaimed = true;
 		const { params } = await request.json();
-		__kodyInstallLocalBridge(async (path, args) => {
-			const response = await env.KODY_BRIDGE.fetch('http://kody-bridge/call', {
-				method: 'POST',
-				headers: { 'content-type': 'application/json', [__kodyRunSecretHeader]: secret },
-				body: JSON.stringify({ path, args }),
-			});
-			const data = await response.json();
-			if (data.error) throw new Error(data.error);
-			return data.result;
+		__kodyInstallLocalBridge({
+			call: async (path, args) => {
+				const response = await env.KODY_BRIDGE.fetch('http://kody-bridge/call', {
+					method: 'POST',
+					headers: { 'content-type': 'application/json', [__kodyRunSecretHeader]: secret },
+					body: JSON.stringify({ path, args }),
+				});
+				const data = await response.json();
+				if (data.error) throw new Error(data.error);
+				return data.result;
+			},
+			gatewayFetch: async (init) => {
+				const headers = new Headers(init?.headers);
+				headers.set(__kodyRunSecretHeader, secret);
+				return await env.KODY_BRIDGE.fetch('http://kody-bridge/gateway-fetch', {
+					...init,
+					method: 'POST',
+					headers,
+				});
+			},
 		});
 		const logs = [];
 		const nativeConsole = globalThis.console;

package/dist/local-runtime-source.js.map

@@ -1 +1 @@
-{"version":3,"file":"local-runtime-source.js","sourceRoot":"","sources":["../src/local-runtime-source.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"local-runtime-source.js","sourceRoot":"","sources":["../src/local-runtime-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,6BAA6B,EAAE,MAAM,uCAAuC,CAAA;AAErF,MAAM,CAAC,MAAM,6BAA6B,GAAG,YAAY,CAAA;AACzD,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,eAAe,CAAU,CAAA;AAExE,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACrC,KAAK,EAAE,uBAAuB;IAC9B,IAAI,EAAE,SAAS;IACf,OAAO,EAAE,cAAc;IACvB;;;;;OAKG;IACH,gBAAgB,EAAE,sBAAsB;CAC/B,CAAA;AAEV,qFAAqF;AACrF,MAAM,CAAC,MAAM,eAAe,GAAG,mBAAmB,CAAA;AAClD,MAAM,CAAC,MAAM,eAAe,GAAG,iBAAiB,CAAA;AAEhD,+EAA+E;AAC/E,MAAM,CAAC,MAAM,mCAAmC,GAAG,qBAAqB,CAAA;AAExE;;;;;GAKG;AACH,MAAM,UAAU,4BAA4B;IAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAA;IAC9D,OAAO,iBAAiB,OAAO,8BAA8B,OAAO,KAAK,CAAA;AAC1E,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,oCAAoC,CAAC,OAGpD;IACA,OAAO;;;;;;;;;;;oBAWY,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6IjE,CAAC,SAAS,EAAE,CAAA;AACb,CAAC;AAED,MAAM,UAAU,8BAA8B;IAC7C,OAAO;;;EAGN,oCAAoC,CAAC;QACtC,sBAAsB,EACrB,6EAA6E;KAC9E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgKA,6BAA6B;;;;;;;gDAOiB,IAAI,CAAC,SAAS,CAAC,mCAAmC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BlG,CAAC,SAAS,EAAE,CAAA;AACb,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,QAEnC,EAAE;IACL,MAAM,iBAAiB,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC;SACnE,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;SACpE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC;SAChD,IAAI,CAAC,IAAI,CAAC,CAAA;IACZ,MAAM,eAAe,GAAG,iBAAiB,CAAC,CAAC,CAAC,GAAG,iBAAiB,IAAI,CAAC,CAAC,CAAC,EAAE,CAAA;IACzE,OAAO;EACN,eAAe;;;SAGR,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,OAAO,CAAC;;gCAEvB,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC;;;;;;;;;uBASxC,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAyCJ,IAAI,CAAC,SAAS,CAAC,KAAK,sBAAsB,CAAC,IAAI,EAAE,CAAC;;;;;;;;;;;;;;;;;CAiBnF,CAAC,SAAS,EAAE,CAAA;AACb,CAAC;AASD;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAKnC;IACA,MAAM,KAAK,GAAG,8BAA8B,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC3F,MAAM,YAAY,GAAG,KAAK,CAAC,mBAAmB;QAC7C,CAAC,CAAC,gCAAgC;QAClC,CAAC,CAAC,YAAY,CAAA;IACf,MAAM,cAAc,GAAG,CAAC,KAAK,CAAC,cAAc,IAAI,EAAE,CAAC;SACjD,GAAG,CACH,CAAC,MAAM,EAAE,EAAE,CACV,eAAe,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,sBAAsB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAChG;SACA,IAAI,CAAC,IAAI,CAAC,CAAA;IACZ,MAAM,YAAY,GAAG,cAAc,CAAC,CAAC,CAAC,KAAK,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IAChE,4EAA4E;IAC5E,kEAAkE;IAClE,MAAM,oBAAoB,GAAG,sBAAsB,CAAC,gBAAgB,CAAA;IACpE,MAAM,gBAAgB,GAAG,eAAe,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,gBAAgB,CAAC,sBAAsB,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,IAAI,CAAA;IAC7J,OAAO;;;;;8DAKsD,KAAK,CAAC,UAAU;6CACjC,YAAY;;;;;;;cAO3C,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,KAAK,CAAC,sBAAsB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC;cACnG,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,IAAI,CAAC,sBAAsB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC;cACjG,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,OAAO,CAAC,sBAAsB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC;EACnH,gBAAgB,GAAG,YAAY;;wBAET,IAAI,CAAC,SAAS,CAAC,6BAA6B,CAAC;0BAC3C,KAAK;;;;cAIjB,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,uBAAuB,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC;;;CAGlG,CAAA;AACD,CAAC"}

package/dist/mock/mock-supported.d.ts

@@ -15,4 +15,4 @@ export type MockCapabilityPath = (typeof mockCapabilityPaths)[number];
 export declare function isMockOpenApiOperation(id: string): id is MockOpenApiOperationId;
 export declare function isMockCapabilityPath(pathKey: string): pathKey is MockCapabilityPath;
 /** CapabilityProxy routes always present on every target. */
-export declare const mockCapabilityProxyRoutes: readonly ["GET /v1/capability-proxy/session", "POST /v1/capability-proxy/call", "POST /v1/local-execute/package-graph"];
+export declare const mockCapabilityProxyRoutes: readonly ["GET /v1/capability-proxy/session", "POST /v1/capability-proxy/call", "POST /v1/capability-proxy/gateway-fetch", "POST /v1/local-execute/package-graph"];

package/dist/mock/mock-supported.js

@@ -57,6 +57,7 @@ export function isMockCapabilityPath(pathKey) {
 export const mockCapabilityProxyRoutes = [
     'GET /v1/capability-proxy/session',
     'POST /v1/capability-proxy/call',
+    'POST /v1/capability-proxy/gateway-fetch',
     'POST /v1/local-execute/package-graph',
 ];
 //# sourceMappingURL=mock-supported.js.map

package/dist/mock/mock-supported.js.map

@@ -1 +1 @@
-{"version":3,"file":"mock-supported.js","sourceRoot":"","sources":["../../src/mock/mock-supported.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,8CAA8C;AAC9C,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACtC,QAAQ;IACR,oBAAoB;IACpB,UAAU;CACD,CAAA;AAEV,6EAA6E;AAC7E,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAClC,yBAAyB;IACzB,aAAa;IACb,cAAc;IACd,eAAe;IACf,6EAA6E;IAC7E,gEAAgE;IAChE,8BAA8B;IAC9B,8BAA8B;IAC9B,iCAAiC;IACjC,+BAA+B;IAC/B,8BAA8B;IAC9B,yEAAyE;IACzE,8DAA8D;IAC9D,wBAAwB;IACxB,wBAAwB;IACxB,2BAA2B;IAC3B,yBAAyB;IACzB,wBAAwB;IACxB,wEAAwE;IACxE,2BAA2B;IAC3B,8BAA8B;IAC9B,4BAA4B;IAC5B,8BAA8B;IAC9B,yEAAyE;IACzE,4EAA4E;IAC5E,wEAAwE;IACxE,0DAA0D;IAC1D,yBAAyB;IACzB,mBAAmB;IACnB,yBAAyB;IACzB,8EAA8E;IAC9E,oBAAoB;CACX,CAAA;AAKV,MAAM,UAAU,sBAAsB,CAAC,EAAU;IAChD,OAAQ,uBAAiD,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;AACvE,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,OAAe;IACnD,OAAQ,mBAA6C,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;AACxE,CAAC;AAED,6DAA6D;AAC7D,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACxC,kCAAkC;IAClC,gCAAgC;IAChC,sCAAsC;CAC7B,CAAA"}
+{"version":3,"file":"mock-supported.js","sourceRoot":"","sources":["../../src/mock/mock-supported.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,8CAA8C;AAC9C,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACtC,QAAQ;IACR,oBAAoB;IACpB,UAAU;CACD,CAAA;AAEV,6EAA6E;AAC7E,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAClC,yBAAyB;IACzB,aAAa;IACb,cAAc;IACd,eAAe;IACf,6EAA6E;IAC7E,gEAAgE;IAChE,8BAA8B;IAC9B,8BAA8B;IAC9B,iCAAiC;IACjC,+BAA+B;IAC/B,8BAA8B;IAC9B,yEAAyE;IACzE,8DAA8D;IAC9D,wBAAwB;IACxB,wBAAwB;IACxB,2BAA2B;IAC3B,yBAAyB;IACzB,wBAAwB;IACxB,wEAAwE;IACxE,2BAA2B;IAC3B,8BAA8B;IAC9B,4BAA4B;IAC5B,8BAA8B;IAC9B,yEAAyE;IACzE,4EAA4E;IAC5E,wEAAwE;IACxE,0DAA0D;IAC1D,yBAAyB;IACzB,mBAAmB;IACnB,yBAAyB;IACzB,8EAA8E;IAC9E,oBAAoB;CACX,CAAA;AAKV,MAAM,UAAU,sBAAsB,CAAC,EAAU;IAChD,OAAQ,uBAAiD,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;AACvE,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,OAAe;IACnD,OAAQ,mBAA6C,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;AACxE,CAAC;AAED,6DAA6D;AAC7D,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACxC,kCAAkC;IAClC,gCAAgC;IAChC,yCAAyC;IACzC,sCAAsC;CAC7B,CAAA"}

package/dist/package-app-dev.d.ts

@@ -19,7 +19,13 @@ export type PackageAppDevOptions = {
     apiUrl: string;
     target: KodyTarget;
     host?: string;
+    /** Listen on exactly this port (0 = any free port); EADDRINUSE is an error. */
     port?: number;
+    /**
+     * Used when `port` is unset: try this port, then the next free ones above
+     * it. Without either, any free port.
+     */
+    defaultPort?: number;
     /** Public mount path the Node proxy strips (default ''). */
     appBasePath?: string;
     /** User-owned token org selection (`?org=`), same as execute --local. */
@@ -58,6 +64,16 @@ export type PackageAppDevOptions = {
     onError?: (message: string) => void;
     /** Rebuilds, build/runtime errors, and app logs. */
     onEvent?: (event: DevEvent) => void;
+    /**
+     * Fired as soon as the HTTP port is bound (before the first build). Used
+     * to advertise the server in the attach registry so a second `kody dev`
+     * cannot start during the initial build window.
+     */
+    onListening?: (info: {
+        port: number;
+        hostedUrl: string;
+        appBasePath: string;
+    }) => void | Promise<void>;
 };
 export type PackageAppDevServer = {
     url: string;

package/dist/package-app-dev.js

@@ -13,17 +13,22 @@ import { rmSync } from 'node:fs';
 import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { createServer, request as httpRequest, } from 'node:http';
 import { tmpdir } from 'node:os';
-import { join, relative } from 'node:path';
+import { join, relative, resolve, sep } from 'node:path';
 import { assertTokenSafeApiUrl, callCapabilityProxy, } from './capability-proxy.js';
 import { apiTokenEnvVar } from './defaults.js';
+import { createDevClientBundler, parseDevAssetPath, serveDevAsset, } from './dev/dev-assets.js';
+import { forwardLocalGatewayFetchStream } from './local-gateway-fetch-forward.js';
+import { startLocalRuntimeBridge, } from './local-runtime-bridge.js';
 import { createDevBundler } from './dev/dev-bundler.js';
 import { parseWorkerdStdoutLine } from './dev/dev-events.js';
 import { devErrorHeader, devRequestIdHeader } from './dev/dev-protocol.js';
+import { listenDevServer } from './dev/dev-port.js';
 import { devStatusPath } from './dev/dev-registry.js';
 import { createDevWatcher } from './dev/dev-watcher.js';
 import { sendDevError } from './dev/error-page.js';
 import { createLiveReloadHub, injectLiveReloadScript, liveReloadClientPath, liveReloadClientSource, liveReloadEventsPath, liveReloadScriptTag, shouldInjectLiveReload, } from './dev/live-reload.js';
 import { devWorkDirPrefix, startProcessReaper, sweepStaleDevDirs, } from './dev/process-reaper.js';
+import { runPrebuild } from './dev/prebuild.js';
 import { createStackMapper } from './dev/stack-trace.js';
 import { cleanWorkerdStderrLine, startWorkerd, } from './dev/workerd-process.js';
 import { BundleError, formatBundleDiagnostic } from './local-bundle.js';
@@ -36,7 +41,9 @@ import { createPackageAppEntrySource, createPackageLocalRuntimeModuleSource, run
 import { resolvePackagePath } from './package-manifest.js';
 import { redact } from './redact.js';
 import { ensureWorkerdBinary } from './workerd-binary.js';
-const defaultDebounceMs = 120;
+const defaultDebounceMs = 30;
+/** Watcher events this soon after a prebuild finishes are its own writes, not edits. */
+const prebuildSettleMs = 150;
 /** Longest a request waits for an in-progress rebuild before the old build answers. */
 const rebuildGateMs = 10_000;
 /** Longest a retired generation may keep draining in-flight requests. */
@@ -113,18 +120,48 @@ export async function startPackageAppDev(options) {
     const proxy = createServer((req, res) => {
         void handleRequest(req, res);
     });
-    await new Promise((resolve, reject) => {
-        proxy.once('error', reject);
-        proxy.listen(options.port ?? 0, host, () => resolve());
-    });
+    try {
+        await listenDevServer(proxy, {
+            host,
+            port: options.port ?? options.defaultPort ?? 0,
+            explicit: options.port !== undefined,
+        });
+    }
+    catch (error) {
+        process.off('exit', killAllSync);
+        reaper.close();
+        await rm(workDir, { recursive: true, force: true });
+        throw error;
+    }
     const address = proxy.address();
     const hostedUrl = `http://${host}:${address.port}`;
-    const packageContext = buildLocalPackageContext({
+    try {
+        await options.onListening?.({
+            port: address.port,
+            hostedUrl,
+            appBasePath,
+        });
+    }
+    catch (error) {
+        // Port is bound but startPackageAppDev has not returned yet — close the
+        // listen handle now or the process stays alive after the throw.
+        process.off('exit', killAllSync);
+        reaper.close();
+        proxy.closeAllConnections();
+        await new Promise((resolve) => {
+            proxy.close(() => resolve());
+        });
+        await rm(workDir, { recursive: true, force: true });
+        throw error;
+    }
+    const contextFor = (client) => buildLocalPackageContext({
         kodyId: options.manifest.kodyId,
         packageId: `local:${options.manifest.kodyId}`,
         hostedUrl,
         appBasePath,
+        clientModuleUrl: client ? clientModuleUrlFor(client) : null,
     });
+    const clientModuleUrlFor = (client) => `${hostedUrl}${appBasePath}/_assets/${client.name}`;
     const mockFetchGateway = await resolveMockFetchGateway({
         target: options.target,
         packageRoot: root,
@@ -132,9 +169,9 @@ export async function startPackageAppDev(options) {
         allowPrivateNetwork: options.allowPrivateNetwork,
         onStatus: options.onStatus,
     });
-    const bridge = await startBridge({
+    const bridge = await startLocalRuntimeBridge({
         runSecret,
-        forward: async (call, signal) => {
+        forwardCall: async (call, signal) => {
             const mocked = tryHandleMockGatewayFetchCall({
                 gateway: mockFetchGateway,
                 path: call.path,
@@ -149,12 +186,36 @@ export async function startPackageAppDev(options) {
                 signal,
             });
         },
+        forwardGatewayFetchStream: async ({ request, response, signal }) => {
+            await forwardLocalGatewayFetchStream({
+                request,
+                response,
+                signal,
+                client,
+                ...(mockFetchGateway ? { mockFetchGateway } : {}),
+            });
+        },
     });
-    const entryPath = resolvePackagePath(options.manifest, options.manifest.app.entry);
+    const app = options.manifest.app;
+    const entryPath = resolvePackagePath(options.manifest, app.entry);
     const bundler = createDevBundler({ entryPath, root });
+    const clientBundler = app.client
+        ? createDevClientBundler({
+            entryPath: resolvePackagePath(options.manifest, app.client),
+            root,
+            externals: app.clientExternals,
+        })
+        : null;
+    const assetsDir = app.assets ? resolve(root, app.assets) : null;
+    const prebuild = options.manifest.dev?.prebuild;
+    let prebuildRunning = false;
+    let prebuildSettledAt = 0;
+    let prebuildAbort;
     const workerdEnv = { ...process.env, [runSecretEnvVar]: runSecret };
     delete workerdEnv[apiTokenEnvVar];
     function requestBuild(paths) {
+        if (closed)
+            return Promise.resolve();
         for (const path of paths)
             changedFiles.add(path);
         if (buildLoop) {
@@ -176,12 +237,17 @@ export async function startPackageAppDev(options) {
     async function buildOnce(files) {
         const started = performance.now();
         emit({ type: 'rebuild_start', files: files.map((file) => relative(root, file) || file) });
-        let bundle;
+        const assetsChanged = assetsDir !== null &&
+            files.some((file) => file === assetsDir || file.startsWith(`${assetsDir}${sep}`));
         try {
-            bundle = await bundler.build();
-            const midBuildEdits = (await watcher?.track([...bundle.inputs, options.manifest.packageJsonPath], {
-                ignoreChanges: files,
-            })) ?? [];
+            if (prebuild) {
+                await runPrebuildStep(prebuild);
+            }
+            const [bundle, client] = await Promise.all([
+                bundler.build(),
+                clientBundler ? clientBundler.build() : Promise.resolve(null),
+            ]);
+            const midBuildEdits = (await watcher?.track([...bundle.inputs, ...(client?.inputs ?? []), options.manifest.packageJsonPath], { ignoreChanges: files })) ?? [];
             // Queue mid-build edits for the next loop iteration directly — do not
             // call onChange (debounced); chokidar may already have the same paths
             // pending and would double-schedule a rebuild after debounce.
@@ -190,7 +256,10 @@ export async function startPackageAppDev(options) {
                     changedFiles.add(path);
                 rebuildAgain = true;
             }
-            if (active && !buildFailure && bundle.code === active.code) {
+            if (active &&
+                !buildFailure &&
+                bundle.code === active.code &&
+                client?.name === active.client?.name) {
                 // Still stamp lastRebuild so agents polling lastRebuild.at see
                 // the no-op rebuild finish (status already flipped building→ready).
                 lastRebuild = { ms: elapsed(started), at: new Date().toISOString() };
@@ -200,9 +269,12 @@ export async function startPackageAppDev(options) {
                     buildId: active.id,
                     restarted: false,
                 });
+                if (assetsChanged || prebuild) {
+                    liveReloadHub.broadcast({ event: 'reload', data: { buildId: active.id } });
+                }
                 return;
             }
-            const generation = await startGeneration(bundle);
+            const generation = await startGeneration(bundle, client);
             if (closed) {
                 await stopGeneration(generation);
                 return;
@@ -233,13 +305,54 @@ export async function startPackageAppDev(options) {
             liveReloadHub.broadcast({ event: 'build_error', data: buildErrorView(buildFailure) });
         }
     }
-    async function startGeneration(bundle) {
+    let clearWatcherPending = null;
+    async function runPrebuildStep(command) {
+        prebuildRunning = true;
+        prebuildAbort = new AbortController();
+        let failed = false;
+        try {
+            await runPrebuild({
+                command,
+                cwd: root,
+                signal: prebuildAbort.signal,
+                onSpawn: (pid) => reaper.trackGroup(pid),
+                onExit: (pid) => reaper.untrackGroup(pid),
+                onLine: (line, stream) => emit({
+                    type: 'log',
+                    source: 'prebuild',
+                    level: stream === 'stderr' ? 'warn' : 'log',
+                    message: redact(line),
+                    request: null,
+                }),
+            });
+        }
+        catch (error) {
+            failed = true;
+            throw error;
+        }
+        finally {
+            prebuildAbort = undefined;
+            prebuildRunning = false;
+            prebuildSettledAt = performance.now();
+            // Absorb writes even when prebuild fails — otherwise the 1s poll
+            // treats partial/failed output as new edits and loops rebuilds.
+            await watcher?.rebaseline();
+            if (failed) {
+                // Drop chokidar echoes of the failed prebuild / trigger burst so
+                // they cannot restart the loop after buildLoop clears.
+                changedFiles.clear();
+                rebuildAgain = false;
+                clearWatcherPending?.();
+            }
+        }
+    }
+    async function startGeneration(bundle, client) {
         const id = ++generationCounter;
         const dir = join(workDir, `g${id}`);
         await writeWorkerFiles({
             workDir: dir,
             code: bundle.code,
-            packageContext,
+            packageContext: contextFor(client),
             packageRoot: root,
             mockStorage: options.target === 'mock',
             bridgePort: bridge.port,
@@ -292,6 +405,7 @@ export async function startPackageAppDev(options) {
             dir,
             workerd,
             code: bundle.code,
+            client,
             mapStack: createStackMapper({
                 sourceMap: bundle.sourceMap,
                 userModule: localWorkerModuleNames.user,
@@ -413,6 +527,20 @@ export async function startPackageAppDev(options) {
             if (handleDevRoute(req, res))
                 return;
             await waitForBuild();
+            const assetPath = parseDevAssetPath(stripMount(new URL(req.url ?? '/', hostedUrl).pathname, appBasePath));
+            if (assetPath !== null) {
+                const client = active?.client ?? null;
+                await serveDevAsset({
+                    req,
+                    res,
+                    relativePath: assetPath,
+                    assetsDir,
+                    client,
+                    clientModuleUrl: client ? clientModuleUrlFor(client) : null,
+                    appBasePath,
+                });
+                return;
+            }
             if (buildFailure) {
                 sendDevError(req, res, 500, buildErrorView(buildFailure), {
                     htmlTail: errorPageTail,
@@ -551,11 +679,25 @@ export async function startPackageAppDev(options) {
         ? null
         : (() => {
             const pending = new Set();
+            clearWatcherPending = () => {
+                pending.clear();
+                clearTimeout(debounceTimer);
+                debouncePending = false;
+                const resolve = resolveDebounceFlush;
+                resolveDebounceFlush = null;
+                debounceFlush = null;
+                resolve?.();
+            };
             return createDevWatcher({
                 root,
+                ignore: options.manifest.dev?.ignore,
                 onChange: (path) => {
                     if (closed)
                         return;
+                    if (prebuildRunning ||
+                        performance.now() - prebuildSettledAt < prebuildSettleMs) {
+                        return;
+                    }
                     // Fold mid-build watcher events into the active loop
                     // (including another save of a file already building).
                     // Debouncing them instead schedules a second rebuild
@@ -600,9 +742,11 @@ export async function startPackageAppDev(options) {
         resolveDebounceFlush = null;
         debounceFlush = null;
         resolve?.();
+        prebuildAbort?.abort();
         await watcher?.close();
         await buildLoop?.catch(() => { });
         await bundler.dispose();
+        await clientBundler?.dispose();
         await Promise.all([...generations].map((generation) => stopGeneration(generation)));
         reaper.close();
         await bridge.close();
@@ -649,7 +793,9 @@ export async function startPackageAppDev(options) {
         port: address.port,
         hostedUrl,
         appBasePath,
-        packageContext,
+        get packageContext() {
+            return contextFor(active?.client ?? null);
+        },
         fetchPath,
         status,
         close,
@@ -748,54 +894,4 @@ function joinUrlPath(base, path) {
         return rest;
     return `${base}${rest === '/' ? '' : rest}` || base;
 }
-async function startBridge(input) {
-    const inFlight = new AbortController();
-    const server = createServer(async (request, response) => {
-        const reply = (status, body) => {
-            response.writeHead(status, { 'content-type': 'application/json' });
-            response.end(JSON.stringify(body));
-        };
-        if (request.method !== 'POST' ||
-            request.url !== '/call' ||
-            request.headers[runSecretHeader] !== input.runSecret) {
-            reply(403, { error: 'Forbidden' });
-            return;
-        }
-        try {
-            const parsed = JSON.parse(await readBody(request));
-            if (!Array.isArray(parsed.path) ||
-                parsed.path.length === 0 ||
-                !parsed.path.every((segment) => typeof segment === 'string')) {
-                throw new Error('Invalid kody:runtime call path.');
-            }
-            const result = await input.forward({
-                path: parsed.path,
-                args: Array.isArray(parsed.args) ? parsed.args : [],
-            }, inFlight.signal);
-            reply(200, { result });
-        }
-        catch (error) {
-            reply(200, { error: redact(error instanceof Error ? error.message : String(error)) });
-        }
-    });
-    await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(0, '127.0.0.1', () => resolve());
-    });
-    return {
-        port: server.address().port,
-        close: () => new Promise((resolve) => {
-            inFlight.abort();
-            server.closeAllConnections();
-            server.close(() => resolve());
-        }),
-    };
-}
-async function readBody(stream) {
-    const chunks = [];
-    for await (const chunk of stream) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    return Buffer.concat(chunks).toString('utf8');
-}
 //# sourceMappingURL=package-app-dev.js.map