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

package/dist/cjs/store/internal/item-write.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteStoreItem = deleteStoreItem;
+exports.assertRowFits = assertRowFits;
+exports.persistRow = persistRow;
+exports.putWithRevisionSwap = putWithRevisionSwap;
+exports.isRetryExhausted = isRetryExhausted;
+exports.verifyWriteLanded = verifyWriteLanded;
+const codec_js_1 = require("../../shared/codec/codec.js");
+const offloader_js_1 = require("../../shared/codec/s3/offloader.js");
+const idempotent_write_js_1 = require("../../shared/dynamodb/idempotent-write.js");
+const retry_js_1 = require("../../shared/dynamodb/retry.js");
+const row_size_js_1 = require("../../shared/dynamodb/row-size.js");
+const table_schema_js_1 = require("../../shared/dynamodb/table-schema.js");
+const base_error_js_1 = require("../../shared/errors/base-error.js");
+const error_code_js_1 = require("../../shared/errors/error-code.js");
+const errors_js_1 = require("../../shared/errors/errors.js");
+const rows_js_1 = require("./rows.js");
+const vector_index_js_1 = require("./vector-index.js");
+async function repinOrResolve(context, key, error) {
+    if ((0, idempotent_write_js_1.isConditionalCheckFailed)(error)) {
+        const rejected = (0, idempotent_write_js_1.rejectedRow)(error);
+        return rejected === undefined ? undefined : (0, rows_js_1.existingFrom)(rejected);
+    }
+    if (isRetryExhausted(error) && (await (0, idempotent_write_js_1.isRowAbsent)(context, key)))
+        return undefined;
+    throw error;
+}
+async function removeObservedRow(context, key, existing) {
+    let observed = existing;
+    for (let attempt = 1; attempt <= idempotent_write_js_1.OVERWRITE_CAS_MAX_ATTEMPTS; attempt++) {
+        try {
+            await (0, idempotent_write_js_1.deleteIdempotently)(context, key, (0, idempotent_write_js_1.revisionGuard)(rows_js_1.REVISION_ATTRIBUTE, observed));
+            return observed;
+        }
+        catch (error) {
+            const repinned = await repinOrResolve(context, key, error);
+            if (repinned === undefined)
+                return observed;
+            observed = repinned;
+        }
+    }
+    return undefined;
+}
+async function deleteStoreItem(context, address) {
+    const key = (0, rows_js_1.itemRowKey)(address);
+    const existing = await (0, rows_js_1.readExisting)(context, key);
+    const released = existing.exists ? await removeObservedRow(context, key, existing) : existing;
+    if (released === undefined) {
+        context.logger.warn('store.delete: compare-and-swap exhausted; the item was not deleted', {
+            namespace: address.namespace,
+            key: address.key,
+            attempts: idempotent_write_js_1.OVERWRITE_CAS_MAX_ATTEMPTS,
+        });
+    }
+    await (0, vector_index_js_1.dropVectorWhenGone)(context, address);
+    if (context.offloader && released?.value) {
+        await (0, offloader_js_1.cleanUpS3Orphans)(context.offloader, {
+            keys: (0, codec_js_1.collectS3Keys)([released.value]),
+            operation: 'store.delete',
+            logger: context.logger,
+            scope: [...address.namespace, address.key],
+        });
+    }
+}
+async function cleanUp(context, release, label, scope) {
+    if (!context.offloader || !release)
+        return;
+    await (0, offloader_js_1.cleanUpS3Orphans)(context.offloader, {
+        keys: (0, codec_js_1.collectS3Keys)([release]),
+        operation: label,
+        logger: context.logger,
+        ...(scope === undefined ? {} : { scope }),
+    });
+}
+function assertRowFits(record) {
+    const bytes = (0, row_size_js_1.rowSizeBytes)(record);
+    if (bytes <= row_size_js_1.MAX_ROW_BYTES)
+        return;
+    const { embeddings, ...bare } = record;
+    const vectorsOverflow = embeddings !== undefined && (0, row_size_js_1.rowSizeBytes)(bare) <= row_size_js_1.MAX_ROW_BYTES;
+    throw (0, errors_js_1.validationError)(vectorsOverflow
+        ? `the item's ${embeddings.length} inline vectors make its row ${bytes} bytes, over ` +
+            `DynamoDB's ${row_size_js_1.MAX_ROW_BYTES}-byte item limit; index fewer fields, embed with fewer ` +
+            'dimensions, or configure a vectorBackend'
+        : `the item's row would be ${bytes} bytes, over DynamoDB's ${row_size_js_1.MAX_ROW_BYTES}-byte item ` +
+            'limit; configure s3 offloading or store a smaller value', vectorsOverflow ? 'index' : 'value');
+}
+async function persistRow(context, record, existing) {
+    try {
+        assertRowFits(record);
+    }
+    catch (error) {
+        await cleanUp(context, record.value, 'store.put');
+        throw error;
+    }
+    let superseded;
+    if (context.offloader) {
+        const swap = await putWithRevisionSwap(context, record, existing);
+        superseded = swap.ok
+            ? swap.superseded
+            : await settleFailedPut(context, record, swap.reason, swap.pinned);
+    }
+    else {
+        try {
+            await (0, retry_js_1.withDynamoDBRetry)((request) => context.client.put({ TableName: context.tableName, Item: record }, request), context.retry);
+            superseded = existing;
+        }
+        catch (error) {
+            superseded = await settleFailedPut(context, record, error, existing);
+        }
+    }
+    await cleanUp(context, superseded.value, 'store.put.overwrite', [
+        ...record.namespace,
+        record.key,
+    ]);
+}
+async function settleFailedPut(context, record, error, pinned) {
+    const verdict = (0, idempotent_write_js_1.settledVerdict)(await verifyWriteLanded(context, record), error);
+    if (verdict === 'landed')
+        return pinned;
+    if (verdict === 'not-landed')
+        await cleanUp(context, record.value, 'store.put');
+    throw error;
+}
+async function put(context, record, observed) {
+    const guard = observed ? (0, idempotent_write_js_1.revisionGuard)(rows_js_1.REVISION_ATTRIBUTE, observed) : undefined;
+    await (0, idempotent_write_js_1.commitRow)(context, record, record.value, { guard });
+}
+async function putWithRevisionSwap(context, record, existing) {
+    let observed = existing;
+    for (let attempt = 1; attempt <= idempotent_write_js_1.OVERWRITE_CAS_MAX_ATTEMPTS; attempt++) {
+        const attempted = observed;
+        try {
+            await put(context, record, attempted);
+            return { ok: true, superseded: attempted };
+        }
+        catch (error) {
+            const rejection = error;
+            if (!(0, idempotent_write_js_1.isConditionalCheckFailed)(rejection)) {
+                return { ok: false, reason: rejection, pinned: attempted };
+            }
+            try {
+                const rejected = (0, idempotent_write_js_1.rejectedRow)(rejection);
+                observed = rejected
+                    ? (0, rows_js_1.existingFrom)(rejected)
+                    : await (0, rows_js_1.readExisting)(context, (0, table_schema_js_1.rowKeyOf)(record));
+            }
+            catch (readError) {
+                return { ok: false, reason: readError, pinned: attempted };
+            }
+            if (record.rev !== undefined && observed.revision === record.rev) {
+                return { ok: true, superseded: attempted };
+            }
+            record.createdAt = (0, rows_js_1.isLiveRow)(observed)
+                ? (observed.createdAt ?? record.createdAt)
+                : record.updatedAt;
+        }
+    }
+    context.logger.warn('store.put: compare-and-swap exhausted; overwriting unconditionally, which can orphan one ' +
+        'S3 object under a concurrent put (reclaimed by ensureS3LifecycleRule)', { namespace: record.namespace, key: record.key, attempts: idempotent_write_js_1.OVERWRITE_CAS_MAX_ATTEMPTS });
+    try {
+        await put(context, record);
+        return { ok: true, superseded: observed };
+    }
+    catch (error) {
+        return { ok: false, reason: error, pinned: observed };
+    }
+}
+function isRetryExhausted(error) {
+    return (0, base_error_js_1.hasErrorCode)(error, error_code_js_1.ErrorCode.RETRY_EXHAUSTED);
+}
+async function verifyWriteLanded(context, record) {
+    const { verdict } = await (0, idempotent_write_js_1.verifyRow)(context, {
+        key: (0, table_schema_js_1.rowKeyOf)(record),
+        kind: 'attribute',
+        attribute: rows_js_1.REVISION_ATTRIBUTE,
+        expected: record.rev,
+    });
+    return verdict;
+}

package/dist/{store → cjs/store}/internal/parse.d.ts

@@ -9,9 +9,9 @@
  * no later step checks again.
  */
 import type { BaseStore, ListNamespacesOperation, Operation, PutOperation, SearchOperation } from '@langchain/langgraph-checkpoint';
-import { type PageLimit } from '../../shared/validation/primitives';
-import type { ListNamespacesOptions } from '../types';
-import type { JsonValue } from './filter';
+import { type PageLimit } from '../../shared/validation/primitives.js';
+import type { ListNamespacesOptions } from '../types.js';
+import type { JsonValue } from './filter.js';
 declare const namespaceBrand: unique symbol;
 declare const namespacePrefixBrand: unique symbol;
 declare const storeAddressBrand: unique symbol;
@@ -49,10 +49,12 @@ export type StoreAddress = {
  *
  * Returns: a copy of the labels, as a {@link NamespacePrefix}. A prefix no
  * stored namespace could ever match is refused rather than answered with a
- * silent empty page.
+ * silent empty page: a malformed label, or labels past the first that compose
+ * more sort key than DynamoDB allows a row to carry before any key — every
+ * label legal on its own, and still no item under it.
  *
- * Throws: `VALIDATION` naming `field` for a non-array, or `<field> element` for
- * a malformed label.
+ * Throws: `VALIDATION` naming `field` for a non-array or a path too wide for
+ * any sort key, or `<field> element` for a malformed label.
  */
 export declare function parseNamespacePrefix(value: unknown, field: string): NamespacePrefix;
 /**
@@ -169,13 +171,16 @@ export declare function parseListOperation(op: ListNamespacesOperation): ParsedL
 /**
  * Parse the options of `listNamespaces`.
  *
- * Accepts: `options` — only `prefix`, `suffix`, `maxDepth`, `limit` and
- * `offset`; `limit` defaults to 100 and `offset` to 0.
+ * Accepts: `options` — an object; `prefix`, `suffix`, `maxDepth`, `limit` and
+ * `offset` are read, `limit` defaulting to 100 and `offset` to 0. Any other key
+ * is ignored rather than refused: `BaseStore.listNamespaces` declares these
+ * options, so a key a later LangGraph adds must not refuse the call (decision
+ * record 28).
  *
  * Returns: the listing the options describe.
  *
- * Throws: `VALIDATION` naming `options.<key>` for a key this package does not
- * read, then as {@link parseListOperation}.
+ * Throws: `VALIDATION` naming `options` for options that are not an object,
+ * then as {@link parseListOperation}.
  */
 export declare function parseListNamespacesOptions(options: ListNamespacesOptions): ParsedList;
 /**

package/dist/cjs/store/internal/parse.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNamespacePrefix = parseNamespacePrefix;
+exports.parseNamespace = parseNamespace;
+exports.parseStoreAddress = parseStoreAddress;
+exports.parseSearch = parseSearch;
+exports.parseListOperation = parseListOperation;
+exports.parseListNamespacesOptions = parseListNamespacesOptions;
+exports.parsePutArguments = parsePutArguments;
+exports.parseOperation = parseOperation;
+exports.parseOperations = parseOperations;
+const table_schema_js_1 = require("../../shared/dynamodb/table-schema.js");
+const errors_js_1 = require("../../shared/errors/errors.js");
+const option_shape_js_1 = require("../../shared/validation/option-shape.js");
+const primitives_js_1 = require("../../shared/validation/primitives.js");
+const rows_js_1 = require("./rows.js");
+const RESERVED_ROOT = 'langgraph';
+const DEFAULT_SEARCH_LIMIT = (0, primitives_js_1.parseLimit)(10, 0);
+const DEFAULT_LIST_LIMIT = 100;
+function parseLabels(value, field) {
+    if (!Array.isArray(value)) {
+        throw (0, errors_js_1.validationError)(`${field} must be an array of labels`, field);
+    }
+    const labels = [];
+    for (const label of value) {
+        labels.push((0, primitives_js_1.parseIdentifier)(label, table_schema_js_1.KEY_SEPARATOR, `${field} element`, table_schema_js_1.MAX_KEY_SEGMENT_BYTES));
+    }
+    return labels;
+}
+function parseNamespacePrefix(value, field) {
+    const labels = parseLabels(value, field);
+    const bytes = Buffer.byteLength((0, rows_js_1.sortKeyPrefix)(labels), 'utf8');
+    if (bytes >= table_schema_js_1.MAX_SORT_KEY_BYTES) {
+        throw (0, errors_js_1.validationError)(`${field} leads a sort key with ${bytes} bytes before any key; DynamoDB caps sort keys at ` +
+            `${table_schema_js_1.MAX_SORT_KEY_BYTES} bytes, so no stored namespace can match it`, field);
+    }
+    return labels;
+}
+function parseNamespace(value, field = 'namespace') {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw (0, errors_js_1.validationError)(`${field} must be a non-empty array`, field);
+    }
+    return parseLabels(value, field);
+}
+function parseStoreAddress(namespace, key) {
+    const parsedNamespace = parseNamespace(namespace);
+    const parsedKey = (0, primitives_js_1.parseIdentifier)(key, table_schema_js_1.KEY_SEPARATOR, 'key', table_schema_js_1.MAX_KEY_SEGMENT_BYTES);
+    const bytes = Buffer.byteLength((0, rows_js_1.sortKey)(parsedNamespace, parsedKey), 'utf8');
+    if (bytes > table_schema_js_1.MAX_SORT_KEY_BYTES) {
+        throw (0, errors_js_1.validationError)(`namespace and key compose a ${bytes}-byte sort key; DynamoDB caps sort keys at ` +
+            `${table_schema_js_1.MAX_SORT_KEY_BYTES} bytes`, 'sortKey');
+    }
+    return { namespace: parsedNamespace, key: parsedKey };
+}
+function parseIndex(index) {
+    if (index === undefined || index === false)
+        return index;
+    return (0, primitives_js_1.parseStringArray)(index, 'index');
+}
+function parseSearch(namespacePrefix, op) {
+    if (op.filter !== undefined)
+        (0, option_shape_js_1.assertObjectShape)(op.filter, 'filter');
+    const query = op.query === undefined ? undefined : (0, primitives_js_1.parseString)(op.query, 'query');
+    const offset = (0, primitives_js_1.parseInteger)(op.offset === undefined ? 0 : op.offset, 'offset', { min: 0 });
+    const limit = op.limit === undefined ? DEFAULT_SEARCH_LIMIT : (0, primitives_js_1.parseLimit)(op.limit, 0);
+    return {
+        kind: 'search',
+        namespacePrefix,
+        filter: op.filter,
+        query,
+        offset,
+        limit,
+    };
+}
+function parseMatchCondition(condition) {
+    (0, option_shape_js_1.assertObjectShape)(condition, 'matchConditions');
+    const { matchType, path } = condition;
+    if (matchType !== 'prefix' && matchType !== 'suffix') {
+        const received = typeof matchType === 'string' ? JSON.stringify(matchType) : typeof matchType;
+        throw (0, errors_js_1.validationError)(`matchType must be "prefix" or "suffix" (received ${received})`, 'matchConditions');
+    }
+    return { matchType, path: parseNamespacePrefix(path, matchType) };
+}
+function parseMatchConditions(conditions) {
+    if (conditions === undefined)
+        return undefined;
+    if (!Array.isArray(conditions)) {
+        throw (0, errors_js_1.validationError)('matchConditions must be an array', 'matchConditions');
+    }
+    const parsed = [];
+    for (const condition of conditions)
+        parsed.push(parseMatchCondition(condition));
+    return parsed;
+}
+function parseListOperation(op) {
+    const offset = (0, primitives_js_1.parseInteger)(op.offset, 'offset', { min: 0 });
+    const limit = (0, primitives_js_1.parseLimit)(op.limit, 0);
+    const maxDepth = op.maxDepth === undefined ? undefined : (0, primitives_js_1.parseInteger)(op.maxDepth, 'maxDepth', { min: 1 });
+    return {
+        kind: 'list',
+        matchConditions: parseMatchConditions(op.matchConditions),
+        maxDepth,
+        offset,
+        limit,
+    };
+}
+function parseListNamespacesOptions(options) {
+    (0, option_shape_js_1.assertObjectShape)(options, 'options');
+    const { prefix, suffix, maxDepth, limit = DEFAULT_LIST_LIMIT, offset = 0 } = options;
+    const matchConditions = [];
+    if (prefix !== undefined)
+        matchConditions.push({ matchType: 'prefix', path: prefix });
+    if (suffix !== undefined)
+        matchConditions.push({ matchType: 'suffix', path: suffix });
+    return parseListOperation({
+        matchConditions: matchConditions.length > 0 ? matchConditions : undefined,
+        maxDepth,
+        limit,
+        offset,
+    });
+}
+function assertNoPeriodLabel(namespace) {
+    if (namespace.some((label) => label.includes('.'))) {
+        throw (0, errors_js_1.validationError)('namespace element must not contain "."; upstream refuses it on every write', 'namespace element');
+    }
+}
+function assertUpstreamPutNamespace(namespace) {
+    assertNoPeriodLabel(namespace);
+    if (namespace[0] === RESERVED_ROOT) {
+        throw (0, errors_js_1.validationError)(`namespace must not start with "${RESERVED_ROOT}", the root label LangGraph reserves`, 'namespace');
+    }
+}
+function parsePutArguments(namespace, key, value, index) {
+    const address = parseStoreAddress(namespace, key);
+    assertUpstreamPutNamespace(address.namespace);
+    if (value === null) {
+        throw (0, errors_js_1.validationError)('value must be an object; delete() removes an item', 'value');
+    }
+    (0, option_shape_js_1.assertObjectShape)(value, 'value');
+    return {
+        kind: 'put',
+        address,
+        value: value,
+        index: parseIndex(index),
+    };
+}
+function parsePutOperation(op) {
+    const address = parseStoreAddress(op.namespace, op.key);
+    if (op.value !== null)
+        assertNoPeriodLabel(address.namespace);
+    if (op.value !== null)
+        (0, option_shape_js_1.assertObjectShape)(op.value, 'value');
+    const index = parseIndex(op.index);
+    if (op.value === null)
+        return { kind: 'delete', address };
+    return { kind: 'put', address, value: op.value, index };
+}
+function parseOperation(operation) {
+    if (typeof operation !== 'object' || operation === null || Array.isArray(operation)) {
+        throw (0, errors_js_1.validationError)('every operation in operations must be an object', 'operations');
+    }
+    if ('namespacePrefix' in operation) {
+        return parseSearch(parseNamespacePrefix(operation.namespacePrefix, 'namespacePrefix'), operation);
+    }
+    if ('value' in operation)
+        return parsePutOperation(operation);
+    if ('key' in operation) {
+        return { kind: 'get', address: parseStoreAddress(operation.namespace, operation.key) };
+    }
+    return parseListOperation(operation);
+}
+function parseOperations(operations) {
+    if (!Array.isArray(operations)) {
+        throw (0, errors_js_1.validationError)('operations must be an array', 'operations');
+    }
+    const parsed = [];
+    for (const operation of operations)
+        parsed.push(parseOperation(operation));
+    return parsed;
+}

package/dist/{store → cjs/store}/internal/rows.d.ts

@@ -4,18 +4,16 @@
  * An item's namespace root is its partition and the rest of its namespace,
  * with its key, is its sort key, so a prefix search is a key-range query. How
  * those keys are composed, which attributes a row carries — its revision token,
- * timestamps, embeddings, recency-index keys — how a value is encoded into one
- * and decoded out, and which rows a read admits as this adapter's items are
- * decided here.
+ * timestamps, embeddings — how a value is encoded into one and decoded out,
+ * and which rows a read admits as this adapter's items are decided here.
  */
 import type { QueryCommandInput, ScanCommandInput } from '@aws-sdk/lib-dynamodb';
 import type { Item } from '@langchain/langgraph-checkpoint';
-import { type DescriptorRef, type PayloadDescriptor } from '../../shared/codec/codec';
-import type { AttributeMap } from '../../shared/dynamodb/client';
-import { type IndexTarget } from '../../shared/dynamodb/recency-index';
-import { type RowKey } from '../../shared/dynamodb/table-schema';
-import type { JsonValue } from './filter';
-import type { StoreContext } from './setup';
+import { type DescriptorRef, type PayloadDescriptor } from '../../shared/codec/codec.js';
+import type { AttributeMap } from '../../shared/dynamodb/client.js';
+import { type RowKey } from '../../shared/dynamodb/table-schema.js';
+import type { JsonValue } from './filter.js';
+import type { StoreContext } from './setup.js';
 /**
  * The attribute an item row carries its revision token in, rewritten on every
  * put. A put's compare-and-swap and a delete's pin both hold the row to the
@@ -164,19 +162,38 @@ export declare function storeScan(tableName: string): ScanCommandInput;
  * transfer and unmarshalling, not cost.
  */
 export declare function projectKeys<T extends QueryCommandInput | ScanCommandInput>(params: T): T;
-/** The previous row's createdAt, payload descriptor and revision. */
+/** The previous row's createdAt, expiry, payload descriptor and revision. */
 export interface ExistingRowMeta {
     exists: boolean;
     createdAt?: string;
+    /** The row's expiry stamp in epoch seconds, when it carries one. */
+    ttl?: number;
     value?: DescriptorRef;
     revision?: string;
 }
+/**
+ * Whether a row a put is about to replace is an item to its readers.
+ *
+ * A row past its `ttl` is hidden from `get`, from every search and from every
+ * listing until DynamoDB's sweep removes it, which can lag for days; a put over
+ * one is a creation, not an update. The row's revision and descriptor still
+ * count — the swap must pin the row that is physically there and release the
+ * object it names — so this is asked only of what the put inherits.
+ *
+ * Accepts: `existing` — what {@link readExisting} or {@link existingFrom} read.
+ *
+ * Returns: true when there is a row and it has not expired.
+ *
+ * Throws: nothing.
+ */
+export declare function isLiveRow(existing: ExistingRowMeta): boolean;
 /**
  * Read the fields a put needs from the row it is about to replace, in one
- * strongly-consistent projection: `createdAt` to preserve, the descriptor's
- * location and S3 key to clean up afterwards (never its inline bytes, which
- * can be hundreds of kilobytes the write would only discard), and the
- * revision the compare-and-swap pins.
+ * strongly-consistent projection: `createdAt` to preserve and the `ttl` that
+ * decides whether it is preserved, the descriptor's location and S3 key to
+ * clean up afterwards (never its inline bytes, which can be hundreds of
+ * kilobytes the write would only discard), and the revision the
+ * compare-and-swap pins.
  *
  * Lives apart from `actions/put.ts` so `item-write.ts` can re-read on a lost swap
  * without importing its own caller.
@@ -212,9 +229,6 @@ export interface StoreItemRow {
     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;
     namespace: string[];
     key: string;
     value: PayloadDescriptor;
@@ -311,13 +325,15 @@ export interface BuildRowOptions {
  * reads back, and an offloaded value's key ends in; absent, a fresh UUID is
  * drawn, before the value is encoded.
  *
- * Returns: the complete row, including the recency-index attributes: a store
- * item is listed across partitions by a rootless search, so it is indexed.
+ * Returns: the complete row. It carries no recency-index keys: no store read
+ * uses that index.
  *
  * Throws: `VALIDATION` naming `value` for a value with no JSON
- * representation; `S3_OFFLOAD_FAILED` when an offloaded payload cannot be
- * uploaded. Encoding happens before any write, so a value that cannot be stored
- * never half-writes a row.
+ * representation, or `payload` for one too large to store inline without
+ * `s3`, or, once offloaded, larger than `s3.maxDownloadBytes`;
+ * `S3_OFFLOAD_FAILED` when an offloaded payload cannot be uploaded. Encoding
+ * happens before any write, so a value that cannot be stored never
+ * half-writes a row.
  */
 export declare function buildStoreRow(context: StoreContext, address: {
     namespace: string[];
@@ -341,15 +357,3 @@ export declare function buildStoreRow(context: StoreContext, address: {
  * overwrite.
  */
 export declare function readStoreItem(context: StoreContext, record: StoreItemRow, signal?: AbortSignal): Promise<Item>;
-/**
- * Where a store row sits in the recency index, for a row written before the
- * index existed.
- *
- * Accepts: `row` — any row of the table.
- *
- * Returns: an item row's identity — its sort key, at its own `updatedAt` — or
- * `undefined` for a row of another adapter.
- *
- * Throws: nothing.
- */
-export declare function storeIndexTarget(row: AttributeMap): IndexTarget | undefined;