@aparte/core 0.19.2 → 0.20.0

package/dist/types/segments.d.ts

@@ -48,16 +48,15 @@ export interface AparteSegmentBase {
 /**
  * What core measured about a segment. Lives in `meta.aparte`, not on the segment.
  *
- * These two were first-class fields, and moving them is not tidying. **No protocol
- * carries a timestamp on a content block** — verified rather than assumed: Anthropic's
+ * **No protocol carries a timestamp on a content block**: Anthropic's
  * blocks have none (and neither does the message), OpenAI's `output_text` part is
  * `{annotations, logprobs, text, type}` with `created_at` on the item above it, and the
  * AI SDK's `UIMessage.parts` have none either. What the AI SDK does have is a metadata
  * bag whose canonical example is literally `{ createdAt, model, totalTokens }` — at the
  * message level. A per-block `id` has industry precedent; per-block time has none.
  *
- * So this is a **local measurement**, and the shape says so. It stays typed — the bag is
- * where it belongs, opacity is not part of the deal — and it is namespaced under
+ * So this is a **local measurement**, and the shape says so. It stays typed, and it is
+ * namespaced under
  * `aparte` because `meta` is the consumer's: a flat `startedAt` there would collide
  * with a key of their own.
  *
@@ -128,15 +127,9 @@ export interface AparteThinkingSegment extends AparteSegmentBase {
     content: string;
     /**
      * Open the block. **Absent means CLOSED** — a reasoning block is a disclosure,
-     * and the reader opens it.
+     * and the reader opens it. The content is behind a click, streaming or settled.
      *
-     * It used to be the other way round: absent meant open, and core's own parser
-     * emitted `collapsed: false` on every block it produced, so a reasoning block
-     * stayed unfolded for the whole conversation and buried the answer under it. No
-     * assistant on the market does that — the content is behind a click, streaming
-     * or settled.
-     *
-     * `false` is still how you open one on purpose. Only ABSENT changed meaning.
+     * `false` opens one on purpose.
      */
     collapsed?: boolean;
     label?: string;
@@ -161,6 +154,10 @@ export interface AparteCodeSegment extends AparteSegmentBase {
     content: string;
     language?: string;
     filename?: string;
+    /**
+     * @deprecated Read by nothing: no renderer and no stylesheet draws line numbers, so setting it
+     * changes nothing. It will be removed in a later minor.
+     */
     showLineNumbers?: boolean;
 }
 /**
@@ -181,6 +178,10 @@ export interface AparteErrorSegment extends AparteSegmentBase {
     type: 'error';
     content: string;
     details?: string;
+    /**
+     * @deprecated Set by nothing and read by nothing: the error renderer draws `content` and
+     * `details` only. Put a stack in `details` to show it. It will be removed in a later minor.
+     */
     stack?: string;
 }
 /**
@@ -268,7 +269,22 @@ export interface AparteCustomSegment extends AparteSegmentBase {
  * segment — a `type` of its own, through `registerSegmentRenderer` and
  * `registerStreamBlock` — the way any consumer registers a `chart` or a `citation`.
  */
-export type AparteSegment = AparteTextSegment | AparteThinkingSegment | AparteCodeSegment | AparteErrorSegment | AparteCustomSegment | AparteToolCallSegment;
+export type AparteSegment = AparteTextSegment | AparteThinkingSegment | AparteCodeSegment | AparteErrorSegment | AparteCustomSegment | AparteToolCallSegment | AparteSegmentTypes[keyof AparteSegmentTypes];
+/**
+ * The segment types an app or a plugin adds, one key per `type`, merged into this interface;
+ * each one joins {@link AparteSegment}, so `addSegment`, `appendMessage` and
+ * `AparteMessage.segments` take it without a cast.
+ *
+ * @example
+ * declare module '@aparte/core' {
+ *   interface AparteSegmentTypes {
+ *     chart: AparteSegmentBase & { type: 'chart'; data: { label: string; value: number }[] };
+ *   }
+ * }
+ * viewport.addSegment('a1', { id: 'c1', type: 'chart', data: [{ label: 'Q1', value: 4 }] });
+ */
+export interface AparteSegmentTypes {
+}
 /** Segment type discriminator values */
 export type AparteSegmentType = AparteSegment['type'];
 /**

package/dist/types/segments.d.ts.map

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

package/dist/types/tools.d.ts

@@ -30,9 +30,6 @@ export interface AparteTool {
      * same turn runs — and then the model gets a turn to answer it, so it can
      * say what it will do instead. The refusal may carry the user's own words.
      *
-     * All three clauses of this comment used to say something else: the default
-     * renderer surfaced the buttons, an `aparte-tool-decision` event resolved
-     * them, and a refusal ended the turn. None of that is true any more.
      */
     needsApproval?: boolean;
 }
@@ -44,11 +41,8 @@ export interface AparteTool {
  * (`<aparte-elicitation>` renders the panel there), and the transcript row shows only a
  * state — there is no Approve/Reject control in a bubble.
  *
- * This block used to say "the built-in renderer already shows Approve/Reject inline",
- * which stopped being true when the decision moved to the composer. A consumer trusting
- * it shipped with no presenter and no `approvalResolver`, and every `needsApproval` call
- * aborted with nothing clickable on screen. The sibling docblock on `needsApproval`
- * records the same correction; this one was missed in the same file.
+ * With no presenter and no `approvalResolver`, every `needsApproval` call aborts with
+ * nothing clickable on screen.
  *
  * @event aparte-tool-approval-request
  */
@@ -111,19 +105,13 @@ export type AparteToolHandler = (call: AparteToolCall, signal: AbortSignal, cont
 /**
  * Which chat a tool handler is running for.
  *
- * Optional and third, so every existing handler keeps compiling and working —
- * nothing has to be rewritten to ignore it.
+ * Optional and third, so a handler that does not need it ignores it.
  *
- * It exists because a handler had NO way to know. `@aparte/plugin-ask-user`
- * calls `requestUserInput({ message, schema, signal })` with no `target`, and
- * `requestUserInput` resolves its presenter with `resolveConfig(request.target ??
- * null)` — so with an instance config carrying the presenter, the call resolved
- * against the GLOBAL config, found nothing, and returned `{ action: 'cancel' }`.
- * The model was told the user refused a question the user was never shown.
- *
- * That failure is described in `AparteConfig.requestUserInput` as "a lie told
- * quietly", and the plugin walked straight into it because the handler signature
- * gave it nothing to walk around with.
+ * A handler needs it to reach the right instance: `requestUserInput` resolves its
+ * presenter with `resolveConfig(request.target ?? null)`, so without a `target` it
+ * resolves against the GLOBAL config, finds no presenter on an instance config, and
+ * rejects with an `AparteElicitationAbortError` (`name` `'AbortError'`, reason
+ * `'no-presenter'`): nothing is shown. Pass `target` from this context.
  *
  * The loop supplies it — `runStreamAgent`, or the runner you injected — so
  * a handler behaves the same whichever one is running.
@@ -161,6 +149,17 @@ export interface AparteToolContext {
  * defensively — a summary that throws shows nothing rather than breaking the row.
  */
 export type AparteToolSummary = (segment: AparteToolCallSegment) => string;
+/**
+ * A tool's arguments as a person reads them: the text the approval panel shows under its
+ * question and the default tool row shows behind its disclosure — one formatter for both, so
+ * the two cannot disagree. Registered via aparteGlobalConfig.registerToolInputFormatter(toolName, formatter).
+ *
+ * Without one, both show the arguments as the model sent them, pretty-printed JSON. Return
+ * plain text: it is written as text, never parsed as HTML; `''` shows no arguments at all.
+ * `input` is whatever the model chose, so read it defensively — a formatter that throws
+ * falls back to the JSON.
+ */
+export type AparteToolInputFormatter = (input: Record<string, unknown>) => string;
 /**
  * Per-tool segment renderer.
  * Registered via aparteGlobalConfig.registerToolRenderer(toolName, renderer).
@@ -176,8 +175,7 @@ export interface AparteToolRenderer {
      * **The segment carries model-chosen data.** `segment.toolCall.input` is
      * whatever the model decided to pass, and `segment.result` is whatever the tool
      * returned — on the SEGMENT, because `AparteToolCall` is `{ id, name, input }`
-     * and nothing else. This line used to say `segment.toolCall.result`, which does
-     * not compile; the first renderer written against it found out.
+     * and nothing else (there is no `segment.toolCall.result`).
      * Both values are untrusted.
      *
      * Return an **HTMLElement** and there is no innerHTML surface at all — set
@@ -187,7 +185,7 @@ export interface AparteToolRenderer {
      * Return a **string** and core inserts it with `innerHTML`, so every
      * interpolated value must go through `escapeHtml` (text position) or
      * `escapeAttr` (inside an attribute). The natural first thing to write here is
-     * `\`<div>Searching for ${s.toolCall.input.query}</div>\``, and that is a direct
+     * `` `<div>Searching for ${s.toolCall.input.query}</div>` ``, and that is a direct
      * model-to-DOM XSS in the host page's origin.
      *
      * Return an empty string to render nothing (e.g. a UI-only tool like

package/dist/types/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/types/tools.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAE3D,2CAA2C;AAC3C,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,8GAA8G;IAC9G,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;;;;;;;;OAiBG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,+BAA+B;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,qDAAqD;AACrD,MAAM,WAAW,cAAc;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACjC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAC/B,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,UAAU,GAAG,SAAS,KAC3B,oBAAoB,GAAG,SAAS,CAAC;AAEtC,oDAAoD;AACpD,MAAM,WAAW,gBAAgB;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC5B,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,EACnB,OAAO,CAAC,EAAE,iBAAiB,KAC1B,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,EAAE,qBAAqB,KAAK,MAAM,CAAC;AAE3E;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,MAAM,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,MAAM,GAAG,WAAW,CAAC;IACjE,8EAA8E;IAC9E,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACvE;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACxE;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACzE,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,MAAM,CAAC;CAC5B"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/types/tools.ts"],"names":[],"mappings":"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"}

package/dist/utils/copy-text.d.ts

@@ -17,8 +17,7 @@
  * the path clipboard.js and copy-to-clipboard take, for the same reason.
  *
  * Rejects when neither path could copy, so a caller's "copied" confirmation can stay
- * honest. `pnpm check:secure-context` refuses a bare `navigator.clipboard` anywhere but
- * here, so the sweep cannot come undone one call site at a time.
+ * honest.
  */
 export declare function copyText(text: string): Promise<void>;
 //# sourceMappingURL=copy-text.d.ts.map

package/dist/utils/copy-text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"copy-text.d.ts","sourceRoot":"","sources":["../../src/utils/copy-text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgCpD"}
+{"version":3,"file":"copy-text.d.ts","sourceRoot":"","sources":["../../src/utils/copy-text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkCpD"}

package/dist/utils/css-escape.d.ts

@@ -8,7 +8,7 @@
  *
  * Segment/message ids are random UUIDs in the default flow, so this is
  * defense-in-depth: a hostile, stream-supplied id containing `"` (e.g. a tool-call
- * id) can no longer break out of the selector into a `SyntaxError` or a
+ * id) cannot break out of the selector into a `SyntaxError` or a
  * selector-list that mis-targets another element.
  *
  * A raw newline (or CR / form feed) is not allowed inside a CSS string either — it

package/dist/utils/escape.d.ts

@@ -1,26 +1,13 @@
 /**
  * HTML escaping — one implementation, for every interpolation core makes.
  *
- * There used to be SEVEN copies of this across the package (`_escapeHtml` in the
- * bubble and in the config, `_escapeAttr` in the chat shell, the composer action
- * and the composer input, plus `escapeHtml` and `escapeAttr` in the segment
- * renderers). They had already drifted: the chat shell's copy escaped only `&`,
- * `"` and `<`, leaving `'` and `>` through, so it was strictly weaker than its
- * six siblings while looking identical at the call site. That is the failure mode
- * a duplicated security helper always ends in — one of them stops matching, and
- * nothing tells you which.
- *
  * Escapes all five characters that matter, which makes the result safe in BOTH
  * text position and quoted-attribute position (single or double quotes). Callers
  * that read better saying "attribute" use {@link escapeAttr}, which is this same
  * function under a second name — an alias, deliberately not a second body.
  *
  * PUBLIC. Both names are exported from the barrel and documented in the
- * customization guide, because a render hook that returns a string needs them and
- * telling an author to "escape it yourself" without naming the function is how a
- * capability becomes invisible. An earlier version of this comment claimed the
- * opposite ("not exported from the package barrel… not a public API") while
- * `index.ts` exported both — the export was real, the comment was not.
+ * customization guide, because a render hook that returns a string needs them.
  */
 export declare function escapeHtml(value: string): string;
 /**
@@ -34,13 +21,11 @@ export declare function escapeHtml(value: string): string;
  * REQUIRES A QUOTED ATTRIBUTE. `title="${escapeAttr(v)}"` and `title='…'` are
  * both safe; bare `title=${escapeAttr(v)}` is NOT, because a space, tab, newline
  * or backtick in the value ends an unquoted attribute and starts the next one —
- * and none of those five escaped characters is one of them. An audit raised this
- * as a latent gap (no unquoted interpolation exists in the library today).
+ * and none of those five escaped characters is one of them. No unquoted attribute
+ * interpolation exists in the library.
  *
  * The fix is to quote the attribute, not to escape harder: encoding spaces would
- * make every legitimate `title="Hello world"` read `Hello&#32;world`. So
- * `pnpm check:attr-escaping` now rejects an unquoted attribute interpolation
- * outright rather than trusting this function to cover a position it cannot.
+ * make every legitimate `title="Hello world"` read `Hello&#32;world`.
  */
 export declare const escapeAttr: typeof escapeHtml;
 //# sourceMappingURL=escape.d.ts.map

package/dist/utils/escape.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"escape.d.ts","sourceRoot":"","sources":["../../src/utils/escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAYhD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,mBAAa,CAAC"}
+{"version":3,"file":"escape.d.ts","sourceRoot":"","sources":["../../src/utils/escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAchD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,UAAU,mBAAa,CAAC"}

package/dist/utils/files-to-attachments.d.ts

@@ -32,8 +32,8 @@ export declare function filesToAttachments(files: readonly File[]): AparteAttach
 /**
  * Release the object URLs of attachments that are no longer on screen.
  *
- * Nothing revoked them, so every `File` a session sent stayed reachable until the
- * page went away. Only the caller knows when an attachment stops being rendered —
+ * Until revoked, every `File` a session sent stays reachable until the page goes
+ * away. Only the caller knows when an attachment stops being rendered —
  * a persisted conversation may re-render one much later — so this is a function
  * rather than something `filesToAttachments` could schedule.
  *

package/dist/utils/fold-text.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Text as a search compares it: no accents, lower case, trimmed — so "Écrire" finds "ecrire".
+ * Shared by the conversation list's filter and the sidebar's search field.
+ */
+export declare function foldText(text: string): string;
+/**
+ * Hide the conversation rows under `root` whose title does not contain `needle` (already
+ * folded), and the date groups left with none; return how many rows match. An empty needle
+ * shows everything. The conversation list runs it on every render; the sidebar runs it itself
+ * on a list that has not upgraded yet, whose rows are the page's own markup.
+ */
+export declare function filterConversationRows(root: ParentNode, needle: string): number;
+//# sourceMappingURL=fold-text.d.ts.map

package/dist/utils/fold-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold-text.d.ts","sourceRoot":"","sources":["../../src/utils/fold-text.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAW/E"}

package/dist/utils/is-awaiting-reply.d.ts

@@ -6,14 +6,11 @@ import type { AparteMessage } from '../types/index.js';
  *
  * Two clauses:
  *
- * 1. **Stated**: `status` is `'streaming'` or `'pending'`. This is exactly the
- *    condition every call site used before this helper existed, role included, so
- *    no existing behaviour shifts.
+ * 1. **Stated**: `status` is `'streaming'` or `'pending'`, whatever the role.
  * 2. **Inferred**: an **assistant** message with **no `status` at all** and nothing
  *    in it — no `content`, no `segments`. That is the empty shell a token stream is
  *    about to fill (`appendMessage({ role: 'assistant', content: '' })` from a
- *    hand-rolled loop). It used to render as a completed reply, action bar and all,
- *    on a message that had never said anything.
+ *    hand-rolled loop).
  *
  * Only silence is interpreted. An explicit `status` — including `'completed'` on an
  * empty message — is the application talking, and is believed.

package/dist/utils/is-awaiting-reply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is-awaiting-reply.d.ts","sourceRoot":"","sources":["../../src/utils/is-awaiting-reply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC,GAAG,OAAO,CAMjH"}
+{"version":3,"file":"is-awaiting-reply.d.ts","sourceRoot":"","sources":["../../src/utils/is-awaiting-reply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC,GAAG,OAAO,CAMjH"}

package/dist/utils/presence.d.ts

@@ -1,14 +1,14 @@
 /**
- * What a presence-attribute SETTER makes of what it was handed (#62).
+ * What a presence-attribute SETTER makes of what it was handed.
  *
  * The generated attribute types map a presence attribute to `'' | null | undefined`,
  * because React and Vue stringify what they set on a custom element — so `''` is the
  * documented spelling for ON. Svelte 5 does not take the attribute path: it assigns
- * the PROPERTY whenever the element has one, which handed these setters the `''` the
- * types promised — and `toggleAttribute(name, '')` reads an empty string as falsy, so
- * the attribute was REMOVED. The opposite of what the template asked for, silently.
+ * the PROPERTY whenever the element has one, which hands these setters the `''` the
+ * types promise — and `toggleAttribute(name, '')` reads an empty string as falsy, so
+ * the attribute would be REMOVED, the opposite of what the template asked for.
  *
- * One rule fixes both paths without forking the spelling: on a presence property, an
+ * One rule serves both paths without forking the spelling: on a presence property, an
  * empty string means ON, exactly as an empty attribute does. Everything else keeps
  * JavaScript's own truthiness (`false`, `null`, `undefined` → OFF).
  */

package/dist/utils/segments.d.ts

@@ -1,22 +1,17 @@
 /**
  * What a segment knows about itself — stamped in one place.
  *
- * A segment carried `id`, `type` and `isStreaming` and nothing else, while the
- * message one level up already had a `timestamp`, a `usage` and a `metadata` bag.
- * Three places in this repo paid for the gap: `render(segment)` takes one argument
- * so a custom renderer could not learn its message, `aparte-terminal-run` shipped a
- * `segmentId` nobody could resolve, and the artifact renderer fabricated a message
- * id to slip past a consumer dedupe keyed on a pair it did not have.
- *
- * **Why the stamp lives here and not in `AparteStreamParser`.** The parser looked
- * like the right owner — both agent loops share it, so parity would be free. It is
- * the wrong one. `tool_call` segments are built by the client and the stream
- * adapter (three sites), `pipeline-waiting` by two more, and `prefixSegments` by the
- * app itself: stamping in the parser would have left a TOOL CALL — the single most
- * useful duration in the whole transcript — with no measurement at all. Worse, the
- * parser's own `segmentCounter` would have produced a wrong index: it is recreated
- * on every `turn-start`, while a tool round-trip appends to the SAME message across
- * turns, so one message would hold two segments at index 0, silently.
+ * A segment carries an identity (`messageId`, `index`) and a measurement
+ * (`startedAt`, `endedAt`), so a custom renderer, which receives only the segment, can
+ * learn its message and its duration.
+ *
+ * **Why the stamp lives here and not in `AparteStreamParser`.** `tool_call` segments
+ * are built by the stream adapter and `prefixSegments` by the app itself: stamping in
+ * the parser would leave
+ * a TOOL CALL — the single most useful duration in the whole transcript — with no
+ * measurement at all. The parser's own `segmentCounter` would also produce a wrong
+ * index: it is recreated on every `turn-start`, while a tool round-trip appends to the
+ * SAME message across turns, so one message would hold two segments at index 0.
  *
  * A segment can only reach a transcript one way — through `addSegment` — and there
  * are exactly two owners of the array behind it: `aparte-chat-viewport` (native) and
@@ -33,7 +28,7 @@ import type { AparteSegmentDefaults, AparteSegmentTiming, AparteSegment } from '
  *
  * Returns a new object; the caller's segment is never mutated — the viewport hands
  * the same segment object to the repository AND to the bubble, so mutating one is
- * action at a distance (a bug this repo has already paid for in `appendToSegment`).
+ * action at a distance.
  *
  * A value already present is never overwritten, so a segment rehydrated from a
  * consumer's storage keeps the numbers it was persisted with.
@@ -42,13 +37,11 @@ export declare function stampSegmentOnInsert(segments: readonly AparteSegment[],
 /**
  * A segment arriving from STORAGE or a server, rather than starting now.
  *
- * The counterpart of {@link stampSegmentOnInsert}, and the reason it exists: the two
- * are not the same act, and treating them as one made the library invent history.
- * `stampSegmentOnInsert` ran on every arrival path including a reload, so a
- * conversation from three weeks ago came back claiming each of its segments had
- * started this second — while THREE other load paths did not stamp at all, so the same
- * stored conversation produced different numbers depending on the mode and on whether
- * a branch tree had been saved. Not a lie so much as an incoherence.
+ * The counterpart of {@link stampSegmentOnInsert}: the two are not the same act, and
+ * treating them as one would invent history — a conversation from three weeks ago
+ * would claim each of its segments had started this second. Every load path goes
+ * through this one, so the same stored conversation produces the same numbers
+ * whatever the mode and whether a branch tree was saved.
  *
  * What it writes, and why each:
  *
@@ -64,15 +57,14 @@ export declare function stampSegmentOnInsert(segments: readonly AparteSegment[],
  *    `openSegmentIds`, which reads exactly this flag — would have the next turn-close
  *    stamp it a brand-new `endedAt`.
  *  - a `tool_call` persisted as `awaiting-approval` — or `pending` in a message that is
- *    no longer in flight, a call saved while it ran, which a server loop's cut connection
+ *    not in flight, a call saved while it ran, which a server loop's cut connection
  *    leaves behind — becomes `'aborted'`, for the same
  *    reason and through a hole the line above cannot reach: `isSegmentSettled` reads
- *    STATUS for a tool call, not `isStreaming`, so a restored gate stayed OPEN. The loop
- *    that awaited the decision is gone and the promise it would have settled went with
- *    the page, so the request is unanswerable — and `'aborted'` rather than `'rejected'`
- *    because nobody refused anything. Documented as a consumer's problem in the
- *    persistence guide until now ("normalise those statuses on save"), which is a
- *    normalisation this function was already the single funnel for. The exception is a
+ *    STATUS for a tool call, not `isStreaming`, so a restored gate would stay OPEN. The
+ *    loop that awaited the decision is gone and the promise it would have settled went
+ *    with the page, so the request is unanswerable — and `'aborted'` rather than
+ *    `'rejected'` because nobody refused anything. Consumers need not normalise those
+ *    statuses on save. The exception is a
  *    call that carries a continuation ticket (`deferred.ticket`): a server loop paused
  *    on it, nothing in the page was awaiting it, and it can still be answered
  *    (`AparteClient.resumeDeferred`).
@@ -104,12 +96,10 @@ export declare function isSegmentSettled(segment: AparteSegment): boolean;
  * Move `endedAt` to now while the segment is open; freeze it once it settles.
  *
  * `endedAt` is **the moment content last arrived**, and that is the only honest
- * signal available. Two simpler rules were tried and are wrong, both measurably:
+ * signal available. Two simpler rules are wrong:
  *
  *  - *"ends when the turn ends"* — a reasoning block would then span the whole
- *    answer that followed it. 2s of thinking before a 20s reply reads "22s". A
- *    mocked stream hides this (it moves from reasoning to text in milliseconds); a
- *    real model does not.
+ *    answer that followed it. 2s of thinking before a 20s reply would read "22s".
  *  - *"ends when the next segment starts"* — the same error, smaller: if the next
  *    segment opens ten seconds later, those ten seconds are counted as thinking,
  *    while the person watching the screen knows perfectly well nothing happened.
@@ -128,7 +118,7 @@ export declare function stampSegmentOnUpdate(segment: AparteSegment, updates: Pa
 /**
  * Merge an update into a segment without one writer erasing the other's `meta`.
  *
- * `{ ...segment, ...updates }` is wrong now that `meta` has two writers. A consumer's
+ * `{ ...segment, ...updates }` is wrong because `meta` has two writers. A consumer's
  * `updateSegment(id, { meta: { cost } })` is presentation, not activity, so it passes
  * through {@link stampSegmentOnUpdate} untouched — and a plain spread would then
  * replace the whole bag and take `meta.aparte` with it. The measurement would vanish
@@ -136,8 +126,7 @@ export declare function stampSegmentOnUpdate(segment: AparteSegment, updates: Pa
  *
  * So the bag is merged one level, and `aparte` inside it merged again. Every site that
  * folds an update into a segment goes through here — the viewport, the host and the
- * bubble each had their own spread, which is three chances to fix this twice and miss
- * once.
+ * bubble.
  */
 export declare function mergeSegmentUpdate(segment: AparteSegment, updates: Partial<AparteSegment>): AparteSegment;
 /**
@@ -145,19 +134,15 @@ export declare function mergeSegmentUpdate(segment: AparteSegment, updates: Part
  *
  * The five identity/measurement fields are optional because they describe a
  * LIFECYCLE: a segment built by hand or freshly emitted by the parser has not been
- * inserted yet, so it has no start, and an open segment has no end. Making them
- * required would either force every creation site to stamp — six of them, which is
- * the forgotten-sibling shape this seam exists to prevent — or force a hand-written
- * literal to invent values the owner then refuses to overwrite.
+ * inserted yet, so it has no start, and an open segment has no end.
  *
- * The cost of that optionality lands on the reader, and this is what removes it. The
- * guard it replaces was written three times in this repo before it earned a function:
+ * The cost of that optionality lands on the reader, and this removes it. Hand-written,
+ * the guard is
  *
  *     if (!isSegmentSettled(seg) || !seg.startedAt || !seg.endedAt) return;
  *
  * — three conditions to get right, and the last two are wrong at epoch 0, where a
- * valid timestamp is falsy. Nobody streams in 1970, but the test suite sets the clock
- * to 0 routinely, so the trap was already in the repo waiting for its first victim.
+ * valid timestamp is falsy.
  *
  * It deliberately does NOT ask whether the segment is finished: during a turn a
  * growing duration is exactly what a "thinking…" counter shows. Pair it with
@@ -168,12 +153,10 @@ export declare function segmentDuration(segment: AparteSegment): number | undefi
  * The patch that records "content just arrived on this segment".
  *
  * The append paths do not go through {@link stampSegmentOnUpdate} — they rebuild
- * the segment themselves, for reasons that predate this (the viewport must not
- * mutate an object the bubble shares; the host coalesces a frame's chunks into one
- * absolute write). They still have to move `endedAt`, because content arriving IS
- * the activity it measures. So they spread this in, and the rule stays in one file
- * — which is not a style preference: `pnpm check:segment-stamp` refused the two
- * inline `endedAt: Date.now()` this replaced, and it was right to.
+ * the segment themselves (the viewport must not mutate an object the bubble shares;
+ * the host coalesces a frame's chunks into one absolute write). They still have to
+ * move `endedAt`, because content arriving IS the activity it measures. So they spread
+ * this in, and the rule stays in one file (`pnpm check:segment-stamp` enforces it).
  *
  * Empty once the segment has settled, so a late write cannot move a final end.
  */
@@ -183,14 +166,13 @@ export declare function stampSegmentActivity(segment: AparteSegment): Partial<Ap
  * that it CLOSED, when it did.
  *
  * The parser marks the segments it closes (`</think>`, a closing fence,
- * `</artifact>`, the opening of the next block). That mark reached nobody: every
- * forwarding site sent `{ content }` alone, so a finished segment arrived at the
- * owner looking exactly like a streaming one. The end then had to be inferred from
- * the end of the TURN, which is what kept a reasoning block reading "Thinking" for
- * as long as the answer took to stream.
- *
- * Five sites forward this way across the two agent loops, which is four too many to
- * patch by hand — that is how the same rule ends up spelled three different ways.
+ * `</artifact>`, the opening of the next block). Forwarding `{ content }` alone would
+ * hand the owner a finished segment that looks exactly like a streaming one, and the
+ * end would have to be inferred from the end of the TURN — a reasoning block would
+ * read "Thinking" for as long as the answer takes to stream.
+ *
+ * Every site that forwards parser output goes through here, so the rule is spelled
+ * once.
  */
 export declare function segmentContentUpdate(segment: AparteSegment): Partial<AparteSegment>;
 /**
@@ -212,13 +194,12 @@ export declare function isTerminalStatus(status: string | null | undefined): boo
  * (`updateMessage({ status: 'completed' })`). So the message's end is the segments'
  * end, and this says which ones are still waiting for it.
  *
- * It returns ids rather than settling the array itself, and that is the point. The
- * first version did mutate in place — and the browser proved it half-broken: the
- * model gained its `endedAt` while the RENDERER never learned the segment had
- * settled, because a silent mutation notifies nobody. Routing each close through
- * the owner's own `updateSegment` gives one path that stamps the model AND repaints
- * the bubble, which is also the path `update()` and the incremental Markdown flush
- * already depend on.
+ * It returns ids rather than settling the array itself, and that is the point: a
+ * silent mutation notifies nobody, so the model would gain its `endedAt` while the
+ * RENDERER never learned the segment had settled. Routing each close through the
+ * owner's own `updateSegment` gives one path that stamps the model AND repaints the
+ * bubble, which is also the path `update()` and the incremental Markdown flush
+ * depend on.
  *
  * Already-closed segments are skipped, so reporting a turn finished twice — a
  * re-render, a branch switch, a reloaded conversation — cannot move an end.
@@ -227,21 +208,16 @@ export declare function openSegmentIds(segments: readonly AparteSegment[]): stri
 /**
  * Adopt every segment of a message arriving from storage or a server.
  *
- * The message-level counterpart of {@link adoptSegment}, and the reason it exists as a
- * function rather than a loop written four times: there are FOUR entry paths for
- * historical data (`setMessages`, `importTree`, `addMessage`, and the framework host's
- * own list setter) and they disagreed. One stamped and invented a start, one wrote
- * straight to the repository, one did nothing, and the host's `appendMessage` — same
- * name as the viewport's, opposite behaviour — did nothing either. The same stored
- * conversation therefore produced different numbers depending on the mode and on
- * whether a branch tree had been saved.
+ * The message-level counterpart of {@link adoptSegment}, shared by the FOUR entry paths
+ * for historical data (`setMessages`, `importTree`, `addMessage`, and the framework
+ * host's own list setter), so the same stored conversation produces the same numbers
+ * whatever the mode and whether a branch tree was saved.
  *
  * Always returns a NEW object, even for a message with no segments. That looks like a
  * missed optimisation and is the invariant of this whole file: the viewport hands the
  * same object to the repository AND to the framework's list, so sharing one makes the
- * immediate paint and the coalesced write land on the same string twice. Returning the
- * caller's message here doubled every streamed reply — caught by the suite that exists
- * for exactly that bug, within minutes of my writing the shortcut.
+ * immediate paint and the coalesced write land on the same string twice, doubling
+ * every streamed reply.
  */
 export declare function adoptMessageSegments<T extends {
     id: string;

package/dist/utils/segments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segments.d.ts","sourceRoot":"","sources":["../../src/utils/segments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AA6BnG;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,SAAS,aAAa,EAAE,EAClC,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,qBAAqB,GACjC,aAAa,CAWf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,YAAY,CACxB,QAAQ,EAAE,SAAS,aAAa,EAAE,EAClC,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM;AACjB,yFAAyF;AACzF,IAAI,UAAQ,GACb,aAAa,CAYf;AASD;;;;;;GAMG;AACH,wBAAgB,aAAa,CACzB,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,GACrC,mBAAmB,GAAG,SAAS,CAEjC;AA6CD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAGhE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAChC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAChC,OAAO,CAAC,aAAa,CAAC,CAgBxB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAC9B,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAChC,aAAa,CAef;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS,CAI1E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAEnF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAMnF;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE3E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,EAAE,CAE3E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAYzH;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,IAAI,CAMhE"}
+{"version":3,"file":"segments.d.ts","sourceRoot":"","sources":["../../src/utils/segments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AA2BnG;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,SAAS,aAAa,EAAE,EAClC,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,qBAAqB,GACjC,aAAa,CAWf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,YAAY,CACxB,QAAQ,EAAE,SAAS,aAAa,EAAE,EAClC,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM;AACjB,yFAAyF;AACzF,IAAI,UAAQ,GACb,aAAa,CAYf;AASD;;;;;;GAMG;AACH,wBAAgB,aAAa,CACzB,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,GACrC,mBAAmB,GAAG,SAAS,CAEjC;AA6CD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAGhE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAChC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAChC,OAAO,CAAC,aAAa,CAAC,CAgBxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAC9B,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAChC,aAAa,CAef;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS,CAI1E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAEnF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAMnF;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE3E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,EAAE,CAE3E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAYzH;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,IAAI,CAMhE"}

package/dist/utils/tool-input.d.ts

@@ -16,5 +16,5 @@
  * The return is TEXT and never markup: both call sites put it on screen through
  * `textContent` or an escaped interpolation, because the arguments are model-authored.
  */
-export declare function describeToolInput(input: unknown): string;
+export declare function describeToolInput(input: unknown, format?: (input: Record<string, unknown>) => string): string;
 //# sourceMappingURL=tool-input.d.ts.map

package/dist/utils/tool-input.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-input.d.ts","sourceRoot":"","sources":["../../src/utils/tool-input.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAOxD"}
+{"version":3,"file":"tool-input.d.ts","sourceRoot":"","sources":["../../src/utils/tool-input.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,GAAG,MAAM,CAe7G"}