@guuey/threads 0.31.0 → 0.32.0

package/dist/in-memory.js

@@ -1,3 +1,11 @@
+/**
+ * InMemoryThreadPersistence — the dev/test binding of
+ * {@link ThreadPersistencePort}. Same contract as any real binding (run
+ * the suite in `@guuey/threads/testing` to prove yours), including the
+ * two conditional-write guards and the null-preview no-touch semantics.
+ */
+import { previewDigest } from "./seal.js";
+import { ThreadClosedError, threadClosure } from "./closed.js";
 export class InMemoryThreadPersistence {
     threads = new Map();
     messages = [];
@@ -15,15 +23,33 @@ export class InMemoryThreadPersistence {
         const t = this.threads.get(threadId);
         if (!t)
             throw new Error(`incrementSeq: thread ${threadId} does not exist`);
+        if (threadClosure(t) !== undefined)
+            throw new ThreadClosedError(threadId);
         t.lastSeq += 1;
         t.lastMessageAt = atIso;
         t.updatedAt = atIso;
         // null = allocate the seq WITHOUT touching the preview (card rows,
         // text-less agent turns) — mirror of the hosted binding's branch.
-        if (preview !== null)
+        if (preview !== null) {
             t.lastMessagePreview = preview;
+            // The preview's source seq and digest ride the same update, so a reader
+            // can tell whether the message the preview came from is sealed (`seal.ts`).
+            t.lastMessagePreviewSeq = t.lastSeq;
+            t.lastMessagePreviewDigest = previewDigest(preview);
+        }
         return t.lastSeq;
     }
+    async closeThread(threadId, closure) {
+        const t = this.threads.get(threadId);
+        if (!t)
+            throw new Error(`closeThread: thread ${threadId} does not exist`);
+        if (threadClosure(t) !== undefined)
+            return "already_closed";
+        t.closedCode = closure.code;
+        t.closedMessage = closure.message;
+        t.closedAt = closure.at;
+        return "closed";
+    }
     async putMessage(row) {
         if (this.messages.some((m) => m.threadId === row.threadId && m.seq === row.seq)) {
             throw new Error(`putMessage: seq ${row.seq} already exists on ${row.threadId}`);

package/dist/index.d.ts

@@ -17,10 +17,16 @@
  *   - `@guuey/threads/testing` — the port contract suite: run it against
  *     your binding for the same guarantees the hosted one carries.
  */
-export type { HandoffEvent, ReportEvent, StoredHistoryMessage, ThreadMessageEvent, ThreadMessageKind, ThreadMessageRole, ThreadMessageRow, ThreadPersistencePort, ThreadRow, ThreadSnapshotRow, TurnOrigin, ClientClass, } from "./rows.js";
-export { ThreadStore, type AppendFoldInput, type AppendFoldResult, type AppendMessageInput, type AppendMessageResult, type EnsureThreadInput, } from "./store.js";
+export type { HandoffEvent, ReportEvent, SealInterval, StoredHistoryMessage, ThreadMessageEvent, ThreadMessageKind, ThreadMessageRole, RowBudget, ThreadClosure, ThreadMessageRow, ThreadPersistencePort, ThreadRow, ThreadSnapshotRow, TurnOrigin, ClientClass, ThreadInputKind, } from "./rows.js";
+export { THREAD_INPUT_KINDS, readThreadInputKind } from "./rows.js";
+export { DYNAMODB_ITEM_LIMIT_BYTES, DYNAMODB_ROW_BUDGET, DYNAMODB_ROW_BUDGET_BYTES, dynamoItemBytes, dynamoNumberFits, } from "./item-size.js";
+export { ThreadStore, STORED_TURN_TOO_LARGE_CODE, STORED_TURN_UNSTORABLE_NUMBER_CODE, type AppendFoldInput, type AppendFoldUnstorable, type AppendFoldResult, type ElidedToolInput, type AppendMessageInput, type AppendMessageResult, type EnsureThreadInput, } from "./store.js";
 export { InMemoryThreadPersistence } from "./in-memory.js";
-export { AGENT_ERROR_ROW_SUFFIX, classifyStoredRow, isBlankBlock, isInformationless, type StoredRowClass, } from "./stored-row.js";
+export { ThreadClosedError, threadClosure } from "./closed.js";
+export { hasSealedPart, isSeqSealed, previewDigest, readableThreadPreview, readSealState, threadSealState, type StoredPreviewSlice, type ThreadSealState, } from "./seal.js";
+export { AGENT_ERROR_ROW_SUFFIX, classifyStoredRow, type ClassifiedRowInput, isBlankBlock, isInformationless, type StoredRowClass, } from "./stored-row.js";
 export { HttpThreadPersistence, HttpThreadStoreError, type HttpThreadPersistenceOptions, type ThreadScope, } from "./http.js";
-export { agArtifactToCardRow, agMessageToRow, cardRowToAgArtifact, messageFullText, messageNarration, messageText, producingToolName, storedTextParts, type StoredTextParts, joinStoredThreadMemory, reassembleFold, rowToAgMessage, seedEventsForReducer, splitStoredThreadMemory, toolNamesByCallId, uiCardArtifactsFromMessages, type RowCtx, } from "./fold-rows.js";
+export { planSnapshot, type PlanSnapshotInput, type PlannedSnapshot, type SnapshotRefusal, type SnapshotRefusalReason, } from "./snapshot-plan.js";
+export { agArtifactToCardRow, agMessageToBoundedRow, agMessageToRow, assertRowFits, cardUiDataByCallId, type CardUiData, type CardUiDataByCallId, ELIDED_VALUE_KEY, isStoredRowRefusal, StoredRowTooLargeError, StoredRowUnstorableNumberError, type ElidedField, type ElisionReason, type RefusedRowKind, type StoredElision, type StoredRowRefusal, cardRowToAgArtifact, messageFullText, messageNarration, messageText, producingToolName, storedTextParts, storedToolCallViews, storedToolResultCallIds, storedToolResults, toolResultCarriesUi, type StoredToolCallView, type StoredToolResultBlock, type StoredRowText, type StoredTextParts, joinStoredThreadMemory, reassembleFold, rowToAgMessage, seedEventsForReducer, splitStoredThreadMemory, toolNamesByCallId, uiCardArtifactsFromMessages, type RowCtx, } from "./fold-rows.js";
+export { isViewDirectiveText, latestPaintProps, paintPartsOfStored, QUICK_REPLY_INTENT, quickReplyLabel, readTapLabels, writeTapLabels, type CardPaint, type CardProps, type LatestPaint, type PaintPart, type TapLabels, } from "@guuey/mcp-apps-host/narrowing";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,YAAY,EACV,YAAY,EACZ,WAAW,EACX,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,EACrB,SAAS,EACT,iBAAiB,EACjB,UAAU,EACV,WAAW,GACZ,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,WAAW,EACX,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,GACvB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,YAAY,EACZ,iBAAiB,EACjB,KAAK,cAAc,GACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,KAAK,4BAA4B,EACjC,KAAK,WAAW,GACjB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,KAAK,eAAe,EACpB,sBAAsB,EACtB,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,EACjB,2BAA2B,EAC3B,KAAK,MAAM,GACZ,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,YAAY,EACV,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,qBAAqB,EACrB,SAAS,EACT,iBAAiB,EACjB,UAAU,EACV,WAAW,EACX,eAAe,GAChB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACpE,OAAO,EACL,yBAAyB,EACzB,mBAAmB,EACnB,yBAAyB,EACzB,eAAe,EACf,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,WAAW,EACX,0BAA0B,EAC1B,kCAAkC,EAClC,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,GACvB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EACL,aAAa,EACb,WAAW,EACX,aAAa,EACb,qBAAqB,EACrB,aAAa,EACb,eAAe,EACf,KAAK,kBAAkB,EACvB,KAAK,eAAe,GACrB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,KAAK,kBAAkB,EACvB,YAAY,EACZ,iBAAiB,EACjB,KAAK,cAAc,GACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,KAAK,4BAA4B,EACjC,KAAK,WAAW,GACjB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,YAAY,EACZ,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,qBAAqB,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,gBAAgB,EAChB,kBAAkB,EAClB,sBAAsB,EACtB,8BAA8B,EAC9B,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,sBAAsB,EACtB,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,EACjB,2BAA2B,EAC3B,KAAK,MAAM,GACZ,MAAM,gBAAgB,CAAC;AAOxB,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,aAAa,EACb,cAAc,EACd,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,SAAS,GACf,MAAM,gCAAgC,CAAC"}

package/dist/index.js

@@ -1,5 +1,17 @@
-export { ThreadStore, } from "./store.js";
+export { THREAD_INPUT_KINDS, readThreadInputKind } from "./rows.js";
+export { DYNAMODB_ITEM_LIMIT_BYTES, DYNAMODB_ROW_BUDGET, DYNAMODB_ROW_BUDGET_BYTES, dynamoItemBytes, dynamoNumberFits, } from "./item-size.js";
+export { ThreadStore, STORED_TURN_TOO_LARGE_CODE, STORED_TURN_UNSTORABLE_NUMBER_CODE, } from "./store.js";
 export { InMemoryThreadPersistence } from "./in-memory.js";
+export { ThreadClosedError, threadClosure } from "./closed.js";
+export { hasSealedPart, isSeqSealed, previewDigest, readableThreadPreview, readSealState, threadSealState, } from "./seal.js";
 export { AGENT_ERROR_ROW_SUFFIX, classifyStoredRow, isBlankBlock, isInformationless, } from "./stored-row.js";
 export { HttpThreadPersistence, HttpThreadStoreError, } from "./http.js";
-export { agArtifactToCardRow, agMessageToRow, cardRowToAgArtifact, messageFullText, messageNarration, messageText, producingToolName, storedTextParts, joinStoredThreadMemory, reassembleFold, rowToAgMessage, seedEventsForReducer, splitStoredThreadMemory, toolNamesByCallId, uiCardArtifactsFromMessages, } from "./fold-rows.js";
+export { planSnapshot, } from "./snapshot-plan.js";
+export { agArtifactToCardRow, agMessageToBoundedRow, agMessageToRow, assertRowFits, cardUiDataByCallId, ELIDED_VALUE_KEY, isStoredRowRefusal, StoredRowTooLargeError, StoredRowUnstorableNumberError, cardRowToAgArtifact, messageFullText, messageNarration, messageText, producingToolName, storedTextParts, storedToolCallViews, storedToolResultCallIds, storedToolResults, toolResultCarriesUi, joinStoredThreadMemory, reassembleFold, rowToAgMessage, seedEventsForReducer, splitStoredThreadMemory, toolNamesByCallId, uiCardArtifactsFromMessages, } from "./fold-rows.js";
+// guuey#2031 — the card-tap contract, re-exported for the persistence side (the
+// runtime stamps a user row's tap labels; the read plane forwards them) so a
+// server imports it from the package it already uses. The names live in
+// `@guuey/mcp-apps-host`'s protocol-free subpath: the writer and the reader of a
+// row's `tapLabels`, the one directive predicate, and the one paint reducer the
+// runtime reads a tapped card with, with the quick-reply intent it labels under.
+export { isViewDirectiveText, latestPaintProps, paintPartsOfStored, QUICK_REPLY_INTENT, quickReplyLabel, readTapLabels, writeTapLabels, } from "@guuey/mcp-apps-host/narrowing";

package/dist/item-size.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The size of a stored row as DynamoDB counts it, so a binding backed by
+ * DynamoDB can declare a {@link RowBudget} that matches the store's own item
+ * limit (400 KB).
+ *
+ * The count follows the published rules (DynamoDB Developer Guide, "Item
+ * sizes and formats"), walked over the row the way the DocumentClient
+ * marshals it (string → S, number → N, boolean → BOOL, null → NULL,
+ * array → L, object → M, `undefined` dropped):
+ *
+ * - a string is its UTF-8 bytes;
+ * - a boolean or null is 1 byte;
+ * - a number is published as 1 byte per two significant digits, plus 1. As
+ *   measured against DynamoDB it is 1 exponent byte, plus the digits in pairs
+ *   aligned on the decimal point (so up to half a pair more than the digits
+ *   alone), plus 1 more byte when the number is negative: -1.5 is 4 bytes and
+ *   -123.456 is 6. It is bounded here from above as half of ALL the digits in
+ *   `String(n)`, rounded up, plus 3, so an exponent form can only over-count;
+ * - a List or Map is 3 bytes, plus 1 byte per element, plus each Map key's
+ *   UTF-8 bytes and each element's own size;
+ * - a top-level attribute is its name's UTF-8 bytes plus its value, plus 1.
+ *
+ * The result is an UPPER bound on the stored size: it may count a little
+ * more than DynamoDB does, never less.
+ *
+ * Why not the length of the row's JSON: JSON under-counts the shapes a chart
+ * input is made of. A list of one-digit numbers costs 2 bytes per element as
+ * JSON (`1,`) and 3 by the rules above; pairs (`[1,2],`) cost 6 against 10.
+ * A row measured as 380 KB of JSON could be about 630 KB in DynamoDB.
+ */
+import type { RowBudget } from "./rows.js";
+/** DynamoDB's maximum item size: 400 KB. */
+export declare const DYNAMODB_ITEM_LIMIT_BYTES = 409600;
+/**
+ * The row budget a DynamoDB-backed binding declares: below the item limit,
+ * so the seq and timestamp the store assigns at write time, and the bound's
+ * own rounding, can never carry a row that fit over the limit.
+ */
+export declare const DYNAMODB_ROW_BUDGET_BYTES = 380000;
+/**
+ * Whether a DynamoDB-backed binding can store `n` as written. The
+ * DocumentClient refuses a number outside the safe-integer range, and NaN or
+ * an infinity, before it sends anything (a JSON number that large has already
+ * lost its digits to `JSON.parse`); DynamoDB itself refuses a non-zero
+ * magnitude below 1e-130. A row carrying such a number would fail its write
+ * whatever its size, so it is planned out like an oversized one.
+ */
+export declare function dynamoNumberFits(n: number): boolean;
+/** The row budget every DynamoDB-backed binding declares. */
+export declare const DYNAMODB_ROW_BUDGET: RowBudget;
+/**
+ * The stored size of an item (a `ThreadMessage` row, or any attribute bag the
+ * DocumentClient marshals), as an upper bound under DynamoDB's own rules.
+ */
+export declare function dynamoItemBytes(item: object): number;
+//# sourceMappingURL=item-size.d.ts.map

package/dist/item-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-size.d.ts","sourceRoot":"","sources":["../src/item-size.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,4CAA4C;AAC5C,eAAO,MAAM,yBAAyB,SAAU,CAAC;AAEjD;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,SAAU,CAAC;AAKjD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAInD;AAED,6DAA6D;AAC7D,eAAO,MAAM,mBAAmB,EAAE,SAIjC,CAAC;AAsDF;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOpD"}

package/dist/item-size.js

@@ -0,0 +1,125 @@
+/**
+ * The size of a stored row as DynamoDB counts it, so a binding backed by
+ * DynamoDB can declare a {@link RowBudget} that matches the store's own item
+ * limit (400 KB).
+ *
+ * The count follows the published rules (DynamoDB Developer Guide, "Item
+ * sizes and formats"), walked over the row the way the DocumentClient
+ * marshals it (string → S, number → N, boolean → BOOL, null → NULL,
+ * array → L, object → M, `undefined` dropped):
+ *
+ * - a string is its UTF-8 bytes;
+ * - a boolean or null is 1 byte;
+ * - a number is published as 1 byte per two significant digits, plus 1. As
+ *   measured against DynamoDB it is 1 exponent byte, plus the digits in pairs
+ *   aligned on the decimal point (so up to half a pair more than the digits
+ *   alone), plus 1 more byte when the number is negative: -1.5 is 4 bytes and
+ *   -123.456 is 6. It is bounded here from above as half of ALL the digits in
+ *   `String(n)`, rounded up, plus 3, so an exponent form can only over-count;
+ * - a List or Map is 3 bytes, plus 1 byte per element, plus each Map key's
+ *   UTF-8 bytes and each element's own size;
+ * - a top-level attribute is its name's UTF-8 bytes plus its value, plus 1.
+ *
+ * The result is an UPPER bound on the stored size: it may count a little
+ * more than DynamoDB does, never less.
+ *
+ * Why not the length of the row's JSON: JSON under-counts the shapes a chart
+ * input is made of. A list of one-digit numbers costs 2 bytes per element as
+ * JSON (`1,`) and 3 by the rules above; pairs (`[1,2],`) cost 6 against 10.
+ * A row measured as 380 KB of JSON could be about 630 KB in DynamoDB.
+ */
+/** DynamoDB's maximum item size: 400 KB. */
+export const DYNAMODB_ITEM_LIMIT_BYTES = 409_600;
+/**
+ * The row budget a DynamoDB-backed binding declares: below the item limit,
+ * so the seq and timestamp the store assigns at write time, and the bound's
+ * own rounding, can never carry a row that fit over the limit.
+ */
+export const DYNAMODB_ROW_BUDGET_BYTES = 380_000;
+/** The smallest non-zero magnitude DynamoDB stores; below it a write is refused as an underflow. */
+const DYNAMODB_MIN_NUMBER_MAGNITUDE = 1e-130;
+/**
+ * Whether a DynamoDB-backed binding can store `n` as written. The
+ * DocumentClient refuses a number outside the safe-integer range, and NaN or
+ * an infinity, before it sends anything (a JSON number that large has already
+ * lost its digits to `JSON.parse`); DynamoDB itself refuses a non-zero
+ * magnitude below 1e-130. A row carrying such a number would fail its write
+ * whatever its size, so it is planned out like an oversized one.
+ */
+export function dynamoNumberFits(n) {
+    if (!Number.isFinite(n))
+        return false;
+    const magnitude = Math.abs(n);
+    return magnitude === 0 || (magnitude >= DYNAMODB_MIN_NUMBER_MAGNITUDE && magnitude <= Number.MAX_SAFE_INTEGER);
+}
+/** The row budget every DynamoDB-backed binding declares. */
+export const DYNAMODB_ROW_BUDGET = {
+    maxBytes: DYNAMODB_ROW_BUDGET_BYTES,
+    bytesOf: dynamoItemBytes,
+    numberFits: dynamoNumberFits,
+};
+const LIST_OR_MAP_OVERHEAD = 3;
+const ELEMENT_OVERHEAD = 1;
+function utf8Bytes(s) {
+    return Buffer.byteLength(s, "utf8");
+}
+function numberBytes(n) {
+    let digits = 0;
+    for (const ch of String(n)) {
+        if (ch >= "0" && ch <= "9")
+            digits++;
+    }
+    // + 1 exponent byte, + 1 for a pair split by the decimal point, + 1 for a negative's terminator.
+    return Math.ceil(digits / 2) + 3;
+}
+/**
+ * The stored size of one attribute VALUE. `undefined` values are dropped by
+ * the marshaller, so they cost nothing and their element overhead is not
+ * counted either.
+ */
+function valueBytes(value) {
+    if (value === null)
+        return 1;
+    switch (typeof value) {
+        case "string":
+            return utf8Bytes(value);
+        case "number":
+            return numberBytes(value);
+        case "boolean":
+            return 1;
+        case "object": {
+            let total = LIST_OR_MAP_OVERHEAD;
+            if (Array.isArray(value)) {
+                for (const el of value) {
+                    if (el === undefined)
+                        continue;
+                    total += ELEMENT_OVERHEAD + valueBytes(el);
+                }
+                return total;
+            }
+            for (const [key, el] of Object.entries(value)) {
+                if (el === undefined)
+                    continue;
+                total += ELEMENT_OVERHEAD + utf8Bytes(key) + valueBytes(el);
+            }
+            return total;
+        }
+        default:
+            // undefined (dropped by the marshaller); functions, symbols and bigints
+            // never reach a stored row.
+            return 0;
+    }
+}
+/**
+ * The stored size of an item (a `ThreadMessage` row, or any attribute bag the
+ * DocumentClient marshals), as an upper bound under DynamoDB's own rules.
+ */
+export function dynamoItemBytes(item) {
+    let total = 0;
+    for (const [name, value] of Object.entries(item)) {
+        if (value === undefined)
+            continue;
+        total += utf8Bytes(name) + valueBytes(value) + 1;
+    }
+    return total;
+}

package/dist/rows.d.ts

@@ -10,6 +10,19 @@
  * thing" are the same mechanical guarantee — the `@guuey/state` pattern.
  */
 import type { AgMemoryRecord, JsonValue } from "@silverprotocol/core";
+import type { TapLabels } from "@guuey/mcp-apps-host/narrowing";
+/**
+ * guuey#2549: what a user turn's content rides on when its text is empty. Mirrors `@guuey/worker`'s
+ * `INPUT_KINDS` (this package does not depend on it); nocode-runtime's sync test pins them equal.
+ */
+export declare const THREAD_INPUT_KINDS: readonly ["context-only"];
+export type ThreadInputKind = (typeof THREAD_INPUT_KINDS)[number];
+/**
+ * The reader contract for a stored row's `inputKind`: a known kind, or
+ * undefined for anything else (absent, malformed, a kind this release does not
+ * know). Never throws: a stored row is read across a rolling release.
+ */
+export declare function readThreadInputKind(raw: unknown): ThreadInputKind | undefined;
 export type ThreadMessageRole = "user" | "agent" | "system";
 export type ThreadMessageKind = "text" | "card" | "event";
 /**
@@ -38,10 +51,65 @@ export interface ThreadRow {
     lastSeq: number;
     lastMessageAt: string;
     lastMessagePreview: string;
+    /**
+     * The seq of the message {@link lastMessagePreview} was taken from, written
+     * in the same atomic update. Optional: rows an older writer wrote carry
+     * none, and a reader treats that as "source unknown" (`readableThreadPreview`, `seal.ts`).
+     */
+    lastMessagePreviewSeq?: number;
+    /**
+     * `previewDigest(lastMessagePreview)` (`seal.ts`), written in the same update
+     * as the preview and its seq. It binds the seq to the text, so a preview an
+     * older writer replaced (leaving the previous seq) reads as "source unknown".
+     */
+    lastMessagePreviewDigest?: string;
+    /**
+     * The thread's seal intervals: the messages the app's operator may not
+     * read. Absent on every thread no seal was ever written for (a legacy,
+     * wholly readable thread). Read only through `readSealState` (`seal.ts`),
+     * never trusted as stored.
+     *
+     * Typed as stored, not as {@link SealInterval}[]: a binding hands the stored
+     * attribute on unchanged, and one this release cannot read must still reach
+     * `readSealState`, which reads it as wholly sealed (fail closed). A writer
+     * writes {@link SealInterval}[]; a reader gets intervals only from
+     * `readSealState` / `threadSealState`.
+     */
+    sealIntervals?: unknown;
+    /**
+     * The conversation was ended for a reason (a worker asked for it, e.g. a
+     * per-conversation limit): it takes no new message, and a client that sends
+     * on it starts a new conversation. All three are written together, once,
+     * and never cleared. `closedCode` is the machine-readable reason (a
+     * worker's code arrives prefixed `app:`), `closedMessage` what the person
+     * reads, `closedAt` when (ISO). Absent on every open thread and on every
+     * row written before closing existed. Read through `threadClosure`
+     * (`closed.ts`). Separate from {@link status}: an archived thread may also
+     * be closed.
+     */
+    closedCode?: string;
+    closedMessage?: string;
+    closedAt?: string;
     threadMode: string;
     createdAt: string;
     updatedAt: string;
 }
+/** Why and when a conversation was ended (see {@link ThreadRow.closedAt}). */
+export interface ThreadClosure {
+    code: string;
+    message: string;
+    /** ISO timestamp. */
+    at: string;
+}
+/**
+ * One sealed stretch of a thread: the messages from `fromSeq` to `toSeq`, both
+ * inclusive. No `toSeq` means the interval is still open, so it also covers
+ * every message written after `fromSeq`.
+ */
+export interface SealInterval {
+    fromSeq: number;
+    toSeq?: number;
+}
 /**
  * The human-handoff event payload (guuey#552 §3.2): the MACHINE half of a
  * `kind:'event'` handoff row — the notify Lambda's stream filter reads
@@ -132,10 +200,25 @@ export interface ThreadMessageRow {
     event?: ThreadMessageEvent;
     /** On a user row: how the turn was started. Absent on older rows. */
     turnOrigin?: TurnOrigin;
+    /**
+     * guuey#2549: set on a user row whose `text` is empty because the turn's content rode on the
+     * page context (`'context-only'`). The history replays it through the worker's one substitution,
+     * so the model sees the same words on every later turn. Absent on every other row.
+     */
+    inputKind?: ThreadInputKind;
     /** On a `card_action` user row: the render session id of the card the gesture answered. */
     answeredCardSessionId?: string;
     /** On a user row: the sending client's class. Absent on older rows. */
     clientClass?: ClientClass;
+    /**
+     * On a card-action user row (guuey#2031): the tapped controls' own words,
+     * one entry per tap the row stands for (`null` for a tap with none), as the
+     * sending client resolved them. DISPLAY-ONLY: `text` and `content` stay the
+     * directive the doorbell sent, and no model path reads this. Absent on rows
+     * written before it existed and on every row whose turn had no labels;
+     * readers read it through the reader contract (`readTapLabels`).
+     */
+    tapLabels?: TapLabels;
 }
 /** Latest-replace fold snapshot for a thread. */
 export interface ThreadSnapshotRow {
@@ -169,6 +252,25 @@ export interface StoredHistoryMessage {
     text: string | null;
     content: unknown;
     at: string;
+    /** guuey#2549: carried from the row (see {@link ThreadMessageRow.inputKind}). */
+    inputKind?: ThreadInputKind;
+}
+/**
+ * A bound on the size of one stored `ThreadMessage` row, declared by a
+ * binding whose store has an item-size limit. `bytesOf` measures a row the
+ * way the store counts it; `maxBytes` is the most a row may measure. The
+ * thread's snapshot row is planned against the same budget before a turn
+ * writes any row (guuey#2120), so `bytesOf` measures a {@link ThreadSnapshotRow}
+ * too (its stored form joins the two memory arrays into one, which is never
+ * larger).
+ * `numberFits`, when declared, says whether the store can hold a number as
+ * written; a row carrying one it cannot is refused like an oversized row.
+ * DynamoDB-backed bindings declare `DYNAMODB_ROW_BUDGET` (`item-size.ts`).
+ */
+export interface RowBudget {
+    readonly maxBytes: number;
+    bytesOf(row: ThreadMessageRow | ThreadSnapshotRow): number;
+    numberFits?(n: number): boolean;
 }
 /**
  * The only surface {@link ThreadStore} needs from a backing store. Keep
@@ -176,6 +278,14 @@ export interface StoredHistoryMessage {
  * `@guuey/threads/testing`.
  */
 export interface ThreadPersistencePort {
+    /**
+     * The store's bound on one message row, when it has one. {@link ThreadStore}
+     * sizes every row of a turn against it before it writes any: an oversized
+     * tool-call input is replaced by an explicit marker, and a turn that still
+     * cannot fit is stored as one failure row (or refused), never written in
+     * part. Absent: no bound, and rows are written exactly as mapped.
+     */
+    readonly rowBudget?: RowBudget;
     /** Point-read a Thread by id; `undefined` when the row does not exist. */
     getThread(threadId: string): Promise<ThreadRow | undefined>;
     /** Put a new Thread row (conditional create — must reject an existing id). */
@@ -185,9 +295,20 @@ export interface ThreadPersistencePort {
      * EXISTING Thread and return the NEW `lastSeq`. `preview: null`
      * allocates the seq WITHOUT touching `lastMessagePreview` (card rows and
      * text-less agent turns must not clobber the last real preview);
-     * a string preview replaces it.
+     * a string preview replaces it. On a closed thread
+     * ({@link ThreadRow.closedAt}) it allocates nothing and rejects with
+     * `ThreadClosedError`.
      */
     incrementSeq(threadId: string, preview: string | null, atIso: string): Promise<number>;
+    /**
+     * Close an EXISTING thread: write the three closure fields
+     * ({@link ThreadRow.closedAt}) in one conditional update that holds only
+     * while the thread exists and is still open. `already_closed` when it was
+     * closed before (the first closure is kept); rejects for a missing thread.
+     * Optional: a binding without it cannot close a conversation
+     * (`ThreadStore.closeThread` answers `unsupported`).
+     */
+    closeThread?(threadId: string, closure: ThreadClosure): Promise<"closed" | "already_closed">;
     /** Put a ThreadMessage row (conditional — must reject a duplicate seq). */
     putMessage(row: ThreadMessageRow): Promise<void>;
     /** Up to `limit` most-recent messages for a thread, returned seq-ASCending. */

package/dist/rows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rows.d.ts","sourceRoot":"","sources":["../src/rows.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"rows.d.ts","sourceRoot":"","sources":["../src/rows.ts"],"names":[],"mappings":"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"}

package/dist/rows.js

@@ -1 +1,13 @@
-export {};
+/**
+ * guuey#2549: what a user turn's content rides on when its text is empty. Mirrors `@guuey/worker`'s
+ * `INPUT_KINDS` (this package does not depend on it); nocode-runtime's sync test pins them equal.
+ */
+export const THREAD_INPUT_KINDS = ['context-only'];
+/**
+ * The reader contract for a stored row's `inputKind`: a known kind, or
+ * undefined for anything else (absent, malformed, a kind this release does not
+ * know). Never throws: a stored row is read across a rolling release.
+ */
+export function readThreadInputKind(raw) {
+    return THREAD_INPUT_KINDS.find((kind) => kind === raw);
+}

package/dist/seal.d.ts

@@ -0,0 +1,63 @@
+import type { SealInterval, ThreadRow } from "./rows.js";
+/** A thread's seal state as a reader sees it, after the stored attribute was checked. */
+export type ThreadSealState = 
+/** No seal record: a legacy thread, wholly readable. */
+{
+    kind: "none";
+}
+/** A well-formed record: these intervals (possibly empty) decide each message. */
+ | {
+    kind: "intervals";
+    intervals: readonly SealInterval[];
+}
+/** A record that is present but malformed: every message reads as sealed. */
+ | {
+    kind: "unreadable";
+};
+/**
+ * Check a stored `sealIntervals` attribute. Absent (`undefined` or `null`) is
+ * a legacy thread; anything else must be an array of well-formed intervals,
+ * or the whole thread reads as sealed.
+ */
+export declare function readSealState(stored: unknown): ThreadSealState;
+/** Whether the message at `seq` is sealed under `state`. */
+export declare function isSeqSealed(state: ThreadSealState, seq: number): boolean;
+/**
+ * Whether ANY part of the thread is, or was, sealed. A copy built from the
+ * whole conversation (a model-written summary, a report) is refused when this
+ * is true, since it may carry sealed messages whatever message triggered it.
+ */
+export declare function hasSealedPart(state: ThreadSealState): boolean;
+/**
+ * The digest a writer stores beside a preview (`lastMessagePreviewDigest`), in
+ * the same update that sets the preview and its source seq. It binds the seq to
+ * the text: a writer that replaces the preview without stamping its seq (one
+ * from before the stamp) leaves a digest that no longer matches, so a reader
+ * cannot mistake the old seq for the new text's source.
+ */
+export declare function previewDigest(preview: string): string;
+/** The thread-row slice {@link readableThreadPreview} reads, as stored. */
+export interface StoredPreviewSlice {
+    lastMessagePreview?: string;
+    /** The seq of the message the preview was taken from; absent on rows a writer before it wrote. */
+    lastMessagePreviewSeq?: unknown;
+    /** {@link previewDigest} of the preview the seq was stamped with; absent on rows a writer before it wrote. */
+    lastMessagePreviewDigest?: unknown;
+    sealIntervals?: unknown;
+}
+/**
+ * The preview an operator-side reader may show: the stored preview, or `''`
+ * when the message it was taken from is sealed. On a thread with any sealed
+ * part, a preview whose source the reader cannot place is withheld too: no
+ * recorded seq, or a digest absent or not matching the stored text (an older
+ * writer replaced the text and left the previous seq beside it). A thread with
+ * no sealed part shows its preview as stored.
+ *
+ * One case reads as placed though it is not: an older writer that stored the
+ * very same text again. The text is then that of the stamped, readable
+ * message, so nothing new is shown.
+ */
+export declare function readableThreadPreview(row: StoredPreviewSlice): string;
+/** {@link readSealState} over a typed {@link ThreadRow}. */
+export declare function threadSealState(row: Pick<ThreadRow, "sealIntervals">): ThreadSealState;
+//# sourceMappingURL=seal.d.ts.map

package/dist/seal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seal.d.ts","sourceRoot":"","sources":["../src/seal.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEzD,yFAAyF;AACzF,MAAM,MAAM,eAAe;AACzB,wDAAwD;AACtD;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE;AAClB,kFAAkF;GAChF;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,SAAS,YAAY,EAAE,CAAA;CAAE;AAC3D,6EAA6E;GAC3E;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC;AAiB3B;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,GAAG,eAAe,CAU9D;AAED,4DAA4D;AAC5D,wBAAgB,WAAW,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAMxE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAI7D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,2EAA2E;AAC3E,MAAM,WAAW,kBAAkB;IACjC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kGAAkG;IAClG,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,8GAA8G;IAC9G,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CASrE;AAED,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE,eAAe,CAAC,GAAG,eAAe,CAEtF"}