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

package/dist/checkpointer/internal/keys.js

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MIN_ENCODABLE_WRITE_INDEX = exports.SORT_KEY_SEPARATOR = void 0;
-exports.checkpointerPartitionPrefix = checkpointerPartitionPrefix;
-exports.partitionKey = partitionKey;
-exports.metaSortKey = metaSortKey;
-exports.metaSortKeyPrefix = metaSortKeyPrefix;
-exports.metaAnyNamespacePrefix = metaAnyNamespacePrefix;
-exports.payloadSortKey = payloadSortKey;
-exports.writeSortKey = writeSortKey;
-exports.isCheckpointerSortKey = isCheckpointerSortKey;
-exports.writeSortKeyPrefix = writeSortKeyPrefix;
-const constants_1 = require("../../shared/constants");
-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;
-/**
- * The most negative write index the sort key can encode, `-WRITE_INDEX_OFFSET`.
- * A static test pins it against the peer's `WRITES_IDX_MAP`, so a peer bump
- * that adds a more negative special slot fails loudly instead of producing
- * unsortable keys.
- */
-exports.MIN_ENCODABLE_WRITE_INDEX = -WRITE_INDEX_OFFSET;
-/** 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}`;
-/** The tag every checkpointer partition key starts with, for a table-wide `begins_with`. */
-function checkpointerPartitionPrefix() {
-    return ADAPTER_PARTITION_PREFIX;
-}
-/** 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}`;
-}
-/** `begins_with` prefix selecting every META item of a thread, whatever its namespace. */
-function metaAnyNamespacePrefix() {
-    return `${CheckpointItemKind.META}${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');
-    const sortKey = [
-        CheckpointItemKind.WRITE,
-        checkpointNs,
-        checkpointId,
-        taskId,
-        paddedIndex,
-        channel,
-    ].join(exports.SORT_KEY_SEPARATOR);
-    const bytes = Buffer.byteLength(sortKey, 'utf8');
-    if (bytes > constants_1.MAX_SORT_KEY_BYTES) {
-        throw new errors_1.ValidationError(`checkpoint_ns, checkpoint_id, taskId and channel compose a ${bytes}-byte sort key; ` +
-            `DynamoDB caps sort keys at ${constants_1.MAX_SORT_KEY_BYTES} bytes`, 'sortKey');
-    }
-    return sortKey;
-}
-/**
- * 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}`;
-}

package/dist/checkpointer/internal/list-scope.d.ts

@@ -1,61 +0,0 @@
-import type { QueryCommandInput, ScanCommandInput } from '@aws-sdk/lib-dynamodb';
-import type { RunnableConfig } from '@langchain/core/runnables';
-import type { CheckpointListOptions, CheckpointMetadata } from '@langchain/langgraph-checkpoint';
-import type { CheckpointMetaItem } from '../types';
-import { type FilterValue } from './filter-match';
-import type { CheckpointerContext } from './setup';
-/** What one `list()` call covers, read once from its config and options. */
-export interface ListScope {
-    /** Undefined when the caller gave no `thread_id`: every thread in the table is listed. */
-    threadId: string | undefined;
-    /** Undefined when the caller gave no `checkpoint_ns`: every namespace of the thread is listed. */
-    checkpointNs: string | undefined;
-    checkpointId: string | undefined;
-    before: string | undefined;
-    filter: Record<string, FilterValue> | undefined;
-    limit: number | undefined;
-    signal: AbortSignal | undefined;
-}
-/**
- * Read the scope. Unlike `getTuple`, which addresses the root namespace when
- * none is given, `list()` without a `checkpoint_ns` covers every namespace,
- * and without a `thread_id` every thread, as the reference savers do; the
- * identifiers that are given are validated either way.
- */
-export declare function readListScope(config: RunnableConfig, options?: CheckpointListOptions): ListScope;
-/**
- * The META query for a scope. A metadata filter means rows may be dropped
- * client-side, so only an unfiltered list passes the caller's limit through as
- * the page size. With an explicit namespace `before` bounds the key range so
- * rows newer than it are never read; across namespaces ids do not share one
- * order and `before` is applied in-process.
- */
-export declare function listQuery(context: CheckpointerContext, scope: ListScope & {
-    threadId: string;
-}): QueryCommandInput;
-/**
- * The table `Scan` a thread-less `list()` runs: every checkpointer META row,
- * narrowed to one namespace when the caller gave one. It is what the
- * reference savers do for a config without a thread, and on DynamoDB it costs
- * a read of the whole table.
- */
-export declare function listScan(context: CheckpointerContext, scope: ListScope): ScanCommandInput;
-/**
- * True when `meta` passes the key-level filters: strictly older than `before`,
- * and — on a table scan, where the key condition cannot narrow them — in the
- * requested namespace and, when one is given, the requested checkpoint.
- */
-export declare function passesKeyFilters(meta: CheckpointMetaItem, scope: ListScope): boolean;
-/** Outcome of the metadata filter: rejected, or accepted with any metadata decoded on the way. */
-export type MetadataVerdict = {
-    pass: false;
-} | {
-    pass: true;
-    metadata?: CheckpointMetadata;
-};
-/**
- * Apply the optional metadata-equality filter. The metadata decoded here is
- * handed to the tuple assembly, so a filtered list decodes (and, when offloaded,
- * downloads) each metadata blob once instead of twice.
- */
-export declare function passesMetadataFilter(context: CheckpointerContext, meta: CheckpointMetaItem, scope: ListScope): Promise<MetadataVerdict>;

package/dist/checkpointer/internal/list-scope.js

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readListScope = readListScope;
-exports.listQuery = listQuery;
-exports.listScan = listScan;
-exports.passesKeyFilters = passesKeyFilters;
-exports.passesMetadataFilter = passesMetadataFilter;
-const configurable_1 = require("./configurable");
-const filter_match_1 = require("./filter-match");
-const item_reader_1 = require("./item-reader");
-const keys_1 = require("./keys");
-const query_1 = require("./query");
-const validation_1 = require("./validation");
-/** The identifiers of a config that names no thread, validated the same way. */
-function readThreadless(config) {
-    const checkpointNs = config.configurable?.checkpoint_ns ?? '';
-    (0, validation_1.validateCheckpointNs)(checkpointNs);
-    const rawId = config.configurable?.checkpoint_id;
-    const checkpointId = rawId ? rawId : undefined;
-    if (checkpointId !== undefined)
-        (0, validation_1.validateCheckpointId)(checkpointId);
-    return { threadId: '', checkpointNs, checkpointId };
-}
-/** The identifiers a list config names; a config without a thread is still validated for the ids it gives. */
-function resolveListIds(config) {
-    if (config.configurable?.thread_id === undefined) {
-        return { ...readThreadless(config), threadId: undefined };
-    }
-    return (0, configurable_1.readConfigurable)(config);
-}
-/**
- * Read the scope. Unlike `getTuple`, which addresses the root namespace when
- * none is given, `list()` without a `checkpoint_ns` covers every namespace,
- * and without a `thread_id` every thread, as the reference savers do; the
- * identifiers that are given are validated either way.
- */
-function readListScope(config, options) {
-    const { threadId, checkpointNs, checkpointId } = resolveListIds(config);
-    return {
-        threadId,
-        checkpointNs: config.configurable?.checkpoint_ns === undefined ? undefined : checkpointNs,
-        checkpointId,
-        before: options?.before?.configurable?.checkpoint_id,
-        filter: options?.filter,
-        limit: options?.limit,
-        signal: config.signal,
-    };
-}
-/**
- * The META query for a scope. A metadata filter means rows may be dropped
- * client-side, so only an unfiltered list passes the caller's limit through as
- * the page size. With an explicit namespace `before` bounds the key range so
- * rows newer than it are never read; across namespaces ids do not share one
- * order and `before` is applied in-process.
- */
-function listQuery(context, scope) {
-    const partition = (0, keys_1.partitionKey)(scope.threadId);
-    const limit = scope.filter === undefined ? scope.limit : undefined;
-    if (scope.checkpointNs === undefined) {
-        return (0, query_1.beginsWithQuery)(context.tableName, partition, (0, keys_1.metaAnyNamespacePrefix)(), { limit });
-    }
-    return (0, query_1.beginsWithQuery)(context.tableName, partition, (0, keys_1.metaSortKeyPrefix)(scope.checkpointNs), {
-        limit,
-        beforeSortKey: scope.before === undefined ? undefined : (0, keys_1.metaSortKey)(scope.checkpointNs, scope.before),
-    });
-}
-/**
- * The table `Scan` a thread-less `list()` runs: every checkpointer META row,
- * narrowed to one namespace when the caller gave one. It is what the
- * reference savers do for a config without a thread, and on DynamoDB it costs
- * a read of the whole table.
- */
-function listScan(context, scope) {
-    return {
-        TableName: context.tableName,
-        FilterExpression: 'begins_with(#pk, :pk) AND begins_with(#sk, :sk)',
-        ExpressionAttributeNames: { '#pk': 'PK', '#sk': 'SK' },
-        ExpressionAttributeValues: {
-            ':pk': (0, keys_1.checkpointerPartitionPrefix)(),
-            ':sk': scope.checkpointNs === undefined
-                ? (0, keys_1.metaAnyNamespacePrefix)()
-                : (0, keys_1.metaSortKeyPrefix)(scope.checkpointNs),
-        },
-    };
-}
-/**
- * True when `meta` passes the key-level filters: strictly older than `before`,
- * and — on a table scan, where the key condition cannot narrow them — in the
- * requested namespace and, when one is given, the requested checkpoint.
- */
-function passesKeyFilters(meta, scope) {
-    return ((scope.before === undefined || meta.checkpointId < scope.before) &&
-        (scope.checkpointNs === undefined || meta.checkpointNs === scope.checkpointNs) &&
-        (scope.checkpointId === undefined || meta.checkpointId === scope.checkpointId));
-}
-/**
- * Apply the optional metadata-equality filter. The metadata decoded here is
- * handed to the tuple assembly, so a filtered list decodes (and, when offloaded,
- * downloads) each metadata blob once instead of twice.
- */
-async function passesMetadataFilter(context, meta, scope) {
-    if (!scope.filter)
-        return { pass: true };
-    const metadata = await (0, item_reader_1.readMetadata)(context, meta, meta.threadId);
-    return (0, filter_match_1.matchesFilter)(metadata, scope.filter)
-        ? { pass: true, metadata }
-        : { pass: false };
-}

package/dist/checkpointer/internal/pending-sends.d.ts

@@ -1,13 +0,0 @@
-import { type Checkpoint } from '@langchain/langgraph-checkpoint';
-import { type ReadOptions } from './fetch';
-import type { CheckpointerContext } from './setup';
-/**
- * Pre-v4 checkpoints kept a task's `Send`s as `__pregel_tasks` pending writes
- * on the parent rather than in the checkpoint itself. Reading such a
- * checkpoint rebuilds `channel_values[TASKS]` from those writes and stamps
- * the channel with the highest version the checkpoint already carries (or
- * the first version when it carries none), exactly as the reference savers
- * do, so a thread written before LangGraph 0.2 still resumes. A v4 checkpoint,
- * or one without a parent, is returned untouched.
- */
-export declare function migratePendingSends(context: CheckpointerContext, checkpoint: Checkpoint, threadId: string, checkpointNs: string, parentCheckpointId: string | undefined, read: ReadOptions): Promise<Checkpoint>;

package/dist/checkpointer/internal/pending-sends.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.migratePendingSends = migratePendingSends;
-const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
-const fetch_1 = require("./fetch");
-/**
- * Pre-v4 checkpoints kept a task's `Send`s as `__pregel_tasks` pending writes
- * on the parent rather than in the checkpoint itself. Reading such a
- * checkpoint rebuilds `channel_values[TASKS]` from those writes and stamps
- * the channel with the highest version the checkpoint already carries (or
- * the first version when it carries none), exactly as the reference savers
- * do, so a thread written before LangGraph 0.2 still resumes. A v4 checkpoint,
- * or one without a parent, is returned untouched.
- */
-async function migratePendingSends(context, checkpoint, threadId, checkpointNs, parentCheckpointId, read) {
-    if (checkpoint.v >= 4 || parentCheckpointId === undefined)
-        return checkpoint;
-    const writes = await (0, fetch_1.fetchPendingWrites)(context, threadId, checkpointNs, parentCheckpointId, read);
-    const sends = writes.filter(([, channel]) => channel === langgraph_checkpoint_1.TASKS).map(([, , value]) => value);
-    const versions = Object.values(checkpoint.channel_versions);
-    return {
-        ...checkpoint,
-        channel_values: { ...checkpoint.channel_values, [langgraph_checkpoint_1.TASKS]: sends },
-        channel_versions: {
-            ...checkpoint.channel_versions,
-            [langgraph_checkpoint_1.TASKS]: versions.length > 0 ? (0, langgraph_checkpoint_1.maxChannelVersion)(...versions) : 1,
-        },
-    };
-}

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

@@ -1,21 +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;
-    /** Inclusive upper bound on the sort key; turns the prefix match into a `BETWEEN`. */
-    beforeSortKey?: string;
-    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;

package/dist/checkpointer/internal/query.js

@@ -1,42 +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 bounded = options.beforeSortKey !== undefined;
-    const params = {
-        TableName: tableName,
-        KeyConditionExpression: bounded
-            ? '#pk = :pk AND #sk BETWEEN :skPrefix AND :before'
-            : '#pk = :pk AND begins_with(#sk, :skPrefix)',
-        ExpressionAttributeNames: { '#pk': 'PK', '#sk': 'SK' },
-        ExpressionAttributeValues: {
-            ':pk': partition,
-            ':skPrefix': skPrefix,
-            ...(bounded ? { ':before': options.beforeSortKey } : {}),
-        },
-        ScanIndexForward: options.ascending ?? false,
-    };
-    if (options.limit !== undefined)
-        params.Limit = options.limit;
-    if (options.consistent)
-        params.ConsistentRead = true;
-    return params;
-}

package/dist/checkpointer/internal/regular-write.d.ts

@@ -1,28 +0,0 @@
-import type { CheckpointWriteItem } from '../types';
-import type { CheckpointerContext } from './setup';
-/**
- * Outcome of {@link writeRegularItems}: never rejects. `deadUploads` holds
- * exactly the items whose own S3 upload is confirmed unreferenced — a
- * verified non-commit, or a guard rejection whose returned row provably
- * belongs to another call — and is therefore safe to delete. Everything else
- * either committed, was turned away by a row this call may have written
- * itself, or could not be verified; none of those may be cleaned up.
- */
-export interface RegularWriteOutcome {
-    deadUploads: CheckpointWriteItem[];
-    error?: Error;
-}
-/**
- * Write regular items with a first-write-wins guard. Every `PutCommand` fully
- * settles (`Promise.allSettled`) before this resolves and never rejects; a
- * genuine failure is reported via `error`, not thrown.
- *
- * A failure is not proof of a non-commit: `withDynamoDBRetry` re-issues a put
- * whose response was lost, and the re-issues can time out at the transport, so
- * the budget is spent on a `RetryExhaustedError` while the row is live.
- * Treating that as "never reached DynamoDB" deleted the object the live row
- * pointed at, making the checkpoint's pending writes unreadable forever. Each
- * such failure is therefore verified against the row before it is classified,
- * and a committed one is not an error at all.
- */
-export declare function writeRegularItems(context: CheckpointerContext, items: CheckpointWriteItem[], signal?: AbortSignal): Promise<RegularWriteOutcome>;

package/dist/checkpointer/internal/regular-write.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeRegularItems = writeRegularItems;
-const conditional_put_1 = require("../../shared/dynamodb/conditional-put");
-const retry_1 = require("../../shared/dynamodb/retry");
-const retry_policy_1 = require("../../shared/dynamodb/retry-policy");
-const special_write_verify_1 = require("./special-write-verify");
-const write_guard_1 = require("./write-guard");
-/**
- * Resolve a non-guard failure by reading the row back. Without an offloader
- * there is no object to protect, so the write is simply reported as not
- * committed and the caller's cleanup is a no-op. The row holding this call's
- * own `writeGroup` means the put landed and only its response was lost.
- */
-async function verifyFailure(context, item) {
-    if (!context.offloader)
-        return 'not-committed';
-    try {
-        const observed = await (0, special_write_verify_1.readSpecialRow)(context, item);
-        return observed.revision === item.writeGroup ? 'committed' : 'not-committed';
-    }
-    catch {
-        return 'unverified';
-    }
-}
-/**
- * Write regular items with a first-write-wins guard. Every `PutCommand` fully
- * settles (`Promise.allSettled`) before this resolves and never rejects; a
- * genuine failure is reported via `error`, not thrown.
- *
- * A failure is not proof of a non-commit: `withDynamoDBRetry` re-issues a put
- * whose response was lost, and the re-issues can time out at the transport, so
- * the budget is spent on a `RetryExhaustedError` while the row is live.
- * Treating that as "never reached DynamoDB" deleted the object the live row
- * pointed at, making the checkpoint's pending writes unreadable forever. Each
- * such failure is therefore verified against the row before it is classified,
- * and a committed one is not an error at all.
- */
-async function writeRegularItems(context, items, signal) {
-    const results = await Promise.allSettled(items.map((item) => (0, retry_1.withDynamoDBRetry)(() => context.client.put({
-        TableName: context.tableName,
-        Item: item,
-        ConditionExpression: 'attribute_not_exists(PK)',
-        ReturnValuesOnConditionCheckFailure: 'ALL_OLD',
-    }), (0, retry_policy_1.retryFor)(context, signal))));
-    const outcome = { deadUploads: [] };
-    for (const [index, result] of results.entries()) {
-        if (result.status === 'fulfilled')
-            continue;
-        const item = items[index];
-        const reason = result.reason;
-        if ((0, conditional_put_1.isConditionalCheckFailed)(reason)) {
-            (0, write_guard_1.reportGuardRejection)(context, item, reason);
-            if ((0, write_guard_1.rejectionProvesForeignRow)(item, reason))
-                outcome.deadUploads.push(item);
-            continue;
-        }
-        const verdict = await verifyFailure(context, item);
-        if (verdict === 'committed')
-            continue;
-        if (verdict === 'not-committed')
-            outcome.deadUploads.push(item);
-        outcome.error = outcome.error ?? reason;
-    }
-    return outcome;
-}

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

@@ -1,33 +0,0 @@
-import type { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import type { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
-import type { SerializerProtocol } from '@langchain/langgraph-checkpoint';
-import type { CompressionConfig } from '../../shared/codec/compression';
-import { S3Offloader } from '../../shared/codec/s3/offloader';
-import type { RetryOptions } from '../../shared/dynamodb/retry';
-import { type Logger } from '../../shared/logging/logger';
-import type { TtlOption } from '../../shared/validation/ttl';
-import type { DynamoDBSaverOptions } from '../types';
-/** Resolved collaborators shared by every checkpointer action. */
-export interface CheckpointerContext {
-    client: DynamoDBDocument;
-    tableName: string;
-    serde: SerializerProtocol;
-    compression?: CompressionConfig;
-    offloader?: S3Offloader;
-    ttl?: TtlOption;
-    logger: Logger;
-    /** Retry budget and backoff for every DynamoDB call, with the retry debug log attached. */
-    retry?: RetryOptions;
-}
-/** Result of wiring up a checkpointer from its options. */
-export interface CheckpointerSetup {
-    context: CheckpointerContext;
-    ddbClient: DynamoDBClient | undefined;
-    ownsClient: boolean;
-}
-/**
- * Resolve the DynamoDB client, optional S3 offloader, and logging into the
- * context every action receives, plus the ownership info the class needs to
- * tear resources down.
- */
-export declare function setUpCheckpointer(options: DynamoDBSaverOptions, serde: SerializerProtocol): CheckpointerSetup;

package/dist/checkpointer/internal/setup.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setUpCheckpointer = setUpCheckpointer;
-const adapter_config_1 = require("../../shared/codec/s3/adapter-config");
-const offloader_1 = require("../../shared/codec/s3/offloader");
-const client_1 = require("../../shared/dynamodb/client");
-const retry_policy_1 = require("../../shared/dynamodb/retry-policy");
-const logger_1 = require("../../shared/logging/logger");
-const options_1 = require("../../shared/validation/options");
-/**
- * Resolve the DynamoDB client, optional S3 offloader, and logging into the
- * context every action receives, plus the ownership info the class needs to
- * tear resources down.
- */
-function setUpCheckpointer(options, serde) {
-    (0, options_1.validateBaseAdapterOptions)(options);
-    const logger = (0, logger_1.resolveLogger)(options.logger);
-    const resolved = (0, client_1.resolveDynamoDBClient)(options);
-    if (!resolved.ownsClient)
-        void (0, client_1.warnOnStackedRetries)(resolved.client, logger);
-    const offloader = options.s3
-        ? new offloader_1.S3Offloader((0, adapter_config_1.offloaderConfigFor)(options.s3, 'checkpointer', options.clientConfig))
-        : undefined;
-    return {
-        context: {
-            client: resolved.client,
-            tableName: options.tableName,
-            serde,
-            compression: options.compression,
-            offloader,
-            ttl: options.ttl,
-            logger,
-            retry: (0, retry_policy_1.resolveRetryPolicy)(options.retry, logger),
-        },
-        ddbClient: resolved.ddbClient,
-        ownsClient: resolved.ownsClient,
-    };
-}

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

@@ -1,29 +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, signal?: AbortSignal): Promise<SpecialWriteOutcome>;