@guuey/threads 0.31.1 → 0.33.0

package/README.md

@@ -79,6 +79,87 @@ and Cognito sessions are served on-platform only. Errors surface as
 `HttpThreadStoreError` (`status`, `code`). Reads retry once on a network
 failure or 5xx; writes never do.
 
+## Row size limits
+
+A store with an item-size limit declares it as the port's optional
+`rowBudget` (`{ maxBytes, bytesOf(row), numberFits?(n) }`). The DynamoDB-backed
+bindings, `HttpThreadPersistence` included, declare `DYNAMODB_ROW_BUDGET`:
+380,000 bytes measured by `dynamoItemBytes`, an upper bound under DynamoDB's
+own item-size rules, and `dynamoNumberFits`, which refuses a number DynamoDB
+cannot hold as written (outside the safe-integer range, NaN or an infinity, or
+a non-zero magnitude below 1e-130). A port without a budget stores rows exactly
+as mapped.
+
+`appendFold` checks every row of a turn against the budget before it writes any:
+
+- A value is stored as a marker in its place,
+  `{ "com.guuey/elided": { "bytes": <UTF-8 length of its JSON> } }`. A
+  tool-call value is, when it carries a number the store cannot hold
+  (`reason: "number"`). An oversized row leaves values out until it fits
+  (`reason: "size"`), the largest first within each step: first a
+  tool-result's `uiData` that is an inline UI resource with text
+  (`{ uri, text }`) when a card row of the same turn carries the same value
+  for the same call (`field: "uiData"`; the card row holds the resource, and
+  the thread's readers draw the card from it), then each
+  `providerMetadata.wireInput` copy, then each `input`. Text blocks are never
+  elided. The result lists each one in `elidedToolInputs`.
+- A turn that still cannot be stored is never written in part. With
+  `unstorableNotice: { text }` the turn is stored as ONE agent row carrying that
+  text and `content.error.code` `"stored_turn_too_large"` or
+  `"stored_turn_unstorable_number"` (`classifyStoredRow` reads either as a
+  failure), and the result carries `unstorable`. Without it, `appendFold`
+  throws `StoredRowTooLargeError` or `StoredRowUnstorableNumberError` and
+  writes nothing.
+
+`appendMessage` refuses such a row the same way before it allocates a seq.
+`withItemSizeLimit(port)` from `@guuey/threads/testing` wraps any port to
+declare the budget and refuse what DynamoDB would (on `putMessage` and
+`putSnapshot`), for tests.
+
+The turn's snapshot is planned under the same budget, also before any row is
+written (`planSnapshot`), so the snapshot write never fails after the rows
+landed:
+
+- A `workingState` that carries a number the store cannot hold is not stored.
+  The snapshot keeps `priorWorkingState` (the state the turn was seeded with),
+  or no state when none is given.
+- A thread-memory element that carries such a number is left out.
+- Over the budget, the turn's state is refused first, then the memory records
+  this turn wrote are left out, the largest first. Records stored unchanged
+  from `priorThreadMemory`, and carried elements, stay.
+- A snapshot that still does not fit is not written, and the prior one stands.
+
+The result's `refusedSnapshot` (`{ state?, memoryNumber, memorySize,
+notWritten }`) reports what was left out, as counts.
+
+## Sealed messages
+
+A thread row may carry `sealIntervals`: stretches of messages (`fromSeq` to
+`toSeq`, both inclusive; no `toSeq` = still open) that the app's operator may
+not read. A reader that shows conversation data to the operator checks them
+with the exported helpers, never by hand:
+
+```ts
+import { isSeqSealed, readableThreadPreview, readSealState } from "@guuey/threads";
+
+const seal = readSealState(row.sealIntervals); // absent = legacy, wholly readable
+if (isSeqSealed(seal, message.seq)) {
+  /* withhold this message */
+}
+const preview = readableThreadPreview(row); // '' when its source message is sealed
+```
+
+A seal record that is present but malformed reads as wholly sealed. Each
+preview records the seq it was taken from (`lastMessagePreviewSeq`) and a
+digest of its text (`lastMessagePreviewDigest`, `previewDigest(preview)`) in
+the same update. On a thread with any sealed part, a preview whose seq is
+missing, or whose digest is missing or does not match its text, is withheld. A
+binding that implements the port writes both with the preview.
+
+An event row (a hand-off, a report) leaves the preview as it was, like a card
+row: it is written from the whole conversation, so it never becomes the
+thread's preview.
+
 ## Support
 
 Questions and help: the guuey community on Discord — https://guuey.com/discord.

package/dist/closed.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A closed conversation (see {@link ThreadRow.closedAt}): how a stored row
+ * reads as closed, and the error a binding answers an append on one with.
+ */
+import type { ThreadClosure, ThreadRow } from "./rows.js";
+/**
+ * The thread's closure, or `undefined` while it is open. `closedAt` alone
+ * decides: a row without it (every row written before closing existed) is
+ * open, and a row with it is closed even when its reason did not land
+ * (`code`/`message` then read as `""`).
+ */
+export declare function threadClosure(row: ThreadRow): ThreadClosure | undefined;
+/**
+ * A binding's answer to `incrementSeq` on a closed thread: the conversation
+ * takes no new message. A caller that meant to continue it starts a new one.
+ */
+export declare class ThreadClosedError extends Error {
+    readonly threadId: string;
+    readonly code = "THREAD_CLOSED";
+    constructor(threadId: string);
+}
+//# sourceMappingURL=closed.d.ts.map

package/dist/closed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closed.d.ts","sourceRoot":"","sources":["../src/closed.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE1D;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,SAAS,GAAG,aAAa,GAAG,SAAS,CAOvE;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAE9B,QAAQ,CAAC,QAAQ,EAAE,MAAM;IADrC,QAAQ,CAAC,IAAI,mBAAmB;gBACX,QAAQ,EAAE,MAAM;CAItC"}

package/dist/closed.js

@@ -0,0 +1,28 @@
+/**
+ * The thread's closure, or `undefined` while it is open. `closedAt` alone
+ * decides: a row without it (every row written before closing existed) is
+ * open, and a row with it is closed even when its reason did not land
+ * (`code`/`message` then read as `""`).
+ */
+export function threadClosure(row) {
+    if (typeof row.closedAt !== "string" || row.closedAt.length === 0)
+        return undefined;
+    return {
+        code: typeof row.closedCode === "string" ? row.closedCode : "",
+        message: typeof row.closedMessage === "string" ? row.closedMessage : "",
+        at: row.closedAt,
+    };
+}
+/**
+ * A binding's answer to `incrementSeq` on a closed thread: the conversation
+ * takes no new message. A caller that meant to continue it starts a new one.
+ */
+export class ThreadClosedError extends Error {
+    threadId;
+    code = "THREAD_CLOSED";
+    constructor(threadId) {
+        super(`thread ${threadId} is closed`);
+        this.threadId = threadId;
+        this.name = "ThreadClosedError";
+    }
+}

package/dist/fold-rows.d.ts

@@ -5,7 +5,7 @@
  * docs/superpowers/specs/2026-06-23-agjson-persistence-fold-design.md §6–§9.
  */
 import type { AgMessage, AgArtifact, AgTurnRecord, AgReduceResult, AgEvent, AgMemoryRecord, JsonValue } from "@silverprotocol/core";
-import type { ThreadMessageRow, ThreadSnapshotRow } from "./rows.js";
+import type { RowBudget, ThreadMessageRow, ThreadSnapshotRow } from "./rows.js";
 export interface RowCtx {
     threadId: string;
     userId: string;
@@ -37,6 +37,12 @@ export declare function messageNarration(msg: AgMessage): string[];
  * bytes whether a row was written before the split or after it.
  */
 export declare function messageFullText(msg: AgMessage): string;
+/**
+ * A stored row's `text` as storage can hand it to a reader: a string, absent, or NULL. The row type
+ * says `string | undefined`, but a raw DynamoDB read cast to it can carry a NULL attribute, so the
+ * readers that take the row's text accept null and read it as no text.
+ */
+export type StoredRowText = string | null | undefined;
 /** A stored message's text, split: the answer, the narration, and everything (the model's view). */
 export interface StoredTextParts {
     answer: string;
@@ -47,13 +53,261 @@ export interface StoredTextParts {
  * Split a stored row's `content` into answer, narration and the model's full
  * text, when `content` is a stored `AgMessage` (an object, or the JSON string
  * an AppSync writer stores). Anything else is null, and a reader falls back to
- * the row's `text`. It is read through core's lenient stored-record reader, so
- * an unknown block is omitted rather than failing the row.
+ * the row's `text`. The message is read by {@link readStoredRowMessage}, so an
+ * unknown block is omitted rather than failing the row, and an elided answer
+ * reads from the row's `text`. `text` is required so that every caller passes
+ * the row's `text` on purpose (`undefined` or null when the row has none).
+ */
+export declare function storedTextParts(content: unknown, text: StoredRowText): StoredTextParts | null;
+/** A tool-result block as a fold stores it. */
+export type StoredToolResultBlock = Extract<AgMessage["content"][number], {
+    type: "tool-result";
+}>;
+/**
+ * A stored tool call as a reader serves it (guuey#2388): its id, the tool's
+ * raw wire name (guuey#402), its display title when the producer gave one,
+ * and its input, exactly what a host's live tool-call row reads. Built field
+ * by field, never core's block: core's call also carries provider and
+ * transport fields (`providerMetadata`, whose `wireInput` is a second copy of
+ * the input, `_meta`, `signature`, `toolMetadata`, `uiVisibility` and more)
+ * that a reader must not serve, and a served view only ever gains fields.
+ */
+export interface StoredToolCallView {
+    toolCallId: string;
+    name: string;
+    title?: string;
+    input: JsonValue;
+}
+/**
+ * The tool calls a stored row's message makes, in block order, as
+ * {@link StoredToolCallView}s (guuey#2388). The name rides only the call; a
+ * result carries just the id, and a facet may store the result in a message
+ * (and so a row) of its own, so a reader that names a result reads the calls
+ * of the rows around it (guuey#2487). Empty when `content` is not a stored
+ * message.
+ */
+export declare function storedToolCallViews(content: unknown, text: StoredRowText): StoredToolCallView[];
+/**
+ * The tool results a stored row's message carries that NO card row stands for
+ * (guuey#2487): every `tool-result` block that does not carry a UI resource
+ * ({@link toolResultCarriesUi}), without its `_meta` (guuey#122), in block
+ * order. A host draws from such a result (an in-process tool's
+ * `structuredContent`, or its text) live; this is how a reader finds it again
+ * after a reload. A UI-carrying result is left out: its card row already
+ * carries it. Empty when `content` is not a stored message.
+ */
+export declare function storedToolResults(content: unknown, text: StoredRowText): StoredToolResultBlock[];
+/**
+ * The call id of EVERY `tool-result` block a stored row's message carries, in
+ * block order, whether it carries a UI resource or not (guuey#2487). A reader
+ * that names results by their calls uses it to tell where a call's results
+ * sit on a page, card-drawn ones included: a call's first result row is
+ * written straight after the call row, and a UI-carrying result's card row
+ * straight after the result (guuey#2396). Empty when `content` is not a
+ * stored message.
+ */
+export declare function storedToolResultCallIds(content: unknown, text: StoredRowText): string[];
+/**
+ * A row's stored message as every reader of a row reads it ({@link storedTextParts},
+ * {@link rowToAgMessage}, `classifyStoredRow`): `content` (a stored `AgMessage`
+ * object) through core's lenient stored-record reader, with an ELIDED ANSWER
+ * restored from the row's `text`. `undefined` when core cannot materialize the
+ * message. Like core's reader, it returns a view, never a record to persist.
+ *
+ * A stored message may leave its answer out of `content` because the row's
+ * `text` carries the same words: an answer block whose `text` is the
+ * {@link ELIDED_VALUE_KEY} marker ({@link isElidedAnswerBlock}). Such a message
+ * is rebuilt once, before it is read: the row's `text` (every answer block,
+ * joined) becomes the text of the first answer block, and every later answer
+ * block is left out, since that `text` already holds it. An answer block here
+ * is a block core can read as a text block, not narration, that is elided or
+ * non-empty. Every other block stays as stored. When the answer blocks stand
+ * together, as a reply's do, the rebuilt message reads the same text as the
+ * unelided one.
+ *
+ * Only the marker reads the row's `text`: a message with no answer blocks reads
+ * as it always has, with an empty answer, whatever the row's `text` says. On a
+ * row with no `text` (absent, NULL or empty) there is nothing to restore: only
+ * the elided blocks are left out and every other block reads as stored, so a
+ * stored word is never erased. An elided answer alone then reads as an empty
+ * answer in {@link storedTextParts} and `classifyStoredRow`, as its unelided
+ * twin with an empty answer would; the rebuilt message leaves the block out.
  */
-export declare function storedTextParts(content: unknown): StoredTextParts | null;
+export declare function readStoredRowMessage(content: unknown, text: StoredRowText): AgMessage | undefined;
+/** A stored text element as a stored message carries it, before core reads it. */
+interface StoredTextElement {
+    type: "text";
+    text: unknown;
+}
 export declare function agMessageToRow(msg: AgMessage, ctx: RowCtx & {
     turnRecord?: AgTurnRecord;
 }): ThreadMessageRow;
+/**
+ * The key of the marker a stored value is replaced by when the row would not
+ * fit its store's {@link RowBudget}: `{ "com.guuey/elided": { bytes } }`, where
+ * `bytes` is the UTF-8 length of the elided value's JSON. It stands in for the
+ * value whole (a tool-call `input`, its `providerMetadata.wireInput`, or a
+ * tool-result `uiData` the turn's card row also carries), so the block keeps
+ * an object where an object was.
+ */
+export declare const ELIDED_VALUE_KEY = "com.guuey/elided";
+/**
+ * Which value of a block was elided: a tool-call's `input` or
+ * `providerMetadata.wireInput`, or a tool-result's `uiData` (an inline UI
+ * resource the turn's card row carries whole).
+ */
+export type ElidedField = "input" | "wireInput" | "uiData";
+/**
+ * Why a tool-call value was elided: the row did not fit the store's row
+ * budget (`size`), or the value carried a number the store cannot hold as
+ * written (`number`, see {@link RowBudget.numberFits}).
+ */
+export type ElisionReason = "size" | "number";
+/** One stored value replaced by the elided marker. */
+export interface StoredElision {
+    toolCallId: string;
+    /** The tool's name (for a `uiData` elision, the name its card row stores). */
+    name: string;
+    field: ElidedField;
+    reason: ElisionReason;
+    /** UTF-8 length of the elided value's JSON. */
+    bytes: number;
+}
+/** The kind of row a stored-row refusal was raised for. */
+export type RefusedRowKind = "message" | "card" | "append";
+/**
+ * A row cannot fit its store's {@link RowBudget}, even with every value it
+ * carries that may be elided elided. Counts only, never row content.
+ */
+export declare class StoredRowTooLargeError extends Error {
+    readonly bytes: number;
+    readonly maxBytes: number;
+    readonly rowKind: RefusedRowKind;
+    /** The row's index among the turn's message or card rows (0 for an append). */
+    readonly index: number;
+    readonly name = "StoredRowTooLargeError";
+    constructor(bytes: number, maxBytes: number, rowKind: RefusedRowKind, 
+    /** The row's index among the turn's message or card rows (0 for an append). */
+    index: number);
+}
+/**
+ * A row carries a number its store cannot hold as written (see
+ * {@link RowBudget.numberFits}) outside any tool-call value that could be
+ * elided. Never names the number: it may be part of a tool's input or result.
+ */
+export declare class StoredRowUnstorableNumberError extends Error {
+    readonly rowKind: RefusedRowKind;
+    /** The row's index among the turn's message or card rows (0 for an append). */
+    readonly index: number;
+    readonly name = "StoredRowUnstorableNumberError";
+    constructor(rowKind: RefusedRowKind, 
+    /** The row's index among the turn's message or card rows (0 for an append). */
+    index: number);
+}
+/** Either reason a row cannot be stored: too large, or carrying an unstorable number. */
+export type StoredRowRefusal = StoredRowTooLargeError | StoredRowUnstorableNumberError;
+export declare function isStoredRowRefusal(err: unknown): err is StoredRowRefusal;
+/** Whether `value` (any JSON-shaped data) holds a number `fits` refuses, at any depth. */
+export declare function carriesUnfitNumber(value: unknown, fits: (n: number) => boolean): boolean;
+/**
+ * Throw when `row` cannot be stored under `budget`: {@link StoredRowUnstorableNumberError}
+ * when it carries a number the store cannot hold, {@link StoredRowTooLargeError}
+ * when it measures over the budget. No-op without a budget.
+ */
+export declare function assertRowFits(row: ThreadMessageRow, budget: RowBudget | undefined, rowKind: RefusedRowKind, index: number): void;
+/** One tool-result `uiData` a card row of the turn carries, with the tool name that row stores. */
+export interface CardUiData {
+    name: string;
+    uiData: JsonValue;
+}
+/**
+ * What a turn's card rows carry, by tool call: for each `toolCallId`, the
+ * `uiData` of every tool-result part of a card row that names its producing
+ * tool. A message row's tool-result `uiData` equal to one of these is a second
+ * copy of what that card row stores.
+ */
+export type CardUiDataByCallId = ReadonlyMap<string, readonly CardUiData[]>;
+/** {@link CardUiDataByCallId} over a turn's card rows (rows of another kind are skipped). */
+export declare function cardUiDataByCallId(cardRows: readonly ThreadMessageRow[]): CardUiDataByCallId;
+/**
+ * A stored ANSWER block left out because the row's `text` carries the same
+ * words: a `text` block whose `text` is the {@link ELIDED_VALUE_KEY} marker
+ * (`{ "com.guuey/elided": { bytes } }`, `bytes` the UTF-8 length of the
+ * elided string's JSON) in place of the string. A narration block
+ * (`phase: "interim"`) is never one: the row's `text` is the answer only, so
+ * it holds no narration to read back. Read on the raw stored element, since
+ * core's lenient reader leaves such a block out (its `text` is not a string).
+ */
+export declare function isElidedAnswerBlock(element: unknown): element is StoredTextElement;
+/**
+ * {@link agMessageToRow}, bounded by the store's {@link RowBudget}. Under the
+ * budget (or with none) the row is exactly `agMessageToRow(msg, ctx)`.
+ *
+ * First, when the budget declares `numberFits`, every tool-call value that
+ * carries a number the store cannot hold is replaced by the
+ * {@link ELIDED_VALUE_KEY} marker (`reason: "number"`; after `JSON.parse` such
+ * a number has already lost its digits, so storing it would store a wrong
+ * one). A row that still carries one elsewhere throws
+ * {@link StoredRowUnstorableNumberError}.
+ *
+ * Then, over the size budget, values are replaced one at a time
+ * (`reason: "size"`) until the row fits. Pure duplicates go first: a
+ * tool-result's `uiData` that is an inline UI resource with text, when a card
+ * row of the turn (`cards`, see {@link cardUiDataByCallId}) carries the same
+ * value for the same call. Then every `providerMetadata.wireInput` (a second
+ * copy of the input, carried only when it differs), then every `input`.
+ * Within each tier the largest goes first, ties in block order. A row that
+ * still does not fit throws {@link StoredRowTooLargeError}.
+ */
+export declare function agMessageToBoundedRow(msg: AgMessage, ctx: RowCtx & {
+    turnRecord?: AgTurnRecord;
+}, budget: RowBudget | undefined, index: number, cards?: CardUiDataByCallId): {
+    row: ThreadMessageRow;
+    elided: StoredElision[];
+};
+/**
+ * Whether a tool-result block carries a UI resource, and so becomes a card row
+ * ({@link uiCardArtifactsFromMessages}) rather than a stored tool result
+ * ({@link storedToolResults}). The one predicate both share, so a result is a
+ * card or a stored tool result, never both and never neither.
+ *
+ * It judges the block AS STORED: without its `_meta` (guuey#122), which never
+ * persists. The card projection sees the live block and the stored-row reader
+ * sees the stored one, so a predicate that read `_meta` would answer the two
+ * differently (a `_meta.ui` locator is visible to the first only). Judging the
+ * stored view gives one answer on both sides by construction.
+ *
+ * A block carries UI only on DURABLE evidence, what a card row needs to mount
+ * after a reload. As stored:
+ *  - its `uiData` is an MCP resource payload (`{ uri, text|blob }`, bare or as
+ *    `{ resource }`), which mounts inline;
+ *  - its `uiData` or `structuredContent` names a `ui://` locator, which mounts
+ *    by a fresh read of the uri (`structuredContent` for a producer that
+ *    withholds `_meta`, guuey#209);
+ *  - its `uiData` is the {@link ELIDED_VALUE_KEY} marker, which stands in for
+ *    an inline resource the turn's card row carries whole
+ *    ({@link agMessageToBoundedRow});
+ *  - or a `provider-raw` part carries a `ui://` resource.
+ *
+ * Anything else is a stored tool result, which a host reads by its tool name.
+ * That includes plain view data in `uiData`: AgJSON §2.1 routes a result's
+ * payload there whenever the producer set any `_meta.ui` sibling, so an
+ * object in `uiData` alone is no evidence that a card can mount. When
+ * `_meta.ui` named no `ui://` locator, nothing could ever mount it; when it
+ * did, the locator rode `_meta` alone and the writer strips it, so the stored
+ * row cannot mount it either. A card row for either would draw as an expired
+ * chip on every reload. (A writer that persisted that locator would make it a
+ * card here, by this same rule.)
+ *
+ * `_meta` alone never mints a card (the guuey#170 pin). Across a rolling
+ * release: a writer before this predicate minted a card row from a `_meta.ui`
+ * locator, so a thread written then holds that card row while this predicate
+ * reads the same stored result as one with no UI resource. A reader that
+ * serves both kinds keeps one item per result by leaving out a stored tool
+ * result whose call already has a card row on its read (the public transcript
+ * read does).
+ */
+export declare function toolResultCarriesUi(block: StoredToolResultBlock): boolean;
 export declare function uiCardArtifactsFromMessages(messages: AgMessage[]): AgArtifact[];
 /**
  * toolCallId → tool name, read off every `tool-call` block in the fold's
@@ -71,6 +325,21 @@ export declare function toolNamesByCallId(messages: AgMessage[]): Map<string, st
  * never a guess (humanization and fallbacks are the kit's, one owner).
  */
 export declare function producingToolName(art: AgArtifact, toolNames: ReadonlyMap<string, string>): string | undefined;
+/**
+ * toolCallId → the index of the fold message that carries that call's
+ * `tool-result` block (guuey#2396). A card is drawn when its tool-result
+ * arrives, so this is where its card row belongs in the turn's stored order.
+ * First message wins on a duplicate id, as in {@link toolNamesByCallId}.
+ */
+export declare function toolResultMessageIndexByCallId(messages: AgMessage[]): Map<string, number>;
+/**
+ * The index of the fold message a card artifact was drawn with: the message
+ * holding the tool-result its first tool-result part names (guuey#2396).
+ * `undefined` when unresolvable (a first-class `artifact.*` event with no
+ * tool-result part, or a call outside this fold): such a card keeps the
+ * turn's tail.
+ */
+export declare function producingMessageIndex(art: AgArtifact, resultIndices: ReadonlyMap<string, number>): number | undefined;
 export declare function agArtifactToCardRow(art: AgArtifact, ctx: RowCtx, toolName?: string): ThreadMessageRow;
 /**
  * Reconstruct an AgMessage from a row. Agent-fold rows store the verbatim
@@ -83,7 +352,8 @@ export declare function agArtifactToCardRow(art: AgArtifact, ctx: RowCtx, toolNa
  * undefined value in a closed set, is omitted whole and the rest restores in
  * order; unknown fields pass through untouched. Only a record the reader
  * cannot materialize (no string `id`, an undefined `role`, no `content`
- * array) falls to the text projection.
+ * array) falls to the text projection. A stored message whose answer block is
+ * elided reads its answer from the row's `text` ({@link readStoredRowMessage}).
  */
 export declare function rowToAgMessage(row: ThreadMessageRow): AgMessage;
 /** Extract the AgArtifact from a kind='card' row, or undefined if malformed. */
@@ -126,6 +396,8 @@ export declare function splitStoredThreadMemory(stored: readonly JsonValue[]): P
  * turn, so write order stays time order.
  */
 export declare function joinStoredThreadMemory(row: Pick<ThreadSnapshotRow, "threadMemory" | "carriedThreadMemory">): JsonValue[];
+/** Structural equality over JSON values (object key order does not matter). */
+export declare function jsonEqual(a: JsonValue | undefined, b: JsonValue | undefined): boolean;
 /**
  * The thread records a turn persists: each record of the fold, except that a
  * record the turn did NOT change is persisted as the PRIOR stored record
@@ -179,4 +451,5 @@ export declare function keepUnchangedThreadMemory(priorView: readonly AgMemoryRe
  * so it cannot round-trip through a live write — that is expected.)
  */
 export declare function seedEventsForReducer(priorState: JsonValue | undefined, priorThreadMemory: AgMemoryRecord[]): AgEvent[];
+export {};
 //# sourceMappingURL=fold-rows.d.ts.map

package/dist/fold-rows.d.ts.map

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