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

package/dist/checkpointer/internal/setup.js

@@ -1,72 +0,0 @@
-"use strict";
-/**
- * Hides which options the saver and its methods accept, and how the saver is
- * assembled from them.
- *
- * The exhaustive key list of every option bag — the constructor's, `list`'s,
- * `getDeltaChannelHistory`'s — lives here, compiler-checked against its type,
- * beside the code that resolves the constructor's options into the context
- * every action receives.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DELTA_CHANNEL_HISTORY_KEYS = exports.SAVER_LIST_KEYS = exports.SAVER_KEYS = void 0;
-exports.setUpCheckpointer = setUpCheckpointer;
-const adapter_1 = require("../../shared/adapter");
-const option_shape_1 = require("../../shared/validation/option-shape");
-/**
- * The keys of each checkpointer option bag, exhaustive in both directions:
- * `allKeysOf<T>` makes omitting or inventing one a compile error, so a list
- * cannot rot away from the type it guards. They live with the feature because
- * the types they are checked against do; `shared/` knows no feature.
- */
-exports.SAVER_KEYS = (0, option_shape_1.allKeysOf)({
-    tableName: 'tableName',
-    client: 'client',
-    clientConfig: 'clientConfig',
-    createClient: 'createClient',
-    ttl: 'ttl',
-    logger: 'logger',
-    retry: 'retry',
-    indexShards: 'indexShards',
-    indexName: 'indexName',
-    readConcurrency: 'readConcurrency',
-    compression: 'compression',
-    s3: 's3',
-    serde: 'serde',
-});
-/** See {@link SAVER_KEYS}. */
-exports.SAVER_LIST_KEYS = (0, option_shape_1.allKeysOf)({
-    limit: 'limit',
-    before: 'before',
-    filter: 'filter',
-});
-/**
- * See {@link SAVER_KEYS}. `DeltaChannelHistoryOptions` is pinned equal to
- * `BaseCheckpointSaver.getDeltaChannelHistory`'s own parameter type, the
- * contract that method implements, so this list is checked against it.
- */
-exports.DELTA_CHANNEL_HISTORY_KEYS = (0, option_shape_1.allKeysOf)({
-    config: 'config',
-    channels: 'channels',
-});
-/**
- * Check the options, then resolve the client, offloader and serializer.
- *
- * Accepts: `options` — already held to the saver's key list by its constructor,
- * which must read `serde` before anything else runs; checked here before
- * anything is built, so no half-built saver exists when one is wrong. `serde` —
- * the serializer the base class resolved, which is the caller's own serializer
- * when they gave one.
- *
- * Returns: the context every action receives, and the shell that releases what
- * it holds — a client the caller passed in is never destroyed by `destroy()`.
- *
- * Throws: `VALIDATION` for an option or collaborator that fails a check,
- * naming the offending option.
- *
- * Guarantees: constructing a saver performs no I/O.
- */
-function setUpCheckpointer(options, serde) {
-    const shell = (0, adapter_1.openAdapter)(options, 'checkpointer');
-    return { shell, context: { ...shell.core, serde } };
-}

package/dist/checkpointer/types.js

@@ -1,12 +0,0 @@
-"use strict";
-/**
- * Hides the saver's own modules from the shapes a caller types against.
- *
- * The saver's options and the options its delta-channel walk accepts are
- * declared here, apart from the saver and its actions, so a caller can type
- * what it builds without importing either. The narrowed `configurable` is
- * declared beside them for the parser that reads it, not for a caller. The
- * delta-channel options are pinned equal to upstream's inline parameter
- * type, so they change only when LangGraph's do.
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/factory/factory.js

@@ -1,266 +0,0 @@
-"use strict";
-/**
- * Hides how several adapters share one client and one set of defaults.
- *
- * A caller states its defaults once; which adapter gets the base client
- * choice and which its own, how the DynamoDB region reaches a shared `s3`
- * config, and who destroys a client the factory built rather than was handed
- * are decided here. Teardown is total — one adapter failing to release cannot
- * strand the others — and a `createAll` that fails partway releases what it
- * had built before its own error propagates.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamoDBFactory = void 0;
-const saver_1 = require("../checkpointer/saver");
-const chat_message_history_1 = require("../history/chat-message-history");
-const client_types_1 = require("../shared/codec/s3/client-types");
-const client_1 = require("../shared/dynamodb/client");
-const base_error_1 = require("../shared/errors/base-error");
-const logger_1 = require("../shared/logging/logger");
-const truncate_1 = require("../shared/logging/truncate");
-const collaborators_1 = require("../shared/validation/collaborators");
-const option_shape_1 = require("../shared/validation/option-shape");
-const options_1 = require("../shared/validation/options");
-const store_1 = require("../store/store");
-/** The factory's own options, checked against {@link FactoryBaseOptions} at compile time. */
-const FACTORY_BASE_KEYS = (0, option_shape_1.allKeysOf)({
-    client: 'client',
-    clientConfig: 'clientConfig',
-    createClient: 'createClient',
-    logger: 'logger',
-    ttl: 'ttl',
-    compression: 'compression',
-    s3: 's3',
-    retry: 'retry',
-});
-/** The sections `createAll` builds, checked against {@link CreateAllOptions} at compile time. */
-const CREATE_ALL_KEYS = (0, option_shape_1.allKeysOf)({
-    saver: 'saver',
-    store: 'store',
-    history: 'history',
-});
-/**
- * Release one resource without letting its failure strand the others.
- *
- * Teardown runs in two places that must both finish: the caller's `destroy`,
- * where a throw halfway through would leak every resource after it, and the
- * rollback of a failed {@link DynamoDBFactory.createAll}, where it would also
- * replace the constructor error the caller needs with its own.
- */
-function release(logger, close) {
-    try {
-        close();
-    }
-    catch (error) {
-        // The name, never the message — and bounded, because a name is a string an
-        // adapter's own `close` threw and nothing this package ran checked its
-        // length. `message` is bounded at `redactedMessage`, and relaying the two
-        // halves of "what the failure was" under different rules is the split that
-        // rule exists to remove.
-        logger.warn('factory.destroy: an adapter did not release its resources', {
-            reason: (0, truncate_1.truncateForLog)((0, base_error_1.failureLabel)(error)),
-        });
-    }
-}
-function overridesClient(options) {
-    return (options.client !== undefined ||
-        options.clientConfig !== undefined ||
-        options.createClient !== undefined);
-}
-/**
- * Convenience constructors for the adapters.
- *
- * Individual `create*` methods each build their own client; {@link createAll}
- * builds one shared client used by all three and returns a combined `destroy`
- * that tears everything down once. Each adapter validates the options it ends
- * up with, so the same mistake is caught the same way however the adapter was
- * built. The factory checks only what it reads itself before an adapter can:
- * its own base options, client choice and logger, the keys of `createAll`'s
- * argument, and that each adapter's options are an object at all.
- *
- * Every `create*` argument and every `createAll` section is one adapter's
- * options, and a mistake in one is named the way that adapter's constructor
- * names it: `options` for a value that is not an object, and the adapter's own
- * field names (`options.<key>`, `tableName`, …) for anything inside one.
- */
-class DynamoDBFactory {
-    base;
-    /**
-     * Accepts: `base` — the defaults every adapter inherits. Checked here, where
-     * the caller wrote them: an unknown key would otherwise be ignored, and a
-     * `client` next to a `clientConfig` was refused by the first `create*` call
-     * and accepted by `createAll`, for the same base. So is the shape of
-     * `clientConfig`: `createAll` hands its adapters the client built from it,
-     * never the config, so no adapter would see a malformed one. And so is
-     * `logger`, which `createAll` logs its own teardown failures through: a
-     * malformed one threw from inside that teardown, replacing a failed build's
-     * own error with a bare `TypeError`.
-     *
-     * Returns: a factory holding those defaults. It opens nothing: every client
-     * is built by the `create*` call that needs one.
-     *
-     * Throws: `VALIDATION` naming `options.<key>`, `client`, `clientConfig`,
-     * `logger` or `logger.<method>`. Everything else each adapter validates for
-     * itself, since a per-adapter value may still replace it.
-     */
-    constructor(base = {}) {
-        this.base = base;
-        (0, option_shape_1.assertShape)(base, FACTORY_BASE_KEYS, 'options');
-        (0, options_1.assertClientChoice)(base);
-        if (base.logger !== undefined)
-            (0, collaborators_1.assertMembers)(base.logger, collaborators_1.LOGGER_MEMBERS, 'logger');
-    }
-    /** The base options every adapter inherits regardless of which client it uses. */
-    sharedDefaults() {
-        const { logger, ttl, compression, s3, retry } = this.base;
-        return { logger, ttl, compression, s3, retry };
-    }
-    /**
-     * The base `s3` config with the region the DynamoDB side was configured with
-     * already filled in.
-     *
-     * An adapter normally reads that region off its own `clientConfig`
-     * (`offloaderConfigFor`), but the adapters {@link createAll} builds are given
-     * the one shared `client` instead — and a `clientConfig` beside a `client` is
-     * refused, because for the DynamoDB client it would be silently ignored. So
-     * the region has to be carried here, on the config that still needs it:
-     * without it, a bucket reachable only through that region fails with an
-     * opaque `PermanentRedirect` on the first offload, unlike the identical
-     * configuration through `createStore`, which resolves its own region
-     * directly.
-     *
-     * A base `s3`, or its `clientConfig`, that is not an object is handed on
-     * unchanged, for each adapter to refuse by its own name: reading `.region`
-     * off a `null` one would throw here instead, and writing a region into a
-     * malformed `clientConfig` would turn it into an object shape an adapter
-     * then accepts instead of refusing.
-     */
-    sharedS3() {
-        const s3 = this.base.s3;
-        if (!(0, option_shape_1.isObjectShape)(s3))
-            return s3;
-        if (s3.clientConfig !== undefined && !(0, option_shape_1.isObjectShape)(s3.clientConfig))
-            return s3;
-        const region = (0, client_types_1.s3ClientOptions)(s3.clientConfig).region ?? this.base.clientConfig?.region;
-        if (region === undefined)
-            return s3;
-        return { ...s3, clientConfig: { ...s3.clientConfig, region } };
-    }
-    /**
-     * Per-adapter options replace the factory's client choice as a unit: a
-     * `client` handed to `createSaver` also displaces the base `clientConfig`
-     * and `createClient`, because carrying those along is exactly the ambiguous
-     * combination the adapters' option validation rejects. The shared
-     * `ttl`/`compression`/`s3`/`retry` defaults stay either way.
-     */
-    defaultsFor(options) {
-        return overridesClient(options) ? this.sharedDefaults() : this.base;
-    }
-    /**
-     * A saver on its own client.
-     *
-     * Accepts: `options` — the saver's own, laid over the factory's defaults. A
-     * per-adapter value wins; see {@link defaultsFor} for how a client choice
-     * replaces the factory's as a unit.
-     *
-     * Returns: the saver, which owns the client it built and releases it on
-     * `destroy()`.
-     *
-     * Throws: `VALIDATION` for any invalid option, naming it as the saver's
-     * constructor does — `options` for a value that is not an object, checked
-     * before the defaults are laid under it: reading `.client` off a `null`
-     * value would throw here, and spreading a string would iterate its
-     * characters instead of refusing it.
-     */
-    createSaver(options) {
-        (0, option_shape_1.assertObjectShape)(options, 'options');
-        return new saver_1.DynamoDBSaver({ ...this.defaultsFor(options), ...options });
-    }
-    /**
-     * A store on its own client.
-     *
-     * Accepts: as {@link createSaver}, for the store's options.
-     *
-     * Returns: the store.
-     *
-     * Throws: as {@link createSaver}.
-     */
-    createStore(options) {
-        (0, option_shape_1.assertObjectShape)(options, 'options');
-        return new store_1.DynamoDBStore({ ...this.defaultsFor(options), ...options });
-    }
-    /**
-     * A chat history on its own client.
-     *
-     * Accepts: as {@link createSaver}, for the history's options.
-     *
-     * Returns: the chat history.
-     *
-     * Throws: as {@link createSaver}.
-     */
-    createChatMessageHistory(options) {
-        (0, option_shape_1.assertObjectShape)(options, 'options');
-        return new chat_message_history_1.DynamoDBChatMessageHistory({ ...this.defaultsFor(options), ...options });
-    }
-    /**
-     * Build the adapters whose sections are given, all on one shared client.
-     *
-     * Accepts: `options` — a section per adapter, laid over the factory's shared
-     * defaults; omitting one, or giving it as `undefined`, skips that adapter,
-     * and `{}` builds none. A key that is not a section name is refused rather
-     * than ignored, so a misspelt one cannot silently build nothing. Each section
-     * is that adapter's options, so one that is not an object, `null` included,
-     * is refused before any client is built.
-     *
-     * Returns: the adapters, typed by the sections asked for, and one `destroy`
-     * that releases all of them and the shared client. A client the factory was
-     * given rather than built is never destroyed.
-     *
-     * Throws: `VALIDATION` naming `options` for an argument or a section that
-     * is not an object, or `options.<key>` for a key that is not a section name.
-     * Whatever an adapter's constructor throws — after the adapters already
-     * built and the freshly created client have been released, so a failed call
-     * leaks nothing and the constructor's own error is the one that propagates.
-     *
-     * Guarantees: one DynamoDB client for all three adapters, and one S3 client
-     * per adapter, each under its own key prefix in the shared bucket. Teardown
-     * is total: one adapter failing to release its resources cannot strand the
-     * others.
-     */
-    createAll(options) {
-        (0, option_shape_1.assertShape)(options, CREATE_ALL_KEYS, 'options');
-        const { saver, store, history } = options;
-        for (const section of [saver, store, history]) {
-            if (section !== undefined)
-                (0, option_shape_1.assertObjectShape)(section, 'options');
-        }
-        const logger = (0, logger_1.resolveLogger)(this.base.logger);
-        const resolved = (0, client_1.resolveDynamoDBClient)(this.base);
-        const shared = { ...this.sharedDefaults(), s3: this.sharedS3(), client: resolved.client };
-        const built = [];
-        // Record an adapter the moment it exists, so a later failure can still tear it down.
-        const track = (adapter) => {
-            built.push(adapter);
-            return adapter;
-        };
-        const destroy = () => {
-            for (const adapter of built)
-                release(logger, () => adapter.destroy());
-            release(logger, () => resolved.ddbClient?.destroy());
-        };
-        try {
-            const adapters = {
-                saver: saver && track(new saver_1.DynamoDBSaver({ ...shared, ...saver })),
-                store: store && track(new store_1.DynamoDBStore({ ...shared, ...store })),
-                history: history && track(new chat_message_history_1.DynamoDBChatMessageHistory({ ...shared, ...history })),
-                destroy,
-            };
-            return adapters;
-        }
-        catch (error) {
-            destroy();
-            throw error;
-        }
-    }
-}
-exports.DynamoDBFactory = DynamoDBFactory;

package/dist/factory/types.js

@@ -1,10 +0,0 @@
-"use strict";
-/**
- * Hides how the factory's options are typed by what a caller asks for.
- *
- * The defaults every adapter inherits, the per-adapter sections of `createAll`
- * without the shared client's fields, and a result whose adapters are typed
- * `undefined` for each section left out are declared here, so a caller's
- * compiler knows which adapters it got without a runtime check.
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/history/actions/get-messages.js

@@ -1,141 +0,0 @@
-"use strict";
-/**
- * Hides which decode failures cost one message and which fail the read.
- *
- * A stored message is fetched, deserialized and rebuilt in three stages, and
- * the stage a failure comes from decides its fate: only a loss no reader could
- * ever recover is confined to that message and handed to `onCorruptMessage`
- * (record 12); a transport fault, an out-of-scope key, a newer payload or a
- * serializer's refusal fails the read under either policy. A caller gets a
- * conversation that is whole or, under `'skip'`, missing a lost turn
- * reported at `error` — never one silently truncated without a trace —
- * however many downloads run at once.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMessages = getMessages;
-const messages_1 = require("@langchain/core/messages");
-const codec_1 = require("../../shared/codec/codec");
-const concurrency_1 = require("../../shared/concurrency");
-const base_error_1 = require("../../shared/errors/base-error");
-const truncate_1 = require("../../shared/logging/truncate");
-const message_read_1 = require("../internal/message-read");
-const parse_1 = require("../internal/parse");
-/**
- * This message's own loss, or the whole read's failure. Only what no reader
- * could ever recover is confined to one message; everything else would hand
- * the caller a silently truncated conversation that
- * `RunnableWithMessageHistory` then re-persists as the truth.
- */
-function corruptOrRethrow(error) {
-    if ((0, codec_1.isPermanentPayloadLoss)(error))
-        return { kind: 'corrupt', error };
-    throw error;
-}
-/**
- * Decode one item in three stages so failures are classified by what caused
- * them. Fetching the bytes (an S3 download, decompression) is infrastructure:
- * a transport, throttling or permission failure there is rethrown. Only a
- * *permanent* loss at that stage — the object is gone, or the decompression
- * guard tripped — is corruption; a row whose `s3Key` lies outside the session's
- * own path is a configuration or tenancy fault, and a payload whose
- * `schemaVersion` is newer than this release reads is a turn a newer reader
- * still serves, so both are rethrown like any other infrastructure failure (see
- * `assertKeyInScope` and `assertReadableDescriptor`).
- *
- * Deserializing is classified the same way, through the same predicate: bytes
- * that are no longer the form the row declares are this message's own loss, but
- * a serde that refuses to reconstruct what intact bytes *name* — the branded
- * refusal {@link loadPayloadValue} raises for a stored `lc` record naming a
- * class outside its allow-list — is a misconfigured serde or a planted row, and
- * is reported for the same reason the out-of-scope key is. Bytes reached this
- * stage bare before it existed, so a refusal of that kind was skipped here
- * while the store and the saver raised on the identical row.
- *
- * Rebuilding the message from what the serde returned is pure data handling, so
- * any failure there — a type LangChain cannot rebuild, such as a
- * `RemoveMessage` — is corruption confined to that one message.
- */
-async function decodeMessage(context, item, sessionId, signal) {
-    const deps = (0, codec_1.codecDepsOf)(context, signal);
-    let bytes;
-    try {
-        bytes = await (0, codec_1.readPayloadBytes)(item.message, deps, [sessionId]);
-    }
-    catch (error) {
-        return corruptOrRethrow(error);
-    }
-    let stored;
-    try {
-        stored = await (0, codec_1.loadPayloadValue)(item.message.serdeType, bytes, deps);
-    }
-    catch (error) {
-        return corruptOrRethrow(error);
-    }
-    try {
-        return { kind: 'ok', message: (0, messages_1.mapStoredMessagesToChatMessages)([stored])[0] };
-    }
-    catch (error) {
-        return { kind: 'corrupt', error: (0, base_error_1.toError)(error) };
-    }
-}
-/**
- * Return a session's messages in chronological order — the whole session, or
- * the window `options` selects: `limit` keeps only the newest `limit`
- * messages, `before` only those appended before that instant (see
- * {@link readWindow}). Items past their TTL are filtered out on read
- * (DynamoDB's background TTL sweep can lag by up to 48h), so the returned
- * history is never stale. A corrupt item — see
- * {@link decodeMessage} for exactly what counts — is handled per
- * `onCorruptMessage`: `'throw'` fails the read with the underlying error;
- * `'skip'` (the default) reports it at `error` with its sort key and returns
- * the rest. Every other failure propagates regardless of the policy.
- *
- * Accepts: `options.limit` — the newest N, at least 1; absent asks for the
- * whole session, and `0` is refused rather than read as an empty conversation
- * (see {@link parseMessageWindow}).
- * `options.before` — only messages appended before that instant.
- * `options.signal` — aborts the reads.
- *
- * Returns: the messages in chronological order, oldest first. A session that
- * does not exist and one whose messages have all expired both return nothing:
- * a conversation nobody can read is a conversation that is not there.
- *
- * Throws: `VALIDATION` naming `sessionId`, `limit`, `before`, `signal`, or
- * `options.<key>` for a key this package does not read;
- * `FORMAT_UNSUPPORTED` for a row, or a payload, a newer version wrote — the
- * payload half whatever the policy, because a newer reader reads it and
- * dropping it would lose a turn a rollback could still serve; the decode error
- * of a corrupt row under `onCorruptMessage: 'throw'`; `VALIDATION` naming
- * `message` for a row in this session's message key space that this adapter
- * did not write, naming
- * `s3Key` for a row addressing an object outside the session's own path, and
- * naming `serde` for a row whose payload the serializer refuses to
- * reconstruct, all three whatever the policy; any infrastructure failure — a
- * throttle, a permission, a transport error — whatever the policy, because
- * dropping a message for one of those would hand back a silently truncated
- * conversation that the chain then re-persists as the truth.
- *
- * Guarantees: strongly consistent, so the turn just appended is visible.
- * Offloaded messages download several at a time, and the corruption policy is
- * applied in message order however they finish.
- */
-async function getMessages(context, sessionId, options = {}) {
-    const request = (0, parse_1.parseGetMessagesRequest)(sessionId, options);
-    const items = await (0, message_read_1.readWindow)(context, request.sessionId, request.window, request.signal);
-    const decoded = await (0, concurrency_1.mapWithConcurrency)(items, context.readConcurrency ?? concurrency_1.DEFAULT_READ_CONCURRENCY, (item) => decodeMessage(context, item, request.sessionId, request.signal));
-    const messages = [];
-    decoded.forEach((result, index) => {
-        if (result.kind === 'ok') {
-            messages.push(result.message);
-            return;
-        }
-        if (context.onCorruptMessage === 'throw')
-            throw result.error;
-        context.logger.error('getMessages: skipped a corrupt message item', {
-            sessionId: request.sessionId,
-            sortKey: (0, truncate_1.truncateForLog)(items[index].SK),
-            reason: (0, truncate_1.truncateForLog)((0, base_error_1.failureLabel)(result.error)),
-        });
-    });
-    return messages;
-}

package/dist/history/actions/list-sessions.js

@@ -1,156 +0,0 @@
-"use strict";
-/**
- * Hides whether a listing reads the recency index or scans the table.
- *
- * With a configured `indexName` a listing is a cursor-paged, newest-first
- * merge of the index shards; without one it is a filtered scan sorted in
- * memory, with no cursor (record 8). A caller passes the same options and gets
- * the same `SessionPage` either way: `limit` is the newest N on both paths,
- * `0` reads neither, and the same rule summarises each session and drops the
- * expired, foreign and malformed ones.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listSessions = listSessions;
-const clock_1 = require("../../shared/clock");
-const concurrency_1 = require("../../shared/concurrency");
-const paginate_1 = require("../../shared/dynamodb/paginate");
-const recency_index_1 = require("../../shared/dynamodb/recency-index");
-const retry_1 = require("../../shared/dynamodb/retry");
-const table_schema_1 = require("../../shared/dynamodb/table-schema");
-const primitives_1 = require("../../shared/validation/primitives");
-const parse_1 = require("../internal/parse");
-const rows_1 = require("../internal/rows");
-const session_1 = require("../internal/session");
-/** Rows per page when the caller names none. */
-const DEFAULT_PAGE_SIZE = (0, primitives_1.parseLimit)(100, 0);
-/**
- * One page from the recency index, newest-updated first.
- *
- * Expired, foreign and malformed rows are dropped after the read, so a page can
- * come back shorter than `limit` while more rows remain. The cursor still advances,
- * because it is the position in the index rather than a count of what survived
- * filtering.
- */
-async function pageFromIndex(context, indexName, request) {
-    const atSeconds = (0, clock_1.nowSeconds)();
-    const page = await (0, recency_index_1.queryRecencyIndex)({
-        client: context.client,
-        tableName: context.tableName,
-        indexName,
-        tag: 'SESS',
-        shards: context.indexShards ?? recency_index_1.DEFAULT_INDEX_SHARDS,
-        concurrency: context.readConcurrency ?? concurrency_1.DEFAULT_READ_CONCURRENCY,
-        limit: request.limit ?? DEFAULT_PAGE_SIZE,
-        cursor: request.cursor,
-        retry: (0, retry_1.retryFor)(context, request.signal),
-        signal: request.signal,
-    });
-    const sessions = page.items
-        .map((raw) => (0, session_1.summariseSession)(raw, atSeconds))
-        .filter((session) => session !== undefined);
-    return { sessions, ...(page.nextCursor === undefined ? {} : { nextCursor: page.nextCursor }) };
-}
-/**
- * Every session, read by scanning the table and sorted in memory.
- *
- * The fallback for a table without the recency index. It consumes read capacity
- * for every row the scan *evaluates*, not every row it returns, and it holds
- * every session at once — which is why the index exists and why this path
- * offers no cursor.
- *
- * An explicit `limit` is honoured here as the newest N, the same thing it means
- * on the index path. It cannot bound the read — a scan has to finish before the
- * newest can be known — but answering a caller who asked for ten with five
- * thousand sessions was a wrong answer, not a cheaper one.
- *
- * The filter names the partition tag before the sort key. The sort key alone
- * does not identify this adapter: a store namespace element may not hold the
- * separator, but the join inserts one, so the legal store key
- * `sortKey(['t', 'HISTORY'], 'SESSION')` composes `SESSION_SORT_KEY` byte for
- * byte. Such a row sits in a `STORE#` partition, and since a row stamped with a
- * format version above this release is *reported* rather than skipped, one of
- * them was enough to fail this listing on a table the three adapters share.
- * `summariseSession` already requires `PK` to equal `sessionPartition(sessionId)`, so
- * the tag excludes only rows it was dropping after the read. Filtering costs no
- * read capacity either way: DynamoDB applies it once the scan has finished.
- */
-async function allByScan(context, request) {
-    const sessions = [];
-    const atSeconds = (0, clock_1.nowSeconds)();
-    for await (const raw of (0, paginate_1.paginateScan)({
-        retry: (0, retry_1.retryFor)(context, request.signal),
-        signal: request.signal,
-        client: context.client,
-        params: {
-            TableName: context.tableName,
-            FilterExpression: 'begins_with(#pk, :pkp) AND #sk = :session',
-            ExpressionAttributeNames: { '#pk': table_schema_1.PARTITION_KEY_ATTRIBUTE, '#sk': table_schema_1.SORT_KEY_ATTRIBUTE },
-            ExpressionAttributeValues: {
-                ':pkp': (0, rows_1.historyPartitionPrefix)(),
-                ':session': rows_1.SESSION_SORT_KEY,
-            },
-        },
-        maxIterations: request.maxIterations,
-        maxItems: request.maxItems,
-    })) {
-        const session = (0, session_1.summariseSession)(raw, atSeconds);
-        if (session)
-            sessions.push(session);
-    }
-    // Ordinal, not `localeCompare`: these are ISO-8601 timestamps, whose byte
-    // order already is their chronological order. Locale-aware collation applies
-    // rules (case folding, punctuation weighting) that have no meaning here and
-    // are not guaranteed to agree with it in every locale.
-    sessions.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0));
-    return { sessions: request.limit === undefined ? sessions : sessions.slice(0, request.limit) };
-}
-/**
- * List sessions as metadata summaries, most recently updated first.
- *
- * Accepts: `options.limit` — the package-wide page rule, an integer from 0 to
- * the page ceiling; absent means one index page (100) with the index, and
- * every session without it, since a scan has no cursor to fetch the rest with.
- * `0` returns an empty page on either path without reading the table, which
- * matters most on the scan path: a scan has to finish before the newest can be
- * known, so answering `limit: 0` by scanning and then slicing to nothing would
- * have paid for the whole table to return an empty page.
- * `options.cursor` — from a previous page, and
- * only with a configured `indexName`. `options.maxItems` and
- * `maxIterations` — caps on the scan path; with the index the page size is the
- * bound and they do nothing. Each must be a positive integer or `Infinity`
- * (the paginator's own way to ask for no cap); absent keeps its default.
- *
- * Returns: the page, newest-updated first, and a `nextCursor` while rows may
- * remain. A page can come back shorter than `limit` while more remain: expired
- * and foreign rows are dropped after the read, and so is a row of this
- * package's own whose `messageCount`, `createdAt`, `updatedAt`, `title` or
- * `ttl` is not the type written there — otherwise one unreadable `ttl` would fail the
- * whole call, taking every healthy session with it. The cursor is a position in
- * the index rather than a count of what survived filtering. A cursor does not
- * promise more rows: the page after it can come back empty (see
- * `queryRecencyIndex`).
- *
- * Throws: `VALIDATION` naming `limit`, `cursor`, `maxItems`,
- * `maxIterations`, `signal`, or `options.<key>` for a key this package does
- * not read; `RESULT_TRUNCATED` past the scan path's caps, or for an
- * index shard whose pages do not end within `MAX_LOOP_ITERATIONS`;
- * `FORMAT_UNSUPPORTED` for a SESSION row a newer release wrote, on either
- * path; `ABORTED`.
- *
- * Guarantees: with a configured `indexName` each index shard is read
- * newest-first one DynamoDB page at a time, and its next page whenever it has
- * no row buffered and the page still needs one, which can cost a query per
- * shard per page whose rows the page never takes; at most `readConcurrency`
- * shards are queried at once. Memory is the page being built, up to `limit`
- * rows and so bounded by the page ceiling, plus at most one DynamoDB page per shard,
- * whatever the table holds. Without one it is a filtered table scan that holds
- * every session at once and returns no cursor, as earlier releases did.
- */
-async function listSessions(context, options = {}) {
-    const request = (0, parse_1.parseListSessionsRequest)(options, context.indexName);
-    if (request.limit === 0)
-        return { sessions: [] };
-    return context.indexName === undefined
-        ? allByScan(context, request)
-        : pageFromIndex(context, context.indexName, request);
-}