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

package/dist/store/internal/overwrite-swap.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.putWithRevisionSwap = putWithRevisionSwap;
-const conditional_put_1 = require("../../shared/dynamodb/conditional-put");
-const retry_1 = require("../../shared/dynamodb/retry");
-const read_existing_1 = require("./read-existing");
-/** Put the record, optionally pinned to the revision the caller observed. */
-async function put(context, record, observed) {
-    const guard = observed ? (0, conditional_put_1.revisionGuard)(conditional_put_1.REVISION_ATTRIBUTE, observed) : {};
-    await (0, retry_1.withDynamoDBRetry)(() => context.client.put({ TableName: context.tableName, Item: record, ...guard }), context.retry);
-}
-/**
- * Commit `record`, re-reading and retrying while another writer holds the row,
- * and return the state this write actually superseded — the only descriptor
- * safe to delete afterwards.
- *
- * Without the swap both racers read the same previous descriptor, both commit,
- * and both delete it, orphaning the loser's own upload. Retrying against the
- * *re-read* state is what makes each writer supersede exactly one payload.
- *
- * A rejection is not proof a competitor won: `withDynamoDBRetry` retries
- * transient errors, so an attempt can commit server-side, its response can be
- * lost, and the retried put can hit the row it just wrote and fail the same
- * guard — indistinguishable from a competitor's win by the rejection alone.
- * Each attempt's pinned observation is captured in `attempted` before the
- * put, so that when a re-read finds the row already holding *this call's
- * own* `rev`, the swap returns whatever `attempted` held — never this
- * record's own just-committed value, which would strand the live row
- * pointing at a deleted object. That comparison is guarded on `rev` being
- * set: `rev` is optional on the record type, and an unnonced record against a
- * pre-0.9.0 revision-less row would otherwise match `undefined === undefined`
- * and claim a race it never entered.
- *
- * On exhaustion the write proceeds unconditionally and warns. That is
- * deliberate: the fallback is precisely the pre-0.9.0 behaviour — one possible
- * orphan, reclaimed by a lifecycle rule — so pathological contention degrades
- * instead of turning a working put into an error. `createdAt` is refreshed from
- * each re-read so a row created by whoever won keeps its true creation time.
- */
-async function putWithRevisionSwap(context, record, existing) {
-    let observed = existing;
-    for (let attempt = 1; attempt <= conditional_put_1.OVERWRITE_CAS_MAX_ATTEMPTS; attempt++) {
-        const attempted = observed;
-        try {
-            await put(context, record, attempted);
-            return attempted;
-        }
-        catch (error) {
-            if (!(0, conditional_put_1.isConditionalCheckFailed)(error))
-                throw error;
-            /** The rejection carries the row that turned it away; the read is spent only when it does not. */
-            const rejected = (0, conditional_put_1.rejectedItem)(error);
-            observed = rejected
-                ? (0, read_existing_1.existingFrom)(rejected)
-                : await (0, read_existing_1.readExisting)(context, record.PK, record.SK);
-            if (record.rev !== undefined && observed.revision === record.rev)
-                return attempted;
-            /** A row that vanished between attempts (a concurrent delete) makes this a fresh creation. */
-            record.createdAt = observed.exists
-                ? (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: conditional_put_1.OVERWRITE_CAS_MAX_ATTEMPTS });
-    await put(context, record);
-    return observed;
-}

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

@@ -1,28 +0,0 @@
-import type { StoreItemRecord } from '../types';
-import type { ExistingRecordMeta } from './read-existing';
-import type { StoreContext } from './setup';
-/**
- * Put the record and clean up whichever side is now dead.
- *
- * The compare-and-swap path runs **only when an offloader is configured**:
- * without one there is no S3 object to orphan, so a plain last-write-wins put
- * stays correct and costs no extra write capacity (DynamoDB charges for a
- * failed conditional write too). With one, the swap is what lets this call
- * delete exactly the payload it superseded rather than a descriptor a racer may
- * already have replaced.
- *
- * Every failure reaching the catch arrives after at least one put was issued —
- * `putWithRevisionSwap` only re-reads from inside its own catch — so none of
- * them proves a non-commit on its own: a put can commit server-side and lose
- * its response, and a `ConditionalCheckFailedException` is as consistent with
- * hitting the row this call just wrote as with a competitor's win. The row is
- * therefore read back (`verifyWriteLanded`) before anything is deleted. Only a
- * confirmed `'not-landed'` deletes this record's own nonced object; a confirmed
- * `'landed'` cleans up the previous object like the success path and swallows
- * the error, and an `'unverified'` read deletes nothing and rethrows — leaking
- * one object at worst rather than stranding a live row pointing at a deleted
- * one. The verification compares the per-call `rev`, so an inline record is
- * verified too: a lost acknowledgement of an inline overwrite used to be
- * reported as a failure while the previous offloaded object was never cleaned.
- */
-export declare function persistRecord(context: StoreContext, record: StoreItemRecord, existing: ExistingRecordMeta): Promise<void>;

package/dist/store/internal/persist.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.persistRecord = persistRecord;
-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 overwrite_swap_1 = require("./overwrite-swap");
-const write_verify_1 = require("./write-verify");
-/**
- * Best-effort delete of one descriptor's S3 object. `scope` is passed for a
- * descriptor read back from the row (the superseded value) and omitted for
- * this call's own upload.
- */
-async function cleanUp(context, descriptor, label, scope) {
-    if (!context.offloader || !descriptor)
-        return;
-    await (0, orphans_1.cleanUpS3Orphans)(context.offloader, (0, descriptor_keys_1.collectS3Keys)([descriptor]), label, context.logger, scope === undefined ? {} : { scope });
-}
-/**
- * Put the record and clean up whichever side is now dead.
- *
- * The compare-and-swap path runs **only when an offloader is configured**:
- * without one there is no S3 object to orphan, so a plain last-write-wins put
- * stays correct and costs no extra write capacity (DynamoDB charges for a
- * failed conditional write too). With one, the swap is what lets this call
- * delete exactly the payload it superseded rather than a descriptor a racer may
- * already have replaced.
- *
- * Every failure reaching the catch arrives after at least one put was issued —
- * `putWithRevisionSwap` only re-reads from inside its own catch — so none of
- * them proves a non-commit on its own: a put can commit server-side and lose
- * its response, and a `ConditionalCheckFailedException` is as consistent with
- * hitting the row this call just wrote as with a competitor's win. The row is
- * therefore read back (`verifyWriteLanded`) before anything is deleted. Only a
- * confirmed `'not-landed'` deletes this record's own nonced object; a confirmed
- * `'landed'` cleans up the previous object like the success path and swallows
- * the error, and an `'unverified'` read deletes nothing and rethrows — leaking
- * one object at worst rather than stranding a live row pointing at a deleted
- * one. The verification compares the per-call `rev`, so an inline record is
- * verified too: a lost acknowledgement of an inline overwrite used to be
- * reported as a failure while the previous offloaded object was never cleaned.
- */
-async function persistRecord(context, record, existing) {
-    let superseded = existing;
-    try {
-        if (context.offloader) {
-            superseded = await (0, overwrite_swap_1.putWithRevisionSwap)(context, record, existing);
-        }
-        else {
-            await (0, retry_1.withDynamoDBRetry)(() => context.client.put({ TableName: context.tableName, Item: record }), context.retry);
-        }
-    }
-    catch (error) {
-        const verdict = await (0, write_verify_1.verifyWriteLanded)(context, record);
-        if (verdict === 'not-landed')
-            await cleanUp(context, record.value, 'store.put');
-        if (verdict !== 'landed')
-            throw error;
-    }
-    await cleanUp(context, superseded.value, 'store.put.overwrite', [
-        ...record.namespace,
-        record.key,
-    ]);
-}

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

@@ -1,11 +0,0 @@
-import type { QueryCommandInput, ScanCommandInput } from '@aws-sdk/lib-dynamodb';
-/** Query input for a scoped prefix (PK = prefix[0], optional SK begins_with). */
-export declare function scopedQuery(tableName: string, prefix: string[]): QueryCommandInput;
-/** Scan input for the rootless case, filtered to store items only. */
-export declare function storeScan(tableName: string): ScanCommandInput;
-/**
- * Restrict a Query/Scan to the attributes `narrowStoreRecord` needs, leaving the
- * payload behind: a namespace listing never reads a value. RCU is billed on
- * the stored size regardless, so the saving is transfer and unmarshalling.
- */
-export declare function projectKeys<T extends QueryCommandInput | ScanCommandInput>(params: T): T;

package/dist/store/internal/query.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scopedQuery = scopedQuery;
-exports.storeScan = storeScan;
-exports.projectKeys = projectKeys;
-const keys_1 = require("./keys");
-/** Query input for a scoped prefix (PK = prefix[0], optional SK begins_with). */
-function scopedQuery(tableName, prefix) {
-    const skPrefix = (0, keys_1.sortKeyPrefix)(prefix);
-    if (skPrefix.length === 0) {
-        return {
-            TableName: tableName,
-            KeyConditionExpression: '#pk = :pk',
-            ExpressionAttributeNames: { '#pk': 'PK' },
-            ExpressionAttributeValues: { ':pk': (0, keys_1.partitionKey)(prefix) },
-        };
-    }
-    return {
-        TableName: tableName,
-        KeyConditionExpression: '#pk = :pk AND begins_with(#sk, :skp)',
-        ExpressionAttributeNames: { '#pk': 'PK', '#sk': 'SK' },
-        ExpressionAttributeValues: { ':pk': (0, keys_1.partitionKey)(prefix), ':skp': skPrefix },
-    };
-}
-/** Scan input for the rootless case, filtered to store items only. */
-function storeScan(tableName) {
-    return {
-        TableName: tableName,
-        FilterExpression: 'attribute_exists(#ns)',
-        ExpressionAttributeNames: { '#ns': 'namespace' },
-    };
-}
-/**
- * Restrict a Query/Scan to the attributes `narrowStoreRecord` needs, leaving the
- * payload behind: a namespace listing never reads a value. RCU is billed on
- * the stored size regardless, so the saving is transfer and unmarshalling.
- */
-function projectKeys(params) {
-    return {
-        ...params,
-        ProjectionExpression: 'PK, SK, #ns, #key',
-        ExpressionAttributeNames: {
-            ...params.ExpressionAttributeNames,
-            '#ns': 'namespace',
-            '#key': 'key',
-        },
-    };
-}

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

@@ -1,18 +0,0 @@
-import type { Item, SearchItem } from '@langchain/langgraph-checkpoint';
-/** A decoded item plus its stored embedding, awaiting ranking. */
-export interface RankCandidate {
-    item: Item;
-    embedding?: number[];
-}
-/**
- * Rank candidates by cosine similarity to `queryVector`, descending. Throws a
- * {@link ValidationError} when the candidate count exceeds `maxCandidates`
- * (steer large corpora to an external VectorBackend).
- *
- * A stored embedding whose length differs from the query vector's cannot be
- * scored — it was written by a different embeddings model — and is ranked
- * last with an undefined score. `onDimensionMismatch` is invoked once with
- * how many candidates that affected, so the caller can say so instead of
- * silently returning a ranking that quietly omits them.
- */
-export declare function rankInMemory(candidates: RankCandidate[], queryVector: number[], maxCandidates: number, onDimensionMismatch?: (count: number) => void): SearchItem[];

package/dist/store/internal/ranker.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rankInMemory = rankInMemory;
-const errors_1 = require("../../shared/errors/errors");
-const semantic_search_1 = require("./semantic-search");
-/** Sort weight for an item without an embedding; below the −1 cosine minimum. */
-const UNSCORED_RANK = -2;
-/**
- * Rank candidates by cosine similarity to `queryVector`, descending. Throws a
- * {@link ValidationError} when the candidate count exceeds `maxCandidates`
- * (steer large corpora to an external VectorBackend).
- *
- * A stored embedding whose length differs from the query vector's cannot be
- * scored — it was written by a different embeddings model — and is ranked
- * last with an undefined score. `onDimensionMismatch` is invoked once with
- * how many candidates that affected, so the caller can say so instead of
- * silently returning a ranking that quietly omits them.
- */
-function rankInMemory(candidates, queryVector, maxCandidates, onDimensionMismatch) {
-    if (candidates.length > maxCandidates) {
-        throw new errors_1.ValidationError(`Semantic search candidate set (${candidates.length}) exceeds maxSearchCandidates ` +
-            `(${maxCandidates}); use a dedicated VectorBackend for large corpora`, 'maxSearchCandidates');
-    }
-    const mismatched = candidates.filter(({ embedding }) => embedding !== undefined && embedding.length !== queryVector.length).length;
-    if (mismatched > 0)
-        onDimensionMismatch?.(mismatched);
-    return candidates
-        .map(({ item, embedding }) => ({
-        ...item,
-        score: embedding && embedding.length === queryVector.length
-            ? (0, semantic_search_1.cosineSimilarity)(queryVector, embedding)
-            : undefined,
-    }))
-        .sort((a, b) => rankValue(b) - rankValue(a));
-}
-/** Sort weight: real cosine score, or a value below the cosine minimum for unscored items. */
-function rankValue(item) {
-    return item.score ?? UNSCORED_RANK;
-}

package/dist/store/internal/read-existing.d.ts

@@ -1,23 +0,0 @@
-import type { DescriptorRef } from '../../shared/codec/descriptor-keys';
-import type { DocItem } from '../../shared/dynamodb/types';
-import type { StoreContext } from './setup';
-/** The previous row's createdAt, payload descriptor and revision. */
-export interface ExistingRecordMeta {
-    exists: boolean;
-    createdAt?: string;
-    value?: DescriptorRef;
-    revision?: string;
-}
-/**
- * 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.
- *
- * Lives apart from `actions/put.ts` so `persist.ts` can re-read on a lost swap
- * without importing its own caller.
- */
-export declare function readExisting(context: StoreContext, pk: string, sk: string): Promise<ExistingRecordMeta>;
-/** Project a raw row (a read result, or the row a rejection carried) onto {@link ExistingRecordMeta}. */
-export declare function existingFrom(item: DocItem | undefined): ExistingRecordMeta;

package/dist/store/internal/read-existing.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readExisting = readExisting;
-exports.existingFrom = existingFrom;
-const conditional_put_1 = require("../../shared/dynamodb/conditional-put");
-const retry_1 = require("../../shared/dynamodb/retry");
-/**
- * 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.
- *
- * Lives apart from `actions/put.ts` so `persist.ts` can re-read on a lost swap
- * without importing its own caller.
- */
-async function readExisting(context, pk, sk) {
-    const existing = await (0, retry_1.withDynamoDBRetry)(() => context.client.get({
-        TableName: context.tableName,
-        Key: { PK: pk, SK: sk },
-        ConsistentRead: true,
-        ProjectionExpression: '#c, #r, #v.#loc, #v.#s3k',
-        ExpressionAttributeNames: {
-            '#c': 'createdAt',
-            '#r': conditional_put_1.REVISION_ATTRIBUTE,
-            '#v': 'value',
-            '#loc': 'location',
-            '#s3k': 's3Key',
-        },
-    }), context.retry);
-    return existingFrom(existing.Item);
-}
-/** Project a raw row (a read result, or the row a rejection carried) onto {@link ExistingRecordMeta}. */
-function existingFrom(item) {
-    return {
-        exists: item !== undefined,
-        createdAt: item?.createdAt,
-        value: item?.value,
-        revision: item?.[conditional_put_1.REVISION_ATTRIBUTE],
-    };
-}

package/dist/store/internal/score-direction.d.ts

@@ -1,31 +0,0 @@
-import type { VectorMatch } from '../vector-backend';
-/** Which direction a {@link VectorBackend} reports its score in. */
-export type VectorScoreDirection = 'relevance' | 'distance';
-/** Every direction {@link toRelevanceScores} recognises, for validating input. */
-export declare const VECTOR_SCORE_DIRECTIONS: readonly VectorScoreDirection[];
-/**
- * Normalise a backend's matches to the relevance direction upstream
- * `SearchItem.score` documents — "higher scores indicate better matches",
- * typically a cosine similarity between -1 and 1.
- *
- * A distance is converted by **negation** rather than `1 / (1 + d)`: negation
- * is monotone over the whole real line, needs no non-negativity precondition,
- * and is exactly invertible, so the original distance is simply `-score`. A
- * reciprocal would silently imply a different `(0, 1]` scale and is undefined
- * at `d === -1`. Negative scores are already in range for this contract, so
- * nothing is lost by producing them.
- *
- * Results are re-sorted after conversion so a backend that returns its matches
- * in some other order still ranks correctly. Anything that is not `'distance'`
- * is returned untouched — its own order stays authoritative, exactly as before.
- *
- * The test is for `'distance'` rather than against `'relevance'` on purpose:
- * converting is the destructive branch, so only the exact value that asks for
- * it may reach it. Testing the other way round made every unrecognised
- * string — `'Distance'`, a typo, a value read from a config file — reverse the
- * ranking silently, with no error and no warning (the ascending-score warning
- * lives downstream of this conversion, so it could never fire). `setUpStore`
- * rejects such a value outright; this keeps the failure harmless for any
- * caller that reaches the function some other way.
- */
-export declare function toRelevanceScores(matches: VectorMatch[], direction: VectorScoreDirection): VectorMatch[];

package/dist/store/internal/score-direction.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VECTOR_SCORE_DIRECTIONS = void 0;
-exports.toRelevanceScores = toRelevanceScores;
-/** Every direction {@link toRelevanceScores} recognises, for validating input. */
-exports.VECTOR_SCORE_DIRECTIONS = ['relevance', 'distance'];
-/**
- * Normalise a backend's matches to the relevance direction upstream
- * `SearchItem.score` documents — "higher scores indicate better matches",
- * typically a cosine similarity between -1 and 1.
- *
- * A distance is converted by **negation** rather than `1 / (1 + d)`: negation
- * is monotone over the whole real line, needs no non-negativity precondition,
- * and is exactly invertible, so the original distance is simply `-score`. A
- * reciprocal would silently imply a different `(0, 1]` scale and is undefined
- * at `d === -1`. Negative scores are already in range for this contract, so
- * nothing is lost by producing them.
- *
- * Results are re-sorted after conversion so a backend that returns its matches
- * in some other order still ranks correctly. Anything that is not `'distance'`
- * is returned untouched — its own order stays authoritative, exactly as before.
- *
- * The test is for `'distance'` rather than against `'relevance'` on purpose:
- * converting is the destructive branch, so only the exact value that asks for
- * it may reach it. Testing the other way round made every unrecognised
- * string — `'Distance'`, a typo, a value read from a config file — reverse the
- * ranking silently, with no error and no warning (the ascending-score warning
- * lives downstream of this conversion, so it could never fire). `setUpStore`
- * rejects such a value outright; this keeps the failure harmless for any
- * caller that reaches the function some other way.
- */
-function toRelevanceScores(matches, direction) {
-    if (direction !== 'distance')
-        return matches;
-    return matches
-        .map((match) => ({ ...match, score: -match.score }))
-        .sort((left, right) => right.score - left.score);
-}

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

@@ -1,3 +0,0 @@
-import type { Item, SearchOperation } from '@langchain/langgraph-checkpoint';
-/** True when `item` satisfies the search operation's optional metadata filter. */
-export declare function passesFilter(item: Item, op: SearchOperation): boolean;

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

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.passesFilter = passesFilter;
-const filter_1 = require("./filter");
-/** True when `item` satisfies the search operation's optional metadata filter. */
-function passesFilter(item, op) {
-    if (!op.filter)
-        return true;
-    return (0, filter_1.matchesStoreFilter)(item.value, op.filter);
-}

package/dist/store/internal/text-path.d.ts

@@ -1,17 +0,0 @@
-import type { JsonValue } from './filter';
-/**
- * Split a JSON path into tokens the way LangGraph's `InMemoryStore` does: dots
- * separate plain segments, while a `[…]` index and a `{…}` field group each
- * become a token of their own (`tags[0]` → `['tags', '[0]']`).
- */
-export declare function tokenizePath(path: string): string[];
-/**
- * Extract the indexable text of `value` at `path`, byte-for-byte as LangGraph's
- * `InMemoryStore` does (`store/utils`), so an embedding computed here matches
- * one computed by the reference store for the same document. Supports plain
- * paths, `[n]`/`[-n]`/`[*]` indexing, a bare `*` wildcard, `{a,b.c}` field
- * groups and `$` for the whole document. The package root's `getTextAtPath` is
- * a string-only variant that returns nothing for numbers, booleans, objects
- * and arrays and throws on a `null` intermediate; it must not be used here.
- */
-export declare function getTextAtPath(value: JsonValue, path: string): string[];

package/dist/store/internal/text-path.js

@@ -1,147 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tokenizePath = tokenizePath;
-exports.getTextAtPath = getTextAtPath;
-/** Pretty JSON, exactly as `InMemoryStore` embeds non-scalar values. */
-function pretty(value) {
-    return JSON.stringify(value, null, 2);
-}
-function isScalar(value) {
-    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
-}
-/** Text for a leaf: scalars stringify, containers pretty-print, null yields nothing. */
-function leafText(value) {
-    if (isScalar(value))
-        return [String(value)];
-    if (value === null)
-        return [];
-    return [pretty(value)];
-}
-/** Index just past the closer matching an opener at `start - 1`, honouring nesting. */
-function scanGroup(path, start, open, close) {
-    let depth = 1;
-    let i = start;
-    while (i < path.length && depth > 0) {
-        if (path[i] === open)
-            depth += 1;
-        else if (path[i] === close)
-            depth -= 1;
-        i += 1;
-    }
-    return i;
-}
-/**
- * Split a JSON path into tokens the way LangGraph's `InMemoryStore` does: dots
- * separate plain segments, while a `[…]` index and a `{…}` field group each
- * become a token of their own (`tags[0]` → `['tags', '[0]']`).
- */
-function tokenizePath(path) {
-    const tokens = [];
-    let current = '';
-    const flush = () => {
-        if (current.length > 0)
-            tokens.push(current);
-        current = '';
-    };
-    let i = 0;
-    while (i < path.length) {
-        const char = path[i];
-        if (char === '[' || char === '{') {
-            flush();
-            const end = scanGroup(path, i + 1, char, char === '[' ? ']' : '}');
-            tokens.push(path.slice(i, end));
-            i = end;
-            continue;
-        }
-        if (char === '.')
-            flush();
-        else
-            current += char;
-        i += 1;
-    }
-    flush();
-    return tokens;
-}
-/** Walk one `{…}`-group field by plain `in` lookups, as the reference does. */
-function groupFieldText(value, field) {
-    let current = value;
-    for (const token of tokenizePath(field)) {
-        if (current !== null && typeof current === 'object' && token in current) {
-            current = current[token];
-        }
-        else {
-            return [];
-        }
-    }
-    return isScalar(current) ? [String(current)] : [pretty(current)];
-}
-/** Resolve a `[n]`, `[-n]` or `[*]` token against an array; anything else yields nothing. */
-function indexText(value, token, tokens, pos) {
-    if (!Array.isArray(value))
-        return [];
-    const index = token.slice(1, -1);
-    if (index === '*')
-        return value.flatMap((item) => extract(item, tokens, pos + 1));
-    let idx = Number.parseInt(index, 10);
-    if (Number.isNaN(idx))
-        return [];
-    if (idx < 0)
-        idx = value.length + idx;
-    return idx >= 0 && idx < value.length ? extract(value[idx], tokens, pos + 1) : [];
-}
-/** Resolve a `{a,b.c}` token: each listed field, walked from the current value. */
-function groupText(value, token) {
-    if (typeof value !== 'object' || value === null)
-        return [];
-    const results = [];
-    for (const field of token.slice(1, -1).split(',')) {
-        const trimmed = field.trim();
-        if (tokenizePath(trimmed).length > 0)
-            results.push(...groupFieldText(value, trimmed));
-    }
-    return results;
-}
-/** Resolve a bare `*` token: every array item or every object value. */
-function wildcardText(value, tokens, pos) {
-    if (Array.isArray(value))
-        return value.flatMap((item) => extract(item, tokens, pos + 1));
-    if (typeof value === 'object' && value !== null) {
-        return Object.values(value).flatMap((item) => extract(item, tokens, pos + 1));
-    }
-    return [];
-}
-/** Resolve a plain member token by an `in` lookup, exactly as the reference does. */
-function memberText(value, token, tokens, pos) {
-    if (typeof value !== 'object' || value === null || !(token in value))
-        return [];
-    return extract(value[token], tokens, pos + 1);
-}
-function extract(value, tokens, pos) {
-    if (pos >= tokens.length)
-        return leafText(value);
-    const token = tokens[pos];
-    if (token.startsWith('[') && token.endsWith(']'))
-        return indexText(value, token, tokens, pos);
-    const results = pos === 0 && token === '$' ? [pretty(value)] : [];
-    if (token.startsWith('{') && token.endsWith('}'))
-        results.push(...groupText(value, token));
-    else if (token === '*')
-        results.push(...wildcardText(value, tokens, pos));
-    else
-        results.push(...memberText(value, token, tokens, pos));
-    return results;
-}
-/**
- * Extract the indexable text of `value` at `path`, byte-for-byte as LangGraph's
- * `InMemoryStore` does (`store/utils`), so an embedding computed here matches
- * one computed by the reference store for the same document. Supports plain
- * paths, `[n]`/`[-n]`/`[*]` indexing, a bare `*` wildcard, `{a,b.c}` field
- * groups and `$` for the whole document. The package root's `getTextAtPath` is
- * a string-only variant that returns nothing for numbers, booleans, objects
- * and arrays and throws on a `null` intermediate; it must not be used here.
- */
-function getTextAtPath(value, path) {
-    if (path === '' || path === '$')
-        return [pretty(value)];
-    return extract(value, tokenizePath(path), 0);
-}

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

@@ -1,18 +0,0 @@
-/** Validate search/listNamespaces paging is non-negative integers. */
-export declare function validatePaging(offset: number, limit: number): void;
-/** Validate the namespace is non-empty and each element is a valid, ≤256-byte identifier. */
-export declare function validateNamespace(namespace: string[]): void;
-/** Validate an item key is a non-blank, separator- and control-char-free, ≤256-byte string. */
-export declare function validateKey(key: string): void;
-/**
- * Validate a namespace/key pair as the item address it becomes: each segment
- * on its own, then the sort key they compose, which DynamoDB caps at 1024
- * bytes regardless of how short the individual segments are.
- */
-export declare function validateStoreKey(namespace: string[], key: string): void;
-/**
- * Validate an optional namespace depth cap. Left unchecked, a negative value
- * silently inverted truncation via `Array.prototype.slice(0, -n)`, which drops
- * the *last* n elements rather than erroring.
- */
-export declare function validateMaxDepth(maxDepth?: number): void;