@lostgradient/weft 0.16.0 → 0.17.0

package/dist/server/operations/set-workflow-attributes.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
 import { readRestJsonBody } from "../rest-body.js";
-import { isOperationFault, shapeRestFault } from "./operation-helpers.js";
+import { isOperationFault } from "./operation-helpers.js";
 const setWorkflowAttributesInput = z.object({
   workflowId: z.string().min(1),
   attributes: z.unknown().optional()
@@ -32,17 +32,7 @@ export const setWorkflowAttributesOperation = defineOperation({
       };
     }
   }
-});
-function shapeSetWorkflowAttributesSuccess(output) {
-  return new Response(JSON.stringify(output), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-function shapeSetWorkflowAttributesFault(fault) {
-  return shapeRestFault(fault);
-}
-export const setWorkflowAttributesRestBinding = {
+}), setWorkflowAttributesRestBinding = {
   method: "PATCH",
   path: "/v1/workflows/:id/attributes",
   pathParamNames: ["id"],
@@ -64,7 +54,5 @@ export const setWorkflowAttributesRestBinding = {
       attributes: typeof body === "object" ? body.attributes : void 0
     };
   },
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeSetWorkflowAttributesSuccess(output),
-  shapeFault: shapeSetWorkflowAttributesFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/signal-workflow.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { isSignalIdWithinByteLimit } from "../../core/signal-id.js";
 import { readRestJsonBody } from "../rest-body.js";
-import { isOperationFault, shapeRestFault } from "./operation-helpers.js";
+import { isOperationFault } from "./operation-helpers.js";
 import {
   createSingleWorkflowControlOperation,
   extractWorkflowIdFromPath
@@ -27,14 +27,7 @@ export const signalWorkflowOperation = createSingleWorkflowControlOperation({
     await engine.signal(input.workflowId, input.signalName, input.payload, input.signalId === void 0 ? void 0 : { signalId: input.signalId });
     return { ok: !0 };
   }
-});
-function shapeSignalWorkflowSuccess(output) {
-  return new Response(JSON.stringify(output), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-export const signalWorkflowRestBinding = {
+}), signalWorkflowRestBinding = {
   method: "POST",
   path: "/v1/workflows/:id/signal/:name",
   pathParamNames: ["id", "name"],
@@ -57,7 +50,5 @@ export const signalWorkflowRestBinding = {
       ...signalId === void 0 ? {} : { signalId }
     };
   },
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeSignalWorkflowSuccess(output),
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/single-workflow-tag-mutation.js

@@ -66,16 +66,9 @@ export function createSingleWorkflowTagMutationRestBinding(configuration) {
       };
     },
     success: { kind: "json", status: 200 },
-    shapeSuccess: shapeSingleWorkflowTagMutationSuccess,
     shapeFault: shapeSingleWorkflowTagMutationFault
   };
 }
-function shapeSingleWorkflowTagMutationSuccess(output) {
-  return new Response(JSON.stringify(output), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}
 function shapeSingleWorkflowTagMutationFault(fault) {
   if (fault.code === "Unprocessable")
     return shapeRestFault(fault, { status: 400 });

package/dist/server/operations/start-or-signal-workflow.js

@@ -9,7 +9,7 @@ import { runtimeWorkflowEngine } from "../../core/runtime-workflow-engine.js";
 import { isSignalIdWithinByteLimit } from "../../core/signal-id.js";
 import { StartWorkflowValidationError } from "../../core/start-workflow-validation.js";
 import { defineOperation } from "../operation-registry.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { invalidParamsFault } from "./operation-helpers.js";
 import { buildStartOrSignalWorkflowOptions } from "./start-workflow-options.js";
 import {
   extractSharedStartWorkflowRestFields,
@@ -136,6 +136,5 @@ export const startOrSignalWorkflowOperation = defineOperation({
       onTerminalConflict: record.onTerminalConflict
     };
   },
-  success: { kind: "json", status: 201 },
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 201 }
 };

package/dist/server/operations/start-workflow.js

@@ -7,7 +7,7 @@ import {
 import { runtimeWorkflowEngine } from "../../core/runtime-workflow-engine.js";
 import { StartWorkflowValidationError } from "../../core/start-workflow-validation.js";
 import { defineOperation } from "../operation-registry.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { invalidParamsFault } from "./operation-helpers.js";
 import { buildSharedStartWorkflowOptions } from "./start-workflow-options.js";
 import {
   extractSharedStartWorkflowRestFields,
@@ -99,6 +99,5 @@ export const startWorkflowOperation = defineOperation({
   extractInput: async (request, _pathParams, context) => {
     return extractSharedStartWorkflowRestFields(await parseStartWorkflowRequestRecord(request, context));
   },
-  success: { kind: "json", status: 201 },
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 201 }
 };

package/dist/server/operations/storage-capabilities.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { shapeRestFault } from "./operation-helpers.js";
 const storageCapabilitiesInput = z.object({}), storageCapabilitiesOutput = z.object({
   persistence: z.enum(["ephemeral", "local", "remote"]),
   readAfterWrite: z.enum(["linearizable", "session", "eventual"]),
@@ -33,6 +32,5 @@ export const storageCapabilitiesOperation = defineOperation({
   inputSources: {},
   extractInput: async () => ({}),
   success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => Response.json(output),
-  shapeFault: shapeRestFault
+  shapeSuccess: (output) => Response.json(output)
 };

package/dist/server/operations/storage.js

@@ -11,7 +11,7 @@ import { raiseFault } from "../operation-catalog.js";
 import { defineOperation } from "../operation-registry.js";
 import { isAuthenticated } from "../principal.js";
 import { readRestBodyBounded, readRestJsonBody } from "../rest-body.js";
-import { invalidParamsFault, isOperationFault, shapeRestFault } from "./operation-helpers.js";
+import { invalidParamsFault, isOperationFault } from "./operation-helpers.js";
 const rawStorageAccess = {
   kind: "scoped",
   scopes: { kind: "anyOf", scopes: ["storage:admin"] }
@@ -283,8 +283,7 @@ export const storageGetOperation = defineOperation({
   },
   extractInput: async (_request, pathParams) => ({ key: storageKeyFromPath(pathParams) }),
   success: { kind: "streaming", mediaType: "application/octet-stream" },
-  shapeSuccess: (output) => createBinaryResponse(output),
-  shapeFault: shapeRestFault
+  shapeSuccess: (output) => createBinaryResponse(output)
 }, storagePutRestBinding = {
   method: "PUT",
   path: "/v1/storage/:key",
@@ -299,8 +298,7 @@ export const storageGetOperation = defineOperation({
     value: await readRestBodyBounded(request, context)
   }),
   success: { kind: "empty", status: 204 },
-  shapeSuccess: createNoContentResponse,
-  shapeFault: shapeRestFault
+  shapeSuccess: createNoContentResponse
 }, storageDeleteRestBinding = {
   method: "DELETE",
   path: "/v1/storage/:key",
@@ -311,8 +309,7 @@ export const storageGetOperation = defineOperation({
   },
   extractInput: async (_request, pathParams) => ({ key: storageKeyFromPath(pathParams) }),
   success: { kind: "empty", status: 204 },
-  shapeSuccess: createNoContentResponse,
-  shapeFault: shapeRestFault
+  shapeSuccess: createNoContentResponse
 }, storageScanRestBinding = {
   method: "GET",
   path: "/v1/storage",
@@ -329,8 +326,7 @@ export const storageGetOperation = defineOperation({
   },
   extractInput: async (request) => extractStorageScanInput(request),
   success: { kind: "streaming", mediaType: "application/x-ndjson" },
-  shapeSuccess: (output) => createNdjsonResponse(output),
-  shapeFault: shapeRestFault
+  shapeSuccess: (output) => createNdjsonResponse(output)
 }, storageBatchRestBinding = {
   method: "POST",
   path: "/v1/storage/-/batch",
@@ -341,8 +337,7 @@ export const storageGetOperation = defineOperation({
   },
   extractInput: async (request, _pathParams, context) => readJsonRequestBody(request, context),
   success: { kind: "empty", status: 204 },
-  shapeSuccess: createNoContentResponse,
-  shapeFault: shapeRestFault
+  shapeSuccess: createNoContentResponse
 }, storageConditionalBatchRestBinding = {
   method: "POST",
   path: "/v1/storage/-/conditional-batch",
@@ -354,6 +349,5 @@ export const storageGetOperation = defineOperation({
   },
   extractInput: async (request, _pathParams, context) => readJsonRequestBody(request, context),
   success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => Response.json(output),
-  shapeFault: shapeRestFault
+  shapeSuccess: (output) => Response.json(output)
 };

package/dist/server/operations/submit-review-decision.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
 import { readRestJsonBody } from "../rest-body.js";
-import { isOperationFault, shapeRestFault } from "./operation-helpers.js";
+import { isOperationFault } from "./operation-helpers.js";
 const VALID_DECISIONS = [
   "approved",
   "rejected",
@@ -92,14 +92,7 @@ export const submitReviewDecisionOperation = defineOperation({
       mapReviewDecisionError(error, input.reviewId);
     }
   }
-});
-function shapeSubmitReviewDecisionSuccess(output) {
-  return new Response(JSON.stringify(output), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-export const submitReviewDecisionRestBinding = {
+}), submitReviewDecisionRestBinding = {
   method: "POST",
   path: "/v1/reviews/:reviewId/decision",
   pathParamNames: ["reviewId"],
@@ -127,7 +120,5 @@ export const submitReviewDecisionRestBinding = {
       workflowId: record.workflowId
     };
   },
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeSubmitReviewDecisionSuccess(output),
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/suspend-workflow.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { WorkflowSuspendNotSupportedError } from "../../core/engine/errors.js";
-import { shapeRestFault } from "./operation-helpers.js";
 import {
   createSingleWorkflowControlOperation,
   extractWorkflowIdFromPath
@@ -31,6 +30,5 @@ export const suspendWorkflowOperation = createSingleWorkflowControlOperation({
     workflowId: { kind: "path", pathParam: "id" }
   },
   extractInput: async (_request, pathParams) => extractWorkflowIdFromPath(pathParams),
-  success: { kind: "empty", status: 204 },
-  shapeFault: shapeRestFault
+  success: { kind: "empty", status: 204 }
 };

package/dist/server/operations/timeout-workflow.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { shapeRestFault } from "./operation-helpers.js";
 import {
   createSingleWorkflowControlOperation,
   extractWorkflowIdFromPath
@@ -29,6 +28,5 @@ export const timeoutWorkflowOperation = createSingleWorkflowControlOperation({
     workflowId: { kind: "path", pathParam: "id" }
   },
   extractInput: async (_request, pathParams) => extractWorkflowIdFromPath(pathParams),
-  success: { kind: "empty", status: 204 },
-  shapeFault: shapeRestFault
+  success: { kind: "empty", status: 204 }
 };

package/dist/server/operations/update-schedule.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { shapeRestFault } from "./operation-helpers.js";
 import {
   mapScheduleErrorToFault,
   validateScheduleInputCadence,
@@ -62,6 +61,5 @@ export const updateScheduleOperation = defineOperation({
       ...extractSharedScheduleRestFields(record)
     };
   },
-  success: { kind: "empty", status: 204 },
-  shapeFault: shapeRestFault
+  success: { kind: "empty", status: 204 }
 };

package/dist/server/operations/update-workflow.js

@@ -6,7 +6,7 @@ import {
 } from "../../core/updates.js";
 import { defineOperation } from "../operation-registry.js";
 import { readRestJsonBody } from "../rest-body.js";
-import { isOperationFault, shapeRestFault } from "./operation-helpers.js";
+import { isOperationFault } from "./operation-helpers.js";
 const DEFAULT_UPDATE_TIMEOUT_MS = 30000, updateWorkflowInput = z.object({
   workflowId: z.string().min(1),
   updateName: z.string().min(1),
@@ -108,6 +108,5 @@ export const updateWorkflowOperation = defineOperation({
       ...idempotencyKey !== void 0 ? { idempotencyKey } : {}
     };
   },
-  success: { kind: "json", status: 200 },
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/worker-drain.js

@@ -159,7 +159,6 @@ function createWorkerDrainRestBinding(method, operationName) {
       ...method === "POST" ? await readDrainBody(request, context) : {}
     }),
     success: { kind: "json", status: 200 },
-    shapeSuccess: shapeDrainSuccess,
     shapeFault: shapeOperationFaultAsJson
   };
 }
@@ -178,16 +177,9 @@ function createDeploymentDrainRestBinding(method, operationName) {
       ...method === "POST" ? await readDrainBody(request, context) : {}
     }),
     success: { kind: "json", status: 200 },
-    shapeSuccess: shapeDrainSuccess,
     shapeFault: shapeOperationFaultAsJson
   };
 }
-function shapeDrainSuccess(output) {
-  return new Response(JSON.stringify(output), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}
 async function readDrainBody(request, context) {
   const text = await readRestTextBody(request, context);
   if (text.trim().length === 0)

package/dist/server/rest-binding.d.ts

@@ -98,8 +98,9 @@ export type RestBinding<Input, Output> = {
     readonly success: ResponseShape;
     /**
      * Optional override for response construction. When absent, transport
-     * adapters default to `Response.json(output, { status: success.status })`
-     * (or `new Response(null, { status })` for `empty`). Provide this
+     * adapters default to `jsonResponse(output, success.status)`, which emits
+     * `JSON.stringify(output)` with `Content-Type: application/json` (or
+     * `new Response(null, { status })` for `empty`). Provide this
      * when the wire representation differs from `output` verbatim.
      *
      * Receives the original `Request` so REST-only response shaping —

package/dist/server/route-model.d.ts

@@ -34,6 +34,8 @@
  * RFC 9264 / discovery convention.
  */
 export declare const API_PREFIX = "/api";
+/** Root-relative namespace for the functional REST and WebSocket API. */
+export declare const ROOT_API_PREFIX = "/v1";
 /**
  * Map a canonical, root-relative server path to its external (`/api`-prefixed)
  * form for emission in specs and discovery documents.

package/dist/server/route-model.js

@@ -1,4 +1,4 @@
-export const API_PREFIX = "/api";
+export const API_PREFIX = "/api", ROOT_API_PREFIX = "/v1";
 export function externalApiPath(canonicalPath) {
   if (!canonicalPath.startsWith("/"))
     throw Error(`externalApiPath requires a leading slash, received: ${canonicalPath}`);

package/dist/server/runtime/task-reconciliation.d.ts

@@ -1,6 +1,14 @@
 import type { ServeOptions } from '../index.ts';
 import type { InflightRecord, TaskRequeueReason } from '../task-state.ts';
 import type { ServerContext } from './context.ts';
+interface ManualTaskReconciliationForTesting {
+    readonly options: ServeOptions;
+    scanAt(operationId: string, trackedDeadline: number, now: number): Promise<void>;
+}
+/** @internal Restricts manual reconciliation to explicitly marked test options. */
+export declare function useManualTaskReconciliationForTesting(options: ServeOptions): ManualTaskReconciliationForTesting;
+/** @internal Installs the narrow one-shot test controller before a server starts. */
+export declare function consumeManualTaskReconciliationForTesting(options: ServeOptions, context: ServerContext, cleanupWorkflowIndex: (operationId: string) => void): boolean;
 /**
  * Given a persisted inflight record, either permanently fail the task (if
  * retry attempts are exhausted) or transition it back to queued and
@@ -13,5 +21,6 @@ export declare function reassignOrExpireTask(context: ServerContext, options: Se
  * their tasks. Only touches storage for the specific operations whose
  * deadlines have actually passed — no full `op:inflight:*` scan.
  */
-export declare function scanExpiredTasks(context: ServerContext, options: ServeOptions, cleanupWorkflowIndex: (operationId: string) => void): Promise<void>;
+export declare function scanExpiredTasks(context: ServerContext, options: ServeOptions, cleanupWorkflowIndex: (operationId: string) => void, now?: number): Promise<void>;
 export declare function reconcileOrphanedRecords(context: ServerContext, options: ServeOptions, cleanupWorkflowIndex: (operationId: string) => void): Promise<void>;
+export {};

package/dist/server/runtime/task-reconciliation.js

@@ -17,6 +17,30 @@ import {
   recordWorkerCapacitySaturationMetric
 } from "./task-metrics.js";
 import { isInflightRecord } from "./websocket-worker.js";
+const manualTaskReconciliationRegistrations = new WeakMap;
+export function useManualTaskReconciliationForTesting(options) {
+  const registration = {};
+  manualTaskReconciliationRegistrations.set(options, registration);
+  return {
+    options,
+    scanAt(operationId, trackedDeadline, now) {
+      if (registration.scanAt === void 0)
+        throw Error("Manual task reconciliation requires a running test server");
+      return registration.scanAt(operationId, trackedDeadline, now);
+    }
+  };
+}
+export function consumeManualTaskReconciliationForTesting(options, context, cleanupWorkflowIndex) {
+  const registration = manualTaskReconciliationRegistrations.get(options);
+  manualTaskReconciliationRegistrations.delete(options);
+  if (registration === void 0)
+    return !1;
+  registration.scanAt = async (operationId, trackedDeadline, now) => {
+    context.deadlineTracker.add({ operationId, deadline: trackedDeadline });
+    await scanExpiredTasks(context, options, cleanupWorkflowIndex, now);
+  };
+  return !0;
+}
 export async function reassignOrExpireTask(context, options, operationId, record, reason = "visibility-timeout") {
   const nextAttempt = (record.attempt ?? 1) + 1, policy = record.retryPolicy, nextRetryCount = Math.max(record.retryCount ?? 0, nextAttempt - 1);
   if (hasExceededMaxAttempts(policy, nextAttempt)) {
@@ -82,12 +106,12 @@ function scheduleTaskRedispatch(context, options, taskDispatch, policy) {
   } else
     dispatchTaskImpl(context, options, taskDispatch).catch((err) => console.error(`[weft] Redispatch failed for "${taskDispatch.operationId}":`, err));
 }
-export async function scanExpiredTasks(context, options, cleanupWorkflowIndex) {
+export async function scanExpiredTasks(context, options, cleanupWorkflowIndex, now = Date.now()) {
   if (context.scanRunning)
     return;
   context.scanRunning = !0;
   try {
-    const now = Date.now(), expired = context.deadlineTracker.drainExpired(now);
+    const expired = context.deadlineTracker.drainExpired(now);
     for (const { operationId, deadline } of expired) {
       if (context.processingOperations.has(operationId)) {
         context.deadlineTracker.add({ operationId, deadline });

package/dist/server/serve-internals.js

@@ -25,7 +25,11 @@ import {
   registerWorkflowEventLifecycle
 } from "./runtime/event-broadcasting.js";
 import { shutdownAllWorkers } from "./runtime/shutdown.js";
-import { reconcileOrphanedRecords, scanExpiredTasks } from "./runtime/task-reconciliation.js";
+import {
+  consumeManualTaskReconciliationForTesting as consumeManual,
+  reconcileOrphanedRecords,
+  scanExpiredTasks
+} from "./runtime/task-reconciliation.js";
 import { DEFAULT_MAX_STREAM_CONNECTIONS_PER_WORKFLOW } from "./runtime/websocket-stream.js";
 import { isInflightRecord, withRetry } from "./runtime/websocket-worker.js";
 import { TaskQueue } from "./task-queue.js";
@@ -166,14 +170,16 @@ export function registerStackDisposers(stack, context, options, broadcastingHand
   stack.defer(() => context.mcpSessionManager[Symbol.asyncDispose]());
   stack.defer(registerWorkflowEventLifecycle(options.engine, context, broadcastingHandle));
   stack.defer(() => shutdownAllWorkers(context, options.workerShutdownTimeoutMs === void 0 ? void 0 : { timeoutMs: options.workerShutdownTimeoutMs, stopWaitingWhenIdle: !0 }));
-  const visibilityPollHandle = setInterval(() => {
+  const schedulesTaskReconciliation = !consumeManual(options, context, onOperationCleanup), visibilityPollHandle = schedulesTaskReconciliation ? setInterval(() => {
     scanExpiredTasks(context, options, onOperationCleanup);
-  }, context.visibilityPollMs), reconciliationIntervalMs = context.visibilityPollMs * RECONCILIATION_MULTIPLIER, reconciliationHandle = setInterval(() => {
+  }, context.visibilityPollMs) : void 0, reconciliationIntervalMs = context.visibilityPollMs * RECONCILIATION_MULTIPLIER, reconciliationHandle = schedulesTaskReconciliation ? setInterval(() => {
     reconcileOrphanedRecords(context, options, onOperationCleanup);
-  }, reconciliationIntervalMs);
+  }, reconciliationIntervalMs) : void 0;
   stack.defer(() => {
-    clearInterval(visibilityPollHandle);
-    clearInterval(reconciliationHandle);
+    if (visibilityPollHandle !== void 0)
+      clearInterval(visibilityPollHandle);
+    if (reconciliationHandle !== void 0)
+      clearInterval(reconciliationHandle);
     context.deadlineTracker.clear();
     for (const timer of context.pendingTimers)
       clearTimeout(timer);

package/dist/storage/indexeddb.js

@@ -74,6 +74,30 @@ function createCursorRequestAwaiter(request, transaction) {
     });
   };
 }
+async function* iterateCursor(database, keyRangeFactory, prefix, options, openCursor, project) {
+  const { limit, reverse } = options, prefixEnd = resolvePrefixRangeEnd(prefix), range = keyRangeFactory.bound(prefix, prefixEnd, !1, !0), direction = reverse ? "prev" : "next", transaction = database.transaction(STORE_NAME, "readonly"), store = transaction.objectStore(STORE_NAME), request = openCursor(store, range, direction), nextCursor = createCursorRequestAwaiter(request, transaction);
+  let count = 0, completed = !1;
+  try {
+    let cursor = await nextCursor();
+    while (cursor) {
+      if (limit !== void 0 && count >= limit)
+        break;
+      const key = cursor.key;
+      if (matchesScanOptions(key, options)) {
+        yield project(cursor);
+        count++;
+      }
+      cursor.continue();
+      cursor = await nextCursor();
+    }
+    completed = !0;
+  } finally {
+    if (!completed)
+      try {
+        transaction.abort();
+      } catch {}
+  }
+}
 
 export class IndexedDBStorage {
   #databaseName;
@@ -168,30 +192,8 @@ export class IndexedDBStorage {
     });
   }
   async* scan(prefix, options = {}) {
-    const { limit, reverse } = options, database = await this.#databasePromise, prefixEnd = resolvePrefixRangeEnd(prefix), range = this.#runtime.IDBKeyRange.bound(prefix, prefixEnd, !1, !0), direction = reverse ? "prev" : "next", transaction = database.transaction(STORE_NAME, "readonly"), request = transaction.objectStore(STORE_NAME).openCursor(range, direction);
-    let count = 0;
-    const nextCursor = createCursorRequestAwaiter(request, transaction);
-    let completed = !1;
-    try {
-      let cursor = await nextCursor();
-      while (cursor) {
-        if (limit !== void 0 && count >= limit)
-          break;
-        const key = cursor.key;
-        if (matchesScanOptions(key, options)) {
-          yield [key, new Uint8Array(cursor.value)];
-          count++;
-        }
-        cursor.continue();
-        cursor = await nextCursor();
-      }
-      completed = !0;
-    } finally {
-      if (!completed)
-        try {
-          transaction.abort();
-        } catch {}
-    }
+    const database = await this.#databasePromise;
+    yield* iterateCursor(database, this.#runtime.IDBKeyRange, prefix, options, (store, range, direction) => store.openCursor(range, direction), (cursor) => [cursor.key, new Uint8Array(cursor.value)]);
   }
   async batch(operations) {
     assertStorageBatchOperationCount("batch operations", operations.length);
@@ -270,30 +272,8 @@ export class IndexedDBStorage {
     });
   }
   async* keys(prefix, options = {}) {
-    const { limit, reverse } = options, database = await this.#databasePromise, prefixEnd = resolvePrefixRangeEnd(prefix), range = this.#runtime.IDBKeyRange.bound(prefix, prefixEnd, !1, !0), direction = reverse ? "prev" : "next", transaction = database.transaction(STORE_NAME, "readonly"), request = transaction.objectStore(STORE_NAME).openKeyCursor(range, direction);
-    let count = 0;
-    const nextCursor = createCursorRequestAwaiter(request, transaction);
-    let completed = !1;
-    try {
-      let cursor = await nextCursor();
-      while (cursor) {
-        if (limit !== void 0 && count >= limit)
-          break;
-        const key = cursor.key;
-        if (matchesScanOptions(key, options)) {
-          yield key;
-          count++;
-        }
-        cursor.continue();
-        cursor = await nextCursor();
-      }
-      completed = !0;
-    } finally {
-      if (!completed)
-        try {
-          transaction.abort();
-        } catch {}
-    }
+    const database = await this.#databasePromise;
+    yield* iterateCursor(database, this.#runtime.IDBKeyRange, prefix, options, (store, range, direction) => store.openKeyCursor(range, direction), (cursor) => cursor.key);
   }
   async count(prefix) {
     const database = await this.#databasePromise, prefixEnd = resolvePrefixRangeEnd(prefix), store = database.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME);

package/dist/storage/testing.d.ts

@@ -70,6 +70,8 @@ export type ConcurrentConditionalBatchConformanceOptions = {
 export type BinaryAndLargeScanConformanceOptions = {
     /** Construct a fresh, empty adapter for each conformance case. */
     readonly create: () => Storage | Promise<Storage>;
+    /** Optional timeout for adapters whose local large-scan test needs more time. */
+    readonly largeScanTimeoutMs?: number;
 };
 /**
  * Construct a fresh, empty adapter for each basic-contract case.
@@ -151,9 +153,10 @@ export declare function runStorageCapabilityConformance(name: string, options: C
  */
 export declare function runConcurrentConditionalBatchConformance(name: string, options: ConcurrentConditionalBatchConformanceOptions): void;
 /**
- * Register the basic key/value and scan contract that every storage adapter
- * must satisfy: get, put, overwrite, delete, prefix scans, limits, reverse
- * ordering, range bounds, and empty-prefix scans.
+ * Register the complete basic key/value and scan contract that every storage
+ * adapter must satisfy: get, put, overwrite, delete (including missing keys),
+ * prefix scans, limits, reverse ordering, exclusive and inclusive range
+ * bounds, no-match scans, empty-prefix scans, and put/delete batches.
  *
  * @example
  * ```ts