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

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

@@ -0,0 +1,571 @@
+/**
+ * Hides the checkpointer's row format.
+ *
+ * A checkpoint is three kinds of row in its thread's partition — a light META
+ * row a listing reads, a heavy PAYLOAD row, and one WRITE row per pending
+ * write — and everything about how they are keyed, what they carry, and how a
+ * checkpoint and its writes become rows and come back is decided here: the
+ * sort-key segments and their order, the offset that lets the reserved negative
+ * write indices sort as plain strings, the `writeGroup` and `occurrence` that
+ * identify a write across calls, the recency-index keys a META row carries, and
+ * which rows a read admits as this adapter's own. Nothing else composes or
+ * splits a checkpointer key.
+ */
+import type { QueryCommandInput } from '@aws-sdk/lib-dynamodb';
+import type { Checkpoint, CheckpointMetadata, CheckpointPendingWrite, PendingWrite, PendingWriteValue } from '@langchain/langgraph-checkpoint';
+import { type PayloadDescriptor } from '../../shared/codec/codec';
+import type { AttributeMap } from '../../shared/dynamodb/client';
+import { type NamedDescriptor } from '../../shared/dynamodb/partition-delete';
+import { type IndexTarget } from '../../shared/dynamodb/recency-index';
+import { type RowKey } from '../../shared/dynamodb/table-schema';
+import type { CheckpointerContext } from './setup';
+/** Where one stored checkpoint lives: from a parsed address, or from a row's own identifiers. */
+export interface CheckpointLocation {
+    readonly threadId: string;
+    readonly checkpointNs: string;
+    readonly checkpointId: string;
+}
+/** Where one pending write lives: its checkpoint, its task, its index and its channel. */
+export interface WriteRowLocation {
+    readonly checkpointNs: string;
+    readonly checkpointId: string;
+    readonly taskId: string;
+    readonly index: number;
+    readonly channel: string;
+}
+/** The lightweight `META#` row: structural fields + serialized metadata. */
+export interface CheckpointMetaRow {
+    PK: string;
+    SK: string;
+    /** Row format version; absent on rows written before it existed (see `table-schema.ts`). */
+    v?: number;
+    /** Recency-index keys; absent on rows written before the index existed. */
+    gsi1pk?: string;
+    gsi1sk?: string;
+    threadId: string;
+    checkpointNs: string;
+    checkpointId: string;
+    parentCheckpointId?: string;
+    metadata: PayloadDescriptor;
+    ttl?: number;
+}
+/** The heavy `PAYLOAD#` row: the serialized checkpoint. */
+export interface CheckpointPayloadRow {
+    PK: string;
+    SK: string;
+    /** Row format version; absent on rows written before it existed (see `table-schema.ts`). */
+    v?: number;
+    checkpoint: PayloadDescriptor;
+    ttl?: number;
+}
+/** A `WRITE#` row: one pending write for a checkpoint/task. */
+export interface CheckpointWriteRow {
+    PK: string;
+    SK: string;
+    /** Row format version; absent on rows written before it existed (see `table-schema.ts`). */
+    v?: number;
+    taskId: string;
+    index: number;
+    channel: string;
+    /** Identifies the `putWrites` call that produced this row; see {@link WRITE_GROUP_ATTRIBUTE}. */
+    writeGroup: string;
+    /**
+     * How many earlier writes in the same call already used this channel.
+     * Optional: rows written before 0.9.0 carry none and read back as 0, which
+     * is exactly the identity they were stored under.
+     */
+    occurrence?: number;
+    value: PayloadDescriptor;
+    ttl?: number;
+}
+/**
+ * The attribute a WRITE row carries the id of the `putWrites` call that wrote
+ * it in. A special write's compare-and-swap pins it, and a thread delete pins
+ * a WRITE row's delete to it; a per-call ULID is already unique, so it needs no
+ * separate revision attribute.
+ */
+export declare const WRITE_GROUP_ATTRIBUTE = "writeGroup";
+/**
+ * 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.
+ */
+export declare const MIN_ENCODABLE_WRITE_INDEX: number;
+/**
+ * The tag every checkpointer partition key starts with.
+ *
+ * Accepts: nothing — the tag is fixed, and the function exists so no caller
+ * composes it by hand.
+ *
+ * Returns: the tag, for a table-wide `begins_with` over this adapter's rows.
+ *
+ * Throws: nothing.
+ */
+export declare function checkpointerPartitionPrefix(): string;
+/**
+ * Partition key for a thread: the adapter tag plus the thread id.
+ *
+ * Accepts: `threadId` — normally validated, so it cannot contain the separator.
+ *
+ * Returns: the partition key. Total, like every key builder here: a row read
+ * from a shared table is *tested* against these, so a malformed value must
+ * compose a key that matches nothing rather than fail the read.
+ *
+ * Throws: nothing.
+ */
+export declare function partitionKey(threadId: string): string;
+/**
+ * Sort key for a checkpoint's lightweight metadata item.
+ *
+ * Accepts: `checkpointNs` — possibly empty, which is the root namespace.
+ * `checkpointId` — the checkpoint's own id.
+ *
+ * Returns: the sort key. The namespace sits above the id so a namespace's
+ * checkpoints are contiguous and a `begins_with` selects exactly them.
+ *
+ * Throws: nothing.
+ */
+export declare function metaSortKey(checkpointNs: string, checkpointId: string): string;
+/**
+ * `begins_with` prefix selecting every META item in one namespace.
+ *
+ * Accepts: `checkpointNs` — the namespace to scope to; empty scopes to the root
+ * namespace, not to every namespace.
+ *
+ * Returns: the prefix, separator-terminated, so the namespace `a` does not also
+ * select `ab`.
+ *
+ * Throws: nothing.
+ */
+export declare function metaSortKeyPrefix(checkpointNs: string): string;
+/**
+ * `begins_with` prefix selecting every META item of a thread.
+ *
+ * Accepts: nothing — the prefix is the same for every thread, because the
+ * thread is already the partition.
+ *
+ * Returns: the kind prefix alone, so the selection spans every namespace of the
+ * thread — what a `list` with no `checkpoint_ns` asks for.
+ *
+ * Throws: nothing.
+ */
+export declare function metaAnyNamespacePrefix(): string;
+/**
+ * Sort key for a checkpoint's heavy payload item.
+ *
+ * Accepts: as {@link metaSortKey}.
+ *
+ * Returns: the sort key of the row holding the checkpoint itself, which is
+ * written before its META row and read only after one is found.
+ *
+ * Throws: nothing.
+ */
+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.
+ *
+ * The composed length is not checked here: `parsePutWritesRequest` refuses a
+ * write whose key would pass the cap, measured by {@link writeSortKeyBytes},
+ * before anything is encoded.
+ *
+ * Accepts: `at` — the write's location: `at.index`, an integer (padding a
+ * fraction produced `00000009.5`, which no longer orders numerically);
+ * `at.channel`, separator-free, which `parseWriteChannel` establishes before
+ * any key is built; `at.checkpointNs`, `at.checkpointId` and `at.taskId`, the
+ * other parsed identifiers.
+ *
+ * Returns: the sort key, its index zero-padded to a fixed width so the special
+ * negative slots order below the positional ones.
+ *
+ * Throws: `VALIDATION` naming `index` for an index this encoding cannot
+ * represent.
+ */
+export declare function writeSortKey(at: WriteRowLocation): string;
+/**
+ * The UTF-8 length of the WRITE sort key a write would get, without refusing
+ * one over DynamoDB's cap.
+ *
+ * Accepts: `at` — the write's location without its index: `at.checkpointNs`,
+ * `at.checkpointId`, `at.taskId` and `at.channel`, the four segments of a
+ * WRITE sort key other than the index. The index is zero-padded to a fixed
+ * width, so the length is the same for every index a write can take, and
+ * index 0 stands for them all.
+ *
+ * Returns: the byte length DynamoDB measures the composed key by.
+ *
+ * Throws: nothing.
+ */
+export declare function writeSortKeyBytes(at: Omit<WriteRowLocation, 'index'>): number;
+/**
+ * Whether `sortKey` is one this adapter writes.
+ *
+ * Accepts: any sort key read from a thread's partition.
+ *
+ * Returns: whether it starts with one of this adapter's kind tags. A partition
+ * query carries no sort-key condition, so a partition-wide delete uses this to
+ * leave a row it does not own in place rather than deleting the whole partition
+ * blindly.
+ *
+ * Throws: nothing.
+ */
+export declare function isCheckpointerSortKey(sortKey: string): boolean;
+/**
+ * `begins_with` prefix selecting every WRITE item of one checkpoint.
+ *
+ * Accepts: the namespace and checkpoint the writes belong to.
+ *
+ * Returns: the prefix, separator-terminated, so one checkpoint's writes never
+ * include another's whose id merely starts the same way.
+ *
+ * Throws: nothing.
+ */
+export declare function writeSortKeyPrefix(checkpointNs: string, checkpointId: string): string;
+/**
+ * The key of one checkpoint's META row.
+ *
+ * Accepts: `at` — the checkpoint's thread, namespace and id.
+ *
+ * Returns: the row's partition and sort key.
+ *
+ * Throws: nothing.
+ */
+export declare function metaRowKey(at: CheckpointLocation): RowKey;
+/**
+ * The key of one checkpoint's PAYLOAD row.
+ *
+ * Accepts: `at` — the checkpoint's thread, namespace and id.
+ *
+ * Returns: the row's partition and sort key.
+ *
+ * Throws: nothing.
+ */
+export declare function payloadRowKey(at: CheckpointLocation): RowKey;
+/** 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;
+}
+/**
+ * Query input selecting every item in a thread's partition.
+ *
+ * Accepts: the thread whose partition to read.
+ *
+ * Returns: the Query input, with no sort-key condition: it selects this
+ * adapter's META, PAYLOAD and WRITE rows and any row another adapter left in
+ * the partition — which is why every caller filters with
+ * `isCheckpointerSortKey`.
+ *
+ * Throws: nothing.
+ */
+export declare function partitionQuery(tableName: string, partition: string, options?: PartitionQueryOptions): QueryCommandInput;
+/**
+ * Query input for a `begins_with` sort-key prefix.
+ *
+ * Accepts: `options.ascending` — sort-key order; newest-first is the default
+ * because that is what "the latest checkpoint" asks for. `options.limit` — rows
+ * DynamoDB evaluates per page, not a total. `options.consistent` — for a read
+ * whose answer a write depends on.
+ *
+ * Returns: the Query input.
+ *
+ * Throws: nothing.
+ */
+export declare function beginsWithQuery(tableName: string, partition: string, skPrefix: string, options?: BeginsWithQueryOptions): QueryCommandInput;
+/** What a checkpoint's META and PAYLOAD rows are built from. */
+export interface CheckpointRowsSource {
+    readonly address: CheckpointLocation;
+    readonly parentCheckpointId: string | undefined;
+    readonly checkpoint: Checkpoint;
+    readonly metadata: CheckpointMetadata;
+    readonly signal: AbortSignal | undefined;
+}
+/** What one call's WRITE rows are built from. */
+export interface WriteRowsSource {
+    readonly address: CheckpointLocation;
+    readonly taskId: string;
+    readonly writes: PendingWrite[];
+    readonly signal: AbortSignal | undefined;
+}
+/**
+ * Encode a checkpoint + metadata into its META and PAYLOAD rows.
+ *
+ * Each call draws one object id and uploads both offloaded payloads under it,
+ * below the row that points at each. A second put of the same checkpoint id — a
+ * put the caller re-issues after a lost response, or a repair tool re-writing a
+ * checkpoint — draws another, so it never names an object the first put
+ * uploaded, and the verification after a failed transaction can tell the two
+ * puts' rows apart by the key alone.
+ *
+ * Accepts: `request` — parsed by `parsePutRequest`: the address the rows are
+ * keyed by (its `checkpointId` is `checkpoint.id`), the parent, the checkpoint
+ * — every channel value it carries is stored; see `putCheckpoint` for why
+ * nothing is narrowed away — the metadata, and the signal that cancels the
+ * uploads. `ttlTimestamp` — stamped on both rows so they expire together.
+ *
+ * Returns: the META row (light: ids, metadata, index keys) and the PAYLOAD row
+ * (heavy: the checkpoint itself), which the caller writes in that order —
+ * payload first, so a META row never names a payload that is not there yet.
+ *
+ * Throws: `VALIDATION` naming `value` for a checkpoint the serializer cannot
+ * represent; `S3_OFFLOAD_FAILED` when an offloaded payload cannot be uploaded.
+ * Encoding precedes every write, so a checkpoint that cannot be stored never
+ * half-writes a thread — and a metadata payload refused after the checkpoint's
+ * own object has uploaded releases that object before the failure leaves here
+ * (see {@link releaseUploads}), so a refusal strands nothing either.
+ */
+export declare function buildCheckpointRows(context: CheckpointerContext, request: CheckpointRowsSource, ttlTimestamp?: number): Promise<{
+    meta: CheckpointMetaRow;
+    payload: CheckpointPayloadRow;
+}>;
+/**
+ * Encode a task's pending writes into one row per write.
+ *
+ * Accepts: `request` — parsed by `parsePutWritesRequest`, so every channel is
+ * well-formed and every composed sort key fits before this runs, and a bad one
+ * costs no S3 object. `writeGroup` — unique per `putWrites` *call*, not per
+ * write, and stored on every row the call produces: it is what tells one
+ * call's writes apart from another's when `dropSupersededWrites` resolves
+ * first-write-wins, and it is the object id every offloaded write of the call
+ * is uploaded under. Two calls writing the same bytes for the same row
+ * therefore upload two objects, and each row names only its own call's.
+ * `ttlTimestamp` — stamped on every row.
+ *
+ * Returns: one row per write, special channels first, each carrying its
+ * `occurrence` so a channel emitted twice by one call keeps both values.
+ *
+ * Throws: `VALIDATION` naming `value`; `S3_OFFLOAD_FAILED`. A payload refused
+ * partway through releases the objects the earlier writes of the same call had
+ * already uploaded (see {@link releaseUploads}), so a build that throws
+ * returns the caller to where it started.
+ */
+export declare function buildWriteRows(context: CheckpointerContext, request: WriteRowsSource, writeGroup: string, ttlTimestamp?: number): Promise<CheckpointWriteRow[]>;
+/**
+ * Narrow a raw row to a {@link CheckpointMetaRow}.
+ *
+ * Accepts: `raw` — any row carrying the `META#` sort-key prefix, which on a
+ * shared table another writer can produce too.
+ *
+ * Returns: the item, or undefined for a row that merely shares the prefix, and
+ * for one whose own `threadId`/`checkpointNs`/`checkpointId` disagree with the
+ * DynamoDB key it was found at. The test is on the attributes a checkpoint must
+ * have, not on a cast: this is the one boundary where a row may not have been
+ * written by this adapter. A `metadata` of `null` is refused here, since
+ * dereferencing it later raised a raw `TypeError`.
+ *
+ * Throws: `FORMAT_UNSUPPORTED` for a row a newer version wrote — checked
+ * **before** the shape, as every other read of this package's rows checks it,
+ * so a row a newer release wrote is reported as newer rather than judged
+ * against attribute names it may no longer use. Skipping it would report a
+ * thread as shorter than it is.
+ *
+ * Guarantees: a row's attributes are bound to the partition it lives in. Those
+ * attributes name the S3 scope the row's payloads are read under and the thread
+ * the assembled tuple reports, so a writer confined to its own partition could
+ * otherwise hand back another tenant's offloaded payload under that tenant's
+ * `thread_id` — the same binding `parseStoreRow` makes for store items. The
+ * binding is judged under this release's rules, which is why it is judged only
+ * for a row this release can read.
+ */
+export declare function parseMetaRow(raw: AttributeMap): CheckpointMetaRow | undefined;
+/**
+ * Narrow a candidate head row, saying so when it is not one of ours.
+ *
+ * Accepts: `raw` — the row a newest-first read returned, or undefined when it
+ * returned none.
+ *
+ * Returns: the item, or undefined for an absent or foreign row — logged at
+ * `warn` in the second case, because a foreign row at the head of a thread is
+ * an operator's problem even though this read recovers from it.
+ *
+ * Throws: as {@link parseMetaRow}.
+ *
+ * Guarantees: a foreign row is skipped, never returned. Returning one made
+ * `assembleTuple` miss its payload and report the thread as empty, so LangGraph
+ * started a new run on top of the real history.
+ */
+export declare function parseHeadRow(context: CheckpointerContext, raw: AttributeMap | undefined): CheckpointMetaRow | undefined;
+/**
+ * Decode the checkpoint stored in a PAYLOAD item.
+ *
+ * Accepts: `threadId` — the **caller's**, from the config, never the row's: it
+ * scopes which S3 object the row may point at, so it must come from the
+ * partition the caller asked for. A row that names an object outside that scope
+ * is refused by the codec rather than downloaded. `signal` — cancels the
+ * download an offloaded payload costs.
+ *
+ * Returns: the checkpoint.
+ *
+ * Throws: `PAYLOAD_CORRUPT` for bytes that cannot be decoded, `VALIDATION`
+ * for a descriptor pointing outside the row's scope and for a payload the
+ * configured serde refuses to reconstruct, and whatever the download throws.
+ */
+export declare function readCheckpoint(context: CheckpointerContext, item: CheckpointPayloadRow, threadId: string, signal?: AbortSignal): Promise<Checkpoint>;
+/**
+ * Decode the metadata stored in a META item.
+ *
+ * Accepts: as {@link readCheckpoint}, for the metadata blob instead of the
+ * checkpoint.
+ *
+ * Returns: the metadata.
+ *
+ * Throws: as {@link readCheckpoint}.
+ */
+export declare function readMetadata(context: CheckpointerContext, item: CheckpointMetaRow, threadId: string, signal?: AbortSignal): Promise<CheckpointMetadata>;
+/**
+ * Decode WRITE items into `[taskId, channel, value]` pending-write tuples.
+ *
+ * Accepts: `items` — one checkpoint's WRITE rows, in any order; empty is empty.
+ * `threadId` — the caller's, as in {@link readCheckpoint}. `signal` — cancels
+ * the downloads, all of which share it.
+ *
+ * Returns: the writes LangGraph replays, first-write-wins already resolved by
+ * `dropSupersededWrites`, in the order the surviving rows were read.
+ *
+ * Throws: whatever a decode throws — the first one, with the rest allowed to
+ * settle.
+ *
+ * Guarantees: payloads decode several at a time, so a checkpoint with many
+ * offloaded writes costs one round of downloads rather than one per write.
+ */
+export declare function toPendingWrites(context: CheckpointerContext, items: CheckpointWriteRow[], threadId: string, signal?: AbortSignal): Promise<CheckpointPendingWrite[]>;
+/** One write with its sort-key index resolved exactly once. */
+export interface ResolvedWrite {
+    channel: string;
+    value: PendingWriteValue;
+    index: number;
+    /**
+     * How many earlier writes in this same call already used this channel. A
+     * retry that emits a channel *more* often than the original call produces a
+     * row at an occurrence no earlier call ever wrote — it collides with nothing
+     * and commits cleanly, so the read-side dedup must not mistake it for a
+     * superseding duplicate.
+     */
+    occurrence: number;
+}
+/**
+ * Assign every write in one `putWrites` call its sort-key index, in a single
+ * pass — nothing recomputes it downstream, so the deduped array's positions
+ * cannot disagree with the ones the caller's array produced.
+ *
+ * A regular write's index is its position in the caller's array, exactly as
+ * the reference `MemorySaver` computes it: that is what makes stored writes
+ * replay in the order the task emitted them. A special channel takes its
+ * fixed `WRITES_IDX_MAP` slot instead, and a later duplicate replaces an
+ * earlier one (last-write-wins, again matching the reference).
+ *
+ * Positions are not stable across calls, which is why the *sort key* also
+ * carries the channel and each call stamps its rows with a shared
+ * `writeGroup` — see {@link buildWriteRows} and `dropSupersededWrites`.
+ *
+ * `Object.hasOwn` guards WRITES_IDX_MAP's own `Object.prototype` chain — a
+ * channel literally named `constructor`/`toString`/etc. must be treated as
+ * regular, not resolve to an inherited function reference.
+ *
+ * Accepts: `writes` — one `putWrites` call's writes, already validated for
+ * channel shape; empty is empty.
+ *
+ * Returns: the special writes first, then the regular ones. A special channel
+ * appearing twice yields one entry (the last), a regular channel appearing
+ * twice yields two, distinguished by `occurrence`.
+ *
+ * Throws: nothing.
+ *
+ * Guarantees: within one call, `(channel, occurrence)` is unique — which is
+ * what lets `dropSupersededWrites` treat it as an identity across calls.
+ */
+export declare function resolveWriteIndices(writes: PendingWrite[]): ResolvedWrite[];
+/**
+ * Resolve a task's pending writes to one row per `(taskId, channel,
+ * occurrence)`, keeping the earliest `putWrites` call that wrote it.
+ *
+ * A regular write's index is its position in the caller's array, so a retried
+ * task whose write mix changed places an already-committed channel at a
+ * different index, where the first-write-wins guard cannot recognise it and a
+ * second row commits. Replaying both double-counts an accumulating channel.
+ * Each call stamps its rows with one `writeGroup`, and the earliest group per
+ * identity is the call that actually won.
+ *
+ * `occurrence` is part of the identity so a retry that legitimately emits a
+ * channel *more* often than the original keeps both values, which is what
+ * `MemorySaver` does when it keys first-write-wins on `(taskId, index)`.
+ *
+ * Accepts: `items` — the WRITE rows of one checkpoint, in any order; empty is
+ * empty. A row written before `writeGroup` or `occurrence` existed carries
+ * neither, and both are normalised at the edge rather than tested for.
+ *
+ * Returns: the rows to replay, in the order given. One per `(taskId, channel,
+ * occurrence)`: the row whose `writeGroup` sorts earliest, which is the call
+ * that actually won the first-write-wins guard.
+ *
+ * Throws: nothing.
+ *
+ * Guarantees: exactly one row survives per identity. Two rows could tie only by
+ * sharing a `writeGroup` as well, and one call assigns each of its channels a
+ * distinct `occurrence`, so within a call the identity is already unique.
+ */
+export declare function dropSupersededWrites(items: CheckpointWriteRow[]): CheckpointWriteRow[];
+/**
+ * The offloaded payloads a checkpointer row references, each named by the
+ * attribute holding it, because a row is pinned through a document path over
+ * that name.
+ *
+ * Accepts: `row` — a row of this adapter's partition.
+ *
+ * Returns: the descriptors, each named by its attribute. An attribute the row
+ * leaves out and one it holds `null` in both name no payload, which is what
+ * `namedDescriptor` decides.
+ *
+ * Throws: nothing.
+ */
+export declare function checkpointRowDescriptors(row: AttributeMap): NamedDescriptor[];
+/**
+ * The checkpoint a row belongs to.
+ *
+ * Accepts: `row` — a row of this adapter's partition.
+ *
+ * Returns: the `ns#id` unit: the namespace and id its sort key carries in the
+ * same two segments whatever its kind, which is exact rather than hopeful
+ * because the separator is forbidden inside every segment.
+ *
+ * Throws: nothing.
+ */
+export declare function checkpointRowUnit(row: AttributeMap): string;
+/**
+ * The row kind.
+ *
+ * Accepts: `row` — a row of this adapter's partition.
+ *
+ * Returns: the kind, which is the sort key's leading segment.
+ *
+ * Throws: nothing.
+ */
+export declare function checkpointRowKind(row: AttributeMap): string;
+/**
+ * Where a checkpointer row sits in the recency index, for a row written before
+ * the index existed.
+ *
+ * Accepts: `row` — any row of the table.
+ *
+ * Returns: a META row's identity — its checkpoint id, at {@link BACKFILLED_AT},
+ * because a META row records no time of its own — or `undefined` for any other
+ * row, this adapter's or not.
+ *
+ * Throws: nothing.
+ */
+export declare function checkpointIndexTarget(row: AttributeMap): IndexTarget | undefined;