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

package/dist/store/actions/put.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.putItem = putItem;
-const node_crypto_1 = require("node:crypto");
-const clock_1 = require("../../shared/clock");
-const descriptor_keys_1 = require("../../shared/codec/descriptor-keys");
-const orphans_1 = require("../../shared/codec/s3/orphans");
-const retry_1 = require("../../shared/dynamodb/retry");
-const ttl_1 = require("../../shared/validation/ttl");
-const index_sync_1 = require("../internal/index-sync");
-const item_mapper_1 = require("../internal/item-mapper");
-const keys_1 = require("../internal/keys");
-const persist_1 = require("../internal/persist");
-const read_existing_1 = require("../internal/read-existing");
-const semantic_search_1 = require("../internal/semantic-search");
-const validation_1 = require("../internal/validation");
-const write_verify_1 = require("../internal/write-verify");
-/**
- * Delete the item and, when a vector backend is configured, drop its vector.
- *
- * The delete asks DynamoDB for the row it removed (`ReturnValues: 'ALL_OLD'`),
- * so S3 cleanup targets the descriptor that was actually removed rather than
- * one read a moment earlier — a concurrent put between a pre-read and the
- * delete used to leave its just-written object orphaned — and the delete costs
- * one request instead of two.
- *
- * A retry-exhausted failure is *ambiguous*: the delete may have landed
- * server-side with only its acknowledgement lost. Mirroring `persistRecord`,
- * that case is resolved with a strongly-consistent read — if the row is gone
- * the delete succeeded and the vector-backend delete must still run. The
- * removed descriptor travelled with the lost response, so that one object, if
- * any, is left to the lifecycle rule. Any other failure, or a row still
- * present, propagates unchanged.
- */
-async function deleteStoreItem(context, op, pk, sk) {
-    let removed;
-    try {
-        const result = await (0, retry_1.withDynamoDBRetry)(() => context.client.delete({
-            TableName: context.tableName,
-            Key: { PK: pk, SK: sk },
-            ReturnValues: 'ALL_OLD',
-        }), context.retry);
-        removed = result.Attributes?.value;
-    }
-    catch (error) {
-        const landed = (0, write_verify_1.isRetryExhausted)(error) && (await (0, write_verify_1.rowIsAbsent)(context, { PK: pk, SK: sk }));
-        if (!landed)
-            throw error;
-    }
-    if (context.offloader && removed) {
-        await (0, orphans_1.cleanUpS3Orphans)(context.offloader, (0, descriptor_keys_1.collectS3Keys)([removed]), 'store.delete', context.logger, {
-            scope: [...op.namespace, op.key],
-        });
-    }
-    if (context.vectorBackend) {
-        await (0, index_sync_1.syncVectorIndex)(context.vectorBackend, op.namespace, op.key, undefined, context.logger);
-    }
-}
-/** Compute the embedding for a put, honoring `op.index` (false disables it). */
-async function resolveEmbedding(context, op, value) {
-    if (op.index === false)
-        return undefined;
-    return (0, semantic_search_1.embedValue)(context, value, Array.isArray(op.index) ? op.index : undefined);
-}
-/**
- * Store, update, or delete an item (null deletes). The value is encoded
- * (optional compression/S3 offload, nonced per call so a failed write can never
- * delete the previous payload) and `createdAt` is preserved across updates; a
- * computed embedding is sent to a configured `vectorBackend` instead of being
- * stored on the item — DynamoDB always holds the canonical item.
- */
-async function putItem(context, op) {
-    (0, validation_1.validateStoreKey)(op.namespace, op.key);
-    const pk = (0, keys_1.partitionKey)(op.namespace);
-    const sk = (0, keys_1.sortKey)(op.namespace, op.key);
-    if (op.value === null) {
-        await deleteStoreItem(context, op, pk, sk);
-        return;
-    }
-    const value = op.value;
-    const timestamp = (0, clock_1.nowIso)();
-    const existing = await (0, read_existing_1.readExisting)(context, pk, sk);
-    const embedding = await resolveEmbedding(context, op, value);
-    const ttlTimestamp = context.ttl ? (0, ttl_1.calculateTtlTimestamp)(context.ttl) : undefined;
-    const record = await (0, item_mapper_1.buildStoreItem)(context, op.namespace, op.key, value, {
-        createdAt: existing.createdAt ?? timestamp,
-        updatedAt: timestamp,
-        embedding: context.vectorBackend ? undefined : embedding,
-        ttlTimestamp,
-        nonce: (0, node_crypto_1.randomUUID)(),
-    });
-    await (0, persist_1.persistRecord)(context, record, existing);
-    if (context.vectorBackend) {
-        await (0, index_sync_1.syncVectorIndex)(context.vectorBackend, op.namespace, op.key, embedding, context.logger);
-    }
-}

package/dist/store/actions/reconcile-vector-index.d.ts

@@ -1,18 +0,0 @@
-import type { StoreContext } from '../internal/setup';
-/** Counts returned by {@link reconcileVectorIndex}. */
-export interface VectorReconcileResult {
-    upserted: number;
-    pruned: number;
-}
-/**
- * Repair the vector backend against the canonical DynamoDB items under
- * `namespacePrefix`: re-push every live embedding, and — when the backend
- * implements {@link VectorBackend.listKeys} — prune vectors with no canonical
- * item. A maintenance tool for backend drift; run it when the namespace is
- * idle. Re-embeds with the store's configured fields, so per-put `index` field
- * overrides are not reproduced. Requires a configured `index` and
- * `vectorBackend`; the prefix must be a non-empty namespace.
- */
-export declare function reconcileVectorIndex(context: StoreContext, namespacePrefix: string[], options?: {
-    signal?: AbortSignal;
-}): Promise<VectorReconcileResult>;

package/dist/store/actions/reconcile-vector-index.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reconcileVectorIndex = reconcileVectorIndex;
-const errors_1 = require("../../shared/errors/errors");
-const index_reconcile_1 = require("../internal/index-reconcile");
-const validation_1 = require("../internal/validation");
-/**
- * Repair the vector backend against the canonical DynamoDB items under
- * `namespacePrefix`: re-push every live embedding, and — when the backend
- * implements {@link VectorBackend.listKeys} — prune vectors with no canonical
- * item. A maintenance tool for backend drift; run it when the namespace is
- * idle. Re-embeds with the store's configured fields, so per-put `index` field
- * overrides are not reproduced. Requires a configured `index` and
- * `vectorBackend`; the prefix must be a non-empty namespace.
- */
-async function reconcileVectorIndex(context, namespacePrefix, options = {}) {
-    (0, validation_1.validateNamespace)(namespacePrefix);
-    if (!context.index || !context.vectorBackend) {
-        throw new errors_1.ValidationError('reconcileVectorIndex requires a configured index and vectorBackend');
-    }
-    const backend = context.vectorBackend;
-    const targets = await (0, index_reconcile_1.collectReconcileTargets)(context, namespacePrefix, options.signal);
-    const upserted = await (0, index_reconcile_1.pushEmbeddings)(backend, targets);
-    const pruned = await (0, index_reconcile_1.pruneOrphans)(context, backend, namespacePrefix, targets);
-    return { upserted, pruned };
-}

package/dist/store/actions/search.d.ts

@@ -1,9 +0,0 @@
-import type { SearchItem, SearchOperation } from '@langchain/langgraph-checkpoint';
-import type { StoreContext } from '../internal/setup';
-/**
- * Search items under a namespace prefix: metadata filtering plus optional
- * semantic ranking. A non-empty prefix uses a native Query; an empty prefix
- * falls back to a (filtered) Scan. Semantic ranking uses the configured
- * VectorBackend when present, else an in-memory cosine ranking (capped).
- */
-export declare function searchItems(context: StoreContext, op: SearchOperation, signal?: AbortSignal): Promise<SearchItem[]>;

package/dist/store/actions/search.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.searchItems = searchItems;
-const backend_search_1 = require("../internal/backend-search");
-const candidates_1 = require("../internal/candidates");
-const ranker_1 = require("../internal/ranker");
-const semantic_search_1 = require("../internal/semantic-search");
-const validation_1 = require("../internal/validation");
-const DEFAULT_LIMIT = 10;
-/**
- * Search items under a namespace prefix: metadata filtering plus optional
- * semantic ranking. A non-empty prefix uses a native Query; an empty prefix
- * falls back to a (filtered) Scan. Semantic ranking uses the configured
- * VectorBackend when present, else an in-memory cosine ranking (capped).
- */
-async function searchItems(context, op, signal) {
-    const offset = op.offset ?? 0;
-    const limit = op.limit ?? DEFAULT_LIMIT;
-    (0, validation_1.validatePaging)(offset, limit);
-    if (op.query && context.index && context.vectorBackend) {
-        const ranked = await (0, backend_search_1.searchViaBackend)(context, context.vectorBackend, context.index, op, offset, limit, signal);
-        return ranked.slice(offset, offset + limit);
-    }
-    if (!op.query || !context.index) {
-        const page = await (0, candidates_1.collectCandidates)(context, op, { kind: 'page', need: offset + limit }, signal);
-        return page.map(({ item }) => ({ ...item })).slice(offset, offset + limit);
-    }
-    const candidates = await (0, candidates_1.collectCandidates)(context, op, { kind: 'semantic', cap: context.maxSearchCandidates }, signal);
-    const queryVector = await context.index.embeddings.embedQuery(op.query);
-    (0, semantic_search_1.assertVectorDims)(context.index, queryVector, 'query');
-    const ranked = (0, ranker_1.rankInMemory)(candidates, queryVector, context.maxSearchCandidates, (count) => context.logger.warn('search: some candidates carry an embedding of a different dimension than the query and ' +
-        'were ranked unscored; re-embed them with reconcileVectorIndex or a re-put', { namespacePrefix: op.namespacePrefix, count }));
-    return ranked.slice(offset, offset + limit);
-}

package/dist/store/internal/backend-search.d.ts

@@ -1,4 +0,0 @@
-import type { IndexConfig, SearchItem, SearchOperation } from '@langchain/langgraph-checkpoint';
-import type { VectorBackend } from '../vector-backend';
-import type { StoreContext } from './setup';
-export declare function searchViaBackend(context: StoreContext, backend: VectorBackend, index: IndexConfig, op: SearchOperation, offset: number, limit: number, signal?: AbortSignal): Promise<SearchItem[]>;

package/dist/store/internal/backend-search.js

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.searchViaBackend = searchViaBackend;
-const errors_1 = require("../../shared/errors/errors");
-const get_1 = require("../actions/get");
-const keys_1 = require("./keys");
-const score_direction_1 = require("./score-direction");
-const search_filter_1 = require("./search-filter");
-const semantic_search_1 = require("./semantic-search");
-/**
- * Warn when a backend's own ordering disagrees with its scores. A backend
- * returning a raw distance still hands back nearest-first, so the order looks
- * right while every score means the opposite of what {@link VectorMatch.score}
- * promises — ascending scores are that exact signature. Results are never
- * reordered on this basis: a correctly-scored backend's order is authoritative.
- */
-function warnOnNonDescendingScores(context, matches, namespacePrefix) {
-    const descending = matches.every((match, position) => position === 0 || matches[position - 1].score >= match.score);
-    if (descending)
-        return;
-    context.logger.warn('search: vectorBackend returned ascending scores; VectorMatch.score must be a relevance ' +
-        '(higher is better), not a distance — results are forwarded in the order the backend gave', { namespacePrefix });
-}
-/**
- * Read the canonical item a backend match points at, or `undefined` when the
- * match is unusable. `getItem` validates, so a backend returning a namespace
- * element containing the reserved separator would otherwise turn the whole
- * search into a ValidationError instead of dropping the one bad match.
- */
-async function fetchMatch(context, match, signal) {
-    try {
-        return await (0, get_1.getItem)(context, match.namespace, match.key, signal);
-    }
-    catch (error) {
-        context.logger.warn('search: skipped an unusable vectorBackend match', {
-            namespace: match.namespace,
-            key: match.key,
-            reason: error.name,
-        });
-        return null;
-    }
-}
-async function searchViaBackend(context, backend, index, op, offset, limit, signal) {
-    const queryVector = await index.embeddings.embedQuery(op.query);
-    (0, semantic_search_1.assertVectorDims)(index, queryVector, 'query');
-    const need = offset + limit;
-    if (need > context.maxSearchCandidates) {
-        throw new errors_1.ValidationError(`Requested page (offset ${offset} + limit ${limit} = ${need}) exceeds maxSearchCandidates ` +
-            `(${context.maxSearchCandidates}); narrow the page or raise maxSearchCandidates`, 'maxSearchCandidates');
-    }
-    let topK = Math.min(need, context.maxSearchCandidates);
-    let results;
-    for (;;) {
-        const matches = (0, score_direction_1.toRelevanceScores)(await backend.query(op.namespacePrefix, queryVector, topK), context.vectorScoreDirection);
-        warnOnNonDescendingScores(context, matches, op.namespacePrefix);
-        results = [];
-        for (const match of matches) {
-            if (!(0, keys_1.namespaceMatchesPrefix)(match.namespace, op.namespacePrefix))
-                continue;
-            const item = await fetchMatch(context, match, signal);
-            if (item && (0, search_filter_1.passesFilter)(item, op))
-                results.push({ ...item, score: match.score });
-        }
-        if (results.length >= need || matches.length < topK)
-            break;
-        if (topK >= context.maxSearchCandidates) {
-            /** The backend still holds matches, but the filter left the page short at the cap: the same answer the in-DB ranker gives, not a silently short page. */
-            throw new errors_1.ValidationError(`Semantic search collected ${results.length} of ${need} matches within maxSearchCandidates ` +
-                `(${context.maxSearchCandidates}); narrow the filter or raise maxSearchCandidates`, 'maxSearchCandidates');
-        }
-        topK = Math.min(topK * 2, context.maxSearchCandidates);
-    }
-    return results;
-}

package/dist/store/internal/batch-plan.d.ts

@@ -1,11 +0,0 @@
-import type { Operation } from '@langchain/langgraph-checkpoint';
-/**
- * Run a batch: every write group serially within itself and groups
- * concurrently with each other, then every read concurrently, at most
- * {@link DEFAULT_READ_CONCURRENCY} operations in flight at a time. Results
- * come back in operation order. Writes complete before any read starts, so a
- * get or search in the same batch observes the puts beside it. Any failure
- * rejects the whole batch: no further operation is started, the ones already
- * in flight settle, and the first error propagates.
- */
-export declare function runBatch<R>(operations: readonly Operation[], dispatch: (operation: Operation) => Promise<R>): Promise<R[]>;

package/dist/store/internal/batch-plan.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runBatch = runBatch;
-const concurrency_1 = require("../../shared/concurrency");
-const constants_1 = require("../../shared/constants");
-function itemOf(op) {
-    return JSON.stringify([op.namespace, op.key]);
-}
-/**
- * Group a batch so that dependent operations stay ordered while independent
- * ones can run side by side. Two writes to the same item must land in the
- * order given, since the later one wins; writes to different items and all
- * reads are independent of each other.
- */
-function planBatch(operations) {
-    const groups = new Map();
-    const reads = [];
-    operations.forEach((op, index) => {
-        if (!('value' in op)) {
-            reads.push(index);
-            return;
-        }
-        const item = itemOf(op);
-        const group = groups.get(item);
-        if (group)
-            group.push(index);
-        else
-            groups.set(item, [index]);
-    });
-    return { writeGroups: [...groups.values()], reads };
-}
-/**
- * Run a batch: every write group serially within itself and groups
- * concurrently with each other, then every read concurrently, at most
- * {@link DEFAULT_READ_CONCURRENCY} operations in flight at a time. Results
- * come back in operation order. Writes complete before any read starts, so a
- * get or search in the same batch observes the puts beside it. Any failure
- * rejects the whole batch: no further operation is started, the ones already
- * in flight settle, and the first error propagates.
- */
-async function runBatch(operations, dispatch) {
-    const plan = planBatch(operations);
-    const results = [];
-    await (0, concurrency_1.mapWithConcurrency)(plan.writeGroups, constants_1.DEFAULT_READ_CONCURRENCY, async (group) => {
-        for (const index of group)
-            results[index] = await dispatch(operations[index]);
-    });
-    await (0, concurrency_1.mapWithConcurrency)(plan.reads, constants_1.DEFAULT_READ_CONCURRENCY, async (index) => {
-        results[index] = await dispatch(operations[index]);
-    });
-    return results;
-}

package/dist/store/internal/candidates.d.ts

@@ -1,23 +0,0 @@
-import type { SearchOperation } from '@langchain/langgraph-checkpoint';
-import type { RankCandidate } from './ranker';
-import type { StoreContext } from './setup';
-/**
- * How far a collection must go. A plain page is complete once `need`
- * (`offset + limit`) matching items are in hand, so rows past it are never
- * read or decoded; a semantic ranking needs every candidate but is refused as
- * soon as more than `cap` rows exist, before a single decode or embedding.
- */
-export type CollectBound = {
-    kind: 'page';
-    need: number;
-} | {
-    kind: 'semantic';
-    cap: number;
-};
-/**
- * Collect the live rows under the prefix and decode them within `bound`. A
- * page decodes rows in batches of {@link DEFAULT_READ_CONCURRENCY} and closes
- * the paginator as soon as the page is full, so a namespace far larger than the
- * page costs neither a full decode nor a truncation error.
- */
-export declare function collectCandidates(context: StoreContext, op: SearchOperation, bound: CollectBound, signal?: AbortSignal): Promise<RankCandidate[]>;

package/dist/store/internal/candidates.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectCandidates = collectCandidates;
-const clock_1 = require("../../shared/clock");
-const concurrency_1 = require("../../shared/concurrency");
-const constants_1 = require("../../shared/constants");
-const expiry_1 = require("../../shared/dynamodb/expiry");
-const paginate_1 = require("../../shared/dynamodb/paginate");
-const retry_policy_1 = require("../../shared/dynamodb/retry-policy");
-const scan_1 = require("../../shared/dynamodb/scan");
-const errors_1 = require("../../shared/errors/errors");
-const item_mapper_1 = require("./item-mapper");
-const keys_1 = require("./keys");
-const query_1 = require("./query");
-const search_filter_1 = require("./search-filter");
-function candidateSource(context, op, signal, now) {
-    return op.namespacePrefix.length > 0
-        ? (0, paginate_1.paginateQuery)({
-            retry: (0, retry_policy_1.retryFor)(context, signal),
-            signal,
-            client: context.client,
-            params: (0, expiry_1.withoutExpired)((0, query_1.scopedQuery)(context.tableName, op.namespacePrefix), now),
-            maxItems: context.maxScanItems,
-        })
-        : (0, scan_1.paginateScan)({
-            retry: (0, retry_policy_1.retryFor)(context, signal),
-            signal,
-            client: context.client,
-            params: (0, expiry_1.withoutExpired)((0, query_1.storeScan)(context.tableName), now),
-            maxItems: context.maxScanItems,
-        });
-}
-/** The store record a raw row denotes, or undefined for a foreign, expired or out-of-prefix row. */
-function liveRecord(raw, op, now) {
-    const record = (0, item_mapper_1.narrowStoreRecord)(raw);
-    if (!record || (0, expiry_1.isExpiredRow)(record, now))
-        return undefined;
-    return (0, keys_1.namespaceMatchesPrefix)(record.namespace, op.namespacePrefix) ? record : undefined;
-}
-/** Decode the pending rows concurrently (each offloaded row is one S3 GET) and keep the ones passing the filter. */
-async function flush(context, op, state) {
-    if (state.pending.length === 0)
-        return;
-    const batch = state.pending;
-    state.pending = [];
-    const items = await (0, concurrency_1.mapWithConcurrency)(batch, constants_1.DEFAULT_READ_CONCURRENCY, (record) => (0, item_mapper_1.readStoreItem)(context, record));
-    batch.forEach((record, index) => {
-        if ((0, search_filter_1.passesFilter)(items[index], op)) {
-            state.collected.push({ item: items[index], embedding: record.embedding });
-        }
-    });
-}
-/**
- * Rows to gather before the next decode. With a filter every batch is a full
- * one, since any row may be dropped; without one every decoded row is a match,
- * so the batch never exceeds what the page still needs.
- */
-function batchSize(op, need, collected) {
-    return op.filter === undefined
-        ? Math.min(constants_1.DEFAULT_READ_CONCURRENCY, need - collected)
-        : constants_1.DEFAULT_READ_CONCURRENCY;
-}
-function tooManyCandidates(count, cap) {
-    return new errors_1.ValidationError(`Semantic search candidate set (${count}) exceeds maxSearchCandidates (${cap}); ` +
-        'use a dedicated VectorBackend for large corpora', 'maxSearchCandidates');
-}
-/**
- * Collect the live rows under the prefix and decode them within `bound`. A
- * page decodes rows in batches of {@link DEFAULT_READ_CONCURRENCY} and closes
- * the paginator as soon as the page is full, so a namespace far larger than the
- * page costs neither a full decode nor a truncation error.
- */
-async function collectCandidates(context, op, bound, signal) {
-    const now = (0, clock_1.nowSeconds)();
-    const state = { pending: [], collected: [] };
-    for await (const raw of candidateSource(context, op, signal, now)) {
-        const record = liveRecord(raw, op, now);
-        if (!record)
-            continue;
-        state.pending.push(record);
-        if (bound.kind === 'semantic') {
-            if (state.pending.length > bound.cap)
-                throw tooManyCandidates(state.pending.length, bound.cap);
-            continue;
-        }
-        if (state.pending.length < batchSize(op, bound.need, state.collected.length))
-            continue;
-        await flush(context, op, state);
-        if (state.collected.length >= bound.need)
-            return state.collected;
-    }
-    await flush(context, op, state);
-    return state.collected;
-}

package/dist/store/internal/filter.d.ts

@@ -1,9 +0,0 @@
-/** A JSON value stored in an item or supplied in a filter. */
-export type JsonValue = string | number | boolean | null | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-/**
- * True when `value` satisfies every field condition in `filter`. A plain value
- * is exact-match ($eq); an operator object ({ $gt: 4 }) applies comparisons.
- */
-export declare function matchesStoreFilter(value: Record<string, JsonValue>, filter: Record<string, JsonValue>): boolean;

package/dist/store/internal/filter.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchesStoreFilter = matchesStoreFilter;
-const node_util_1 = require("node:util");
-/**
- * Three-way order for a like-typed pair, or `undefined` when the pair is
- * *unordered*. `NaN` compares `false` against everything including itself, so a
- * bare `===`/`>` ternary silently reports it as "less than" — which let a
- * stored `NaN` satisfy `$lt`/`$lte` against any number, contradicting
- * {@link compareOrdered}'s own contract.
- */
-function orderOf(actual, expected) {
-    if (actual < expected)
-        return -1;
-    if (actual > expected)
-        return 1;
-    return actual === expected ? 0 : undefined;
-}
-/** Apply `test` to a resolved order; an unordered pair never matches. */
-function testOrder(order, test) {
-    return order !== undefined && test(order);
-}
-/**
- * Ordered comparison over like-typed values only: numbers compare numerically,
- * strings lexicographically, and a mismatched or unordered pair never matches.
- *
- * Deliberately stricter than both what this used to do and what upstream does.
- * Native `>` coerces, so a stored `'10'` satisfied `{ $gt: 5 }` — inclusion
- * decided by JS coercion rather than by the stored type. Upstream instead
- * reduces both sides with `Number()`, which makes two ISO-8601 date strings
- * `NaN` and every comparison between them false. Comparing like types
- * directly is well-defined in both cases.
- */
-function compareOrdered(actual, expected, test) {
-    if (typeof actual === 'number' && typeof expected === 'number') {
-        return testOrder(orderOf(actual, expected), test);
-    }
-    if (typeof actual === 'string' && typeof expected === 'string') {
-        return testOrder(orderOf(actual, expected), test);
-    }
-    return false;
-}
-const COMPARATORS = {
-    $eq: (actual, expected) => (0, node_util_1.isDeepStrictEqual)(actual, expected),
-    $ne: (actual, expected) => !(0, node_util_1.isDeepStrictEqual)(actual, expected),
-    $gt: (actual, expected) => compareOrdered(actual, expected, (order) => order > 0),
-    $gte: (actual, expected) => compareOrdered(actual, expected, (order) => order >= 0),
-    $lt: (actual, expected) => compareOrdered(actual, expected, (order) => order < 0),
-    $lte: (actual, expected) => compareOrdered(actual, expected, (order) => order <= 0),
-    $in: (actual, expected) => Array.isArray(expected)
-        ? expected.some((candidate) => (0, node_util_1.isDeepStrictEqual)(actual, candidate))
-        : false,
-    $nin: (actual, expected) => Array.isArray(expected)
-        ? !expected.some((candidate) => (0, node_util_1.isDeepStrictEqual)(actual, candidate))
-        : true,
-};
-/**
- * True only when every key is one of the exact known operator names — matches
- * the official `@langchain/langgraph-checkpoint` InMemoryStore's own detection
- * exactly, so a stored value that merely has `$`-prefixed keys (e.g. a JSON
- * Schema document) is compared as a literal value instead of misread as a
- * filter operator.
- */
-function isOperatorObject(condition) {
-    return (typeof condition === 'object' &&
-        condition !== null &&
-        !Array.isArray(condition) &&
-        Object.keys(condition).length > 0 &&
-        Object.keys(condition).every((key) => Object.prototype.hasOwnProperty.call(COMPARATORS, key)));
-}
-function matchesCondition(actual, condition) {
-    if (!isOperatorObject(condition))
-        return (0, node_util_1.isDeepStrictEqual)(actual, condition);
-    return Object.entries(condition).every(([operator, expected]) => COMPARATORS[operator](actual, expected));
-}
-/**
- * True when `value` satisfies every field condition in `filter`. A plain value
- * is exact-match ($eq); an operator object ({ $gt: 4 }) applies comparisons.
- */
-function matchesStoreFilter(value, filter) {
-    return Object.entries(filter).every(([field, condition]) => 
-    /** Own properties only: `value['toString']` would otherwise resolve up the
-     *  prototype chain and be compared as if it were stored data. */
-    matchesCondition(Object.hasOwn(value, field) ? value[field] : undefined, condition));
-}

package/dist/store/internal/index-reconcile.d.ts

@@ -1,21 +0,0 @@
-import type { VectorBackend, VectorRef } from '../vector-backend';
-import type { StoreContext } from './setup';
-/** A canonical item's location plus the embedding recomputed for it. */
-export interface ReconcileTarget {
-    namespace: string[];
-    key: string;
-    embedding: number[] | undefined;
-}
-/**
- * Enumerate the live (unexpired) items under `prefix`, then recompute their
- * embeddings in batches. A failed embedding rejects the whole reconcile: a
- * skipped item would leave the live set and {@link selectOrphans} would prune
- * its still-valid vector.
- */
-export declare function collectReconcileTargets(context: StoreContext, prefix: string[], signal?: AbortSignal): Promise<ReconcileTarget[]>;
-/** Re-push every live embedding to the backend; returns the upsert count. */
-export declare function pushEmbeddings(backend: VectorBackend, targets: ReconcileTarget[]): Promise<number>;
-/** Refs present in the backend but absent from `live` — orphans to prune. */
-export declare function selectOrphans(backendRefs: VectorRef[], live: ReconcileTarget[]): VectorRef[];
-/** Delete backend vectors with no canonical item; returns the prune count. */
-export declare function pruneOrphans(context: StoreContext, backend: VectorBackend, prefix: string[], live: ReconcileTarget[]): Promise<number>;