@teaflask/assistant 0.3.0 → 0.7.0

package/dist/core/tool-schema-anchors.js

@@ -1,29 +1,5 @@
-// The tool-schema anchor model, pure of React: the recorder
-// maps each tool_call_annotated CUSTOM marker's schema siblings to its
-// toolCallId, the presenter reads the map to hand a mounted view its
-// `argsSchema` / `resultSchema`, and the resume store holds the map
-// across remounts. Same indirection as the display anchors — a CUSTOM
-// marker never becomes a message, so this map is the schemas' only
-// client home — plus one more feed: the approval card's
-// toolInputSchema / toolOutputSchema (the `approval_requested` marker
-// and the REST turn record's pending_approvals both build cards), so a
-// paused-then-denied call that never ran still knows its shape.
-//
-// Deliberately uncapped, unlike the display sentences' 500-char clip: a
-// clipped JSON Schema is a syntactically broken lie, not a degraded
-// sentence, and the source is the operator-reviewed catalog row the
-// approval channel already carries whole. The narrower guards shape
-// only — a plain non-array record or absent, never a fabricated `{}`.
 import { TOOL_CALL_ANNOTATED_EVENT_NAME } from "../contract/events.js";
 export const EMPTY_TOOL_SCHEMA_ANCHORS = new Map();
-/**
- * Narrow a tool_call_annotated marker's schema siblings. Null means the
- * marker anchors no schema — a display-only annotation (the common
- * completion emission), a null field (an explicit "none"), or a
- * malformed one all leave this map untouched; the display narrower owns
- * the display half independently, so neither half's absence gates the
- * other.
- */
 export function toolSchemaAnchorOf(value) {
     if (typeof value !== "object" || value === null) {
         return null;
@@ -46,17 +22,6 @@ export function toolSchemaAnchorOf(value) {
     }
     return { toolCallId, schemas };
 }
-/**
- * Idempotent per-field merge, first non-absent value wins: the schemas
- * legitimately arrive more than once for one call (the approval card's
- * feed for a paused call, then the progress annotation once it runs,
- * then every replay again), and re-applying the same sequence changes
- * nothing. A no-op merge returns the map unchanged — identity is the
- * publish gate — and a merged entry keeps the previously stored field
- * REFERENCES, so a schema handed to a mounted view stays
- * identity-stable across re-records (the slot's delivery guard compares
- * `===`).
- */
 export function withToolSchemasAnchored(previous, toolCallId, schemas) {
     const existing = previous.get(toolCallId);
     if (existing === undefined) {
@@ -81,17 +46,8 @@ export function withToolSchemasAnchored(previous, toolCallId, schemas) {
     next.set(toolCallId, merged);
     return next;
 }
-/**
- * A defensive re-validation for seeding transcript state from the
- * resume store, like every sibling anchors map: an entry that is not a
- * string-keyed record of plain-record schemas is dropped rather than
- * rendered (or crashed on) — a stale shape becomes a missing schema,
- * never a wedged resume.
- */
 export function wellFormedToolSchemaAnchorsOf(stored) {
     const seeded = new Map();
-    // The narrowing deliberately distrusts the map's own types (the seam
-    // where any future persisted form of the store must degrade).
     const entries = stored;
     for (const [toolCallId, schemas] of entries) {
         if (typeof toolCallId !== "string" || !_isWellFormedSchemas(schemas)) {
@@ -101,7 +57,6 @@ export function wellFormedToolSchemaAnchorsOf(stored) {
     }
     return seeded;
 }
-/** Records each annotated call's toolCallId → registered schemas. */
 export function toolSchemaRecorder(onSchemasAnchored) {
     return {
         onCustomEvent({ event }) {
@@ -115,15 +70,6 @@ export function toolSchemaRecorder(onSchemasAnchored) {
         },
     };
 }
-/**
- * The approval card's schemas as an anchorable record — the null→absent
- * seam for the channel's other producer. The card model is the single
- * already-narrowed home of the `approval_requested` marker's
- * tool_input_schema / tool_output_schema (stream AND the REST turn
- * record's pending_approvals — approval-inbox.ts), so this consumes the
- * built card rather than re-narrowing the wire a second time. Null on a
- * card that carries neither schema.
- */
 export function approvalCardSchemasOf(card) {
     if (card.toolInputSchema === null && card.toolOutputSchema === null) {
         return null;
@@ -137,9 +83,6 @@ export function approvalCardSchemasOf(card) {
     }
     return schemas;
 }
-/** A schema is a plain non-array record, verbatim; anything else —
- *  null, an array, a string — is absent, never a crash and never `{}`
- *  invented from a malformed value. */
 function _schemaOf(schema) {
     if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
         return undefined;
@@ -156,4 +99,3 @@ function _isWellFormedSchemas(schemas) {
     return (fieldsAreWellTypedOrAbsent &&
         (argsSchema !== undefined || resultSchema !== undefined));
 }
-//# sourceMappingURL=tool-schema-anchors.js.map

package/dist/core/tool-sentence-anchors.js

@@ -1,22 +1,6 @@
-// The sentence-carrying tool-result anchor family, pure of React: one
-// factory behind tool-error-anchors and tool-refusal-anchors (the
-// sibling of tool-flag-anchors' boolean family). Each instance maps
-// a TOOL_CALL_RESULT extra that carries a server-derived sentence to the
-// toolCallIds carrying it: the recorder collects sentences from the live
-// stream, the transcript reads the map to light a call's state and show
-// the sentence, and the resume store holds the map across remounts. The
-// indirection exists because @ag-ui/client 1.0 strips unknown top-level
-// fields before any subscriber — the transport lifts the extras into
-// metadata (core/tool-outcome.ts), and the map is the sentence's only home
-// on the client. The two bindings differ in exactly one rule, stated at
-// the factory's door: whether the empty string counts.
 import { toolOutcomeOf } from "./tool-outcome.js";
 import { WIRE_SENTENCE_MAX_CHARS } from "./wire-sentence-cap.js";
-export function toolSentenceAnchorsOf(
-// The closed set of sentence-carrying TOOL_CALL_RESULT extras: a typo
-// here would compile into a map that silently never fills, so the type
-// refuses anything off the wire.
-field, options) {
+export function toolSentenceAnchorsOf(field, options) {
     function sentenceOf(event) {
         const value = toolOutcomeOf(event)[field];
         if (typeof value !== "string") {
@@ -40,8 +24,6 @@ field, options) {
         },
         wellFormedOf: (stored) => {
             const seeded = new Map();
-            // The narrowing deliberately distrusts the map's own types: this
-            // seam turns a stale shape into a missing sentence, never a crash.
             const entries = stored;
             for (const [toolCallId, sentence] of entries) {
                 if (typeof toolCallId === "string" && typeof sentence === "string") {
@@ -62,4 +44,3 @@ field, options) {
         },
     };
 }
-//# sourceMappingURL=tool-sentence-anchors.js.map

package/dist/core/tool-view.d.ts

@@ -1,135 +1,235 @@
 import type { ToolCallState } from "./tool-call-display.js";
-/** The resolved palette a view renders under — "light" | "dark", never the
- *  authored "auto" (use-resolved-theme-mode.ts resolves it). */
+/** The palette a tool view renders in. */
 export type ToolViewThemeMode = "light" | "dark";
-/** A JSON Schema document, verbatim from the wire: the catalog row's
- *  declared shape, untyped by design — data a view may read, never validated. */
+/** A JSON Schema document, passed through as received and never validated. */
 export type JsonSchema = Record<string, unknown>;
-/** The recorded tool call a view presents — the contract's entire data
- *  surface. The generics default to today's untyped behaviour so generated
- *  per-org argument types are usable when they arrive. */
+/**
+ * One tool or action call, as a tool view receives it. You get a fresh copy
+ * through `update` as the call progresses; never mutate it.
+ */
 export interface ToolViewCall<TArgs = Record<string, unknown>, TResult = unknown> {
+    /** The tool's name. For an action, `action__<slug>`. */
     toolName: string;
+    /**
+     * Unique id of the call, stable for its whole life and equal to the
+     * `data-tf-tool-call-id` attribute on its row. Empty when the call has no
+     * id.
+     */
     toolCallId: string;
+    /** Where the call is in its life. See ToolCallState for each value. */
     status: ToolCallState;
-    /** True while a pending approval or elicitation anchored to this call
-     *  awaits the member. The view may say so; it can never decide. */
+    /**
+     * True while an approval or a question tied to this call is waiting on the
+     * user. The view may say so, but the decision itself happens in the
+     * assistant's own card, never in the view.
+     */
     awaitingDecision: boolean;
-    /** The streamed arguments, parsed, minus the protocol-reserved `caption`
-     *  — the row's label, never an argument. `{}` while the argument text is
-     *  still arriving or is not a JSON record. */
+    /**
+     * The arguments the agent passed, parsed, without the short caption the
+     * agent writes for each step; `{}` while they are still streaming in or if
+     * they are not a JSON object. For an action, `{ path_params, query, body
+     * }`, with one key for each part your API operation declares.
+     */
     args: TArgs;
-    /** The result parsed for presentation: the tool-result/v1 envelope
-     *  unwrapped (core/tool-result-envelope.ts), other JSON passed through.
-     *  Absent until it lands, when not JSON, or when `truncated`. */
+    /**
+     * The parsed result once the call has finished; for an action, your API's
+     * response body alone (read the HTTP status with
+     * `actionEnvelopeOf(resultText)`). Undefined until the result arrives, when
+     * it is not JSON, or when `truncated` is true.
+     */
     result?: TResult;
-    /** The result verbatim from the wire; absent until it lands (and
-     *  withheld upstream on errored, denied, cancelled, refused and
-     *  offloaded calls, exactly as the technical panes withhold it). */
+    /**
+     * The raw result text as recorded. Undefined until the call finishes, and
+     * withheld for calls that failed, were not approved, didn't run, were
+     * declined or had their result replaced by a preview.
+     */
     resultText?: string;
-    /** True when the wire's result was degraded to fit the size cap: the
-     *  bytes in `resultText` are honest; `result` refuses to structure them. */
+    /**
+     * True when the result was cut to fit a size limit. `result` is then
+     * undefined and `resultText` holds only the cut text, so don't show it as
+     * complete.
+     */
     truncated?: boolean;
-    /** True when the wire's result was the context offloader's
-     *  model-facing replacement, not the tool's output. */
+    /**
+     * True when the result was too large for the agent and was replaced by a
+     * shortened preview. The tool's real output is not available to the view.
+     */
     offloaded?: boolean;
+    /**
+     * Why the call failed, set when it failed. Use humanFailureSentenceOf to
+     * get a sentence fit for the user, and actionFailureOf to read an action's
+     * HTTP status, error code and per-field problems.
+     */
     errorText?: string;
+    /**
+     * Teaflask's reason for declining the call, set when `status` is "refused".
+     */
     refusalText?: string;
-    /** The tool's registered argument schema, when the wire carried one (the
-     *  `approval_requested` marker or `tool_call_annotated`). Absent
-     *  is a legitimate answer — `undefined`, never `{}`, never inferred — and
-     *  a view must degrade, never demand. The runtime door beside `TArgs`. */
+    /**
+     * The JSON Schema of the tool's arguments, when it declared one. For an
+     * action, built from your operation's path, query and body schemas;
+     * undefined (never `{}`) otherwise, so a view must still work without it.
+     */
     argsSchema?: JsonSchema;
-    /** The tool's registered success-result schema (`tool_output_schema`)
-     *  — same channels and absence semantics as `argsSchema`. */
+    /**
+     * The JSON Schema of the tool's successful result, when it declared one.
+     * For an action, your operation's success response body schema, which
+     * matches `result`; undefined otherwise.
+     */
     resultSchema?: JsonSchema;
 }
-/** What a view receives — the call, and the one ambient fact it may not
- *  resolve itself. Additively extensible: a future `actions` member is a
- *  recorded reserved step (tool-views.md), never this contract's. */
+/** What a tool view's `mount` and `update` receive. */
 export interface ToolViewProps<TArgs = Record<string, unknown>, TResult = unknown> {
+    /** The call to draw. */
     call: ToolViewCall<TArgs, TResult>;
+    /**
+     * `themeMode` is the palette the assistant is actually painted in, "light"
+     * or "dark", with an "auto" setting already resolved. A change arrives
+     * through `update`.
+     */
     context: {
         themeMode: ToolViewThemeMode;
     };
 }
-/** A mounted view. `update` MUST apply new props in place, so local UI
- *  state survives the call's status advancing; `destroy` runs on unmount. */
+/** A mounted tool view, as returned from `mount`. */
 export interface ToolViewInstance<TArgs = Record<string, unknown>, TResult = unknown> {
+    /**
+     * Called with new props whenever the call changes (arguments arrive, status
+     * advances, the result lands, an approval opens or settles) or the theme
+     * changes. Apply them to the existing view so the user's state in it
+     * survives; a throw makes the assistant show the next matching view.
+     */
     update(props: ToolViewProps<TArgs, TResult>): void;
+    /**
+     * Called when the view is removed. Release any listeners, timers or roots
+     * you created.
+     */
     destroy(): void;
 }
-/** The canonical authoring form: an imperative mount into a package-owned
- *  container. A throw from `mount` or `update` is the adapter's one failure
- *  channel — the slot reports it and resolution falls to the rung below.
- *  `mount`/`update` are METHOD declarations on purpose: bivariant parameters
- *  let a typed adapter assign into the default-typed registration slot
- *  (docs/tool-call-contract.md, "Adapter typing" — use `type` aliases). */
+/**
+ * A tool view, which draws one tool or action call inside its row in the
+ * conversation in place of the default view of its arguments. Write one
+ * directly for plain DOM or any framework, or create one from a React component
+ * with reactToolView.
+ */
 export interface ToolViewAdapter<TArgs = Record<string, unknown>, TResult = unknown> {
+    /**
+     * Called once per call, even while its row is collapsed. Draw into
+     * `container` (the assistant owns it) and return the instance that receives
+     * updates; if `mount` throws, the error goes to the provider's `onError`
+     * and the next matching view is shown instead.
+     */
     mount(container: HTMLElement, props: ToolViewProps<TArgs, TResult>): ToolViewInstance<TArgs, TResult>;
 }
-/** The operation-mark role: the identical lifecycle over identical props,
- *  named apart so the roles can diverge additively (tool-view-slot.tsx). */
+/**
+ * A custom icon for a tool call, drawn in place of the default glyph in the
+ * small mark beside the row's label. Same mount, update and destroy lifecycle
+ * as a view; reactToolView can create one from a React component.
+ */
 export interface IconAdapter<TArgs = Record<string, unknown>, TResult = unknown> {
+    /**
+     * Draws the icon into `container` and returns the instance that receives
+     * later updates and teardown. If it throws, the next matching icon or the
+     * default glyph is shown instead.
+     */
     mount(container: HTMLElement, props: ToolViewProps<TArgs, TResult>): ToolViewInstance<TArgs, TResult>;
 }
-/** One registration, two roles: a view, an icon, or both. `version` is the
- *  contract version the adapters target; a wire ref resolves only on exact
- *  match (rungs 1 and 3). Default-typed slots: registries are heterogeneous. */
+/** One entry in your tool-view registry, carrying a view, an icon, or both. */
 export interface ToolViewRegistration {
-    version: number;
+    /**
+     * Leave it out for your own tools and actions; they match by tool name,
+     * which ignores it. It only matters for a view key the server names, which
+     * must match this version exactly.
+     */
+    version?: number;
+    /**
+     * Draws the call in its row's body, replacing the default view of its
+     * arguments.
+     */
     view?: ToolViewAdapter;
+    /**
+     * Replaces the glyph in the small mark beside the row's label. The mark's
+     * frame stays.
+     */
     icon?: IconAdapter;
 }
-/** The registry a trusted host supplies (`toolViews` on the provider or the
- *  script-tag elements), keyed by the wire key a backend annotation names
- *  (rung 1) or the host's exact tool name (rung 2). No code rides the wire. */
+/**
+ * Your tool views, keyed by tool name (for an action, `action__<slug>`; see
+ * actionToolViews) or by a view key the server names, and passed as `toolViews`
+ * on the provider or the script-tag element. Keys starting with `teaflask.` are
+ * reserved and ignored.
+ */
 export type ToolViewRegistry = Readonly<Record<string, ToolViewRegistration>>;
-/** True for keys the package owns. A reserved key never resolves through
- *  the HOST registry — by wire key or tool name — so tool output can never
- *  name a privileged view and a host cannot occupy the namespace. */
 export declare function isReservedToolViewKey(key: string): boolean;
-/** Rung 3 — the package's own views under reserved `teaflask.*` keys, as
- *  vanilla adapters (runtime-React-free); the backend names them beside the
- *  tools in tool_call_display.py. Frozen: nothing registers here at runtime. */
 export declare const PACKAGE_TOOL_VIEWS: ToolViewRegistry;
-/** The tool name a granted catalog action mounts as
- *  (the serving side's action_tool_name): the slug shown on the
- *  Actions page, under the `action__` prefix — the one spelling a HOST
- *  gets. The dashboard's agent-config twin (draft-writers.ts, kept apart
- *  by the import law) is pinned equal to this and the backend constant by
- *  the dashboard's action-tool-prefix test. */
+/**
+ * Returns the tool name an action runs under, `action__<slug>`, where the slug
+ * is the one shown for the action on its Actions page in Teaflask.
+ */
 export declare function actionToolName(slug: string): string;
-/** A registry written in action SLUGS — the names the Actions page shows
- *  — keyed for rung 2 by the tool name each slug mounts as. A registry
- *  of ordinary tool names composes beside it with a spread. */
+/**
+ * Builds a tool-view registry keyed by action slug instead of tool name, by
+ * turning each slug into `action__<slug>`. Spread the result beside a registry
+ * of ordinary tool names and pass both as `toolViews`.
+ */
 export declare function actionToolViews(bySlug: Readonly<Record<string, ToolViewRegistration>>): ToolViewRegistry;
-/** A statically resolved view candidate: which rung answered, under
- *  which key, with which adapter. */
+/** One tool view that matches a call, and how it matched. */
 export interface ResolvedToolView {
+    /**
+     * How the view matched, where lower wins. 1 is your registry by the view
+     * key and version the server named for this call, 2 is your registry by the
+     * call's exact tool name (for an action, `action__<slug>`), and 3 is a view
+     * built into the package; because 2 beats 3, registering under a built-in
+     * tool's name replaces its view, and with no match at all the package's
+     * default view of the arguments is shown.
+     */
     rung: 1 | 2 | 3;
+    /**
+     * The registry key that matched, either the server-named view key or the
+     * tool name.
+     */
     key: string;
+    /** The view to mount. */
     adapter: ToolViewAdapter;
 }
+/** One tool-call icon that matches a call, and how it matched. */
 export interface ResolvedToolViewIcon {
+    /**
+     * How the icon matched, with the same meaning as ResolvedToolView.rung. 1
+     * is your registry by the server-named view key and version, 2 is your
+     * registry by exact tool name, and 3 is a built-in.
+     */
     rung: 1 | 2 | 3;
+    /**
+     * The registry key that matched, either the server-named view key or the
+     * tool name.
+     */
     key: string;
+    /** The icon to mount. */
     adapter: IconAdapter;
 }
-/** The presenter's tool-view slot: the rung 1–3 candidates in ladder order,
- *  per role, plus the lazily assembled call (tool-call-presentation.ts).
- *  Rung 4 — the package default — is the definitional terminal, never a
- *  list member: exhausting `views` IS the resolution "package default". */
+/**
+ * The views and icons that match one call, best first, plus the call they will
+ * receive.
+ */
 export interface ToolViewResolution {
+    /**
+     * Matching views, best first. The first that mounts without throwing is
+     * shown; an empty list means the default view of the arguments.
+     */
     views: readonly ResolvedToolView[];
+    /** Matching icons, best first. An empty list means the default glyph. */
     icons: readonly ResolvedToolViewIcon[];
+    /** The call the matched view receives, built the first time it is read. */
     call: ToolViewCall;
 }
-/** The four-rung resolution ladder (docs/tool-call-contract.md, "The
- *  resolution ladder"), static half: host registry by exact `{key,
- *  version}` (1), host registry by exact tool name (2), package built-ins
- *  by reserved `teaflask.*` key (3); rung 4 is the definitional default.
- *  Own-property-guarded lookups; reserved keys refused at both host rungs. */
+/**
+ * Finds the registered views and icons that match one tool call, best first,
+ * from the view the server named for it (if any), its tool name and your
+ * registry. The assistant does this for you; call it only if you render tool
+ * calls yourself, and treat an empty `views` list as "use the default view of
+ * the arguments".
+ */
 export declare function resolvedToolViewsOf(ref: {
     key: string;
     version: number;
@@ -137,4 +237,3 @@ export declare function resolvedToolViewsOf(ref: {
     views: readonly ResolvedToolView[];
     icons: readonly ResolvedToolViewIcon[];
 };
-//# sourceMappingURL=tool-view.d.ts.map

package/dist/core/tool-view.js

@@ -1,25 +1,12 @@
-// The tool-view contract (tool-views.md): one view per tool call, resolved
-// once over four rungs, mounted once in the row's body for the call's whole
-// lifecycle. A view is a presentation of a tool call, not an approval
-// mechanism — it receives the call and nothing else. The imperative adapter
-// is canonical; the React registry is sugar over the same lifecycle: one
-// contract, two spellings, never two systems. Runtime-React-free by design.
 import { actionToolView } from "../components/tool-views/action-view.js";
 import { commandToolView } from "../components/tool-views/command-view.js";
 import { docsSearchToolView } from "../components/tool-views/docs-search-view.js";
 import { fileEditToolView } from "../components/tool-views/file-edit-view.js";
 import { questionsToolView } from "../components/tool-views/questions-view.js";
-/** The reserved namespace for package-shipped views (rung 3). */
 const RESERVED_TOOL_VIEW_KEY_PREFIX = "teaflask.";
-/** True for keys the package owns. A reserved key never resolves through
- *  the HOST registry — by wire key or tool name — so tool output can never
- *  name a privileged view and a host cannot occupy the namespace. */
 export function isReservedToolViewKey(key) {
     return key.startsWith(RESERVED_TOOL_VIEW_KEY_PREFIX);
 }
-/** Rung 3 — the package's own views under reserved `teaflask.*` keys, as
- *  vanilla adapters (runtime-React-free); the backend names them beside the
- *  tools in tool_call_display.py. Frozen: nothing registers here at runtime. */
 export const PACKAGE_TOOL_VIEWS = Object.freeze({
     "teaflask.questions": { version: 1, view: questionsToolView },
     "teaflask.action": { version: 1, view: actionToolView },
@@ -27,18 +14,9 @@ export const PACKAGE_TOOL_VIEWS = Object.freeze({
     "teaflask.file-edit": { version: 1, view: fileEditToolView },
     "teaflask.docs-search": { version: 1, view: docsSearchToolView },
 });
-/** The tool name a granted catalog action mounts as
- *  (the serving side's action_tool_name): the slug shown on the
- *  Actions page, under the `action__` prefix — the one spelling a HOST
- *  gets. The dashboard's agent-config twin (draft-writers.ts, kept apart
- *  by the import law) is pinned equal to this and the backend constant by
- *  the dashboard's action-tool-prefix test. */
 export function actionToolName(slug) {
     return `action__${slug}`;
 }
-/** A registry written in action SLUGS — the names the Actions page shows
- *  — keyed for rung 2 by the tool name each slug mounts as. A registry
- *  of ordinary tool names composes beside it with a spread. */
 export function actionToolViews(bySlug) {
     const registry = {};
     for (const [slug, registration] of Object.entries(bySlug)) {
@@ -46,11 +24,6 @@ export function actionToolViews(bySlug) {
     }
     return registry;
 }
-/** The four-rung resolution ladder (docs/tool-call-contract.md, "The
- *  resolution ladder"), static half: host registry by exact `{key,
- *  version}` (1), host registry by exact tool name (2), package built-ins
- *  by reserved `teaflask.*` key (3); rung 4 is the definitional default.
- *  Own-property-guarded lookups; reserved keys refused at both host rungs. */
 export function resolvedToolViewsOf(ref, toolName, registry, builtIns = PACKAGE_TOOL_VIEWS) {
     const candidates = [];
     if (ref !== undefined && !isReservedToolViewKey(ref.key)) {
@@ -95,4 +68,3 @@ function _ownRegistrationOf(registry, key) {
         ? registry[key]
         : undefined;
 }
-//# sourceMappingURL=tool-view.js.map

package/dist/core/transcript-lease.js

@@ -1,30 +1,9 @@
-// Surface presence — the transcript lease: a mounted transcript chrome
-// registers its presence for its lifetime, and presence is what upgrades
-// the socket policy and arms the leased idle re-read. The _leaseHolders
-// roster stays a store field per the friend convention.
 import { publishStore, scheduleConnectionSync, } from "./conversation-publish.js";
 import { syncIdleRecheck } from "./idle-recheck.js";
-/** A mounted transcript chrome registers its presence for its lifetime;
- *  the release is the returned function (idempotent). Any number of
- *  surfaces may render the same cells concurrently — the store is the
- *  only connection driver, so there is nothing left to collide.
- *  Presence upgrades the socket policy (see syncConnection): a mounted
- *  surface guarantees the epoch connects once so history paints, and
- *  the LAST release mid-live-turn changes nothing — the store's own run
- *  simply keeps streaming (the old CopilotChat-abort handoff dance is
- *  gone with the chassis). LAW: never bump reconnectNonce
- *  from this release path — a keyed remount releases and re-acquires in
- *  one tick during normal reconnects. */
 export function acquireTranscriptLeaseFromStore(store, surface) {
     store._leaseHolders.push(surface);
-    // A human is present again: the automatic-reconnect budget refills.
     store._automaticReconnects = 0;
-    // The presence flip may demand a connect (a chrome mounting over a
-    // never-connected epoch); the decision rides the same coalesced
-    // microtask as every other trigger.
     scheduleConnectionSync(store);
-    // Presence also arms the idle re-read — the acquire path
-    // deliberately never publishes, so the sync must run here.
     syncIdleRecheck(store);
     let released = false;
     return () => {
@@ -36,11 +15,6 @@ export function acquireTranscriptLeaseFromStore(store, surface) {
         if (index !== -1) {
             store._leaseHolders.splice(index, 1);
         }
-        // The publish schedules the connect decision on the coalesced
-        // microtask (see scheduleConnectionSync), so a keyed transcript
-        // REMOUNT (release then re-acquire in the same tick) is seen
-        // settled before the store acts.
         publishStore(store);
     };
 }
-//# sourceMappingURL=transcript-lease.js.map