@kortix/ui 0.0.0-stage → 0.14.4

package/dist/_vendor/shared/channel-header.d.ts

@@ -0,0 +1,12 @@
+export interface LegacyChannelHeader {
+    /** The platform word as written, such as `Slack`. */
+    platform: string;
+    /** The channel or chat, trimmed. */
+    context: string;
+    /** The sender, trimmed. */
+    userName: string;
+    /** The header's length, including the whitespace after its `]`. */
+    length: number;
+}
+/** The header at the start of `text`, or null when `text` does not start with one. */
+export declare function readLegacyChannelHeader(text: string): LegacyChannelHeader | null;

package/dist/_vendor/shared/channel-message.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Recognise a channel-originated user message (Slack, Microsoft Teams,
+ * Telegram) inside the raw prompt text the API scaffolds for the agent, and
+ * pull out what a person wants to see: who wrote it, where, and the words they
+ * typed — not the tenant ids and the `How to work:` instructions.
+ *
+ * Every shape here is produced by exactly one API renderer:
+ *
+ * | Shape | Producer |
+ * | --- | --- |
+ * | `You're answering a message on Slack as a teammate.` | `channels/slack/session.ts` renderAgentPrompt |
+ * | `New message from <user> in Slack channel <channel>, thread <ts>:` | `channels/slack/session.ts` renderFollowUpPrompt |
+ * | `New message from <user> in the same Slack thread:` | the same renderer before 2026-09, kept for old transcripts |
+ * | `You're answering a message on Microsoft Teams as a teammate.` | `channels/teams/session.ts` renderAgentPrompt |
+ * | `New message from <user> in the same Teams conversation:` | `channels/teams/session.ts` renderFollowUpPrompt |
+ * | `You received a message on Telegram.` | `channels/telegram-webhook.ts` renderAgentPrompt |
+ * | `[<Platform> · <context> · message from <user>]` | the pre-2026 header, kept so old transcripts still render |
+ *
+ * The parser is pure and framework-free so `channel-message.test.ts` can pin
+ * each shape against the real prompt text. The web and mobile session views
+ * both read channel messages with it.
+ *
+ * Channel text comes from anyone who can post in the channel, and every viewer
+ * of the session parses it, so no pattern here may re-read the text per
+ * attempt. The pre-2026 header regex and the `<at>` strip did: 240k characters
+ * took 22 s and 7 s.
+ */
+export type ChannelPlatform = 'Slack' | 'Teams' | 'Telegram';
+export interface ChannelMessageInfo {
+    platform: ChannelPlatform;
+    /** Channel / conversation / chat id; empty for a follow-up, which carries none. */
+    context: string;
+    userName: string;
+    messageText: string;
+    /** True for a later message in a thread the agent already owns. */
+    followUp: boolean;
+}
+export declare function parseChannelMessage(rawText: string | null | undefined): ChannelMessageInfo | undefined;

package/dist/_vendor/shared/chat-mention.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Teams wraps a channel @-mention of the bot in `<at>…</at>`. Sessions titled
+ * from such a message before the API stripped it (#7388) still carry the tag
+ * in `name`; nothing a person reads should show it.
+ */
+export declare function stripChatMentionMarkup(value: string): string;

package/dist/_vendor/shared/code-language.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Fenced-code language hints that are not the id the highlighter preloads.
+ *
+ * Two kinds live here and both cost the reader something:
+ *
+ * 1. Hints Shiki has no grammar *or* alias for — `golang`, `env`, `patch`,
+ *    `svg`, `psql`, `plaintext`. `ensureLangLoaded` throws on these, the catch
+ *    warns, and the block renders unhighlighted forever.
+ * 2. Hints Shiki resolves but only through its own alias table — `rs`, `kt`,
+ *    `c++`, `ps1`. Those highlight, but `highlightSync` gates on
+ *    `loadedLangs.has(lang)`, which is seeded from `PRELOAD_LANGS` verbatim, so
+ *    the unresolved spelling misses the fast path and the block repaints from
+ *    plain to colour a frame later.
+ *
+ * Every value must therefore be a `PRELOAD_LANGS` entry, not Shiki's canonical
+ * id — that list carries `dockerfile`, `makefile` and `bash`, which are
+ * themselves Shiki aliases (of `docker`, `make`, `shellscript`). Normalising to
+ * the canonical id would be correct and still miss the sync path. The unit test
+ * pins this; add an alias there and it fails until the target is preloaded.
+ */
+export declare const LANGUAGE_ALIASES: Record<string, string>;
+/** Normalise a fenced-code language hint to a Shiki grammar id. */
+export declare function normalizeLanguage(lang: string): string;
+/** Display label for the code-block header; empty hint falls back to "text". */
+export declare function languageLabel(language: string): string;

package/dist/_vendor/shared/connector-sections.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Connector catalogue browse sections: the curated category buckets and the
+ * per-section picks, shared by the API and the web app.
+ *
+ * The API groups the COMPLETE Discover catalogue with these rules, so a
+ * section heading states the category's true size. The web app renders and
+ * filters with the same rules, so a heading and the grid its "View all" opens
+ * can never disagree about what a category contains. Framework-free on purpose.
+ */
+export declare const OTHER = "Other";
+/**
+ * The synthetic first section. Not a catalogue category — see `catalogSections`
+ * in `catalog-entry.ts`, which re-exports this.
+ *
+ * Defined here rather than there because `catalogCategoryKeys` below has to
+ * exclude it, and `catalog-entry.ts` already imports from this module — the
+ * other direction would be a cycle.
+ */
+export declare const POPULAR_SECTION = "popular";
+export interface CatalogSectionDef {
+    /** Stable key, and the value the category `Select` round-trips. Must not
+     *  start with a space — that is `ALL_CATEGORIES`' sentinel. */
+    key: string;
+    /** The section heading. Ours to choose: these are curated groupings, not
+     *  catalogue values, so the heading does not have to echo whatever a
+     *  provider happened to name its bucket. */
+    title: string;
+    /** Folded raw categories this section claims. A token that matches nothing
+     *  in the live feeds costs nothing — the section stays empty and is never
+     *  emitted. */
+    match: readonly string[];
+}
+/**
+ * The browse order, chosen rather than measured.
+ *
+ * **Why this exists.** Sections used to be ranked by bucket size alone, so
+ * whichever category the upstream feed happened to fill most took the top slot
+ * — in practice "Business management", a heading nobody picked and few people
+ * are shopping for. Size is a fact about the feed, not a statement about what
+ * someone browsing should see first.
+ *
+ * **The order.** Getting work done first, then the tools a team runs the
+ * business on, then what a technical user goes looking for deliberately.
+ * Developer tools is last on purpose: someone who wants GitHub searches for
+ * GitHub, while someone browsing is better served by every non-technical row
+ * above it.
+ *
+ * Anything the catalogue publishes that no section claims still renders. It
+ * falls through to the tail, ranked by size the way everything used to be,
+ * with `Other` below that. Nothing is hidden by being absent from this list;
+ * it is only ranked beneath what is present.
+ */
+export declare const CURATED_SECTIONS: readonly CatalogSectionDef[];
+/**
+ * The section a raw catalogue category belongs to: a curated key when one
+ * claims it, otherwise the trimmed raw value, which then becomes its own
+ * section exactly as before.
+ */
+export declare function sectionKeyForCategory(raw: string): string;
+/**
+ * A section key as a heading. Curated sections use the title we chose;
+ * anything else falls back to the catalogue's own value, humanized.
+ */
+export declare function sectionTitle(key: string): string;
+/**
+ * The sections one item belongs to — the single definition of membership, used
+ * both to build the buckets and to count a category without building them.
+ *
+ * Categories are trimmed and blank ones are dropped before anything else.
+ * `categories: ['']` is not hypothetical — `Malwarebytes` ships exactly that in
+ * the live catalogue, and a plain `length > 0` check would accept the empty
+ * string as a category and render a section under a blank heading. Trimming
+ * also stops `' data'` and `'data '` from forking one category into two
+ * adjacent sections. An item left with nothing after that is genuinely
+ * uncategorized and lands in `Other`.
+ *
+ * A `Set` over the MAPPED keys, not the raw names: `project-management` and
+ * `task-management` are two distinct raw categories that both fold into
+ * Productivity, and an app claiming both would otherwise render twice in that
+ * grid under two identical React keys.
+ */
+export declare function sectionKeysForEntry(categories: readonly string[], opts?: {
+    raw?: boolean;
+}): Set<string>;
+/**
+ * How many of `items` a section holds, without bucketing the rest.
+ *
+ * Shares `sectionKeysForEntry` with `groupIntoSections`, so the count that
+ * decides whether to fetch another page and the grid that page fills can never
+ * disagree about what is in a category. Counting with a second, hand-written
+ * membership rule is how a page ends up fetching forever against a target the
+ * grid has already met.
+ */
+export declare function countInSection<T>(items: readonly T[], getCategories: (item: T) => readonly string[], section: string): number;
+/**
+ * Bucket catalog items into browse sections, in `CURATED_SECTIONS` order.
+ *
+ * Items are duplicated across the sections they claim on purpose — that is how
+ * a browse surface works, and `DiscoverConnector.categories` is genuinely
+ * multi-valued. What must NOT duplicate is one item inside one section;
+ * `sectionKeysForEntry` owns that rule and the blank-category handling.
+ *
+ * Sorting is rank first, size second. Curated ranks are unique, so the size
+ * rule can never reorder them — it orders only the uncurated tail, which is
+ * what this function did for every section before there was a rank.
+ */
+export declare function groupIntoSections<T>(items: readonly T[], getCategories: (item: T) => readonly string[], opts?: {
+    raw?: boolean;
+}): Array<{
+    category: string;
+    items: T[];
+}>;
+/**
+ * A catalogue category as a section heading. The values arrive kebab-case
+ * (`sales-and-marketing`, `financial-services`), which reads as broken markup
+ * when rendered raw. Hyphen -> space matches the existing transform at
+ * `packages/ui/src/internal/lib/utils/kortix-system-tags.ts:131`.
+ *
+ * Only the first character is capitalized; the tail is left exactly as the
+ * catalogue published it. Lowercasing the tail would produce sentence case for
+ * kebab values but turn any acronym (`CRM`) into `Crm`, and this catalogue is
+ * third-party data whose casing we do not control.
+ *
+ * Reached through `sectionTitle` for anything no curated section claimed.
+ */
+export declare function humanizeCategory(raw: string): string;
+/**
+ * The tools a person browsing a category should meet first, in the order they
+ * should meet them.
+ *
+ * **Why a hand-written list.** The catalogue is ~5,758 apps and the feed's own
+ * order is not an editorial judgement — it is whatever the provider returns.
+ * Left alone, a category's first six cards are arbitrary, and someone who does
+ * not already know the space cannot tell a household name from a long-tail
+ * entry. These lists put the recognisable ones in front.
+ *
+ * **Keys are `CURATED_SECTIONS` keys**, not a second vocabulary — a key that
+ * is not a real section is a test failure, so this cannot drift into naming
+ * sections that no longer exist.
+ *
+ * **Entries are matched against an app's folded slug OR its folded name**, so
+ * one token covers both catalogues. An entry that matches nothing is inert: it
+ * pins nothing, hides nothing, and cannot duplicate a card. That is the whole
+ * safety story for a list written from product knowledge rather than from a
+ * catalogue dump — being wrong costs a pin, never a render.
+ *
+ * An app only reaches a section if the FEED puts it in that category, so
+ * pinning `slack` under both communication and productivity is not a conflict;
+ * whichever section Slack actually lands in is the one where its pin applies.
+ */
+export declare const CATEGORY_PICKS: Record<string, readonly string[]>;
+/** Sorts after every pinned entry. `Number.MAX_SAFE_INTEGER` rather than
+ *  `Infinity` so the subtraction in the comparator stays a real number —
+ *  `Infinity - Infinity` is `NaN`, and a `NaN` comparator silently leaves the
+ *  array in an arbitrary order. */
+export declare const UNPINNED_RANK: number;
+/**
+ * Where an app sits in its section's pick list, or `UNPINNED_RANK`.
+ *
+ * Slug and name are both tried because the two catalogues disagree about which
+ * one carries the recognisable string — Easy Connect ships `google_sheets` as
+ * a slug, the Discover feed can ship an opaque id with `Google Sheets` as the
+ * name. One token covers both.
+ */
+export declare function pinRank(sectionKey: string, app: {
+    slug: string;
+    name: string;
+}): number;
+/**
+ * A section's items with its picks floated to the top, in pick order, and
+ * everything else left exactly as the feed returned it.
+ *
+ * `Array.prototype.sort` is stable (required since ES2019), which is what
+ * preserves feed order among the unpinned rather than scrambling them into an
+ * order nobody chose.
+ */
+export declare function sortByPicks<T extends {
+    slug: string;
+    name: string;
+}>(sectionKey: string, items: readonly T[]): T[];

package/dist/_vendor/shared/constants/auto-topup.d.ts

@@ -0,0 +1,13 @@
+export declare const AUTO_TOPUP_DEFAULT_THRESHOLD = 1;
+export declare const AUTO_TOPUP_DEFAULT_AMOUNT = 5;
+export declare const AUTO_TOPUP_MIN_THRESHOLD = 1;
+export declare const AUTO_TOPUP_MIN_AMOUNT = 1;
+/**
+ * Buffer the topup amount must add above the threshold. Without it, a topup
+ * of $5 with threshold $5 would re-trigger on every subsequent debit and
+ * charge the user repeatedly. Shared so the client can enforce the identical
+ * rule the server enforces in `validateAutoTopupConfig`
+ * (apps/api/src/billing/services/auto-topup.ts) instead of maintaining a
+ * second copy that could drift.
+ */
+export declare const AUTO_TOPUP_MIN_BUFFER = 1;

package/dist/_vendor/shared/constants/upload-limits.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared upload limits and file type definitions
+ * Used across web, mobile, and backend
+ */
+export declare const UPLOAD_LIMITS: {
+    readonly MAX_FILE_SIZE_BYTES: number;
+    readonly MAX_FILE_SIZE_MB: 50;
+    readonly MAX_PDF_PAGES: 500;
+    readonly MAX_EXCEL_ROWS: 100000;
+    readonly MAX_EXCEL_SHEETS: 50;
+    readonly MAX_TEXT_CHARS: 10000000;
+    readonly MAX_ZIP_FILES: 50;
+    readonly MAX_ZIP_TOTAL_SIZE_BYTES: number;
+};
+export declare const ALLOWED_EXTENSIONS: readonly [".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".odt", ".ods", ".odp", ".rtf", ".epub", ".txt", ".csv", ".md", ".markdown", ".html", ".htm", ".css", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".py", ".pyw", ".pyi", ".java", ".class", ".c", ".cpp", ".h", ".hpp", ".cc", ".cxx", ".cs", ".go", ".rs", ".rb", ".php", ".swift", ".kt", ".kts", ".scala", ".sh", ".bash", ".zsh", ".sql", ".r", ".m", ".lua", ".pl", ".dart", ".yaml", ".yml", ".toml", ".xml", ".json", ".jsonc", ".json5", ".env", ".ini", ".cfg", ".conf", ".lock", ".vue", ".svelte", ".astro", ".ejs", ".pug", ".hbs", ".handlebars", ".jpeg", ".jpg", ".png", ".gif", ".webp", ".svg", ".bmp", ".ico", ".heic", ".heif", ".tiff", ".tif", ".mp4", ".webm", ".mov", ".avi", ".mkv", ".m4v", ".flv", ".wmv", ".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac", ".wma", ".zip", ".tar", ".gz", ".7z", ".rar", ".bz2", ".xz", ".ttf", ".otf", ".woff", ".woff2", ".eot", ".svg", ".ai", ".sketch", ".fig", ".xd", ".obj", ".stl", ".gltf", ".glb", ".fbx", ".bin", ".exe", ".dll", ".so", ".dylib", ".wasm", ".db", ".sqlite", ".sqlite3", ".ipynb", ".kanvax"];
+export declare function formatFileSize(bytes: number): string;
+export declare function isAllowedFile(file: {
+    name: string;
+    size?: number;
+}): {
+    allowed: boolean;
+    reason?: string;
+};

package/dist/_vendor/shared/file-tags.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The runtime writes an attached file into user text as
+ * `<file path="…" mime="…" filename="…">…</file>`. This finds those blocks.
+ *
+ * WHY NOT A REGEX. Every reader of this format used
+ * `/<file\s+([^>]*?)>\s*[\s\S]*?<\/file>/g`, and it is quadratic: `\s+` and
+ * `[^>]*?` both match whitespace, so `<file` followed by N whitespace
+ * characters and no `>` is re-split N ways. Measured: 10k characters 32 ms, 20k
+ * 125 ms — each doubling quadruples it — so a 200k-character prompt costs
+ * ~12 s. That text is user-controlled, and one reader runs synchronously on the
+ * API's event loop at every turn-end capture, where it stalls every request on
+ * the process. The scanner behind this, and the reason no tighter regex fixes
+ * the class, is in `tag-blocks.ts`.
+ *
+ * It returns exactly what that regex matched: `<file`, then whitespace, then
+ * attributes up to the first `>`, then everything up to the first `</file>`,
+ * non-overlapping, in order. `attrs` is the attribute text without its leading
+ * whitespace, as the regex's first group was.
+ */
+export interface FileTagBlock {
+    /** Index of `<file`. */
+    index: number;
+    /** Index just past `</file>`. */
+    end: number;
+    /** The attribute text between `<file ` and `>`, leading whitespace removed. */
+    attrs: string;
+}
+export declare function fileTagBlocks(text: string): FileTagBlock[];

package/dist/_vendor/shared/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @kortix/shared
+ *
+ * Shared TypeScript code for Kortix frontend applications.
+ * Contains utilities, error classes, and tool metadata.
+ */
+export * from "./tools";
+export * from "./utils";
+export * from "./constants/upload-limits";
+export * from "./constants/auto-topup";
+export * from "./runtime-versions";
+export * from "./project-glyphs";
+export * from "./meta-agent";
+export * from "./utils/format-relative";
+export * from './prompt-attachments';
+export * from './markdown-math';
+export * from './session-attachments';
+export * from './file-tags';
+export * from './tag-blocks';
+export * from './trigger-event';
+export * from './reminder-prompt';
+export * from './room-prompt';
+export * from './channel-header';
+export * from './channel-message';
+export * from './slack-text';
+export * from './chat-mention';
+export * from './webhook-signing';
+export * from './pasted-content';

package/dist/_vendor/shared/markdown-math.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pure markdown helpers for math and Mermaid, shared by apps/web and apps/mobile
+ * so both clients pair the same `$` delimiters and route the same fences.
+ *
+ * - `prepareMarkdownForKatex` runs before the markdown parser: it escapes
+ *   currency dollars (`$4M`) and rewrites `\(…\)` / `\[…\]` to the `$` / `$$`
+ *   delimiters remark-math (web) and the mobile markdown-it math rule parse.
+ *   `prepareMarkdownForMath` (mobile) does the same outside code only.
+ * - `KATEX_FENCE_LANGUAGES` are fence languages rendered as display math.
+ * - `isMermaidCode` decides whether a fence renders as a Mermaid diagram.
+ * - `hasReferenceDefinitionOutsideFences` tests a reference-definition pattern
+ *   against the runs of lines both clients route as top-level text.
+ *
+ * No dependencies and no DOM: this file runs in Next.js, Bun, and Hermes.
+ */
+export declare function escapeCurrencyDollars(text: string): string;
+/**
+ * Normalize standard LaTeX delimiters to the dollar delimiters supported by remark-math.
+ * Preserve delimiter-like text inside inline code and fenced code blocks.
+ */
+export declare function normalizeLatexDelimiters(text: string): string;
+/**
+ * Normalize markdown before Streamdown: support standard LaTeX delimiters and escape currency `$`.
+ */
+export declare function prepareMarkdownForKatex(text: string): string;
+/**
+ * `prepareMarkdownForKatex` that leaves inline code and fenced code as written,
+ * so `` `echo $1` `` and a generative UI fence's `"$10"` keep their dollars.
+ * Web and mobile both render through this.
+ */
+export declare function prepareMarkdownForMath(text: string): string;
+/**
+ * Test whole text runs outside code/math, preserving multiline labels. HTML
+ * can suppress fence openers, so ambiguous HTML keeps the conservative guard.
+ * Indented openers are excluded only without container markers: a container
+ * fence can end implicitly when a later line leaves its container.
+ */
+export declare function hasReferenceDefinitionOutsideFences(markdown: string, definition: RegExp): boolean;
+/** Fenced code languages rendered as display math (rehype-katex only handles `math` by default). */
+export declare const KATEX_FENCE_LANGUAGES: ReadonlySet<string>;
+/** True when a fence language renders as display math. Case-insensitive, as on web. */
+export declare function isMathFenceLanguage(language: string): boolean;
+/**
+ * Detects if a code block contains Mermaid syntax
+ */
+export declare function isMermaidCode(language: string, code: string): boolean;

package/dist/_vendor/shared/meta-agent.d.ts

@@ -0,0 +1,7 @@
+export declare const META_AGENT_NAME = "meta";
+export declare const META_SANDBOX_SLUG = "meta";
+/** Meta — the platform coordinator's DISPLAY name. The internal id stays `meta`
+ *  (it keys the grant, the sandbox slug, and the project default agent); this is
+ *  the brand name every UI renders. */
+export declare const META_AGENT_DISPLAY_NAME = "Meta";
+export declare function isMetaAgentName(name: string | null | undefined): boolean;

package/dist/_vendor/shared/pasted-content.d.ts

@@ -0,0 +1,38 @@
+/** Chat pastes at or above this length become a "Pasted text" tile. */
+export declare const PASTE_TILE_MIN_CHARS = 1000;
+/** Chat pastes with more lines than this become a tile. */
+export declare const PASTE_TILE_MIN_LINES = 10;
+/** Inline tiles may add at most this many UTF-8 bytes to a prompt; larger pastes go out as a file. */
+export declare const PASTED_INLINE_MAX_BYTES = 100000;
+export type PastedContent = {
+    id: string;
+    text: string;
+};
+export declare function shouldTilePaste(text: string): boolean;
+/** Math.random, not crypto: this runs in Hermes/React Native without a crypto polyfill. */
+export declare function newPastedContentId(): string;
+/** Blank lines at the top and whitespace at the end go; the first line's indentation stays. */
+export declare function trimPastedText(text: string): string;
+export declare function pastedContentXml(p: PastedContent): string;
+/** Typed text must never parse as a tile: escape every opening and closing tag the user typed. */
+export declare function neutralizePastedTags(text: string): string;
+/** The exact inverse of `neutralizePastedTags`: what the user typed, for display, Copy and Edit. */
+export declare function restorePastedTags(text: string): string;
+export declare function serializePromptWithPastes(text: string, pastes: PastedContent[]): string;
+type PastedBlock = {
+    index: number;
+    end: number;
+    id: string;
+    text: string;
+};
+/** Blocks whose `id` is set and whose `chars` equals the decoded body length. Others stay text. */
+export declare function pastedContentBlocks(text: string): PastedBlock[];
+/** The text without its tiles, and the tiles. Blank lines the serializer put after a block go with it. */
+export declare function splitPastedContent(text: string): {
+    text: string;
+    pastes: PastedContent[];
+};
+/** Each valid block replaced by its body, for "Copy message". The typed text around the blocks gets its tags back. */
+export declare function expandPastedContent(text: string): string;
+export declare function utf8Bytes(text: string): number;
+export {};

package/dist/_vendor/shared/project-glyphs.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The glyphs and colours a project icon can use.
+ *
+ * This list is the ONE source of truth. `apps/api` imports it to allowlist what
+ * may be written to `metadata.icon_glyph`; `apps/web` imports it to build the
+ * picker grid and the name -> component registry. Keeping it here is what makes
+ * "the API accepts exactly what the UI can render" true by construction rather
+ * than by review.
+ *
+ * Every name is a PascalCase `@phosphor-icons/react` export, verified present in
+ * 2.1.10. Adding one means adding it here AND to the web registry — a test in
+ * apps/web asserts every name resolves to a real component, so a name added
+ * here alone fails CI rather than shipping a blank tile.
+ *
+ * WHY 202. Each Phosphor module carries ~3.5 KB of path data (all six weights
+ * ship together per icon, though the app paints only `bold`). Measured across
+ * the package: 5,269,143 bytes for 1512 icons. 202 is ~704 KB raw — statically
+ * importable, and well under budget gzipped. The full set would need dynamic
+ * import or a generated sprite plus a loading state inside the tab.
+ *
+ * Letters and digits are deliberately absent. Phosphor has no alphabet (only
+ * LetterCircleH/P/V, three strays), and mixing typographic letters with drawn
+ * glyphs would make the tab read as two families. The Numbers group is the one
+ * deliberate exception: NumberCircle* glyphs are drawn pictograms (a digit set
+ * inside a circle), not typographic characters, so they stay visually
+ * consistent with the rest of the catalogue.
+ */
+export declare const PROJECT_GLYPH_GROUPS: readonly [{
+    readonly label: "Objects";
+    readonly names: readonly ["Trash", "ShoppingCart", "Package", "Briefcase", "Gift", "Lightbulb", "Wrench", "Hammer", "Key", "Lock", "Umbrella", "Trophy"];
+}, {
+    readonly label: "Shapes";
+    readonly names: readonly ["Circle", "Square", "Triangle", "Diamond", "Hexagon", "Star", "Heart", "Lightning", "Spade", "Club", "Cube", "Polygon"];
+}, {
+    readonly label: "Files";
+    readonly names: readonly ["File", "FileText", "Folder", "FolderOpen", "Note", "Book", "Newspaper", "Paperclip", "Archive", "Notebook", "Files", "FolderPlus"];
+}, {
+    readonly label: "Actions";
+    readonly names: readonly ["Plus", "Minus", "Copy", "Check", "X", "Pencil", "Bookmark", "Eraser", "Scissors", "LinkSimple", "ShareNetwork", "Clipboard"];
+}, {
+    readonly label: "Arrows";
+    readonly names: readonly ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "ArrowsClockwise", "ArrowSquareOut", "TrendUp", "TrendDown", "ArrowsLeftRight", "ArrowUUpLeft", "ArrowsOut", "ArrowsIn"];
+}, {
+    readonly label: "Tech";
+    readonly names: readonly ["Code", "Terminal", "Database", "Cloud", "Cpu", "Bug", "GitBranch", "Rocket", "Monitor", "DeviceMobile", "Keyboard", "Robot"];
+}, {
+    readonly label: "Nature";
+    readonly names: readonly ["Leaf", "Tree", "Sun", "Moon", "Drop", "Fire", "Mountains", "Planet", "Flower", "Cactus", "Snowflake", "Rainbow"];
+}, {
+    readonly label: "Symbols";
+    readonly names: readonly ["Hash", "At", "Percent", "Asterisk", "Question", "Warning", "Info", "Bell", "Crown", "Flag", "Medal", "Sparkle"];
+}, {
+    readonly label: "Food";
+    readonly names: readonly ["Carrot", "Pizza", "Hamburger", "IceCream", "Coffee", "BeerStein", "Cookie", "Cake", "Egg", "Bread", "Wine", "Martini"];
+}, {
+    readonly label: "Animals";
+    readonly names: readonly ["Dog", "Cat", "Bird", "Butterfly", "Rabbit", "Horse", "Cow", "PawPrint", "Fish", "Shrimp", "Feather", "Bone"];
+}, {
+    readonly label: "Transport";
+    readonly names: readonly ["Car", "Bus", "Truck", "Train", "Airplane", "Bicycle", "Motorcycle", "Boat", "Scooter", "Taxi", "Van", "Jeep"];
+}, {
+    readonly label: "People";
+    readonly names: readonly ["User", "Users", "Smiley", "SmileyMeh", "SmileySad", "Ghost", "Alien", "Baby", "PersonSimpleRun", "Hand", "ThumbsUp", "Eye"];
+}, {
+    readonly label: "Music";
+    readonly names: readonly ["MusicNote", "MusicNotes", "Guitar", "Microphone", "SpeakerHigh", "Radio", "Playlist", "Metronome", "Waveform", "Disc", "Headphones", "Equalizer"];
+}, {
+    readonly label: "Sport";
+    readonly names: readonly ["Basketball", "Football", "SoccerBall", "Baseball", "TennisBall", "Barbell", "Target", "Golf", "Volleyball", "PingPong", "Racquet", "PersonSimpleSwim"];
+}, {
+    readonly label: "Money";
+    readonly names: readonly ["CurrencyDollar", "Wallet", "CreditCard", "PiggyBank", "Coins", "Receipt", "Bank", "ChartLine", "Tag", "ChartBar", "ChartPie", "Handshake"];
+}, {
+    readonly label: "Care";
+    readonly names: readonly ["CloudRain", "CloudSnow", "CloudLightning", "Wind", "Thermometer", "Sunglasses", "Heartbeat", "Pill", "FirstAid", "Syringe", "Bandaids", "Stethoscope"];
+}, {
+    readonly label: "Numbers";
+    readonly names: readonly ["NumberCircleZero", "NumberCircleOne", "NumberCircleTwo", "NumberCircleThree", "NumberCircleFour", "NumberCircleFive", "NumberCircleSix", "NumberCircleSeven", "NumberCircleEight", "NumberCircleNine"];
+}];
+export declare const PROJECT_GLYPH_NAMES: readonly string[];
+/**
+ * `grey` first because it is the default on a first pick — an unedited glyph
+ * project should look deliberately neutral, not randomly coloured.
+ */
+export declare const PROJECT_GLYPH_COLORS: readonly ["grey", "red", "orange", "yellow", "lime", "blue", "purple", "magenta"];
+export type ProjectGlyphName = (typeof PROJECT_GLYPH_GROUPS)[number]['names'][number];
+export type ProjectGlyphColor = (typeof PROJECT_GLYPH_COLORS)[number];
+export interface ProjectGlyph {
+    name: ProjectGlyphName;
+    color: ProjectGlyphColor;
+}
+export declare function isProjectGlyphName(value: unknown): value is ProjectGlyphName;
+export declare function isProjectGlyphColor(value: unknown): value is ProjectGlyphColor;

package/dist/_vendor/shared/prompt-attachments.d.ts

@@ -0,0 +1,20 @@
+export declare const MAX_PROMPT_UPLOAD_FILENAME_BYTES: number;
+export declare const MAX_PROMPT_ATTACHMENT_BYTES: number;
+export declare const MAX_PROMPT_ATTACHMENTS_BYTES: number;
+export declare const MAX_PROMPT_ATTACHMENT_FILES = 20;
+export declare const PROMPT_ATTACHMENT_TTL_MS: number;
+export interface PromptFileReference {
+    path: string;
+    mime: string;
+    filename: string;
+    /**
+     * A sent attachment's identity (the SDK local upload id). Only on refs the
+     * browser draws before delivery.
+     */
+    attachment?: string;
+    attachmentUrl?: string;
+    pendingId?: string;
+}
+export declare function isModelNativeAttachmentMime(mime: string): boolean;
+export declare function sanitizePromptUploadFilename(name: string): string;
+export declare function promptFileReferenceXml(input: PromptFileReference): string;

package/dist/_vendor/shared/reminder-prompt.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The text a session reminder fire delivers into its session:
+ *
+ *   [REMINDER reminder.<12 hex> — one-time scheduled check-in on this session, not a new user message.]
+ *
+ *   <reminder text>
+ *
+ * The API writes it (`reminderPromptText`); web and mobile read it back
+ * (`parseReminderPrompt`) to render the turn as a reminder, not as something
+ * the person typed. One module owns both sides so they cannot drift.
+ */
+export interface ReminderPromptInfo {
+    /** `reminder.<12 hex>`. */
+    id: string;
+    recurring: boolean;
+    /** The reminder text, without the header. */
+    prompt: string;
+}
+export declare function reminderPromptText(input: ReminderPromptInfo): string;
+/** The reminder a prompt carries, or undefined for any other text. Linear time. */
+export declare function parseReminderPrompt(rawText: string | null | undefined): ReminderPromptInfo | undefined;