devflare 1.0.0-next.5 → 1.0.0-next.51

package/dist/sveltekit/index.js

@@ -1,182 +1,328 @@
-import"../index-m2q41jwa.js";
-import {
-  createEnvProxy,
-  getClient
-} from "../index-pf5s73n9.js";
-import"../index-07q6yxyc.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-OQ2AWpqm.js";
+import { l as normalizeHyperdriveBinding } from "../_chunks/schema-normalization-GjhTATHL.js";
+import { D as createFetchEvent, I as getClient, M as createEnvProxy, P as setBindingHints, v as runWithEventContext } from "../_chunks/context-CX50Y2Kb.js";
+import { createLocalSendEmailBinding } from "../utils/send-email.js";
+import { i as extractBindingHints, n as createLocalWorkerLoaderBinding, t as createLocalHyperdrive } from "../_chunks/local-hyperdrive-CJ90j46O.js";
+import { t as buildLocalSecretNodeBindings } from "../_chunks/local-secrets-CYoHfvQ1.js";
+import { n as createLocalImagesBinding, r as createLocalMediaBinding } from "../_chunks/local-media-bindings-DsAW4AMF.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: () => {}
+	};
+}
+/**
+* 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 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));
+}
+async function createPlatformWithRequestContext(event, resolve, options) {
+	const platform = await createDevflarePlatform(options);
+	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") try {
+			return await createPlatformWithRequestContext(event, resolve, await getCustomPlatformOptions(platformOptions));
+		} catch (error) {
+			console.error("[devflare] Failed to create platform:", error);
+		}
+		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") try {
+		return await createPlatformWithRequestContext(event, resolve, await getAutoPlatformOptions());
+	} catch (error) {
+		console.error("[devflare] Failed to create platform:", error);
+	}
+	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,18 @@ 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[];
 /**
  * Create a platform object that routes bindings through the bridge
  *
@@ -107,6 +123,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 +152,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;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,sBAAsB,CAC3C,OAAO,GAAE,uBAA4B,GACnC,OAAO,CAAC,QAAQ,CAAC,CAqDnB;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;AAgGD;;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,CAwBpE;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,CAgBlB,CAAA"}

package/dist/test/ai-search.d.ts

@@ -0,0 +1,39 @@
+type AISearchChunk = AiSearchSearchResponse['chunks'][number];
+export interface MockAISearchItemFixture {
+    id?: string;
+    key: string;
+    content?: string;
+    contentType?: string;
+    metadata?: Record<string, unknown>;
+    status?: AiSearchItemInfo['status'];
+    chunks?: string[];
+}
+export interface MockAISearchInstanceOptions {
+    id?: string;
+    namespace?: string;
+    info?: Partial<AiSearchInstanceInfo>;
+    items?: MockAISearchItemFixture[];
+    chatMessage?: string | ((chunks: AISearchChunk[], request: AiSearchChatCompletionsRequest) => string);
+}
+export interface MockAISearchNamespaceOptions {
+    namespace?: string;
+    instances?: Record<string, MockAISearchInstanceOptions | AiSearchInstance>;
+}
+export type MockAISearchInstance = AiSearchInstance & {
+    _getSearches(): AiSearchSearchRequest[];
+    _getItems(): AiSearchItemInfo[];
+    _getJobs(): AiSearchJobInfo[];
+};
+export type MockAISearchNamespace = AiSearchNamespace & {
+    _getInstances(): string[];
+};
+/**
+ * Creates a deterministic AI Search instance binding for pure unit tests.
+ */
+export declare function createMockAISearchInstance(options?: MockAISearchInstanceOptions): MockAISearchInstance;
+/**
+ * Creates a deterministic AI Search namespace binding for pure unit tests.
+ */
+export declare function createMockAISearchNamespace(options?: MockAISearchNamespaceOptions): MockAISearchNamespace;
+export {};
+//# sourceMappingURL=ai-search.d.ts.map

package/dist/test/ai-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-search.d.ts","sourceRoot":"","sources":["../../src/test/ai-search.ts"],"names":[],"mappings":"AAQA,KAAK,aAAa,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAA;AAG7D,MAAM,WAAW,uBAAuB;IACvC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC,MAAM,CAAC,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAA;IACnC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CACjB;AAED,MAAM,WAAW,2BAA2B;IAC3C,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAA;IACpC,KAAK,CAAC,EAAE,uBAAuB,EAAE,CAAA;IACjC,WAAW,CAAC,EACT,MAAM,GACN,CAAC,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE,OAAO,EAAE,8BAA8B,KAAK,MAAM,CAAC,CAAA;CACjF;AAED,MAAM,WAAW,4BAA4B;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,2BAA2B,GAAG,gBAAgB,CAAC,CAAA;CAC1E;AAED,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,GAAG;IACrD,YAAY,IAAI,qBAAqB,EAAE,CAAA;IACvC,SAAS,IAAI,gBAAgB,EAAE,CAAA;IAC/B,QAAQ,IAAI,eAAe,EAAE,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,GAAG;IACvD,aAAa,IAAI,MAAM,EAAE,CAAA;CACzB,CAAA;AAqJD;;GAEG;AACH,wBAAgB,0BAA0B,CACzC,OAAO,GAAE,2BAAgC,GACvC,oBAAoB,CAiXtB;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAC1C,OAAO,GAAE,4BAAiC,GACxC,qBAAqB,CA2IvB"}

package/dist/test/alarm.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Minimal shape a Durable Object instance must satisfy to have its alarm fired:
+ * an `alarm()` method, plus the `state`/`ctx` and `env` the runtime injects.
+ * Matches the wrapper the Devflare DO transform generates around `alarm()`.
+ */
+export interface AlarmTriggerTarget {
+    alarm?: (...args: unknown[]) => unknown;
+    state?: DurableObjectState;
+    ctx?: DurableObjectState;
+    env?: unknown;
+}
+export interface AlarmTriggerOptions {
+    /**
+     * Durable Object state to attach to the alarm event. Defaults to the
+     * instance's `state` (or `ctx`) when present.
+     */
+    state?: DurableObjectState;
+    /**
+     * Env to attach to the alarm event. Defaults to the instance's `env` when
+     * present, otherwise an empty object.
+     */
+    env?: unknown;
+}
+export interface AlarmTriggerResult {
+    /** Whether the alarm handler completed successfully. */
+    success: boolean;
+    /** Error message if the handler threw. */
+    error?: string;
+}
+/**
+ * Trigger a Durable Object's `alarm()` handler.
+ *
+ * This mirrors how the Devflare runtime invokes a DO alarm: it builds a
+ * `durable-object-alarm` event with the instance's env + state, installs it into
+ * AsyncLocalStorage via `runWithEventContext`, and calls the instance's
+ * `alarm()` with that event (so `getDurableObjectAlarmEvent()` works inside the
+ * handler). The instance keeps using its own `this.env` / `this.ctx`; the event
+ * is supplied for context-aware code paths.
+ *
+ * @param target - The Durable Object instance whose `alarm()` should be fired.
+ * @param options - Optional explicit `state`/`env` for the alarm event.
+ * @returns Result object with success status.
+ *
+ * @example
+ * const counter = new Counter(state, env)
+ * await counter.scheduleAlarm()
+ * const result = await cf.alarm.trigger(counter)
+ * expect(result.success).toBe(true)
+ */
+declare function trigger(target: AlarmTriggerTarget, options?: AlarmTriggerOptions): Promise<AlarmTriggerResult>;
+export declare const alarm: {
+    trigger: typeof trigger;
+};
+export {};
+//# sourceMappingURL=alarm.d.ts.map