@farukada/aws-langgraph-dynamodb-ts 0.2.2 → 0.3.0

package/dist/history/actions/reconcile-count.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileMessageCount = reconcileMessageCount;
+const retry_1 = require("../../shared/dynamodb/retry");
+const primitives_1 = require("../../shared/validation/primitives");
+const keys_1 = require("../internal/keys");
+const query_1 = require("../internal/query");
+/** Count a session's message items with a server-side `COUNT` query, all pages. */
+async function countMessages(context, sessionId) {
+    const base = (0, query_1.messageQuery)(context.tableName, sessionId);
+    let total = 0;
+    let startKey;
+    do {
+        const page = await (0, retry_1.withDynamoDBRetry)(() => context.client.query({ ...base, Select: 'COUNT', ExclusiveStartKey: startKey }));
+        total += page.Count ?? 0;
+        startKey = page.LastEvaluatedKey;
+    } while (startKey);
+    return total;
+}
+/**
+ * Recompute `messageCount` from the authoritative number of stored message items
+ * and write it back, repairing any drift. A repair tool: the append path keeps
+ * the count consistent transactionally, so this is only needed after external
+ * corruption. Run it when the session is quiescent — it `SET`s the count, so a
+ * concurrent append's increment could be clobbered. Returns the reconciled count.
+ */
+async function reconcileMessageCount(context, sessionId) {
+    (0, primitives_1.validateNonEmptyString)(sessionId, 'sessionId');
+    const count = await countMessages(context, sessionId);
+    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: 'SET #count = :count',
+        ExpressionAttributeNames: { '#count': 'messageCount' },
+        ExpressionAttributeValues: { ':count': count },
+    }));
+    return count;
+}
+//# sourceMappingURL=reconcile-count.js.map

package/dist/history/actions/reconcile-count.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile-count.js","sourceRoot":"","sources":["../../../src/history/actions/reconcile-count.ts"],"names":[],"mappings":";;AA8BA,sDAgBC;AA5CD,uDAAgE;AAChE,mEAA4E;AAC5E,2CAAsE;AACtE,6CAAiD;AAGjD,mFAAmF;AACnF,KAAK,UAAU,aAAa,CAAC,OAAuB,EAAE,SAAiB;IACrE,MAAM,IAAI,GAAG,IAAA,oBAAY,EAAC,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;IACxD,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,QAA0D,CAAC;IAC/D,GAAG,CAAC;QACF,MAAM,IAAI,GAAG,MAAM,IAAA,yBAAiB,EAAC,GAAG,EAAE,CACxC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,CAAC,CAChF,CAAC;QACF,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;QACzB,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC;IACnC,CAAC,QAAQ,QAAQ,EAAE;IACnB,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACI,KAAK,UAAU,qBAAqB,CACzC,OAAuB,EACvB,SAAiB;IAEjB,IAAA,mCAAsB,EAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAG,MAAM,aAAa,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACtD,MAAM,IAAA,yBAAiB,EAAC,GAAG,EAAE,CAC3B,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC;QACpB,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,GAAG,EAAE,EAAE,EAAE,EAAE,IAAA,uBAAgB,EAAC,SAAS,CAAC,EAAE,EAAE,EAAE,uBAAgB,EAAE;QAC9D,gBAAgB,EAAE,qBAAqB;QACvC,wBAAwB,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE;QACtD,yBAAyB,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE;KAC/C,CAAC,CACH,CAAC;IACF,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/history/chat-message-history.d.ts

@@ -0,0 +1,36 @@
+import type { BaseMessage } from '@langchain/core/messages';
+import { DynamoDBSessionChatMessageHistory } from './session-adapter';
+import type { DynamoDBChatMessageHistoryOptions, SessionMetadata } from './types';
+/**
+ * DynamoDB-backed multi-session chat history. Each message is its own item
+ * (ordered by a monotonic ULID, compressed / S3-offloaded as needed) alongside a
+ * per-session metadata item; every message in a session shares one uniform TTL.
+ * Appends are O(1) and lock-free. Use {@link forSession} to get a single-session
+ * LangChain adapter.
+ */
+export declare class DynamoDBChatMessageHistory {
+    private readonly context;
+    private readonly ownsClient;
+    private readonly ddbClient;
+    constructor(options: DynamoDBChatMessageHistoryOptions);
+    /** Get a session's messages in order. */
+    getMessages(sessionId: string): Promise<BaseMessage[]>;
+    /** Append messages to a session. */
+    addMessages(sessionId: string, messages: BaseMessage[]): Promise<void>;
+    /** Append a single message to a session. */
+    addMessage(sessionId: string, message: BaseMessage): Promise<void>;
+    /** Delete a session and any offloaded payload. */
+    clear(sessionId: string): Promise<void>;
+    /** List all sessions as metadata summaries. */
+    listSessions(): Promise<SessionMetadata[]>;
+    /**
+     * Recompute and repair a session's `messageCount` from the stored messages.
+     * A maintenance tool for external corruption; run it when the session is idle.
+     */
+    reconcileMessageCount(sessionId: string): Promise<number>;
+    /** Get a single-session LangChain adapter for `sessionId`. */
+    forSession(sessionId: string): DynamoDBSessionChatMessageHistory;
+    /** Release owned resources (the underlying client and any S3 client). */
+    destroy(): void;
+}
+//# sourceMappingURL=chat-message-history.d.ts.map

package/dist/history/chat-message-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-message-history.d.ts","sourceRoot":"","sources":["../../src/history/chat-message-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAQ5D,OAAO,EAAE,iCAAiC,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,iCAAiC,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAElF;;;;;;GAMG;AACH,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+C;gBAE7D,OAAO,EAAE,iCAAiC;IAOtD,yCAAyC;IACzC,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAItD,oCAAoC;IACpC,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAItE,4CAA4C;IAC5C,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlE,kDAAkD;IAClD,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC,+CAA+C;IAC/C,YAAY,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAI1C;;;OAGG;IACH,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIzD,8DAA8D;IAC9D,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,iCAAiC;IAIhE,yEAAyE;IACzE,OAAO,IAAI,IAAI;CAIhB"}

package/dist/history/chat-message-history.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDBChatMessageHistory = void 0;
+const add_messages_1 = require("./actions/add-messages");
+const clear_1 = require("./actions/clear");
+const get_messages_1 = require("./actions/get-messages");
+const list_sessions_1 = require("./actions/list-sessions");
+const reconcile_count_1 = require("./actions/reconcile-count");
+const setup_1 = require("./internal/setup");
+const session_adapter_1 = require("./session-adapter");
+/**
+ * DynamoDB-backed multi-session chat history. Each message is its own item
+ * (ordered by a monotonic ULID, compressed / S3-offloaded as needed) alongside a
+ * per-session metadata item; every message in a session shares one uniform TTL.
+ * Appends are O(1) and lock-free. Use {@link forSession} to get a single-session
+ * LangChain adapter.
+ */
+class DynamoDBChatMessageHistory {
+    context;
+    ownsClient;
+    ddbClient;
+    constructor(options) {
+        const setup = (0, setup_1.setUpHistory)(options);
+        this.context = setup.context;
+        this.ownsClient = setup.ownsClient;
+        this.ddbClient = setup.ddbClient;
+    }
+    /** Get a session's messages in order. */
+    getMessages(sessionId) {
+        return (0, get_messages_1.getMessages)(this.context, sessionId);
+    }
+    /** Append messages to a session. */
+    addMessages(sessionId, messages) {
+        return (0, add_messages_1.addMessages)(this.context, sessionId, messages);
+    }
+    /** Append a single message to a session. */
+    addMessage(sessionId, message) {
+        return (0, add_messages_1.addMessages)(this.context, sessionId, [message]);
+    }
+    /** Delete a session and any offloaded payload. */
+    clear(sessionId) {
+        return (0, clear_1.clearSession)(this.context, sessionId);
+    }
+    /** List all sessions as metadata summaries. */
+    listSessions() {
+        return (0, list_sessions_1.listSessions)(this.context);
+    }
+    /**
+     * Recompute and repair a session's `messageCount` from the stored messages.
+     * A maintenance tool for external corruption; run it when the session is idle.
+     */
+    reconcileMessageCount(sessionId) {
+        return (0, reconcile_count_1.reconcileMessageCount)(this.context, sessionId);
+    }
+    /** Get a single-session LangChain adapter for `sessionId`. */
+    forSession(sessionId) {
+        return new session_adapter_1.DynamoDBSessionChatMessageHistory(this, sessionId);
+    }
+    /** Release owned resources (the underlying client and any S3 client). */
+    destroy() {
+        this.context.offloader?.destroy();
+        if (this.ownsClient)
+            this.ddbClient?.destroy();
+    }
+}
+exports.DynamoDBChatMessageHistory = DynamoDBChatMessageHistory;
+//# sourceMappingURL=chat-message-history.js.map

package/dist/history/chat-message-history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-message-history.js","sourceRoot":"","sources":["../../src/history/chat-message-history.ts"],"names":[],"mappings":";;;AAEA,yDAA0E;AAC1E,2CAA+C;AAC/C,yDAA0E;AAC1E,2DAA6E;AAC7E,+DAAiG;AACjG,4CAAqE;AACrE,uDAAsE;AAGtE;;;;;;GAMG;AACH,MAAa,0BAA0B;IACpB,OAAO,CAAiB;IACxB,UAAU,CAAU;IACpB,SAAS,CAA+C;IAEzE,YAAY,OAA0C;QACpD,MAAM,KAAK,GAAG,IAAA,oBAAY,EAAC,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QAC7B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QACnC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;IACnC,CAAC;IAED,yCAAyC;IACzC,WAAW,CAAC,SAAiB;QAC3B,OAAO,IAAA,0BAAiB,EAAC,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACpD,CAAC;IAED,oCAAoC;IACpC,WAAW,CAAC,SAAiB,EAAE,QAAuB;QACpD,OAAO,IAAA,0BAAiB,EAAC,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAED,4CAA4C;IAC5C,UAAU,CAAC,SAAiB,EAAE,OAAoB;QAChD,OAAO,IAAA,0BAAiB,EAAC,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,kDAAkD;IAClD,KAAK,CAAC,SAAiB;QACrB,OAAO,IAAA,oBAAY,EAAC,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAC/C,CAAC;IAED,+CAA+C;IAC/C,YAAY;QACV,OAAO,IAAA,4BAAkB,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACH,qBAAqB,CAAC,SAAiB;QACrC,OAAO,IAAA,uCAA2B,EAAC,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAC9D,CAAC;IAED,8DAA8D;IAC9D,UAAU,CAAC,SAAiB;QAC1B,OAAO,IAAI,mDAAiC,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAChE,CAAC;IAED,yEAAyE;IACzE,OAAO;QACL,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,EAAE,CAAC;QAClC,IAAI,IAAI,CAAC,UAAU;YAAE,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,CAAC;IACjD,CAAC;CACF;AAvDD,gEAuDC"}

package/dist/history/internal/append-saga.d.ts

@@ -0,0 +1,17 @@
+import type { ChatMessageItem } from '../types';
+import type { HistoryContext } from './setup';
+/** Shared per-append metadata applied to every chunk's session update. */
+export interface AppendFields {
+    now: string;
+    title?: string;
+    ttlTimestamp?: number;
+}
+/**
+ * Append message chunks with caller-observed atomicity. Each chunk commits its
+ * messages and count in one transaction; if a later chunk fails, every
+ * already-committed chunk is deleted and its count reverted, and all batch S3
+ * objects are cleaned, restoring the pre-call state before the error is
+ * rethrown. So `addMessages` either lands the whole batch or nothing.
+ */
+export declare function appendChunks(context: HistoryContext, sessionId: string, chunks: ChatMessageItem[][], fields: AppendFields): Promise<void>;
+//# sourceMappingURL=append-saga.d.ts.map

package/dist/history/internal/append-saga.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-saga.d.ts","sourceRoot":"","sources":["../../../src/history/internal/append-saga.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAwFD;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,eAAe,EAAE,EAAE,EAC3B,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,IAAI,CAAC,CAmBf"}

package/dist/history/internal/append-saga.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendChunks = appendChunks;
+const descriptor_keys_1 = require("../../shared/codec/descriptor-keys");
+const orphans_1 = require("../../shared/codec/s3/orphans");
+const batch_write_1 = require("../../shared/dynamodb/batch-write");
+const retry_1 = require("../../shared/dynamodb/retry");
+const errors_1 = require("../../shared/errors/errors");
+const wrap_error_1 = require("../../shared/errors/wrap-error");
+const keys_1 = require("./keys");
+const message_transaction_1 = require("./message-transaction");
+/** Subtract a previously-added count from the session, leaving it consistent. */
+async function revertSessionCount(context, sessionId, delta) {
+    if (delta === 0)
+        return;
+    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: 'ADD #count :neg',
+        ExpressionAttributeNames: { '#count': 'messageCount' },
+        ExpressionAttributeValues: { ':neg': -delta },
+    }));
+}
+/** Best-effort delete every offloaded S3 object uploaded for the whole batch. */
+async function cleanBatchS3(context, chunks) {
+    if (!context.offloader)
+        return;
+    const descriptors = chunks.flat().map((item) => item.message);
+    await (0, orphans_1.cleanUpS3Orphans)(context.offloader, (0, descriptor_keys_1.collectS3Keys)(descriptors), 'history.addMessages', context.logger);
+}
+/** Delete every committed chunk's items and revert their counted total. */
+async function rollbackCommitted(context, sessionId, committed) {
+    const keys = committed.flatMap((chunk) => chunk.keys);
+    if (keys.length > 0) {
+        await (0, batch_write_1.batchWriteAll)(context.client, context.tableName, keys.map((Key) => ({ DeleteRequest: { Key } })));
+    }
+    const total = committed.reduce((sum, chunk) => sum + chunk.count, 0);
+    await revertSessionCount(context, sessionId, total);
+}
+/**
+ * Undo a failed batch: warn, best-effort clean S3, then roll back committed
+ * chunks. Always throws. If the rollback itself fails the session may have
+ * drifted, so it raises {@link CompensationFailedError} carrying both the
+ * trigger and the rollback error; otherwise it rethrows the trigger.
+ */
+async function compensate(context, sessionId, chunks, committed, trigger) {
+    if (committed.length > 0) {
+        context.logger.warn('history.addMessages compensating committed chunks after a chunk failed', {
+            sessionId,
+            committedChunks: committed.length,
+        });
+    }
+    await cleanBatchS3(context, chunks);
+    try {
+        await rollbackCommitted(context, sessionId, committed);
+    }
+    catch (rollbackError) {
+        context.logger.error('history.addMessages rollback failed; messageCount may have drifted', {
+            sessionId,
+            committedChunks: committed.length,
+        });
+        throw new errors_1.CompensationFailedError(trigger, (0, wrap_error_1.toError)(rollbackError));
+    }
+    throw trigger;
+}
+/**
+ * Append message chunks with caller-observed atomicity. Each chunk commits its
+ * messages and count in one transaction; if a later chunk fails, every
+ * already-committed chunk is deleted and its count reverted, and all batch S3
+ * objects are cleaned, restoring the pre-call state before the error is
+ * rethrown. So `addMessages` either lands the whole batch or nothing.
+ */
+async function appendChunks(context, sessionId, chunks, fields) {
+    const committed = [];
+    for (const chunk of chunks) {
+        try {
+            await (0, message_transaction_1.writeMessageChunk)(context, chunk, {
+                sessionId,
+                count: chunk.length,
+                now: fields.now,
+                title: fields.title,
+                ttlTimestamp: fields.ttlTimestamp,
+            });
+            committed.push({
+                keys: chunk.map((item) => ({ PK: item.PK, SK: item.SK })),
+                count: chunk.length,
+            });
+        }
+        catch (error) {
+            await compensate(context, sessionId, chunks, committed, (0, wrap_error_1.toError)(error));
+        }
+    }
+}
+//# sourceMappingURL=append-saga.js.map

package/dist/history/internal/append-saga.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-saga.js","sourceRoot":"","sources":["../../../src/history/internal/append-saga.ts"],"names":[],"mappings":"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"}

package/dist/history/internal/item-mapper.d.ts

@@ -0,0 +1,12 @@
+import type { StoredMessage } from '@langchain/core/messages';
+import type { ChatMessageItem } from '../types';
+import type { HistoryContext } from './setup';
+/**
+ * Encode a single stored message into its DynamoDB item, keyed by the session
+ * partition and a `MSG#<ulid>` sort key. A `ttlTimestamp` stamps the uniform
+ * whole-conversation expiry shared by every message in the session.
+ */
+export declare function buildMessageItem(context: HistoryContext, sessionId: string, ulid: string, message: StoredMessage, ttlTimestamp?: number): Promise<ChatMessageItem>;
+/** Decode a single message item back into its stored message. */
+export declare function decodeMessageItem(context: HistoryContext, item: ChatMessageItem): Promise<StoredMessage>;
+//# sourceMappingURL=item-mapper.d.ts.map

package/dist/history/internal/item-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-mapper.d.ts","sourceRoot":"","sources":["../../../src/history/internal/item-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAG9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAM9C;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,aAAa,EACtB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,eAAe,CAAC,CAY1B;AAED,iEAAiE;AACjE,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,aAAa,CAAC,CAExB"}

package/dist/history/internal/item-mapper.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMessageItem = buildMessageItem;
+exports.decodeMessageItem = decodeMessageItem;
+const codec_1 = require("../../shared/codec/codec");
+const keys_1 = require("./keys");
+function codecDeps(context) {
+    return { serde: context.serde, compression: context.compression, offloader: context.offloader };
+}
+/**
+ * Encode a single stored message into its DynamoDB item, keyed by the session
+ * partition and a `MSG#<ulid>` sort key. A `ttlTimestamp` stamps the uniform
+ * whole-conversation expiry shared by every message in the session.
+ */
+async function buildMessageItem(context, sessionId, ulid, message, ttlTimestamp) {
+    const descriptor = await (0, codec_1.encodePayload)(message, codecDeps(context), {
+        keyParts: [sessionId, ulid],
+    });
+    const item = {
+        PK: (0, keys_1.sessionPartition)(sessionId),
+        SK: (0, keys_1.messageSortKey)(ulid),
+        sessionId,
+        message: descriptor,
+    };
+    if (ttlTimestamp !== undefined)
+        item.ttl = ttlTimestamp;
+    return item;
+}
+/** Decode a single message item back into its stored message. */
+async function decodeMessageItem(context, item) {
+    return (0, codec_1.decodePayload)(item.message, codecDeps(context));
+}
+//# sourceMappingURL=item-mapper.js.map

package/dist/history/internal/item-mapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-mapper.js","sourceRoot":"","sources":["../../../src/history/internal/item-mapper.ts"],"names":[],"mappings":";;AAgBA,4CAkBC;AAGD,8CAKC;AAxCD,oDAAwF;AAExF,iCAA0D;AAG1D,SAAS,SAAS,CAAC,OAAuB;IACxC,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC;AAClG,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,gBAAgB,CACpC,OAAuB,EACvB,SAAiB,EACjB,IAAY,EACZ,OAAsB,EACtB,YAAqB;IAErB,MAAM,UAAU,GAAG,MAAM,IAAA,qBAAa,EAAC,OAAO,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE;QAClE,QAAQ,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC;KAC5B,CAAC,CAAC;IACH,MAAM,IAAI,GAAoB;QAC5B,EAAE,EAAE,IAAA,uBAAgB,EAAC,SAAS,CAAC;QAC/B,EAAE,EAAE,IAAA,qBAAc,EAAC,IAAI,CAAC;QACxB,SAAS;QACT,OAAO,EAAE,UAAU;KACpB,CAAC;IACF,IAAI,YAAY,KAAK,SAAS;QAAE,IAAI,CAAC,GAAG,GAAG,YAAY,CAAC;IACxD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,iEAAiE;AAC1D,KAAK,UAAU,iBAAiB,CACrC,OAAuB,EACvB,IAAqB;IAErB,OAAO,IAAA,qBAAa,EAAgB,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;AACxE,CAAC"}

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

@@ -0,0 +1,9 @@
+/** Fixed sort key for the per-session metadata item. */
+export declare const SESSION_SORT_KEY = "SESSION";
+/** Partition key for a chat session: the session id itself. */
+export declare function sessionPartition(sessionId: string): string;
+/** Sort key for a single message item, ordered by its monotonic ULID. */
+export declare function messageSortKey(ulid: string): string;
+/** `begins_with` prefix selecting every message item in a session. */
+export declare function messageSortKeyPrefix(): string;
+//# sourceMappingURL=keys.d.ts.map

package/dist/history/internal/keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../src/history/internal/keys.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAI1C,+DAA+D;AAC/D,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,sEAAsE;AACtE,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C"}

package/dist/history/internal/keys.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_SORT_KEY = void 0;
+exports.sessionPartition = sessionPartition;
+exports.messageSortKey = messageSortKey;
+exports.messageSortKeyPrefix = messageSortKeyPrefix;
+/** Fixed sort key for the per-session metadata item. */
+exports.SESSION_SORT_KEY = 'SESSION';
+const MESSAGE_PREFIX = 'MSG#';
+/** Partition key for a chat session: the session id itself. */
+function sessionPartition(sessionId) {
+    return sessionId;
+}
+/** Sort key for a single message item, ordered by its monotonic ULID. */
+function messageSortKey(ulid) {
+    return `${MESSAGE_PREFIX}${ulid}`;
+}
+/** `begins_with` prefix selecting every message item in a session. */
+function messageSortKeyPrefix() {
+    return MESSAGE_PREFIX;
+}
+//# sourceMappingURL=keys.js.map

package/dist/history/internal/keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.js","sourceRoot":"","sources":["../../../src/history/internal/keys.ts"],"names":[],"mappings":";;;AAMA,4CAEC;AAGD,wCAEC;AAGD,oDAEC;AAlBD,wDAAwD;AAC3C,QAAA,gBAAgB,GAAG,SAAS,CAAC;AAE1C,MAAM,cAAc,GAAG,MAAM,CAAC;AAE9B,+DAA+D;AAC/D,SAAgB,gBAAgB,CAAC,SAAiB;IAChD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,yEAAyE;AACzE,SAAgB,cAAc,CAAC,IAAY;IACzC,OAAO,GAAG,cAAc,GAAG,IAAI,EAAE,CAAC;AACpC,CAAC;AAED,sEAAsE;AACtE,SAAgB,oBAAoB;IAClC,OAAO,cAAc,CAAC;AACxB,CAAC"}

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

@@ -0,0 +1,14 @@
+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[][];
+//# sourceMappingURL=message-chunker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"message-chunker.d.ts","sourceRoot":"","sources":["../../../src/history/internal/message-chunker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAmBhD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAQ/D;AAaD;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,eAAe,EAAE,EACxB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,eAAe,EAAE,EAAE,CAgBrB"}

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

@@ -0,0 +1,60 @@
+"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;
+function descriptorBytes(descriptor) {
+    const body = descriptor.location === codec_1.PayloadLocation.INLINE
+        ? descriptor.bytes.length
+        : descriptor.s3Key.length;
+    return body + descriptor.serdeType.length;
+}
+/**
+ * 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 (item.PK.length +
+        item.SK.length +
+        item.sessionId.length +
+        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;
+}
+//# sourceMappingURL=message-chunker.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"message-chunker.js","sourceRoot":"","sources":["../../../src/history/internal/message-chunker.ts"],"names":[],"mappings":";;AAyBA,8CAQC;AAkBD,kCAoBC;AAvED,oDAAmF;AAGnF;;;;;;GAMG;AACH,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEhC,SAAS,eAAe,CAAC,UAA6B;IACpD,MAAM,IAAI,GACR,UAAU,CAAC,QAAQ,KAAK,uBAAe,CAAC,MAAM;QAC5C,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,MAAM;QACzB,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC;IAC9B,OAAO,IAAI,GAAG,UAAU,CAAC,SAAS,CAAC,MAAM,CAAC;AAC5C,CAAC;AAED;;;;GAIG;AACH,SAAgB,iBAAiB,CAAC,IAAqB;IACrD,OAAO,CACL,IAAI,CAAC,EAAE,CAAC,MAAM;QACd,IAAI,CAAC,EAAE,CAAC,MAAM;QACd,IAAI,CAAC,SAAS,CAAC,MAAM;QACrB,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC;QAC7B,mBAAmB,CACpB,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAClB,KAAa,EACb,KAAa,EACb,IAAY,EACZ,GAAW,EACX,QAAgB;IAEhB,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC9B,OAAO,KAAK,IAAI,GAAG,IAAI,KAAK,GAAG,IAAI,GAAG,QAAQ,CAAC;AACjD,CAAC;AAED;;;;GAIG;AACH,SAAgB,WAAW,CACzB,KAAwB,EACxB,QAAgB,EAChB,QAAgB;IAEhB,MAAM,MAAM,GAAwB,EAAE,CAAC;IACvC,IAAI,OAAO,GAAsB,EAAE,CAAC;IACpC,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC;YACxE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrB,OAAO,GAAG,EAAE,CAAC;YACb,YAAY,GAAG,CAAC,CAAC;QACnB,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnB,YAAY,IAAI,IAAI,CAAC;IACvB,CAAC;IACD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;QAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7C,OAAO,MAAM,CAAC;AAChB,CAAC"}

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

@@ -0,0 +1,17 @@
+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 reused across retries so a re-sent commit (e.g.
+ * after a lost response) is idempotent and never double-applies the count `ADD`.
+ */
+export declare function writeMessageChunk(context: HistoryContext, items: ChatMessageItem[], fields: SessionUpdateFields, retry?: ChunkRetryOptions): Promise<void>;
+//# sourceMappingURL=message-transaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"message-transaction.d.ts","sourceRoot":"","sources":["../../../src/history/internal/message-transaction.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACpF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,wEAAwE;AACxE,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,eAAe,EAAE,EACxB,MAAM,EAAE,mBAAmB,EAC3B,KAAK,GAAE,iBAAsB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAYf"}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeMessageChunk = writeMessageChunk;
+const node_crypto_1 = require("node:crypto");
+const retry_1 = require("../../shared/dynamodb/retry");
+const session_update_1 = require("./session-update");
+/**
+ * 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 reused across retries so a re-sent commit (e.g.
+ * after a lost response) is idempotent and never double-applies the count `ADD`.
+ */
+async function writeMessageChunk(context, items, fields, retry = {}) {
+    const input = {
+        TransactItems: [
+            (0, session_update_1.buildSessionUpdateItem)(context.tableName, fields),
+            ...items.map((item) => ({ Put: { TableName: context.tableName, Item: item } })),
+        ],
+        ClientRequestToken: (0, node_crypto_1.randomUUID)(),
+    };
+    await (0, retry_1.withDynamoDBRetry)(() => context.client.transactWrite(input), {
+        rng: retry.rng,
+        signal: retry.signal,
+    });
+}
+//# sourceMappingURL=message-transaction.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"message-transaction.js","sourceRoot":"","sources":["../../../src/history/internal/message-transaction.ts"],"names":[],"mappings":";;AAoBA,8CAiBC;AArCD,6CAAyC;AAEzC,uDAAgE;AAEhE,qDAAoF;AASpF;;;;;;GAMG;AACI,KAAK,UAAU,iBAAiB,CACrC,OAAuB,EACvB,KAAwB,EACxB,MAA2B,EAC3B,QAA2B,EAAE;IAE7B,MAAM,KAAK,GAAG;QACZ,aAAa,EAAE;YACb,IAAA,uCAAsB,EAAC,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC;YACjD,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;SAChF;QACD,kBAAkB,EAAE,IAAA,wBAAU,GAAE;KACjC,CAAC;IACF,MAAM,IAAA,yBAAiB,EAAC,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE;QACjE,GAAG,EAAE,KAAK,CAAC,GAAG;QACd,MAAM,EAAE,KAAK,CAAC,MAAM;KACrB,CAAC,CAAC;AACL,CAAC"}

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

@@ -0,0 +1,6 @@
+import type { QueryCommandInput } from '@aws-sdk/lib-dynamodb';
+/** Query input selecting every item in a session's partition (messages + metadata). */
+export declare function sessionItemsQuery(tableName: string, sessionId: string): QueryCommandInput;
+/** Query input selecting a session's message items in chronological order. */
+export declare function messageQuery(tableName: string, sessionId: string): QueryCommandInput;
+//# sourceMappingURL=query.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/history/internal/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAI/D,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,iBAAiB,CAOzF;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,iBAAiB,CAWpF"}

package/dist/history/internal/query.js

@@ -0,0 +1,28 @@
+"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) {
+    return {
+        TableName: tableName,
+        KeyConditionExpression: '#pk = :pk',
+        ExpressionAttributeNames: { '#pk': 'PK' },
+        ExpressionAttributeValues: { ':pk': (0, keys_1.sessionPartition)(sessionId) },
+    };
+}
+/** Query input selecting a session's message items in chronological order. */
+function messageQuery(tableName, sessionId) {
+    return {
+        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: true,
+    };
+}
+//# sourceMappingURL=query.js.map

package/dist/history/internal/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../../../src/history/internal/query.ts"],"names":[],"mappings":";;AAKA,8CAOC;AAGD,oCAWC;AAxBD,iCAAgE;AAEhE,uFAAuF;AACvF,SAAgB,iBAAiB,CAAC,SAAiB,EAAE,SAAiB;IACpE,OAAO;QACL,SAAS,EAAE,SAAS;QACpB,sBAAsB,EAAE,WAAW;QACnC,wBAAwB,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;QACzC,yBAAyB,EAAE,EAAE,KAAK,EAAE,IAAA,uBAAgB,EAAC,SAAS,CAAC,EAAE;KAClE,CAAC;AACJ,CAAC;AAED,8EAA8E;AAC9E,SAAgB,YAAY,CAAC,SAAiB,EAAE,SAAiB;IAC/D,OAAO;QACL,SAAS,EAAE,SAAS;QACpB,sBAAsB,EAAE,sCAAsC;QAC9D,wBAAwB,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE;QACtD,yBAAyB,EAAE;YACzB,KAAK,EAAE,IAAA,uBAAgB,EAAC,SAAS,CAAC;YAClC,MAAM,EAAE,IAAA,2BAAoB,GAAE;SAC/B;QACD,gBAAgB,EAAE,IAAI;KACvB,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,20 @@
+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;
+}
+/**
+ * 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.
+ */
+export declare function buildSessionUpdateItem(tableName: string, fields: SessionUpdateFields): HistoryTransactItem;
+//# sourceMappingURL=session-update.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-update.d.ts","sourceRoot":"","sources":["../../../src/history/internal/session-update.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAwB,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAI7F,8EAA8E;AAC9E,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,yBAAyB,CAAC,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAElG,oFAAoF;AACpF,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,mBAAmB,GAC1B,mBAAmB,CAiCrB"}