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

package/dist/shared/validation/ttl.js

@@ -1,132 +0,0 @@
-"use strict";
-/**
- * Hides how a `ttl` option becomes an expiry.
- *
- * A caller gives days or seconds. The one-unit rule, the five-year cap, the
- * epoch second DynamoDB's TTL attribute takes, and the S3 lifecycle days that
- * keep an offloaded object alive past its row's sweep lag are all derived
- * here, so the two spellings of the `ttl` option are accepted or rejected
- * alike and no reader re-derives one unit from the other itself. A stored
- * row's own epoch-second `ttl` is converted to milliseconds for `Date` where
- * that row is read, not here.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3_LIFECYCLE_SWEEP_MARGIN_DAYS = exports.MAX_TTL_SECONDS = exports.MAX_TTL_DAYS = void 0;
-exports.resolveTtlSeconds = resolveTtlSeconds;
-exports.calculateTtlTimestamp = calculateTtlTimestamp;
-exports.lifecycleExpirationDays = lifecycleExpirationDays;
-const errors_1 = require("../errors/errors");
-const option_shape_1 = require("./option-shape");
-const primitives_1 = require("./primitives");
-const SECONDS_PER_DAY = 24 * 60 * 60;
-/** Maximum TTL expressed in days (5 years). */
-exports.MAX_TTL_DAYS = 365 * 5;
-/** Maximum TTL expressed in seconds: the same five years as {@link MAX_TTL_DAYS}. */
-exports.MAX_TTL_SECONDS = exports.MAX_TTL_DAYS * 24 * 60 * 60;
-/**
- * Extra days an S3 lifecycle rule adds over the TTL it backs. DynamoDB's TTL
- * sweep can lag up to ~48 h past the `ttl` timestamp; the offloaded object
- * must outlive its row, never the other way round.
- */
-exports.S3_LIFECYCLE_SWEEP_MARGIN_DAYS = 2;
-/**
- * The units {@link TtlOption} declares. `allKeysOf<TtlOption>` cannot check
- * this list: over a union its parameter is itself a union of one key map per
- * shape, so `{ days: 'days' }` alone satisfies the first shape and compiles.
- * Listing the keys of every shape as one record restores the check, so leaving
- * a unit out, inventing one, or adding a shape to the union without listing
- * its unit here fails to compile.
- */
-const TTL_KEYS = (0, option_shape_1.allKeysOf)({
-    days: 'days',
-    seconds: 'seconds',
-});
-/** Positive integer no greater than `max`, with a message that names what the cap means. */
-function assertWithinCap(value, field, max) {
-    (0, primitives_1.assertInteger)(value, field, { min: 1 });
-    if (value > max) {
-        throw (0, errors_1.validationError)(`${field} must be <= ${max} (five years)`, field);
-    }
-}
-/**
- * Reject a `ttl` that is not an object at all, carries a key other than a
- * unit, or names neither unit or both. The stray key is checked before the
- * units, so `{ day: 1 }` names the key the caller wrote rather than a unit it
- * did not.
- */
-function assertOneUnit(ttl) {
-    if (typeof ttl !== 'object' || ttl === null) {
-        throw (0, errors_1.validationError)('ttl must be an object: { days } or { seconds }', 'ttl');
-    }
-    (0, option_shape_1.assertShape)(ttl, TTL_KEYS, 'ttl');
-    const days = 'days' in ttl;
-    const seconds = 'seconds' in ttl;
-    if (days && seconds) {
-        throw (0, errors_1.validationError)('ttl must specify either ttl.days or ttl.seconds, not both', 'ttl');
-    }
-    if (!days && !seconds) {
-        throw (0, errors_1.validationError)('ttl must specify either ttl.days or ttl.seconds', 'ttl');
-    }
-}
-/**
- * A {@link TtlOption} resolved to a positive number of seconds.
- *
- * Accepts: `ttl` — declared as the two-shape union; a JavaScript caller, or a
- * config built from JSON, can also reach `undefined`, a non-object, `{}`, an
- * object carrying both keys and one carrying any other key, and each is
- * rejected. Within a shape the value must be an integer of at least 1.
- *
- * Returns: whole seconds, `days × 86400` for the days form.
- *
- * Throws: `VALIDATION`, in this order, naming `ttl` for a value that is not
- * an object, `ttl.<key>` for a key other than `days` or `seconds`, `ttl` for
- * an object naming neither unit or both, and `ttl.days` or `ttl.seconds` for a
- * value outside 1..five years. Both forms share that cap, so the two spellings
- * of one duration are accepted or rejected alike.
- */
-function resolveTtlSeconds(ttl) {
-    assertOneUnit(ttl);
-    if ('days' in ttl) {
-        assertWithinCap(ttl.days, 'ttl.days', exports.MAX_TTL_DAYS);
-        return ttl.days * SECONDS_PER_DAY;
-    }
-    assertWithinCap(ttl.seconds, 'ttl.seconds', exports.MAX_TTL_SECONDS);
-    return ttl.seconds;
-}
-/**
- * The value DynamoDB's TTL attribute takes for an item written now: the Unix
- * epoch second at which it expires.
- *
- * Accepts: `ttl` — as {@link resolveTtlSeconds}. `now` — a clock returning
- * epoch **milliseconds**, defaulting to `Date.now`; supplied by tests and by
- * the adapters' clock seam.
- *
- * Returns: `floor(now() / 1000) + resolveTtlSeconds(ttl)`. Whole seconds,
- * because DynamoDB reads the attribute as an epoch-second Number
- * (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/time-to-live-ttl-before-you-start.html).
- *
- * Throws: whatever {@link resolveTtlSeconds} throws.
- */
-function calculateTtlTimestamp(ttl, now = Date.now) {
-    return Math.floor(now() / 1000) + resolveTtlSeconds(ttl);
-}
-/**
- * The `Days` of the S3 lifecycle expiration rule that backs a TTL.
- *
- * Accepts: `ttl` — as {@link resolveTtlSeconds}.
- *
- * Returns: the TTL rounded **up** to whole days plus
- * {@link S3_LIFECYCLE_SWEEP_MARGIN_DAYS}, so always at least
- * `1 + margin`.
- *
- * Throws: whatever {@link resolveTtlSeconds} throws.
- *
- * Guarantees: the object outlives the row that points at it. S3 expires an
- * object at the first midnight UTC at least `Days` after creation, while
- * DynamoDB may keep an expired item for up to 48 hours past its `ttl`
- * (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/howitworks-ttl.html);
- * the margin covers that lag, which a bare `{ days: N }` did not.
- */
-function lifecycleExpirationDays(ttl) {
-    return Math.ceil(resolveTtlSeconds(ttl) / SECONDS_PER_DAY) + exports.S3_LIFECYCLE_SWEEP_MARGIN_DAYS;
-}

package/dist/store/actions/list-namespaces.js

@@ -1,197 +0,0 @@
-"use strict";
-/**
- * Hides how the distinct namespaces are found and held in one order.
- *
- * A listing reads every live row it can reach — one partition when its first
- * prefix condition opens with concrete labels, the whole table otherwise —
- * keeps the namespaces every condition matches, truncates and deduplicates
- * them, and sorts them by one pinned collation with its ties settled. A caller
- * paging by `offset` gets the same order on every call and every host.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchNamespace = matchNamespace;
-exports.truncateDepth = truncateDepth;
-exports.prefixRoot = prefixRoot;
-exports.listNamespaces = listNamespaces;
-const clock_1 = require("../../shared/clock");
-const paginate_1 = require("../../shared/dynamodb/paginate");
-const table_schema_1 = require("../../shared/dynamodb/table-schema");
-const rows_1 = require("../internal/rows");
-const WILDCARD = '*';
-function segmentMatches(actual, path) {
-    return path.every((element, index) => element === WILDCARD || element === actual[index]);
-}
-/**
- * Whether `namespace` satisfies one match condition. `condition.matchType` is
- * `'prefix'` or `'suffix'`, already refused otherwise by the parser that built
- * `condition` (`parseMatchCondition` in `parse.ts`).
- *
- * Accepts: `condition.path` — elements, where `'*'` matches any one element;
- * longer than the namespace never matches, and empty matches every namespace.
- *
- * Returns: whether the condition holds.
- *
- * Throws: nothing.
- */
-function matchNamespace(namespace, condition) {
-    const { matchType, path } = condition;
-    if (path.length > namespace.length)
-        return false;
-    const slice = matchType === 'prefix'
-        ? namespace.slice(0, path.length)
-        : namespace.slice(namespace.length - path.length);
-    return segmentMatches(slice, path);
-}
-/**
- * Cap a namespace to at most `maxDepth` elements.
- *
- * Accepts: `maxDepth` — absent returns the namespace unchanged; otherwise a
- * parsed positive integer (see `parseListOperation` for what a negative or
- * zero value did here).
- *
- * Returns: the namespace, truncated from the end; shorter than `maxDepth` is
- * returned whole.
- *
- * Throws: nothing.
- */
-function truncateDepth(namespace, maxDepth) {
-    return maxDepth === undefined ? namespace : namespace.slice(0, maxDepth);
-}
-/**
- * Leading concrete (non-wildcard) elements of the first prefix condition.
- *
- * Accepts: `conditions` — absent, empty, suffix-only, or a prefix condition
- * starting with `'*'` all yield nothing to scope by.
- *
- * Returns: the concrete leading elements, which name a partition and a sort-key
- * prefix the listing can be read from. An empty result means the listing cannot
- * be scoped to one partition and falls back to a Scan.
- *
- * Throws: nothing.
- *
- * Guarantees: the root is only ever a *superset* of what the conditions select
- * — every condition is still applied to each namespace read — so scoping can
- * never drop a namespace that belongs in the answer.
- */
-function prefixRoot(conditions) {
-    const prefixCondition = conditions?.find((condition) => condition.matchType === 'prefix');
-    if (!prefixCondition)
-        return [];
-    const root = [];
-    for (const element of prefixCondition.path) {
-        if (element === WILDCARD)
-            break;
-        root.push(element);
-    }
-    return root;
-}
-function namespaceSource(context, op, now) {
-    const root = prefixRoot(op.matchConditions);
-    if (root.length > 0) {
-        return (0, paginate_1.paginateQuery)({
-            retry: context.retry,
-            client: context.client,
-            params: (0, table_schema_1.withoutExpired)((0, rows_1.projectKeys)((0, rows_1.scopedQuery)(context.tableName, root)), now),
-            maxItems: context.maxScanItems,
-        });
-    }
-    return (0, paginate_1.paginateScan)({
-        retry: context.retry,
-        client: context.client,
-        params: (0, table_schema_1.withoutExpired)((0, rows_1.projectKeys)((0, rows_1.storeScan)(context.tableName)), now),
-        maxItems: context.maxScanItems,
-    });
-}
-/**
- * The collation namespaces are sorted by, pinned to one locale.
- *
- * `InMemoryStore` sorts with bare `localeCompare`
- * (`@langchain/langgraph-checkpoint@1.1.5` `dist/store/memory.js:119`), which
- * means "in the host's default locale" — and locales disagree: `'ä'` sorts
- * before `'z'` in German and after it in Swedish. A listing paged by `offset`
- * is a position a caller holds between two calls, so an order that changes
- * with the host answering the call cuts the same listing in two places and the
- * caller misses one namespace and sees another twice. Matching the reference
- * there is not possible anyway, because the reference's own order varies with
- * its host; what is possible is matching it on every host that agrees with
- * this locale, and being deterministic on the rest.
- *
- * `en` is the locale to pin because ICU applies no tailoring to it — its order
- * is the untailored root order — and because it is the one locale a Node built
- * with small ICU still carries, so this cannot degrade to a different order on
- * a minimal runtime.
- */
-const NAMESPACE_COLLATOR = new Intl.Collator('en');
-/**
- * Order two namespaces by the reference store's collation, pinned, with its
- * ties settled.
- *
- * The collation is {@link NAMESPACE_COLLATOR} on the joined namespace — the
- * comparison `InMemoryStore` makes, held to one locale. Collation calls some
- * *distinct* strings equal — `'café'` written precomposed and decomposed is
- * one such pair — and the reference then leaves their order to insertion
- * order. Here that would be the order DynamoDB happened to return the rows in,
- * so the same listing could place a page boundary between them differently on
- * two calls and a page could skip one namespace while repeating another. The
- * tie-break settles exactly those pairs and never reorders a pair the
- * collation itself orders.
- */
-function compareNamespaces(a, b) {
-    const left = a.join(table_schema_1.KEY_SEPARATOR);
-    const right = b.join(table_schema_1.KEY_SEPARATOR);
-    const collated = NAMESPACE_COLLATOR.compare(left, right);
-    // `Number(left > right)` keeps the comparator total: 0 for a pair that really is equal.
-    return collated !== 0 ? collated : left < right ? -1 : Number(left > right);
-}
-/**
- * The distinct namespaces satisfying every match condition.
- *
- * Accepts: `op` — parsed; every match condition must hold, absent or empty
- * matches every namespace. A concrete prefix root scopes the read to one
- * partition's Query, and anything else — a suffix condition, a leading `*`, no
- * conditions — spans the table and is one of the four reads allowed to Scan
- * (`test/static/guards/scan-sites.ts`).
- * `op.maxDepth` — namespaces are truncated to it and then
- * deduplicated, so `['a','b']` and `['a','c']` list once as `['a']`.
- * `op.offset` and `op.limit` — a `limit` of 0 returns an empty listing without reading.
- *
- * Returns: the namespaces, sorted, then `limit` of them from `offset`.
- *
- * Throws: `RESULT_TRUNCATED` when `maxScanItems` is reached while rows
- * remain, so a partial listing is never returned as a complete one;
- * `FORMAT_UNSUPPORTED` for a store item a newer release wrote.
- *
- * Guarantees: every live row is read — the answer is about which namespaces
- * exist, and paging over it must not depend on which rows were read first. That
- * is also why the sort is total (see {@link compareNamespaces}), and why a
- * `limit` of 0 is answered ahead of the read rather than by slicing one.
- */
-async function listNamespaces(context, op) {
-    // A zero page is answered before the read. This listing is the one that can
-    // never stop early — every live row must be seen before the namespaces can
-    // be sorted and sliced — so scanning the whole table to slice nothing out of
-    // it is the entire cost for none of the answer.
-    if (op.limit === 0)
-        return [];
-    const now = (0, clock_1.nowSeconds)();
-    const seen = new Set();
-    const namespaces = [];
-    for await (const raw of namespaceSource(context, op, now)) {
-        const record = (0, rows_1.parseStoreRow)(raw);
-        if (!record || (0, table_schema_1.isExpiredRow)(record, now))
-            continue;
-        const namespace = record.namespace;
-        if (op.matchConditions &&
-            !op.matchConditions.every((condition) => matchNamespace(namespace, condition))) {
-            continue;
-        }
-        const truncated = truncateDepth(namespace, op.maxDepth);
-        const dedupeKey = truncated.join(table_schema_1.KEY_SEPARATOR);
-        if (seen.has(dedupeKey))
-            continue;
-        seen.add(dedupeKey);
-        namespaces.push(truncated);
-    }
-    namespaces.sort(compareNamespaces);
-    return namespaces.slice(op.offset, op.offset + op.limit);
-}

package/dist/store/actions/put.js

@@ -1,78 +0,0 @@
-"use strict";
-/**
- * Hides the order a put happens in.
- *
- * A put reads the row it replaces for its `createdAt`, embeds once — a vector
- * per extracted path onto the row, or one vector for the `vectorBackend`,
- * never both — writes the row, and only then syncs the backend, best-effort.
- * A `null` value takes the delete path instead. A caller hands over an item;
- * that the table commits first and the vector copy follows is decided here.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.putItem = putItem;
-const node_crypto_1 = require("node:crypto");
-const clock_1 = require("../../shared/clock");
-const ttl_1 = require("../../shared/validation/ttl");
-const item_write_1 = require("../internal/item-write");
-const rows_1 = require("../internal/rows");
-const semantic_search_1 = require("../internal/semantic-search");
-const vector_index_1 = require("../internal/vector-index");
-/**
- * The vectors a put stores on the row: one per extracted path, scored by best
- * match on read. Not computed when a `vectorBackend` holds the vectors, which
- * takes a single vector per item instead (see {@link itemVector}).
- */
-async function resolvePassages(context, op, value) {
-    if (op.index === false)
-        return undefined;
-    return (0, semantic_search_1.embedPassages)(context, value, op.index);
-}
-/**
- * Store, update or delete an item.
- *
- * Accepts: `op` — parsed; a `ParsedDelete` removes the item, a `ParsedPut` is
- * stored, its value encoded with optional compression and S3 offload under
- * this row's own path, in an object named by this put's own id. `op.index` —
- * `false` stores the item without indexing it and clears any vector it had, an
- * array overrides the configured fields for this put, and absent uses the
- * store's configuration.
- *
- * Returns: nothing. Deleting an item that is not there is not an error.
- *
- * Throws: `VALIDATION` naming `value` for a value that JSON cannot represent —
- * refused at the write rather than stored as a row that can never be read back;
- * `S3_OFFLOAD_FAILED`; whatever the write throws.
- *
- * Guarantees: DynamoDB holds the canonical item — the vector index is synced
- * afterwards and best-effort, so a backend outage never fails a put or leaves a
- * half-written item. `createdAt` survives every update. The superseded payload
- * is deleted only once the new row is committed, and this put's own upload
- * only once a read proves its write did not land. Neither release reads the
- * row first: each put uploads under a key ending in an id of its own, so the
- * object a put uploads is named only by that put's own rows.
- */
-async function putItem(context, op) {
-    if (op.kind === 'delete') {
-        await (0, item_write_1.deleteStoreItem)(context, op.address);
-        return;
-    }
-    const { namespace, key } = op.address;
-    const value = op.value;
-    const timestamp = (0, clock_1.nowIso)();
-    const existing = await (0, rows_1.readExisting)(context, (0, rows_1.itemRowKey)(op.address));
-    // The two indexing modes are exclusive, so only one of them embeds: the row
-    // carries a vector per extracted path, while a configured backend takes one
-    // vector per item because that is what its `upsert` contract addresses.
-    const embedding = await (0, vector_index_1.itemVector)(context, op);
-    const embeddings = context.vectorBackend ? undefined : await resolvePassages(context, op, value);
-    const ttlTimestamp = context.ttl ? (0, ttl_1.calculateTtlTimestamp)(context.ttl) : undefined;
-    const record = await (0, rows_1.buildStoreRow)(context, { namespace, key }, value, {
-        createdAt: existing.createdAt ?? timestamp,
-        updatedAt: timestamp,
-        embeddings,
-        ttlTimestamp,
-        rev: (0, node_crypto_1.randomUUID)(),
-    });
-    await (0, item_write_1.persistRow)(context, record, existing);
-    await (0, vector_index_1.syncItemVector)(context, op.address, embedding);
-}

package/dist/store/actions/search.js

@@ -1,66 +0,0 @@
-"use strict";
-/**
- * Hides which of three paths serves a search.
- *
- * A query with a `vectorBackend` is answered by the backend; no query, or no
- * `index` to embed one with, is a page read from the table that stops once
- * full; anything else is ranked in memory over at most `maxSearchCandidates`.
- * A page of zero is answered before any of them. A caller gets the same shape
- * of page whichever path ran, scored exactly when a query could be ranked.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.searchItems = searchItems;
-const truncate_1 = require("../../shared/logging/truncate");
-const semantic_search_1 = require("../internal/semantic-search");
-const table_search_1 = require("../internal/table-search");
-const vector_index_1 = require("../internal/vector-index");
-/**
- * Search items under a namespace prefix: metadata filtering plus optional
- * semantic ranking.
- *
- * Accepts: `search` — already parsed, so `namespacePrefix`, `offset` and
- * `limit` are resolved; `search.query` absent or empty
- * (which is absent: there is no query to embed) ranks nothing and returns the
- * page as read, which is what the reference store does
- * (`@langchain/langgraph-checkpoint@1.1.5` `dist/store/memory.js:70-80`, where a
- * falsy query takes the unscored path). A query without a configured `index`
- * does the same, since there is nothing to embed it with.
- *
- * Returns: at most `limit` items from `offset`. With a query and an index every
- * item carries a `score`; without one none does. Scores rank best-first; an item
- * that cannot be scored ranks last rather than being dropped.
- *
- * Throws: `VALIDATION` naming `maxSearchCandidates` or `index.dims`; whatever
- * the reads, decodes and the embeddings model throw.
- *
- * Guarantees: a page of zero costs no request at all, and otherwise only the
- * page's own items are decoded on the unranked path — the
- * read stops as soon as it is full. A semantic search must read every candidate
- * to rank it, which is why it is capped and why a large corpus belongs in a
- * `vectorBackend`.
- */
-async function searchItems(context, search, signal) {
-    const { offset, limit } = search;
-    // A zero page is answered here, ahead of all three paths below, because each
-    // of them pays for it: `collectCandidates` pulls the first row out of the
-    // paginator before it tests its `offset + limit` bound, so even a page that
-    // needs nothing costs one Query or Scan, and the two ranked paths embed the
-    // query as well. Slicing the result to nothing afterwards hid the cost
-    // rather than avoiding it.
-    if (limit === 0)
-        return [];
-    if (search.query && (0, vector_index_1.hasVectorBackend)(context)) {
-        const ranked = await (0, vector_index_1.searchViaBackend)(context, search, signal);
-        return ranked.slice(offset, offset + limit);
-    }
-    if (!search.query || !context.index) {
-        const page = await (0, table_search_1.collectCandidates)(context, search, { kind: 'page', need: offset + limit }, signal);
-        return page.map(({ item }) => ({ ...item })).slice(offset, offset + limit);
-    }
-    const candidates = await (0, table_search_1.collectCandidates)(context, search, { kind: 'semantic', cap: context.maxSearchCandidates }, signal);
-    const queryVector = await context.index.embeddings.embedQuery(search.query);
-    (0, semantic_search_1.assertVectorDims)(context.index, queryVector, 'query');
-    const ranked = (0, table_search_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: (0, truncate_1.truncateLabelsForLog)(search.namespacePrefix), count }));
-    return ranked.slice(offset, offset + limit);
-}

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

@@ -1,26 +0,0 @@
-/**
- * Hides how a batch runs concurrently and still in the order it was written.
- *
- * Operations on different items, and reads of the same item, share a run and
- * go in flight together; anything that could observe or overwrite an earlier
- * operation's effect starts the next run. A caller sees the order it wrote —
- * a `get` after a `put` of the same item sees it, a `search` sees every write
- * before it — and how independence is judged can change without the store.
- */
-import type { ParsedOperation } from './parse';
-/**
- * Run a batch: each run of independent operations concurrently, at most
- * `limit` in flight, and the runs themselves in
- * order. Results come back in operation order.
- *
- * Accepts: `operations` — in caller order, which is the order they are
- * observed in; empty returns empty. `limit` — operations in flight within one
- * run.
- *
- * Returns: the results in operation order, not completion order.
- *
- * Throws: the first failure. Any failure rejects the whole batch: no operation
- * in a later run starts, the ones already in flight settle, and that first
- * error is the one thrown.
- */
-export declare function runBatch<R>(operations: readonly ParsedOperation[], dispatch: (operation: ParsedOperation) => Promise<R>, limit?: number): Promise<R[]>;

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

@@ -1,109 +0,0 @@
-"use strict";
-/**
- * Hides how a batch runs concurrently and still in the order it was written.
- *
- * Operations on different items, and reads of the same item, share a run and
- * go in flight together; anything that could observe or overwrite an earlier
- * operation's effect starts the next run. A caller sees the order it wrote —
- * a `get` after a `put` of the same item sees it, a `search` sees every write
- * before it — and how independence is judged can change without the store.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runBatch = runBatch;
-const concurrency_1 = require("../../shared/concurrency");
-function itemOf(address) {
-    return JSON.stringify([address.namespace, address.key]);
-}
-/** What `op` touches, decided by the kind the parser already assigned — the only place that asks. */
-function touchOf(op) {
-    switch (op.kind) {
-        case 'put':
-        case 'delete':
-            return { kind: 'write', item: itemOf(op.address) };
-        case 'get':
-            return { kind: 'get', item: itemOf(op.address) };
-        default:
-            return { kind: 'broad' };
-    }
-}
-/**
- * True when `touch` may not join `segment` — because some operation already in
- * it addresses the same item, or because a write and a whole-store read would
- * then be unordered with respect to each other.
- */
-function conflicts(segment, touch) {
-    if (touch.kind === 'broad')
-        return segment.hasWrite;
-    if (touch.kind === 'get')
-        return segment.written.has(touch.item);
-    return segment.written.has(touch.item) || segment.read.has(touch.item) || segment.hasBroad;
-}
-function admit(segment, index, touch) {
-    segment.indices.push(index);
-    if (touch.kind === 'broad')
-        segment.hasBroad = true;
-    if (touch.kind === 'get')
-        segment.read.add(touch.item);
-    if (touch.kind === 'write') {
-        segment.written.add(touch.item);
-        segment.hasWrite = true;
-    }
-}
-function emptySegment() {
-    return { indices: [], written: new Set(), read: new Set(), hasWrite: false, hasBroad: false };
-}
-/**
- * Split a batch into runs of mutually independent operations, in caller order.
- *
- * Operations that address different items, and reads that address the same
- * item, are independent of each other and share a run. Anything that could
- * observe or overwrite an earlier operation's effect starts a new one, so the
- * order the caller wrote is the order the caller observes: a `get` after a
- * `put` of the same item sees it, a `get` before one does not, and a `search`
- * sees every write that precedes it and none that follow.
- *
- * Running every write before every read — the earlier behaviour — made a
- * `[delete, get]` batch return nothing where the reference store returns the
- * value, and a `[get, put]` batch return the new value where the reference
- * returns null. `AsyncBatchedStore` coalesces everything enqueued in one tick
- * into a single `batch()`, so that difference is reachable from ordinary code.
- */
-function planBatch(operations) {
-    const runs = [];
-    let segment = emptySegment();
-    operations.forEach((op, index) => {
-        const touch = touchOf(op);
-        if (segment.indices.length > 0 && conflicts(segment, touch)) {
-            runs.push(segment.indices);
-            segment = emptySegment();
-        }
-        admit(segment, index, touch);
-    });
-    if (segment.indices.length > 0)
-        runs.push(segment.indices);
-    return runs;
-}
-/**
- * Run a batch: each run of independent operations concurrently, at most
- * `limit` in flight, and the runs themselves in
- * order. Results come back in operation order.
- *
- * Accepts: `operations` — in caller order, which is the order they are
- * observed in; empty returns empty. `limit` — operations in flight within one
- * run.
- *
- * Returns: the results in operation order, not completion order.
- *
- * Throws: the first failure. Any failure rejects the whole batch: no operation
- * in a later run starts, the ones already in flight settle, and that first
- * error is the one thrown.
- */
-async function runBatch(operations, dispatch, limit = concurrency_1.DEFAULT_READ_CONCURRENCY) {
-    const results = [];
-    for (const run of planBatch(operations)) {
-        await (0, concurrency_1.mapWithConcurrency)(run, limit, async (index) => {
-            results[index] = await dispatch(operations[index]);
-        });
-    }
-    return results;
-}