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

package/dist/checkpointer/internal/item-writer.d.ts

@@ -1,26 +0,0 @@
-import type { Checkpoint, CheckpointMetadata, PendingWrite } from '@langchain/langgraph-checkpoint';
-import { type CodecDeps } from '../../shared/codec/codec';
-import type { CheckpointMetaItem, CheckpointPayloadItem, CheckpointWriteItem } from '../types';
-import type { CheckpointerContext } from './setup';
-/** Map a context to the codec collaborators. */
-export declare function codecDeps(context: CheckpointerContext): CodecDeps;
-/** Encode a checkpoint + metadata into its META and PAYLOAD items. */
-export declare function buildCheckpointItems(context: CheckpointerContext, threadId: string, checkpointNs: string, checkpoint: Checkpoint, metadata: CheckpointMetadata, parentCheckpointId?: string, ttlTimestamp?: number): Promise<{
-    meta: CheckpointMetaItem;
-    payload: CheckpointPayloadItem;
-}>;
-/**
- * Encode a task's pending writes into one item per write. `nonce` must be
- * unique per `putWrites` *call* (not per write) and is appended to every
- * write's S3 offload keyParts — regular and special alike — so a repeated
- * write (a retried task re-emitting the same channel, or two calls to the
- * same special channel) never shares an S3 location with any earlier
- * attempt. Special (negative-index) writes still overwrite their DynamoDB
- * row in place (see {@link writeSpecialItemsWithCleanup}), but that
- * overwrite-safety now comes from reading the previous descriptor before
- * writing and only cleaning it up after the new row is confirmed committed —
- * the same pattern store/actions/put.ts uses for the identical "overwrite in
- * place, nonce every upload" shape.
- */
-export declare function buildWriteItems(context: CheckpointerContext, threadId: string, checkpointNs: string, checkpointId: string, taskId: string, writes: PendingWrite[], nonce: string, ttlTimestamp?: number): Promise<CheckpointWriteItem[]>;
-//# sourceMappingURL=item-writer.d.ts.map

package/dist/checkpointer/internal/item-writer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"item-writer.d.ts","sourceRoot":"","sources":["../../../src/checkpointer/internal/item-writer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpG,OAAO,EAAE,KAAK,SAAS,EAAiB,MAAM,0BAA0B,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAGnD,gDAAgD;AAChD,wBAAgB,SAAS,CAAC,OAAO,EAAE,mBAAmB,GAAG,SAAS,CAEjE;AAOD,sEAAsE;AACtE,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,kBAAkB,EAC5B,kBAAkB,CAAC,EAAE,MAAM,EAC3B,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,OAAO,EAAE,qBAAqB,CAAA;CAAE,CAAC,CAwBvE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,YAAY,EAAE,EACtB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAiChC"}

package/dist/checkpointer/internal/item-writer.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.codecDeps = codecDeps;
-exports.buildCheckpointItems = buildCheckpointItems;
-exports.buildWriteItems = buildWriteItems;
-const codec_1 = require("../../shared/codec/codec");
-const keys_1 = require("./keys");
-const write_index_1 = require("./write-index");
-/** Map a context to the codec collaborators. */
-function codecDeps(context) {
-    return { serde: context.serde, compression: context.compression, offloader: context.offloader };
-}
-function withTtl(item, ttlTimestamp) {
-    if (ttlTimestamp !== undefined)
-        item.ttl = ttlTimestamp;
-    return item;
-}
-/** Encode a checkpoint + metadata into its META and PAYLOAD items. */
-async function buildCheckpointItems(context, threadId, checkpointNs, checkpoint, metadata, parentCheckpointId, ttlTimestamp) {
-    const deps = codecDeps(context);
-    const pk = (0, keys_1.partitionKey)(threadId);
-    const checkpointDescriptor = await (0, codec_1.encodePayload)(checkpoint, deps, {
-        keyParts: [threadId, checkpointNs, checkpoint.id, 'checkpoint'],
-    });
-    const metadataDescriptor = await (0, codec_1.encodePayload)(metadata, deps, {
-        keyParts: [threadId, checkpointNs, checkpoint.id, 'metadata'],
-    });
-    const meta = {
-        PK: pk,
-        SK: (0, keys_1.metaSortKey)(checkpointNs, checkpoint.id),
-        threadId,
-        checkpointNs,
-        checkpointId: checkpoint.id,
-        metadata: metadataDescriptor,
-    };
-    if (parentCheckpointId !== undefined)
-        meta.parentCheckpointId = parentCheckpointId;
-    const payload = {
-        PK: pk,
-        SK: (0, keys_1.payloadSortKey)(checkpointNs, checkpoint.id),
-        checkpoint: checkpointDescriptor,
-    };
-    return { meta: withTtl(meta, ttlTimestamp), payload: withTtl(payload, ttlTimestamp) };
-}
-/**
- * Encode a task's pending writes into one item per write. `nonce` must be
- * unique per `putWrites` *call* (not per write) and is appended to every
- * write's S3 offload keyParts — regular and special alike — so a repeated
- * write (a retried task re-emitting the same channel, or two calls to the
- * same special channel) never shares an S3 location with any earlier
- * attempt. Special (negative-index) writes still overwrite their DynamoDB
- * row in place (see {@link writeSpecialItemsWithCleanup}), but that
- * overwrite-safety now comes from reading the previous descriptor before
- * writing and only cleaning it up after the new row is confirmed committed —
- * the same pattern store/actions/put.ts uses for the identical "overwrite in
- * place, nonce every upload" shape.
- */
-async function buildWriteItems(context, threadId, checkpointNs, checkpointId, taskId, writes, nonce, ttlTimestamp) {
-    const deps = codecDeps(context);
-    const pk = (0, keys_1.partitionKey)(threadId);
-    const items = [];
-    for (const { channel, value, index, occurrence } of (0, write_index_1.resolveWriteIndices)(writes)) {
-        /**
-         * `channel` is part of the key as well as the index: two channels can
-         * share an index (each channel's first occurrence is 0), so without it
-         * their uploads would collide on one S3 object within a single call.
-         */
-        const descriptor = await (0, codec_1.encodePayload)(value, deps, {
-            keyParts: [threadId, checkpointNs, checkpointId, taskId, `write-${index}`, channel, nonce],
-        });
-        const item = {
-            PK: pk,
-            SK: (0, keys_1.writeSortKey)(checkpointNs, checkpointId, taskId, index, channel),
-            taskId,
-            index,
-            channel,
-            /**
-             * Shared by every row this call writes. Positions shift when a retried
-             * task's write mix changes, so a channel an earlier call already
-             * committed can land at a second index and be replayed twice; the group
-             * is what lets the read side tell that apart from a channel a single
-             * call legitimately wrote more than once.
-             */
-            writeGroup: nonce,
-            occurrence,
-            value: descriptor,
-        };
-        items.push(withTtl(item, ttlTimestamp));
-    }
-    return items;
-}
-//# sourceMappingURL=item-writer.js.map

package/dist/checkpointer/internal/item-writer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"item-writer.js","sourceRoot":"","sources":["../../../src/checkpointer/internal/item-writer.ts"],"names":[],"mappings":"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"}

package/dist/checkpointer/internal/keys.d.ts

@@ -1,31 +0,0 @@
-/** Reserved separator joining sort-key segments; forbidden inside any segment. */
-export declare const SORT_KEY_SEPARATOR = "#";
-/** Partition key for a thread: the adapter tag plus the thread id. */
-export declare function partitionKey(threadId: string): string;
-/** Sort key for a checkpoint's lightweight metadata item. */
-export declare function metaSortKey(checkpointNs: string, checkpointId: string): string;
-/** `begins_with` prefix selecting every META item in a namespace (for list). */
-export declare function metaSortKeyPrefix(checkpointNs: string): string;
-/** Sort key for a checkpoint's heavy payload item. */
-export declare function payloadSortKey(checkpointNs: string, checkpointId: string): string;
-/**
- * Sort key for a single pending write. The trailing `channel` segment is what
- * keeps two *different* channels from ever occupying one row: without it, a
- * retried task whose write mix changed could compute an index another
- * channel already holds, and the first-write-wins guard — which cannot tell a
- * genuine retry from an unrelated write — would silently discard it. The
- * channel is appended verbatim as the final segment, so two sort keys collide
- * only when their channels are byte-identical; `writeSortKeyPrefix` stops at
- * the checkpoint id, ahead of this segment, so `begins_with` reads are
- * unaffected.
- */
-export declare function writeSortKey(checkpointNs: string, checkpointId: string, taskId: string, index: number, channel: string): string;
-/**
- * True when `sortKey` is one this adapter writes. A partition query carries no
- * sort-key condition, so a partition-wide delete uses this to leave any row it
- * does not own in place rather than deleting the whole partition blindly.
- */
-export declare function isCheckpointerSortKey(sortKey: string): boolean;
-/** `begins_with` prefix selecting every WRITE item for one checkpoint. */
-export declare function writeSortKeyPrefix(checkpointNs: string, checkpointId: string): string;
-//# sourceMappingURL=keys.d.ts.map

package/dist/checkpointer/internal/keys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../src/checkpointer/internal/keys.ts"],"names":[],"mappings":"AAEA,kFAAkF;AAClF,eAAO,MAAM,kBAAkB,MAAM,CAAC;AA8BtC,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,6DAA6D;AAC7D,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEjF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GACd,MAAM,CAaR;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAI9D;AAED,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAErF"}

package/dist/checkpointer/internal/keys.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SORT_KEY_SEPARATOR = void 0;
-exports.partitionKey = partitionKey;
-exports.metaSortKey = metaSortKey;
-exports.metaSortKeyPrefix = metaSortKeyPrefix;
-exports.payloadSortKey = payloadSortKey;
-exports.writeSortKey = writeSortKey;
-exports.isCheckpointerSortKey = isCheckpointerSortKey;
-exports.writeSortKeyPrefix = writeSortKeyPrefix;
-const errors_1 = require("../../shared/errors/errors");
-/** Reserved separator joining sort-key segments; forbidden inside any segment. */
-exports.SORT_KEY_SEPARATOR = '#';
-/** Fixed digit width for the WRITE index so sort keys order numerically. */
-const WRITE_INDEX_PAD_WIDTH = 10;
-/**
- * Added to every write index before padding so the special negative slots from
- * `WRITES_IDX_MAP` (-1 ERROR .. -4 RESUME) encode as non-negative, sortable
- * integers that order below positional (0+) writes.
- */
-const WRITE_INDEX_OFFSET = 8;
-/** Sort-key kinds for the checkpoints table (the approved SK separation). */
-var CheckpointItemKind;
-(function (CheckpointItemKind) {
-    CheckpointItemKind["META"] = "META";
-    CheckpointItemKind["PAYLOAD"] = "PAYLOAD";
-    CheckpointItemKind["WRITE"] = "WRITE";
-})(CheckpointItemKind || (CheckpointItemKind = {}));
-/**
- * Adapter tag prefixed to every checkpointer partition key. Without it a
- * `thread_id` reused as a `sessionId` or a store namespace root — an ordinary
- * design choice — put all three adapters' rows in one partition on a table
- * shared via `DynamoDBFactory.createAll()`, where a partition-wide delete
- * reached another adapter's data and composed sort keys could collide
- * byte-for-byte. The three tags differ in their first character, so the key
- * spaces are disjoint by construction.
- */
-const ADAPTER_PARTITION_PREFIX = `CHKPT${exports.SORT_KEY_SEPARATOR}`;
-/** Partition key for a thread: the adapter tag plus the thread id. */
-function partitionKey(threadId) {
-    return `${ADAPTER_PARTITION_PREFIX}${threadId}`;
-}
-/** Sort key for a checkpoint's lightweight metadata item. */
-function metaSortKey(checkpointNs, checkpointId) {
-    return `${CheckpointItemKind.META}${exports.SORT_KEY_SEPARATOR}${checkpointNs}${exports.SORT_KEY_SEPARATOR}${checkpointId}`;
-}
-/** `begins_with` prefix selecting every META item in a namespace (for list). */
-function metaSortKeyPrefix(checkpointNs) {
-    return `${CheckpointItemKind.META}${exports.SORT_KEY_SEPARATOR}${checkpointNs}${exports.SORT_KEY_SEPARATOR}`;
-}
-/** Sort key for a checkpoint's heavy payload item. */
-function payloadSortKey(checkpointNs, checkpointId) {
-    return `${CheckpointItemKind.PAYLOAD}${exports.SORT_KEY_SEPARATOR}${checkpointNs}${exports.SORT_KEY_SEPARATOR}${checkpointId}`;
-}
-/**
- * Sort key for a single pending write. The trailing `channel` segment is what
- * keeps two *different* channels from ever occupying one row: without it, a
- * retried task whose write mix changed could compute an index another
- * channel already holds, and the first-write-wins guard — which cannot tell a
- * genuine retry from an unrelated write — would silently discard it. The
- * channel is appended verbatim as the final segment, so two sort keys collide
- * only when their channels are byte-identical; `writeSortKeyPrefix` stops at
- * the checkpoint id, ahead of this segment, so `begins_with` reads are
- * unaffected.
- */
-function writeSortKey(checkpointNs, checkpointId, taskId, index, channel) {
-    const offsetIndex = index + WRITE_INDEX_OFFSET;
-    if (offsetIndex < 0 || offsetIndex.toString().length > WRITE_INDEX_PAD_WIDTH) {
-        throw new errors_1.ValidationError(`write index ${index} is outside the range encodable at offset ${WRITE_INDEX_OFFSET} ` +
-            `with ${WRITE_INDEX_PAD_WIDTH} digits`, 'index');
-    }
-    const paddedIndex = offsetIndex.toString().padStart(WRITE_INDEX_PAD_WIDTH, '0');
-    return [CheckpointItemKind.WRITE, checkpointNs, checkpointId, taskId, paddedIndex, channel].join(exports.SORT_KEY_SEPARATOR);
-}
-/**
- * True when `sortKey` is one this adapter writes. A partition query carries no
- * sort-key condition, so a partition-wide delete uses this to leave any row it
- * does not own in place rather than deleting the whole partition blindly.
- */
-function isCheckpointerSortKey(sortKey) {
-    return Object.values(CheckpointItemKind).some((kind) => sortKey.startsWith(`${kind}${exports.SORT_KEY_SEPARATOR}`));
-}
-/** `begins_with` prefix selecting every WRITE item for one checkpoint. */
-function writeSortKeyPrefix(checkpointNs, checkpointId) {
-    return `${CheckpointItemKind.WRITE}${exports.SORT_KEY_SEPARATOR}${checkpointNs}${exports.SORT_KEY_SEPARATOR}${checkpointId}${exports.SORT_KEY_SEPARATOR}`;
-}
-//# sourceMappingURL=keys.js.map

package/dist/checkpointer/internal/keys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"keys.js","sourceRoot":"","sources":["../../../src/checkpointer/internal/keys.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,uDAA6D;AAE7D,kFAAkF;AACrE,QAAA,kBAAkB,GAAG,GAAG,CAAC;AAEtC,4EAA4E;AAC5E,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAEjC;;;;GAIG;AACH,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAE7B,6EAA6E;AAC7E,IAAK,kBAIJ;AAJD,WAAK,kBAAkB;IACrB,mCAAa,CAAA;IACb,yCAAmB,CAAA;IACnB,qCAAe,CAAA;AACjB,CAAC,EAJI,kBAAkB,KAAlB,kBAAkB,QAItB;AAED;;;;;;;;GAQG;AACH,MAAM,wBAAwB,GAAG,QAAQ,QAAA,kBAAkB,EAAE,CAAC;AAE9D,sEAAsE;AACtE,sBAA6B,QAAgB;IAC3C,OAAO,GAAG,wBAAwB,GAAG,QAAQ,EAAE,CAAC;AAClD,CAAC;AAED,6DAA6D;AAC7D,qBAA4B,YAAoB,EAAE,YAAoB;IACpE,OAAO,GAAG,kBAAkB,CAAC,IAAI,GAAG,QAAA,kBAAkB,GAAG,YAAY,GAAG,QAAA,kBAAkB,GAAG,YAAY,EAAE,CAAC;AAC9G,CAAC;AAED,gFAAgF;AAChF,2BAAkC,YAAoB;IACpD,OAAO,GAAG,kBAAkB,CAAC,IAAI,GAAG,QAAA,kBAAkB,GAAG,YAAY,GAAG,QAAA,kBAAkB,EAAE,CAAC;AAC/F,CAAC;AAED,sDAAsD;AACtD,wBAA+B,YAAoB,EAAE,YAAoB;IACvE,OAAO,GAAG,kBAAkB,CAAC,OAAO,GAAG,QAAA,kBAAkB,GAAG,YAAY,GAAG,QAAA,kBAAkB,GAAG,YAAY,EAAE,CAAC;AACjH,CAAC;AAED;;;;;;;;;;GAUG;AACH,sBACE,YAAoB,EACpB,YAAoB,EACpB,MAAc,EACd,KAAa,EACb,OAAe;IAEf,MAAM,WAAW,GAAG,KAAK,GAAG,kBAAkB,CAAC;IAC/C,IAAI,WAAW,GAAG,CAAC,IAAI,WAAW,CAAC,QAAQ,EAAE,CAAC,MAAM,GAAG,qBAAqB,EAAE,CAAC;QAC7E,MAAM,IAAI,wBAAe,CACvB,eAAe,KAAK,6CAA6C,kBAAkB,GAAG;YACpF,QAAQ,qBAAqB,SAAS,EACxC,OAAO,CACR,CAAC;IACJ,CAAC;IACD,MAAM,WAAW,GAAG,WAAW,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,qBAAqB,EAAE,GAAG,CAAC,CAAC;IAChF,OAAO,CAAC,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAC9F,QAAA,kBAAkB,CACnB,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,+BAAsC,OAAe;IACnD,OAAO,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CACrD,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,GAAG,QAAA,kBAAkB,EAAE,CAAC,CACnD,CAAC;AACJ,CAAC;AAED,0EAA0E;AAC1E,4BAAmC,YAAoB,EAAE,YAAoB;IAC3E,OAAO,GAAG,kBAAkB,CAAC,KAAK,GAAG,QAAA,kBAAkB,GAAG,YAAY,GAAG,QAAA,kBAAkB,GAAG,YAAY,GAAG,QAAA,kBAAkB,EAAE,CAAC;AACpI,CAAC"}

package/dist/checkpointer/internal/query.d.ts

@@ -1,20 +0,0 @@
-import type { QueryCommandInput } from '@aws-sdk/lib-dynamodb';
-/** Options for {@link partitionQuery}. */
-export interface PartitionQueryOptions {
-    consistent?: boolean;
-}
-/** Options for {@link beginsWithQuery}. */
-export interface BeginsWithQueryOptions {
-    limit?: number;
-    ascending?: boolean;
-    consistent?: boolean;
-}
-/** Build a Query input selecting every item in a partition (all sort keys). */
-export declare function partitionQuery(tableName: string, partition: string, options?: PartitionQueryOptions): QueryCommandInput;
-/**
- * Build a Query input selecting items whose partition equals `partition` and
- * whose sort key begins with `skPrefix`. Names are aliased so reserved words
- * never appear bare. Defaults to newest-first ordering.
- */
-export declare function beginsWithQuery(tableName: string, partition: string, skPrefix: string, options?: BeginsWithQueryOptions): QueryCommandInput;
-//# sourceMappingURL=query.d.ts.map

package/dist/checkpointer/internal/query.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/checkpointer/internal/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,0CAA0C;AAC1C,MAAM,WAAW,qBAAqB;IACpC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,2CAA2C;AAC3C,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,qBAA0B,GAClC,iBAAiB,CASnB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,sBAA2B,GACnC,iBAAiB,CAWnB"}

package/dist/checkpointer/internal/query.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.partitionQuery = partitionQuery;
-exports.beginsWithQuery = beginsWithQuery;
-/** Build a Query input selecting every item in a partition (all sort keys). */
-function partitionQuery(tableName, partition, options = {}) {
-    const params = {
-        TableName: tableName,
-        KeyConditionExpression: '#pk = :pk',
-        ExpressionAttributeNames: { '#pk': 'PK' },
-        ExpressionAttributeValues: { ':pk': partition },
-    };
-    if (options.consistent)
-        params.ConsistentRead = true;
-    return params;
-}
-/**
- * Build a Query input selecting items whose partition equals `partition` and
- * whose sort key begins with `skPrefix`. Names are aliased so reserved words
- * never appear bare. Defaults to newest-first ordering.
- */
-function beginsWithQuery(tableName, partition, skPrefix, options = {}) {
-    const params = {
-        TableName: tableName,
-        KeyConditionExpression: '#pk = :pk AND begins_with(#sk, :skPrefix)',
-        ExpressionAttributeNames: { '#pk': 'PK', '#sk': 'SK' },
-        ExpressionAttributeValues: { ':pk': partition, ':skPrefix': skPrefix },
-        ScanIndexForward: options.ascending ?? false,
-    };
-    if (options.limit !== undefined)
-        params.Limit = options.limit;
-    if (options.consistent)
-        params.ConsistentRead = true;
-    return params;
-}
-//# sourceMappingURL=query.js.map

package/dist/checkpointer/internal/query.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.js","sourceRoot":"","sources":["../../../src/checkpointer/internal/query.ts"],"names":[],"mappings":";;;;AAcA,+EAA+E;AAC/E,wBACE,SAAiB,EACjB,SAAiB,EACjB,OAAO,GAA0B,EAAE;IAEnC,MAAM,MAAM,GAAsB;QAChC,SAAS,EAAE,SAAS;QACpB,sBAAsB,EAAE,WAAW;QACnC,wBAAwB,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;QACzC,yBAAyB,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;KAChD,CAAC;IACF,IAAI,OAAO,CAAC,UAAU;QAAE,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;IACrD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,yBACE,SAAiB,EACjB,SAAiB,EACjB,QAAgB,EAChB,OAAO,GAA2B,EAAE;IAEpC,MAAM,MAAM,GAAsB;QAChC,SAAS,EAAE,SAAS;QACpB,sBAAsB,EAAE,2CAA2C;QACnE,wBAAwB,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE;QACtD,yBAAyB,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE;QACtE,gBAAgB,EAAE,OAAO,CAAC,SAAS,IAAI,KAAK;KAC7C,CAAC;IACF,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS;QAAE,MAAM,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAC9D,IAAI,OAAO,CAAC,UAAU;QAAE,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;IACrD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/checkpointer/internal/setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../src/checkpointer/internal/setup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAExE,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAG9D,OAAO,EAAE,KAAK,MAAM,EAAiB,MAAM,6BAA6B,CAAC;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD,kEAAkE;AAClE,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,kBAAkB,CAAC;IAC1B,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,2DAA2D;AAC3D,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,SAAS,EAAE,cAAc,GAAG,SAAS,CAAC;IACtC,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,oBAAoB,EAC7B,KAAK,EAAE,kBAAkB,GACxB,iBAAiB,CAsBnB"}

package/dist/checkpointer/internal/setup.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup.js","sourceRoot":"","sources":["../../../src/checkpointer/internal/setup.ts"],"names":[],"mappings":";;;AAKA,yDAAuE;AACvE,+DAA8D;AAC9D,sDAA+D;AAC/D,yDAAqE;AACrE,wDAAyE;AAsBzE;;;;GAIG;AACH,2BACE,OAA6B,EAC7B,KAAyB;IAEzB,MAAM,QAAQ,GAAG,IAAA,8BAAqB,EAAC,OAAO,CAAC,CAAC;IAChD,MAAM,SAAS,GAAG,OAAO,CAAC,EAAE;QAC1B,CAAC,CAAC,IAAI,uBAAW,CAAC;YACd,GAAG,OAAO,CAAC,EAAE;YACb,SAAS,EACP,OAAO,CAAC,EAAE,CAAC,SAAS,IAAI,IAAA,gCAAuB,EAAC,iCAAqB,EAAE,cAAc,CAAC;SACzF,CAAC;QACJ,CAAC,CAAC,SAAS,CAAC;IACd,OAAO;QACL,OAAO,EAAE;YACP,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,KAAK;YACL,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,SAAS;YACT,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,MAAM,EAAE,IAAA,sBAAa,EAAC,OAAO,CAAC,MAAM,CAAC;SACtC;QACD,SAAS,EAAE,QAAQ,CAAC,SAAS;QAC7B,UAAU,EAAE,QAAQ,CAAC,UAAU;KAChC,CAAC;AACJ,CAAC"}

package/dist/checkpointer/internal/special-write-cas.d.ts

@@ -1,30 +0,0 @@
-import type { CheckpointWriteItem } from '../types';
-import type { CheckpointerContext } from './setup';
-import { type SpecialWriteOutcome } from './special-write-verify';
-/**
- * Overwrite one special row, pinned to the `writeGroup` this call observed, and
- * report the descriptor it superseded.
- *
- * Overwriting is correct for special channels — every reference implementation
- * does it — but two concurrent calls to the same channel both read the same
- * previous descriptor and both delete it, orphaning the loser's upload. Pinning
- * the observed `writeGroup` and re-reading on rejection makes each call
- * supersede exactly one payload.
- *
- * `BatchWriteItem` cannot carry conditions, which is why this path issues
- * individual puts; a call holds at most one row per special channel, so that is
- * four writes at worst.
- *
- * The compare-and-swap runs only when an offloader is configured — matching
- * `store/internal/persist.ts` — because without one there is no S3 object to
- * orphan, so a plain unconditional put stays correct and costs no extra
- * ConsistentRead or write capacity. That shortcut is also why the surviving
- * `catch` may report `committed: false` without verifying: with no offloader
- * there is no object for the caller to delete on the strength of it.
- *
- * Never rejects: the caller runs this concurrently with the regular writes
- * under `Promise.all`, whose own cleanup depends on every branch resolving
- * rather than short-circuiting.
- */
-export declare function writeSpecialItem(context: CheckpointerContext, item: CheckpointWriteItem): Promise<SpecialWriteOutcome>;
-//# sourceMappingURL=special-write-cas.d.ts.map

package/dist/checkpointer/internal/special-write-cas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"special-write-cas.d.ts","sourceRoot":"","sources":["../../../src/checkpointer/internal/special-write-cas.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAIL,KAAK,mBAAmB,EAEzB,MAAM,wBAAwB,CAAC;AAsEhC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CAoB9B"}

package/dist/checkpointer/internal/special-write-cas.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeSpecialItem = writeSpecialItem;
-const conditional_put_1 = require("../../shared/dynamodb/conditional-put");
-const retry_1 = require("../../shared/dynamodb/retry");
-const special_write_verify_1 = require("./special-write-verify");
-/**
- * Retry a conditional put up to {@link OVERWRITE_CAS_MAX_ATTEMPTS} times,
- * re-reading the row each time a racer's write invalidates the pinned
- * `writeGroup`. Extracted from {@link writeSpecialItem} to keep both
- * functions under the repo's block-nesting limit.
- *
- * A rejection is not proof a competitor won: `withDynamoDBRetry` retries
- * transient errors, so an attempt can commit server-side, its response can be
- * lost, and the retried put can hit the row it just wrote and fail the same
- * guard — indistinguishable from a competitor's win by the rejection alone.
- * Each attempt's pinned observation is captured in `attempted` before the
- * put, so that when {@link verifyAfterFailure} finds the row already holding
- * *this item's own* `writeGroup`, the outcome reports having superseded
- * whatever `attempted` held — never the item's own just-committed payload,
- * which would strand the live row pointing at a deleted object.
- *
- * Only a rejection whose re-read proves some *other* writer holds the row is
- * retried; every other failure is already settled by the verification.
- */
-async function attemptCasWrites(context, item, initial) {
-    let observed = initial;
-    for (let attempt = 1; attempt <= conditional_put_1.OVERWRITE_CAS_MAX_ATTEMPTS; attempt++) {
-        const attempted = observed;
-        try {
-            await (0, retry_1.withDynamoDBRetry)(() => context.client.put({
-                TableName: context.tableName,
-                Item: item,
-                ...(0, conditional_put_1.revisionGuard)(special_write_verify_1.SPECIAL_REVISION_ATTRIBUTE, attempted),
-            }));
-            return { done: true, outcome: { committed: true, superseded: attempted.value } };
-        }
-        catch (error) {
-            const verified = await (0, special_write_verify_1.verifyAfterFailure)(context, item, attempted, error);
-            if (!verified.observed || !(0, conditional_put_1.isConditionalCheckFailed)(error)) {
-                return { done: true, outcome: verified.outcome };
-            }
-            observed = verified.observed;
-        }
-    }
-    return { done: false, observed };
-}
-/**
- * Overwrite the row unconditionally once the compare-and-swap budget is spent,
- * verifying rather than assuming if that put fails too.
- */
-async function overwriteUnconditionally(context, item, observed) {
-    try {
-        await (0, retry_1.withDynamoDBRetry)(() => context.client.put({ TableName: context.tableName, Item: item }));
-        return { committed: true, superseded: observed.value };
-    }
-    catch (error) {
-        return (await (0, special_write_verify_1.verifyAfterFailure)(context, item, observed, error)).outcome;
-    }
-}
-/**
- * Overwrite one special row, pinned to the `writeGroup` this call observed, and
- * report the descriptor it superseded.
- *
- * Overwriting is correct for special channels — every reference implementation
- * does it — but two concurrent calls to the same channel both read the same
- * previous descriptor and both delete it, orphaning the loser's upload. Pinning
- * the observed `writeGroup` and re-reading on rejection makes each call
- * supersede exactly one payload.
- *
- * `BatchWriteItem` cannot carry conditions, which is why this path issues
- * individual puts; a call holds at most one row per special channel, so that is
- * four writes at worst.
- *
- * The compare-and-swap runs only when an offloader is configured — matching
- * `store/internal/persist.ts` — because without one there is no S3 object to
- * orphan, so a plain unconditional put stays correct and costs no extra
- * ConsistentRead or write capacity. That shortcut is also why the surviving
- * `catch` may report `committed: false` without verifying: with no offloader
- * there is no object for the caller to delete on the strength of it.
- *
- * Never rejects: the caller runs this concurrently with the regular writes
- * under `Promise.all`, whose own cleanup depends on every branch resolving
- * rather than short-circuiting.
- */
-async function writeSpecialItem(context, item) {
-    try {
-        if (!context.offloader) {
-            await (0, retry_1.withDynamoDBRetry)(() => context.client.put({ TableName: context.tableName, Item: item }));
-            return { committed: true };
-        }
-        const initial = await (0, special_write_verify_1.readSpecialRow)(context, item);
-        const attempt = await attemptCasWrites(context, item, initial);
-        if (attempt.done)
-            return attempt.outcome;
-        context.logger.warn('putWrites: special-write compare-and-swap exhausted; overwriting unconditionally, which ' +
-            'can orphan one S3 object under a concurrent call (reclaimed by ensureS3LifecycleRule)', { sortKey: item.SK, channel: item.channel, attempts: conditional_put_1.OVERWRITE_CAS_MAX_ATTEMPTS });
-        return await overwriteUnconditionally(context, item, attempt.observed);
-    }
-    catch (error) {
-        return { committed: false, error: error };
-    }
-}
-//# sourceMappingURL=special-write-cas.js.map

package/dist/checkpointer/internal/special-write-cas.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"special-write-cas.js","sourceRoot":"","sources":["../../../src/checkpointer/internal/special-write-cas.ts"],"names":[],"mappings":"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"}

package/dist/checkpointer/internal/special-write-cleanup.d.ts

@@ -1,24 +0,0 @@
-import type { CheckpointWriteItem } from '../types';
-import type { CheckpointerContext } from './setup';
-/**
- * Write special (negative-index) items, then clean up the correct side of each.
- *
- * Overwrite is correct here, matching every reference checkpointer. Each item
- * is written with a compare-and-swap on its row's `writeGroup` (see
- * {@link writeSpecialItem}) so a concurrent call to the same special channel
- * cannot make both callers delete the same superseded object and orphan one
- * upload. A committed item cleans up the payload it actually superseded; an
- * item confirmed never to have committed cleans up its own new upload.
- *
- * "Confirmed" is load-bearing, and {@link writeSpecialItem} is what earns it:
- * an ambiguous failure is verified against the row and reported as committed
- * unless the read proves otherwise. Deleting on *unknown* would strand a live
- * row pointing at a deleted object; leaking one object instead is recoverable.
- *
- * Never rejects — a failure is reported via the return value, because the
- * caller runs this concurrently with `writeRegularItems` under `Promise.all`,
- * whose own cleanup depends on every branch resolving rather than
- * short-circuiting.
- */
-export declare function writeSpecialItemsWithCleanup(context: CheckpointerContext, items: CheckpointWriteItem[]): Promise<Error | undefined>;
-//# sourceMappingURL=special-write-cleanup.d.ts.map

package/dist/checkpointer/internal/special-write-cleanup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"special-write-cleanup.d.ts","sourceRoot":"","sources":["../../../src/checkpointer/internal/special-write-cleanup.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAgBnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,mBAAmB,EAC5B,KAAK,EAAE,mBAAmB,EAAE,GAC3B,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAmB5B"}

package/dist/checkpointer/internal/special-write-cleanup.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeSpecialItemsWithCleanup = writeSpecialItemsWithCleanup;
-const descriptor_keys_1 = require("../../shared/codec/descriptor-keys");
-const orphans_1 = require("../../shared/codec/s3/orphans");
-const special_write_cas_1 = require("./special-write-cas");
-/** Best-effort delete the S3 objects backing `descriptors`, if offloading is on. */
-async function deleteDescriptors(context, descriptors, label) {
-    if (!context.offloader)
-        return;
-    const present = descriptors.filter((d) => d !== undefined);
-    if (present.length === 0)
-        return;
-    await (0, orphans_1.cleanUpS3Orphans)(context.offloader, (0, descriptor_keys_1.collectS3Keys)(present), label, context.logger);
-}
-/**
- * Write special (negative-index) items, then clean up the correct side of each.
- *
- * Overwrite is correct here, matching every reference checkpointer. Each item
- * is written with a compare-and-swap on its row's `writeGroup` (see
- * {@link writeSpecialItem}) so a concurrent call to the same special channel
- * cannot make both callers delete the same superseded object and orphan one
- * upload. A committed item cleans up the payload it actually superseded; an
- * item confirmed never to have committed cleans up its own new upload.
- *
- * "Confirmed" is load-bearing, and {@link writeSpecialItem} is what earns it:
- * an ambiguous failure is verified against the row and reported as committed
- * unless the read proves otherwise. Deleting on *unknown* would strand a live
- * row pointing at a deleted object; leaking one object instead is recoverable.
- *
- * Never rejects — a failure is reported via the return value, because the
- * caller runs this concurrently with `writeRegularItems` under `Promise.all`,
- * whose own cleanup depends on every branch resolving rather than
- * short-circuiting.
- */
-async function writeSpecialItemsWithCleanup(context, items) {
-    if (items.length === 0)
-        return undefined;
-    const outcomes = await Promise.all(items.map(async (item) => [
-        item,
-        await (0, special_write_cas_1.writeSpecialItem)(context, item),
-    ]));
-    await deleteDescriptors(context, outcomes.filter(([, o]) => o.committed).map(([, o]) => o.superseded), 'putWrites.special.previous');
-    await deleteDescriptors(context, outcomes.filter(([, o]) => !o.committed).map(([item]) => item.value), 'putWrites.special.newUpload');
-    return outcomes.find(([, o]) => o.error)?.[1].error;
-}
-//# sourceMappingURL=special-write-cleanup.js.map

package/dist/checkpointer/internal/special-write-cleanup.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"special-write-cleanup.js","sourceRoot":"","sources":["../../../src/checkpointer/internal/special-write-cleanup.ts"],"names":[],"mappings":";;;AACA,wEAAmE;AACnE,2DAAiE;AAGjE,2DAAuD;AAGvD,oFAAoF;AACpF,KAAK,UAAU,iBAAiB,CAC9B,OAA4B,EAC5B,WAA8C,EAC9C,KAAa;IAEb,IAAI,CAAC,OAAO,CAAC,SAAS;QAAE,OAAO;IAC/B,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAA0B,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;IACnF,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IACjC,MAAM,IAAA,0BAAgB,EAAC,OAAO,CAAC,SAAS,EAAE,IAAA,+BAAa,EAAC,OAAO,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;AAC3F,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACI,KAAK,uCACV,OAA4B,EAC5B,KAA4B;IAE5B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACzC,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAChC,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAuD,EAAE,CAAC;QAC7E,IAAI;QACJ,MAAM,IAAA,oCAAgB,EAAC,OAAO,EAAE,IAAI,CAAC;KACtC,CAAC,CACH,CAAC;IACF,MAAM,iBAAiB,CACrB,OAAO,EACP,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,EACpE,4BAA4B,CAC7B,CAAC;IACF,MAAM,iBAAiB,CACrB,OAAO,EACP,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EACpE,6BAA6B,CAC9B,CAAC;IACF,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AACtD,CAAC"}

package/dist/checkpointer/internal/special-write-verify.d.ts

@@ -1,54 +0,0 @@
-import type { PayloadDescriptor } from '../../shared/codec/codec';
-import type { CheckpointWriteItem } from '../types';
-import type { CheckpointerContext } from './setup';
-/**
- * A special row already carries a per-call ULID in `writeGroup`, so it needs no
- * extra revision attribute to compare and swap on.
- */
-export declare const SPECIAL_REVISION_ATTRIBUTE = "writeGroup";
-/** What a special item's row held before this call tried to overwrite it. */
-export interface SpecialRowState {
-    exists: boolean;
-    value?: PayloadDescriptor;
-    revision?: string;
-}
-/** Outcome of one special item's conditional write. Never thrown, always returned. */
-export interface SpecialWriteOutcome {
-    committed: boolean;
-    superseded?: PayloadDescriptor;
-    error?: Error;
-}
-/** What a post-failure verification read established about the attempt. */
-export interface VerifiedFailure {
-    outcome: SpecialWriteOutcome;
-    /** Present only when the row was read and holds some other writer's group. */
-    observed?: SpecialRowState;
-}
-/** Read a special row's current descriptor and the writeGroup guarding it. */
-export declare function readSpecialRow(context: CheckpointerContext, item: CheckpointWriteItem): Promise<SpecialRowState>;
-/**
- * Read the row back after a put failed, and report what that failure actually
- * did — never assuming it did nothing.
- *
- * No rejection is proof of a non-commit. `withDynamoDBRetry` re-issues a put
- * whose response was lost, and those re-issues can time out at the transport
- * without ever reaching DynamoDB, so the budget is spent on a
- * `RetryExhaustedError` and never on a `ConditionalCheckFailedException` — yet
- * the row is committed. Reporting that as a confirmed non-commit let
- * `writeSpecialItemsWithCleanup` delete the S3 object the live row points at,
- * so every later `getTuple()` on that checkpoint failed with `NoSuchKey`,
- * permanently.
- *
- * Three answers are possible:
- * - the row holds this item's own `writeGroup`: the write landed, and the
- *   descriptor this attempt pinned is the dead one.
- * - the row holds some other group: the write is confirmed not to be what is
- *   live, so this item's own upload is the dead one. `observed` is returned so
- *   a rejected compare-and-swap can re-pin and try again.
- * - the read itself fails: nothing is confirmed, so the outcome still reports a
- *   commit and keeps the originating error. That leaks one S3 object at worst
- *   (reclaimed by `ensureS3LifecycleRule`) where the alternative strands a live
- *   row — the same trade `store/internal/persist.ts` makes.
- */
-export declare function verifyAfterFailure(context: CheckpointerContext, item: CheckpointWriteItem, attempted: SpecialRowState, error: Error): Promise<VerifiedFailure>;
-//# sourceMappingURL=special-write-verify.d.ts.map

package/dist/checkpointer/internal/special-write-verify.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"special-write-verify.d.ts","sourceRoot":"","sources":["../../../src/checkpointer/internal/special-write-verify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,eAAe,CAAC;AAEvD,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,sFAAsF;AACtF,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,mBAAmB,CAAC;IAC7B,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B;AAED,8EAA8E;AAC9E,wBAAsB,cAAc,CAClC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,eAAe,CAAC,CAgB1B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,mBAAmB,EACzB,SAAS,EAAE,eAAe,EAC1B,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,eAAe,CAAC,CAU1B"}