@farukada/aws-langgraph-dynamodb-ts 1.0.0-rc.2 → 1.0.0

package/dist/{shared → cjs/shared}/dynamodb/idempotent-write.d.ts

@@ -11,10 +11,10 @@
  * whose outcome was lost into one of three verdicts. Whether a write needs the
  * token is the payload descriptor's question, answered here once.
  */
-import { type PayloadDescriptor, type DescriptorRef } from '../codec/codec';
-import type { DynamoDBDocumentLike, AttributeMap, TransactAction } from './client';
-import type { RetryOptions } from './retry';
-import { type RowKey } from './table-schema';
+import { type PayloadDescriptor, type DescriptorRef } from '../codec/codec.js';
+import type { DynamoDBDocumentLike, AttributeMap, TransactAction } from './client.js';
+import type { RetryOptions } from './retry.js';
+import { type RowKey } from './table-schema.js';
 /**
  * What a row write needs of its adapter: the document client, the table, and
  * the retry policy. Every context that writes or reads back a row already
@@ -102,13 +102,14 @@ export declare function referencesS3Object(descriptor: DescriptorRef): boolean;
  * token, which is required rather than merely tidy: the re-pinned request
  * carries a different `ConditionExpression`, and the same token presented with
  * changed parameters inside the window is refused with
- * `IdempotentParameterMismatchException` — a name that appears in no retry
- * list and in no handler in this package, so reusing a token would surface a
- * raw SDK error to a caller. That refusal is only observable against real
+ * `IdempotentParameterMismatchException` — classified as `AWS_REJECTED` and
+ * never retried, so reusing a token would fail the caller's write with that
+ * error instead of applying the re-pin. That refusal is only observable against real
  * DynamoDB: the local image does not reserve a cancelled token's parameters
- * and simply re-evaluates the changed body, so the unit and integration tiers
- * can assert only that two re-pins carry different tokens, and the refusal
- * itself belongs to the tier that runs against AWS.
+ * and simply re-evaluates the changed body, so the integration tier, on
+ * DynamoDB Local, can assert only that two re-pins carry different tokens —
+ * the unit tier mocks the client — and the refusal itself belongs to the
+ * tier that runs against AWS.
  *
  * **At most one guarded action, and only ever as many actions as must land
  * together.** A cancellation is read as a guard rejection only while exactly
@@ -165,7 +166,7 @@ export declare function transactIdempotently(deps: RowWriteDeps, actions: Transa
  * Commit one row under a request token; see {@link transactIdempotently} for
  * why the write takes a transaction's shape and what the token buys.
  *
- * Accepts: `deps` — the adapter's client, table and retry policy. `item` — the
+ * Accepts: `deps` — the adapter's client, table and retry policy. `row` — the
  * row to commit. It is captured by reference and re-sent unchanged on every
  * attempt of the budget, so a caller must not mutate it while this call is in
  * flight: the re-send would carry the same token with different parameters,
@@ -184,7 +185,7 @@ export declare function transactIdempotently(deps: RowWriteDeps, actions: Transa
  * `rejectedRow`, so a caller reads them the same way. A spent budget
  * throws `RETRY_EXHAUSTED` as any other call does.
  */
-export declare function putIdempotently(deps: RowWriteDeps, item: AttributeMap, guard?: RevisionGuard, signal?: AbortSignal): Promise<void>;
+export declare function putIdempotently(deps: RowWriteDeps, row: AttributeMap, guard?: RevisionGuard, signal?: AbortSignal): Promise<void>;
 /**
  * Remove one row under a request token; see {@link transactIdempotently} for
  * why the delete takes a transaction's shape and what the token buys.
@@ -241,7 +242,8 @@ export declare function commitRow(deps: RowWriteDeps, row: AttributeMap, payload
  * unconditionally. Kept small on purpose: DynamoDB charges write capacity for a
  * *failed* conditional write too, sized on the existing item, so an aggressive
  * loop turns contention into cost. Three attempts settle every realistic race,
- * and the fallback is exactly the pre-0.9.0 behaviour rather than an error.
+ * and the fallback is an unconditional write — one possible orphaned object,
+ * reclaimed by the lifecycle rule — rather than an error.
  */
 export declare const OVERWRITE_CAS_MAX_ATTEMPTS = 3;
 /** What a caller saw at the row before it tried to overwrite it. */
@@ -272,8 +274,9 @@ export interface RevisionGuard {
  * because neither writer can learn of an object it never saw; only refusing the
  * second write until it re-reads can.
  *
- * A row with no revision attribute was written before 0.9.0. Pinning its
- * *absence* is what makes the swap correct across an upgrade: the first writer
+ * A row with no revision attribute was written before the attribute existed
+ * — 0.9.0 for a store row's `rev`, 0.8.0 for a write row's `writeGroup`.
+ * Pinning its *absence* is what makes the swap correct across an upgrade: the first writer
  * to touch such a row stamps one, and any racer still holding the pre-upgrade
  * observation is turned away.
  *
@@ -417,10 +420,7 @@ export declare function rejectedRow(error: Error): AttributeMap | undefined;
 export type WriteVerdict = 'landed' | 'not-landed' | 'unverified';
 /** Which row to read, and which attributes of it to project. */
 export interface RowRead {
-    key: {
-        PK: string;
-        SK: string;
-    };
+    key: RowKey;
     /** The attribute carrying the row's identity; always projected. */
     attribute: string;
     /** Further attributes to project, when the caller needs the row itself back. */
@@ -492,6 +492,51 @@ export declare function identityOf(probe: RowProbe, row: AttributeMap | undefine
  * Throws: nothing.
  */
 export declare function verdictFor(probe: RowProbe, row: AttributeMap | undefined): WriteVerdict;
+/**
+ * Whether a write that failed may still commit after its failure was reported.
+ *
+ * A write the service answered with a definite refusal or a throttle is
+ * finished: a strongly consistent read after that answer sees whatever it
+ * did. A write is not finished while *any* attempt of it left DynamoDB free to
+ * apply it later — not only its last attempt: `TransactWriteItems` is sent
+ * under one `ClientRequestToken` for the whole retry budget, and DynamoDB
+ * answers a re-send that arrives while an earlier attempt under that same
+ * token is still being processed with `TransactionInProgressException` —
+ * itself proof that the earlier attempt reached the service and may still
+ * land — while the very next attempt can be answered normally. A cancel is
+ * the same story from the caller's own side: it stops the client waiting, not
+ * the service applying a request it had already received.
+ *
+ * Accepts: `failure` — what the write threw.
+ *
+ * Returns: true for `ABORTED`, and for any failure carrying the record
+ * `withRetry` kept across every attempt of its budget
+ * (`retryBudgetMayStillLand`) — a spent budget, or a refusal that ended one
+ * after an attempt that got no answer. Without that record, a spent budget is
+ * judged by its last attempt's own failure (`mayStillBeInFlight`), which is
+ * what a `RETRY_EXHAUSTED` error built outside `withRetry` falls back to; any
+ * other failure is judged by itself the same way.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function mayStillLand(failure: Error): boolean;
+/**
+ * The verdict a read-back licenses once the write it judges may still be in flight.
+ *
+ * Accepts: `verdict` — what the read found. `failure` — what the write threw.
+ *
+ * Returns: `'unverified'` in place of `'not-landed'` when the write may still
+ * commit ({@link mayStillLand}): an absent row is exactly what an attempt still
+ * on its way can fill, so the upload it names is not yet dead. Every other
+ * verdict is returned unchanged. A caller whose write is pinned to a state the
+ * row has already left may skip this, since such a write can no longer apply
+ * (the pending-writes verification does); `persistRow` asks it unconditionally,
+ * so its upload is kept whether the read found the row absent or holding
+ * another revision.
+ *
+ * Throws: nothing.
+ */
+export declare function settledVerdict(verdict: WriteVerdict, failure: Error): WriteVerdict;
 /**
  * Read the row a probe names, strongly consistently.
  *

package/dist/cjs/shared/dynamodb/idempotent-write.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WRITE_ID_ATTRIBUTE = exports.OVERWRITE_CAS_MAX_ATTEMPTS = void 0;
+exports.referencesS3Object = referencesS3Object;
+exports.transactIdempotently = transactIdempotently;
+exports.putIdempotently = putIdempotently;
+exports.deleteIdempotently = deleteIdempotently;
+exports.commitRow = commitRow;
+exports.revisionGuard = revisionGuard;
+exports.writeIdGuard = writeIdGuard;
+exports.isConditionalCheckFailed = isConditionalCheckFailed;
+exports.rejectedRow = rejectedRow;
+exports.offloadedKey = offloadedKey;
+exports.identityOf = identityOf;
+exports.verdictFor = verdictFor;
+exports.mayStillLand = mayStillLand;
+exports.settledVerdict = settledVerdict;
+exports.readRow = readRow;
+exports.verifyRow = verifyRow;
+exports.isRowAbsent = isRowAbsent;
+const node_crypto_1 = require("node:crypto");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const clock_js_1 = require("../clock.js");
+const codec_js_1 = require("../codec/codec.js");
+const base_error_js_1 = require("../errors/base-error.js");
+const classify_js_1 = require("../errors/classify.js");
+const error_code_js_1 = require("../errors/error-code.js");
+const errors_js_1 = require("../errors/errors.js");
+const abort_js_1 = require("./abort.js");
+const cancellation_js_1 = require("./cancellation.js");
+const retry_js_1 = require("./retry.js");
+const table_schema_js_1 = require("./table-schema.js");
+function referencesS3Object(descriptor) {
+    return descriptor.location === codec_js_1.PayloadLocation.S3;
+}
+async function transactIdempotently(deps, actions, options = {}) {
+    const input = { TransactItems: actions, ClientRequestToken: (0, node_crypto_1.randomUUID)() };
+    const deadlineAt = (0, clock_js_1.nowMs)() + retry_js_1.MAX_WRITE_LIFETIME_MS;
+    await (0, retry_js_1.withDynamoDBRetry)((request) => deps.client.transactWrite(input, request), {
+        ...(0, retry_js_1.retryFor)(deps, options.signal),
+        ...(options.minAttempts === undefined
+            ? {}
+            : { maxAttempts: Math.max(options.minAttempts, deps.retry?.maxAttempts ?? 0) }),
+        ...(options.rng === undefined ? {} : { rng: options.rng }),
+        deadlineAt,
+    });
+}
+async function putIdempotently(deps, row, guard, signal) {
+    await transactIdempotently(deps, [{ Put: { TableName: deps.tableName, Item: row, ...guard } }], {
+        signal,
+    });
+}
+async function deleteIdempotently(deps, key, guard, signal) {
+    await transactIdempotently(deps, [{ Delete: { TableName: deps.tableName, Key: key, ...guard } }], { signal });
+}
+async function commitRow(deps, row, payload, options = {}) {
+    if (referencesS3Object(payload)) {
+        await putIdempotently(deps, row, options.guard, options.signal);
+        return;
+    }
+    await (0, retry_js_1.withDynamoDBRetry)((request) => deps.client.put({ TableName: deps.tableName, Item: row, ...options.guard }, request), (0, retry_js_1.retryFor)(deps, options.signal));
+}
+exports.OVERWRITE_CAS_MAX_ATTEMPTS = 3;
+const RETURN_REJECTED_ROW = { ReturnValuesOnConditionCheckFailure: 'ALL_OLD' };
+function revisionGuard(attribute, observed) {
+    if (!observed.exists)
+        return {
+            ...RETURN_REJECTED_ROW,
+            ConditionExpression: `attribute_not_exists(${table_schema_js_1.PARTITION_KEY_ATTRIBUTE})`,
+        };
+    if (observed.revision === undefined) {
+        return {
+            ...RETURN_REJECTED_ROW,
+            ConditionExpression: 'attribute_not_exists(#rev)',
+            ExpressionAttributeNames: { '#rev': attribute },
+        };
+    }
+    return {
+        ...RETURN_REJECTED_ROW,
+        ConditionExpression: '#rev = :rev',
+        ExpressionAttributeNames: { '#rev': attribute },
+        ExpressionAttributeValues: { ':rev': observed.revision },
+    };
+}
+exports.WRITE_ID_ATTRIBUTE = 'writeId';
+function writeIdGuard(attribute, id, field) {
+    const names = { '#pin': attribute };
+    if (field !== undefined)
+        names['#field'] = field;
+    return {
+        ...RETURN_REJECTED_ROW,
+        ConditionExpression: field === undefined ? '#pin = :pin' : '#pin.#field = :pin',
+        ExpressionAttributeNames: names,
+        ExpressionAttributeValues: { ':pin': id },
+    };
+}
+function isConditionalCheckFailed(error) {
+    return (0, classify_js_1.classifyAwsError)(error) === error_code_js_1.ErrorCode.CONDITION_CONFLICT;
+}
+function rejectedRow(error) {
+    const attached = error.Item;
+    const raw = attached ?? (0, cancellation_js_1.conditionalCheckFailure)(error)?.Item;
+    return raw === undefined ? undefined : (0, util_dynamodb_1.unmarshall)(raw);
+}
+function offloadedKey(descriptor) {
+    return descriptor?.location === codec_js_1.PayloadLocation.S3 ? descriptor.s3Key : undefined;
+}
+function identityOf(probe, row) {
+    if (probe.kind === 'attribute')
+        return row?.[probe.attribute];
+    return offloadedKey(row?.[probe.attribute]);
+}
+function verdictFor(probe, row) {
+    return identityOf(probe, row) === probe.expected ? 'landed' : 'not-landed';
+}
+function mayStillLand(failure) {
+    if ((0, abort_js_1.isAbortError)(failure) || (0, errors_js_1.retryBudgetMayStillLand)(failure))
+        return true;
+    if ((0, base_error_js_1.hasErrorCode)(failure, error_code_js_1.ErrorCode.RETRY_EXHAUSTED)) {
+        return (0, classify_js_1.mayStillBeInFlight)(failure.cause);
+    }
+    return (0, classify_js_1.mayStillBeInFlight)(failure);
+}
+function settledVerdict(verdict, failure) {
+    return verdict === 'not-landed' && mayStillLand(failure) ? 'unverified' : verdict;
+}
+function projectionOf(read) {
+    const nested = read.descriptors ?? [];
+    const whole = [read.attribute, ...(read.also ?? [])].filter((name) => !nested.includes(name));
+    const names = {};
+    const paths = [];
+    whole.forEach((name, index) => {
+        names[`#a${index}`] = name;
+        paths.push(`#a${index}`);
+    });
+    nested.forEach((name, index) => {
+        names[`#d${index}`] = name;
+        paths.push(`#d${index}.#loc`, `#d${index}.#s3k`);
+    });
+    if (nested.length > 0)
+        Object.assign(names, { '#loc': 'location', '#s3k': 's3Key' });
+    return { expression: paths.join(', '), names };
+}
+async function readRow(deps, read) {
+    const { expression, names } = projectionOf(read);
+    const result = await (0, retry_js_1.withDynamoDBRetry)((request) => deps.client.get({
+        TableName: deps.tableName,
+        Key: read.key,
+        ConsistentRead: true,
+        ProjectionExpression: expression,
+        ExpressionAttributeNames: names,
+    }, request), deps.retry);
+    return result.Item;
+}
+async function verifyRow(deps, probe) {
+    if (probe.expected === undefined)
+        return { verdict: 'not-landed' };
+    try {
+        const row = await readRow(deps, probe);
+        return { verdict: verdictFor(probe, row), row };
+    }
+    catch {
+        return { verdict: 'unverified' };
+    }
+}
+async function isRowAbsent(deps, key) {
+    try {
+        return (await readRow(deps, { key, attribute: table_schema_js_1.PARTITION_KEY_ATTRIBUTE })) === undefined;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/{shared → cjs/shared}/dynamodb/paginate.d.ts

@@ -8,8 +8,8 @@
  * between pages are decided here, the same way for a Query and a Scan.
  */
 import type { QueryCommandInput, ScanCommandInput } from '@aws-sdk/lib-dynamodb';
-import type { DynamoDBDocumentLike, AttributeMap } from './client';
-import { type RetryOptions } from './retry';
+import type { DynamoDBDocumentLike, AttributeMap } from './client.js';
+import { type RetryOptions } from './retry.js';
 /** Hard cap on query-pagination loop iterations (runaway-loop guard). */
 export declare const MAX_LOOP_ITERATIONS = 1000;
 /** Hard cap on rows collected into memory across a paginated query. */

package/dist/cjs/shared/dynamodb/paginate.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIST_SCAN_WARN_THRESHOLD = exports.MAX_TOTAL_ROWS_IN_MEMORY = exports.MAX_LOOP_ITERATIONS = void 0;
+exports.paginateQuery = paginateQuery;
+exports.paginatePages = paginatePages;
+exports.paginateScan = paginateScan;
+const errors_js_1 = require("../errors/errors.js");
+const abort_js_1 = require("./abort.js");
+const retry_js_1 = require("./retry.js");
+exports.MAX_LOOP_ITERATIONS = 1000;
+exports.MAX_TOTAL_ROWS_IN_MEMORY = 10000;
+exports.LIST_SCAN_WARN_THRESHOLD = 10000;
+function paginateQuery(options) {
+    return paginatePages(async (startKey) => {
+        const page = await (0, retry_js_1.withDynamoDBRetry)((request) => options.client.query({ ...options.params, ExclusiveStartKey: startKey }, request), { ...options.retry, signal: options.signal });
+        return {
+            items: page.Items ?? [],
+            lastKey: page.LastEvaluatedKey,
+        };
+    }, options);
+}
+async function readPage(reader, startKey) {
+    if (reader.iterations >= reader.maxIterations) {
+        throw (0, errors_js_1.resultTruncatedError)('maxIterations', reader.maxIterations);
+    }
+    if (reader.signal?.aborted)
+        throw (0, abort_js_1.abortErrorFrom)(reader.signal);
+    reader.iterations += 1;
+    return reader.fetchPage(startKey);
+}
+function* yieldPageRows(page, state, maxItems) {
+    for (let index = 0; index < page.items.length; index++) {
+        yield page.items[index];
+        state.yielded += 1;
+        if (state.yielded >= maxItems) {
+            if (index < page.items.length - 1)
+                throw (0, errors_js_1.resultTruncatedError)('maxItems', maxItems);
+            return 'capped';
+        }
+    }
+    return 'exhausted';
+}
+async function dataRemains(reader, startKey) {
+    let key = startKey;
+    while (key !== undefined) {
+        const page = await readPage(reader, key);
+        if (page.items.length > 0)
+            return true;
+        key = page.lastKey;
+    }
+    return false;
+}
+function assertPositiveCap(value, field) {
+    if (!(value >= 1)) {
+        throw (0, errors_js_1.validationError)(`${field} must be at least 1 (pass Infinity to read to completion)`, field);
+    }
+    return value;
+}
+async function* paginatePages(fetchPage, options = {}) {
+    const maxItems = assertPositiveCap(options.maxItems ?? exports.MAX_TOTAL_ROWS_IN_MEMORY, 'maxItems');
+    const reader = {
+        fetchPage,
+        maxIterations: assertPositiveCap(options.maxIterations ?? exports.MAX_LOOP_ITERATIONS, 'maxIterations'),
+        iterations: 0,
+        signal: options.signal,
+    };
+    const state = { yielded: 0 };
+    let startKey;
+    for (;;) {
+        const page = await readPage(reader, startKey);
+        const outcome = yield* yieldPageRows(page, state, maxItems);
+        if (outcome === 'capped') {
+            if (await dataRemains(reader, page.lastKey))
+                throw (0, errors_js_1.resultTruncatedError)('maxItems', maxItems);
+            return;
+        }
+        startKey = page.lastKey;
+        if (startKey === undefined)
+            return;
+    }
+}
+function paginateScan(options) {
+    return paginatePages(async (startKey) => {
+        const page = await (0, retry_js_1.withDynamoDBRetry)((request) => options.client.scan({ ...options.params, ExclusiveStartKey: startKey }, request), { ...options.retry, signal: options.signal });
+        return {
+            items: page.Items ?? [],
+            lastKey: page.LastEvaluatedKey,
+        };
+    }, options);
+}

package/dist/{shared → cjs/shared}/dynamodb/partition-delete.d.ts

@@ -8,12 +8,12 @@
  * object is released only once the row naming it is confirmed gone.
  */
 import type { QueryCommandInput } from '@aws-sdk/lib-dynamodb';
-import { type PayloadDescriptor, type DescriptorRef } from '../codec/codec';
-import { type S3Offloader } from '../codec/s3/offloader';
-import type { Logger } from '../logging/logger';
-import type { DynamoDBDocumentLike, AttributeMap } from './client';
-import { type RevisionGuard } from './idempotent-write';
-import { type RetryOptions } from './retry';
+import { type PayloadDescriptor, type DescriptorRef } from '../codec/codec.js';
+import { type S3Offloader } from '../codec/s3/offloader.js';
+import type { Logger } from '../logging/logger.js';
+import type { DynamoDBDocumentLike, AttributeMap } from './client.js';
+import { type RevisionGuard } from './idempotent-write.js';
+import { type RetryOptions } from './retry.js';
 /**
  * Conditional row deletes a partition-wide delete keeps in flight. Pinning a
  * row on the write that produced it costs one request per row where a batch

package/dist/cjs/shared/dynamodb/partition-delete.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELETE_CONCURRENCY = void 0;
+exports.namedDescriptor = namedDescriptor;
+exports.deletePartitionRows = deletePartitionRows;
+exports.flushPendingDeletes = flushPendingDeletes;
+const codec_js_1 = require("../codec/codec.js");
+const offloader_js_1 = require("../codec/s3/offloader.js");
+const concurrency_js_1 = require("../concurrency.js");
+const errors_js_1 = require("../errors/errors.js");
+const truncate_js_1 = require("../logging/truncate.js");
+const abort_js_1 = require("./abort.js");
+const batch_write_js_1 = require("./batch-write.js");
+const idempotent_write_js_1 = require("./idempotent-write.js");
+const paginate_js_1 = require("./paginate.js");
+const retry_js_1 = require("./retry.js");
+const table_schema_js_1 = require("./table-schema.js");
+exports.DELETE_CONCURRENCY = 8;
+function namedDescriptor(row, attribute) {
+    const descriptor = row[attribute];
+    if (descriptor === null || descriptor === undefined)
+        return undefined;
+    return { attribute, descriptor };
+}
+function pinFor(idAttribute, row, named) {
+    if (idAttribute !== undefined) {
+        const observed = row[idAttribute];
+        if (typeof observed === 'string')
+            return (0, idempotent_write_js_1.writeIdGuard)(idAttribute, observed);
+    }
+    for (const entry of named) {
+        const { writeId } = entry.descriptor;
+        if (writeId !== undefined)
+            return (0, idempotent_write_js_1.writeIdGuard)(entry.attribute, writeId, idempotent_write_js_1.WRITE_ID_ATTRIBUTE);
+    }
+    return undefined;
+}
+function pendingDelete(options, row) {
+    const named = options.descriptorsOf(row);
+    return {
+        key: (0, table_schema_js_1.rowKeyOf)(row),
+        guard: pinFor(options.idAttribute, row, named),
+        descriptors: named.map((entry) => entry.descriptor),
+        unit: options.unitOf?.(row),
+    };
+}
+function unitRefused(options, row, state) {
+    const unit = options.unitOf?.(row);
+    return unit !== undefined && state.units.has(unit);
+}
+function cancelAmong(failures) {
+    return failures.find(abort_js_1.isAbortError);
+}
+async function flushBuffer(options, state) {
+    if (state.buffer.length === 0)
+        return;
+    const tally = await flushPendingDeletes(options, state.buffer.splice(0));
+    state.deleted += tally.deleted;
+    state.skipped += tally.refused;
+    state.attempted += tally.deleted + tally.failures.length;
+    for (const unit of tally.refusedUnits)
+        state.units.add(unit);
+    if (tally.failures.length === 0)
+        return;
+    const cancelled = cancelAmong(tally.failures);
+    if (cancelled !== undefined)
+        throw cancelled;
+    const { deleted, attempted } = state;
+    throw (0, errors_js_1.batchWriteAllIncompleteError)({
+        succeeded: deleted,
+        total: attempted,
+        failures: tally.failures,
+        succeededCount: deleted,
+        unit: 'row',
+    });
+}
+async function deletePartitionRows(options) {
+    const state = { buffer: [], deleted: 0, attempted: 0, skipped: 0, units: new Set() };
+    let kind;
+    const pages = (0, paginate_js_1.paginateQuery)({
+        client: options.client,
+        params: options.params,
+        retry: options.retry,
+        signal: options.signal,
+        maxItems: Number.POSITIVE_INFINITY,
+        maxIterations: Number.POSITIVE_INFINITY,
+    });
+    for await (const row of pages) {
+        const sortKey = row.SK;
+        if (!options.ownsSortKey(sortKey)) {
+            state.skipped += 1;
+            options.logger.warn(`${options.operation}: left a foreign row in place`, {
+                sortKey: (0, truncate_js_1.truncateForLog)(sortKey),
+            });
+            continue;
+        }
+        const rowKind = options.kindOf?.(row);
+        if (rowKind !== kind) {
+            await flushBuffer(options, state);
+            kind = rowKind;
+        }
+        if (unitRefused(options, row, state)) {
+            state.skipped += 1;
+            options.logger.warn(`${options.operation}: skipped a row whose unit was refused`, {
+                sortKey: (0, truncate_js_1.truncateForLog)(sortKey),
+            });
+            continue;
+        }
+        state.buffer.push(pendingDelete(options, row));
+        if (state.buffer.length >= batch_write_js_1.BATCH_WRITE_MAX)
+            await flushBuffer(options, state);
+    }
+    await flushBuffer(options, state);
+    const { deleted, skipped } = state;
+    options.logger.info(`${options.operation}: deleted rows`, { deleted, skipped });
+    return deleted;
+}
+function recordRefusal(deps, row, tally) {
+    deps.logger.warn(`${deps.operation}: left a row rewritten since the read`, {
+        sortKey: (0, truncate_js_1.truncateForLog)(row.key.SK),
+    });
+    tally.refused += 1;
+    if (row.unit !== undefined)
+        tally.refusedUnits.push(row.unit);
+}
+async function settleRow(deps, row, tally) {
+    try {
+        await (0, retry_js_1.withDynamoDBRetry)((request) => deps.client.delete({
+            TableName: deps.tableName,
+            Key: row.key,
+            ...row.guard,
+        }, request), deps.retry);
+    }
+    catch (error) {
+        const rejection = error;
+        if (!(0, idempotent_write_js_1.isConditionalCheckFailed)(rejection))
+            throw rejection;
+        if ((0, idempotent_write_js_1.rejectedRow)(rejection) !== undefined) {
+            recordRefusal(deps, row, tally);
+            return;
+        }
+    }
+    tally.deleted += 1;
+    tally.released.push(...row.descriptors);
+}
+async function deleteRow(deps, row, tally) {
+    try {
+        await settleRow(deps, row, tally);
+    }
+    catch (error) {
+        tally.failures.push(error);
+        throw error;
+    }
+}
+async function flushPendingDeletes(deps, rows) {
+    const tally = {
+        deleted: 0,
+        refused: 0,
+        refusedUnits: [],
+        failures: [],
+        released: [],
+    };
+    try {
+        await (0, concurrency_js_1.mapWithConcurrency)(rows, exports.DELETE_CONCURRENCY, (row) => deleteRow(deps, row, tally));
+    }
+    catch {
+    }
+    if (deps.offloader) {
+        await (0, offloader_js_1.cleanUpS3Orphans)(deps.offloader, {
+            keys: (0, codec_js_1.collectS3Keys)(tally.released),
+            operation: deps.operation,
+            logger: deps.logger,
+            scope: deps.scope,
+        });
+    }
+    return tally;
+}