@lostgradient/weft 0.16.0 → 0.18.0

package/dist/server/rest-bindings.js

@@ -1,110 +1,12 @@
 import { createOperationRegistry } from "./operation-catalog.js";
-import {
-  addWorkflowTagsOperation,
-  addWorkflowTagsRestBinding
-} from "./operations/add-workflow-tags.js";
-import {
-  aggregateWorkflowsOperation,
-  aggregateWorkflowsRestBinding
-} from "./operations/aggregate-workflows.js";
-import * as asyncActivity from "./operations/async-activity.js";
-import {
-  bulkCancelWorkflowsOperation,
-  bulkCancelWorkflowsRestBinding
-} from "./operations/bulk-cancel-workflows.js";
-import {
-  bulkDeleteWorkflowsOperation,
-  bulkDeleteWorkflowsRestBinding
-} from "./operations/bulk-delete-workflows.js";
-import {
-  bulkMutateWorkflowTagsOperation,
-  bulkMutateWorkflowTagsRestBinding
-} from "./operations/bulk-mutate-workflow-tags.js";
-import {
-  bulkRetryFailedWorkflowsOperation,
-  bulkRetryFailedWorkflowsRestBinding
-} from "./operations/bulk-retry-failed-workflows.js";
-import {
-  bulkSignalWorkflowsOperation,
-  bulkSignalWorkflowsRestBinding
-} from "./operations/bulk-signal-workflows.js";
-import {
-  cancelScheduleOperation,
-  cancelScheduleRestBinding
-} from "./operations/cancel-schedule.js";
-import {
-  cancelWorkflowOperation,
-  cancelWorkflowRestBinding
-} from "./operations/cancel-workflow.js";
-import {
-  createScheduleOperation,
-  createScheduleRestBinding
-} from "./operations/create-schedule.js";
-import {
-  fleetEventsSseOperation,
-  fleetEventsSseRestBinding
-} from "./operations/fleet-events-sse.js";
-import { fleetEventsSubscriptionOperation } from "./operations/fleet-events-subscription.js";
-import { forkWorkflowOperation, forkWorkflowRestBinding } from "./operations/fork-workflow.js";
-import {
-  getCheckpointAtOperation,
-  getCheckpointAtRestBinding
-} from "./operations/get-checkpoint-at.js";
-import { getRegistryOperation, getRegistryRestBinding } from "./operations/get-registry.js";
-import {
-  getRetentionOverviewOperation,
-  getRetentionOverviewRestBinding
-} from "./operations/get-retention-overview.js";
-import { getReviewOperation, getReviewRestBinding } from "./operations/get-review.js";
-import { getScheduleOperation, getScheduleRestBinding } from "./operations/get-schedule.js";
-import {
-  getStreamChunksOperation,
-  getStreamChunksRestBinding
-} from "./operations/get-stream-chunks.js";
-import {
-  getSystemLeaseOperation,
-  getSystemLeaseRestBinding
-} from "./operations/get-system-lease.js";
 import {
   createGetSystemMetricsOperation,
   createGetSystemMetricsRestBinding
 } from "./operations/get-system-metrics.js";
 import {
-  clearTaskDeadLetterOperation,
-  clearTaskDeadLetterRestBinding,
   createGetTaskDiagnosticsOperation,
-  getTaskDiagnosticsOperation,
-  getTaskDiagnosticsRestBinding
+  getTaskDiagnosticsOperation
 } from "./operations/get-task-diagnostics.js";
-import {
-  getUpdateResultOperation,
-  getUpdateResultRestBinding
-} from "./operations/get-update-result.js";
-import {
-  getWorkflowAttributesOperation,
-  getWorkflowAttributesRestBinding
-} from "./operations/get-workflow-attributes.js";
-import {
-  getWorkflowEventsOperation,
-  getWorkflowEventsRestBinding
-} from "./operations/get-workflow-events.js";
-import * as workflowObservability from "./operations/get-workflow-observability.js";
-import {
-  getWorkflowResultOperation,
-  getWorkflowResultRestBinding
-} from "./operations/get-workflow-result.js";
-import {
-  getWorkflowTimelineOperation,
-  getWorkflowTimelineRestBinding
-} from "./operations/get-workflow-timeline.js";
-import { getWorkflowOperation, getWorkflowRestBinding } from "./operations/get-workflow.js";
-import { listAlertsOperation, listAlertsRestBinding } from "./operations/list-alerts.js";
-import {
-  listCheckpointsOperation,
-  listCheckpointsRestBinding
-} from "./operations/list-checkpoints.js";
-import { listReviewsOperation, listReviewsRestBinding } from "./operations/list-reviews.js";
-import { listSchedulesOperation, listSchedulesRestBinding } from "./operations/list-schedules.js";
 import {
   createListTaskQueuesOperation,
   createListTaskQueuesRestBinding,
@@ -115,86 +17,7 @@ import {
   createListWorkersRestBinding,
   listWorkersOperation
 } from "./operations/list-workers.js";
-import { listWorkflowsOperation, listWorkflowsRestBinding } from "./operations/list-workflows.js";
-import { pauseScheduleOperation, pauseScheduleRestBinding } from "./operations/pause-schedule.js";
-import {
-  purgeWorkflowsOperation,
-  purgeWorkflowsRestBinding
-} from "./operations/purge-workflows.js";
-import {
-  queryWorkflowOperation,
-  queryWorkflowRestBinding,
-  queryWorkflowWithInputRestBinding
-} from "./operations/query-workflow.js";
-import { recoverAllOperation, recoverAllRestBinding } from "./operations/recover-all.js";
-import {
-  removeWorkflowTagsOperation,
-  removeWorkflowTagsRestBinding
-} from "./operations/remove-workflow-tags.js";
-import {
-  replayWorkflowOperation,
-  replayWorkflowRestBinding
-} from "./operations/replay-workflow.js";
-import {
-  resumeScheduleOperation,
-  resumeScheduleRestBinding
-} from "./operations/resume-schedule.js";
-import {
-  resumeWorkflowOperation,
-  resumeWorkflowRestBinding
-} from "./operations/resume-workflow.js";
-import {
-  setWorkflowAttributesOperation,
-  setWorkflowAttributesRestBinding
-} from "./operations/set-workflow-attributes.js";
-import {
-  signalWorkflowOperation,
-  signalWorkflowRestBinding
-} from "./operations/signal-workflow.js";
-import {
-  startOrSignalWorkflowOperation,
-  startOrSignalWorkflowRestBinding
-} from "./operations/start-or-signal-workflow.js";
-import { startWorkflowOperation, startWorkflowRestBinding } from "./operations/start-workflow.js";
-import * as storageCapabilities from "./operations/storage-capabilities.js";
-import {
-  storageBatchOperation,
-  storageBatchRestBinding,
-  storageConditionalBatchOperation,
-  storageConditionalBatchRestBinding,
-  storageDeleteOperation,
-  storageDeleteRestBinding,
-  storageGetOperation,
-  storageGetRestBinding,
-  storagePutOperation,
-  storagePutRestBinding,
-  storageScanOperation,
-  storageScanRestBinding
-} from "./operations/storage.js";
-import {
-  streamWorkflowSseOperation,
-  streamWorkflowSseRestBinding
-} from "./operations/stream-workflow-sse.js";
-import {
-  submitReviewDecisionOperation,
-  submitReviewDecisionRestBinding
-} from "./operations/submit-review-decision.js";
-import {
-  suspendWorkflowOperation,
-  suspendWorkflowRestBinding
-} from "./operations/suspend-workflow.js";
-import {
-  timeoutWorkflowOperation,
-  timeoutWorkflowRestBinding
-} from "./operations/timeout-workflow.js";
-import {
-  updateScheduleOperation,
-  updateScheduleRestBinding
-} from "./operations/update-schedule.js";
-import {
-  updateWorkflowOperation,
-  updateWorkflowRestBinding
-} from "./operations/update-workflow.js";
+import { STATIC_OPERATIONS, STATIC_REST_BINDINGS } from "./operations/static-registrations.js";
 import {
   clearDeploymentDrainOperation,
   clearWorkerDrainOperation,
@@ -209,76 +32,7 @@ import {
   drainDeploymentOperation,
   drainWorkerOperation
 } from "./operations/worker-drain.js";
-import {
-  workflowEventsSseOperation,
-  workflowEventsSseRestBinding
-} from "./operations/workflow-events-sse.js";
-import { workflowEventsSubscriptionOperation } from "./operations/workflow-events-subscription.js";
-export const REST_BINDINGS = [
-  listAlertsRestBinding,
-  startWorkflowRestBinding,
-  startOrSignalWorkflowRestBinding,
-  recoverAllRestBinding,
-  listWorkflowsRestBinding,
-  aggregateWorkflowsRestBinding,
-  purgeWorkflowsRestBinding,
-  bulkCancelWorkflowsRestBinding,
-  bulkSignalWorkflowsRestBinding,
-  bulkRetryFailedWorkflowsRestBinding,
-  bulkDeleteWorkflowsRestBinding,
-  bulkMutateWorkflowTagsRestBinding,
-  getWorkflowRestBinding,
-  cancelWorkflowRestBinding,
-  getWorkflowResultRestBinding,
-  getWorkflowAttributesRestBinding,
-  ...workflowObservability.workflowObservabilityRestBindings,
-  getWorkflowEventsRestBinding,
-  setWorkflowAttributesRestBinding,
-  signalWorkflowRestBinding,
-  asyncActivity.listPendingAsyncActivitiesRestBinding,
-  asyncActivity.completeAsyncActivityRestBinding,
-  asyncActivity.failAsyncActivityRestBinding,
-  queryWorkflowRestBinding,
-  queryWorkflowWithInputRestBinding,
-  resumeWorkflowRestBinding,
-  suspendWorkflowRestBinding,
-  forkWorkflowRestBinding,
-  timeoutWorkflowRestBinding,
-  updateWorkflowRestBinding,
-  createScheduleRestBinding,
-  updateScheduleRestBinding,
-  getRegistryRestBinding,
-  getSystemLeaseRestBinding,
-  getRetentionOverviewRestBinding,
-  getUpdateResultRestBinding,
-  listReviewsRestBinding,
-  getReviewRestBinding,
-  listCheckpointsRestBinding,
-  getCheckpointAtRestBinding,
-  getWorkflowTimelineRestBinding,
-  addWorkflowTagsRestBinding,
-  removeWorkflowTagsRestBinding,
-  submitReviewDecisionRestBinding,
-  cancelScheduleRestBinding,
-  pauseScheduleRestBinding,
-  resumeScheduleRestBinding,
-  getStreamChunksRestBinding,
-  streamWorkflowSseRestBinding,
-  workflowEventsSseRestBinding,
-  fleetEventsSseRestBinding,
-  getTaskDiagnosticsRestBinding,
-  clearTaskDeadLetterRestBinding,
-  listSchedulesRestBinding,
-  getScheduleRestBinding,
-  replayWorkflowRestBinding,
-  storageCapabilities.storageCapabilitiesRestBinding,
-  storageGetRestBinding,
-  storagePutRestBinding,
-  storageDeleteRestBinding,
-  storageScanRestBinding,
-  storageBatchRestBinding,
-  storageConditionalBatchRestBinding
-];
+export const REST_BINDINGS = STATIC_REST_BINDINGS;
 export function createLiveRestBindings() {
   return [
     ...REST_BINDINGS,
@@ -349,70 +103,8 @@ function buildTaskDiagnosticsOperationForRegistry(options) {
 export function createLiveOperationRegistry(options) {
   const resolved = options ?? {};
   return createOperationRegistry([
-    startWorkflowOperation,
-    startOrSignalWorkflowOperation,
-    recoverAllOperation,
-    listWorkflowsOperation,
-    aggregateWorkflowsOperation,
-    purgeWorkflowsOperation,
-    bulkCancelWorkflowsOperation,
-    bulkSignalWorkflowsOperation,
-    bulkRetryFailedWorkflowsOperation,
-    bulkDeleteWorkflowsOperation,
-    bulkMutateWorkflowTagsOperation,
-    getWorkflowOperation,
-    cancelWorkflowOperation,
-    getWorkflowResultOperation,
-    getWorkflowAttributesOperation,
-    ...workflowObservability.workflowObservabilityOperations,
-    getWorkflowEventsOperation,
-    setWorkflowAttributesOperation,
-    signalWorkflowOperation,
-    asyncActivity.listPendingAsyncActivitiesOperation,
-    asyncActivity.completeAsyncActivityOperation,
-    asyncActivity.failAsyncActivityOperation,
-    queryWorkflowOperation,
-    resumeWorkflowOperation,
-    suspendWorkflowOperation,
-    forkWorkflowOperation,
-    timeoutWorkflowOperation,
-    updateWorkflowOperation,
-    createScheduleOperation,
-    updateScheduleOperation,
-    getRegistryOperation,
-    getSystemLeaseOperation,
-    getRetentionOverviewOperation,
-    getUpdateResultOperation,
-    listReviewsOperation,
-    getReviewOperation,
-    listCheckpointsOperation,
-    getCheckpointAtOperation,
-    getWorkflowTimelineOperation,
-    addWorkflowTagsOperation,
-    removeWorkflowTagsOperation,
-    submitReviewDecisionOperation,
-    cancelScheduleOperation,
-    pauseScheduleOperation,
-    resumeScheduleOperation,
-    getStreamChunksOperation,
-    streamWorkflowSseOperation,
-    workflowEventsSseOperation,
-    fleetEventsSseOperation,
-    workflowEventsSubscriptionOperation,
-    fleetEventsSubscriptionOperation,
+    ...STATIC_OPERATIONS,
     buildTaskDiagnosticsOperationForRegistry(resolved),
-    clearTaskDeadLetterOperation,
-    listSchedulesOperation,
-    listAlertsOperation,
-    getScheduleOperation,
-    replayWorkflowOperation,
-    storageCapabilities.storageCapabilitiesOperation,
-    storageGetOperation,
-    storagePutOperation,
-    storageDeleteOperation,
-    storageScanOperation,
-    storageBatchOperation,
-    storageConditionalBatchOperation,
     buildSystemMetricsOperation(resolved),
     buildListWorkersOperationForRegistry(resolved),
     buildDrainWorkerOperationForRegistry(resolved),

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