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

package/dist/checkpointer/actions/list.js

@@ -1,142 +0,0 @@
-"use strict";
-/**
- * Hides when a listing reads, and when it stops.
- *
- * A `limit` of `0` is answered before any request is built, a config that
- * pins one checkpoint in a known namespace is a single direct read rather than
- * a range, and every other listing streams tuples until the caller stops
- * pulling or `limit` is reached. The read is deliberately unbounded and
- * eventually consistent; past a threshold an operator is warned instead of the
- * caller being refused. Where the rows come from is `listing`'s concern.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listCheckpoints = listCheckpoints;
-const clock_1 = require("../../shared/clock");
-const paginate_1 = require("../../shared/dynamodb/paginate");
-const table_schema_1 = require("../../shared/dynamodb/table-schema");
-const listing_1 = require("../internal/listing");
-const parse_1 = require("../internal/parse");
-const read_1 = require("../internal/read");
-/**
- * The tuple for one META item that passes every filter, assembled eventually
- * consistently (a history listing tolerates a replica lag `getTuple` does not)
- * and reusing the metadata the filter already decoded. Undefined when the row
- * is filtered out or its payload is missing.
- */
-async function tupleFor(context, meta, scope) {
-    if (!(0, listing_1.passesKeyFilters)(meta, scope))
-        return undefined;
-    const verdict = await (0, listing_1.passesMetadataFilter)(context, meta, scope);
-    if (!verdict.pass)
-        return undefined;
-    return (0, read_1.assembleTuple)(context, { threadId: meta.threadId, checkpointNs: meta.checkpointNs }, meta, {
-        signal: scope.signal,
-        consistent: false,
-        metadata: verdict.metadata,
-    });
-}
-/** A `checkpoint_id` addresses one row: read it directly instead of scanning the namespace for it. */
-async function* listOne(context, scope) {
-    const meta = await (0, read_1.fetchTargetMeta)(context, {
-        threadId: scope.threadId,
-        checkpointNs: scope.checkpointNs,
-        checkpointId: scope.checkpointId,
-    }, scope.signal);
-    if (!meta)
-        return;
-    const tuple = await tupleFor(context, meta, scope);
-    if (tuple)
-        yield tuple;
-}
-/**
- * True when the caller asked for no tuples at all. Answered before any request
- * is built: DynamoDB rejects `Limit: 0`, and yielding one tuple and only then
- * testing the limit returns a result the caller did not ask for. The reference
- * saver returns nothing here (`@langchain/langgraph-checkpoint@1.1.5`
- * `dist/memory.js:172`).
- *
- * Exactly `0`, not "zero or less": a negative limit is refused by
- * {@link parseListScope} before this runs, so treating one as a request for
- * nothing would be a branch no call could reach.
- */
-function asksForNothing(scope) {
-    return scope.limit === 0;
-}
-/**
- * True when the scope names exactly one row, which is only so once the
- * namespace is known. A `checkpoint_id` without a `checkpoint_ns` may address a
- * checkpoint in any namespace — a subgraph's, for instance — so the read stays
- * namespace-wide and `passesKeyFilters` narrows it to that id.
- */
-function addressesOneRow(scope) {
-    return (scope.threadId !== undefined &&
-        scope.checkpointId !== undefined &&
-        scope.checkpointNs !== undefined);
-}
-/**
- * Yield checkpoint tuples for a thread, newest first: every namespace when the
- * config names none (grouped by namespace, newest first within each), else the
- * one namespace given. Without a `thread_id` every thread in the table is
- * listed: through a table scan, as the reference savers do, which is unordered
- * across threads, or through the recency index when `indexName` is set. Either
- * read is cross-tenant by construction. Honors `options.before` (only
- * checkpoints older than the given id), `options.filter` (metadata equality),
- * and `options.limit` (max tuples yielded; the read stops right after the
- * yield that reaches it).
- *
- * Accepts: `config` — `thread_id` scopes the read to one thread and its absence
- * lists every thread in the table, through a scan as the reference savers do or
- * through the recency index when `indexName` is set; `checkpoint_ns` scopes to
- * one namespace and its absence spans every namespace of the thread.
- * `options.before` — only checkpoints older than that id. `options.filter` —
- * metadata equality. `options.limit` — at most this many tuples, up to the
- * package's page ceiling; `0` yields nothing, which is what the reference
- * returns, and a negative value is refused.
- *
- * Returns: an async generator over the tuples, newest first within a namespace,
- * unordered across threads on the scan path. The read stops right after the
- * yield that reaches `limit`, and abandoning the generator stops it too.
- *
- * Throws: `VALIDATION`, from the first `.next()` and before any read, for
- * a config of the wrong shape (`config`, `configurable`, `signal`), a
- * malformed identifier, or options that fail the checks
- * {@link parseListScope} makes;
- * `FORMAT_UNSUPPORTED` for a row of ours written by a newer version; whatever
- * the reads and decodes throw.
- *
- * Guarantees: eventually consistent — a listing tolerates the replica lag
- * `getTuple` does not. The read is deliberately unbounded: this generator
- * streams and never accumulates, `limit` returns early, and a raw-row cap would
- * turn a caller asking for a handful of rare matches over a large thread into a
- * hard error instead of the true (possibly empty) answer. Past the warning
- * threshold an operator is told to narrow the filter or pass a limit.
- */
-async function* listCheckpoints(context, config, options) {
-    const scope = (0, parse_1.parseListScope)(config, options);
-    if (asksForNothing(scope))
-        return;
-    if (addressesOneRow(scope)) {
-        yield* listOne(context, scope);
-        return;
-    }
-    const now = (0, clock_1.nowSeconds)();
-    let yielded = 0;
-    let scanned = 0;
-    for await (const raw of (0, listing_1.metaRows)(context, scope, now)) {
-        scanned += 1;
-        if (scanned === paginate_1.LIST_SCAN_WARN_THRESHOLD) {
-            context.logger.warn('list: scanned a large number of rows without the caller stopping; this read is ' +
-                'deliberately unbounded, so narrow the filter or pass options.limit', { threadId: scope.threadId, checkpointNs: scope.checkpointNs, scanned });
-        }
-        const meta = (0, listing_1.parseListedRow)(context, raw);
-        if (!meta || (0, table_schema_1.isExpiredRow)(meta, now))
-            continue;
-        const tuple = await tupleFor(context, meta, scope);
-        if (!tuple)
-            continue;
-        yield tuple;
-        yielded += 1;
-        if (scope.limit !== undefined && yielded >= scope.limit)
-            return;
-    }
-}

package/dist/checkpointer/actions/put.js

@@ -1,195 +0,0 @@
-"use strict";
-/**
- * Hides what it takes for a checkpoint to land exactly once.
- *
- * The META and PAYLOAD rows go out as one transaction under a request token
- * drawn once, and a failure with S3 offload configured is read back before
- * any upload is released, so a lost acknowledgement reports success and only a
- * confirmed non-commit cleans up (record 6). Every channel value is stored
- * whatever `newVersions` says (record 10). A caller gets back the config that
- * addresses the stored checkpoint and none of this.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.putCheckpoint = putCheckpoint;
-exports.verifyCheckpointLanded = verifyCheckpointLanded;
-const codec_1 = require("../../shared/codec/codec");
-const offloader_1 = require("../../shared/codec/s3/offloader");
-const idempotent_write_1 = require("../../shared/dynamodb/idempotent-write");
-const table_schema_1 = require("../../shared/dynamodb/table-schema");
-const ttl_1 = require("../../shared/validation/ttl");
-const parse_1 = require("../internal/parse");
-const rows_1 = require("../internal/rows");
-/**
- * Persist a checkpoint and its metadata as a transactional pair of META and
- * PAYLOAD rows, returning the config that addresses the stored checkpoint. The
- * incoming `checkpoint_id` (if any) becomes the new checkpoint's parent.
- *
- * **Every channel value the checkpoint carries is stored.** `newVersions` is
- * accepted because `BaseCheckpointSaver.put` declares it
- * (`@langchain/langgraph-checkpoint@1.1.5` `dist/base.d.ts:68`) and is
- * deliberately ignored: narrowing the stored values to the ones it names, and
- * carrying the rest forward from the parent, made a put whose `newVersions` is
- * `{}` write no values at all. LangGraph passes `{}` when forking a checkpoint
- * and when writing an empty-checkpoint update (`@langchain/langgraph@1.4.13`
- * `dist/pregel/index.js:668` and `:613`), so that put silently dropped user
- * state. The reference saver does not narrow either: `MemorySaver.put` takes
- * three parameters and stores the whole checkpoint (`dist/memory.js:206`).
- *
- * Accepts: `config` — its `checkpoint_id`, when present, becomes the new
- * checkpoint's parent. `checkpoint.id` — validated as the sort-key segment it
- * becomes. `metadata` — stored beside it, on the light row a listing reads.
- * `config.signal` — cancels the writes' retries; checked before anything is
- * encoded.
- *
- * Returns: the config addressing the stored checkpoint, which is what the
- * caller passes back to continue the thread.
- *
- * Throws: `VALIDATION` naming `config`, `configurable` or `signal` for a
- * config of the wrong shape, `thread_id`, `checkpoint_ns`, `checkpoint_id` or
- * `thread_ts` for a malformed identifier, `checkpoint` for a `null` or
- * `undefined` checkpoint, `checkpoint_id` for a malformed `checkpoint.id`,
- * `payload` for a payload too large to store inline without `s3`, or `s3Key`
- * for an offloaded object's key over S3's cap; `S3_OFFLOAD_FAILED`; whatever
- * the transaction throws once the outcome is established.
- *
- * Guarantees: both rows land or neither does — they are one transaction, so a
- * META row never names a payload that is not there. That transaction goes out
- * under a client request token drawn once, with the request it travels on, so
- * a retry that follows a lost acknowledgement is discarded by the service
- * rather than applied a second time. Writing the same `checkpoint.id` again
- * replaces both, which is what a retry and a repair tool both need; the objects
- * the replaced rows named are not deleted by the put, and are left to the
- * lifecycle rule. A payload the serde refuses is refused before any write and
- * releases whatever the same call had already uploaded, so an encode that fails
- * halfway leaves nothing behind either. On failure with S3 offload configured
- * the row carrying an offloaded descriptor is read back before any upload is
- * deleted (see {@link verifyCheckpointLanded}): a transaction that committed
- * and lost its response is reported as success, a confirmed non-commit cleans
- * up the objects this call uploaded, and an unverifiable outcome leaks them
- * rather than risk stranding a live row. Each put uploads under an object id of
- * its own, so no row another put commits names this call's uploads.
- */
-async function putCheckpoint(context, config, checkpoint, metadata, _newVersions) {
-    const request = (0, parse_1.parsePutRequest)(config, checkpoint, metadata);
-    const { threadId, checkpointNs, checkpointId } = request.address;
-    const ttlTimestamp = context.ttl ? (0, ttl_1.calculateTtlTimestamp)(context.ttl) : undefined;
-    const { meta, payload } = await (0, rows_1.buildCheckpointRows)(context, request, ttlTimestamp);
-    const stored = {
-        configurable: { thread_id: threadId, checkpoint_ns: checkpointNs, checkpoint_id: checkpointId },
-    };
-    try {
-        // One request, one token, re-sent unchanged for every attempt of the
-        // budget — which is what the token is worth here, since a token minted on
-        // a request the retry closure rebuilt would be a fresh one per attempt and
-        // would deduplicate nothing.
-        //
-        // Neither row is guarded, so nothing else can turn a re-send away: a retry
-        // that follows a lost acknowledgement puts both rows back, and one
-        // arriving after a `deleteThread` removed them puts back two live rows
-        // naming two objects that call has already released. Inside the service's
-        // idempotency window the token discards it instead. The pair is atomic, so
-        // what that window covers is the pair: a re-send either re-applies both
-        // rows or neither.
-        //
-        // A condition on either row is not the alternative it looks like. Two
-        // guarded items would make one genuine race cancel with two
-        // `ConditionalCheckFailed` reasons, and `conditionalCheckFailure` reads a
-        // cancellation as a guard rejection only while a single cause remains — so
-        // the race would surface as an unrecognised non-retryable error.
-        //
-        // Because neither row is guarded, the precondition on what a token
-        // guarantees — see {@link transactIdempotently} — never bites on the rows
-        // themselves: no condition here can turn an attempt away, so an attempt
-        // either committed the pair, and its re-send is discarded, or committed
-        // nothing. It does bite on the transaction, which a conflict with a
-        // concurrent writer of the same id can still cancel: a cancellation
-        // completes nothing and is cached as nothing, so the attempt after one is
-        // a fresh evaluation rather than a replay. That is the wanted outcome here
-        // — the pair did not land, so it must still land — and it is why the
-        // token's promise is worded about a write that *committed* rather than one
-        // that was merely sent.
-        //
-        // The deadline that helper carries is what keeps this budget inside the
-        // window the token is honoured for. The token enforces no window itself,
-        // and a re-send arriving after it has closed is simply a new request: both
-        // rows land again, over whatever has replaced them and after whatever
-        // released the objects they name.
-        await (0, idempotent_write_1.transactIdempotently)(context, [
-            { Put: { TableName: context.tableName, Item: meta } },
-            { Put: { TableName: context.tableName, Item: payload } },
-        ], { signal: request.signal });
-    }
-    catch (error) {
-        if (!context.offloader)
-            throw error;
-        const verdict = await verifyCheckpointLanded(context, meta, payload);
-        if (verdict === 'landed') {
-            context.logger.debug('put: transaction committed although its response was lost', {
-                threadId,
-                checkpointId,
-            });
-            return stored;
-        }
-        if (verdict === 'not-landed') {
-            await (0, offloader_1.cleanUpS3Orphans)(context.offloader, {
-                keys: (0, codec_1.collectS3Keys)([meta.metadata, payload.checkpoint]),
-                operation: 'put',
-                logger: context.logger,
-            });
-        }
-        throw error;
-    }
-    return stored;
-}
-/**
- * Pick the row carrying an offloaded descriptor, projected to that
- * descriptor's `location` and `s3Key`. The META and PAYLOAD rows commit in one
- * transaction, so one of them is enough; with neither offloaded there is
- * nothing to protect and no read to spend, which {@link verifyRow} answers
- * `'not-landed'` for an absent `expected`.
- */
-function chooseProbe(meta, payload) {
-    const metaKey = (0, idempotent_write_1.offloadedKey)(meta.metadata);
-    if (metaKey !== undefined) {
-        return {
-            key: (0, table_schema_1.rowKeyOf)(meta),
-            kind: 'descriptor',
-            attribute: 'metadata',
-            expected: metaKey,
-            descriptors: ['metadata'],
-        };
-    }
-    return {
-        key: (0, table_schema_1.rowKeyOf)(payload),
-        kind: 'descriptor',
-        attribute: 'checkpoint',
-        expected: (0, idempotent_write_1.offloadedKey)(payload.checkpoint),
-        descriptors: ['checkpoint'],
-    };
-}
-/**
- * Read one of the two rows back after the META+PAYLOAD transaction failed and
- * report what that failure actually did — never assuming it did nothing.
- *
- * Accepts: `meta` and `payload` — the two rows the failed transaction carried.
- * Whichever of them has something offloaded is the one read back; a fully
- * inline write has no object at stake and spends no read.
- *
- * Returns: the verdict. See {@link WriteVerdict} for what each answer licenses
- * the caller to do. `'landed'` when the row holds this attempt's key,
- * `'not-landed'` when it holds another or none, `'unverified'` when the read
- * failed.
- *
- * Throws: nothing — a failed read is the `'unverified'` answer.
- *
- * Guarantees: both descriptors' keys end in the object id this put drew, which
- * no other put uses. The row holds this attempt's key only if this put's
- * transaction committed, and the other row commits with it, so one read decides
- * the landing. A row holding any other key was committed by another put, whose
- * rows name only that put's objects, so a `'not-landed'` answer leaves both of
- * this put's uploads named by no row.
- */
-async function verifyCheckpointLanded(context, meta, payload) {
-    const { verdict } = await (0, idempotent_write_1.verifyRow)(context, chooseProbe(meta, payload));
-    return verdict;
-}

package/dist/checkpointer/internal/delta-history.js

@@ -1,252 +0,0 @@
-"use strict";
-/**
- * Hides how a delta channel's history is rebuilt, and what a hole in it means.
- *
- * A delta channel stores a full value only every `snapshotFrequency` updates,
- * so its value at a checkpoint is its last snapshot plus the writes since,
- * collected by walking parent pointers. The walk, the order the writes are
- * collected in, and the one read that tells an expired ancestor (a hole to
- * report) from one that never existed (the history's true start) are decided
- * here.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deltaChannelHistory = deltaChannelHistory;
-exports.probeAncestor = probeAncestor;
-exports.ancestorExpired = ancestorExpired;
-const clock_1 = require("../../shared/clock");
-const retry_1 = require("../../shared/dynamodb/retry");
-const table_schema_1 = require("../../shared/dynamodb/table-schema");
-const base_error_1 = require("../../shared/errors/base-error");
-const error_code_1 = require("../../shared/errors/error-code");
-const truncate_1 = require("../../shared/logging/truncate");
-const rows_1 = require("./rows");
-/** An empty accumulator wanting every channel named. */
-function startWalk(channels) {
-    const writes = {};
-    for (const channel of channels)
-        writes[channel] = [];
-    return { remaining: new Set(channels), writes, seeds: {} };
-}
-/**
- * Collect one ancestor's pending writes for the channels still being walked,
- * newest task first within the ancestor, matching the reference walk.
- */
-function collectWrites(tuple, walk) {
-    const perChannel = {};
-    for (const write of tuple.pendingWrites ?? []) {
-        const channel = write[1];
-        if (walk.remaining.has(channel))
-            (perChannel[channel] ??= []).push(write);
-    }
-    for (const channel of Object.keys(perChannel)) {
-        const block = perChannel[channel];
-        block.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-        for (let i = block.length - 1; i >= 0; i -= 1)
-            walk.writes[channel].push(block[i]);
-    }
-}
-/**
- * Take the seed for every channel this ancestor stores a value for, and stop
- * walking those channels: the nearest stored value is the one that counts.
- */
-function takeSeeds(tuple, walk) {
-    for (const channel of [...walk.remaining]) {
-        if (Object.prototype.hasOwnProperty.call(tuple.checkpoint.channel_values, channel)) {
-            walk.seeds[channel] = tuple.checkpoint.channel_values[channel];
-            walk.remaining.delete(channel);
-        }
-    }
-}
-/**
- * The parent pointer a tuple carries, re-given the caller's `signal`.
- *
- * A tuple's `config` and `parentConfig` are built by `assembleTuple` as bare
- * `{ configurable }` addresses, and they stay that way: they are handed to
- * whoever called `getTuple`, who may keep a `parentConfig` and read from it
- * later, long after this call's signal has fired. So the signal is re-attached
- * here, to the cursor this walk reads with, rather than stamped onto the value
- * the tuple publishes.
- *
- * The cursor is a `RunnableConfig`, and `config.signal` is how every reader in
- * this package already takes a cancel, so nothing new carries it: the second
- * hop is cancellable for exactly the reason the first one is.
- */
-function cursorFor(parent, signal) {
-    if (parent === undefined || signal === undefined)
-        return parent;
-    return { ...parent, signal };
-}
-/**
- * Follow `parentConfig` from `from.start` until every channel has a seed or the
- * chain ends, feeding each ancestor to {@link collectWrites} and
- * {@link takeSeeds}.
- *
- * An ancestor that cannot be read ends the walk — quietly when it was never
- * written or the cursor names no checkpoint, both ordinary ends of a chain, and
- * with {@link ancestorExpired} when the row is still stored but past its ttl,
- * which is a hole in the thread.
- *
- * `from.signal` cancels every hop, not just the first. The chain is unbounded
- * in principle — a delta channel rebuilds from the nearest ancestor that stored
- * a value — and each hop is a `getTuple`, which can cost an S3 download, so a
- * walk that could not be stopped part-way would be the one read in this
- * package that ignores a cancel it is given. A cancel is read before each
- * request is sent, so the hop the signal fires on is the last read the call
- * makes.
- */
-async function walkAncestors(context, getTuple, walk, from) {
-    let cursor = cursorFor(from.start, from.signal);
-    while (cursor !== undefined && walk.remaining.size > 0) {
-        const tuple = await getTuple(cursor);
-        if (tuple === undefined) {
-            const stop = await probeAncestor(context, cursor);
-            if (stop?.expired)
-                throw ancestorExpired(stop, [...walk.remaining]);
-            return;
-        }
-        collectWrites(tuple, walk);
-        takeSeeds(tuple, walk);
-        cursor = cursorFor(tuple.parentConfig, from.signal);
-    }
-}
-/** Shape one channel's accumulated writes and seed into its public history. */
-function historyOf(walk, channel) {
-    const writes = walk.writes[channel].slice().reverse();
-    return Object.prototype.hasOwnProperty.call(walk.seeds, channel)
-        ? { writes, seed: walk.seeds[channel] }
-        : { writes };
-}
-/**
- * Walk a checkpoint's ancestors for the delta channels named, accumulating
- * their writes oldest-first and the nearest stored value of each.
- *
- * Same contract and same result as the inherited implementation
- * (`@langchain/langgraph-checkpoint@1.1.5` `dist/base.js:78`), with one
- * difference that is the reason for overriding it: where the inherited walk
- * meets an ancestor it cannot read it simply stops (`if (tup === void 0)
- * break`), reports no seed, and the consumer rebuilds the channel from its
- * initial value (`@langchain/langgraph@1.4.13` `dist/channels/delta.js:65`).
- * That is silent state loss, and this package can produce it: a ttl is computed
- * per put, so a long-running thread expires its own older checkpoints while the
- * newer ones live on.
- *
- * Accepts: `channels` — the delta channels to rebuild; none returns nothing and
- * reads nothing. `getTuple` — the saver's own, so the walk sees exactly what a
- * reader would. `config` — the checkpoint to walk back from. `config.signal` —
- * cancels the whole walk: it is re-attached to each ancestor cursor
- * ({@link cursorFor}), because the pointer a tuple carries is a bare address.
- *
- * Returns: per channel, its on-path writes oldest-first and the nearest stored
- * value found. A channel whose value was never stored gets none, which is the
- * consumer's cue to start from its initial value — correctly, because there is
- * nothing to lose.
- *
- * Throws: `ANCESTOR_EXPIRED` when an ancestor a channel still needs exists but
- * has expired ({@link ancestorExpired}). An ancestor that was never written
- * still ends the walk quietly — that is an ordinary root. `ABORTED` when the
- * signal fires, at whichever hop it fires on, and in preference to a diagnosis
- * of the stop: a walk cancelled just as it reached an expired ancestor reports
- * the cancel, since the caller stopped waiting for the answer either way.
- *
- * Guarantees: the walk stops at the first ancestor that answers for every
- * channel, so a deep thread costs reads only as far back as the nearest
- * snapshot.
- */
-async function deltaChannelHistory(context, getTuple, config, channels) {
-    if (channels.length === 0)
-        return {};
-    const walk = startWalk(channels);
-    const target = await getTuple(config);
-    await walkAncestors(context, getTuple, walk, {
-        start: target?.parentConfig,
-        signal: config.signal,
-    });
-    const result = {};
-    for (const channel of channels)
-        result[channel] = historyOf(walk, channel);
-    return result;
-}
-/**
- * Read the META row an ancestor walk could not follow, **ignoring expiry**, to
- * tell "this checkpoint was never written" apart from "it expired out from
- * under its own descendants".
- *
- * Every other read in this package treats an expired row as absent, which is
- * the right rule for a reader asking for state. Here the distinction is the
- * whole point: one is an ordinary root, the other is data loss.
- *
- * Accepts: `config` — the parent pointer a walk stopped at. `config.signal` —
- * cancels the read, and is read before it is sent. The walk re-attaches the
- * caller's signal to every cursor, so the probe takes its cancel from the same
- * place every other reader in this package takes it, rather than from a
- * parameter of its own.
- *
- * Returns: whether that checkpoint exists and whether it has expired, or
- * `undefined` when the config names no thread or no checkpoint — such a pointer
- * addresses nothing that could have expired, so the walk has simply run out of
- * chain.
- *
- * Throws: whatever the read throws after retries; `ABORTED` when the signal
- * has already fired, which is answered in preference to the expiry this read
- * exists to diagnose — a caller who cancelled is owed its own stop, and is no
- * longer waiting to be told why the walk ended.
- *
- * Guarantees: the read ignores the ttl, deliberately. Every other read in this
- * package treats an expired row as absent, which is the right rule for a reader
- * asking for state; here the distinction is the whole point, because one answer
- * is an ordinary root and the other is data loss.
- */
-async function probeAncestor(context, config) {
-    const ids = config.configurable;
-    const threadId = ids?.thread_id;
-    const checkpointId = ids?.checkpoint_id;
-    if (typeof threadId !== 'string' || typeof checkpointId !== 'string')
-        return undefined;
-    const checkpointNs = ids?.checkpoint_ns ?? '';
-    const result = await (0, retry_1.withDynamoDBRetry)((request) => context.client.get({
-        TableName: context.tableName,
-        Key: (0, rows_1.metaRowKey)({ threadId, checkpointNs, checkpointId }),
-        ConsistentRead: true,
-    }, request), (0, retry_1.retryFor)(context, config.signal));
-    const row = result.Item;
-    return {
-        threadId,
-        checkpointId,
-        expired: row !== undefined && (0, table_schema_1.isExpiredRow)(row, (0, clock_1.nowSeconds)()),
-    };
-}
-/**
- * The error a read raises when a delta channel's history has a hole in it.
- *
- * Accepts: `stop` — the expired ancestor the walk reached. `channels` — the
- * delta channels that still needed it, named in the message so the operator
- * knows what was lost.
- *
- * Returns: the error, coded `ANCESTOR_EXPIRED` and carrying the thread and
- * checkpoint. The message bounds all three: after the first hop the walk's
- * cursor is a row's own `parentConfig`, so the identifiers it names come off a
- * row, and `channels` is checked for being an array of strings and for nothing
- * else — neither how many nor how long. `context` carries both identifiers
- * whole, which is what a caller branches on.
- *
- * Throws: nothing — it builds the error, the caller throws it.
- *
- * Guarantees: returning the partial history instead would hand the caller a
- * channel rebuilt from its initial value plus whatever writes survived — a
- * shorter message list, say, with nothing to say that anything is missing. The
- * reference contract has no way to express "incomplete", so refusing the read
- * is the only honest answer.
- */
-function ancestorExpired(stop, channels) {
-    const named = (0, truncate_1.truncateLabelsForLog)(channels)
-        .map((channel) => `"${channel}"`)
-        .join(', ');
-    return new base_error_1.DynamoDBLangGraphError(`checkpoint "${(0, truncate_1.truncateForLog)(stop.checkpointId)}" of thread ` +
-        `"${(0, truncate_1.truncateForLog)(stop.threadId)}" has expired, but later ` +
-        `checkpoints still need it to reconstruct ${named}. ` +
-        'A delta channel writes a full snapshot only every `snapshotFrequency` updates and leaves ' +
-        'itself out of the checkpoints in between, so its value is rebuilt from an earlier ' +
-        'ancestor — which a per-checkpoint ttl expires while its descendants live on. Lower ' +
-        '`snapshotFrequency` (1 makes every checkpoint self-contained), or do not configure a ttl ' +
-        'on threads that use delta channels.', error_code_1.ErrorCode.ANCESTOR_EXPIRED, { threadId: stop.threadId, checkpointId: stop.checkpointId });
-}