zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/labels.ts

@@ -1,373 +0,0 @@
-/**
- * The chat layer's strings, on top of the design system's (`labels.tsx`).
- * One flat dictionary so an app overrides any of them with one
- * `<LabelsProvider>`; the headless helpers take it as an argument.
- */
-import { RUN_WAITING_LABEL, runRetryingLabel } from 'zidane/chat/pure';
-
-import { DEFAULT_LABELS } from '../../labels';
-import { TRANSCRIPT_LABELS } from './transcript-labels';
-
-/** The default English strings of the chat layer, merged over the design system's labels. Override any of them through {@link ChatProvider}. */
-export const DEFAULT_CHAT_LABELS = {
-  ...DEFAULT_LABELS,
-  ...TRANSCRIPT_LABELS,
-  // Session list
-  today: 'Today',
-  yesterday: 'Yesterday',
-  months: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] as readonly string[],
-  justNow: 'now',
-  chats: 'Chats',
-  favorites: 'Favorites',
-  addFavorite: 'Add to favorites',
-  removeFavorite: 'Remove from favorites',
-  stateRunning: 'Running',
-  stateCompleted: 'Completed',
-  stateError: 'Error',
-  stateIdle: 'Idle',
-  archived: 'Archived',
-  sessionActions: 'Open chat actions',
-  moreActions: 'More actions',
-  archive: 'Archive',
-  unarchive: 'Unarchive',
-  delete: 'Delete',
-  showMore: 'Show more',
-  expandGroup: (label: string) => `Expand ${label}`,
-  collapseGroup: (label: string) => `Collapse ${label}`,
-  openGroup: (label: string) => `Open ${label}`,
-  newSessionIn: (label: string) => `New session in ${label}`,
-  newSession: 'New session',
-  searchSessions: 'Search sessions',
-  noSessions: 'No sessions yet',
-  noMatches: (query: string) => `No sessions match "${query}"`,
-  sessions: 'Sessions',
-  // Status dot
-  dotIdle: 'Idle',
-  dotRunning: 'Running',
-  dotPending: 'Pending approval',
-  dotCompleted: 'Completed',
-  dotError: 'Errored',
-  dotAttention: 'Awaiting input',
-  dotAttached: 'Attached',
-  // Run time estimates: the chip on a running session's row and a subagent's header
-  estimateTitle: (left: string) => `About ${left.replace(/^~/, '')} left (estimated)`,
-  estimatePausedTitle: (left: string) => `About ${left.replace(/^~/, '')} left. Paused while the run waits for you`,
-  estimateDue: 'almost done',
-  estimateDueTitle: 'Past its estimate, so it should end soon',
-  estimateOver: 'over',
-  estimateOverTitle: 'Taking longer than estimated',
-  runningFor: (elapsed: string) => `Running for ${elapsed}`,
-  // Transcript
-  agent: 'Agent',
-  stepRunning: 'running',
-  stepFailed: 'failed',
-  stepDone: 'done',
-  // Reasoning rows
-  thinkingLive: 'Thinking…',
-  thoughtFor: (seconds: number) => `Thought for ${seconds}s`,
-  thoughts: 'Thoughts',
-  thoughtTimes: (count: number) => `Thought ${count} times`,
-  // Run status, in the live work row's header (the TUI's words: `zidane/chat/pure`)
-  runWaiting: RUN_WAITING_LABEL,
-  runRetrying: (attempt: number, max: number, source?: string) => runRetryingLabel({ attempt, max, source }),
-  // Run receipt
-  runReceipt: 'Run receipt',
-  receiptAgent: 'Agent that ran this turn',
-  receiptAgentSwitched: 'Agent that ran this turn, switched from the previous run',
-  receiptModel: 'Model that ran this turn',
-  receiptModelOthers: (others: number) =>
-    `Model that wrote the last reply. ${others} other model${others === 1 ? '' : 's'} ran earlier turns.`,
-  receiptDuration: 'Run time, tools included',
-  receiptTurns: (turns: number) => `${turns} model call${turns === 1 ? '' : 's'} in this run`,
-  receiptCost: 'Run cost',
-  receiptTokens: (sent: string, received: string) => `${sent} tokens sent, ${received} received`,
-  receiptSpeed: 'Output speed while streaming',
-  // Run failures
-  stopped: 'Stopped',
-  stoppedByYou: 'Stopped by you',
-  retry: 'Retry',
-  retryHint: 'Send your message again',
-  continueRun: 'Continue',
-  continueHint: 'Ask the model to continue',
-  resetsAt: (time: string) => `Resets at ${time}`,
-  // Session events
-  sessionEventLabel: (title: string, verb: string, needsAttention: boolean) =>
-    `${title} ${verb}${needsAttention ? '. Click to answer' : ''}`,
-  clickToAnswer: 'Answer',
-  openSession: 'open →',
-  // Command, spawn and compaction rows
-  commandDetail: 'detail',
-  spawnTask: 'Task',
-  spawnResumes: (childId: string) => `resumes ${childId}`,
-  turnsCompacted: 'turns compacted',
-  // Tool rows
-  stepWaiting: 'waiting',
-  /** A running call of a batch a durable run resumed after a process death (`StreamEvent.resuming`). */
-  stepResuming: 'resuming',
-  waitingForSlot: (max: number) => `Starts when one of the ${max} running agents finishes`,
-  autoDenied: 'auto-denied',
-  modelVerdictTitle: (approved: boolean, model: string, confidence: string | null) =>
-    `${approved ? 'Approved' : 'Blocked'} by the decision model ${model}${confidence ? ` (confidence ${confidence})` : ''}`,
-  loadFullOutput: 'Load full output',
-  loadingFullOutput: 'Loading full output…',
-  showOutput: 'Show output',
-  inputCaption: 'Input',
-  outputCaption: 'Output',
-  openNamedSession: (title: string) => `Open ${title}`,
-  /** A Mermaid diagram's accessible name, and its type when Pele detected one (`flowchart`). */
-  diagram: (type: string | null) => (type ? `${type} diagram` : 'Diagram'),
-  /** The diagram frame's toggle to its Mermaid source. */
-  showDiagramSource: 'Show source',
-  /** The diagram frame's toggle back to the drawing. */
-  showDiagram: 'Show diagram',
-  /** The diagram frame's zoom controls. */
-  zoomInDiagram: 'Zoom in',
-  zoomOutDiagram: 'Zoom out',
-  fitDiagram: 'Fit diagram',
-  /** Copy button of a diagram frame. */
-  copyDiagramSource: 'Copy diagram source',
-  /** Under a fence that could not be drawn; `at` is `line 3, column 7` or empty. */
-  diagramError: (message: string, at: string) =>
-    at ? `Diagram not drawn (${at}): ${message}` : `Diagram not drawn: ${message}`,
-  /** Where a diagram error is. */
-  diagramErrorAt: (line: number, column: number) => (column ? `line ${line}, column ${column}` : `line ${line}`),
-  // `!` shell rows
-  stopCommand: 'Stop command',
-  shellCancelled: 'cancelled',
-  shellKilled: 'killed',
-  shellExit: (code: number) => `exit ${code}`,
-  earlierLines: (count: number) => `… (+${count} earlier lines)`,
-  // Folds
-  working: 'Working',
-  foldSteps: (count: number) => `${count} steps`,
-  foldOutcomes: (ok: number, failed: number) => (failed > 0 ? `${ok} succeeded, ${failed} failed` : `${ok} succeeded`),
-  workerModel: 'Model',
-  workerType: 'Type',
-  workerContinues: 'Continues',
-  workerSystemPrompt: 'System prompt',
-  workerSystemReplaced: 'replaced for this worker',
-  showSystemPrompt: 'Show system prompt',
-  earlierMessages: (count: number) => `${count} earlier message${count === 1 ? '' : 's'}`,
-  // The fold's attachments strip
-  toolAttachments: 'Tool attachments',
-  moreAttachments: (count: number) => `+${count}`,
-  showMoreAttachments: (count: number) => `Show ${count} more attachment${count === 1 ? '' : 's'}`,
-  // Prompt echo
-  viewAttachment: (name: string) => `View ${name}`,
-  // Image generation (`generate_image` rows)
-  generatingImage: (model: string | null) => (model ? `Generating with ${model}…` : 'Generating image…'),
-  generatingImages: (count: number, model: string | null) =>
-    model ? `Generating ${count} images with ${model}…` : `Generating ${count} images…`,
-  generatedImage: 'Generated image',
-  openImageFile: (path: string) => `Open ${path}`,
-  // Host transcript
-  transcriptLoading: 'Loading conversation…',
-  earlierHistory: 'Earlier messages',
-  loadingEarlierMessages: 'Loading earlier messages',
-  loadEarlierHistory: 'Load earlier history',
-  loadingEarlierHistory: 'Loading earlier history…',
-  // Composer
-  composerLabel: 'Message',
-  composerPlaceholder: 'Message the agent…',
-  sendMessage: 'Send message',
-  sendHint: 'Send (Enter)',
-  stopRun: 'Stop',
-  stopHint: 'Stop the run (Esc)',
-  steerMessage: 'Steer the run',
-  steerHint: 'Add to the running turn (Enter)',
-  queueMessage: 'Queue message',
-  queueHint: 'Send when the run ends (Enter)',
-  attachFile: 'Attach file',
-  removeAttachment: (name: string) => `Remove ${name}`,
-  attachments: 'Attachments',
-  previewTooLarge: (name: string, size: string) => `${name} (${size}) is too large to preview.`,
-  previewFailed: (name: string) => `Couldn't load ${name}.`,
-  attachmentEmpty: (name: string) => `${name} is empty.`,
-  attachmentTooLarge: (name: string, size: string, limit: string) =>
-    `${name} is too large (${size}). The limit is ${limit}.`,
-  attachmentExportPdf: (name: string) => `${name} can't be attached. Export it as PDF first.`,
-  attachmentUnreadableImage: (name: string) => `${name} can't be read here. Export it as PNG or JPEG.`,
-  attachmentUnsupported: (name: string) => `${name} can't be attached. Only images, PDFs and text files can.`,
-  attachmentReadFailed: (name: string) => `${name} could not be read.`,
-  attachmentTitle: (name: string, detail: string) => `${name} (${detail})`,
-  attachmentNotices: 'Files not attached',
-  mentionSuggestions: 'Mentions',
-  commandSuggestions: 'Commands',
-  noSuggestions: 'No matches',
-  composerBadges: 'Composer badges',
-  // Agent, model and model options pickers (the desktop app's wording)
-  switchAgent: 'Switch agent',
-  defaultAgent: 'Default agent',
-  agentProfiles: 'Agent profiles',
-  switchingAgent: 'switching…',
-  agentDraftNote: 'Applies to your next chat.',
-  switchModel: 'Switch model',
-  chooseModel: 'Choose model',
-  // The model pill's tooltip: the chain, then how to change it
-  modelChain: 'Model chain',
-  modelForNextChat: 'For your next chat',
-  modelServing: (picked: string, serving: string) =>
-    `${picked} failed this run, so ${serving} took over. The next run tries ${picked} again.`,
-  modelServingFallback: 'The picked model',
-  modelChainNoModel: 'No model picked yet',
-  searchModels: 'Search models',
-  searchModelsPlaceholder: 'Search models…',
-  modelsShowLegacy: 'Show legacy models',
-  modelsShowLegacyHint: 'Show legacy models (⌥L)',
-  modelsLegacy: 'Legacy',
-  modelsJumpToProvider: 'Jump to provider',
-  modelsJumpHint: (provider: string, digit: number | null) => (digit ? `${provider} (⌘${digit})` : provider),
-  modelsLoading: 'Loading…',
-  modelsLoadFailed: (error: string) => `Failed to load models: ${error}`,
-  modelsNoProviders: 'No provider is signed in. Sign in under Settings → Accounts.',
-  modelsNoMatch: (query: string) => `No model matches "${query}".`,
-  modelsTypeAnId: 'Type any model id to use it. Put a provider first to pick one, for example "xai grok-9".',
-  modelsInUse: 'In use',
-  modelsChatTab: 'Chat',
-  modelsImageTab: 'Image',
-  modelKinds: 'Model kind',
-  imageModelsPill: 'Image model',
-  imageModelsNone:
-    'No connected provider generates images. Connect OpenRouter, Google Gemini, xAI, or OpenAI with a platform API key.',
-  imageModelReferences: 'reference images',
-  imageModelReferencesHint: 'Edits or matches reference images',
-  imageModelTransparency: 'transparency',
-  imageModelTransparencyHint: 'Can make a transparent background',
-  modelsCustomId: 'Custom id',
-  modelsShownOf: (shown: number, total: number) => `${shown} of ${total}`,
-  modelsLegacyHidden: (count: number) => `${count} legacy hidden`,
-  modelsSelected: (count: number) => `${count} selected`,
-  pickModel: 'pick',
-  modelPrimary: 'primary',
-  modelFallback: 'fallback',
-  modelFallbackHint: 'Tab or shift+click adds or removes a fallback',
-  modelChainOrderHint: 'Fallbacks run in this order. ctrl+shift+↑↓ moves the highlighted row.',
-  modelPrimaryHint: 'Primary model',
-  modelFallbackPosition: (n: number) => `Fallback #${n}`,
-  modelRemovePrimary: 'Remove primary model',
-  modelRemoveFallback: (n: number) => `Remove fallback #${n}`,
-  modelRemoveFromChain: 'Remove from chain',
-  modelAccountBlocked: (provider: string) =>
-    `Another ${provider} account is in use. Picking this one switches the chain to it.`,
-  modelLegacy: 'legacy',
-  modelLegacyHint: 'Newer models exist in this family',
-  modelUnavailable: 'unavailable',
-  modelNotInCatalog: 'not in catalog',
-  modelNotInCatalogHint: 'Used as typed. No details are known for this id.',
-  modelVia: 'via',
-  modelViaHint: (modelId: string, provider: string) => `${modelId} via ${provider}`,
-  modelInUse: 'in use',
-  modelReasoning: 'reasoning',
-  modelReasoningHint: 'Can think before answering',
-  contextWindow: 'Context window',
-  modelOptions: 'Model options',
-  setModelOptions: 'Set model options',
-  modelOptionsHint: 'Reasoning effort and model options',
-  modelOptionsEmpty: 'Options',
-  modelFeatures: 'Features',
-  reasoningEffort: 'Reasoning effort',
-  effortLevel: (level: string) => level,
-  // Interactions (exact desktop wording: the inbox cards render through these)
-  interactionPlan: 'Plan',
-  interactionQuestion: 'Question',
-  questionCount: (count: number) => `${count} questions`,
-  interactionsLabel: 'Requests from the agent',
-  inboxEmpty: 'Nothing waiting on you',
-  inboxPreviousSession: 'previous session',
-  unsupportedInteraction: (tool: string) => `The agent is waiting on ${tool}, which this view cannot answer.`,
-  planRejectNote: 'Rejecting stops the run. Add a note so the agent knows why.',
-  planReviseNote: 'Say what should change. The agent sends back a revised plan.',
-  planRejectPlaceholder: 'Why you reject this plan (optional)',
-  planRevisePlaceholder: 'What should change (optional)',
-  back: 'Back',
-  planRejectAndStop: 'Reject and stop',
-  planSendRevision: 'Send revision',
-  planReject: 'Reject…',
-  planRevise: 'Revise…',
-  planApprove: 'Approve',
-  additionalInstructions: 'Additional instructions',
-  additionalInstructionsHint: 'optional, refines or overrides the answers',
-  additionalInstructionsPlaceholder: 'e.g. keep the old endpoint alive until the migration lands',
-  dismiss: 'Dismiss',
-  dismissHint: 'Continue without answering',
-  sendAnswers: (count: number) => `Send answer${count === 1 ? '' : 's'}`,
-  requiredHint: 'Required',
-  requiredMark: 'required',
-  pickOneOrMore: 'Pick one or more.',
-  noAnswer: 'No answer',
-  confirmYes: 'yes',
-  confirmNo: 'no',
-  // Session filter menu (the desktop app's sidebar faders menu)
-  filterSessions: 'Filter sessions',
-  filterView: 'View',
-  filterStatus: 'Status',
-  filterProject: 'Project',
-  filterActivity: 'Last activity',
-  filterSort: 'Sort by',
-  filterViews: {
-    project: 'Per directory',
-    host: 'Per host',
-    none: 'All projects',
-    date: 'By date',
-    state: 'By state',
-    agent: 'By agent',
-  },
-  filterStatuses: { active: 'Active', archived: 'Archived', all: 'All' },
-  filterActivities: { '1d': '1d', '3d': '3d', '7d': '7d', '30d': '30d', all: 'All' },
-  filterSorts: { recency: 'Recency', createdTime: 'Created time', alphabetical: 'Alphabetically' },
-  filterAllProjects: 'All',
-  filterAllProjectsOption: 'All projects',
-  filterNoProjects: 'No projects yet',
-  filterAgent: 'Agent',
-  filterAllAgents: 'All',
-  filterAllAgentsOption: 'All agents',
-  filterNoAgents: 'No agents yet',
-  /** A contributed select or multi filter with nothing picked. */
-  filterAny: 'Any',
-  /** A contributed filter's value: how many options are picked. */
-  filterPicked: (count: number) => `${count} picked`,
-  /** A space's own grouping or sort, among the view's choices. */
-  filterSpaceDefault: 'Space default',
-  filterSaveView: 'Save view as space',
-  // Hosts: the sidebar's host headers, status dots and the new-chat host picker (the desktop app's wording)
-  hostStatuses: {
-    local: 'connected',
-    connected: 'connected',
-    connecting: 'connecting',
-    reconnecting: 'reconnecting',
-    offline: 'offline',
-    'auth-refused': 'token refused',
-    identity: 'different server',
-    'version-mismatch': 'version mismatch',
-  },
-  hostStatusError: (status: string, error: string) => `${status}: ${error}`,
-  hostBadgeTitle: (host: string, status: string) => `${host}: ${status}`,
-  hostOpenSettings: (host: string) => `Open ${host}'s settings`,
-  hostExpand: (name: string) => `Expand ${name}`,
-  hostCollapse: (name: string) => `Collapse ${name}`,
-  hostPicker: 'Choose the host for this chat',
-  hostRunsOn: (name: string) => `Runs on: ${name}`,
-  hostRunsOnSection: 'Runs on',
-  hostThisMachine: 'This machine',
-  // Context orb and breakdown (the desktop app's composer)
-  contextSummary: (used: string, window: string, pct: number) => `Context: ${used} / ${window} (${pct}%)`,
-  contextSummaryCost: (summary: string, cost: string) => `${summary}, ${cost} this session`,
-  contextDetail: 'Context window detail',
-  contextAutoCompact: (pct: number) => `Auto-compact at ${pct}%`,
-  contextSessionCost: 'Session cost',
-  contextRunCount: (runs: number) => `${runs} run${runs === 1 ? '' : 's'}`,
-  contextNoBreakdown: 'The breakdown shows after the first run.',
-  contextDeferred: 'Deferred',
-  contextActiveSkills: 'Active skills',
-  contextLastTurn: 'Last turn',
-  contextCacheRead: 'Cached (read)',
-  contextCacheWrite: 'Cache write',
-  contextFreshInput: 'Fresh input',
-  contextOutput: 'Output',
-  contextEstimated: '~ Estimated. This provider does not report exact counts.',
-  contextClickToCopy: (hasDescription: boolean) => `click to copy ${hasDescription ? 'description' : 'name'}`,
-  contextCopied: 'Copied',
-};
-
-/** The shape of the chat label dictionary: every key of {@link DEFAULT_CHAT_LABELS}. Some values are functions that build a string. */
-export type ChatLabels = typeof DEFAULT_CHAT_LABELS;

package/src/chat/headless/markdown-chunks.ts

@@ -1,134 +0,0 @@
-/**
- * Split long markdown into independently parseable chunks.
- *
- * A boundary is a blank line followed by a line that starts at column 0,
- * outside a fenced code block: nothing can continue across it (an indented
- * line after a blank could still belong to a list item, a fence spans
- * blanks). What it changes is cosmetic at worst: a loose list becomes two
- * adjacent lists (an ordered one keeps its numbering through `start`).
- *
- * Boundaries only depend on the text before them and the line right after,
- * so while a reply streams every chunk but the last keeps its exact text,
- * and its memoised render.
- *
- * Fences open and close by core's rules (`parseFenceOpen` / `isFenceClose`),
- * so a chunk never ends inside a code block the parse sees as still open.
- */
-import { type FenceOpen, isFenceClose, parseFenceOpen } from 'zidane/chat/pure';
-
-/** Below this, one parse is cheap enough: no chunking at all. */
-export const CHUNK_THRESHOLD = 6000;
-/** A chunk closes at the first boundary past this size. */
-const CHUNK_TARGET = 3000;
-
-/** The fence open after `line`, given the one open before it. */
-function stepFence(fence: FenceOpen | null, line: string): FenceOpen | null {
-  if (fence) return isFenceClose(line, fence.char, fence.length) ? null : fence;
-  return parseFenceOpen(line);
-}
-
-/**
- * While a reply streams it is re-rendered on every delta (many per second),
- * so it splits much finer: everything above the growing paragraph stays a
- * memoised chunk and only the tail is parsed again.
- */
-const STREAMING_THRESHOLD = 1200;
-const STREAMING_TARGET = 600;
-
-/** A last line of one or two backticks or tildes: a fence still arriving. */
-const PARTIAL_FENCE = /\n {0,3}(?:`{1,2}|~{1,2})$/;
-
-/**
- * Holds back a fence still arriving at the end of a streaming reply. Text
- * reveals a few characters a frame, so a closing ```` ``` ```` lands as `` ` ``,
- * then ` `` `: until the third, an open code block shows the partial
- * marker as one more line of code, then drops it, and the reply shrinks by
- * a line under a view following its bottom. A frame later the whole fence
- * is there.
- *
- * @param text - The reply so far.
- */
-export function withoutPartialFence(text: string): string {
-  return text.replace(PARTIAL_FENCE, '\n');
-}
-
-/** A streaming chunk's fence that has not closed yet, apart from the text before it. */
-export interface OpenFence {
-  /** The markdown before the fence (may be empty). */
-  before: string;
-  /** The fence's language, as the parsed block names it (`plaintext` when the info string names none). */
-  language: string;
-  /** The code so far. */
-  code: string;
-}
-
-/**
- * The fence a streaming chunk ends inside, when it opened at column 0 (an
- * indented one may belong to a list item, which only the parse can tell).
- * The open fence is the whole tail of the chunk, so parsing it again on
- * every delta re-parses a growing code block for nothing: the code block can
- * draw the text as is, and the chunk parses normally once the fence closes.
- *
- * @param chunk - The last chunk of a streaming reply.
- * @returns The open fence, or `null` when the chunk does not end inside one.
- */
-export function openFenceOf(chunk: string): OpenFence | null {
-  const lines = chunk.split('\n');
-  let fence: FenceOpen | null = null;
-  let at = -1;
-  for (let i = 0; i < lines.length; i++) {
-    const next = stepFence(fence, lines[i]!);
-    if (next && !fence) at = i;
-    fence = next;
-  }
-  if (fence === null || fence.indent !== 0) return null;
-  const info = lines[at]!.slice(fence.length);
-  // The parse's class is `language-<first word of the info string>`, read back as its leading \w run.
-  const language = /^(\w+)/.exec(info.trim().split(/\s/)[0] ?? '')?.[1] ?? 'plaintext';
-  return {
-    before: lines.slice(0, at).join('\n'),
-    language,
-    code: lines
-      .slice(at + 1)
-      .join('\n')
-      .replace(/\n$/, ''),
-  };
-}
-
-/**
- * Splits markdown into chunks that parse on their own, so a long or streaming reply can re-render only its last chunk. Text shorter than the threshold comes back as one chunk.
- *
- * @param text - The markdown to split.
- * @param opts - Split options. `streaming: true` uses finer chunks for a reply that is still growing.
- */
-export function splitMarkdown(text: string, opts: { streaming?: boolean } = {}): string[] {
-  const threshold = opts.streaming ? STREAMING_THRESHOLD : CHUNK_THRESHOLD;
-  const target = opts.streaming ? STREAMING_TARGET : CHUNK_TARGET;
-  if (text.length < threshold) return [text];
-  const lines = text.split('\n');
-  const chunks: string[] = [];
-  let start = 0;
-  let size = 0;
-  let fence: FenceOpen | null = null;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]!;
-    fence = stepFence(fence, line);
-    size += line.length + 1;
-    const next = lines[i + 1];
-    if (
-      fence === null &&
-      size >= target &&
-      line.trim() === '' &&
-      next !== undefined &&
-      next.length > 0 &&
-      next[0] !== ' ' &&
-      next[0] !== '\t'
-    ) {
-      chunks.push(lines.slice(start, i + 1).join('\n'));
-      start = i + 1;
-      size = 0;
-    }
-  }
-  chunks.push(lines.slice(start).join('\n'));
-  return chunks;
-}

package/src/chat/headless/path-resolver.ts

@@ -1,178 +0,0 @@
-/**
- * What a prose chip points at (a file or folder on disk, or a branch), asked
- * of the host (`ChatHost.paths`) in batches.
- *
- * Every chip mounting in the same frame shares one `resolve` call per
- * folder; answers are cached per folder and text so scrolling history back
- * into view costs nothing. An answer older than `STALE_MS` is shown while it
- * is checked again (the agent may have created or removed the file since),
- * and a folder the host says moved (a commit, a checkout) is checked afresh.
- */
-import type { ChatPaths, ChatResolvedPath } from './transcript-host';
-
-/** `null`: not known yet, or the folder can't be checked (sandboxes). */
-export type ChipResolution = ChatResolvedPath | null;
-
-const STALE_MS = 15_000;
-
-interface Entry {
-  value: ChipResolution;
-  at: number;
-  inFlight: boolean;
-}
-
-/** Options for {@link createPathResolver}. */
-export interface PathResolverOptions {
-  /** Marks a first ask (an answer may resize the chip); the returned function ends it (`beginChipWork`). */
-  beginWork?: () => () => void;
-}
-
-/** The chip answers of one host. */
-export interface PathResolver {
-  /** The current answer for `text` in `cwd`. */
-  get(cwd: string, text: string): ChipResolution;
-  /** Asks for `text` in `cwd` unless an answer is fresh or on the wire. */
-  request(cwd: string, text: string): void;
-  /** Asks again now, bypassing the cache (a click: the file may exist since). */
-  resolveNow(cwd: string, text: string): Promise<ChipResolution>;
-  /** Calls `listener` when the answer for `text` in `cwd` changes. Returns the unsubscribe. */
-  subscribe(cwd: string, text: string, listener: () => void): () => void;
-  /** Stops following the host's changes. */
-  dispose(): void;
-}
-
-const keyOf = (cwd: string, text: string) => `${cwd}\0${text}`;
-const NO_WORK = () => () => {};
-
-function sameResolution(a: ChipResolution, b: ChipResolution): boolean {
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-
-/**
- * Creates the chip answers over a host's paths.
- *
- * @param paths - The host's `paths` member.
- * @param options - The chip-work counter.
- */
-export function createPathResolver(paths: ChatPaths, options: PathResolverOptions = {}): PathResolver {
-  const beginWork = options.beginWork ?? NO_WORK;
-  const cache = new Map<string, Map<string, Entry>>();
-  const listeners = new Map<string, Set<() => void>>();
-  const queued = new Map<string, Set<string>>();
-  let flushScheduled = false;
-  /** First asks (nothing shown yet): an answer may resize the chip, so a thread's reveal waits on them. */
-  const firstAsks = new Map<string, () => void>();
-  let watching = false;
-  let offChanges: (() => void) | undefined;
-
-  const answered = (cwd: string, text: string) => {
-    const key = keyOf(cwd, text);
-    firstAsks.get(key)?.();
-    firstAsks.delete(key);
-  };
-
-  /** `null` when the host can't answer. */
-  const ask = (cwd: string, texts: string[]): Promise<readonly ChatResolvedPath[] | null> =>
-    Promise.resolve()
-      .then(() => paths.resolve(cwd, texts))
-      .catch(() => null);
-
-  const entries = (cwd: string) => {
-    let map = cache.get(cwd);
-    if (!map) {
-      map = new Map();
-      cache.set(cwd, map);
-    }
-    return map;
-  };
-
-  const emit = (cwd: string, text: string) => {
-    for (const listener of listeners.get(keyOf(cwd, text)) ?? []) listener();
-  };
-
-  const watchRepoMoves = () => {
-    if (watching) return;
-    watching = true;
-    // Commits, checkouts and pulls add and remove files (and branches): answer afresh.
-    offChanges = paths.onChanged?.((cwd) => {
-      for (const entry of cache.get(cwd)?.values() ?? []) entry.at = 0;
-    });
-  };
-
-  const flush = async () => {
-    flushScheduled = false;
-    const batches = [...queued];
-    queued.clear();
-    await Promise.all(
-      batches.map(async ([cwd, set]) => {
-        const texts = [...set];
-        const answers = await ask(cwd, texts);
-        const map = entries(cwd);
-        texts.forEach((text, i) => {
-          const value = answers ? (answers[i] ?? { kind: 'missing' as const }) : null;
-          const prev = map.get(text);
-          map.set(text, { value, at: Date.now(), inFlight: false });
-          if (!prev || !sameResolution(prev.value, value)) emit(cwd, text);
-          answered(cwd, text);
-        });
-      }),
-    );
-  };
-
-  const request = (cwd: string, text: string) => {
-    watchRepoMoves();
-    const map = entries(cwd);
-    const entry = map.get(text);
-    if (entry?.inFlight) return;
-    if (entry && Date.now() - entry.at < STALE_MS) return;
-    if (entry) entry.inFlight = true;
-    else {
-      map.set(text, { value: null, at: 0, inFlight: true });
-      firstAsks.set(keyOf(cwd, text), beginWork());
-    }
-    let set = queued.get(cwd);
-    if (!set) {
-      set = new Set();
-      queued.set(cwd, set);
-    }
-    set.add(text);
-    if (!flushScheduled) {
-      flushScheduled = true;
-      // One frame of chips per call: the whole message, not one call per chip.
-      setTimeout(() => void flush(), 0);
-    }
-  };
-
-  return {
-    get: (cwd, text) => cache.get(cwd)?.get(text)?.value ?? null,
-    request,
-    async resolveNow(cwd, text) {
-      const answers = await ask(cwd, [text]);
-      const value = answers ? (answers[0] ?? { kind: 'missing' as const }) : null;
-      const map = entries(cwd);
-      const prev = map.get(text);
-      map.set(text, { value, at: Date.now(), inFlight: false });
-      if (!prev || !sameResolution(prev.value, value)) emit(cwd, text);
-      return value;
-    },
-    subscribe(cwd, text, listener) {
-      const key = keyOf(cwd, text);
-      let set = listeners.get(key);
-      if (!set) {
-        set = new Set();
-        listeners.set(key, set);
-      }
-      set.add(listener);
-      const own = set;
-      return () => {
-        own.delete(listener);
-        if (own.size === 0 && listeners.get(key) === own) listeners.delete(key);
-      };
-    },
-    dispose() {
-      offChanges?.();
-      for (const done of firstAsks.values()) done();
-      firstAsks.clear();
-    },
-  };
-}