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

package/dist/history/internal/message-chunker.d.ts

@@ -1,13 +0,0 @@
-import type { ChatMessageItem } from '../types';
-/**
- * Conservatively estimate a message item's stored size, so chunks can stay under
- * the DynamoDB transaction byte limit. The overhead allowance keeps the estimate
- * on the safe side of the real marshalled size.
- */
-export declare function estimateItemBytes(item: ChatMessageItem): number;
-/**
- * Split message items into transaction-sized chunks bounded by both the item
- * count and the aggregate byte budget. A single item larger than the budget is
- * placed alone rather than dropped.
- */
-export declare function chunkBySize(items: ChatMessageItem[], maxItems: number, maxBytes: number): ChatMessageItem[][];

package/dist/history/internal/message-chunker.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.estimateItemBytes = estimateItemBytes;
-exports.chunkBySize = chunkBySize;
-const codec_1 = require("../../shared/codec/codec");
-/**
- * Per-item allowance added to the measured field bytes to cover what the size
- * estimate does not count directly: DynamoDB attribute names, the document
- * marshalling envelope, and descriptor scaffolding. Deliberately generous so the
- * estimate stays at or above the real marshalled item size and chunks never
- * overshoot the transaction byte limit.
- */
-const ITEM_OVERHEAD_BYTES = 256;
-/**
- * Byte length of a string as DynamoDB stores it. `String.length` counts UTF-16
- * code units, which understates every non-ASCII character — the wrong
- * direction for an estimate documented to sit at or above the real size.
- */
-function utf8Bytes(value) {
-    return Buffer.byteLength(value, 'utf8');
-}
-function descriptorBytes(descriptor) {
-    const body = descriptor.location === codec_1.PayloadLocation.INLINE
-        ? descriptor.bytes.length
-        : utf8Bytes(descriptor.s3Key);
-    return body + utf8Bytes(descriptor.serdeType);
-}
-/**
- * Conservatively estimate a message item's stored size, so chunks can stay under
- * the DynamoDB transaction byte limit. The overhead allowance keeps the estimate
- * on the safe side of the real marshalled size.
- */
-function estimateItemBytes(item) {
-    return (utf8Bytes(item.PK) +
-        utf8Bytes(item.SK) +
-        utf8Bytes(item.sessionId) +
-        descriptorBytes(item.message) +
-        ITEM_OVERHEAD_BYTES);
-}
-function shouldFlush(count, bytes, next, max, maxBytes) {
-    if (count === 0)
-        return false;
-    return count >= max || bytes + next > maxBytes;
-}
-/**
- * Split message items into transaction-sized chunks bounded by both the item
- * count and the aggregate byte budget. A single item larger than the budget is
- * placed alone rather than dropped.
- */
-function chunkBySize(items, maxItems, maxBytes) {
-    const chunks = [];
-    let current = [];
-    let currentBytes = 0;
-    for (const item of items) {
-        const size = estimateItemBytes(item);
-        if (shouldFlush(current.length, currentBytes, size, maxItems, maxBytes)) {
-            chunks.push(current);
-            current = [];
-            currentBytes = 0;
-        }
-        current.push(item);
-        currentBytes += size;
-    }
-    if (current.length > 0)
-        chunks.push(current);
-    return chunks;
-}

package/dist/history/internal/message-transaction.d.ts

@@ -1,25 +0,0 @@
-import type { ChatMessageItem } from '../types';
-import { type SessionUpdateFields } from './session-update';
-import type { HistoryContext } from './setup';
-/** Per-call retry seams (injected in tests to keep backoff instant). */
-export interface ChunkRetryOptions {
-    rng?: () => number;
-    signal?: AbortSignal;
-}
-/**
- * Atomically write a chunk of message items together with the session-metadata
- * count update in one {@link https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html | TransactWriteItems}
- * call, so `messageCount` can never disagree with the messages that landed. A
- * single `ClientRequestToken` is used per attempt so a re-sent commit (e.g.
- * after a lost response) is idempotent and never double-applies the count
- * `ADD`. When `fields.forceTtlRefresh` is set, the session update carries a
- * monotonic ConditionExpression (see session-update.ts); if — and only if —
- * that specific condition loses a race against a concurrent caller who just
- * healed the same anchor, this retries the identical chunk once with
- * `forceTtlRefresh: false` (safe: `if_not_exists` then converges to whatever
- * already won) rather than losing the message writes to a benign ttl race. A
- * cancellation caused by any other item (a genuine message-row conflict) is
- * not retried here — it propagates for the normal transient-conflict retry
- * budget inside `withDynamoDBRetry` to handle, or to the caller otherwise.
- */
-export declare function writeMessageChunk(context: HistoryContext, items: ChatMessageItem[], fields: SessionUpdateFields, retry?: ChunkRetryOptions): Promise<void>;

package/dist/history/internal/message-transaction.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeMessageChunk = writeMessageChunk;
-const node_crypto_1 = require("node:crypto");
-const constants_1 = require("../../shared/constants");
-const cancellation_1 = require("../../shared/dynamodb/cancellation");
-const retry_1 = require("../../shared/dynamodb/retry");
-const session_update_1 = require("./session-update");
-/** True when a TransactWriteItems cancellation was caused solely by the SESSION update's ttl condition (always TransactItems index 0 — see buildInput below), not by any message item. */
-function isTtlConditionLoss(error) {
-    const reasons = (0, cancellation_1.getCancellationReasons)(error);
-    return (reasons?.[0]?.Code === 'ConditionalCheckFailed' &&
-        reasons.slice(1).every((reason) => reason.Code === 'None'));
-}
-function buildInput(context, items, fields) {
-    return {
-        TransactItems: [
-            (0, session_update_1.buildSessionUpdateItem)(context.tableName, fields),
-            ...items.map((item) => ({ Put: { TableName: context.tableName, Item: item } })),
-        ],
-        ClientRequestToken: (0, node_crypto_1.randomUUID)(),
-    };
-}
-async function attempt(context, items, fields, retry) {
-    const input = buildInput(context, items, fields);
-    await (0, retry_1.withDynamoDBRetry)(() => context.client.transactWrite(input), {
-        ...context.retry,
-        /** The contention floor: a caller policy may raise the budget, never lower it. */
-        maxAttempts: Math.max(constants_1.MESSAGE_APPEND_RETRY_MAX_ATTEMPTS, context.retry?.maxAttempts ?? 0),
-        rng: retry.rng,
-        signal: retry.signal,
-    });
-}
-/**
- * Atomically write a chunk of message items together with the session-metadata
- * count update in one {@link https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html | TransactWriteItems}
- * call, so `messageCount` can never disagree with the messages that landed. A
- * single `ClientRequestToken` is used per attempt so a re-sent commit (e.g.
- * after a lost response) is idempotent and never double-applies the count
- * `ADD`. When `fields.forceTtlRefresh` is set, the session update carries a
- * monotonic ConditionExpression (see session-update.ts); if — and only if —
- * that specific condition loses a race against a concurrent caller who just
- * healed the same anchor, this retries the identical chunk once with
- * `forceTtlRefresh: false` (safe: `if_not_exists` then converges to whatever
- * already won) rather than losing the message writes to a benign ttl race. A
- * cancellation caused by any other item (a genuine message-row conflict) is
- * not retried here — it propagates for the normal transient-conflict retry
- * budget inside `withDynamoDBRetry` to handle, or to the caller otherwise.
- */
-async function writeMessageChunk(context, items, fields, retry = {}) {
-    try {
-        await attempt(context, items, fields, retry);
-    }
-    catch (error) {
-        if (fields.forceTtlRefresh && isTtlConditionLoss(error)) {
-            await attempt(context, items, { ...fields, forceTtlRefresh: false }, retry);
-            return;
-        }
-        throw error;
-    }
-}

package/dist/history/internal/message-window.d.ts

@@ -1,17 +0,0 @@
-import type { CancelOptions } from '../../shared/options';
-import type { ChatMessageItem, MessageWindow } from '../types';
-import type { HistoryContext } from './setup';
-/**
- * Read the live message items a window selects, in chronological order.
- *
- * Without `limit` the query walks the session oldest-first. With it the query
- * walks newest-first with a matching page cap and stops as soon as `limit`
- * live items are in hand — rows past their TTL are skipped here, so a page can
- * come back short and the walk simply continues — and the tail is then
- * reversed back into chronological order. `before` becomes an exclusive upper
- * sort-key bound: the message prefix plus the ULID time characters of that
- * instant, which every message id from that millisecond onwards sorts after.
- * Reads are strongly consistent so the turn just appended is visible to the
- * very next read.
- */
-export declare function readWindow(context: HistoryContext, sessionId: string, options: MessageWindow & CancelOptions): Promise<ChatMessageItem[]>;

package/dist/history/internal/message-window.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readWindow = readWindow;
-const clock_1 = require("../../shared/clock");
-const expiry_1 = require("../../shared/dynamodb/expiry");
-const paginate_1 = require("../../shared/dynamodb/paginate");
-const retry_policy_1 = require("../../shared/dynamodb/retry-policy");
-const ulid_1 = require("../../shared/ulid");
-const keys_1 = require("./keys");
-const query_1 = require("./query");
-/**
- * Read the live message items a window selects, in chronological order.
- *
- * Without `limit` the query walks the session oldest-first. With it the query
- * walks newest-first with a matching page cap and stops as soon as `limit`
- * live items are in hand — rows past their TTL are skipped here, so a page can
- * come back short and the walk simply continues — and the tail is then
- * reversed back into chronological order. `before` becomes an exclusive upper
- * sort-key bound: the message prefix plus the ULID time characters of that
- * instant, which every message id from that millisecond onwards sorts after.
- * Reads are strongly consistent so the turn just appended is visible to the
- * very next read.
- */
-async function readWindow(context, sessionId, options) {
-    const now = (0, clock_1.nowSeconds)();
-    const limit = options.limit ?? Number.POSITIVE_INFINITY;
-    const items = [];
-    for await (const raw of (0, paginate_1.paginateQuery)({
-        retry: (0, retry_policy_1.retryFor)(context, options.signal),
-        signal: options.signal,
-        client: context.client,
-        params: (0, query_1.messageQuery)(context.tableName, sessionId, {
-            consistent: true,
-            descending: options.limit !== undefined,
-            limit: options.limit,
-            beforeSortKey: options.before && (0, keys_1.messageSortKey)((0, ulid_1.ulidTimePrefix)(options.before.getTime())),
-        }),
-        maxItems: Number.POSITIVE_INFINITY,
-        maxIterations: Number.POSITIVE_INFINITY,
-    })) {
-        const item = raw;
-        if ((0, expiry_1.isExpiredRow)(item, now))
-            continue;
-        items.push(item);
-        if (items.length >= limit)
-            break;
-    }
-    return options.limit === undefined ? items : items.reverse();
-}

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

@@ -1,23 +0,0 @@
-import type { QueryCommandInput } from '@aws-sdk/lib-dynamodb';
-/** Options for {@link sessionItemsQuery}. */
-export interface SessionItemsQueryOptions {
-    consistent?: boolean;
-}
-/** Query input selecting every item in a session's partition (messages + metadata). */
-export declare function sessionItemsQuery(tableName: string, sessionId: string, options?: SessionItemsQueryOptions): QueryCommandInput;
-/** Options for {@link messageQuery}. */
-export interface MessageQueryOptions extends SessionItemsQueryOptions {
-    /** Walk the messages newest-first; the caller restores chronological order. */
-    descending?: boolean;
-    /** Cap the rows DynamoDB evaluates per page. */
-    limit?: number;
-    /**
-     * Exclusive upper sort-key bound. Expressed as `BETWEEN prefix AND bound`
-     * because a key condition allows one sort-key operator: the bound is the
-     * message prefix plus the ULID time characters of an instant, so every
-     * real message key from that millisecond onwards sorts strictly after it.
-     */
-    beforeSortKey?: string;
-}
-/** Query input selecting a session's message items, chronological unless `descending`. */
-export declare function messageQuery(tableName: string, sessionId: string, options?: MessageQueryOptions): QueryCommandInput;

package/dist/history/internal/query.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sessionItemsQuery = sessionItemsQuery;
-exports.messageQuery = messageQuery;
-const keys_1 = require("./keys");
-/** Query input selecting every item in a session's partition (messages + metadata). */
-function sessionItemsQuery(tableName, sessionId, options = {}) {
-    const params = {
-        TableName: tableName,
-        KeyConditionExpression: '#pk = :pk',
-        ExpressionAttributeNames: { '#pk': 'PK' },
-        ExpressionAttributeValues: { ':pk': (0, keys_1.sessionPartition)(sessionId) },
-    };
-    if (options.consistent)
-        params.ConsistentRead = true;
-    return params;
-}
-/** Query input selecting a session's message items, chronological unless `descending`. */
-function messageQuery(tableName, sessionId, options = {}) {
-    const params = {
-        TableName: tableName,
-        KeyConditionExpression: '#pk = :pk AND begins_with(#sk, :skp)',
-        ExpressionAttributeNames: { '#pk': 'PK', '#sk': 'SK' },
-        ExpressionAttributeValues: {
-            ':pk': (0, keys_1.sessionPartition)(sessionId),
-            ':skp': (0, keys_1.messageSortKeyPrefix)(),
-        },
-        ScanIndexForward: !options.descending,
-    };
-    if (options.beforeSortKey !== undefined) {
-        params.KeyConditionExpression = '#pk = :pk AND #sk BETWEEN :skp AND :before';
-        params.ExpressionAttributeValues[':before'] = options.beforeSortKey;
-    }
-    if (options.limit !== undefined)
-        params.Limit = options.limit;
-    if (options.consistent)
-        params.ConsistentRead = true;
-    return params;
-}

package/dist/history/internal/session-count.d.ts

@@ -1,47 +0,0 @@
-import type { HistoryContext } from './setup';
-/**
- * Subtract a previously-added count from the session, leaving it consistent.
- * Guarded so a concurrently-deleted SESSION row is never resurrected as a
- * permanent, ttl-less junk row: if the row is already gone there is nothing
- * to revert, so that specific condition failure is swallowed rather than
- * surfaced — this runs only from an already-in-progress rollback, where a
- * spurious error for a no-op would misrepresent what happened.
- *
- * The same condition also pins the *incarnation*: `createdAt <= createdBefore`
- * (this call's own append timestamp). A session `clear()`-ed and re-created by
- * another caller between this call's commit and its rollback carries a later
- * `createdAt`; decrementing it would corrupt the new incarnation's count, and
- * its rows were never this call's to revert. That rejection is swallowed too,
- * for the same reason as a vanished row.
- *
- * Deliberately does not revert a `forceTtlRefresh`-driven ttl SET from an
- * earlier committed chunk: the healed anchor is never shorter than what
- * was there before, so leaving it in place after a rollback only means the
- * session's metadata row outlives its content a bit longer than ideal —
- * self-healing (the next successful append, or DynamoDB's own TTL sweep,
- * resolves it), unlike reverting, which would need to re-check for a
- * concurrent legitimate extension to avoid regressing it. See README.md's
- * "TTL expiry" section.
- */
-export declare function revertSessionCount(context: HistoryContext, sessionId: string, delta: number, createdBefore: string): Promise<void>;
-/**
- * Undo a rolled-back append's effect on the session row.
- *
- * When this call is the one that created the row — `createdAt` still equals
- * this call's timestamp, and the only messages counted on it are the ones
- * being reverted — the whole row is deleted. Without that, a failed first
- * append left a "ghost session": `title`, `createdAt` and `sessionId` are all
- * written via `if_not_exists`, so they were never reverted and never set
- * again, leaving `listSessions()` reporting a session with `messageCount: 0`
- * whose title still held up to 80 characters of a message the caller was told
- * had not persisted, with no API to clear it.
- *
- * Both conditions are load-bearing. `createdAt = :now` establishes that this
- * call created the row; `messageCount = :total` establishes that nothing else
- * has added to it since. A concurrent append to the same brand-new session
- * fails the count check, because deleting the row would destroy that caller's
- * committed messages — so it falls through to the plain decrement, and then
- * strips just the title this call contributed, which is the only part of the
- * row still carrying rolled-back message content.
- */
-export declare function revertSessionCreation(context: HistoryContext, sessionId: string, total: number, createdAt: string, title?: string): Promise<void>;

package/dist/history/internal/session-count.js

@@ -1,115 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.revertSessionCount = revertSessionCount;
-exports.revertSessionCreation = revertSessionCreation;
-const node_crypto_1 = require("node:crypto");
-const cancellation_1 = require("../../shared/dynamodb/cancellation");
-const retry_1 = require("../../shared/dynamodb/retry");
-const keys_1 = require("./keys");
-const session_title_1 = require("./session-title");
-/**
- * True when a TransactWriteItems cancellation was caused by a
- * ConditionalCheckFailed reason. Named distinctly from
- * checkpointer/actions/put-writes.ts's isConditionalCheckFailed, which
- * checks a different thing entirely (a raw PutItem exception name, not a
- * transaction cancellation reason) — this function had that same name
- * until now, a real trap for whoever read one assuming it was the other.
- */
-function isCancelledByCondition(error) {
-    const reasons = (0, cancellation_1.getCancellationReasons)(error);
-    return reasons?.[0]?.Code === 'ConditionalCheckFailed';
-}
-/**
- * Subtract a previously-added count from the session, leaving it consistent.
- * Guarded so a concurrently-deleted SESSION row is never resurrected as a
- * permanent, ttl-less junk row: if the row is already gone there is nothing
- * to revert, so that specific condition failure is swallowed rather than
- * surfaced — this runs only from an already-in-progress rollback, where a
- * spurious error for a no-op would misrepresent what happened.
- *
- * The same condition also pins the *incarnation*: `createdAt <= createdBefore`
- * (this call's own append timestamp). A session `clear()`-ed and re-created by
- * another caller between this call's commit and its rollback carries a later
- * `createdAt`; decrementing it would corrupt the new incarnation's count, and
- * its rows were never this call's to revert. That rejection is swallowed too,
- * for the same reason as a vanished row.
- *
- * Deliberately does not revert a `forceTtlRefresh`-driven ttl SET from an
- * earlier committed chunk: the healed anchor is never shorter than what
- * was there before, so leaving it in place after a rollback only means the
- * session's metadata row outlives its content a bit longer than ideal —
- * self-healing (the next successful append, or DynamoDB's own TTL sweep,
- * resolves it), unlike reverting, which would need to re-check for a
- * concurrent legitimate extension to avoid regressing it. See README.md's
- * "TTL expiry" section.
- */
-async function revertSessionCount(context, sessionId, delta, createdBefore) {
-    if (delta === 0)
-        return;
-    const update = {
-        TableName: context.tableName,
-        Key: { PK: (0, keys_1.sessionPartition)(sessionId), SK: keys_1.SESSION_SORT_KEY },
-        UpdateExpression: 'ADD #count :neg',
-        ConditionExpression: 'attribute_exists(PK) AND #c <= :now',
-        ExpressionAttributeNames: { '#count': 'messageCount', '#c': 'createdAt' },
-        ExpressionAttributeValues: { ':neg': -delta, ':now': createdBefore },
-    };
-    const input = { TransactItems: [{ Update: update }], ClientRequestToken: (0, node_crypto_1.randomUUID)() };
-    try {
-        await (0, retry_1.withDynamoDBRetry)(() => context.client.transactWrite(input), context.retry);
-    }
-    catch (error) {
-        if (isCancelledByCondition(error))
-            return;
-        throw error;
-    }
-}
-/**
- * Undo a rolled-back append's effect on the session row.
- *
- * When this call is the one that created the row — `createdAt` still equals
- * this call's timestamp, and the only messages counted on it are the ones
- * being reverted — the whole row is deleted. Without that, a failed first
- * append left a "ghost session": `title`, `createdAt` and `sessionId` are all
- * written via `if_not_exists`, so they were never reverted and never set
- * again, leaving `listSessions()` reporting a session with `messageCount: 0`
- * whose title still held up to 80 characters of a message the caller was told
- * had not persisted, with no API to clear it.
- *
- * Both conditions are load-bearing. `createdAt = :now` establishes that this
- * call created the row; `messageCount = :total` establishes that nothing else
- * has added to it since. A concurrent append to the same brand-new session
- * fails the count check, because deleting the row would destroy that caller's
- * committed messages — so it falls through to the plain decrement, and then
- * strips just the title this call contributed, which is the only part of the
- * row still carrying rolled-back message content.
- */
-async function revertSessionCreation(context, sessionId, total, createdAt, title) {
-    if (total === 0)
-        return;
-    const input = {
-        TransactItems: [
-            {
-                Delete: {
-                    TableName: context.tableName,
-                    Key: { PK: (0, keys_1.sessionPartition)(sessionId), SK: keys_1.SESSION_SORT_KEY },
-                    ConditionExpression: '#count = :total AND #c = :now',
-                    ExpressionAttributeNames: { '#count': 'messageCount', '#c': 'createdAt' },
-                    ExpressionAttributeValues: { ':total': total, ':now': createdAt },
-                },
-            },
-        ],
-        ClientRequestToken: (0, node_crypto_1.randomUUID)(),
-    };
-    try {
-        await (0, retry_1.withDynamoDBRetry)(() => context.client.transactWrite(input), context.retry);
-        return;
-    }
-    catch (error) {
-        if (!isCancelledByCondition(error))
-            throw error;
-    }
-    await revertSessionCount(context, sessionId, total, createdAt);
-    if (title !== undefined)
-        await (0, session_title_1.removeRolledBackTitle)(context, sessionId, createdAt, title);
-}

package/dist/history/internal/session-title.d.ts

@@ -1,19 +0,0 @@
-import type { HistoryContext } from './setup';
-/**
- * Strip a title this call contributed to a session row it created, when the
- * row itself could not be deleted because a concurrent append has since added
- * messages to it.
- *
- * Without this, that narrow window reopens exactly the leak C4 closes: the
- * title is derived from the first human message of an append the caller was
- * told had failed, and `if_not_exists` means nothing ever overwrites it — so
- * a row that now belongs to a different caller keeps up to 80 characters of
- * rolled-back message content.
- *
- * Both guards are load-bearing. `createdAt = :now` establishes that this call
- * created the row, and `title = :title` that the title on it is still the one
- * this call wrote — so a pre-existing title, or one a concurrent caller won
- * the `if_not_exists` race for, is never removed. A condition rejection means
- * exactly that and is not an error; anything else is.
- */
-export declare function removeRolledBackTitle(context: HistoryContext, sessionId: string, createdAt: string, title: string): Promise<void>;

package/dist/history/internal/session-title.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeRolledBackTitle = removeRolledBackTitle;
-const retry_1 = require("../../shared/dynamodb/retry");
-const keys_1 = require("./keys");
-/** True when a plain UpdateItem was turned away by its ConditionExpression. */
-function isConditionRejected(error) {
-    return error.name === 'ConditionalCheckFailedException';
-}
-/**
- * Strip a title this call contributed to a session row it created, when the
- * row itself could not be deleted because a concurrent append has since added
- * messages to it.
- *
- * Without this, that narrow window reopens exactly the leak C4 closes: the
- * title is derived from the first human message of an append the caller was
- * told had failed, and `if_not_exists` means nothing ever overwrites it — so
- * a row that now belongs to a different caller keeps up to 80 characters of
- * rolled-back message content.
- *
- * Both guards are load-bearing. `createdAt = :now` establishes that this call
- * created the row, and `title = :title` that the title on it is still the one
- * this call wrote — so a pre-existing title, or one a concurrent caller won
- * the `if_not_exists` race for, is never removed. A condition rejection means
- * exactly that and is not an error; anything else is.
- */
-async function removeRolledBackTitle(context, sessionId, createdAt, title) {
-    try {
-        await (0, retry_1.withDynamoDBRetry)(() => context.client.update({
-            TableName: context.tableName,
-            Key: { PK: (0, keys_1.sessionPartition)(sessionId), SK: keys_1.SESSION_SORT_KEY },
-            UpdateExpression: 'REMOVE #title',
-            ConditionExpression: '#c = :now AND #title = :title',
-            ExpressionAttributeNames: { '#title': 'title', '#c': 'createdAt' },
-            ExpressionAttributeValues: { ':now': createdAt, ':title': title },
-        }), context.retry);
-    }
-    catch (error) {
-        if (isConditionRejected(error))
-            return;
-        throw error;
-    }
-}

package/dist/history/internal/session-update.d.ts

@@ -1,27 +0,0 @@
-import type { TransactWriteCommandInput } from '@aws-sdk/lib-dynamodb';
-/** One member of a {@link TransactWriteCommandInput} `TransactItems` list. */
-export type HistoryTransactItem = NonNullable<TransactWriteCommandInput['TransactItems']>[number];
-/** Fields driving the per-session metadata update inside the append transaction. */
-export interface SessionUpdateFields {
-    sessionId: string;
-    count: number;
-    now: string;
-    title?: string;
-    ttlTimestamp?: number;
-    forceTtlRefresh?: boolean;
-}
-/**
- * Build the metadata `Update` transact-item: `ADD` the message count and `SET`
- * `updatedAt` every time, while `createdAt`, `sessionId`, `title`, and the `ttl`
- * anchor are written once via `if_not_exists`. Folding the `ttl` anchor in here
- * means the first append fixes one shared expiry atomically with the count, with
- * no separate pre-write that could orphan a metadata-only row. When
- * `forceTtlRefresh` is set (because {@link resolveTtlAnchor} found the persisted
- * anchor missing or already expired), the `ttl` clause instead does a plain
- * `SET`, so the SESSION row's own stale attribute actually heals instead of
- * being permanently blocked by `if_not_exists`. When forceTtlRefresh is set,
- * the SET is additionally guarded by a ConditionExpression so a concurrent
- * caller's already-healed anchor can never be regressed backward — see
- * message-transaction.ts for how a lost race is retried without forcing.
- */
-export declare function buildSessionUpdateItem(tableName: string, fields: SessionUpdateFields): HistoryTransactItem;

package/dist/history/internal/session-update.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSessionUpdateItem = buildSessionUpdateItem;
-const keys_1 = require("./keys");
-/**
- * Build the metadata `Update` transact-item: `ADD` the message count and `SET`
- * `updatedAt` every time, while `createdAt`, `sessionId`, `title`, and the `ttl`
- * anchor are written once via `if_not_exists`. Folding the `ttl` anchor in here
- * means the first append fixes one shared expiry atomically with the count, with
- * no separate pre-write that could orphan a metadata-only row. When
- * `forceTtlRefresh` is set (because {@link resolveTtlAnchor} found the persisted
- * anchor missing or already expired), the `ttl` clause instead does a plain
- * `SET`, so the SESSION row's own stale attribute actually heals instead of
- * being permanently blocked by `if_not_exists`. When forceTtlRefresh is set,
- * the SET is additionally guarded by a ConditionExpression so a concurrent
- * caller's already-healed anchor can never be regressed backward — see
- * message-transaction.ts for how a lost race is retried without forcing.
- */
-function buildSessionUpdateItem(tableName, fields) {
-    const names = {
-        '#count': 'messageCount',
-        '#u': 'updatedAt',
-        '#c': 'createdAt',
-        '#sid': 'sessionId',
-    };
-    const values = {
-        ':n': fields.count,
-        ':u': fields.now,
-        ':c': fields.now,
-        ':sid': fields.sessionId,
-    };
-    const sets = ['#u = :u', '#c = if_not_exists(#c, :c)', '#sid = if_not_exists(#sid, :sid)'];
-    if (fields.title !== undefined) {
-        names['#title'] = 'title';
-        values[':title'] = fields.title;
-        sets.push('#title = if_not_exists(#title, :title)');
-    }
-    let conditionExpression;
-    if (fields.ttlTimestamp !== undefined) {
-        names['#ttl'] = 'ttl';
-        values[':ttl'] = fields.ttlTimestamp;
-        if (fields.forceTtlRefresh) {
-            sets.push('#ttl = :ttl');
-            /**
-             * Guards the force-overwrite so a concurrent caller's already-healed,
-             * equal-or-later anchor can never be regressed backward by this one.
-             * `<=` (not `<`): two concurrent healers of the same stale anchor
-             * typically compute the identical target timestamp, and `<=` lets
-             * the second one succeed by re-applying the same value instead of
-             * failing the condition and paying a full transaction retry for a
-             * write that was never actually a regression.
-             */
-            conditionExpression = 'attribute_not_exists(#ttl) OR #ttl <= :ttl';
-        }
-        else {
-            sets.push('#ttl = if_not_exists(#ttl, :ttl)');
-        }
-    }
-    return {
-        Update: {
-            TableName: tableName,
-            Key: { PK: (0, keys_1.sessionPartition)(fields.sessionId), SK: keys_1.SESSION_SORT_KEY },
-            UpdateExpression: `ADD #count :n SET ${sets.join(', ')}`,
-            ...(conditionExpression ? { ConditionExpression: conditionExpression } : {}),
-            ExpressionAttributeNames: names,
-            ExpressionAttributeValues: values,
-        },
-    };
-}