devflare 1.0.0-next.44 → 1.0.0-next.46

package/dist/test/index.js

@@ -4,12 +4,12 @@ import { _ as normalizeSecretsStoreBinding, f as normalizeMediaBinding, h as nor
 import { t as applyLocalDevVarsToConfig } from "../_chunks/local-dev-vars-CTSa-wvF.js";
 import { g as isAuthenticated, p as getApiToken } from "../_chunks/api-TzdliH-6.js";
 import { d as getPrimaryAccount, n as getEffectiveAccountId } from "../_chunks/preferences-BKp_7XJx.js";
-import { A as createTailEvent, D as createFetchEvent, E as createEmailEvent, F as BridgeClient, M as createEnvProxy, O as createQueueEvent, P as setBindingHints, _ as runWithContext, k as createScheduledEvent, v as runWithEventContext } from "../_chunks/context-CX50Y2Kb.js";
+import { A as createTailEvent, D as createFetchEvent, E as createEmailEvent, F as BridgeClient, M as createEnvProxy, O as createQueueEvent, P as setBindingHints, _ as runWithContext, k as createScheduledEvent, v as runWithEventContext, x as createDurableObjectAlarmEvent } from "../_chunks/context-CX50Y2Kb.js";
 import { createLocalSendEmailBinding, wrapEnvSendEmailBindings } from "../utils/send-email.js";
 import { n as __setTestContext, r as env, t as __clearTestContext } from "../_chunks/env-S0_nMVz1.js";
 import { d as invokeFetchModule, m as resolveFetchHandler, r as matchFetchRoute, t as createRouteResolve } from "../_chunks/runtime-FvXvfuZ2.js";
 import { i as extractBindingHints, n as createLocalWorkerLoaderBinding, r as disposeLocalWorkerLoaderBindings, t as createLocalHyperdrive } from "../_chunks/local-hyperdrive-CJ90j46O.js";
-import { a as hasServiceBindings, i as hasCrossWorkerDOs, o as resolveDOBindings, p as buildHyperdrivesConfig, r as clearBundleCache, s as resolveServiceBindings, t as discoverRoutes } from "../_chunks/routes-5OnFhKR2.js";
+import { T as buildTailConsumersConfig, a as hasServiceBindings, i as hasCrossWorkerDOs, m as buildHyperdrivesConfig, o as resolveDOBindings, r as clearBundleCache, s as resolveServiceBindings, t as discoverRoutes, u as buildAnalyticsEngineConfig } from "../_chunks/routes-C4S8x2HU.js";
 import { i as findFiles, t as DEFAULT_DO_PATTERN } from "../_chunks/glob-CmQOvunB.js";
 import { a as isRemoteModeActive, i as getRemoteModeStatus } from "../_chunks/remote-config-D39BY9ji.js";
 import { t as bundleWorkflowEntrypointScript } from "../_chunks/local-workflow-entrypoints-Cq_WJajd.js";
@@ -1226,7 +1226,231 @@ function createMockArtifacts(options = {}) {
 	};
 }
 //#endregion
+//#region src/test/utilities/vectorize.ts
+function toNumberArray(values) {
+	return Array.isArray(values) ? values.slice() : Array.from(values);
+}
+function cloneVector(vector) {
+	return {
+		id: vector.id,
+		values: toNumberArray(vector.values),
+		...vector.namespace !== void 0 && { namespace: vector.namespace },
+		...vector.metadata !== void 0 && { metadata: structuredClone(vector.metadata) }
+	};
+}
+/**
+* Cosine similarity between two equal-length vectors. Returns 0 when either
+* vector has zero magnitude (undefined direction), matching a "no similarity"
+* result rather than throwing.
+*/
+function cosineSimilarity(a, b) {
+	let dot = 0;
+	let magA = 0;
+	let magB = 0;
+	const length = Math.min(a.length, b.length);
+	for (let i = 0; i < length; i++) {
+		dot += a[i] * b[i];
+		magA += a[i] * a[i];
+		magB += b[i] * b[i];
+	}
+	if (magA === 0 || magB === 0) return 0;
+	return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+function readMetadataField(metadata, field) {
+	return metadata?.[field];
+}
+function compareScalar(op, actual, expected) {
+	switch (op) {
+		case "$eq": return actual === expected;
+		case "$ne": return actual !== expected;
+		case "$lt": return typeof actual === "number" && typeof expected === "number" && actual < expected;
+		case "$lte": return typeof actual === "number" && typeof expected === "number" && actual <= expected;
+		case "$gt": return typeof actual === "number" && typeof expected === "number" && actual > expected;
+		case "$gte": return typeof actual === "number" && typeof expected === "number" && actual >= expected;
+		default: throw new Error(`Mock Vectorize query filter operator "${op}" is not supported. Supported operators: $eq, $ne, $lt, $lte, $gt, $gte, $in, $nin.`);
+	}
+}
+function evaluateOperator(op, actual, expected) {
+	if (op === "$in") return Array.isArray(expected) && expected.includes(actual);
+	if (op === "$nin") return !Array.isArray(expected) || !expected.includes(actual);
+	return compareScalar(op, actual, expected);
+}
+/**
+* Evaluates one field's condition: either a scalar `$eq` shorthand or an
+* operator object where every operator must hold.
+*/
+function matchesCondition(actual, condition) {
+	if (condition === null || typeof condition !== "object" || Array.isArray(condition)) return actual === condition;
+	return Object.entries(condition).every(([op, expected]) => evaluateOperator(op, actual, expected));
+}
+/**
+* Evaluates a Vectorize metadata filter against a stored vector's metadata,
+* mirroring the documented filter grammar (scalar equality shorthand plus the
+* `$eq/$ne/$lt/$lte/$gt/$gte` and `$in/$nin` operators). All fields must match.
+*/
+function matchesFilter(metadata, filter) {
+	return Object.entries(filter).every(([field, condition]) => matchesCondition(readMetadataField(metadata, field), condition));
+}
+function applyMetadataRetrieval(metadata, returnMetadata) {
+	if (metadata === void 0) return;
+	if (returnMetadata === void 0 || returnMetadata === false || returnMetadata === "none") return;
+	return structuredClone(metadata);
+}
+/**
+* Creates a deterministic in-memory Vectorize index binding for pure unit tests.
+*
+* @example
+* ```ts
+* const index = createMockVectorize({
+*   vectors: [{ id: 'a', values: [1, 0], metadata: { topic: 'cats' } }]
+* })
+* await index.insert([{ id: 'b', values: [0, 1] }])
+* const result = await index.query([1, 0], { topK: 1, returnMetadata: true })
+* // result.matches[0].id === 'a'
+* ```
+*/
+function createMockVectorize(options = {}) {
+	const store = /* @__PURE__ */ new Map();
+	let inferredDimensions = options.dimensions;
+	const noteDimensions = (vector) => {
+		if (inferredDimensions === void 0) inferredDimensions = toNumberArray(vector.values).length;
+	};
+	for (const vector of options.vectors ?? []) {
+		const stored = cloneVector(vector);
+		noteDimensions(stored);
+		store.set(stored.id, stored);
+	}
+	const insert = async (vectors, { overwrite }) => {
+		const ids = [];
+		for (const vector of vectors) {
+			if (!overwrite && store.has(vector.id)) throw new Error(`Mock Vectorize insert failed: a vector with id "${vector.id}" already exists. Use upsert() to replace it.`);
+			const stored = cloneVector(vector);
+			noteDimensions(stored);
+			store.set(stored.id, stored);
+			ids.push(stored.id);
+		}
+		return {
+			ids,
+			count: ids.length
+		};
+	};
+	const deleteByIds = async (ids) => {
+		const deleted = [];
+		for (const id of ids) if (store.delete(id)) deleted.push(id);
+		return {
+			ids: deleted,
+			count: deleted.length
+		};
+	};
+	return {
+		async describe() {
+			return {
+				id: `mock-${options.name ?? "mock-vectorize"}`,
+				name: options.name ?? "mock-vectorize",
+				config: {
+					dimensions: inferredDimensions ?? 0,
+					metric: options.metric ?? "cosine"
+				},
+				vectorsCount: store.size
+			};
+		},
+		async insert(vectors) {
+			return insert(vectors, { overwrite: false });
+		},
+		async upsert(vectors) {
+			return insert(vectors, { overwrite: true });
+		},
+		async deleteByIds(ids) {
+			return deleteByIds(ids);
+		},
+		async delete(ids) {
+			return deleteByIds(ids);
+		},
+		async getByIds(ids) {
+			const result = [];
+			for (const id of ids) {
+				const vector = store.get(id);
+				if (vector) result.push(cloneVector(vector));
+			}
+			return result;
+		},
+		async query(vector, queryOptions) {
+			const queryVector = toNumberArray(vector);
+			const topK = queryOptions?.topK ?? 5;
+			const namespace = queryOptions?.namespace;
+			const filter = queryOptions?.filter;
+			const returnValues = queryOptions?.returnValues ?? false;
+			const returnMetadata = queryOptions?.returnMetadata;
+			const matches = Array.from(store.values()).filter((candidate) => namespace === void 0 || candidate.namespace === namespace).filter((candidate) => filter === void 0 || matchesFilter(candidate.metadata, filter)).map((candidate) => ({
+				candidate,
+				score: cosineSimilarity(queryVector, toNumberArray(candidate.values))
+			})).sort((a, b) => b.score - a.score || a.candidate.id.localeCompare(b.candidate.id)).slice(0, topK).map(({ candidate, score }) => {
+				const match = {
+					id: candidate.id,
+					score,
+					...candidate.namespace !== void 0 && { namespace: candidate.namespace }
+				};
+				if (returnValues) match.values = toNumberArray(candidate.values);
+				const metadata = applyMetadataRetrieval(candidate.metadata, returnMetadata);
+				if (metadata !== void 0) match.metadata = metadata;
+				return match;
+			});
+			return {
+				matches,
+				count: matches.length
+			};
+		},
+		_getVectors() {
+			return Array.from(store.values()).map(cloneVector);
+		}
+	};
+}
+//#endregion
+//#region src/test/utilities/analytics-engine.ts
+/**
+* Creates a write-only Analytics Engine dataset binding for pure unit tests.
+*
+* @example
+* ```ts
+* const dataset = createMockAnalyticsEngine()
+* dataset.writeDataPoint({ indexes: ['user-1'], doubles: [1], blobs: ['signup'] })
+* expect(dataset.writtenDataPoints).toEqual([
+*   { indexes: ['user-1'], doubles: [1], blobs: ['signup'] }
+* ])
+* ```
+*/
+function createMockAnalyticsEngine() {
+	const dataPoints = [];
+	return {
+		writeDataPoint(event) {
+			dataPoints.push(event ? structuredClone(event) : {});
+		},
+		get writtenDataPoints() {
+			return dataPoints;
+		},
+		get points() {
+			return dataPoints;
+		},
+		clear() {
+			dataPoints.length = 0;
+		}
+	};
+}
+//#endregion
 //#region src/test/utilities/env.ts
+function isVectorizeBinding$1(value) {
+	return typeof value.query === "function";
+}
+function addVectorizeMockBindings(env, vectorize) {
+	if (Array.isArray(vectorize)) {
+		for (const name of vectorize) env[name] = createMockVectorize();
+		return;
+	}
+	if (vectorize) for (const [name, value] of Object.entries(vectorize)) env[name] = isVectorizeBinding$1(value) ? value : createMockVectorize(value);
+}
+function addAnalyticsEngineMockBindings(env, analyticsEngine) {
+	for (const name of analyticsEngine ?? []) env[name] = createMockAnalyticsEngine();
+}
 /**
 * Creates a complete mock environment with specified bindings
 *
@@ -1264,6 +1488,8 @@ function createMockEnv(options = {}) {
 	else if (options.media) env.MEDIA = options.media;
 	if (Array.isArray(options.artifacts)) for (const name of options.artifacts) env[name] = createMockArtifacts();
 	else if (options.artifacts) for (const [name, artifactsOptions] of Object.entries(options.artifacts)) env[name] = isArtifactsBinding$1(artifactsOptions) ? artifactsOptions : createMockArtifacts(artifactsOptions);
+	addVectorizeMockBindings(env, options.vectorize);
+	addAnalyticsEngineMockBindings(env, options.analyticsEngine);
 	if (options.secretsStore) for (const [name, value] of Object.entries(options.secretsStore)) env[name] = createMockSecretsStoreSecret(value);
 	if (options.vars) Object.assign(env, options.vars);
 	if (options.secrets) Object.assign(env, options.secrets);
@@ -2054,7 +2280,7 @@ function createMessageBatch(messages) {
 * ])
 * ```
 */
-async function trigger$2(messages) {
+async function trigger$3(messages) {
 	if (!queueHandlerPath) throw new Error("Queue handler not configured. Make sure your devflare.config.ts has files.queue set, and the file exists at the specified path (default: src/queue.ts)");
 	if (!configDir$3 || !testEnvGetter$3) throw new Error("Queue helper not initialized. Call createTestContext() before using cf.queue.trigger()");
 	const handlerModule = await import(join$1(configDir$3, queueHandlerPath));
@@ -2108,10 +2334,10 @@ async function trigger$2(messages) {
 * ```
 */
 async function send(message) {
-	return trigger$2([message]);
+	return trigger$3([message]);
 }
 const queue = {
-	trigger: trigger$2,
+	trigger: trigger$3,
 	send
 };
 //#endregion
@@ -2159,7 +2385,7 @@ function resetScheduledState() {
 * // Trigger without cron (just scheduled time)
 * await cf.scheduled.trigger()
 */
-async function trigger$1(cronOrOptions) {
+async function trigger$2(cronOrOptions) {
 	if (!scheduledHandlerPath) throw new Error("Scheduled handler not configured. Make sure your devflare.config.ts has files.scheduled set, and the file exists at the specified path (default: src/scheduled.ts)");
 	if (!configDir$2 || !testEnvGetter$2) throw new Error("Scheduled helper not initialized. Call createTestContext() before using cf.scheduled.trigger()");
 	const options = typeof cronOrOptions === "string" ? { cron: cronOrOptions } : cronOrOptions ?? {};
@@ -2198,7 +2424,7 @@ async function trigger$1(cronOrOptions) {
 		};
 	}
 }
-const scheduled = { trigger: trigger$1 };
+const scheduled = { trigger: trigger$2 };
 //#endregion
 //#region src/test/tail.ts
 let tailHandlerPath = null;
@@ -2267,7 +2493,7 @@ function createTraceItem(options) {
 * ])
 * ```
 */
-async function trigger(items) {
+async function trigger$1(items) {
 	if (!tailHandlerPath) throw new Error("Tail handler not configured. Add a src/tail.ts file exporting tail(), or configure a tail handler before calling cf.tail.trigger().");
 	if (!configDir$1 || !testEnvGetter$1) throw new Error("Tail helper not initialized. Call createTestContext() before using cf.tail.trigger()");
 	const traceItems = items.map((item) => {
@@ -2314,7 +2540,7 @@ function create(options = {}) {
 	return createTraceItem(options);
 }
 const tail = {
-	trigger,
+	trigger: trigger$1,
 	create
 };
 //#endregion
@@ -3090,7 +3316,11 @@ function buildInlineBridgeMfConfig(config, options = {}) {
 	if (config.bindings?.versionMetadata) mfConfig.versionMetadata = config.bindings.versionMetadata.binding;
 	if (config.bindings?.workerLoaders) mfConfig.workerLoaders = Object.fromEntries(Object.keys(config.bindings.workerLoaders).map((bindingName) => [bindingName, {}]));
 	if (config.bindings?.mtlsCertificates) mfConfig.mtlsCertificates = Object.fromEntries(Object.entries(config.bindings.mtlsCertificates).map(([bindingName, binding]) => {
-		return [bindingName, { certificate_id: normalizeMtlsCertificateBinding(binding).certificateId }];
+		const normalized = normalizeMtlsCertificateBinding(binding);
+		return [bindingName, {
+			certificate_id: normalized.certificateId,
+			...normalized.remote !== void 0 && { remote: normalized.remote }
+		}];
 	}));
 	if (config.bindings?.dispatchNamespaces) mfConfig.dispatchNamespaces = Object.fromEntries(Object.entries(config.bindings.dispatchNamespaces).map(([bindingName, binding]) => {
 		return [bindingName, { namespace: normalizeDispatchNamespaceBinding(binding).namespace }];
@@ -3122,6 +3352,10 @@ function buildInlineBridgeMfConfig(config, options = {}) {
 			mfConfig.media = { binding: normalizeMediaBinding(bindingName, binding).binding };
 		}
 	}
+	const analyticsEngineConfig = buildAnalyticsEngineConfig(config.bindings ?? {});
+	if (analyticsEngineConfig) mfConfig.analyticsEngineDatasets = analyticsEngineConfig;
+	const tailConsumersConfig = buildTailConsumersConfig(config);
+	if (tailConsumersConfig) mfConfig.tails = tailConsumersConfig;
 	if (config.bindings?.artifacts) mfConfig.artifacts = Object.fromEntries(Object.entries(config.bindings.artifacts).map(([bindingName, binding]) => {
 		return [bindingName, { namespace: normalizeArtifactsBinding(binding).namespace }];
 	}));
@@ -3188,6 +3422,8 @@ function applyMultiWorkerConfig(mfConfig, config, serviceBindingResolution, doBi
 		...mfConfig.pipelines && { pipelines: mfConfig.pipelines },
 		...mfConfig.images && { images: mfConfig.images },
 		...mfConfig.media && { media: mfConfig.media },
+		...mfConfig.analyticsEngineDatasets && { analyticsEngineDatasets: mfConfig.analyticsEngineDatasets },
+		...mfConfig.tails && { tails: mfConfig.tails },
 		...mfConfig.artifacts && { artifacts: mfConfig.artifacts },
 		...mfConfig.secretsStoreSecrets && { secretsStoreSecrets: mfConfig.secretsStoreSecrets },
 		...mfConfig.wrappedBindings && { wrappedBindings: mfConfig.wrappedBindings },
@@ -3231,6 +3467,8 @@ function applyMultiWorkerConfig(mfConfig, config, serviceBindingResolution, doBi
 	delete mfConfig.pipelines;
 	delete mfConfig.images;
 	delete mfConfig.media;
+	delete mfConfig.analyticsEngineDatasets;
+	delete mfConfig.tails;
 	delete mfConfig.artifacts;
 	delete mfConfig.secretsStoreSecrets;
 	delete mfConfig.wrappedBindings;
@@ -3481,6 +3719,43 @@ async function createTestContext(configPath) {
 	__setTestContext(createBridgeEnvAccessor(state, hints, shouldPreferBridgeBinding), disposeContext);
 }
 //#endregion
+//#region src/test/alarm.ts
+/**
+* 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)
+*/
+async function trigger(target, options = {}) {
+	if (!target || typeof target.alarm !== "function") throw new Error("cf.alarm.trigger(target): the target Durable Object instance has no alarm() method. Pass a DO instance whose class defines an async alarm() handler (and enable alarms via the @durableObject({ alarms: true }) decorator so the runtime wraps it).");
+	const state = options.state ?? target.state ?? target.ctx;
+	const alarmEvent = createDurableObjectAlarmEvent(options.env ?? target.env ?? {}, state);
+	try {
+		await runWithEventContext(alarmEvent, () => target.alarm?.(alarmEvent));
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+const alarm = { trigger };
+//#endregion
 //#region src/test/cf.ts
 /**
 * Unified Cloudflare test helpers.
@@ -3491,6 +3766,7 @@ async function createTestContext(configPath) {
 * - `cf.scheduled` — Cron/scheduled handler testing
 * - `cf.worker` — Fetch handler testing
 * - `cf.tail` — Tail helper surface (uses `files.tail`, or auto-detects `src/tail.ts` when present)
+* - `cf.alarm` — Durable Object alarm handler testing (fires a DO instance's `alarm()`)
 *
 * The helpers use the real Miniflare-backed bindings created by `createTestContext()`,
 * but several helper surfaces still synthesize event/controller objects around those
@@ -3541,7 +3817,8 @@ const cf = {
 	queue,
 	scheduled,
 	worker,
-	tail
+	tail,
+	alarm
 };
 //#endregion
 //#region src/test/should-skip.ts
@@ -4356,9 +4633,15 @@ const SUPPORT_MATRIX = {
 	},
 	vectorize: {
 		service: "vectorize",
-		tier: "remote-boundary",
-		reason: "Cloudflare lists Vectorize with no local simulation.",
-		recommendation: "Use DEVFLARE_REMOTE=1/devflare remote enable for real indexes, or inject a fake Vectorize binding for pure tests."
+		tier: "offline-fixture",
+		reason: "Vector storage and cosine-similarity query are deterministic in-memory; Cloudflare's real indexing/ranking/scale are hosted — use remote mode for those.",
+		recommendation: "Use createMockVectorize() or createOfflineEnv() for app-level vector tests; use DEVFLARE_REMOTE=1/devflare remote enable for real index relevance and scale."
+	},
+	analyticsEngine: {
+		service: "analyticsEngine",
+		tier: "offline-fixture",
+		reason: "Analytics Engine writes are recordable in-memory (createMockAnalyticsEngine), but there is no in-worker read API — querying is the hosted SQL API/dashboard.",
+		recommendation: "Use createMockAnalyticsEngine() to assert recorded writeDataPoint() calls; query analytics through the hosted SQL API/dashboard."
 	},
 	builds: {
 		service: "builds",
@@ -4427,6 +4710,9 @@ function isArtifactsBinding(value) {
 function isAISearchInstance(value) {
 	return typeof value?.search === "function";
 }
+function isVectorizeBinding(value) {
+	return typeof value?.query === "function";
+}
 function isAISearchNamespace(value) {
 	return typeof value?.get === "function";
 }
@@ -4444,6 +4730,27 @@ function addStaticBindings(env, config) {
 function addRateLimitBindings(env, bindings) {
 	for (const [name, binding] of Object.entries(bindings?.rateLimits ?? {})) env[name] = createMockRateLimit(binding.simple);
 }
+function addKVBindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.kv ?? {})) env[name] = fixtures.kv?.[name] ?? createMockKV();
+}
+function addD1Bindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.d1 ?? {})) env[name] = fixtures.d1?.[name] ?? createMockD1();
+}
+function addR2Bindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.r2 ?? {})) env[name] = fixtures.r2?.[name] ?? createMockR2();
+}
+function addQueueBindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.queues?.producers ?? {})) env[name] = fixtures.queues?.[name] ?? createMockQueue();
+}
+function addVectorizeBindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.vectorize ?? {})) {
+		const fixture = fixtures.vectorize?.[name];
+		env[name] = isVectorizeBinding(fixture) ? fixture : createMockVectorize(fixture);
+	}
+}
+function addAnalyticsEngineBindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.analyticsEngine ?? {})) env[name] = fixtures.analyticsEngine?.[name] ?? createMockAnalyticsEngine();
+}
 function addVersionMetadataBinding(env, bindings) {
 	if (bindings?.versionMetadata) env[bindings.versionMetadata.binding] = createMockVersionMetadata();
 }
@@ -4555,55 +4862,47 @@ function addAISearchNamespaceBindings(env, bindings, fixtures) {
 	}
 }
 /**
-* Core storage and wiring bindings (kv/d1/r2/queues/durableObjects/services)
-* have no pure-offline fixture: they need a real Miniflare runtime, which only
-* `createTestContext()` provides. `createOfflineBindings()` therefore cannot
-* populate them, and leaving them silently absent from `env` is a surprise.
-* Surface each one in `missingFixtures` (with `env` left unset rather than a fake)
-* so callers see exactly which bindings require `createTestContext()` /
-* `createMock*()` instead of getting an `undefined` lookup at use time.
+* Wiring bindings (durableObjects/services) have no pure-offline fixture: they
+* need a real Miniflare runtime, which only `createTestContext()` provides.
+* `createOfflineBindings()` therefore cannot populate them, and leaving them
+* silently absent from `env` is a surprise. Surface each one in
+* `missingFixtures` (with `env` left unset rather than a fake) so callers see
+* exactly which bindings require `createTestContext()` / a cross-worker setup
+* instead of getting an `undefined` lookup at use time.
+*
+* Storage bindings (kv/d1/r2/queues) DO have deterministic in-memory mocks, so
+* `createOfflineBindings()` auto-creates them — they are not listed here.
 */
-const OFFLINE_UNAVAILABLE_STORAGE_BINDINGS = [
-	"kv",
-	"d1",
-	"r2",
-	"durableObjects",
-	"services"
-];
+const OFFLINE_UNAVAILABLE_STORAGE_BINDINGS = ["durableObjects", "services"];
 function addUnsupportedStorageBindings(bindings, missingFixtures) {
 	for (const service of OFFLINE_UNAVAILABLE_STORAGE_BINDINGS) {
 		const group = bindings?.[service];
 		for (const name of Object.keys(group ?? {})) missingFixtures.push({
 			service,
 			binding: name,
-			reason: `${service} binding "${name}" needs a real Miniflare runtime and is not created by createOfflineBindings(); it will be undefined. Use createTestContext() (Miniflare-backed) or a createMock* helper for this binding.`
+			reason: `${service} binding "${name}" needs a real Miniflare runtime and is not created by createOfflineBindings(); it will be undefined. Use createTestContext() (Miniflare-backed) for this binding.`
 		});
 	}
-	const queueProducers = (bindings?.queues)?.producers ?? {};
-	for (const name of Object.keys(queueProducers)) missingFixtures.push({
-		service: "queues",
-		binding: name,
-		reason: `queues producer binding "${name}" needs a real Miniflare runtime and is not created by createOfflineBindings(); it will be undefined. Use createTestContext() or createMockQueue() for this binding.`
-	});
 }
 function addRemoteBoundaries(remoteBoundaries, bindings) {
 	if (bindings?.ai) addBoundary(remoteBoundaries, "ai", bindings.ai.binding || "AI", "Workers AI inference is not available in offline local simulations.");
-	for (const name of Object.keys(bindings?.vectorize ?? {})) addBoundary(remoteBoundaries, "vectorize", name, "Vectorize has no offline local simulation in Cloudflare local development.");
 	for (const name of Object.keys(bindings?.vpcServices ?? {})) addBoundary(remoteBoundaries, "vpcServices", name, "VPC services are proxy-only locally — Miniflare's vpc-services plugin needs a remote proxy connection, so there is no offline simulation.");
 	for (const name of Object.keys(bindings?.vpcNetworks ?? {})) addBoundary(remoteBoundaries, "vpcNetworks", name, "VPC networks are proxy-only locally — Miniflare's vpc-networks plugin needs a remote proxy connection, so there is no offline simulation.");
 }
 /**
 * Builds a deterministic, pure-test env object from Devflare config.
 *
-* Covers the bindings that have a pure-offline simulator or fixture (rate
-* limits, version metadata, hyperdrive, worker loaders, mTLS, dispatch
-* namespaces, workflows, pipelines, images, media, stream, flagship, artifacts,
-* secrets store, AI Search). It does **not** create the core storage/wiring bindings
-* (`kv`, `d1`, `r2`, `queues`, `durableObjects`, `services`) — those require a
-* real Miniflare runtime, which only `createTestContext()` provides. When such a
-* binding is present in config it is reported in the returned `missingFixtures`
-* (its `env` entry is left unset rather than silently faked); use
-* `createTestContext()` or a `createMock*()` helper for those bindings.
+* Covers the bindings that have a pure-offline simulator or fixture: the core
+* storage mocks (`kv`, `d1`, `r2`, `queues`) are **auto-created** from the
+* existing `createMock*()` helpers (an explicit `fixtures.{kv,d1,r2,queues}`
+* entry overrides the auto-mock), alongside rate limits, version metadata,
+* hyperdrive, worker loaders, mTLS, dispatch namespaces, workflows, pipelines,
+* images, media, stream, flagship, artifacts, secrets store, AI Search,
+* Vectorize, and Analytics Engine. It does **not** create the wiring bindings
+* (`durableObjects`, `services`) — those require a real Miniflare runtime, which
+* only `createTestContext()` provides. When such a binding is present in config
+* it is reported in the returned `missingFixtures` (its `env` entry is left
+* unset rather than silently faked); use `createTestContext()` for those.
 */
 function createOfflineBindings(config, fixtures = {}, options = {}) {
 	const env = {};
@@ -4612,6 +4911,12 @@ function createOfflineBindings(config, fixtures = {}, options = {}) {
 	const bindings = config.bindings;
 	const localSecretValues = options.cwd && options.useLocalSecrets !== false ? resolveLocalSecretValuesForBindings(config, options.cwd) : {};
 	addStaticBindings(env, config);
+	addKVBindings(env, bindings, fixtures);
+	addD1Bindings(env, bindings, fixtures);
+	addR2Bindings(env, bindings, fixtures);
+	addQueueBindings(env, bindings, fixtures);
+	addVectorizeBindings(env, bindings, fixtures);
+	addAnalyticsEngineBindings(env, bindings, fixtures);
 	addRateLimitBindings(env, bindings);
 	addVersionMetadataBinding(env, bindings);
 	addHyperdriveBindings(env, bindings, fixtures, missingFixtures);
@@ -4641,14 +4946,14 @@ function createOfflineBindings(config, fixtures = {}, options = {}) {
 /**
 * Convenience wrapper for callers that only need the derived env object.
 *
-* Note: the core storage/wiring bindings (`kv`, `d1`, `r2`, `queues`,
-* `durableObjects`, `services`) are **not** created here and will be
-* `undefined` in the returned env — they need a real Miniflare runtime. Use
-* `createTestContext()` or a `createMock*()` helper for them, or call
-* `createOfflineBindings()` to inspect `missingFixtures` for the exact list.
+* Note: the storage mocks (`kv`, `d1`, `r2`, `queues`) are auto-created here, but
+* the wiring bindings (`durableObjects`, `services`) are **not** — they need a
+* real Miniflare runtime and will be `undefined` in the returned env. Use
+* `createTestContext()` for them, or call `createOfflineBindings()` to inspect
+* `missingFixtures` for the exact list.
 */
 function createOfflineEnv(config, fixtures = {}, options = {}) {
 	return createOfflineBindings(config, fixtures, options).env;
 }
 //#endregion
-export { cf, clearBundleCache, containers, createContainerManager, createMockAISearchInstance, createMockAISearchNamespace, createMockArtifacts, createMockD1, createMockDispatchNamespace, createMockEnv, createMockFlagshipBinding, createMockHyperdrive, createMockImagesBinding, createMockKV, createMockMTLSCertificate, createMockMediaBinding, createMockPipeline, createMockQueue, createMockR2, createMockRateLimit, createMockSecretsStoreSecret, createMockStreamBinding, createMockTestContext, createMockVersionMetadata, createMockWorkerLoader, createMockWorkflow, createOfflineBindings, createOfflineEnv, createTestContext, describeOfflineSupport, detectContainerEngine, email, env, getContainerSkipReason, getOfflineSupportMatrix, hasCrossWorkerDOs, hasServiceBindings, queue, resolveDOBindings, resolveServiceBindings, scheduled, shouldSkip, stopActiveContainers, tail, withTestContext, worker };
+export { alarm, cf, clearBundleCache, containers, createContainerManager, createMockAISearchInstance, createMockAISearchNamespace, createMockAnalyticsEngine, createMockArtifacts, createMockD1, createMockDispatchNamespace, createMockEnv, createMockFlagshipBinding, createMockHyperdrive, createMockImagesBinding, createMockKV, createMockMTLSCertificate, createMockMediaBinding, createMockPipeline, createMockQueue, createMockR2, createMockRateLimit, createMockSecretsStoreSecret, createMockStreamBinding, createMockTestContext, createMockVectorize, createMockVersionMetadata, createMockWorkerLoader, createMockWorkflow, createOfflineBindings, createOfflineEnv, createTestContext, describeOfflineSupport, detectContainerEngine, email, env, getContainerSkipReason, getOfflineSupportMatrix, hasCrossWorkerDOs, hasServiceBindings, queue, resolveDOBindings, resolveServiceBindings, scheduled, shouldSkip, stopActiveContainers, tail, withTestContext, worker };