@mjasnikovs/pi-task 0.17.21 → 0.17.23

package/dist/remote/bridge.d.ts

@@ -65,6 +65,14 @@ export declare class SessionUI {
     private askLocal;
 }
 export declare function publishNotify(message: string, level: 'info' | 'warning' | 'error'): void;
+/**
+ * Abort the running agent turn — the browser Stop button. `abort()` lives on the
+ * base ExtensionContext ("Abort the current agent operation") so it works for a
+ * host chat turn, a /task phase turn, or a /task-auto run alike. The shimmed ctx
+ * inherits it from the real event ctx via its prototype, so this is safe even
+ * before the user has run a command in the terminal. No-op when nothing is running.
+ */
+export declare function interruptAgent(): void;
 /**
  * Mirror a task lifecycle notice (the kind pi-task shows on the terminal via
  * ctx.ui.notify) to connected remote viewers. Task failures and other

package/dist/remote/bridge.js

@@ -108,6 +108,16 @@ export class SessionUI {
 export function publishNotify(message, level) {
     getBridge().broadcast({ type: 'notify', message, level });
 }
+/**
+ * Abort the running agent turn — the browser Stop button. `abort()` lives on the
+ * base ExtensionContext ("Abort the current agent operation") so it works for a
+ * host chat turn, a /task phase turn, or a /task-auto run alike. The shimmed ctx
+ * inherits it from the real event ctx via its prototype, so this is safe even
+ * before the user has run a command in the terminal. No-op when nothing is running.
+ */
+export function interruptAgent() {
+    getBridge().currentCtx?.abort();
+}
 /**
  * Mirror a task lifecycle notice (the kind pi-task shows on the terminal via
  * ctx.ui.notify) to connected remote viewers. Task failures and other

package/dist/remote/events.js

@@ -1,18 +1,24 @@
 import { setAgentIdle } from './state.js';
 import { publishNotify } from './bridge.js';
-import { agentStart, appendText, textEnd, startTool, updateTool, endTool, agentEnd, addUserTurn, addError, addSystemNote } from './session-state.js';
+import { agentStart, appendText, textEnd, appendThinking, thinkingEnd, startTool, updateTool, endTool, agentEnd, addUserTurn, addError, addSystemNote } from './session-state.js';
 /** Mirror pi agent events into the authoritative SessionState. Each handler
  *  drives a mutator, which updates the snapshot AND broadcasts the live delta. */
 export function setupEvents(pi) {
-    pi.on('agent_start', (_event, _ctx) => {
+    pi.on('agent_start', (_event, ctx) => {
         setAgentIdle(false);
-        agentStart();
+        agentStart(ctx.model?.name);
     });
     pi.on('message_update', (event, _ctx) => {
         const ae = event.assistantMessageEvent;
         if (ae.type === 'text_delta' && 'delta' in ae && typeof ae.delta === 'string') {
             appendText(ae.delta);
         }
+        else if (ae.type === 'thinking_delta' && 'delta' in ae && typeof ae.delta === 'string') {
+            appendThinking(ae.delta);
+        }
+        else if (ae.type === 'thinking_end') {
+            thinkingEnd();
+        }
         else if (ae.type === 'error') {
             const errorMessage = 'error' in ae && ae.error && typeof ae.error.errorMessage === 'string' ?
                 ae.error.errorMessage
@@ -43,7 +49,7 @@ export function setupEvents(pi) {
     });
     pi.on('agent_end', (_event, ctx) => {
         setAgentIdle(true);
-        agentEnd(ctx.getContextUsage());
+        agentEnd(ctx.getContextUsage(), ctx.model?.name);
         // Deliberately no push: agent_end fires on EVERY host turn — every chat
         // reply, every internal phase turn inside /task, and every internal /task
         // run inside /task-auto — so a "Task finished" push here floods the device.

package/dist/remote/history.d.ts

@@ -2,6 +2,12 @@ export interface TextPart {
     kind: 'text';
     text: string;
 }
+export interface ThinkingPart {
+    kind: 'thinking';
+    text: string;
+    /** false while thinking deltas are still streaming; true once thinking_end fires. */
+    done?: boolean;
+}
 export interface ToolPart {
     kind: 'tool';
     toolCallId: string;
@@ -11,8 +17,10 @@ export interface ToolPart {
     isError: boolean;
     /** false while the tool is still running (result not in yet). */
     done: boolean;
+    /** Wall-clock duration once finished, shown dimly in the tool summary. */
+    elapsedMs?: number;
 }
-export type Part = TextPart | ToolPart;
+export type Part = TextPart | ThinkingPart | ToolPart;
 export interface Turn {
     role: 'user' | 'assistant' | 'system';
     /** User text, error text, or a system note. Assistant content lives in `parts`. */
@@ -20,6 +28,8 @@ export interface Turn {
     /** Ordered assistant content (text + tools). */
     parts?: Part[];
     error?: boolean;
+    /** Epoch ms when the turn was committed — the client renders a dim HH:MM. */
+    ts?: number;
 }
 export declare class HistoryBuffer {
     private entries;

package/dist/remote/history.js

@@ -24,7 +24,7 @@ export class HistoryBuffer {
         return [...this.entries];
     }
     _push(entry) {
-        this.entries.push(entry);
+        this.entries.push({ ts: Date.now(), ...entry });
         if (this.entries.length > this.limit) {
             this.entries.shift();
         }

package/dist/remote/protocol.d.ts

@@ -10,10 +10,27 @@ export interface PromptResolvedMessage {
     type: 'prompt_resolved';
     id: string;
 }
-/** The single task-widget slot. `lines: null` clears it. */
+/** Structured task-widget payload — lets the browser render a real progress bar,
+ *  phase badge and elapsed clock instead of reflowing the terminal's text lines.
+ *  Always sent ALONGSIDE `lines`, which stays the authoritative fallback. */
+export interface WidgetData {
+    /** Head line, e.g. "TASK_0003 · auth routes" or "/task-auto · building". */
+    title: string;
+    /** Current phase/stage label, e.g. "refine", "implementing", "enforcing guidelines". */
+    phase: string;
+    /** Progress numerator (current step) — omitted for stages without numbering. */
+    done?: number;
+    /** Progress denominator (total steps) — omitted for stages without numbering. */
+    total?: number;
+    /** Pre-formatted elapsed clock, e.g. "2:14". */
+    elapsed?: string;
+}
+/** The single task-widget slot. `lines: null` clears it. `data` carries the
+ *  structured view (null when clearing or when a producer only has text). */
 export interface WidgetMessage {
     type: 'widget';
     lines: string[] | null;
+    data?: WidgetData | null;
 }
 export interface NotifyMessage {
     type: 'notify';
@@ -58,5 +75,9 @@ export interface ClientPromptAnswer {
     id: string;
     value: string | undefined;
 }
-export type ClientMessage = ClientChatMessage | ClientPromptAnswer;
+/** Stop the running agent turn (the browser Stop button). */
+export interface ClientInterrupt {
+    type: 'interrupt';
+}
+export type ClientMessage = ClientChatMessage | ClientPromptAnswer | ClientInterrupt;
 export declare function isClientMessage(x: unknown): x is ClientMessage;

package/dist/remote/protocol.js

@@ -6,6 +6,8 @@ export function isClientMessage(x) {
     const m = x;
     if (m.type === 'message')
         return typeof m.text === 'string';
+    if (m.type === 'interrupt')
+        return true;
     if (m.type === 'prompt_answer') {
         return typeof m.id === 'string' && (m.value === undefined || typeof m.value === 'string');
     }

package/dist/remote/register.js

@@ -1,5 +1,5 @@
 import { getConfig } from '../config/config.js';
-import { getBridge, dispatchRemoteLine, dispatchRemoteNewSession, makeShimmedCtx } from './bridge.js';
+import { getBridge, dispatchRemoteLine, dispatchRemoteNewSession, makeShimmedCtx, interruptAgent } from './bridge.js';
 import { setupEvents } from './events.js';
 import { reset, addUserTurn } from './session-state.js';
 import { html } from './ui.js';
@@ -33,11 +33,15 @@ export function registerRemote(pi) {
                         S.send?.(plain);
                     }
                     else {
-                        S.send?.(plain, { deliverAs: 'followUp' });
+                        // Mid-run: steer the live turn (inject the message into the
+                        // current generation) rather than queueing it for after, so a
+                        // remote nudge lands immediately — matching the composer's
+                        // "delivered mid-run" affordance.
+                        S.send?.(plain, { deliverAs: 'steer' });
                     }
                 }
             });
-        }, wsUrl => html(wsUrl));
+        }, wsUrl => html(wsUrl), interruptAgent);
         // Hands-off HTTPS: point Tailscale serve at our port so phones get a
         // secure context. Best-effort — any failure degrades to the http URL.
         S.serveResult = await ensureTailscaleServe(S.server.port).catch(() => ({ state: 'unavailable' }));

package/dist/remote/server.d.ts

@@ -28,5 +28,5 @@ export declare function getLocalIPs(nets?: NodeJS.Dict<import("node:os").Network
  *  Tailscale line uses the MagicDNS host when known (resolves to the same node,
  *  but is what SSH and webpush certs need), falling back to the raw IP. */
 export declare function formatAddresses(ips: LocalIPs, port: number, tsHost?: string): AddressLine[];
-export declare function startServer(onMessage: MessageCallback, getHtml: (wsUrl: string) => string): Promise<ServerHandle>;
+export declare function startServer(onMessage: MessageCallback, getHtml: (wsUrl: string) => string, onInterrupt?: () => void): Promise<ServerHandle>;
 export {};

package/dist/remote/server.js

@@ -64,7 +64,7 @@ async function findPort(start, max) {
     }
     throw new Error(`No free port found in range ${start}–${start + max - 1}`);
 }
-export async function startServer(onMessage, getHtml) {
+export async function startServer(onMessage, getHtml, onInterrupt) {
     const port = await findPort(8800, 100);
     const ips = getLocalIPs();
     const ip = ips.primary;
@@ -159,6 +159,10 @@ export async function startServer(onMessage, getHtml) {
             }
             if (!isClientMessage(msg))
                 return;
+            if (msg.type === 'interrupt') {
+                onInterrupt?.();
+                return;
+            }
             if (msg.type === 'prompt_answer') {
                 answerPrompt(msg.id, msg.value);
                 return;

package/dist/remote/session-state.d.ts

@@ -1,6 +1,6 @@
 import { HistoryBuffer } from './history.js';
 import type { Turn, Part } from './history.js';
-import type { ContextUsage, PromptMessage } from './protocol.js';
+import type { ContextUsage, PromptMessage, WidgetData } from './protocol.js';
 export interface LiveTurn {
     /** Ordered assistant content (text segments + tool calls) for this run. */
     parts: Part[];
@@ -14,36 +14,50 @@ export interface SnapshotMessage {
     live: LiveTurn | null;
     agentRunning: boolean;
     taskWidget: string[] | null;
+    taskWidgetData: WidgetData | null;
     prompt: PromptMessage | null;
     context: ContextUsage | null;
+    model: string | null;
 }
 interface SessionState {
     history: HistoryBuffer;
     live: LiveTurn | null;
     agentRunning: boolean;
     taskWidget: string[] | null;
+    taskWidgetData: WidgetData | null;
     prompt: PromptMessage | null;
     context: ContextUsage | null;
+    /** Human-readable active model name (e.g. "Qwen3.6 27B"), for the header chip. */
+    model: string | null;
+    /** tool start timestamps (ms), keyed by toolCallId — kept off the serialized
+     *  parts so it never reaches the client; used only to compute elapsedMs. */
+    toolStarts: Record<string, number>;
     /** Broadcast sink — swapped in tests via _setSink. */
     sink: (msg: unknown) => void;
 }
 export declare function getState(): SessionState;
 /** @internal Test-only: swap the broadcast sink to capture emitted deltas. */
 export declare function _setSink(fn: (msg: unknown) => void): void;
-export declare function agentStart(): void;
+export declare function agentStart(model?: string): void;
 export declare function appendText(delta: string): void;
 export declare function textEnd(): void;
+/** Accumulate a reasoning/thinking delta into the current thinking part (a new
+ *  part opens when the previous one is closed or the last part isn't thinking).
+ *  Stored as a part kind so a reconnect snapshot replays the collapsed block. */
+export declare function appendThinking(delta: string): void;
+export declare function thinkingEnd(): void;
 export declare function startTool(toolCallId: string, toolName: string, args: unknown): void;
 export declare function updateTool(toolCallId: string, partialResult: unknown): void;
 export declare function endTool(toolCallId: string, toolName: string, result: unknown, isError: boolean): void;
-export declare function agentEnd(context: ContextUsage): void;
+export declare function agentEnd(context: ContextUsage, model?: string): void;
 export declare function addUserTurn(text: string): void;
 export declare function addError(message: string): void;
 /** A persistent inline note (committed to the transcript so it survives reconnect)
  *  plus a live delta so connected clients render it immediately. */
 export declare function addSystemNote(text: string): void;
-/** The single task-widget slot. Empty/undefined lines clear it. */
-export declare function setTaskWidget(lines: string[] | null | undefined): void;
+/** The single task-widget slot. Empty/undefined lines clear it. `data` is the
+ *  structured view rendered by the browser; the lines remain the fallback. */
+export declare function setTaskWidget(lines: string[] | null | undefined, data?: WidgetData | null): void;
 export declare function setPrompt(prompt: PromptMessage): void;
 export declare function clearPrompt(id: string): void;
 export declare function setContext(context: ContextUsage): void;

package/dist/remote/session-state.js

@@ -18,8 +18,11 @@ function fresh() {
         live: null,
         agentRunning: false,
         taskWidget: null,
+        taskWidgetData: null,
         prompt: null,
         context: null,
+        model: null,
+        toolStarts: {},
         sink: wsBroadcast
     };
 }
@@ -38,11 +41,13 @@ function ensureLive(s) {
     return s.live;
 }
 // ─── Mutators ────────────────────────────────────────────────────────────────
-export function agentStart() {
+export function agentStart(model) {
     const s = getState();
     s.live = { parts: [], textOpen: false };
     s.agentRunning = true;
-    s.sink({ type: 'agent_start' });
+    if (model)
+        s.model = model;
+    s.sink({ type: 'agent_start', model: s.model });
 }
 export function appendText(delta) {
     const s = getState();
@@ -63,6 +68,29 @@ export function textEnd() {
         s.live.textOpen = false; // next text starts a new segment
     s.sink({ type: 'text_end' });
 }
+/** Accumulate a reasoning/thinking delta into the current thinking part (a new
+ *  part opens when the previous one is closed or the last part isn't thinking).
+ *  Stored as a part kind so a reconnect snapshot replays the collapsed block. */
+export function appendThinking(delta) {
+    const s = getState();
+    const live = ensureLive(s);
+    const last = live.parts[live.parts.length - 1];
+    if (last && last.kind === 'thinking' && !last.done) {
+        last.text += delta;
+    }
+    else {
+        live.parts.push({ kind: 'thinking', text: delta, done: false });
+    }
+    live.textOpen = false; // a following text delta begins a fresh bubble
+    s.sink({ type: 'thinking_delta', delta });
+}
+export function thinkingEnd() {
+    const s = getState();
+    const last = s.live?.parts[s.live.parts.length - 1];
+    if (last && last.kind === 'thinking')
+        last.done = true;
+    s.sink({ type: 'thinking_end' });
+}
 export function startTool(toolCallId, toolName, args) {
     const s = getState();
     const live = ensureLive(s);
@@ -76,6 +104,7 @@ export function startTool(toolCallId, toolName, args) {
         isError: false,
         done: false
     });
+    s.toolStarts[toolCallId] = Date.now();
     s.sink({ type: 'tool_start', toolCallId, toolName, args });
 }
 export function updateTool(toolCallId, partialResult) {
@@ -85,10 +114,18 @@ export function endTool(toolCallId, toolName, result, isError) {
     const s = getState();
     const live = ensureLive(s);
     const part = live.parts.find((p) => p.kind === 'tool' && p.toolCallId === toolCallId);
+    const startedAt = s.toolStarts[toolCallId];
+    let elapsedMs;
+    if (startedAt != null) {
+        elapsedMs = Date.now() - startedAt;
+        delete s.toolStarts[toolCallId];
+    }
     if (part) {
         part.result = result;
         part.isError = isError;
         part.done = true;
+        if (elapsedMs != null)
+            part.elapsedMs = elapsedMs;
     }
     else {
         // tool_end without a matching start (shouldn't happen) — append a done tool.
@@ -102,16 +139,18 @@ export function endTool(toolCallId, toolName, result, isError) {
             done: true
         });
     }
-    s.sink({ type: 'tool_end', toolCallId, toolName, result, isError });
+    s.sink({ type: 'tool_end', toolCallId, toolName, result, isError, elapsedMs });
 }
-export function agentEnd(context) {
+export function agentEnd(context, model) {
     const s = getState();
     if (s.live)
         s.history.addAssistantTurn(s.live.parts);
     s.live = null;
     s.agentRunning = false;
     s.context = context;
-    s.sink({ type: 'agent_end', contextUsage: context });
+    if (model)
+        s.model = model;
+    s.sink({ type: 'agent_end', contextUsage: context, model: s.model });
 }
 export function addUserTurn(text) {
     const s = getState();
@@ -132,11 +171,13 @@ export function addSystemNote(text) {
     s.history.addSystemNote(text);
     s.sink({ type: 'system_note', text });
 }
-/** The single task-widget slot. Empty/undefined lines clear it. */
-export function setTaskWidget(lines) {
+/** The single task-widget slot. Empty/undefined lines clear it. `data` is the
+ *  structured view rendered by the browser; the lines remain the fallback. */
+export function setTaskWidget(lines, data) {
     const s = getState();
     s.taskWidget = lines && lines.length ? lines : null;
-    s.sink({ type: 'widget', lines: s.taskWidget });
+    s.taskWidgetData = s.taskWidget ? (data ?? null) : null;
+    s.sink({ type: 'widget', lines: s.taskWidget, data: s.taskWidgetData });
 }
 export function setPrompt(prompt) {
     const s = getState();
@@ -160,8 +201,11 @@ export function reset() {
     s.live = null;
     s.agentRunning = false;
     s.taskWidget = null;
+    s.taskWidgetData = null;
     s.prompt = null;
     s.context = null;
+    // Deliberately keep s.model: the active model doesn't change across a /new,
+    // so the header chip needn't blank and re-fill on every session switch.
     s.sink({ type: 'reset' });
 }
 /** Serialize the whole state for a (re)connecting client. */
@@ -173,7 +217,9 @@ export function snapshot() {
         live: s.live ? { parts: [...s.live.parts], textOpen: s.live.textOpen } : null,
         agentRunning: s.agentRunning,
         taskWidget: s.taskWidget,
+        taskWidgetData: s.taskWidgetData,
         prompt: s.prompt,
-        context: s.context
+        context: s.context,
+        model: s.model
     };
 }

package/dist/remote/ui-highlight.d.ts

@@ -0,0 +1,2 @@
+/** Emitted client JS (top-level function declarations + language tables). */
+export declare function highlightModule(): string;

package/dist/remote/ui-highlight.js

@@ -0,0 +1,119 @@
+// Generalized single-pass syntax highlighter, shipped as a JS string and
+// concatenated into the page by ui.ts. It grew out of the client's original
+// JS-only tokenizer: the string/comment/number/identifier logic is now shared and
+// parameterized by a per-language config (keyword set + comment markers + string
+// flavors). Unknown languages fall back to escaped plain text (unchanged).
+//
+// Depends on escHtml (ui-render.ts) — both land in the same <script>.
+/** Emitted client JS (top-level function declarations + language tables). */
+export function highlightModule() {
+    return `    var HL_JS_KW = new Set(('break case catch class const continue debugger default delete do else export '
+      + 'extends finally for from function if import in instanceof let new of return static super switch this '
+      + 'throw try typeof var void while with yield async await type interface enum implements abstract as declare '
+      + 'namespace readonly undefined null true false override satisfies public private protected get set').split(' '));
+    var HL_PY_KW = new Set(('def return if elif else for while in not and or import from as class try except finally '
+      + 'raise with lambda yield pass break continue global nonlocal assert del None True False async await is print self').split(' '));
+    var HL_SH_KW = new Set(('if then else elif fi for while do done case esac in function return echo export local read '
+      + 'cd set unset source alias exit test').split(' '));
+    var HL_SQL_KW = new Set(('select from where insert into values update set delete create table drop alter add column '
+      + 'join left right inner outer full on group by order having limit offset union and or not null is as distinct '
+      + 'count sum avg min max primary key foreign references index unique default int integer text varchar char boolean '
+      + 'timestamp date time serial begin commit rollback').split(' '));
+    var HL_GO_KW = new Set(('func package import var const type struct interface map chan go defer return if else for range '
+      + 'switch case default break continue select nil true false make new append len cap string int int64 float64 bool byte rune error').split(' '));
+    var HL_RUST_KW = new Set(('fn let mut const static struct enum impl trait pub use mod match if else for while loop return '
+      + 'break continue self Self super crate as where move ref dyn async await unsafe true false None Some Ok Err String Vec Option Result Box').split(' '));
+    var HL_YAML_KW = new Set('true false null yes no on off'.split(' '));
+    var HL_JSON_KW = new Set('true false null'.split(' '));
+
+    var HL_LANGS = {
+      js:     {kw: HL_JS_KW,   line: '//', block: ['/*', '*/'], tmpl: true},
+      ts:     {kw: HL_JS_KW,   line: '//', block: ['/*', '*/'], tmpl: true},
+      python: {kw: HL_PY_KW,   line: '#',  block: null,         triple: true},
+      sh:     {kw: HL_SH_KW,   line: '#',  block: null},
+      sql:    {kw: HL_SQL_KW,  line: '--', block: ['/*', '*/'], ci: true},
+      go:     {kw: HL_GO_KW,   line: '//', block: ['/*', '*/'], tmpl: true},
+      rust:   {kw: HL_RUST_KW, line: '//', block: ['/*', '*/']},
+      yaml:   {kw: HL_YAML_KW, line: '#',  block: null},
+      json:   {kw: HL_JSON_KW, line: null, block: null},
+      css:    {kw: null,       line: null, block: ['/*', '*/']}
+    };
+    var HL_ALIAS = {javascript: 'js', jsx: 'js', mjs: 'js', cjs: 'js', node: 'js', typescript: 'ts', tsx: 'ts',
+      py: 'python', python3: 'python', bash: 'sh', shell: 'sh', shellscript: 'sh', zsh: 'sh', console: 'sh',
+      yml: 'yaml', rs: 'rust', golang: 'go', htm: 'html', xml: 'html', svg: 'html', scss: 'css'};
+
+    function hlSpan(cls, text) { return '<span class="' + cls + '">' + escHtml(text) + '</span>'; }
+
+    function tokenize(code, cfg) {
+      var BT = String.fromCharCode(96);
+      var r = '', i = 0, n = code.length;
+      while (i < n) {
+        var ch = code[i];
+        if (cfg.block && code.startsWith(cfg.block[0], i)) {
+          var end = code.indexOf(cfg.block[1], i + cfg.block[0].length);
+          var je = end < 0 ? n : end + cfg.block[1].length;
+          r += hlSpan('hl-cmt', code.slice(i, je)); i = je; continue;
+        }
+        if (cfg.line && code.startsWith(cfg.line, i)) {
+          var jl = i; while (jl < n && code[jl] !== '\\n') jl++;
+          r += hlSpan('hl-cmt', code.slice(i, jl)); i = jl; continue;
+        }
+        if (ch === '"' || ch === "'" || (cfg.tmpl && ch === BT)) {
+          if (cfg.triple && code[i + 1] === ch && code[i + 2] === ch) {
+            var close = code.indexOf(ch + ch + ch, i + 3);
+            var jt = close < 0 ? n : close + 3;
+            r += hlSpan('hl-str', code.slice(i, jt)); i = jt; continue;
+          }
+          var js = i + 1;
+          while (js < n) { if (code[js] === '\\\\') { js += 2; continue; } if (code[js] === ch || code[js] === '\\n') break; js++; }
+          if (code[js] === ch) js++;
+          r += hlSpan('hl-str', code.slice(i, js)); i = js; continue;
+        }
+        if (ch >= '0' && ch <= '9') {
+          var jn = i;
+          if (code[i] === '0' && /[xXoObB]/.test(code[i + 1] || '')) {
+            jn += 2; while (jn < n && /[0-9a-fA-F_]/.test(code[jn])) jn++;
+          } else {
+            while (jn < n && ((code[jn] >= '0' && code[jn] <= '9') || code[jn] === '_')) jn++;
+            if (code[jn] === '.') { jn++; while (jn < n && code[jn] >= '0' && code[jn] <= '9') jn++; }
+            if (code[jn] === 'e' || code[jn] === 'E') { jn++; if (code[jn] === '+' || code[jn] === '-') jn++; while (jn < n && code[jn] >= '0' && code[jn] <= '9') jn++; }
+            if (code[jn] === 'n') jn++;
+          }
+          r += hlSpan('hl-num', code.slice(i, jn)); i = jn; continue;
+        }
+        if (/[a-zA-Z_$]/.test(ch)) {
+          var jw = i; while (jw < n && /[a-zA-Z0-9_$]/.test(code[jw])) jw++;
+          var word = code.slice(i, jw);
+          var kwHit = cfg.kw && (cfg.kw.has(word) || (cfg.ci && cfg.kw.has(word.toLowerCase())));
+          if (kwHit) r += hlSpan('hl-kw', word);
+          else if (code[jw] === '(') r += hlSpan('hl-fn', word);
+          else r += escHtml(word);
+          i = jw; continue;
+        }
+        r += escHtml(ch); i++;
+      }
+      return r;
+    }
+
+    // Markup languages don't fit the identifier tokenizer; highlight tag names and
+    // attribute names off the already-escaped text.
+    function highlightMarkup(code) {
+      var e = escHtml(code);
+      // Attribute names first (before any spans exist), then tag names — otherwise
+      // the attribute pass would re-match the class="" inside the spans it inserted.
+      e = e.replace(/([a-zA-Z-]+)=("|&quot;)/g, function (_, a, q) { return '<span class="hl-fn">' + a + '</span>=' + q; });
+      e = e.replace(/(&lt;\\/?)([a-zA-Z][\\w-]*)/g, function (_, p, t) { return p + '<span class="hl-kw">' + t + '</span>'; });
+      return e;
+    }
+
+    function syntaxHighlight(code, lang) {
+      code = String(code == null ? '' : code);
+      lang = (lang || '').toLowerCase();
+      lang = HL_ALIAS[lang] || lang;
+      if (lang === 'html') return highlightMarkup(code);
+      var cfg = HL_LANGS[lang];
+      if (!cfg) return escHtml(code);
+      return tokenize(code, cfg);
+    }
+`;
+}

package/dist/remote/ui-render.d.ts

@@ -0,0 +1,2 @@
+/** Emitted client JS (top-level function declarations). */
+export declare function renderModule(): string;