devflare 1.0.0-next.7 → 1.0.0-next.70

package/dist/sveltekit/index.js

@@ -1,184 +1,392 @@
-import"../index-n3np2d6t.js";
-import"../index-p7g30wd2.js";
-import"../index-k7r18na8.js";
-import {
-  createEnvProxy,
-  getClient
-} from "../index-ccrh4w3t.js";
-import"../index-v8vvsn9x.js";
-import"../index-67qcae0f.js";
-import {
-  loadConfig
-} from "../index-hcex3rgh.js";
-import"../index-37x76zdn.js";
-
-// src/sveltekit/platform.ts
-var platformCache = null;
-function getPlatformCacheKey(bridgeUrl) {
-  return bridgeUrl;
+import { r as loadConfig } from "../_chunks/loader-BC0skbnH.js";
+import { l as normalizeHyperdriveBinding } from "../_chunks/schema-normalization-CTdiY17P.js";
+import { D as createFetchEvent, I as getClient, M as createEnvProxy, P as setBindingHints, v as runWithEventContext } from "../_chunks/context-DGMev2AF.js";
+import { createLocalSendEmailBinding } from "../utils/send-email.js";
+import { i as extractBindingHints, n as createLocalWorkerLoaderBinding, t as createLocalHyperdrive } from "../_chunks/local-hyperdrive-CcORzo76.js";
+import { t as buildLocalSecretNodeBindings } from "../_chunks/local-secrets-C0n5oRgI.js";
+import { n as createLocalImagesBinding, r as createLocalMediaBinding } from "../_chunks/local-media-bindings-ZQe-epuw.js";
+//#region src/sveltekit/local-bindings.ts
+function buildLocalHyperdriveBindings(config) {
+	const bindings = {};
+	for (const [name, binding] of Object.entries(config.bindings?.hyperdrive ?? {})) {
+		const normalized = normalizeHyperdriveBinding(binding);
+		if (normalized.localConnectionString) bindings[name] = createLocalHyperdrive(normalized.localConnectionString);
+	}
+	return bindings;
 }
+function buildSvelteKitLocalBindings(config, cwd) {
+	const bindings = {
+		...config.vars ?? {},
+		...buildLocalHyperdriveBindings(config),
+		...buildLocalSecretNodeBindings(config, cwd)
+	};
+	for (const [name, binding] of Object.entries(config.bindings?.sendEmail ?? {})) bindings[name] = createLocalSendEmailBinding(binding);
+	for (const name of Object.keys(config.bindings?.workerLoaders ?? {})) bindings[name] = createLocalWorkerLoaderBinding();
+	for (const name of Object.keys(config.bindings?.images ?? {})) bindings[name] = createLocalImagesBinding();
+	for (const name of Object.keys(config.bindings?.media ?? {})) bindings[name] = createLocalMediaBinding();
+	return bindings;
+}
+function overlayLocalBindings(baseEnv, localBindings) {
+	if (Object.keys(localBindings).length === 0) return baseEnv;
+	return new Proxy(baseEnv, {
+		get(target, prop, receiver) {
+			if (typeof prop === "string" && prop in localBindings) return localBindings[prop];
+			return Reflect.get(target, prop, receiver);
+		},
+		has(target, prop) {
+			return typeof prop === "string" && prop in localBindings || Reflect.has(target, prop);
+		},
+		ownKeys(target) {
+			return Array.from(new Set([...Reflect.ownKeys(target), ...Reflect.ownKeys(localBindings)]));
+		},
+		getOwnPropertyDescriptor(target, prop) {
+			if (typeof prop === "string" && prop in localBindings) return {
+				configurable: true,
+				enumerable: true,
+				writable: false,
+				value: localBindings[prop]
+			};
+			return Reflect.getOwnPropertyDescriptor(target, prop);
+		}
+	});
+}
+//#endregion
+//#region src/sveltekit/platform.ts
+/** Cached platform keyed by bridgeUrl + binding hint fingerprint */
+let platformCache = null;
+/**
+* Generate a stable fingerprint for binding hints so cached platforms are not
+* shared across configs with differing hint sets.
+*/
+function fingerprintHints(hints) {
+	const entries = Object.keys(hints).sort().map((name) => [name, hints[name]]);
+	return JSON.stringify(entries);
+}
+/**
+* Generate cache key from options
+*/
+function getPlatformCacheKey(bridgeUrl, hints) {
+	return `${bridgeUrl}\u0000${fingerprintHints(hints)}`;
+}
+function shouldUseCachedPlatform(localBindings) {
+	return Object.keys(localBindings).length === 0;
+}
+/**
+* Build a dev-mode ExecutionContext that records `waitUntil()` rejections on
+* the provided `pendingErrors` array. The original console.error log is kept
+* for parity with existing behavior.
+*/
+function createDevExecutionContext(pendingErrors) {
+	return {
+		waitUntil: (promise) => {
+			promise.catch((err) => {
+				console.error("[devflare] waitUntil error:", err);
+				pendingErrors.push(err);
+			});
+		},
+		passThroughOnException: () => {}
+	};
+}
+/**
+* Total budget for riding out a transient bridge outage while (re)connecting for a request. An HMR worker
+* reload or a brief coordinator restart drops the bridge socket for well under a second; retrying within this
+* window keeps the request's bindings available instead of failing it. Kept modest so a bridge that is
+* genuinely down (devflare not running) still surfaces the error promptly rather than hanging every request.
+*/
+const BRIDGE_CONNECT_MAX_WAIT_MS = 3e3;
+/** Delay between bridge (re)connect attempts within {@link BRIDGE_CONNECT_MAX_WAIT_MS}. */
+const BRIDGE_CONNECT_RETRY_DELAY_MS = 150;
+/**
+* Connect to the bridge, riding out a TRANSIENT outage with a bounded retry.
+*
+* The bridge socket drops for a fraction of a second whenever the dev runtime reloads a worker (HMR /
+* config change) or the coordinator briefly restarts (e.g. after a worker threw). A single per-request
+* `connect()` attempt rejects the instant the socket is refused, which the SvelteKit handle turns into
+* "dropped every binding for this request" — so an unrelated route 500s with a missing D1/KV/R2 binding
+* mid-reload. Retrying for a short window instead lets the reconnect land and the request proceed. The LAST
+* error is rethrown only once the budget is spent (the bridge really is down), so a genuine
+* misconfiguration still fails fast rather than hanging.
+*
+* Exported for unit testing; `sleep`/`now` are injectable so the retry schedule is asserted without real time.
+*
+* @param connect - the bridge client's `connect()`; a fresh attempt each call (the client dedups in-flight ones).
+* @param options - `maxWaitMs` total budget, `retryDelayMs` between attempts, and injectable `sleep`/`now` for tests.
+*/
+async function connectBridgeWithRetry(connect, options = {}) {
+	const maxWaitMs = options.maxWaitMs ?? BRIDGE_CONNECT_MAX_WAIT_MS;
+	const retryDelayMs = options.retryDelayMs ?? BRIDGE_CONNECT_RETRY_DELAY_MS;
+	const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const now = options.now ?? Date.now;
+	const deadline = now() + maxWaitMs;
+	for (;;) try {
+		await connect();
+		return;
+	} catch (error) {
+		if (now() + retryDelayMs >= deadline) throw error;
+		await sleep(retryDelayMs);
+	}
+}
+/**
+* Create a platform object that routes bindings through the bridge
+*
+* Use this in dev mode to get access to Miniflare bindings via WebSocket RPC.
+*
+* @example
+* ```ts
+* // src/hooks.server.ts
+* import { dev } from '$app/environment'
+* import { createDevflarePlatform } from 'devflare/sveltekit'
+*
+* export async function handle({ event, resolve }) {
+*   if (dev && process.env.DEVFLARE_DEV) {
+*     // Override platform with bridge-connected proxy
+*     event.platform = await createDevflarePlatform({
+*       hints: {
+*         MY_KV: 'kv',
+*         MY_DO: 'do',
+*         MY_D1: 'd1',
+*         MY_R2: 'r2'
+*       }
+*     })
+*   }
+*   return resolve(event)
+* }
+* ```
+*/
 async function createDevflarePlatform(options = {}) {
-  const {
-    bridgeUrl = `ws://localhost:${process.env.DEVFLARE_BRIDGE_PORT ?? 8787}`,
-    hints = {}
-  } = options;
-  const cacheKey = getPlatformCacheKey(bridgeUrl);
-  if (platformCache?.key === cacheKey) {
-    return platformCache.platform;
-  }
-  const client = getClient({ url: bridgeUrl });
-  await client.connect();
-  const env = createEnvProxy({ client, hints });
-  const context = {
-    waitUntil: (promise) => {
-      promise.catch((err) => {
-        console.error("[devflare] waitUntil error:", err);
-      });
-    },
-    passThroughOnException: () => {}
-  };
-  const caches = {
-    default: createMockCache(),
-    open: async (cacheName) => createMockCache()
-  };
-  const cf = {
-    colo: "DEV",
-    country: "XX",
-    city: "Development",
-    continent: "XX",
-    latitude: "0",
-    longitude: "0",
-    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    region: "Development",
-    regionCode: "DEV",
-    asn: 0,
-    asOrganization: "Devflare Dev"
-  };
-  const platform = { env, context, caches, cf };
-  platformCache = { key: cacheKey, platform };
-  return platform;
+	const { bridgeUrl = `ws://localhost:${process.env.DEVFLARE_BRIDGE_PORT ?? 8787}`, hints = {}, localBindings = {} } = options;
+	const cacheKey = getPlatformCacheKey(bridgeUrl, hints);
+	if (shouldUseCachedPlatform(localBindings) && platformCache?.key === cacheKey) return platformCache.platform;
+	const client = getClient({ url: bridgeUrl });
+	await connectBridgeWithRetry(() => client.connect());
+	const env = overlayLocalBindings(createEnvProxy({
+		client,
+		hints,
+		strict: true
+	}), localBindings);
+	const pendingErrors = [];
+	const platform = {
+		env,
+		context: createDevExecutionContext(pendingErrors),
+		caches: {
+			default: createMockCache(),
+			open: async (cacheName) => createMockCache()
+		},
+		cf: {
+			colo: "DEV",
+			country: "XX",
+			city: "Development",
+			continent: "XX",
+			latitude: "0",
+			longitude: "0",
+			timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+			region: "Development",
+			regionCode: "DEV",
+			asn: 0,
+			asOrganization: "Devflare Dev"
+		},
+		pendingErrors
+	};
+	if (shouldUseCachedPlatform(localBindings)) platformCache = {
+		key: cacheKey,
+		platform
+	};
+	return platform;
 }
+/**
+* Create a simple mock cache for dev mode
+* Note: Cloudflare's Cache interface differs from browser Cache API
+*/
 function createMockCache() {
-  const store = new Map;
-  return {
-    async match(request) {
-      const key = typeof request === "string" ? request : request instanceof URL ? request.href : request.url;
-      return store.get(key)?.clone();
-    },
-    async put(request, response) {
-      const key = typeof request === "string" ? request : request instanceof URL ? request.href : request.url;
-      store.set(key, response.clone());
-    },
-    async delete(request) {
-      const key = typeof request === "string" ? request : request instanceof URL ? request.href : request.url;
-      return store.delete(key);
-    }
-  };
+	const store = /* @__PURE__ */ new Map();
+	return {
+		async match(request) {
+			const key = typeof request === "string" ? request : request instanceof URL ? request.href : request.url;
+			return store.get(key)?.clone();
+		},
+		async put(request, response) {
+			const key = typeof request === "string" ? request : request instanceof URL ? request.href : request.url;
+			store.set(key, response.clone());
+		},
+		async delete(request) {
+			const key = typeof request === "string" ? request : request instanceof URL ? request.href : request.url;
+			return store.delete(key);
+		}
+	};
 }
+/**
+* Reset the cached platform (for testing)
+*/
 function resetPlatform() {
-  platformCache = null;
+	platformCache = null;
 }
+/**
+* Reset the cached config (for testing)
+*/
 function resetConfigCache() {
-  configCache = null;
+	configCache = null;
 }
+/**
+* Check if running in devflare dev mode
+*/
 function isDevflareDev() {
-  return process.env.DEVFLARE_DEV === "true";
+	return process.env.DEVFLARE_DEV === "true";
 }
+/**
+* Get the bridge port from environment
+*/
 function getBridgePort() {
-  return parseInt(process.env.DEVFLARE_BRIDGE_PORT ?? "8787", 10);
-}
-var configCache = null;
-function extractHintsFromConfig(config) {
-  const hints = {};
-  const bindings = config.bindings;
-  if (!bindings)
-    return hints;
-  if (bindings.kv) {
-    for (const name of Object.keys(bindings.kv)) {
-      hints[name] = "kv";
-    }
-  }
-  if (bindings.d1) {
-    for (const name of Object.keys(bindings.d1)) {
-      hints[name] = "d1";
-    }
-  }
-  if (bindings.r2) {
-    for (const name of Object.keys(bindings.r2)) {
-      hints[name] = "r2";
-    }
-  }
-  if (bindings.durableObjects) {
-    for (const name of Object.keys(bindings.durableObjects)) {
-      hints[name] = "do";
-    }
-  }
-  if (bindings.queues?.producers) {
-    for (const name of Object.keys(bindings.queues.producers)) {
-      hints[name] = "queue";
-    }
-  }
-  if (bindings.services) {
-    for (const name of Object.keys(bindings.services)) {
-      hints[name] = "service";
-    }
-  }
-  if (bindings.ai?.binding) {
-    hints[bindings.ai.binding] = "ai";
-  }
-  return hints;
-}
-async function loadHintsFromConfig() {
-  const cwd = process.cwd();
-  if (configCache?.cwd === cwd) {
-    const config2 = await configCache.promise;
-    return config2 ? extractHintsFromConfig(config2) : {};
-  }
-  const promise = loadConfig({ cwd }).catch((err) => {
-    if (process.env.DEVFLARE_DEBUG) {
-      console.warn("[devflare] Failed to load config for hints:", err.message);
-    }
-    return null;
-  });
-  configCache = { cwd, promise };
-  const config = await promise;
-  return config ? extractHintsFromConfig(config) : {};
+	return Number.parseInt(process.env.DEVFLARE_BRIDGE_PORT ?? "8787", 10);
+}
+/** Cached config promise keyed by cwd + explicit config path */
+let configCache = null;
+function getConfigFileFromEnv() {
+	return process.env.DEVFLARE_CONFIG_PATH;
+}
+async function loadConfigFromCurrentCwd() {
+	const cwd = process.cwd();
+	const configFile = getConfigFileFromEnv();
+	if (configCache?.cwd === cwd && configCache.configFile === configFile) return configCache.promise;
+	const promise = loadConfig({
+		cwd,
+		configFile
+	}).catch((err) => {
+		if (process.env.DEVFLARE_DEBUG) console.warn("[devflare] Failed to load config for hints:", err.message);
+		return null;
+	});
+	configCache = {
+		cwd,
+		configFile,
+		promise
+	};
+	return promise;
 }
+async function loadPlatformOptionsFromConfig() {
+	const cwd = process.cwd();
+	const config = await loadConfigFromCurrentCwd();
+	if (!config) return {
+		hints: {},
+		localBindings: {}
+	};
+	return {
+		hints: extractBindingHints(config),
+		localBindings: buildSvelteKitLocalBindings(config, cwd)
+	};
+}
+function resolveWithPlatformContext(event, resolve, platform) {
+	if (!(event.request instanceof Request)) return resolve(event);
+	return runWithEventContext(createFetchEvent(event.request, platform.env, platform.context), () => resolve(event));
+}
+/**
+* Build this request's dev platform, reporting a failure instead of throwing.
+*
+* A dev request should still be served when the bridge is unreachable — just without bindings — so the
+* failure is deliberately swallowed here. Equally deliberately, this covers ONLY the setup: resolving
+* options and connecting. An error raised by the request itself belongs to the request. Catching that
+* here (as one try around setup AND `resolve()` used to) blamed it on the platform, hid the real cause,
+* and re-ran the whole request — repeating every side effect and running the second pass outside the
+* context {@link resolveWithPlatformContext} established for the first.
+*
+* @param resolveOptions - produces the platform options; may itself fail (config load, hint extraction).
+* @returns the platform, or null when it could not be built.
+*/
+async function createPlatformOrReport(resolveOptions) {
+	try {
+		return await createDevflarePlatform(await resolveOptions());
+	} catch (error) {
+		console.error("[devflare] Failed to create platform:", error);
+		return null;
+	}
+}
+/**
+* Attach a built platform to the event and resolve the request under its context.
+*
+* @param event - the SvelteKit request event.
+* @param resolve - SvelteKit's resolve for this handle.
+* @param platform - the platform from {@link createPlatformOrReport}.
+*/
+function serveWithPlatform(event, resolve, platform) {
+	event.platform = platform;
+	return resolveWithPlatformContext(event, resolve, platform);
+}
+async function getAutoPlatformOptions() {
+	const options = await loadPlatformOptionsFromConfig();
+	setBindingHints(options.hints ?? {});
+	return options;
+}
+async function getCustomPlatformOptions(options) {
+	if (options.hints) setBindingHints(options.hints);
+	return options;
+}
+/**
+* Create a SvelteKit handle that automatically injects the devflare platform
+* in development mode. This eliminates the need for boilerplate in hooks.server.ts.
+*
+* @example
+* ```ts
+* // src/hooks.server.ts
+* import { createHandle } from 'devflare/sveltekit'
+*
+* export const handle = createHandle({
+*   hints: {
+*     MY_KV: 'kv',
+*     MY_DO: 'do',
+*     MY_D1: 'd1',
+*     MY_R2: 'r2'
+*   }
+* })
+* ```
+*
+* @example Composing with other handles using SvelteKit's sequence
+* ```ts
+* import { sequence } from '@sveltejs/kit/hooks'
+* import { createHandle } from 'devflare/sveltekit'
+*
+* const devflareHandle = createHandle({ hints: { ... } })
+* const authHandle: Handle = async ({ event, resolve }) => { ... }
+*
+* export const handle = sequence(devflareHandle, authHandle)
+* ```
+*/
 function createHandle(options = {}) {
-  const { shouldEnable, ...platformOptions } = options;
-  return async ({ event, resolve }) => {
-    const enabled = shouldEnable ? shouldEnable() : process.env.DEVFLARE_DEV === "true";
-    if (enabled) {
-      try {
-        const platform = await createDevflarePlatform(platformOptions);
-        event.platform = platform;
-      } catch (error) {
-        console.error("[devflare] Failed to create platform:", error);
-      }
-    }
-    return resolve(event);
-  };
-}
-var handle = async (input) => {
-  const { event, resolve } = input;
-  const enabled = process.env.DEVFLARE_DEV === "true";
-  if (enabled) {
-    try {
-      const hints = await loadHintsFromConfig();
-      const platform = await createDevflarePlatform({ hints });
-      event.platform = platform;
-    } catch (error) {
-      console.error("[devflare] Failed to create platform:", error);
-    }
-  }
-  return resolve(event);
-};
-export {
-  resetPlatform,
-  resetConfigCache,
-  isDevflareDev,
-  handle,
-  getBridgePort,
-  createHandle,
-  createDevflarePlatform
+	const { shouldEnable, ...platformOptions } = options;
+	return async ({ event, resolve }) => {
+		if (shouldEnable ? shouldEnable() : process.env.NODE_ENV !== "production" && process.env.DEVFLARE_DEV === "true") {
+			const platform = await createPlatformOrReport(() => getCustomPlatformOptions(platformOptions));
+			if (platform) return serveWithPlatform(event, resolve, platform);
+		}
+		return resolve(event);
+	};
+}
+/**
+* Pre-configured SvelteKit handle that auto-loads binding hints from devflare.config.ts.
+*
+* This is the simplest way to integrate devflare with SvelteKit:
+*
+* @example Simplest usage — just re-export
+* ```ts
+* // src/hooks.server.ts
+* export { handle } from 'devflare/sveltekit'
+* ```
+*
+* @example With other handles
+* ```ts
+* // src/hooks.server.ts
+* import { sequence } from '@sveltejs/kit/hooks'
+* import { handle as devflareHandle } from 'devflare/sveltekit'
+*
+* const authHandle: Handle = async ({ event, resolve }) => { ... }
+*
+* export const handle = sequence(devflareHandle, authHandle)
+* ```
+*/
+const handle = async (input) => {
+	const { event, resolve } = input;
+	if (process.env.NODE_ENV !== "production" && process.env.DEVFLARE_DEV === "true") {
+		const platform = await createPlatformOrReport(getAutoPlatformOptions);
+		if (platform) return serveWithPlatform(event, resolve, platform);
+	}
+	return resolve(event);
 };
+//#endregion
+export { createDevflarePlatform, createHandle, getBridgePort, handle, isDevflareDev, resetConfigCache, resetPlatform };

package/dist/sveltekit/local-bindings.d.ts

@@ -0,0 +1,4 @@
+import { type DevflareConfig } from '../config/index.js';
+export declare function buildSvelteKitLocalBindings(config: DevflareConfig, cwd: string): Record<string, unknown>;
+export declare function overlayLocalBindings(baseEnv: Record<string, unknown>, localBindings: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=local-bindings.d.ts.map

package/dist/sveltekit/local-bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-bindings.d.ts","sourceRoot":"","sources":["../../src/sveltekit/local-bindings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA8B,MAAM,WAAW,CAAA;AAoB3E,wBAAgB,2BAA2B,CAC1C,MAAM,EAAE,cAAc,EACtB,GAAG,EAAE,MAAM,GACT,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwBzB;AAED,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACpC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgCzB"}

package/dist/sveltekit/platform.d.ts

@@ -1,4 +1,4 @@
-import { type BindingHints } from '../bridge';
+import { type BindingHints } from '../bridge/index.js';
 /**
  * SvelteKit platform object shape
  */
@@ -7,6 +7,11 @@ export interface Platform {
     context: ExecutionContext;
     caches: CacheStorage;
     cf: Record<string, unknown>;
+    /**
+     * Errors captured from `ctx.waitUntil()` rejections in dev mode.
+     * Drain via `drainWaitUntilErrors(platform)`.
+     */
+    pendingErrors?: unknown[];
 }
 export interface DevflarePlatformOptions {
     /**
@@ -19,7 +24,40 @@ export interface DevflarePlatformOptions {
      * Keys are binding names, values are binding types
      */
     hints?: BindingHints;
+    /**
+     * Local Node-side binding shims to prefer over the bridge-backed env.
+     * Used by the SvelteKit handle for bindings whose local API exposes
+     * synchronous properties or rich transformation objects.
+     */
+    localBindings?: Record<string, unknown>;
 }
+/**
+ * Drain errors captured from `ctx.waitUntil()` calls on a dev platform.
+ * Returns a snapshot of the pending errors and clears the buffer.
+ */
+export declare function drainWaitUntilErrors(platform: Platform): unknown[];
+/**
+ * Connect to the bridge, riding out a TRANSIENT outage with a bounded retry.
+ *
+ * The bridge socket drops for a fraction of a second whenever the dev runtime reloads a worker (HMR /
+ * config change) or the coordinator briefly restarts (e.g. after a worker threw). A single per-request
+ * `connect()` attempt rejects the instant the socket is refused, which the SvelteKit handle turns into
+ * "dropped every binding for this request" — so an unrelated route 500s with a missing D1/KV/R2 binding
+ * mid-reload. Retrying for a short window instead lets the reconnect land and the request proceed. The LAST
+ * error is rethrown only once the budget is spent (the bridge really is down), so a genuine
+ * misconfiguration still fails fast rather than hanging.
+ *
+ * Exported for unit testing; `sleep`/`now` are injectable so the retry schedule is asserted without real time.
+ *
+ * @param connect - the bridge client's `connect()`; a fresh attempt each call (the client dedups in-flight ones).
+ * @param options - `maxWaitMs` total budget, `retryDelayMs` between attempts, and injectable `sleep`/`now` for tests.
+ */
+export declare function connectBridgeWithRetry(connect: () => Promise<void>, options?: {
+    maxWaitMs?: number;
+    retryDelayMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}): Promise<void>;
 /**
  * Create a platform object that routes bindings through the bridge
  *
@@ -107,6 +145,7 @@ export interface CreateHandleOptions extends DevflarePlatformOptions {
 export declare function createHandle<T extends {
     event: {
         platform?: unknown;
+        request?: Request;
     };
     resolve: (event: unknown) => Response | Promise<Response>;
 }>(options?: CreateHandleOptions): (input: T) => Promise<Response>;
@@ -135,7 +174,8 @@ export declare function createHandle<T extends {
 export declare const handle: <T extends {
     event: {
         platform?: unknown;
+        request?: Request;
     };
-    resolve: (event: unknown) => Promise<Response> | Response;
+    resolve: (event: unknown) => Response | Promise<Response>;
 }>(input: T) => Promise<Response>;
 //# sourceMappingURL=platform.d.ts.map

package/dist/sveltekit/platform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/sveltekit/platform.ts"],"names":[],"mappings":"AAQA,OAAO,EAA6B,KAAK,YAAY,EAAE,MAAM,WAAW,CAAA;AAMxE;;GAEG;AACH,MAAM,WAAW,QAAQ;IACxB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC5B,OAAO,EAAE,gBAAgB,CAAA;IACzB,MAAM,EAAE,YAAY,CAAA;IACpB,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC3B;AAED,MAAM,WAAW,uBAAuB;IACvC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;;OAGG;IACH,KAAK,CAAC,EAAE,YAAY,CAAA;CACpB;AAgBD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,sBAAsB,CAC3C,OAAO,GAAE,uBAA4B,GACnC,OAAO,CAAC,QAAQ,CAAC,CA2DnB;AAyBD;;GAEG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAoGD;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,uBAAuB;IACnE;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,OAAO,CAAA;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS;IAAE,KAAK,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;CAAE,EAClI,OAAO,GAAE,mBAAwB,GAC/B,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,CAqBjC;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,MAAM,GAAU,CAAC;;;;;iCAqB7B,CAAA"}
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/sveltekit/platform.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,YAAY,EAA8C,MAAM,WAAW,CAAA;AAUzF;;GAEG;AACH,MAAM,WAAW,QAAQ;IACxB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC5B,OAAO,EAAE,gBAAgB,CAAA;IACzB,MAAM,EAAE,YAAY,CAAA;IACpB,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC3B;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,EAAE,CAAA;CACzB;AAED,MAAM,WAAW,uBAAuB;IACvC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;;OAGG;IACH,KAAK,CAAC,EAAE,YAAY,CAAA;IAEpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACvC;AAkDD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,EAAE,CAQlE;AAYD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,sBAAsB,CAC3C,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC5B,OAAO,GAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACrC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CACb,GACJ,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,sBAAsB,CAC3C,OAAO,GAAE,uBAA4B,GACnC,OAAO,CAAC,QAAQ,CAAC,CAsDnB;AA4BD;;GAEG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AA8HD;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,uBAAuB;IACnE;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,OAAO,CAAA;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAC3B,CAAC,SAAS;IACT,KAAK,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;IAChD,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;CACzD,EACA,OAAO,GAAE,mBAAwB,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,CAiBpE;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,MAAM,GAClB,CAAC,SAAS;IACT,KAAK,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;IAChD,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;CACzD,SAEM,CAAC,KACN,OAAO,CAAC,QAAQ,CAalB,CAAA"}