devflare 1.0.0-next.45 → 1.0.0-next.47

package/LLM.md

@@ -4411,6 +4411,8 @@ That is the main reason the built-in harness scales: the same config and file co
 
 These helpers are runtime-shaped and context-accurate for handler logic, but they do not try to recreate every internal Cloudflare dispatch step byte for byte. Their timing rules are documented explicitly instead of being left to guesswork.
 
+Each surface is also exported standalone for tree-shaking — `cf.alarm.trigger()` is the same function as the named `alarm` export, just as `cf.queue` mirrors `queue`. The Durable Object `alarm` helper takes a DO instance you construct in the test (not a handler file path), mirroring how the runtime wrapper invokes `alarm()`.
+
 ##### Reference table
 
 | Helper | Current behavior |
@@ -4420,6 +4422,7 @@ These helpers are runtime-shaped and context-accurate for handler logic, but the
 | `cf.scheduled.trigger()` | Waits for scheduled background work before it returns. |
 | `cf.email.send()` | In `createTestContext()` tests, directly invokes the configured local email handler and waits for its queued `waitUntil()` work; otherwise it falls back to the local email endpoint. |
 | `cf.tail.trigger()` | Works when `src/tail.ts` exists, supports a default or named `tail` export, and waits for the handler plus its `waitUntil()` work before it returns. |
+| `cf.alarm.trigger(instance)` | Fires a Durable Object instance’s `alarm()` handler under a `durable-object-alarm` event context (the standalone `alarm` export is the same trigger) and awaits it, returning `{ success, error? }`. |
 
 > **Warning — Do not assert the wrong timing contract**
 >
@@ -4739,8 +4742,8 @@ The `devflare/test` entrypoint intentionally has multiple lanes: runtime-shaped
 | Export family | Smallest use | Status |
 | --- | --- | --- |
 | `createTestContext`, `env`, `cf` | Runtime-shaped Worker tests with cleanup. | Recommended |
-| `cf.worker`, `cf.queue`, `cf.scheduled`, `cf.email`, `cf.tail` | Trigger the matching Worker surface directly. | Recommended |
-| `worker`, `queue`, `scheduled`, `email`, `tail` | Direct helper modules behind the unified `cf` API. | Advanced |
+| `cf.worker`, `cf.queue`, `cf.scheduled`, `cf.email`, `cf.tail`, `cf.alarm` | Trigger the matching Worker (or Durable Object alarm) surface directly. | Recommended |
+| `worker`, `queue`, `scheduled`, `email`, `tail`, `alarm` | Direct helper modules behind the unified `cf` API. | Advanced |
 | `createOfflineEnv`, `createOfflineBindings`, `describeOfflineSupport`, `getOfflineSupportMatrix` | Pure config-derived binding fixtures without runtime startup. | Recommended for offline-first unit tests |
 | `createMockKV`, `createMockD1`, `createMockR2`, `createMockQueue`, `createMockEnv` | Small pure unit tests without Miniflare. | Recommended when runtime dispatch is irrelevant |
 | `createMockRateLimit`, `createMockVersionMetadata`, `createMockWorkerLoader`, `createMockSecretsStoreSecret` | Pure fixture for one platform-shaped binding. | Recommended |
@@ -4758,12 +4761,13 @@ The `devflare/test` entrypoint intentionally has multiple lanes: runtime-shaped
 | --- | --- |
 | `createTestContext` | Boot the nearest Devflare config in the test harness. |
 | `env` | Read bindings and call `env.dispose()` in harness tests. |
-| `cf` | Unified Worker, queue, scheduled, email, and tail trigger API. |
+| `cf` | Unified Worker, queue, scheduled, email, tail, and DO alarm trigger API. |
 | `worker` | Direct Worker fetch helper behind `cf.worker`. |
 | `queue` | Direct queue helper behind `cf.queue`. |
 | `scheduled` | Direct scheduled helper behind `cf.scheduled`. |
 | `email` | Direct email helper behind `cf.email`. |
 | `tail` | Direct tail helper behind `cf.tail`. |
+| `alarm` | Direct Durable Object alarm helper behind `cf.alarm`. |
 | `shouldSkip` | Skip Cloudflare-auth, paid, remote, or local engine tests explicitly. |
 | `containers` | Default Docker/Podman-backed container manager. |
 | `createContainerManager` | Create an isolated container manager for tests. |
@@ -4794,6 +4798,8 @@ The `devflare/test` entrypoint intentionally has multiple lanes: runtime-shaped
 | `createMockStreamBinding` | Mock a Stream binding. |
 | `createMockFlagshipBinding` | Mock a Flagship feature-flag binding. |
 | `createMockArtifacts` | Mock Artifacts repo APIs. |
+| `createMockVectorize` | Mock a Vectorize index (in-memory cosine query). |
+| `createMockAnalyticsEngine` | Mock an Analytics Engine dataset (write-only recording stub). |
 | `createMockSecretsStoreSecret` | Mock a Secrets Store secret. |
 | `createMockEnv` | Create a pure env with selected mock bindings. |
 | `hasServiceBindings` | Advanced/internal service-binding resolution predicate. |
@@ -9921,7 +9927,7 @@ describe.skipIf(skipVectorize)('Vectorize binding', () => {
 
 - Use `shouldSkip.vectorize` so missing remote prerequisites are explicit instead of noisy.
 - Keep the vector size and index name close to the test so the contract remains visible.
-- If the surrounding app only needs a demo path locally, mock above the worker boundary instead of pretending the remote index was exercised.
+- For app-level paths, `createMockVectorize()` (or `createMockEnv({ vectorize })` / `createOfflineEnv()`) is a deterministic in-memory index: `insert`/`upsert`/`delete`/`getByIds` plus a real cosine-ranked `query()` honoring `topK`, `returnValues`, `returnMetadata`, `namespace`, and metadata `filter`. It models the binding shape and ranking math, not Cloudflare’s hosted indexing/relevance/scale — use the remote smoke test for those.
 
 #### When to move beyond the default harness
 
@@ -10821,7 +10827,7 @@ Use Cloudflare when analytics delivery itself is a release-critical guarantee. T
 
 ##### Key points
 
-- The repo does not show a dedicated analytics helper surface comparable to `cf.queue.trigger()` or `env.DB.prepare()`.
+- For app-level tests, `createMockAnalyticsEngine()` (or `createMockEnv({ analyticsEngine })` / `createOfflineEnv()`) is a write-only recording stub: it records every `writeDataPoint()` into `.writtenDataPoints` so you can assert what the worker emitted. Analytics Engine has no in-worker read API, so the stub records writes — it does not query.
 - Preview-scoped dataset names can be materialized, but Devflare does not provision or delete datasets because Analytics Engine creates them on first write.
 - Tests should focus on event-producing behavior rather than pretending you need a full local analytics backend.
 
@@ -10966,17 +10972,16 @@ If you later need stronger end-to-end confidence, add a higher-level integration
 
 ```ts
 import { expect, test } from 'bun:test'
-
-const writes: unknown[] = []
-const analytics = {
-	writeDataPoint(point: unknown) {
-		writes.push(point)
-	}
-}
+import { createMockAnalyticsEngine } from 'devflare/test'
 
 test('records an analytics point', () => {
+	const analytics = createMockAnalyticsEngine()
+
 	analytics.writeDataPoint({ indexes: ['search'], blobs: ['devflare'] })
-	expect(writes).toHaveLength(1)
+
+	expect(analytics.writtenDataPoints).toEqual([
+		{ indexes: ['search'], blobs: ['devflare'] }
+	])
 })
 ```
 

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

package/dist/test/alarm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alarm.d.ts","sourceRoot":"","sources":["../../src/test/alarm.ts"],"names":[],"mappings":"AAqBA;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAA;IACvC,KAAK,CAAC,EAAE,kBAAkB,CAAA;IAC1B,GAAG,CAAC,EAAE,kBAAkB,CAAA;IACxB,GAAG,CAAC,EAAE,OAAO,CAAA;CACb;AAED,MAAM,WAAW,mBAAmB;IACnC;;;OAGG;IACH,KAAK,CAAC,EAAE,kBAAkB,CAAA;IAC1B;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAA;CACb;AAED,MAAM,WAAW,kBAAkB;IAClC,wDAAwD;IACxD,OAAO,EAAE,OAAO,CAAA;IAChB,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAA;CACd;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,iBAAe,OAAO,CACrB,MAAM,EAAE,kBAAkB,EAC1B,OAAO,GAAE,mBAAwB,GAC/B,OAAO,CAAC,kBAAkB,CAAC,CAuB7B;AAMD,eAAO,MAAM,KAAK;;CAEjB,CAAA"}

package/dist/test/cf.d.ts

@@ -1,8 +1,10 @@
+export { alarm } from './alarm.js';
 export { email } from './email.js';
 export { queue } from './queue.js';
 export { scheduled } from './scheduled.js';
 export { worker } from './worker.js';
 export { tail } from './tail.js';
+export type { AlarmTriggerTarget, AlarmTriggerOptions, AlarmTriggerResult } from './alarm.js';
 export type { EmailSendOptions, ReceivedEmail, EmailReceiveCallback } from './email.js';
 export type { QueueMessageOptions, QueueTriggerResult } from './queue.js';
 export type { ScheduledTriggerOptions, ScheduledTriggerResult } from './scheduled.js';
@@ -17,6 +19,7 @@ export type { TraceItemOptions, TailTriggerResult } from './tail.js';
  * - `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
@@ -140,5 +143,24 @@ export declare const cf: {
         trigger: (items: Array<import("@cloudflare/workers-types").TraceItem | import("./tail.js").TraceItemOptions>) => Promise<import("./tail.js").TailTriggerResult>;
         create: (options?: import("./tail.js").TraceItemOptions) => import("@cloudflare/workers-types").TraceItem;
     };
+    /**
+     * Durable Object alarm handler testing.
+     *
+     * - `cf.alarm.trigger(instance, options?)` — Fire a DO instance's `alarm()`
+     *   handler under a `durable-object-alarm` event context and assert effects.
+     *
+     * Unlike the other surfaces this operates directly on a Durable Object
+     * instance you construct in the test (it does not resolve a handler file),
+     * mirroring how the Devflare DO wrapper invokes `alarm()` at runtime.
+     *
+     * @example
+     * const counter = new Counter(state, env)
+     * await counter.scheduleAlarm()
+     * const result = await cf.alarm.trigger(counter)
+     * expect(result.success).toBe(true)
+     */
+    alarm: {
+        trigger: (target: import("./alarm.js").AlarmTriggerTarget, options?: import("./alarm.js").AlarmTriggerOptions) => Promise<import("./alarm.js").AlarmTriggerResult>;
+    };
 };
 //# sourceMappingURL=cf.d.ts.map

package/dist/test/cf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cf.d.ts","sourceRoot":"","sources":["../../src/test/cf.ts"],"names":[],"mappings":"AAiCA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAG7B,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AACpF,YAAY,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AACtE,YAAY,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAClF,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAClD,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,EAAE;IACd;;;;;;;;;;;OAWG;;;;;;;IAGH;;;;;;;OAOG;;;;;IAGH;;;;;;;;;OASG;;;;IAGH;;;;;;;;;;;;OAYG;;;;;;;;;IAGH;;;;;;;;OAQG;;;;;CAEH,CAAA"}
+{"version":3,"file":"cf.d.ts","sourceRoot":"","sources":["../../src/test/cf.ts"],"names":[],"mappings":"AAkCA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAG7B,YAAY,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAC1F,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AACpF,YAAY,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AACtE,YAAY,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAClF,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAClD,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,EAAE;IACd;;;;;;;;;;;OAWG;;;;;;;IAGH;;;;;;;OAOG;;;;;IAGH;;;;;;;;;OASG;;;;IAGH;;;;;;;;;;;;OAYG;;;;;;;;;IAGH;;;;;;;;OAQG;;;;;IAGH;;;;;;;;;;;;;;;OAeG;;;;CAEH,CAAA"}

package/dist/test/index.d.ts

@@ -1,10 +1,12 @@
 export { createTestContext, env, type DevflareEnv, type TestEnv } from './simple-context.js';
 export { cf } from './cf.js';
+export { alarm } from './alarm.js';
 export { email } from './email.js';
 export { queue } from './queue.js';
 export { scheduled } from './scheduled.js';
 export { worker } from './worker.js';
 export { tail } from './tail.js';
+export type { AlarmTriggerTarget, AlarmTriggerOptions, AlarmTriggerResult } from './alarm.js';
 export type { EmailSendOptions, ReceivedEmail, EmailReceiveCallback } from './email.js';
 export type { QueueMessageOptions, QueueTriggerResult } from './queue.js';
 export type { ScheduledTriggerOptions, ScheduledTriggerResult } from './scheduled.js';
@@ -15,5 +17,5 @@ export { shouldSkip } from './should-skip.js';
 export { containers, createContainerManager, detectContainerEngine, getContainerSkipReason, stopActiveContainers, type ContainerCommandResult, type ContainerCommandRunner, type ContainerEngineCheck, type ContainerEngineName, type ContainerEnginePreference, type ContainerEngineStatus, type ContainerManager, type ContainerManagerOptions, type DevflareContainerInstance, type LocalContainerState, type StartContainerOptions } from './containers.js';
 export { createOfflineBindings, createOfflineEnv, describeOfflineSupport, getOfflineSupportMatrix, type OfflineBindingFixtures, type OfflineBindingsResult, type OfflineMissingFixture, type OfflineRemoteBoundary, type OfflineSupportEntry, type OfflineSupportTier } from './offline-bindings.js';
 export { createMockAISearchInstance, createMockAISearchNamespace, type MockAISearchInstance, type MockAISearchInstanceOptions, type MockAISearchItemFixture, type MockAISearchNamespace, type MockAISearchNamespaceOptions } from './ai-search.js';
-export { createMockTestContext, createMockKV, createMockD1, createMockR2, createMockQueue, createMockRateLimit, createMockVersionMetadata, createMockHyperdrive, createMockWorkerLoader, createMockMTLSCertificate, createMockDispatchNamespace, createMockWorkflow, createMockPipeline, createMockImagesBinding, createMockMediaBinding, createMockStreamBinding, createMockFlagshipBinding, createMockArtifacts, createMockSecretsStoreSecret, createMockEnv, withTestContext, type TestContext, type TestContextOptions, type MockEnvOptions, type MockRateLimitOptions, type MockWorkerLoaderOptions, type MockFetchInput, type MockFetcherHandler, type MockDispatchNamespaceOptions, type MockWorkflowOptions, type MockWorkflowInstanceOptions, type MockPipeline, type MockImagesBindingOptions, type MockMediaBindingOptions, type MockStreamBindingOptions, type MockFlagshipBindingOptions, type MockArtifactsOptions } from './utilities.js';
+export { createMockTestContext, createMockKV, createMockD1, createMockR2, createMockQueue, createMockRateLimit, createMockVersionMetadata, createMockHyperdrive, createMockWorkerLoader, createMockMTLSCertificate, createMockDispatchNamespace, createMockWorkflow, createMockPipeline, createMockImagesBinding, createMockMediaBinding, createMockStreamBinding, createMockFlagshipBinding, createMockArtifacts, createMockVectorize, createMockAnalyticsEngine, createMockSecretsStoreSecret, createMockEnv, withTestContext, type TestContext, type TestContextOptions, type MockEnvOptions, type MockRateLimitOptions, type MockWorkerLoaderOptions, type MockFetchInput, type MockFetcherHandler, type MockDispatchNamespaceOptions, type MockWorkflowOptions, type MockWorkflowInstanceOptions, type MockPipeline, type MockImagesBindingOptions, type MockMediaBindingOptions, type MockStreamBindingOptions, type MockFlagshipBindingOptions, type MockArtifactsOptions, type MockVectorizeOptions, type MockVectorizeIndex, type MockAnalyticsEngineDataset } from './utilities.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/test/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACN,iBAAiB,EACjB,GAAG,EACH,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,EAAE,EAAE,MAAM,MAAM,CAAA;AACzB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAG7B,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AACpF,YAAY,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AACtE,YAAY,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAClF,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAClD,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAGjE,OAAO,EACN,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAG1C,OAAO,EACN,UAAU,EACV,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,qBAAqB,EACrB,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EACN,0BAA0B,EAC1B,2BAA2B,EAC3B,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAChC,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,4BAA4B,EACjC,MAAM,aAAa,CAAA;AAGpB,OAAO,EACN,qBAAqB,EACrB,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,mBAAmB,EACnB,yBAAyB,EACzB,oBAAoB,EACpB,sBAAsB,EACtB,yBAAyB,EACzB,2BAA2B,EAC3B,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,yBAAyB,EACzB,mBAAmB,EACnB,4BAA4B,EAC5B,aAAa,EACb,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,4BAA4B,EACjC,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAChC,KAAK,YAAY,EACjB,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EACzB,MAAM,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"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"}

package/dist/test/index.js

@@ -4,7 +4,7 @@ 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";
@@ -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
@@ -3493,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.
@@ -3503,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
@@ -3553,7 +3817,8 @@ const cf = {
 	queue,
 	scheduled,
 	worker,
-	tail
+	tail,
+	alarm
 };
 //#endregion
 //#region src/test/should-skip.ts
@@ -4246,6 +4511,18 @@ function createMockAISearchNamespace(options = {}) {
 //#endregion
 //#region src/test/offline-bindings.ts
 const SUPPORT_MATRIX = {
+	durableObjects: {
+		service: "durableObjects",
+		tier: "offline-native",
+		reason: "Miniflare executes Durable Object classes locally, so createTestContext() runs them fully offline. There is no pure in-memory createMockEnv() mock for a DO (a real instance needs the Miniflare runtime).",
+		recommendation: "Use createTestContext() (Miniflare-backed) to run Durable Objects locally; there is no standalone createMockEnv() DO fixture."
+	},
+	services: {
+		service: "services",
+		tier: "offline-native",
+		reason: "Miniflare resolves service bindings worker-to-worker locally, so createTestContext() runs them fully offline. There is no pure in-memory createMockEnv() mock (a real service binding needs the Miniflare runtime to wire the target Worker).",
+		recommendation: "Use createTestContext() (Miniflare-backed) for worker-to-worker service bindings; there is no standalone createMockEnv() service fixture."
+	},
 	rateLimits: {
 		service: "rateLimits",
 		tier: "offline-native",
@@ -4368,9 +4645,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",
@@ -4439,6 +4722,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";
 }
@@ -4456,6 +4742,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();
 }
@@ -4567,55 +4874,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 = {};
@@ -4624,6 +4923,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);
@@ -4653,14 +4958,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 };

package/dist/test/offline-bindings.d.ts

@@ -1,7 +1,7 @@
 import type { Pipeline } from 'cloudflare:pipelines';
 import { type DevflareConfig } from '../config/index.js';
 import { type MockAISearchInstanceOptions, type MockAISearchNamespaceOptions } from './ai-search.js';
-import { type MockArtifactsOptions, type MockDispatchNamespaceOptions, type MockFetcherHandler, type MockFlagshipBindingOptions, type MockImagesBindingOptions, type MockMediaBindingOptions, type MockStreamBindingOptions, type MockWorkerLoaderOptions, type MockWorkflowOptions } from './utilities.js';
+import { type MockArtifactsOptions, type MockDispatchNamespaceOptions, type MockFetcherHandler, type MockFlagshipBindingOptions, type MockImagesBindingOptions, type MockMediaBindingOptions, type MockStreamBindingOptions, type MockVectorizeOptions, type MockWorkerLoaderOptions, type MockWorkflowOptions } from './utilities.js';
 export type OfflineSupportTier = 'offline-native' | 'offline-fixture' | 'remote-boundary';
 export interface OfflineSupportEntry {
     service: string;
@@ -21,6 +21,36 @@ export interface OfflineMissingFixture {
     reason: string;
 }
 export interface OfflineBindingFixtures {
+    /**
+     * Explicit KV namespace bindings. Any KV binding in config without an entry
+     * here is auto-created with `createMockKV()`.
+     */
+    kv?: Record<string, KVNamespace>;
+    /**
+     * Explicit D1 database bindings. Any D1 binding in config without an entry
+     * here is auto-created with `createMockD1()`.
+     */
+    d1?: Record<string, D1Database>;
+    /**
+     * Explicit R2 bucket bindings. Any R2 binding in config without an entry here
+     * is auto-created with `createMockR2()`.
+     */
+    r2?: Record<string, R2Bucket>;
+    /**
+     * Explicit queue-producer bindings. Any queue producer in config without an
+     * entry here is auto-created with `createMockQueue()`.
+     */
+    queues?: Record<string, Queue>;
+    /**
+     * Vectorize index bindings. Any vectorize binding in config without an entry
+     * here is auto-created with `createMockVectorize()`.
+     */
+    vectorize?: Record<string, MockVectorizeOptions | VectorizeIndex>;
+    /**
+     * Analytics Engine dataset bindings. Any analyticsEngine binding in config
+     * without an entry here is auto-created with `createMockAnalyticsEngine()`.
+     */
+    analyticsEngine?: Record<string, AnalyticsEngineDataset>;
     secretsStore?: Record<string, string>;
     workerLoaders?: Record<string, MockWorkerLoaderOptions>;
     mtlsCertificates?: Record<string, MockFetcherHandler>;
@@ -58,25 +88,27 @@ export declare function describeOfflineSupport(service: string): OfflineSupportE
 /**
  * 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.
  */
 export declare function createOfflineBindings(config: OfflineConfig, fixtures?: OfflineBindingFixtures, options?: OfflineBindingOptions): OfflineBindingsResult;
 /**
  * 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.
  */
 export declare function createOfflineEnv(config: OfflineConfig, fixtures?: OfflineBindingFixtures, options?: OfflineBindingOptions): Record<string, unknown>;
 export {};

package/dist/test/offline-bindings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"offline-bindings.d.ts","sourceRoot":"","sources":["../../src/test/offline-bindings.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"offline-bindings.d.ts","sourceRoot":"","sources":["../../src/test/offline-bindings.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,KAAK,cAAc,EAA8B,MAAM,WAAW,CAAA;AAE3E,OAAO,EACN,KAAK,2BAA2B,EAChC,KAAK,4BAA4B,EAGjC,MAAM,aAAa,CAAA;AACpB,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,4BAA4B,EACjC,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EAqBxB,MAAM,aAAa,CAAA;AAEpB,MAAM,MAAM,kBAAkB,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,iBAAiB,CAAA;AAEzF,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,kBAAkB,CAAA;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,qBAAqB;IACrC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,qBAAqB;IACrC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,sBAAsB;IACtC;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IAChC;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IAC/B;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAC7B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC9B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc,CAAC,CAAA;IACjE;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACrC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAA;IACvD,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;IACrD,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAA;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,GAAG,QAAQ,CAAC,CAAA;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,GAAG,aAAa,CAAC,CAAA;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,GAAG,YAAY,CAAC,CAAA;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,GAAG,aAAa,CAAC,CAAA;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,0BAA0B,GAAG,QAAQ,CAAC,CAAA;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,GAAG,SAAS,CAAC,CAAA;IAC5D,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,2BAA2B,GAAG,gBAAgB,CAAC,CAAA;IACzE,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,4BAA4B,GAAG,iBAAiB,CAAC,CAAA;IACrF,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,CAAA;CAChD;AAED,MAAM,WAAW,qBAAqB;IACrC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;IAC5C,gBAAgB,EAAE,qBAAqB,EAAE,CAAA;IACzC,eAAe,EAAE,qBAAqB,EAAE,CAAA;CACxC;AAED,MAAM,WAAW,qBAAqB;IACrC,8DAA8D;IAC9D,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,kEAAkE;IAClE,eAAe,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,KAAK,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC,GAAG;IAC9C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,QAAQ,CAAC,EAAE,cAAc,CAAC,UAAU,CAAC,CAAA;CACrC,CAAA;AA8ND,wBAAgB,uBAAuB,IAAI,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAI7E;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,CAa3E;AAqbD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,aAAa,EACrB,QAAQ,GAAE,sBAA2B,EACrC,OAAO,GAAE,qBAA0B,GACjC,qBAAqB,CA8CvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,aAAa,EACrB,QAAQ,GAAE,sBAA2B,EACrC,OAAO,GAAE,qBAA0B,GACjC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzB"}

package/dist/test/utilities/analytics-engine.d.ts

@@ -0,0 +1,22 @@
+export type MockAnalyticsEngineDataset = AnalyticsEngineDataset & {
+    /** Every data point passed to `writeDataPoint()`, in call order. */
+    readonly writtenDataPoints: AnalyticsEngineDataPoint[];
+    /** Alias for {@link writtenDataPoints} (parity with other record-only mocks). */
+    readonly points: AnalyticsEngineDataPoint[];
+    /** Clear the recorded data points. */
+    clear(): void;
+};
+/**
+ * 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'] }
+ * ])
+ * ```
+ */
+export declare function createMockAnalyticsEngine(): MockAnalyticsEngineDataset;
+//# sourceMappingURL=analytics-engine.d.ts.map

package/dist/test/utilities/analytics-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytics-engine.d.ts","sourceRoot":"","sources":["../../../src/test/utilities/analytics-engine.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,0BAA0B,GAAG,sBAAsB,GAAG;IACjE,oEAAoE;IACpE,QAAQ,CAAC,iBAAiB,EAAE,wBAAwB,EAAE,CAAA;IACtD,iFAAiF;IACjF,QAAQ,CAAC,MAAM,EAAE,wBAAwB,EAAE,CAAA;IAC3C,sCAAsC;IACtC,KAAK,IAAI,IAAI,CAAA;CACb,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,IAAI,0BAA0B,CAmBtE"}

package/dist/test/utilities/env.d.ts

@@ -1,6 +1,7 @@
 import type { Pipeline } from 'cloudflare:pipelines';
 import { type MockArtifactsOptions } from './artifacts.js';
 import { type MockDispatchNamespaceOptions, type MockFetcherHandler, type MockRateLimitOptions, type MockWorkerLoaderOptions } from './platform.js';
+import { type MockVectorizeOptions } from './vectorize.js';
 import { type MockWorkflowOptions } from './workflows.js';
 export interface MockEnvOptions {
     kv?: string[];
@@ -18,6 +19,8 @@ export interface MockEnvOptions {
     images?: string | ImagesBinding;
     media?: string | MediaBinding;
     artifacts?: string[] | Record<string, MockArtifactsOptions | Artifacts>;
+    vectorize?: string[] | Record<string, MockVectorizeOptions | VectorizeIndex>;
+    analyticsEngine?: string[];
     secretsStore?: Record<string, string>;
     durableObjects?: string[];
     vars?: Record<string, string>;

package/dist/test/utilities/env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/test/utilities/env.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,KAAK,oBAAoB,EAA2C,MAAM,aAAa,CAAA;AAIhG,OAAO,EACN,KAAK,4BAA4B,EACjC,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAQ5B,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,KAAK,mBAAmB,EAA0C,MAAM,aAAa,CAAA;AAE9F,MAAM,WAAW,cAAc;IAC9B,EAAE,CAAC,EAAE,MAAM,EAAE,CAAA;IACb,EAAE,CAAC,EAAE,MAAM,EAAE,CAAA;IACb,EAAE,CAAC,EAAE,MAAM,EAAE,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;IACjD,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,CAAA;IAChD,aAAa,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAA;IAClE,gBAAgB,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;IAChE,kBAAkB,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAA;IAC5E,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,mBAAmB,GAAG,QAAQ,CAAC,CAAA;IACrE,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAC/C,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,CAAA;IAC/B,KAAK,CAAC,EAAE,MAAM,GAAG,YAAY,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,GAAG,SAAS,CAAC,CAAA;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACrC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAChC;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA4JnF"}
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/test/utilities/env.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAEpD,OAAO,EAAE,KAAK,oBAAoB,EAA2C,MAAM,aAAa,CAAA;AAIhG,OAAO,EACN,KAAK,4BAA4B,EACjC,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAQ5B,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,KAAK,oBAAoB,EAAuB,MAAM,aAAa,CAAA;AAC5E,OAAO,EAAE,KAAK,mBAAmB,EAA0C,MAAM,aAAa,CAAA;AAE9F,MAAM,WAAW,cAAc;IAC9B,EAAE,CAAC,EAAE,MAAM,EAAE,CAAA;IACb,EAAE,CAAC,EAAE,MAAM,EAAE,CAAA;IACb,EAAE,CAAC,EAAE,MAAM,EAAE,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;IACjD,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,CAAA;IAChD,aAAa,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAA;IAClE,gBAAgB,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;IAChE,kBAAkB,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAA;IAC5E,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,mBAAmB,GAAG,QAAQ,CAAC,CAAA;IACrE,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAC/C,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,CAAA;IAC/B,KAAK,CAAC,EAAE,MAAM,GAAG,YAAY,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,GAAG,SAAS,CAAC,CAAA;IACvE,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc,CAAC,CAAA;IAC5E,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACrC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAChC;AAoCD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkKnF"}

package/dist/test/utilities/vectorize.d.ts

@@ -0,0 +1,38 @@
+export interface MockVectorizeOptions {
+    /** Index name reported by `describe()` (default `mock-vectorize`). */
+    name?: string;
+    /** Distance metric reported by `describe()` (default `cosine`). */
+    metric?: VectorizeDistanceMetric;
+    /**
+     * Dimensions reported by `describe()`. When omitted it is inferred from the
+     * first inserted/seeded vector; before any vector exists `describe()` reports
+     * `0`.
+     */
+    dimensions?: number;
+    /** Vectors seeded into the index up front. */
+    vectors?: VectorizeVector[];
+}
+export type MockVectorizeIndex = VectorizeIndex & {
+    /** Inspect every stored vector (test helper). */
+    _getVectors(): VectorizeVector[];
+    /**
+     * Delete vectors by id. Convenience alias for `deleteByIds` so tests can call
+     * the same verb as KV/R2 mocks.
+     */
+    delete(ids: string[]): Promise<VectorizeVectorMutation>;
+};
+/**
+ * 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'
+ * ```
+ */
+export declare function createMockVectorize(options?: MockVectorizeOptions): MockVectorizeIndex;
+//# sourceMappingURL=vectorize.d.ts.map

package/dist/test/utilities/vectorize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectorize.d.ts","sourceRoot":"","sources":["../../../src/test/utilities/vectorize.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,oBAAoB;IACpC,sEAAsE;IACtE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,mEAAmE;IACnE,MAAM,CAAC,EAAE,uBAAuB,CAAA;IAChC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,eAAe,EAAE,CAAA;CAC3B;AAED,MAAM,MAAM,kBAAkB,GAAG,cAAc,GAAG;IACjD,iDAAiD;IACjD,WAAW,IAAI,eAAe,EAAE,CAAA;IAChC;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAA;CACvD,CAAA;AA6HD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,oBAAyB,GAAG,kBAAkB,CAkI1F"}

package/dist/test/utilities.d.ts

@@ -8,5 +8,7 @@ export * from './utilities/workflows.js';
 export * from './utilities/media.js';
 export * from './utilities/stream-flagship.js';
 export * from './utilities/artifacts.js';
+export * from './utilities/vectorize.js';
+export * from './utilities/analytics-engine.js';
 export * from './utilities/env.js';
 //# sourceMappingURL=utilities.d.ts.map

package/dist/test/utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/test/utilities.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,mBAAmB,CAAA;AACjC,cAAc,sBAAsB,CAAA;AACpC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mBAAmB,CAAA;AACjC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/test/utilities.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,mBAAmB,CAAA;AACjC,cAAc,sBAAsB,CAAA;AACpC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mBAAmB,CAAA;AACjC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,uBAAuB,CAAA;AACrC,cAAc,uBAAuB,CAAA;AACrC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,iBAAiB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "devflare",
-	"version": "1.0.0-next.45",
+	"version": "1.0.0-next.47",
 	"description": "Devflare is a developer-first toolkit for Cloudflare Workers that sits on top of Miniflare and Wrangler-compatible config",
 	"repository": {
 		"type": "git",