@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/sequences-react/lazy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Code-split entry for the timeline editor. The editor pulls in canvas
+ * painting, waveform decode, and gesture machinery products only need on the
+ * sequence route — `React.lazy` keeps it out of their main bundle. Mount
+ * inside a `<Suspense>` boundary.
+ */
+import React from 'react';
+export declare const SequenceTimelineEditorLazy: React.LazyExoticComponent<typeof import("./components").TimelineEditor>;

package/dist/sequences-react/media/frame-provider.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Baseline frame pipeline behind the `VideoFrameProvider` seam: an off-DOM
+ * HTMLVideoElement pool for video URLs and an HTMLImageElement pool for
+ * stills, merged by a per-URL kind dispatcher so the editor canvas never
+ * cares which kind a clip's media is. A WebCodecs implementation can replace
+ * this wholesale behind the same seam.
+ *
+ * Server-safe at import time, browser-only at call time: nothing touches
+ * `document` or `fetch` until a provider method runs.
+ */
+import type { VideoFrameProvider } from '../contracts';
+/** Define the default maximum number of media elements allowed in a collection */
+export declare const DEFAULT_MAX_MEDIA_ELEMENTS = 4;
+/** Half a frame at 30fps. Seeks closer than this repaint the decoder's
+ *  current frame instead of forcing a redundant seek. */
+export declare const SEEK_TOLERANCE_SECONDS: number;
+/** A seek that hasn't fired `seeked` after this long is a decode failure —
+ *  the draw REJECTS rather than painting whatever frame happens to be up. */
+export declare const SEEK_TIMEOUT_MS = 5000;
+/** Define a rectangular frame with position and size properties x, y, width, and height */
+export interface FrameRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Object-fit 'contain' placement: preserve aspect ratio, fit entirely inside
+ *  `dest`, center the residual space. Callers own clearing the letterbox
+ *  margins — this paints only the fitted region. */
+export declare function containFitRect(source: {
+    width: number;
+    height: number;
+}, dest: FrameRect): FrameRect;
+/** Determine if seeking is required based on the difference between current and target times */
+export declare function needsSeek(currentTimeSeconds: number, targetSeconds: number): boolean;
+/** Manage a leased element from a pool and release it to enable LRU eviction */
+export interface PooledElementLease<T> {
+    element: T;
+    /** Unpins the element; idle elements become LRU-evictable. Idempotent. */
+    release(): void;
+}
+/** Manage a pool of media elements to acquire, check, count, and dispose resources efficiently */
+export interface MediaElementPool<T> {
+    acquire(url: string): PooledElementLease<T>;
+    has(url: string): boolean;
+    size(): number;
+    dispose(): void;
+}
+/** LRU pool of media elements keyed by URL. Entries pinned by an outstanding
+ *  lease are never evicted — a draw in flight must keep its element — so the
+ *  pool can temporarily exceed `maxElements` under concurrent draws and
+ *  shrinks back as leases release. */
+export declare function createMediaElementPool<T>(opts: {
+    maxElements: number;
+    create(url: string): T;
+    destroy(element: T, url: string): void;
+}): MediaElementPool<T>;
+/** Extension-based kind classification; 'unknown' defers to a HEAD
+ *  content-type probe at draw time. */
+export declare function classifyMediaUrl(url: string): 'video' | 'image' | 'unknown';
+/** Stills behind the same `VideoFrameProvider` seam — `sourceSeconds` is
+ *  validated for contract parity but does not affect the painted pixels. */
+export declare function createImageFrameProvider(opts?: {
+    maxElements?: number;
+}): VideoFrameProvider;
+/** The baseline provider `TimelineEditorProps.frameProvider` defaults to.
+ *  Video and image pools each hold up to `maxElements` entries. */
+export declare function createVideoElementFrameProvider(opts?: {
+    maxElements?: number;
+}): VideoFrameProvider;

package/dist/sequences-react/media/transcription.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Whisper transcription behind the `TranscriptionProvider` seam, powered by
+ * the OPTIONAL peer `@huggingface/transformers`. The peer is loaded with a
+ * dynamic variable-specifier import inside `transcribe()` so bundlers leave
+ * it external and apps that never transcribe never pay for it. `available`
+ * is the sync UI affordance signal; `transcribe()` re-verifies with the real
+ * import and is the source of truth.
+ */
+import type { TranscriptionProvider, TranscriptionSegment } from '../contracts';
+import type { AudioBufferLike } from './waveform';
+/** Provide the default Whisper model identifier for ONNX community large v3 turbo */
+export declare const DEFAULT_WHISPER_MODEL = "onnx-community/whisper-large-v3-turbo";
+interface WhisperChunk {
+    text: string;
+    timestamp: [number, number | null];
+}
+/** Define the structure for transcribed text output with optional segmented chunks */
+export interface WhisperOutput {
+    text: string;
+    chunks?: WhisperChunk[];
+}
+/** Mean-mixdown to mono. Single-channel buffers return the live channel data
+ *  without copying — callers must treat the result as read-only. */
+export declare function mixdownToMono(buffer: AudioBufferLike): Float32Array;
+/** Map whisper chunk output to contract segments. A `null` end timestamp is
+ *  whisper's "ran past the end of the audio" sentinel on the final chunk and
+ *  resolves to the audio duration. */
+export declare function mapWhisperOutput(output: WhisperOutput | WhisperOutput[], durationSeconds: number, mediaUrl: string): TranscriptionSegment[];
+/** Create a Whisper-based transcription provider with optional model configuration */
+export declare function createWhisperTranscriptionProvider(opts?: {
+    model?: string;
+}): TranscriptionProvider;
+export {};

package/dist/sequences-react/media/waveform.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Waveform rendering for audio clips: bucketed max-abs peaks computed once
+ * per (media, zoom bucket count) and painted as mirrored bars around the
+ * track lane's midline. `computeWaveform` is pure so peak math is testable
+ * without Web Audio; `loadWaveform` is the browser edge that decodes real
+ * media into it.
+ */
+import type { WaveformData } from '../contracts';
+/** Structural slice of Web Audio's AudioBuffer so peak math runs on synthetic
+ *  fixtures in tests and on real decoded buffers in the browser. */
+export interface AudioBufferLike {
+    numberOfChannels: number;
+    length: number;
+    sampleRate: number;
+    duration: number;
+    getChannelData(channel: number): Float32Array;
+}
+/** One max-abs peak per bucket, taken across all channels. `peaks[b]` is the
+ *  loudest absolute sample in bucket `b`; rendering mirrors it around the
+ *  midline, which is what the contract's "peak pair" denotes. Buckets past
+ *  the end of short audio hold 0. */
+export declare function computeWaveform(buffer: AudioBufferLike, bucketCount: number): WaveformData;
+/** Fetch + decode `mediaUrl` and bucket it. Pass `ctx` to reuse a shared
+ *  AudioContext; otherwise one is created and closed around the decode. */
+export declare function loadWaveform(mediaUrl: string, bucketCount: number, ctx?: AudioContext): Promise<WaveformData>;
+/** Paint mirrored peak bars centered on the rect's midline. Silent buckets
+ *  still paint a 1px hairline so the lane reads as audio, not as empty;
+ *  peaks beyond ±1.0 (hot masters) clip to the full lane height. */
+export declare function drawWaveform(ctx: CanvasRenderingContext2D, data: WaveformData, rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, color: string): void;

package/dist/session-shell/index.d.ts

@@ -1,174 +1,3 @@
-/**
- * Nav destinations, and the guard that proves every href the rail renders
- * resolves to a route the product's router actually registered.
- *
- * A rail row's href is assembled from a base plus a relative path, and nothing
- * downstream re-checks it: the sidebar renders a link, the click navigates, and
- * the router answers 404. A unit test written against the nav builder alone
- * cannot catch that — it asserts the href the builder produced, which is the
- * same wrong string the user clicks.
- *
- * Two mechanisms, meant to be used together:
- *
- * 1. `NavDestination` makes the base a REQUIRED discriminant (`scope`). An
- *    optional `absolute?: boolean`-style flag has the opposite property:
- *    omitting it type-checks, and the destination silently resolves under the
- *    workspace prefix instead of the app-level one. A required literal union
- *    turns that omission into a compile error, and widening `TScope` demands a
- *    base for the new scope rather than defaulting to a wrong one.
- * 2. `assertNavHrefsRegistered` matches every resolved href against the route
- *    table, so a destination the router never registered fails a test instead
- *    of a user's click. It reads the product's real route table, so it cannot
- *    agree with the builder's mistake the way a hand-maintained expected-href
- *    list does.
- */
-/** The bases a product routes rail rows under. `workspace` is the per-workspace
- *  prefix (`/app/ws_123`); `app` is the account-level one (`/app`), where
- *  singleton surfaces such as a shared terminal or billing live. */
-type NavScope = 'workspace' | 'app';
-/** A base path per scope. Widening `TScope` widens this record, so a product
- *  that adds a scope cannot compile until it supplies that scope's base. */
-type NavScopeBases<TScope extends string = NavScope> = Readonly<Record<TScope, string>>;
-/** One rail destination as the product declares it, before a base is applied. */
-interface NavDestination<TScope extends string = NavScope> {
-    id: string;
-    /** Path relative to the base named by `scope`. `''` is the base itself.
-     *  Must be empty or start with `/` — a bare `'vault'` would concatenate into
-     *  `/app/ws_123vault`, so it is rejected rather than silently repaired. */
-    path: string;
-    /** Which base `path` resolves against. Required on purpose. */
-    scope: TScope;
-}
-/** A destination with its base applied. */
-interface ResolvedNavDestination<TScope extends string = NavScope> {
-    id: string;
-    href: string;
-    scope: TScope;
-}
-/** Apply a destination's scope base to its path.
- *
- *  Throws when the scope has no base configured — a product that assembles
- *  `bases` dynamically can defeat the type-level guarantee, and a missing base
- *  would otherwise produce `undefined/vault`. */
-declare function resolveNavHref<TScope extends string>(destination: NavDestination<TScope>, bases: NavScopeBases<TScope>): string;
-/** Apply the bases to every destination, preserving declaration order. */
-declare function resolveNavDestinations<TScope extends string>(destinations: readonly NavDestination<TScope>[], bases: NavScopeBases<TScope>): ResolvedNavDestination<TScope>[];
-interface ResolveScopedActiveNavIdOptions<TScope extends string = NavScope> {
-    pathname: string;
-    destinations: readonly NavDestination<TScope>[];
-    bases: NavScopeBases<TScope>;
-    /** Extra ABSOLUTE prefixes that light an existing row, e.g.
-     *  `{ '/app/ws_1/agents': 'integrations' }`. Same longest-prefix contest. */
-    aliases?: Readonly<Record<string, string>>;
-    /** ABSOLUTE prefixes that deliberately highlight nothing, beating any shorter
-     *  match. */
-    claimsNothing?: readonly string[];
-}
-/**
- * The rail row to highlight, across scopes.
- *
- * `resolveActiveNavId` resolves rows against ONE base, so an app-level row can
- * only be highlighted by a second, hand-rolled scan — the same split that lets
- * an app-level destination render under the workspace base. This resolves the
- * hrefs first and runs a single longest-prefix contest over absolute paths, so
- * declaration order cannot change the answer and no scope needs its own pass.
- *
- * Prefixes in `aliases` / `claimsNothing` are absolute here, unlike
- * `resolveActiveNavId`'s base-relative ones, because the contest itself is
- * absolute.
- */
-declare function resolveScopedActiveNavId<TScope extends string>({ pathname, destinations, bases, aliases, claimsNothing, }: ResolveScopedActiveNavIdOptions<TScope>): string | undefined;
-/**
- * One entry of a registered route table. Structurally compatible with
- * react-router's `RouteConfigEntry`, so a product passes its real `routes.ts`
- * default export straight in — the point of the guard is that it reads the
- * router's own truth rather than a second list that can agree with the bug.
- */
-interface RegisteredRoute {
-    /** Absent on a pathless layout route: its children inherit the parent path. */
-    path?: string;
-    index?: boolean;
-    children?: readonly RegisteredRoute[];
-}
-/** A route table entry is either a bare pattern string or a router config node. */
-type NavRouteTable = readonly (string | RegisteredRoute)[];
-/**
- * Every path pattern the table registers, rooted and de-duplicated.
- *
- * Parent nodes contribute their own cumulative path as well as their children's:
- * a router matches a parent route with an index child at the parent path, and a
- * parent without one still matches with an empty outlet, so treating parents as
- * unregistered would flag working hrefs.
- */
-declare function flattenRouteTable(table: NavRouteTable): string[];
-/**
- * A nav row as the guard needs to see it. Structurally satisfied by
- * `SessionRailNavItem` / `SessionRailSubItem` and by sandbox-ui's
- * `SidebarLayoutNavItem`, so the guard runs over the builder's real output
- * rather than a re-declaration of it.
- */
-interface NavHrefItem {
-    id: string;
-    href: string;
-    subItems?: readonly NavHrefItem[];
-}
-type NavHrefProblemReason = 
-/** No registered pattern matches the resolved href. */
-'unregistered'
-/** Empty, fragment-only, or not rooted at `/` — the row navigates nowhere
- *  predictable regardless of the route table. */
- | 'not-a-path'
-/** Leaves the router (scheme or protocol-relative) while `allowExternal` is
- *  off. */
- | 'external';
-interface NavHrefProblem {
-    id: string;
-    href: string;
-    reason: NavHrefProblemReason;
-    /** Registered patterns ending in the same segment. A destination resolved
-     *  under the wrong base lands here as its correctly-based twin, which is what
-     *  names the missing scope in the failure message. */
-    nearest: string[];
-    message: string;
-}
-interface NavHrefReport {
-    /** Hrefs examined, including nested sub-items. */
-    checked: number;
-    problems: NavHrefProblem[];
-    /** Off-router destinations accepted because `allowExternal` is on. */
-    external: string[];
-    /** The flattened route table the check ran against. */
-    patterns: string[];
-}
-interface NavHrefCheckOptions {
-    /** Hrefs to skip, compared after query/fragment removal. For a destination
-     *  served outside this route table (a static asset, another worker). */
-    ignore?: readonly string[];
-    /** Absolute URLs / `mailto:` / `tel:` are reported under `external` instead
-     *  of failing. Default true. */
-    allowExternal?: boolean;
-    /** Compare literal segments case-sensitively. Default true — a router that
-     *  matches case-insensitively still renders a link the deploy's CDN or a
-     *  case-sensitive origin may not. */
-    caseSensitive?: boolean;
-}
-/**
- * Check every nav href against the product's route table.
- *
- * Pure — returns the full report so a caller can assert on parts of it. Use
- * {@link assertNavHrefsRegistered} in tests; it turns the report into a failure
- * that names the offending row, its resolved href, and the near-miss pattern.
- */
-declare function checkNavHrefs(items: readonly NavHrefItem[], routes: NavRouteTable, options?: NavHrefCheckOptions): NavHrefReport;
-/**
- * Fail unless every nav href resolves to a registered route.
- *
- * Throws on an empty item list or an empty route table as well: a guard that
- * examined nothing reports safety it does not provide, and both are what a
- * mis-wired import looks like.
- */
-declare function assertNavHrefsRegistered(items: readonly NavHrefItem[], routes: NavRouteTable, options?: NavHrefCheckOptions): void;
-
 /**
  * Session shell — the app-shell mechanism every agent product needs around the
  * chat surface: a list of past sessions in the rail, an entry point for a new
@@ -185,10 +14,10 @@ declare function assertNavHrefsRegistered(items: readonly NavHrefItem[], routes:
  * shape to the shell, and the product supplies routing through `hrefForSession`
  * rather than the shell knowing any URL.
  */
-
+export * from './nav-guard';
 /** One session as the shell needs to see it. Products map their own row
  *  (thread / session / matter) onto this before handing it over. */
-interface SessionSummary {
+export interface SessionSummary {
     id: string;
     /** `null`/empty renders as the untitled placeholder rather than a blank row. */
     title: string | null;
@@ -202,14 +31,14 @@ interface SessionSummary {
     category?: string | null;
 }
 /** One fetched page of sessions with an optional continuation cursor. */
-interface SessionPage {
+export interface SessionPage {
     items: SessionSummary[];
     /** Opaque continuation token; absent/null ⇒ no further pages. */
     nextCursor?: string | null;
 }
 /** Sort order for the history view. The product's fetcher decides what these
  *  mean against its own storage; the shell only round-trips the value. */
-type SessionSort = 'newest' | 'oldest';
+export type SessionSort = 'newest' | 'oldest';
 /**
  * These mirror `@tangle-network/sandbox-ui/dashboard`'s `SidebarLayoutNavItem`
  * / `RailExpandableSubItem` STRUCTURALLY rather than importing them, so this
@@ -221,15 +50,15 @@ type SessionSort = 'newest' | 'oldest';
  * `TIcon` is the product's icon component type (lucide, custom, anything) —
  * generic so this file needs no React types.
  */
-interface SessionRailAction<TIcon = unknown> {
+export interface SessionRailAction<TIcon = unknown> {
     id: string;
     label: string;
     icon?: TIcon;
     destructive?: boolean;
     onSelect: () => void;
 }
-type RailPrefetch = 'none' | 'intent' | 'render' | 'viewport';
-interface SessionRailSubItem<TIcon = unknown> {
+export type RailPrefetch = 'none' | 'intent' | 'render' | 'viewport';
+export interface SessionRailSubItem<TIcon = unknown> {
     id: string;
     label: string;
     href: string;
@@ -242,7 +71,7 @@ interface SessionRailSubItem<TIcon = unknown> {
     emphasis?: boolean;
     actions?: SessionRailAction<TIcon>[];
 }
-interface SessionRailNavItem<TIcon = unknown> {
+export interface SessionRailNavItem<TIcon = unknown> {
     id: string;
     /** REQUIRED, mirroring sandbox-ui — the rail renders `<Icon />` unguarded, so
      *  an omitted icon is a blank/crashing row rather than a styling nit. */
@@ -259,7 +88,7 @@ interface SessionRailNavItem<TIcon = unknown> {
 }
 /** Per-row rename/delete wiring. Supplied by the layout that owns the dialogs;
  *  omitted (or `canEdit: false`) leaves rows read-only. */
-interface SessionRowActions<TIcon = unknown> {
+export interface SessionRowActions<TIcon = unknown> {
     canEdit: boolean;
     renameIcon?: TIcon;
     deleteIcon?: TIcon;
@@ -286,11 +115,11 @@ interface SessionRowActions<TIcon = unknown> {
      */
     extraActions?: (session: SessionSummary) => SessionRailAction<TIcon>[];
 }
-declare const UNTITLED_SESSION_LABEL = "Untitled chat";
+export declare const UNTITLED_SESSION_LABEL = "Untitled chat";
 /** Display title for a session row — trims, and falls back rather than
  *  rendering an empty row the user cannot aim at. */
-declare function sessionLabel(session: SessionSummary, untitled?: string): string;
-interface BuildSessionSubItemsOptions<TIcon = unknown> {
+export declare function sessionLabel(session: SessionSummary, untitled?: string): string;
+export interface BuildSessionSubItemsOptions<TIcon = unknown> {
     sessions: SessionSummary[];
     /** The product's route for one session. The shell never builds a URL itself. */
     hrefForSession: (sessionId: string) => string;
@@ -306,8 +135,8 @@ interface BuildSessionSubItemsOptions<TIcon = unknown> {
     };
 }
 /** Session rows for the rail's expandable history item. */
-declare function buildSessionSubItems<TIcon = unknown>({ sessions, hrefForSession, respondingSessionIds, actions, untitledLabel, prefetch, overflow, }: BuildSessionSubItemsOptions<TIcon>): SessionRailSubItem<TIcon>[];
-interface BuildSessionNavItemOptions<TIcon = unknown> extends BuildSessionSubItemsOptions<TIcon> {
+export declare function buildSessionSubItems<TIcon = unknown>({ sessions, hrefForSession, respondingSessionIds, actions, untitledLabel, prefetch, overflow, }: BuildSessionSubItemsOptions<TIcon>): SessionRailSubItem<TIcon>[];
+export interface BuildSessionNavItemOptions<TIcon = unknown> extends BuildSessionSubItemsOptions<TIcon> {
     /** Nav id the product highlights against (`activeNavId === id`). */
     id?: string;
     label?: string;
@@ -325,8 +154,8 @@ interface BuildSessionNavItemOptions<TIcon = unknown> extends BuildSessionSubIte
  * recent sessions. This is the structure the owner asked for — history lives IN
  * the rail, not in a second sidebar panel beside it.
  */
-declare function buildSessionNavItem<TIcon = unknown>({ id, label, icon, href, activeSessionId, emptyLabel, defaultOpen, ...subItemOptions }: BuildSessionNavItemOptions<TIcon>): SessionRailNavItem<TIcon>;
-interface ActiveSessionIdOptions {
+export declare function buildSessionNavItem<TIcon = unknown>({ id, label, icon, href, activeSessionId, emptyLabel, defaultOpen, ...subItemOptions }: BuildSessionNavItemOptions<TIcon>): SessionRailNavItem<TIcon>;
+export interface ActiveSessionIdOptions {
     pathname: string;
     /** Workspace-scoped route base, e.g. `/app/ws_123`. */
     base: string;
@@ -356,13 +185,13 @@ interface ActiveSessionIdOptions {
  * in. Same class as attaching to a stale box: it looks right and points at the
  * wrong row.
  */
-declare function activeSessionIdFromPath({ pathname, base, segment, newSegment, reserved, }: ActiveSessionIdOptions): string | null;
+export declare function activeSessionIdFromPath({ pathname, base, segment, newSegment, reserved, }: ActiveSessionIdOptions): string | null;
 /** One rail destination. `path` is relative to the workspace base. */
-interface NavRouteDef {
+export interface NavRouteDef {
     id: string;
     path: string;
 }
-interface ResolveActiveNavIdOptions {
+export interface ResolveActiveNavIdOptions {
     pathname: string;
     base: string;
     /** The product's rail rows, in any order — resolution is longest-prefix. */
@@ -382,8 +211,8 @@ interface ResolveActiveNavIdOptions {
  * per-product versions this replaces were first-match over an array, which made
  * `/chat/new` vs `/chat` an ordering accident rather than a rule.
  */
-declare function resolveActiveNavId({ pathname, base, routes, aliases, claimsNothing, }: ResolveActiveNavIdOptions): string | undefined;
-interface ResolveSessionUnreadOptions {
+export declare function resolveActiveNavId({ pathname, base, routes, aliases, claimsNothing, }: ResolveActiveNavIdOptions): string | undefined;
+export interface ResolveSessionUnreadOptions {
     sessionId: string;
     /** Server-computed unread from the route loader. */
     loaderUnread: boolean;
@@ -400,8 +229,8 @@ interface ResolveSessionUnreadOptions {
  * unread after the user opened it — so live and local overlays win over it, and
  * the currently-open session always reads as read.
  */
-declare function resolveSessionUnread({ sessionId, loaderUnread, liveUnreadIds, locallyReadIds, currentSessionId, }: ResolveSessionUnreadOptions): boolean;
-interface ComposeSidebarSessionsOptions {
+export declare function resolveSessionUnread({ sessionId, loaderUnread, liveUnreadIds, locallyReadIds, currentSessionId, }: ResolveSessionUnreadOptions): boolean;
+export interface ComposeSidebarSessionsOptions {
     /** Server-rendered rows, already ordered by the product's query. */
     loaderSessions: SessionSummary[];
     /** Optimistic rows from the live channel (a chat created in another tab). */
@@ -414,7 +243,7 @@ interface ComposeSidebarSessionsOptions {
     locallyReadIds?: ReadonlySet<string>;
     currentSessionId?: string | null;
 }
-interface ComposedSidebarSessions {
+export interface ComposedSidebarSessions {
     sessions: SessionSummary[];
     /** More sessions exist than the rail shows ⇒ render the "view all" row. */
     hasMore: boolean;
@@ -428,14 +257,14 @@ interface ComposedSidebarSessions {
  * (duplicate React keys, and the row's actions would target the same session
  * from two places).
  */
-declare function composeSidebarSessions({ loaderSessions, optimisticSessions, limit, totalCount, liveUnreadIds, locallyReadIds, currentSessionId, }: ComposeSidebarSessionsOptions): ComposedSidebarSessions;
+export declare function composeSidebarSessions({ loaderSessions, optimisticSessions, limit, totalCount, liveUnreadIds, locallyReadIds, currentSessionId, }: ComposeSidebarSessionsOptions): ComposedSidebarSessions;
 /**
  * Append a fetched page to held rows, dropping ids already shown. A session
  * bumped to the top between two page fetches otherwise arrives twice — once in
  * the page it moved out of and once in the page it moved into.
  */
-declare function mergeSessionPages(existing: SessionSummary[], incoming: SessionSummary[]): SessionSummary[];
-declare const DEFAULT_RAIL_COOKIE_NAME = "agent-sidebar-rail-collapsed";
+export declare function mergeSessionPages(existing: SessionSummary[], incoming: SessionSummary[]): SessionSummary[];
+export declare const DEFAULT_RAIL_COOKIE_NAME = "agent-sidebar-rail-collapsed";
 /**
  * Read the persisted rail-collapse state from a request's `Cookie` header, so
  * the server renders the rail in the state the user left it and the first
@@ -445,8 +274,8 @@ declare const DEFAULT_RAIL_COOKIE_NAME = "agent-sidebar-rail-collapsed";
  * shape the products shipped): a name containing a regex metacharacter would
  * silently match the wrong cookie or none at all.
  */
-declare function readRailCollapsedCookie(cookieHeader: string | null | undefined, name?: string): boolean;
-interface RailCookieOptions {
+export declare function readRailCollapsedCookie(cookieHeader: string | null | undefined, name?: string): boolean;
+export interface RailCookieOptions {
     name?: string;
     /** Seconds. Default one year. */
     maxAge?: number;
@@ -457,9 +286,7 @@ interface RailCookieOptions {
 }
 /** The cookie string for a collapse state. Usable as `document.cookie` or as a
  *  `Set-Cookie` value. Exported separately so it is testable without a DOM. */
-declare function railCollapsedCookie(collapsed: boolean, { name, maxAge, path, secure }?: RailCookieOptions): string;
+export declare function railCollapsedCookie(collapsed: boolean, { name, maxAge, path, secure }?: RailCookieOptions): string;
 /** Persist the rail-collapse state from the browser. No-op without a document
  *  so a shared toggle handler is safe to call during SSR. */
-declare function writeRailCollapsedCookie(collapsed: boolean, options?: RailCookieOptions): void;
-
-export { type ActiveSessionIdOptions, type BuildSessionNavItemOptions, type BuildSessionSubItemsOptions, type ComposeSidebarSessionsOptions, type ComposedSidebarSessions, DEFAULT_RAIL_COOKIE_NAME, type NavDestination, type NavHrefCheckOptions, type NavHrefItem, type NavHrefProblem, type NavHrefProblemReason, type NavHrefReport, type NavRouteDef, type NavRouteTable, type NavScope, type NavScopeBases, type RailCookieOptions, type RailPrefetch, type RegisteredRoute, type ResolveActiveNavIdOptions, type ResolveScopedActiveNavIdOptions, type ResolveSessionUnreadOptions, type ResolvedNavDestination, type SessionPage, type SessionRailAction, type SessionRailNavItem, type SessionRailSubItem, type SessionRowActions, type SessionSort, type SessionSummary, UNTITLED_SESSION_LABEL, activeSessionIdFromPath, assertNavHrefsRegistered, buildSessionNavItem, buildSessionSubItems, checkNavHrefs, composeSidebarSessions, flattenRouteTable, mergeSessionPages, railCollapsedCookie, readRailCollapsedCookie, resolveActiveNavId, resolveNavDestinations, resolveNavHref, resolveScopedActiveNavId, resolveSessionUnread, sessionLabel, writeRailCollapsedCookie };
+export declare function writeRailCollapsedCookie(collapsed: boolean, options?: RailCookieOptions): void;