typebulb 0.58.0 → 0.58.1

package/README.md

@@ -192,13 +192,13 @@ everywhere.
 |-----|--------------|:-----------:|
 | `tb.data(n)` / `tb.json(n)` | Read data chunk `n` from the `data.txt` block — raw string, or parsed JSON | |
 | `tb.insight()` | Read the `insight.json` block as JSON | |
-| `tb.setData(chunks)` / `tb.setInsight(v)` | Replace this run's data / insight and get back a link carrying it; the file is untouched | |
+| `tb.setData(chunks)` / `tb.setInsight(v)` | Replace this run's data / insight; the URL fragment follows, the file is untouched | |
 | `tb.theme` | Get/set the light/dark override; `undefined` follows the OS | |
 | `tb.mode` | Runtime mode — `'local'` (CLI) or `'inline'` (sandboxed iframe); `'ide'`/`'published'` on typebulb.com | |
 | `tb.proxy(url)` | Rewrite a CDN URL to load through the host origin (Web Worker / WASM) | |
 | `tb.dump(...)` | Log values (incl. lazy / device-backed tensors) to the browser console | |
 | `tb.copy(text)` | Copy text to the clipboard | |
-| `tb.url()` | Get the bulb URL (the served localhost URL, locally) | |
+| `tb.url()` | Get the bulb's canonical URL, `#tb=` fragment included (the served localhost URL, locally) | |
 | `tb.models()` | List available AI models (for dynamic model selectors); the `.env` default is flagged (`default: true`); returns `[]` when inline (no host AI) | |
 | `tb.aiAccess()` | What backs `tb.ai` — `'own' \| 'courtesy' \| 'none'` | |
 | `tb.log(...)` | Print to the CLI's stdout (read back with `typebulb logs`); falls back to the browser console when no CLI serves the page | |
@@ -511,17 +511,18 @@ the whole file; `put` replaces it blind, knowing neither its size, its format, n
 ## Runtime data (`tb.setData`)
 
 A bulb that computes its own results (a scrape, a batch score, a simulation, a tournament) can swap
-them in as the data it's running on, and get back a link that carries them:
+them in as the data it's running on, and the page URL then carries them:
 
 ```ts
-const url = await tb.setData(JSON.stringify(results))
-if (url) tb.copy(url)
+await tb.setData(JSON.stringify(results))
+tb.copy(await tb.url())
 ```
 
 - `tb.data()` / `tb.json()` return the new chunks for the rest of the page, and the URL's `#tb=` fragment holds them, so reloading or opening that link restores the run. `tb.setInsight(value)` is the same for `tb.insight()`.
+- **The write is the URL update.** Awaiting a setter means the address bar holds the run. Nothing comes back: `tb.url()` is how you read the link. On typebulb.com the fragment lands in fullscreen, exactly as `tb.infer()` does; an inline bulb has no URL of its own, so there the swap happens and nothing else does.
 - **Runtime only, never the file.** A reload without the fragment is back on the bulb's own `data.txt`. Two gestures promote a run to source, and no `tb.*` call does: `typebulb put` from the terminal, or `tb.infer()` to raise the modal and press **Save to bulb**, which files whatever the page holds — an LLM call is not needed and the size ceiling does not apply (needs `--trust`).
-- **The link has a size ceiling; the file doesn't.** Around 60KB encoded, so pass what a share needs rather than everything. `undefined` back means it didn't fit (also what an inline bulb gets — no address bar).
-- **Set only what you changed.** An unset slot stays out of the link and falls through to the bulb's own block, so a data-only run doesn't drag a copy of `insight.json` along. Both in one tick is one encode and one link: `tb.setData(d); const url = await tb.setInsight(i)`.
+- **The link has a size ceiling; the file doesn't.** Around 60KB encoded, so pass what a share needs rather than everything. Over it the run still swaps, but the fragment clears and there is no link.
+- **Set only what you changed.** An unset slot stays out of the link and falls through to the bulb's own block, so a data-only run doesn't drag a copy of `insight.json` along. Both in one tick is one encode: `tb.setData(d); await tb.setInsight(i)`.
 
 ## Charts
 

package/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: typebulb
 description: "Author and run Typebulb bulbs — single-file markdown apps (TypeScript/TSX) that run locally via `npx typebulb` (full power: filesystem, database, `server.ts`, `tb.ai`) or render live inline in your coding agent's session through Typebulb's agent mirror (sandboxed, client-only). A bulb can be a visual widget (chart, simulation, diagram, calculator, UI), a full-stack tool with a Node backend, or an AI app that calls models at runtime. Covers the bulb format, the `tb.*` API, trust, and the local run/inline workflow. Use when the user wants a bulb, a quick local tool (visual, backend-backed, or AI-powered), or something visual rendered inline in the conversation."
-version: 0.58.0
+version: 0.58.1
 ---
 
-> Generated from typebulb v0.58.0. `npx typebulb agent` prints the running version alongside the path to its packaged SKILL.md: if that version is newer than this one, replace this file with that one.
+> Generated from typebulb v0.58.1. `npx typebulb agent` prints the running version alongside the path to its packaged SKILL.md: if that version is newer than this one, replace this file with that one.
 
 # typebulb
 
@@ -200,13 +200,13 @@ everywhere.
 |-----|--------------|:-----------:|
 | `tb.data(n)` / `tb.json(n)` | Read data chunk `n` from the `data.txt` block — raw string, or parsed JSON | |
 | `tb.insight()` | Read the `insight.json` block as JSON | |
-| `tb.setData(chunks)` / `tb.setInsight(v)` | Replace this run's data / insight and get back a link carrying it; the file is untouched | |
+| `tb.setData(chunks)` / `tb.setInsight(v)` | Replace this run's data / insight; the URL fragment follows, the file is untouched | |
 | `tb.theme` | Get/set the light/dark override; `undefined` follows the OS | |
 | `tb.mode` | Runtime mode — `'local'` (CLI) or `'inline'` (sandboxed iframe); `'ide'`/`'published'` on typebulb.com | |
 | `tb.proxy(url)` | Rewrite a CDN URL to load through the host origin (Web Worker / WASM) | |
 | `tb.dump(...)` | Log values (incl. lazy / device-backed tensors) to the browser console | |
 | `tb.copy(text)` | Copy text to the clipboard | |
-| `tb.url()` | Get the bulb URL (the served localhost URL, locally) | |
+| `tb.url()` | Get the bulb's canonical URL, `#tb=` fragment included (the served localhost URL, locally) | |
 | `tb.models()` | List available AI models (for dynamic model selectors); the `.env` default is flagged (`default: true`); returns `[]` when inline (no host AI) | |
 | `tb.aiAccess()` | What backs `tb.ai` — `'own' \| 'courtesy' \| 'none'` | |
 | `tb.log(...)` | Print to the CLI's stdout (read back with `typebulb logs`); falls back to the browser console when no CLI serves the page | |
@@ -519,17 +519,18 @@ the whole file; `put` replaces it blind, knowing neither its size, its format, n
 ## Runtime data (`tb.setData`)
 
 A bulb that computes its own results (a scrape, a batch score, a simulation, a tournament) can swap
-them in as the data it's running on, and get back a link that carries them:
+them in as the data it's running on, and the page URL then carries them:
 
 ```ts
-const url = await tb.setData(JSON.stringify(results))
-if (url) tb.copy(url)
+await tb.setData(JSON.stringify(results))
+tb.copy(await tb.url())
 ```
 
 - `tb.data()` / `tb.json()` return the new chunks for the rest of the page, and the URL's `#tb=` fragment holds them, so reloading or opening that link restores the run. `tb.setInsight(value)` is the same for `tb.insight()`.
+- **The write is the URL update.** Awaiting a setter means the address bar holds the run. Nothing comes back: `tb.url()` is how you read the link. On typebulb.com the fragment lands in fullscreen, exactly as `tb.infer()` does; an inline bulb has no URL of its own, so there the swap happens and nothing else does.
 - **Runtime only, never the file.** A reload without the fragment is back on the bulb's own `data.txt`. Two gestures promote a run to source, and no `tb.*` call does: `typebulb put` from the terminal, or `tb.infer()` to raise the modal and press **Save to bulb**, which files whatever the page holds — an LLM call is not needed and the size ceiling does not apply (needs `--trust`).
-- **The link has a size ceiling; the file doesn't.** Around 60KB encoded, so pass what a share needs rather than everything. `undefined` back means it didn't fit (also what an inline bulb gets — no address bar).
-- **Set only what you changed.** An unset slot stays out of the link and falls through to the bulb's own block, so a data-only run doesn't drag a copy of `insight.json` along. Both in one tick is one encode and one link: `tb.setData(d); const url = await tb.setInsight(i)`.
+- **The link has a size ceiling; the file doesn't.** Around 60KB encoded, so pass what a share needs rather than everything. Over it the run still swaps, but the fragment clears and there is no link.
+- **Set only what you changed.** An unset slot stays out of the link and falls through to the bulb's own block, so a data-only run doesn't drag a copy of `insight.json` along. Both in one tick is one encode: `tb.setData(d); await tb.setInsight(i)`.
 
 ## Charts
 

package/dist/agents/claude/client.js

@@ -1109,8 +1109,8 @@ ${V9t}
   // tb.setData / tb.setInsight (TB-State.md), on the engine both hosts share. The globals and the
   // transport are all this host owns: encoding round-trips to the server because the page carries
   // no fflate on purpose, and the fragment write is the address bar the setters exist to fill.
-  // Resolves the shareable URL, or undefined when there is no address bar to put it in (inline) or
-  // the state is too large to encode \u2014 the one failure an author must handle.
+  // Resolves once that write has landed, and hands back nothing: the link is then tb.url() like
+  // any other. An inline bulb has no address bar, so its swap is page-local and never encodes.
   window.__tbState.init({
     applyData: (chunks) => { window.__TB_DATA__ = chunks; },
     applyInsight: (json) => { window.__TB_INSIGHT__ = json; },
@@ -1128,7 +1128,6 @@ ${V9t}
           // earlier fragment, or the address bar keeps addressing a run the page is no longer
           // showing \u2014 and a reload would silently revert to it.
           history.replaceState(null, '', location.pathname + location.search + hash);
-          return hash ? location.href : undefined;
         });
     }
   });

package/dist/agents/codex/client.js

@@ -1109,8 +1109,8 @@ ${q9t}
   // tb.setData / tb.setInsight (TB-State.md), on the engine both hosts share. The globals and the
   // transport are all this host owns: encoding round-trips to the server because the page carries
   // no fflate on purpose, and the fragment write is the address bar the setters exist to fill.
-  // Resolves the shareable URL, or undefined when there is no address bar to put it in (inline) or
-  // the state is too large to encode \u2014 the one failure an author must handle.
+  // Resolves once that write has landed, and hands back nothing: the link is then tb.url() like
+  // any other. An inline bulb has no address bar, so its swap is page-local and never encodes.
   window.__tbState.init({
     applyData: (chunks) => { window.__TB_DATA__ = chunks; },
     applyInsight: (json) => { window.__TB_INSIGHT__ = json; },
@@ -1128,7 +1128,6 @@ ${q9t}
           // earlier fragment, or the address bar keeps addressing a run the page is no longer
           // showing \u2014 and a reload would silently revert to it.
           history.replaceState(null, '', location.pathname + location.search + hash);
-          return hash ? location.href : undefined;
         });
     }
   });

package/dist/agents/pi/client.js

@@ -1109,8 +1109,8 @@ ${W9t}
   // tb.setData / tb.setInsight (TB-State.md), on the engine both hosts share. The globals and the
   // transport are all this host owns: encoding round-trips to the server because the page carries
   // no fflate on purpose, and the fragment write is the address bar the setters exist to fill.
-  // Resolves the shareable URL, or undefined when there is no address bar to put it in (inline) or
-  // the state is too large to encode \u2014 the one failure an author must handle.
+  // Resolves once that write has landed, and hands back nothing: the link is then tb.url() like
+  // any other. An inline bulb has no address bar, so its swap is page-local and never encodes.
   window.__tbState.init({
     applyData: (chunks) => { window.__TB_DATA__ = chunks; },
     applyInsight: (json) => { window.__TB_INSIGHT__ = json; },
@@ -1128,7 +1128,6 @@ ${W9t}
           // earlier fragment, or the address bar keeps addressing a run the page is no longer
           // showing \u2014 and a reload would silently revert to it.
           history.replaceState(null, '', location.pathname + location.search + hash);
-          return hash ? location.href : undefined;
         });
     }
   });

package/dist/dts/tbTypings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tbTypings.d.ts","sourceRoot":"","sources":["../../dts/src/tbTypings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA6SH,kEAAkE;AAClE,eAAO,MAAM,eAAe,QAO3B,CAAA;AASD;;;wDAGwD;AACxD,eAAO,MAAM,eAAe,QAO3B,CAAA"}
+{"version":3,"file":"tbTypings.d.ts","sourceRoot":"","sources":["../../dts/src/tbTypings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAgTH,kEAAkE;AAClE,eAAO,MAAM,eAAe,QAO3B,CAAA;AASD;;;wDAGwD;AACxD,eAAO,MAAM,eAAe,QAO3B,CAAA"}

package/dist/dts/tbTypings.js

@@ -9,312 +9,315 @@
  * TypeChecker, and the CLI's emitted typecheck dirs.
  */
 import { modeUnion } from 'typebulb/format';
-const dataAndJson = `
-  /**
-   * Get raw data chunk from the Data tab.
-   * @param index - Chunk index (0-based). Separate chunks with 2 blank lines.
-   */
-  data(index: number): string;
-  /**
-   * Get data chunk parsed as JSON (handles JSON-ish with unquoted keys).
-   * @param index - Chunk index (0-based)
-   * @throws If chunk is not valid JSON/JSON-ish
-   */
+const dataAndJson = `
+  /**
+   * Get raw data chunk from the Data tab.
+   * @param index - Chunk index (0-based). Separate chunks with 2 blank lines.
+   */
+  data(index: number): string;
+  /**
+   * Get data chunk parsed as JSON (handles JSON-ish with unquoted keys).
+   * @param index - Chunk index (0-based)
+   * @throws If chunk is not valid JSON/JSON-ish
+   */
   json<T = unknown>(index: number): T;`;
-const insight = `
-  /**
-   * Get the insight data produced by the inference layer.
-   *
-   * Returns the parsed JSON from insight.json, populated by the inference LLM.
-   * Use a type parameter to get typed access to the insight data.
-   *
-   * @returns The parsed insight JSON, or undefined if no insight is available
-   */
+const insight = `
+  /**
+   * Get the insight data produced by the inference layer.
+   *
+   * Returns the parsed JSON from insight.json, populated by the inference LLM.
+   * Use a type parameter to get typed access to the insight data.
+   *
+   * @returns The parsed insight JSON, or undefined if no insight is available
+   */
   insight<T = unknown>(): T | undefined;`;
 // Runtime-state writers — duals of tb.data()/tb.json() and tb.insight() (TB-State.md).
-const runtimeStateWriters = `
-  /**
-   * Replace the data this run is working on, and get back a link that carries it.
-   *
-   * Updates what \`tb.data()\` / \`tb.json()\` return for the rest of this page, and writes the
-   * result into the URL fragment so the address bar addresses this run. The bulb's source
-   * \`data.txt\` is never touched: a reload without the fragment goes back to the file.
-   *
-   * @param chunks - The new data chunks (a bare string is treated as one chunk)
-   * @returns The shareable URL, or undefined when there is no address bar (inline bulbs) or the
-   *   data is too large to fit a URL. Pass only what a share needs, not necessarily everything.
-   */
-  setData(chunks: string | string[]): Promise<string | undefined>;
-  /**
-   * Replace the insight this run is working on, and get back a link that carries it.
-   *
-   * The \`tb.insight()\` counterpart of \`setData\`, with the same fragment behavior and the same
-   * rule: runtime only, never the bulb's source \`insight.json\`.
-   *
-   * @param value - Any JSON-serializable value
-   * @returns The shareable URL, or undefined (see \`setData\`)
-   */
-  setInsight(value: unknown): Promise<string | undefined>;`;
+const runtimeStateWriters = `
+  /**
+   * Replace the data this run is working on.
+   *
+   * Updates what \`tb.data()\` / \`tb.json()\` return for the rest of this page, and writes the
+   * result into the URL fragment, so the address bar addresses this run and \`tb.url()\` carries
+   * it. The bulb's source \`data.txt\` is never touched: a reload without the fragment goes back
+   * to the file.
+   *
+   * @param chunks - The new data chunks (a bare string is treated as one chunk)
+   * @returns Resolves once the address bar reflects the write. Data too large to fit a URL
+   *   (~60KB encoded) still swaps, but carries no fragment: pass what a share needs, not
+   *   necessarily everything.
+   */
+  setData(chunks: string | string[]): Promise<void>;
+  /**
+   * Replace the insight this run is working on.
+   *
+   * The \`tb.insight()\` counterpart of \`setData\`, with the same fragment behavior and the same
+   * rule: runtime only, never the bulb's source \`insight.json\`.
+   *
+   * @param value - Any JSON-serializable value
+   */
+  setInsight(value: unknown): Promise<void>;`;
 // One options shape, reused by tb.ai() and tb.ai.stream().
-const aiOptions = `options: {
-    messages: Array<{ role: "user" | "assistant"; content: string }>;
-    system?: string;
-    /** Reasoning effort: 0=minimal, 1=low, 2=med, 3=high, 4=xhigh. Mapped to each provider's native mechanism (OpenAI/OpenRouter reasoning effort, Gemini thinking level, Anthropic adaptive thinking). 0 reaches the vendor's explicit off switch, and floors to a little thinking only on always-thinking models. 4 reaches the rung above high where the vendor has one (OpenAI/OpenRouter xhigh, Anthropic max) and clamps to high where it doesn't (Gemini) — never an error. Pin 1 (low) for most work; pick 0 deliberately, when you want the raw model or latency is the constraint. Omitting is NOT off — it buys the model's own default (medium on GPT-5.6), which reasons and bills invisibly. Ignored on the courtesy model, which runs at the level Typebulb sets. */
-    effort?: 0 | 1 | 2 | 3 | 4;
-    provider?: string;
-    model?: string;
-    /** Give the model a web-search tool, billed to the user's key. Off by default; the free model never searches. */
-    webSearch?: boolean;
-    /** Abort the request. On abort the promise rejects / the stream ends. */
-    signal?: AbortSignal;
+const aiOptions = `options: {
+    messages: Array<{ role: "user" | "assistant"; content: string }>;
+    system?: string;
+    /** Reasoning effort: 0=minimal, 1=low, 2=med, 3=high, 4=xhigh. Mapped to each provider's native mechanism (OpenAI/OpenRouter reasoning effort, Gemini thinking level, Anthropic adaptive thinking). 0 reaches the vendor's explicit off switch, and floors to a little thinking only on always-thinking models. 4 reaches the rung above high where the vendor has one (OpenAI/OpenRouter xhigh, Anthropic max) and clamps to high where it doesn't (Gemini) — never an error. Pin 1 (low) for most work; pick 0 deliberately, when you want the raw model or latency is the constraint. Omitting is NOT off — it buys the model's own default (medium on GPT-5.6), which reasons and bills invisibly. Ignored on the courtesy model, which runs at the level Typebulb sets. */
+    effort?: 0 | 1 | 2 | 3 | 4;
+    provider?: string;
+    model?: string;
+    /** Give the model a web-search tool, billed to the user's key. Off by default; the free model never searches. */
+    webSearch?: boolean;
+    /** Abort the request. On abort the promise rejects / the stream ends. */
+    signal?: AbortSignal;
   }`;
 /** A streamed delta from \`tb.ai.stream()\` — a discriminated union, exactly one kind per chunk. */
-const aiChunkType = `
-/** Provider-reported token counts for one call — real usage from the API, never an estimate.
- *  \`output\` is total billed output (reasoning included); \`reasoning\` is the itemized subset where
- *  the provider splits it (OpenAI, Gemini, OpenRouter — Anthropic doesn't); \`cacheRead\` is the
- *  cached subset of \`input\`. */
-type AiUsage = { input: number; output: number; reasoning?: number; cacheRead?: number };
-
-/** A single streamed delta from \`tb.ai.stream()\`. Discriminated by \`kind\`. */
-type AiChunk =
-  | { kind: "text"; text: string }
-  | { kind: "reasoning"; text: string }
-  | { kind: "usage"; usage: AiUsage };
+const aiChunkType = `
+/** Provider-reported token counts for one call — real usage from the API, never an estimate.
+ *  \`output\` is total billed output (reasoning included); \`reasoning\` is the itemized subset where
+ *  the provider splits it (OpenAI, Gemini, OpenRouter — Anthropic doesn't); \`cacheRead\` is the
+ *  cached subset of \`input\`. */
+type AiUsage = { input: number; output: number; reasoning?: number; cacheRead?: number };
+
+/** A single streamed delta from \`tb.ai.stream()\`. Discriminated by \`kind\`. */
+type AiChunk =
+  | { kind: "text"; text: string }
+  | { kind: "reasoning"; text: string }
+  | { kind: "usage"; usage: AiUsage };
 `;
 /** What \`tb.aiAccess()\` answers. Named so bulbs can hold it in state without respelling the union. */
-const aiAccessType = `
-/** What backs \`tb.ai\`: the user's own keys, the quota-limited courtesy model, or nothing. */
-type AiAccess = "own" | "courtesy" | "none";
+const aiAccessType = `
+/** What backs \`tb.ai\`: the user's own keys, the quota-limited courtesy model, or nothing. */
+type AiAccess = "own" | "courtesy" | "none";
 `;
-const ai = `
-  /**
-   * General-purpose AI call. \`tb.ai(opts)\` resolves with the full text; \`tb.ai.stream(opts)\`
-   * returns an async iterable of {@link AiChunk} deltas you consume with \`for await\`.
-   *
-   * @returns Promise resolving to { text, usage? } — \`usage\` is the provider-reported token
-   *   counts ({@link AiUsage}), absent when the provider reported none
-   * @throws On rate limit, network error, or provider error
-   */
-  ai: {
-    (${aiOptions}): Promise<{ text: string; usage?: AiUsage }>;
-    /**
-     * Streaming counterpart of \`tb.ai()\`. Yields \`{ kind: "text" | "reasoning", text }\` deltas
-     * as they arrive, then one final \`{ kind: "usage", usage }\` chunk with the call's token
-     * counts (when the provider reported them); break the loop (or abort \`signal\`) to cancel
-     * and stop the upstream. Match \`kind\` positively — a bare \`else\` branch that assumes
-     * "not reasoning means text" will misread the usage chunk.
-     *
-     * \`kind: "reasoning"\` deltas only arrive when you pass \`effort: 1-4\` AND use a
-     * thinking-capable model; otherwise the stream is \`text\`-only.
-     *
-     * @example
-     * let answer = "";
-     * for await (const c of tb.ai.stream({ messages })) {
-     *   if (c.kind === "text") answer += c.text;
-     * }
-     */
-    stream(${aiOptions}): AsyncIterable<AiChunk>;
+const ai = `
+  /**
+   * General-purpose AI call. \`tb.ai(opts)\` resolves with the full text; \`tb.ai.stream(opts)\`
+   * returns an async iterable of {@link AiChunk} deltas you consume with \`for await\`.
+   *
+   * @returns Promise resolving to { text, usage? } — \`usage\` is the provider-reported token
+   *   counts ({@link AiUsage}), absent when the provider reported none
+   * @throws On rate limit, network error, or provider error
+   */
+  ai: {
+    (${aiOptions}): Promise<{ text: string; usage?: AiUsage }>;
+    /**
+     * Streaming counterpart of \`tb.ai()\`. Yields \`{ kind: "text" | "reasoning", text }\` deltas
+     * as they arrive, then one final \`{ kind: "usage", usage }\` chunk with the call's token
+     * counts (when the provider reported them); break the loop (or abort \`signal\`) to cancel
+     * and stop the upstream. Match \`kind\` positively — a bare \`else\` branch that assumes
+     * "not reasoning means text" will misread the usage chunk.
+     *
+     * \`kind: "reasoning"\` deltas only arrive when you pass \`effort: 1-4\` AND use a
+     * thinking-capable model; otherwise the stream is \`text\`-only.
+     *
+     * @example
+     * let answer = "";
+     * for await (const c of tb.ai.stream({ messages })) {
+     *   if (c.kind === "text") answer += c.text;
+     * }
+     */
+    stream(${aiOptions}): AsyncIterable<AiChunk>;
   };`;
-const models = `
-  /**
-   * Returns AI models available to the current user.
-   * Models are filtered by the user's configured API keys.
-   * If no keys are configured, returns only the courtesy model.
-   */
-  models(): Promise<Array<{
-    /** Provider protocol: "anthropic", "openai", "gemini", "openrouter" */
-    provider: string;
-    /** Model identifier, e.g. "claude-sonnet-4-6" */
-    name: string;
-    /** Human-readable display name, e.g. "Sonnet 4.6" */
-    friendlyName: string;
-    /** Provider display name, e.g. "Anthropic" */
-    providerName: string;
-    /** True on the .env-configured default model (TB_AI_PROVIDER + TB_AI_MODEL); absent otherwise */
-    default?: boolean;
-  }>>;
-  /**
-   * What backs \`tb.ai\` right now:
-   *
-   * - \`'own'\` — the user's own API keys (or their own local model server)
-   * - \`'courtesy'\` — the quota-limited courtesy model, fine for a call or two
-   * - \`'none'\` — no AI at all (the CLI with no keys, an inline bulb)
-   *
-   * A bulb making many AI calls should show a "use your own keys" notice
-   * instead of running unless this is \`'own'\`. Never derive it from
-   * \`tb.mode\` or the length of \`tb.models()\` — which hosts offer a courtesy
-   * model is the host's business and changes without your bulb changing.
-   */
+const models = `
+  /**
+   * Returns AI models available to the current user.
+   * Models are filtered by the user's configured API keys.
+   * If no keys are configured, returns only the courtesy model.
+   */
+  models(): Promise<Array<{
+    /** Provider protocol: "anthropic", "openai", "gemini", "openrouter" */
+    provider: string;
+    /** Model identifier, e.g. "claude-sonnet-4-6" */
+    name: string;
+    /** Human-readable display name, e.g. "Sonnet 4.6" */
+    friendlyName: string;
+    /** Provider display name, e.g. "Anthropic" */
+    providerName: string;
+    /** True on the .env-configured default model (TB_AI_PROVIDER + TB_AI_MODEL); absent otherwise */
+    default?: boolean;
+  }>>;
+  /**
+   * What backs \`tb.ai\` right now:
+   *
+   * - \`'own'\` — the user's own API keys (or their own local model server)
+   * - \`'courtesy'\` — the quota-limited courtesy model, fine for a call or two
+   * - \`'none'\` — no AI at all (the CLI with no keys, an inline bulb)
+   *
+   * A bulb making many AI calls should show a "use your own keys" notice
+   * instead of running unless this is \`'own'\`. Never derive it from
+   * \`tb.mode\` or the length of \`tb.models()\` — which hosts offer a courtesy
+   * model is the host's business and changes without your bulb changing.
+   */
   aiAccess(): Promise<AiAccess>;`;
-const theme = `
-  /**
-   * The bulb's theme override (\`<html data-theme>\`).
-   *
-   * - Get: the current override — \`'dark'\` | \`'light'\`, or \`undefined\` when
-   *   following the OS preference.
-   * - Set \`'dark'\`/\`'light'\` to force and persist it (per-bulb); set
-   *   \`undefined\` to clear the override and follow the OS again.
-   *
-   * Drives \`<html data-theme>\`, so render off \`html[data-theme="…"]\` selectors
-   * (or observe the attribute) rather than reading \`tb.theme\`.
-   */
+const theme = `
+  /**
+   * The bulb's theme override (\`<html data-theme>\`).
+   *
+   * - Get: the current override — \`'dark'\` | \`'light'\`, or \`undefined\` when
+   *   following the OS preference.
+   * - Set \`'dark'\`/\`'light'\` to force and persist it (per-bulb); set
+   *   \`undefined\` to clear the override and follow the OS again.
+   *
+   * Drives \`<html data-theme>\`, so render off \`html[data-theme="…"]\` selectors
+   * (or observe the attribute) rather than reading \`tb.theme\`.
+   */
   theme: 'light' | 'dark' | undefined;`;
-const mode = `
-  /**
-   * The mode this bulb is running in.
-   *
-   * - \`'local'\` — Running via the typebulb CLI
-   * - \`'ide'\` — Running in the typebulb.com editor
-   * - \`'published'\` — Running as a published/standalone bulb on typebulb.com
-   * - \`'inline'\` — Running inline in an agent's transcript, rendered by the mirror
-   *   (sandboxed, client-only: AI, filesystem, and server RPC are unavailable)
-   */
+const mode = `
+  /**
+   * The mode this bulb is running in.
+   *
+   * - \`'local'\` — Running via the typebulb CLI
+   * - \`'ide'\` — Running in the typebulb.com editor
+   * - \`'published'\` — Running as a published/standalone bulb on typebulb.com
+   * - \`'inline'\` — Running inline in an agent's transcript, rendered by the mirror
+   *   (sandboxed, client-only: AI, filesystem, and server RPC are unavailable)
+   */
   mode: ${modeUnion};`;
-const fs = `
-  /**
-   * Local filesystem access (CLI only).
-   *
-   * Relative paths resolve against the bulb's folder (\`tb.dir\` —
-   * \`<bulb-dir>/<filename-stem>/\`, created on demand), so
-   * \`tb.fs.write('results.json')\` lands beside the bulb. \`../\` reaches sibling
-   * bulbs' folders; everything stays confined to the project (the launch cwd).
-   * Throws in ide/published mode.
-   */
-  fs: {
-    /** Read a file as UTF-8 text. Throws if the file is not valid UTF-8 — use readBytes for binary. */
-    read(path: string): Promise<string>;
-    /** Read a file as raw bytes. */
-    readBytes(path: string): Promise<Uint8Array>;
-    /** Write text or raw bytes to a file. Creates parent directories if needed. */
-    write(path: string, content: string | Uint8Array): Promise<boolean>;
+const fs = `
+  /**
+   * Local filesystem access (CLI only).
+   *
+   * Relative paths resolve against the bulb's folder (\`tb.dir\` —
+   * \`<bulb-dir>/<filename-stem>/\`, created on demand), so
+   * \`tb.fs.write('results.json')\` lands beside the bulb. \`../\` reaches sibling
+   * bulbs' folders; everything stays confined to the project (the launch cwd).
+   * Throws in ide/published mode.
+   */
+  fs: {
+    /** Read a file as UTF-8 text. Throws if the file is not valid UTF-8 — use readBytes for binary. */
+    read(path: string): Promise<string>;
+    /** Read a file as raw bytes. */
+    readBytes(path: string): Promise<Uint8Array>;
+    /** Write text or raw bytes to a file. Creates parent directories if needed. */
+    write(path: string, content: string | Uint8Array): Promise<boolean>;
   };`;
-const dir = `
-  /**
-   * The bulb's folder — absolute path to \`<bulb-dir>/<filename-stem>/\`
-   * (or its \`batches/<name>/\` folder when the run is scoped with \`--batch\`).
-   *
-   * For interop only (handing a path to \`server.ts\` or a spawned tool):
-   * \`tb.fs\` already resolves relative paths against it, so bulb code writing
-   * its own files never needs it. CLI only — throws in ide/published/inline mode.
-   */
+const dir = `
+  /**
+   * The bulb's folder — absolute path to \`<bulb-dir>/<filename-stem>/\`
+   * (or its \`batches/<name>/\` folder when the run is scoped with \`--batch\`).
+   *
+   * For interop only (handing a path to \`server.ts\` or a spawned tool):
+   * \`tb.fs\` already resolves relative paths against it, so bulb code writing
+   * its own files never needs it. CLI only — throws in ide/published/inline mode.
+   */
   readonly dir: string;`;
-const clientOnlyMembers = `
-  /**
-   * Async value inspector for tensor-like objects.
-   *
-   * Materializes lazy values (like GPU tensors) and logs them with metadata.
-   * Handles objects with \`.js()\`, \`.data()\`, \`.array()\`, \`.arraySync()\`, etc.
-   *
-   * @remarks
-   * - Always use \`await\` - materialization may be async (GPU→CPU readback)
-   * - Large values are truncated (max 1000 elements)
-   * - Promises are logged as \`[Promise]\` (not awaited - could hang)
-   */
-  dump(...args: any[]): Promise<void>;
-  /**
-   * Trigger inference to generate new insight data.
-   *
-   * Opens a confirmation modal showing the data to be analyzed, then streams
-   * the inference result. On success, updates the insight so subsequent
-   * \`tb.insight()\` calls return the new value.
-   *
-   * @param opts - Options for inference
-   * @param opts.data - Data to pre-populate in the modal (string or array of strings). If omitted, modal opens with empty textarea for user to paste.
-   * @returns Promise that resolves with the parsed insight JSON
-   * @throws If inference is already in progress, or on network/parse/rate limit errors
-   */
-  infer<T = unknown>(opts?: { data?: string | string[] }): Promise<T>;
-  /**
-   * Proxy a CDN URL through the sandbox origin for Web Worker/WASM same-origin loading.
-   *
-   * In the sandbox, prepends \`/proxy/\` so the URL is served from the same origin.
-   * Outside the sandbox (exported HTML, CLI), returns the URL unchanged.
-   *
-   * @param url - Full HTTPS URL to an allowlisted CDN (esm.sh, unpkg.com, cdn.jsdelivr.net, cdnjs.cloudflare.com)
-   * @returns The proxied URL (sandbox) or the original URL (standalone/CLI)
-   */
-  proxy(url: string): string;
-  /**
-   * Copy text to clipboard.
-   * Must be called synchronously within a user gesture (click/keydown).
-   * @returns true if successful, false otherwise
-   */
-  copy(text: string): Promise<boolean>;
-  /**
-   * Get the canonical URL of this bulb.
-   *
-   * Returns the parent typebulb.com URL (including path, query, and \`#tb=\` fragment),
-   * resolving correctly from inside the cross-origin sandbox iframe.
-   * Use this instead of \`location.href\` or \`document.referrer\`.
-   *
-   * @returns The full canonical URL
-   */
+const clientOnlyMembers = `
+  /**
+   * Async value inspector for tensor-like objects.
+   *
+   * Materializes lazy values (like GPU tensors) and logs them with metadata.
+   * Handles objects with \`.js()\`, \`.data()\`, \`.array()\`, \`.arraySync()\`, etc.
+   *
+   * @remarks
+   * - Always use \`await\` - materialization may be async (GPU→CPU readback)
+   * - Large values are truncated (max 1000 elements)
+   * - Promises are logged as \`[Promise]\` (not awaited - could hang)
+   */
+  dump(...args: any[]): Promise<void>;
+  /**
+   * Trigger inference to generate new insight data.
+   *
+   * Opens a confirmation modal showing the data to be analyzed, then streams
+   * the inference result. On success, updates the insight so subsequent
+   * \`tb.insight()\` calls return the new value.
+   *
+   * @param opts - Options for inference
+   * @param opts.data - Data to pre-populate in the modal (string or array of strings). If omitted, modal opens with empty textarea for user to paste.
+   * @returns Promise that resolves with the parsed insight JSON
+   * @throws If inference is already in progress, or on network/parse/rate limit errors
+   */
+  infer<T = unknown>(opts?: { data?: string | string[] }): Promise<T>;
+  /**
+   * Proxy a CDN URL through the sandbox origin for Web Worker/WASM same-origin loading.
+   *
+   * In the sandbox, prepends \`/proxy/\` so the URL is served from the same origin.
+   * Outside the sandbox (exported HTML, CLI), returns the URL unchanged.
+   *
+   * @param url - Full HTTPS URL to an allowlisted CDN (esm.sh, unpkg.com, cdn.jsdelivr.net, cdnjs.cloudflare.com)
+   * @returns The proxied URL (sandbox) or the original URL (standalone/CLI)
+   */
+  proxy(url: string): string;
+  /**
+   * Copy text to clipboard.
+   * Must be called synchronously within a user gesture (click/keydown).
+   * @returns true if successful, false otherwise
+   */
+  copy(text: string): Promise<boolean>;
+  /**
+   * Get the canonical URL of this bulb.
+   *
+   * Returns the parent typebulb.com URL (including query and \`#tb=\` fragment), resolving
+   * correctly from inside the cross-origin sandbox iframe. That is the published \`/full\` page
+   * even while authoring in the IDE, because it is the link someone you send it to can open.
+   * Locally it is the served localhost URL. Use this instead of \`location.href\` or
+   * \`document.referrer\`.
+   *
+   * @returns The full canonical URL
+   */
   url(): Promise<string>;`;
-const onMessage = `
-  /**
-   * Subscribe to a value pushed from the terminal via \`typebulb send <file> [message]\`.
-   *
-   * The dual of \`tb.log\` (data out): a value sent *in* from the CLI, no \`--trust\` required.
-   * Use it to start expensive work on demand instead of on load — e.g. \`tb.onMessage(() => start())\`
-   * — so hot reloads don't re-trigger it while you edit, and an agent kicks off one run when ready.
-   *
-   * The message is the JSON-parsed value of what \`send\` was given (or the raw string if it isn't
-   * JSON; \`undefined\` for a bare \`typebulb send <file>\`). A non-\`undefined\` return value (awaited)
-   * becomes the reply \`send --wait\` prints on stdout — JSON-serializable, at most one handler
-   * replying — the structured read-back for self-tests. Returns an unsubscribe function. Inert in
-   * an inline bulb (no sender) — the handler is registered but never fires.
-   *
-   * @param handler - Called with each pushed message; may return a JSON-serializable reply.
-   * @returns An unsubscribe function.
-   */
+const onMessage = `
+  /**
+   * Subscribe to a value pushed from the terminal via \`typebulb send <file> [message]\`.
+   *
+   * The dual of \`tb.log\` (data out): a value sent *in* from the CLI, no \`--trust\` required.
+   * Use it to start expensive work on demand instead of on load — e.g. \`tb.onMessage(() => start())\`
+   * — so hot reloads don't re-trigger it while you edit, and an agent kicks off one run when ready.
+   *
+   * The message is the JSON-parsed value of what \`send\` was given (or the raw string if it isn't
+   * JSON; \`undefined\` for a bare \`typebulb send <file>\`). A non-\`undefined\` return value (awaited)
+   * becomes the reply \`send --wait\` prints on stdout — JSON-serializable, at most one handler
+   * replying — the structured read-back for self-tests. Returns an unsubscribe function. Inert in
+   * an inline bulb (no sender) — the handler is registered but never fires.
+   *
+   * @param handler - Called with each pushed message; may return a JSON-serializable reply.
+   * @returns An unsubscribe function.
+   */
   onMessage(handler: (message: any) => unknown): () => void;`;
-const log = `
-  /**
-   * Print to the CLI's stdout — the bulb's log channel, read back with \`typebulb logs <file>\`.
-   *
-   * Ungated: needs no \`server.ts\` block and no \`--trust\`, so a Restricted client-only bulb can
-   * instrument itself. Args cross to the CLI as JSON; where no CLI serves the page (web, inline,
-   * or a transport failure) it falls back to the browser console. Works in \`server.ts\` too (same
-   * as \`console.log\` there).
-   */
+const log = `
+  /**
+   * Print to the CLI's stdout — the bulb's log channel, read back with \`typebulb logs <file>\`.
+   *
+   * Ungated: needs no \`server.ts\` block and no \`--trust\`, so a Restricted client-only bulb can
+   * instrument itself. Args cross to the CLI as JSON; where no CLI serves the page (web, inline,
+   * or a transport failure) it falls back to the browser console. Works in \`server.ts\` too (same
+   * as \`console.log\` there).
+   */
   log(...args: any[]): void;`;
-const clientServerProxy = `
-  /**
-   * Server-side function proxy.
-   *
-   * In the CLI, calls exported functions from the \`**server.ts**\` section.
-   *
-   * A normal export is awaited for its result (\`await tb.server.fn()\`). An \`async function*\`
-   * export streams: \`for await (const chunk of tb.server.gen())\`. The call object supports both;
-   * break the \`for await\` to cancel and tear down the server generator.
-   */
+const clientServerProxy = `
+  /**
+   * Server-side function proxy.
+   *
+   * In the CLI, calls exported functions from the \`**server.ts**\` section.
+   *
+   * A normal export is awaited for its result (\`await tb.server.fn()\`). An \`async function*\`
+   * export streams: \`for await (const chunk of tb.server.gen())\`. The call object supports both;
+   * break the \`for await\` to cancel and tear down the server generator.
+   */
   server: Record<string, (...args: any[]) => Promise<any> & AsyncIterable<any>>;`;
 /** Typebulb globals available in browser-side code (code.tsx). */
-export const clientTbTypings = `${aiChunkType}${aiAccessType}
-/**
- * Typebulb utilities namespace.
- * Type \`tb.\` to discover available helpers.
- */
-declare const tb: {${dataAndJson}${clientOnlyMembers}${insight}${runtimeStateWriters}${log}${clientServerProxy}${onMessage}${ai}${fs}${dir}${models}${theme}${mode}
-};
+export const clientTbTypings = `${aiChunkType}${aiAccessType}
+/**
+ * Typebulb utilities namespace.
+ * Type \`tb.\` to discover available helpers.
+ */
+declare const tb: {${dataAndJson}${clientOnlyMembers}${insight}${runtimeStateWriters}${log}${clientServerProxy}${onMessage}${ai}${fs}${dir}${models}${theme}${mode}
+};
 `;
-const serverLog = `
-  /**
-   * Print to the CLI's stdout — the same channel as \`console.log\` here (the server's console IS
-   * the bulb's log). One log verb across blocks: page-side \`tb.log\` reaches this same stdout.
-   */
+const serverLog = `
+  /**
+   * Print to the CLI's stdout — the same channel as \`console.log\` here (the server's console IS
+   * the bulb's log). One log verb across blocks: page-side \`tb.log\` reaches this same stdout.
+   */
   log(...args: any[]): void;`;
 /** Typebulb globals available in Node-side code (server.ts).
  *  Only what carries a bulb-specific rule Node can't know — tb.ai, tb.fs, tb.dir (TB-FS.md);
  *  plus the tb.log uniformity exception (serverTb.ts). The browser-only helpers are intentionally
  *  absent. Must match serverTb.ts's runtime surface. */
-export const serverTbTypings = `${aiChunkType}${aiAccessType}
-/**
- * Typebulb utilities namespace (server-side).
- * Type \`tb.\` to discover available helpers.
- */
-declare const tb: {${serverLog}${ai}${fs}${dir}${models}${mode}
-};
+export const serverTbTypings = `${aiChunkType}${aiAccessType}
+/**
+ * Typebulb utilities namespace (server-side).
+ * Type \`tb.\` to discover available helpers.
+ */
+declare const tb: {${serverLog}${ai}${fs}${dir}${models}${mode}
+};
 `;
 //# sourceMappingURL=tbTypings.js.map

package/dist/dts/tbTypings.js.map

@@ -1 +1 @@
-{"version":3,"file":"tbTypings.js","sourceRoot":"","sources":["../../dts/src/tbTypings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,MAAM,WAAW,GAAG;;;;;;;;;;;uCAWmB,CAAA;AAEvC,MAAM,OAAO,GAAG;;;;;;;;;yCASyB,CAAA;AAEzC,uFAAuF;AACvF,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;2DAsB+B,CAAA;AAE3D,2DAA2D;AAC3D,MAAM,SAAS,GAAG;;;;;;;;;;;IAWd,CAAA;AAEJ,oGAAoG;AACpG,MAAM,WAAW,GAAG;;;;;;;;;;;;CAYnB,CAAA;AAED,wGAAwG;AACxG,MAAM,YAAY,GAAG;;;CAGpB,CAAA;AAED,MAAM,EAAE,GAAG;;;;;;;;;;OAUJ,SAAS;;;;;;;;;;;;;;;;;aAiBH,SAAS;KACjB,CAAA;AAEL,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA8BkB,CAAA;AAEjC,MAAM,KAAK,GAAG;;;;;;;;;;;;uCAYyB,CAAA;AAEvC,MAAM,IAAI,GAAG;;;;;;;;;;UAUH,SAAS,GAAG,CAAA;AAEtB,MAAM,EAAE,GAAG;;;;;;;;;;;;;;;;;KAiBN,CAAA;AAEL,MAAM,GAAG,GAAG;;;;;;;;;wBASY,CAAA;AAExB,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAmDA,CAAA;AAE1B,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;6DAiB2C,CAAA;AAE7D,MAAM,GAAG,GAAG;;;;;;;;;6BASiB,CAAA;AAE7B,MAAM,iBAAiB,GAAG;;;;;;;;;;iFAUuD,CAAA;AAEjF,kEAAkE;AAClE,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,WAAW,GAAG,YAAY;;;;;qBAKvC,WAAW,GAAG,iBAAiB,GAAG,OAAO,GAAG,mBAAmB,GAAG,GAAG,GAAG,iBAAiB,GAAG,SAAS,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,MAAM,GAAG,KAAK,GAAG,IAAI;;CAEjK,CAAA;AAED,MAAM,SAAS,GAAG;;;;;6BAKW,CAAA;AAE7B;;;wDAGwD;AACxD,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,WAAW,GAAG,YAAY;;;;;qBAKvC,SAAS,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,MAAM,GAAG,IAAI;;CAE7D,CAAA"}
+{"version":3,"file":"tbTypings.js","sourceRoot":"","sources":["../../dts/src/tbTypings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,MAAM,WAAW,GAAG;;;;;;;;;;;uCAWmB,CAAA;AAEvC,MAAM,OAAO,GAAG;;;;;;;;;yCASyB,CAAA;AAEzC,uFAAuF;AACvF,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;6CAuBiB,CAAA;AAE7C,2DAA2D;AAC3D,MAAM,SAAS,GAAG;;;;;;;;;;;IAWd,CAAA;AAEJ,oGAAoG;AACpG,MAAM,WAAW,GAAG;;;;;;;;;;;;CAYnB,CAAA;AAED,wGAAwG;AACxG,MAAM,YAAY,GAAG;;;CAGpB,CAAA;AAED,MAAM,EAAE,GAAG;;;;;;;;;;OAUJ,SAAS;;;;;;;;;;;;;;;;;aAiBH,SAAS;KACjB,CAAA;AAEL,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA8BkB,CAAA;AAEjC,MAAM,KAAK,GAAG;;;;;;;;;;;;uCAYyB,CAAA;AAEvC,MAAM,IAAI,GAAG;;;;;;;;;;UAUH,SAAS,GAAG,CAAA;AAEtB,MAAM,EAAE,GAAG;;;;;;;;;;;;;;;;;KAiBN,CAAA;AAEL,MAAM,GAAG,GAAG;;;;;;;;;wBASY,CAAA;AAExB,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAqDA,CAAA;AAE1B,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;6DAiB2C,CAAA;AAE7D,MAAM,GAAG,GAAG;;;;;;;;;6BASiB,CAAA;AAE7B,MAAM,iBAAiB,GAAG;;;;;;;;;;iFAUuD,CAAA;AAEjF,kEAAkE;AAClE,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,WAAW,GAAG,YAAY;;;;;qBAKvC,WAAW,GAAG,iBAAiB,GAAG,OAAO,GAAG,mBAAmB,GAAG,GAAG,GAAG,iBAAiB,GAAG,SAAS,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,MAAM,GAAG,KAAK,GAAG,IAAI;;CAEjK,CAAA;AAED,MAAM,SAAS,GAAG;;;;;6BAKW,CAAA;AAE7B;;;wDAGwD;AACxD,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,WAAW,GAAG,YAAY;;;;;qBAKvC,SAAS,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,MAAM,GAAG,IAAI;;CAE7D,CAAA"}

package/dist/format/runtimeState.d.ts

@@ -8,11 +8,13 @@
  *   init({ applyData, applyInsight, send })
  *     applyData(chunks)   -> put the chunks in this host's data global
  *     applyInsight(json)  -> put the serialized insight in this host's insight global
- *     send(pair)          -> hand { data?, insight? } to this host's transport; resolve the
- *                            shareable URL, or undefined when there is none. Must never reject:
- *                            every failure reads to a bulb as "no link".
+ *     send(pair)          -> hand { data?, insight? } to this host's transport; resolve once the
+ *                            write has landed. Must never reject: a transport failure costs the
+ *                            fragment, never the swap.
  *
- *   setData(chunks) / setInsight(value) -> the two tb.* writers, resolving send's URL
+ *   setData(chunks) / setInsight(value) -> the two tb.* writers, resolving once the address bar
+ *                            reflects the write. Neither hands back a link: the fragment is
+ *                            already in the URL, which a bulb reads with tb.url() like any other.
  *   seed(pair)  -> apply and record what a decoded `#tb=` fragment carried, without sending it back
  *   pair()      -> the wire pair, for a host that files it (the CLI modal's Save). Empty when
  *                  nothing has been set, which is also how a host asks whether anything has.
@@ -24,10 +26,9 @@
  * which stays exact for a null insight and needs no companion flag.
  *
  * Coalescing keys on whether the in-flight write has read the pair yet, not on whether one is
- * outstanding. Writes landing before that ride it and share its URL, one round trip for the pair;
- * a write landing after it queues one re-send, because the write on the wire carries a state the
- * page has moved past. Answering it with that URL would address a run the page no longer shows,
- * and skipping the re-send would leave the address bar doing so (Invariant 6).
+ * outstanding. Writes landing before that ride it, one round trip for the pair; a write landing
+ * after it queues one re-send, because the write on the wire carries a state the page has moved
+ * past, and skipping the re-send would leave the address bar addressing it (Invariant 6).
  */
 export declare const runtimeStateEngine = "(function () {\n  var W = window;\n  var rtData, rtInsight, rtHasInsight = false;\n  var applyData, applyInsight, send;\n  var pending = null, sent = false, queued = null;\n\n  var pair = function () {\n    var p = {};\n    if (rtData !== undefined) p.data = rtData;\n    if (rtHasInsight) p.insight = rtInsight;\n    return p;\n  };\n\n  var start = function () {\n    sent = false;\n    return Promise.resolve()\n      .then(function () { sent = true; return send(pair()); })\n      .catch(function () { return undefined; })\n      .finally(function () { pending = null; });\n  };\n  var publish = function () {\n    if (!pending) { pending = start(); return pending; }\n    if (!sent) return pending;\n    if (!queued) queued = pending.then(function () { queued = null; return publish(); });\n    return queued;\n  };\n\n  W.__tbState = {\n    init: function (o) { applyData = o.applyData; applyInsight = o.applyInsight; send = o.send; },\n    pair: pair,\n    // Applied but not sent: the fragment already holds this, so sending it back would re-encode\n    // the state the page just booted from.\n    seed: function (p) {\n      if (p.data !== undefined) { rtData = p.data; applyData(p.data); }\n      if ('insight' in p) { rtInsight = p.insight; rtHasInsight = true; applyInsight(JSON.stringify(p.insight, null, 2)); }\n    },\n    // The globals move before the round trip, so a synchronous tb.data() right after the await is\n    // never stale.\n    setData: function (chunks) {\n      var arr = Array.isArray(chunks) ? chunks : [chunks];\n      rtData = arr;\n      applyData(arr);\n      return publish();\n    },\n    setInsight: function (value) {\n      // Serialize before recording: a value JSON.stringify rejects (a cycle, a BigInt) must leave\n      // the slot untouched, or every later setter carries a pair that can never be encoded or sent.\n      var json = JSON.stringify(value, null, 2);\n      rtInsight = value;\n      rtHasInsight = true;\n      applyInsight(json);\n      return publish();\n    }\n  };\n})();";
 //# sourceMappingURL=runtimeState.d.ts.map

package/dist/format/runtimeState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtimeState.d.ts","sourceRoot":"","sources":["../../format/src/runtimeState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,kBAAkB,4/DAsDzB,CAAA"}
+{"version":3,"file":"runtimeState.d.ts","sourceRoot":"","sources":["../../format/src/runtimeState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,kBAAkB,4/DAsDzB,CAAA"}

package/dist/format/runtimeState.js

@@ -8,11 +8,13 @@
  *   init({ applyData, applyInsight, send })
  *     applyData(chunks)   -> put the chunks in this host's data global
  *     applyInsight(json)  -> put the serialized insight in this host's insight global
- *     send(pair)          -> hand { data?, insight? } to this host's transport; resolve the
- *                            shareable URL, or undefined when there is none. Must never reject:
- *                            every failure reads to a bulb as "no link".
+ *     send(pair)          -> hand { data?, insight? } to this host's transport; resolve once the
+ *                            write has landed. Must never reject: a transport failure costs the
+ *                            fragment, never the swap.
  *
- *   setData(chunks) / setInsight(value) -> the two tb.* writers, resolving send's URL
+ *   setData(chunks) / setInsight(value) -> the two tb.* writers, resolving once the address bar
+ *                            reflects the write. Neither hands back a link: the fragment is
+ *                            already in the URL, which a bulb reads with tb.url() like any other.
  *   seed(pair)  -> apply and record what a decoded `#tb=` fragment carried, without sending it back
  *   pair()      -> the wire pair, for a host that files it (the CLI modal's Save). Empty when
  *                  nothing has been set, which is also how a host asks whether anything has.
@@ -24,64 +26,63 @@
  * which stays exact for a null insight and needs no companion flag.
  *
  * Coalescing keys on whether the in-flight write has read the pair yet, not on whether one is
- * outstanding. Writes landing before that ride it and share its URL, one round trip for the pair;
- * a write landing after it queues one re-send, because the write on the wire carries a state the
- * page has moved past. Answering it with that URL would address a run the page no longer shows,
- * and skipping the re-send would leave the address bar doing so (Invariant 6).
+ * outstanding. Writes landing before that ride it, one round trip for the pair; a write landing
+ * after it queues one re-send, because the write on the wire carries a state the page has moved
+ * past, and skipping the re-send would leave the address bar addressing it (Invariant 6).
  */
-export const runtimeStateEngine = `(function () {
-  var W = window;
-  var rtData, rtInsight, rtHasInsight = false;
-  var applyData, applyInsight, send;
-  var pending = null, sent = false, queued = null;
-
-  var pair = function () {
-    var p = {};
-    if (rtData !== undefined) p.data = rtData;
-    if (rtHasInsight) p.insight = rtInsight;
-    return p;
-  };
-
-  var start = function () {
-    sent = false;
-    return Promise.resolve()
-      .then(function () { sent = true; return send(pair()); })
-      .catch(function () { return undefined; })
-      .finally(function () { pending = null; });
-  };
-  var publish = function () {
-    if (!pending) { pending = start(); return pending; }
-    if (!sent) return pending;
-    if (!queued) queued = pending.then(function () { queued = null; return publish(); });
-    return queued;
-  };
-
-  W.__tbState = {
-    init: function (o) { applyData = o.applyData; applyInsight = o.applyInsight; send = o.send; },
-    pair: pair,
-    // Applied but not sent: the fragment already holds this, so sending it back would re-encode
-    // the state the page just booted from.
-    seed: function (p) {
-      if (p.data !== undefined) { rtData = p.data; applyData(p.data); }
-      if ('insight' in p) { rtInsight = p.insight; rtHasInsight = true; applyInsight(JSON.stringify(p.insight, null, 2)); }
-    },
-    // The globals move before the round trip, so a synchronous tb.data() right after the await is
-    // never stale.
-    setData: function (chunks) {
-      var arr = Array.isArray(chunks) ? chunks : [chunks];
-      rtData = arr;
-      applyData(arr);
-      return publish();
-    },
-    setInsight: function (value) {
-      // Serialize before recording: a value JSON.stringify rejects (a cycle, a BigInt) must leave
-      // the slot untouched, or every later setter carries a pair that can never be encoded or sent.
-      var json = JSON.stringify(value, null, 2);
-      rtInsight = value;
-      rtHasInsight = true;
-      applyInsight(json);
-      return publish();
-    }
-  };
+export const runtimeStateEngine = `(function () {
+  var W = window;
+  var rtData, rtInsight, rtHasInsight = false;
+  var applyData, applyInsight, send;
+  var pending = null, sent = false, queued = null;
+
+  var pair = function () {
+    var p = {};
+    if (rtData !== undefined) p.data = rtData;
+    if (rtHasInsight) p.insight = rtInsight;
+    return p;
+  };
+
+  var start = function () {
+    sent = false;
+    return Promise.resolve()
+      .then(function () { sent = true; return send(pair()); })
+      .catch(function () { return undefined; })
+      .finally(function () { pending = null; });
+  };
+  var publish = function () {
+    if (!pending) { pending = start(); return pending; }
+    if (!sent) return pending;
+    if (!queued) queued = pending.then(function () { queued = null; return publish(); });
+    return queued;
+  };
+
+  W.__tbState = {
+    init: function (o) { applyData = o.applyData; applyInsight = o.applyInsight; send = o.send; },
+    pair: pair,
+    // Applied but not sent: the fragment already holds this, so sending it back would re-encode
+    // the state the page just booted from.
+    seed: function (p) {
+      if (p.data !== undefined) { rtData = p.data; applyData(p.data); }
+      if ('insight' in p) { rtInsight = p.insight; rtHasInsight = true; applyInsight(JSON.stringify(p.insight, null, 2)); }
+    },
+    // The globals move before the round trip, so a synchronous tb.data() right after the await is
+    // never stale.
+    setData: function (chunks) {
+      var arr = Array.isArray(chunks) ? chunks : [chunks];
+      rtData = arr;
+      applyData(arr);
+      return publish();
+    },
+    setInsight: function (value) {
+      // Serialize before recording: a value JSON.stringify rejects (a cycle, a BigInt) must leave
+      // the slot untouched, or every later setter carries a pair that can never be encoded or sent.
+      var json = JSON.stringify(value, null, 2);
+      rtInsight = value;
+      rtHasInsight = true;
+      applyInsight(json);
+      return publish();
+    }
+  };
 })();`;
 //# sourceMappingURL=runtimeState.js.map

package/dist/format/runtimeState.js.map

@@ -1 +1 @@
-{"version":3,"file":"runtimeState.js","sourceRoot":"","sources":["../../format/src/runtimeState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsD5B,CAAA"}
+{"version":3,"file":"runtimeState.js","sourceRoot":"","sources":["../../format/src/runtimeState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsD5B,CAAA"}

package/dist/index.js

@@ -302,7 +302,7 @@ ${t.comment}`:t.comment}this.doc.range[2]=t.offset;break}default:this.errors.pus
 `),l=i.filter(u=>u.type==="tool_use").map(u=>({id:u.id??"",name:u.name??"",input:u.input??{}}));if(o||a||l.length){let u=Date.parse(e.timestamp??""),f=!isNaN(u)&&u>=t;r.push({type:"assistant",text:o,thinking:a,tools:l,live:f})}let c=e.message?.usage??e.usage,d=c&&{in:c.input_tokens??0,out:c.output_tokens??0,cached:c.cache_read_input_tokens??0,cacheCreate:c.cache_creation_input_tokens??0};return{events:r,usage:d,model:e.message?.model}}return{events:r}}chainWorking(e){let t;for(let o of e)(o.type==="user"||o.type==="assistant")&&(t=o);if(!t)return!1;if(t.type==="user"){try{let o=t.message?.content,a=typeof o=="string"?o:Array.isArray(o)?o.filter(c=>c&&c.type==="text").map(c=>c.text??"").join(""):"";if(!(Array.isArray(o)&&o.some(c=>c&&c.type==="tool_result"))&&a.trim()&&Nt(a)==="")return!1}catch{}return!0}let s=(Array.isArray(t.message?.content)?t.message.content:[]).filter(o=>o.type==="tool_use").map(o=>o.id);if(s.length===0)return!1;let i=new Set;for(let o of e){let a=o.message?.content;if(Array.isArray(a))for(let l of a)l.type==="tool_result"&&l.tool_use_id&&i.add(l.tool_use_id)}return s.some(o=>o&&!i.has(o))}sessionAlive(e){return SA(e)}readPreview(e){return vA(e)}searchText(e){if(!e||ps(e)||e.type!=="user"&&e.type!=="assistant")return"";let t=e.message?.content,r="";if(typeof t=="string")r=Nt(t);else if(Array.isArray(t)){let s=t;r=e.type==="user"?s.map(ru).filter(Boolean).join(" "):s.filter(i=>i.type==="text"&&typeof i.text=="string").map(i=>i.text).join(" ")}return r.replace(/\s+/g," ").trim()}}});import{statSync as kA,readdirSync as xA,openSync as EA,readSync as AA,closeSync as TA,existsSync as PA}from"fs";import{basename as OA,join as ou,resolve as _A}from"path";import{homedir as bg}from"os";function RA(n){let e=n.trimStart();return CA.some(t=>e.startsWith(t))}function ms(n,e){return Array.isArray(n)?n.map(t=>typeof t?.text=="string"?e&&RA(t.text)?"":Ae(t.text):t?.type==="input_image"&&typeof t.image_url=="string"&&t.image_url.startsWith("data:")?`![image](${t.image_url})`:"").filter(Boolean).join(`
 `):""}function IA(n){return typeof n=="string"?Ae(n):ms(n,!1)}function NA(n){let e=n??"";for(let t of[/tools\.shell_command\((\{[\s\S]*?\})\)/,/tools\.shell_command\((\{[\s\S]*\})\)/]){let r=t.exec(e);if(r)try{return JSON.parse(r[1])}catch{}}return{script:e}}function $A(n){if(typeof n=="string"&&n)try{let e=JSON.parse(n);if(e&&typeof e=="object"&&!Array.isArray(e))return e}catch{}return{arguments:n??""}}function vg(n,e){let t;try{t=EA(n,"r")}catch{return}try{let r=Buffer.alloc(e),s=AA(t,r,0,e,0);return{text:r.subarray(0,s).toString("utf8"),bytes:s}}finally{TA(t)}}function LA(n){let t=vg(n,65536);if(t===void 0)return;let r=t.text.indexOf(`
 `);if(r<0)return t.bytes>=65536?"":void 0;try{let s=JSON.parse(t.text.slice(0,r));return s?.type==="session_meta"&&typeof s.payload?.cwd=="string"?s.payload.cwd:""}catch{return""}}var CA,wg,Wn,au=v(()=>{"use strict";fs();mo();CA=["<permissions instructions>","<apps_instructions>","<plugins_instructions>","<skills_instructions>","<recommended_plugins>","<environment_context>","<user_instructions>"];wg=n=>{let e=_A(n);return process.platform==="win32"?e.toLowerCase():e},Wn=class extends It{constructor(t=ou(bg(),".codex","sessions")){super();this.root=t}displayName="Codex Mirror";#e=0;#s;#t=new Map;detectsSelf(){return!!process.env.CODEX_THREAD_ID}detectsInstalled(){return PA(ou(bg(),".codex"))}sessionsDir(t){return this.root}listSessionFiles(t){let r=wg(t),s=[];for(let i of this.#r()){let o;try{let l=kA(i);if(!l.isFile())continue;o=l.mtimeMs}catch{continue}let a=this.#t.get(i);if(a===void 0){if(a=LA(i),a===void 0)continue;this.#t.set(i,a)}wg(a)===r&&s.push({sessionId:OA(i,".jsonl"),file:i,mtime:o})}return s}#r(){let t=[],r=s=>{try{return xA(s).map(i=>ou(s,i))}catch{return[]}};for(let s of r(this.root))for(let i of r(s))for(let o of r(i))for(let a of r(o))a.endsWith(".jsonl")&&t.push(a);return t}parseEntry(t){let r;try{r=JSON.parse(t)}catch{return null}return!r||typeof r.type!="string"?null:r}idOf(t){return t.ord===void 0&&(t.ord=String(this.#e++),t.parent=this.#s,this.#s=t.ord),t.ord}parentOf(t){return t.parent}timestampOf(t){return t.timestamp}isSidechain(t){return!1}isLeafType(t){return!0}isRecoveryNoise(t){return!1}apply(t,r){let s=[],i=t.payload;if(!i)return{events:s};let o=()=>{let a=Date.parse(t.timestamp??"");return!isNaN(a)&&a>=r};if(t.type==="response_item"){if(i.type==="message"){if(i.role==="user"){let a=ms(i.content,!0).trim();a&&s.push({type:"user",text:a})}else if(i.role==="assistant"){let a=ms(i.content,!1);a&&s.push({type:"assistant",text:a,thinking:"",tools:[],live:o()})}return{events:s}}if(i.type==="reasoning"){let a=ms(i.summary,!1);return a&&s.push({type:"assistant",text:"",thinking:a,tools:[],live:o()}),{events:s}}if(i.type==="custom_tool_call"||i.type==="function_call"){let a=i.type==="custom_tool_call"?NA(i.input):$A(i.arguments);return s.push({type:"assistant",text:"",thinking:"",tools:[{id:i.call_id??"",name:i.name??"",input:a}],live:o()}),{events:s}}if(i.type==="custom_tool_call_output"||i.type==="function_call_output"){let a=IA(i.output);return s.push({type:"tool_result",id:i.call_id??"",content:a,isError:!1,digest:qe(a)}),{events:s}}return{events:s}}if(t.type==="event_msg"){if(i.type==="token_count"){let a=i.info?.last_token_usage;if(!a)return{events:s};let l={in:Math.max(0,(a.input_tokens??0)-(a.cached_input_tokens??0)),out:a.output_tokens??0,cached:a.cached_input_tokens??0,cacheCreate:a.cache_write_input_tokens??0};return{events:s,usage:l}}return{events:s}}return t.type==="turn_context"?{events:s,model:i.model}:{events:s}}chainWorking(t){let r=!1;for(let s of t){if(s.type!=="event_msg")continue;let i=s.payload?.type;i==="task_started"?r=!0:(i==="task_complete"||i==="turn_aborted")&&(r=!1)}return r}sessionAlive(){}readPreview(t){for(let r of(vg(t,256*1024)?.text??"").split(`
-`))if(r.includes('"user_message"'))try{let s=JSON.parse(r);if(s?.type==="event_msg"&&s.payload?.type==="user_message"&&typeof s.payload.message=="string"){let i=s.payload.message.replace(/\s+/g," ").trim();if(i)return i.slice(0,200)}}catch{}return""}searchText(t){if(t?.type!=="response_item"||t.payload?.type!=="message")return"";let r=t.payload.role;return r!=="user"&&r!=="assistant"?"":ms(t.payload.content,r==="user").replace(/\s+/g," ").trim()}}});import{realpathSync as MA}from"fs";import{createHash as BA}from"crypto";import{join as bo,resolve as DA}from"path";import{homedir as jA}from"os";function $t(){let n=process.env.TYPEBULB_SERVERS_DIR;return n?bo(n,".."):bo(jA(),".typebulb")}function lt(){Sg||(Sg=!0,console.error(`${$t()} not writable \u2014 continuing stateless: ports won't stick, caches stay cold, and typebulb logs/wait/send/stop may not see this run`))}function ct(){return process.env.TYPEBULB_SERVERS_DIR||bo($t(),"servers")}function kg(n){let e=se(n),t=e.slice(e.lastIndexOf("/")+1).replace(/\.bulb\.md$/,"");return bo($t(),"canvas",`${t}-${gs(n)}.png`)}function gs(n){return BA("sha1").update(se(n)).digest("hex").slice(0,8)}function se(n){let e=DA(n),t=e;try{t=MA.native(e)}catch{}return(process.platform==="win32"?t.toLowerCase():t).replace(/\\/g,"/")}function xg(n,e){let t=se(n),r=se(e);return t.startsWith(r.endsWith("/")?r:r+"/")?!t.includes("/node_modules/"):!1}var Sg,et=v(()=>{"use strict";Sg=!1});import*as Tg from"net";import{mkdir as FA,readFile as UA,writeFile as Pg}from"fs/promises";import{existsSync as qA}from"fs";import{join as Og}from"path";function Rg(){return Og($t(),"blocks")}function lu(n){return Og(Rg(),`${n}.json`)}function vo(n){return new Promise(e=>{let t=Tg.createServer();t.once("error",()=>e(!1)),t.listen(n,"127.0.0.1",()=>t.close(()=>e(!0)))})}async function HA(n){for(let e=n;e<65535;e++)if(await vo(e))return e;throw new Error(`No free port found above ${n}`)}async function cu(n){let{listBulbServers:e}=await Promise.resolve().then(()=>(Re(),Ig)),t=(await e()).find(s=>s.port===n),r=t?` (pid ${t.pid}, ${t.agent?`agent:${t.agent}`:t.file})`:"";console.error(`port ${n} in use${r}`),process.exit(1)}async function So(n){try{let e=JSON.parse(await UA(lu(n),"utf8"));return e&&typeof e.cwd=="string"?{cwd:e.cwd,slots:e.slots??{},mirrors:e.mirrors??{}}:void 0}catch{return}}async function ko(n,e){try{return await Pg(lu(n),JSON.stringify(e,null,2)),!0}catch{return lt(),!1}}async function YA(n){let e=se(n);try{await FA(Rg(),{recursive:!0})}catch{return}let t=[];for(let o=0;o<Cg;o++)t.push(_g+o*sn);let r=await Promise.all(t.map(async o=>({base:o,block:await So(o)})));for(let{base:o,block:a}of r)if(a?.cwd===e)return o;let s={cwd:e,slots:{},mirrors:{}};for(let{base:o,block:a}of r){if(!a)try{return await Pg(lu(o),JSON.stringify(s,null,2),{flag:"wx"}),o}catch(l){if((await So(o))?.cwd===e)return o;l.code!=="EEXIST"&&lt();continue}if(!qA(a.cwd))return await ko(o,s)?o:void 0}let i=r.filter(o=>!!o.block).sort((o,a)=>Eg(o.block)-Eg(a.block))[0];if(i)return await ko(i.base,s)?i.base:void 0}function Eg(n){return Object.values(n.slots).reduce((e,t)=>Math.max(e,t.usedAt??0),0)}async function VA(n,e){let t=await So(n)??{cwd:"",slots:{},mirrors:{}};if(e.kind==="mirror"){let i=t.mirrors[e.agent];if(i!==void 0)return i;let o=Ag(t),a=o.has(0)?KA:0;for(;a>wo&&o.has(a);)a--;return t.mirrors[e.agent]=a,await ko(n,t),a}let r=se(e.file),s=t.slots[r]?.offset;if(s===void 0){let i=Ag(t);for(s=wo;s<sn&&i.has(s);)s++;if(s>=sn){let o=Object.entries(t.slots).sort((a,l)=>(a[1].usedAt??0)-(l[1].usedAt??0))[0];s=o?o[1].offset:wo,o&&delete t.slots[o[0]]}}return t.slots[r]={offset:s,usedAt:Date.now()},await ko(n,t),s}function Ag(n){return new Set([...Object.values(n.mirrors),...Object.values(n.slots).map(e=>e.offset)])}async function Hn(n,e){let t=await YA(e);return t===void 0?void 0:t+await VA(t,n)}async function on(n){let e=se(n);for(let t=0;t<Cg;t++){let r=await So(_g+t*sn);if(r?.cwd===e)return s=>r.slots[se(s)]?.usedAt??0}return()=>0}async function xo(n){if(n.explicit!==void 0)return await vo(n.explicit)||await cu(n.explicit),n.target.kind==="bulb"&&await Hn(n.target,n.cwd),{port:n.explicit};let e=await Hn(n.target,n.cwd);if(e!==void 0){let r=e-e%sn,s=Date.now()+WA;do{if(await vo(e))return{port:e};await new Promise(i=>setTimeout(i,150))}while(Date.now()<s);for(let i=wo;i<sn;i++){let o=r+i;if(o!==e&&await vo(o))return{port:o,note:`(slot ${e} was busy)`}}}return{port:await HA(JA),note:e===void 0?"(no port block available)":"(this project's block was full)"}}var _g,sn,Cg,JA,wo,KA,WA,an=v(()=>{"use strict";et();_g=20100,sn=100,Cg=19,JA=23e3,wo=1,KA=sn-1,WA=3e3});var Ie,Eo=v(()=>{"use strict";Ie="0.58.0"});var Ig={};oi(Ig,{agentViewerCommand:()=>qg,bulbServerCommand:()=>Ug,clearServerLog:()=>hu,findProjectViewer:()=>Po,isAlive:()=>Yn,isMirror:()=>me,isProjectBulb:()=>wu,isProjectMirror:()=>Gn,launchAgentViewer:()=>ku,launchBulbServer:()=>ws,listBulbServers:()=>X,probePageCount:()=>Su,readServerLog:()=>Ke,readWaitCursor:()=>To,recordDenial:()=>bu,registerServer:()=>yu,relayOpen:()=>vu,runMarker:()=>mu,serverLogPath:()=>zn,serversForBulb:()=>cn,sliceRunLog:()=>gu,startServerLog:()=>bs,stopBulbServer:()=>Vn,stopServer:()=>Lt,stopServersForBulb:()=>Oo,typebulbBinPath:()=>Xn,unregisterServer:()=>ln,writeWaitCursor:()=>ys});import{spawn as Ng}from"child_process";import{readdir as zA,readFile as Mg,writeFile as Bg,unlink as uu,mkdir as GA}from"fs/promises";import{mkdirSync as Dg,writeFileSync as Ao,appendFileSync as XA,readFileSync as du}from"fs";import*as Te from"path";import{fileURLToPath as QA}from"url";function fu(n){return Te.join(ct(),`${n}.json`)}function zn(n){return Te.join(ct(),`${n}.log`)}function pu(n){return Te.join(ct(),`${n}.wait.json`)}function jg(n){try{let e=JSON.parse(du(pu(n),"utf8"));return e.cursors&&typeof e.cursors=="object"?e.cursors:{}}catch{return{}}}function To(n,e=""){let t=jg(n)[e];return typeof t=="number"&&Number.isFinite(t)&&t>=0?t:void 0}function ys(n,e,t=""){try{Dg(ct(),{recursive:!0});let r=jg(n);r[t]=e,Ao(pu(n),JSON.stringify({cursors:r}))}catch{}}function bs(n){let e=zn(n);try{Dg(ct(),{recursive:!0}),Ao(e,"")}catch{return()=>{}}let t=process.stdout.write.bind(process.stdout),r=process.stderr.write.bind(process.stderr),s=0,i=!1,o=a=>{if(!i)try{let l=typeof a=="string"?Buffer.from(a,"utf8"):Buffer.from(a);if(XA(e,l),s+=l.length,s>2*$g){let c=du(e),d=c.subarray(Math.max(0,c.length-$g));Ao(e,d),s=d.length}}catch{i=!0}};return process.stdout.write=((a,...l)=>(o(a),t(a,...l))),process.stderr.write=((a,...l)=>(o(a),r(a,...l))),()=>{process.stdout.write=t,process.stderr.write=r}}function hu(n){try{Ao(zn(n),"")}catch{}}function Ke(n,e=0){try{let t=du(zn(n)),r=e>=0&&e<=t.length?e:0;return{text:t.subarray(r).toString("utf8"),offset:t.length}}catch{return{text:"",offset:0}}}function mu(n){return`\u2500\u2500 run ${n} \u2500\u2500 ${new Date().toTimeString().slice(0,8)}`}function eT(n){let e=ZA.exec(n);return e?Number(e[1]):void 0}function gu(n,e){let t=n.split(`
+`))if(r.includes('"user_message"'))try{let s=JSON.parse(r);if(s?.type==="event_msg"&&s.payload?.type==="user_message"&&typeof s.payload.message=="string"){let i=s.payload.message.replace(/\s+/g," ").trim();if(i)return i.slice(0,200)}}catch{}return""}searchText(t){if(t?.type!=="response_item"||t.payload?.type!=="message")return"";let r=t.payload.role;return r!=="user"&&r!=="assistant"?"":ms(t.payload.content,r==="user").replace(/\s+/g," ").trim()}}});import{realpathSync as MA}from"fs";import{createHash as BA}from"crypto";import{join as bo,resolve as DA}from"path";import{homedir as jA}from"os";function $t(){let n=process.env.TYPEBULB_SERVERS_DIR;return n?bo(n,".."):bo(jA(),".typebulb")}function lt(){Sg||(Sg=!0,console.error(`${$t()} not writable \u2014 continuing stateless: ports won't stick, caches stay cold, and typebulb logs/wait/send/stop may not see this run`))}function ct(){return process.env.TYPEBULB_SERVERS_DIR||bo($t(),"servers")}function kg(n){let e=se(n),t=e.slice(e.lastIndexOf("/")+1).replace(/\.bulb\.md$/,"");return bo($t(),"canvas",`${t}-${gs(n)}.png`)}function gs(n){return BA("sha1").update(se(n)).digest("hex").slice(0,8)}function se(n){let e=DA(n),t=e;try{t=MA.native(e)}catch{}return(process.platform==="win32"?t.toLowerCase():t).replace(/\\/g,"/")}function xg(n,e){let t=se(n),r=se(e);return t.startsWith(r.endsWith("/")?r:r+"/")?!t.includes("/node_modules/"):!1}var Sg,et=v(()=>{"use strict";Sg=!1});import*as Tg from"net";import{mkdir as FA,readFile as UA,writeFile as Pg}from"fs/promises";import{existsSync as qA}from"fs";import{join as Og}from"path";function Rg(){return Og($t(),"blocks")}function lu(n){return Og(Rg(),`${n}.json`)}function vo(n){return new Promise(e=>{let t=Tg.createServer();t.once("error",()=>e(!1)),t.listen(n,"127.0.0.1",()=>t.close(()=>e(!0)))})}async function HA(n){for(let e=n;e<65535;e++)if(await vo(e))return e;throw new Error(`No free port found above ${n}`)}async function cu(n){let{listBulbServers:e}=await Promise.resolve().then(()=>(Re(),Ig)),t=(await e()).find(s=>s.port===n),r=t?` (pid ${t.pid}, ${t.agent?`agent:${t.agent}`:t.file})`:"";console.error(`port ${n} in use${r}`),process.exit(1)}async function So(n){try{let e=JSON.parse(await UA(lu(n),"utf8"));return e&&typeof e.cwd=="string"?{cwd:e.cwd,slots:e.slots??{},mirrors:e.mirrors??{}}:void 0}catch{return}}async function ko(n,e){try{return await Pg(lu(n),JSON.stringify(e,null,2)),!0}catch{return lt(),!1}}async function YA(n){let e=se(n);try{await FA(Rg(),{recursive:!0})}catch{return}let t=[];for(let o=0;o<Cg;o++)t.push(_g+o*sn);let r=await Promise.all(t.map(async o=>({base:o,block:await So(o)})));for(let{base:o,block:a}of r)if(a?.cwd===e)return o;let s={cwd:e,slots:{},mirrors:{}};for(let{base:o,block:a}of r){if(!a)try{return await Pg(lu(o),JSON.stringify(s,null,2),{flag:"wx"}),o}catch(l){if((await So(o))?.cwd===e)return o;l.code!=="EEXIST"&&lt();continue}if(!qA(a.cwd))return await ko(o,s)?o:void 0}let i=r.filter(o=>!!o.block).sort((o,a)=>Eg(o.block)-Eg(a.block))[0];if(i)return await ko(i.base,s)?i.base:void 0}function Eg(n){return Object.values(n.slots).reduce((e,t)=>Math.max(e,t.usedAt??0),0)}async function VA(n,e){let t=await So(n)??{cwd:"",slots:{},mirrors:{}};if(e.kind==="mirror"){let i=t.mirrors[e.agent];if(i!==void 0)return i;let o=Ag(t),a=o.has(0)?KA:0;for(;a>wo&&o.has(a);)a--;return t.mirrors[e.agent]=a,await ko(n,t),a}let r=se(e.file),s=t.slots[r]?.offset;if(s===void 0){let i=Ag(t);for(s=wo;s<sn&&i.has(s);)s++;if(s>=sn){let o=Object.entries(t.slots).sort((a,l)=>(a[1].usedAt??0)-(l[1].usedAt??0))[0];s=o?o[1].offset:wo,o&&delete t.slots[o[0]]}}return t.slots[r]={offset:s,usedAt:Date.now()},await ko(n,t),s}function Ag(n){return new Set([...Object.values(n.mirrors),...Object.values(n.slots).map(e=>e.offset)])}async function Hn(n,e){let t=await YA(e);return t===void 0?void 0:t+await VA(t,n)}async function on(n){let e=se(n);for(let t=0;t<Cg;t++){let r=await So(_g+t*sn);if(r?.cwd===e)return s=>r.slots[se(s)]?.usedAt??0}return()=>0}async function xo(n){if(n.explicit!==void 0)return await vo(n.explicit)||await cu(n.explicit),n.target.kind==="bulb"&&await Hn(n.target,n.cwd),{port:n.explicit};let e=await Hn(n.target,n.cwd);if(e!==void 0){let r=e-e%sn,s=Date.now()+WA;do{if(await vo(e))return{port:e};await new Promise(i=>setTimeout(i,150))}while(Date.now()<s);for(let i=wo;i<sn;i++){let o=r+i;if(o!==e&&await vo(o))return{port:o,note:`(slot ${e} was busy)`}}}return{port:await HA(JA),note:e===void 0?"(no port block available)":"(this project's block was full)"}}var _g,sn,Cg,JA,wo,KA,WA,an=v(()=>{"use strict";et();_g=20100,sn=100,Cg=19,JA=23e3,wo=1,KA=sn-1,WA=3e3});var Ie,Eo=v(()=>{"use strict";Ie="0.58.1"});var Ig={};oi(Ig,{agentViewerCommand:()=>qg,bulbServerCommand:()=>Ug,clearServerLog:()=>hu,findProjectViewer:()=>Po,isAlive:()=>Yn,isMirror:()=>me,isProjectBulb:()=>wu,isProjectMirror:()=>Gn,launchAgentViewer:()=>ku,launchBulbServer:()=>ws,listBulbServers:()=>X,probePageCount:()=>Su,readServerLog:()=>Ke,readWaitCursor:()=>To,recordDenial:()=>bu,registerServer:()=>yu,relayOpen:()=>vu,runMarker:()=>mu,serverLogPath:()=>zn,serversForBulb:()=>cn,sliceRunLog:()=>gu,startServerLog:()=>bs,stopBulbServer:()=>Vn,stopServer:()=>Lt,stopServersForBulb:()=>Oo,typebulbBinPath:()=>Xn,unregisterServer:()=>ln,writeWaitCursor:()=>ys});import{spawn as Ng}from"child_process";import{readdir as zA,readFile as Mg,writeFile as Bg,unlink as uu,mkdir as GA}from"fs/promises";import{mkdirSync as Dg,writeFileSync as Ao,appendFileSync as XA,readFileSync as du}from"fs";import*as Te from"path";import{fileURLToPath as QA}from"url";function fu(n){return Te.join(ct(),`${n}.json`)}function zn(n){return Te.join(ct(),`${n}.log`)}function pu(n){return Te.join(ct(),`${n}.wait.json`)}function jg(n){try{let e=JSON.parse(du(pu(n),"utf8"));return e.cursors&&typeof e.cursors=="object"?e.cursors:{}}catch{return{}}}function To(n,e=""){let t=jg(n)[e];return typeof t=="number"&&Number.isFinite(t)&&t>=0?t:void 0}function ys(n,e,t=""){try{Dg(ct(),{recursive:!0});let r=jg(n);r[t]=e,Ao(pu(n),JSON.stringify({cursors:r}))}catch{}}function bs(n){let e=zn(n);try{Dg(ct(),{recursive:!0}),Ao(e,"")}catch{return()=>{}}let t=process.stdout.write.bind(process.stdout),r=process.stderr.write.bind(process.stderr),s=0,i=!1,o=a=>{if(!i)try{let l=typeof a=="string"?Buffer.from(a,"utf8"):Buffer.from(a);if(XA(e,l),s+=l.length,s>2*$g){let c=du(e),d=c.subarray(Math.max(0,c.length-$g));Ao(e,d),s=d.length}}catch{i=!0}};return process.stdout.write=((a,...l)=>(o(a),t(a,...l))),process.stderr.write=((a,...l)=>(o(a),r(a,...l))),()=>{process.stdout.write=t,process.stderr.write=r}}function hu(n){try{Ao(zn(n),"")}catch{}}function Ke(n,e=0){try{let t=du(zn(n)),r=e>=0&&e<=t.length?e:0;return{text:t.subarray(r).toString("utf8"),offset:t.length}}catch{return{text:"",offset:0}}}function mu(n){return`\u2500\u2500 run ${n} \u2500\u2500 ${new Date().toTimeString().slice(0,8)}`}function eT(n){let e=ZA.exec(n);return e?Number(e[1]):void 0}function gu(n,e){let t=n.split(`
 `),r=[];if(t.forEach((o,a)=>{let l=eT(o);l!==void 0&&r.push({id:l,idx:a})}),!r.length)return e==="latest"?n:"";let s=e==="latest"?r[r.length-1]:r.find(o=>o.id===e);if(!s)return"";let i=r.find(o=>o.idx>s.idx);return t.slice(s.idx,i?i.idx:t.length).join(`
 `)}function Yn(n){try{return process.kill(n,0),!0}catch(e){return e.code==="EPERM"}}async function yu(n){try{await GA(ct(),{recursive:!0}),await Bg(fu(n.pid),JSON.stringify({version:Ie,...n}))}catch{lt()}}async function bu(n,e){let t=fu(n);try{let r=JSON.parse(await Mg(t,"utf8"));if(r.denied===e)return;r.denied=e,await Bg(t,JSON.stringify(r))}catch{}}async function ln(n){await uu(fu(n)).catch(()=>{}),await uu(zn(n)).catch(()=>{}),await uu(pu(n)).catch(()=>{})}function me(n){return n.agent!=null}function Gn(n,e){return me(n)&&n.cwd!=null&&se(n.cwd)===se(e)}function wu(n,e){return!me(n)&&xg(n.file,e)}async function X(n){let e;try{e=await zA(ct())}catch{return[]}let t=[];return await Promise.all(e.map(async s=>{if(!/^\d+\.json$/.test(s))return;let i=parseInt(s,10),o;try{o=JSON.parse(await Mg(Te.join(ct(),s),"utf8"))}catch{await ln(i);return}o&&typeof o.pid=="number"&&Yn(o.pid)?t.push(o):await ln(i)})),(n?t.filter(s=>wu(s,n)):t).sort((s,i)=>s.startedAt-i.startedAt)}async function Po(n,e){return(await X()).find(t=>Gn(t,n)&&(e?t.agent===e:!0))}async function vu(n,e){let t=new URL(n).port,r=(await X()).filter(a=>String(a.port)!==t),s=r.filter(a=>Gn(a,e)),i=r.filter(a=>wu(a,e)),o=0;for(let a of[...s,...i])try{let l=await fetch(`${a.url}/__open`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({url:n}),signal:AbortSignal.timeout(2e3)});if(!l.ok)continue;let{opened:c,pages:d}=await l.json();if(c)return{where:"editor",via:a.agent?"the agent mirror":`${Te.basename(a.file)}'s page`};me(a)&&(o+=d??0)}catch{}return o>0?{where:"external"}:void 0}async function Vn(n){try{process.kill(n,"SIGTERM")}catch{}await ln(n)}async function Su(n){try{let e=await fetch(`${n.url}/__pages`,{signal:AbortSignal.timeout(tT)});if(!e.ok)return;let{pages:t}=await e.json();return typeof t=="number"?t:void 0}catch{return}}async function Lt(n,e=me(n)?"keep":"close"){try{let t=await fetch(`${n.url}/__stop`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({pages:e}),signal:AbortSignal.timeout(Lg)});if(!t.ok)throw new Error(`/__stop ${t.status}`);let{closed:r=0,stuck:s=0}=await t.json(),i=Date.now()+Lg;for(;Yn(n.pid)&&Date.now()<i;)await Fg(100);return Yn(n.pid)?(await Vn(n.pid),"killed"):(await ln(n.pid),{closed:r,stuck:s})}catch{return await Vn(n.pid),"killed"}}function cn(n,e){let t=se(e);return n.filter(r=>!me(r)&&r.pid!==process.pid&&se(r.file)===t)}async function Oo(n,e){let t=cn(await X(),n);for(let r of t)await Lt(r,e!==void 0&&r.port===e?"keep":"close");return t}function nT(n,e,t){(process.platform==="win32"?Ng("cmd",["/c","start","","/b",n,...e],{cwd:t,stdio:"ignore",windowsHide:!0}):Ng(n,e,{cwd:t,detached:!0,stdio:"ignore"})).unref()}function Xn(){return Te.join(Te.dirname(QA(import.meta.url)),"index.js")}function Ug(n,e={}){return{command:process.execPath,args:[Xn(),...e.trust?["--trust"]:[],...e.batch?["--batch",e.batch]:[],...e.mode?["--mode",e.mode]:[],n,...e.open===!1?["--no-open"]:[]]}}function qg(n){return{command:process.execPath,args:[Xn(),`agent:${n}`,"--no-open"]}}async function Jg(n,e,t,r){let s=await n();if(s)return s;nT(e.command,e.args,t);let i=Date.now()+2e4;for(;Date.now()<i;){await Fg(150);let o=await n();if(o)return o}throw new Error(`Launched ${r} but it did not register within 20s.`)}async function ws(n,e={}){let t=e.cwd??process.cwd(),r=Te.resolve(t,n),s=await Hn({kind:"bulb",file:r},t),[i]=await Oo(r,s),o={...e,batch:e.batch??i?.batch,mode:e.mode??i?.mode};return Jg(async()=>cn(await X(),r)[0],Ug(n,o),t,Te.basename(n))}async function ku(n,e=process.cwd()){return Jg(()=>Po(e,n),qg(n),e,`the ${n} mirror`)}var $g,ZA,Lg,tT,Fg,Re=v(()=>{"use strict";et();an();Eo();$g=1e6;ZA=/^── run (\d+) ── /;Lg=6e3,tT=500;Fg=n=>new Promise(e=>setTimeout(e,n))});function Qn(n){return{...Uf(n),server:n.files.get("server.ts")??""}}function _o(n){return!!n.server&&!n.code}var vs=v(()=>{"use strict";ee();ee()});function Co(n){let e=/^---[^\n]*\n([\s\S]*?)\n---/.exec(n),t=e?/^\s*name:\s*(.+?)\s*$/m.exec(e[1]):null;return t?t[1].replace(/^["']|["']$/g,""):void 0}function xu(n){return qn(Co(n)??"bulb")||"bulb"}var Eu=v(()=>{"use strict";ee()});import{transform as rT}from"sucrase";function Au(n,e={}){let t=e.serverOnly?["typescript"]:["typescript","jsx"];try{let{code:r}=rT(n,{transforms:t,jsxRuntime:"automatic",jsxImportSource:e.jsxImportSource||"react",production:!0});return{code:r}}catch(r){return{code:"",error:String(r)}}}var Kg=v(()=>{});function Tu(n){let e=n.split(""),t=(i,o)=>{for(let a=i;a<o&&a<e.length;a++)e[a]!==`
 `&&(e[a]=" ")},r=0,s="";for(;r<n.length;){let i=n[r],o=n[r+1];if(i==="/"&&o==="/"){let a=r;for(;a<n.length&&n[a]!==`
@@ -608,8 +608,8 @@ ${cg}
   // tb.setData / tb.setInsight (TB-State.md), on the engine both hosts share. The globals and the
   // transport are all this host owns: encoding round-trips to the server because the page carries
   // no fflate on purpose, and the fragment write is the address bar the setters exist to fill.
-  // Resolves the shareable URL, or undefined when there is no address bar to put it in (inline) or
-  // the state is too large to encode \u2014 the one failure an author must handle.
+  // Resolves once that write has landed, and hands back nothing: the link is then tb.url() like
+  // any other. An inline bulb has no address bar, so its swap is page-local and never encodes.
   window.__tbState.init({
     applyData: (chunks) => { window.__TB_DATA__ = chunks; },
     applyInsight: (json) => { window.__TB_INSIGHT__ = json; },
@@ -627,7 +627,6 @@ ${cg}
           // earlier fragment, or the address bar keeps addressing a run the page is no longer
           // showing \u2014 and a reload would silently revert to it.
           history.replaceState(null, '', location.pathname + location.search + hash);
-          return hash ? location.href : undefined;
         });
     }
   });
@@ -2229,27 +2228,28 @@ Examples:
    */
   insight<T = unknown>(): T | undefined;`,PC=`
   /**
-   * Replace the data this run is working on, and get back a link that carries it.
+   * Replace the data this run is working on.
    *
    * Updates what \`tb.data()\` / \`tb.json()\` return for the rest of this page, and writes the
-   * result into the URL fragment so the address bar addresses this run. The bulb's source
-   * \`data.txt\` is never touched: a reload without the fragment goes back to the file.
+   * result into the URL fragment, so the address bar addresses this run and \`tb.url()\` carries
+   * it. The bulb's source \`data.txt\` is never touched: a reload without the fragment goes back
+   * to the file.
    *
    * @param chunks - The new data chunks (a bare string is treated as one chunk)
-   * @returns The shareable URL, or undefined when there is no address bar (inline bulbs) or the
-   *   data is too large to fit a URL. Pass only what a share needs, not necessarily everything.
+   * @returns Resolves once the address bar reflects the write. Data too large to fit a URL
+   *   (~60KB encoded) still swaps, but carries no fragment: pass what a share needs, not
+   *   necessarily everything.
    */
-  setData(chunks: string | string[]): Promise<string | undefined>;
+  setData(chunks: string | string[]): Promise<void>;
   /**
-   * Replace the insight this run is working on, and get back a link that carries it.
+   * Replace the insight this run is working on.
    *
    * The \`tb.insight()\` counterpart of \`setData\`, with the same fragment behavior and the same
    * rule: runtime only, never the bulb's source \`insight.json\`.
    *
    * @param value - Any JSON-serializable value
-   * @returns The shareable URL, or undefined (see \`setData\`)
    */
-  setInsight(value: unknown): Promise<string | undefined>;`,Pw=`options: {
+  setInsight(value: unknown): Promise<void>;`,Pw=`options: {
     messages: Array<{ role: "user" | "assistant"; content: string }>;
     system?: string;
     /** Reasoning effort: 0=minimal, 1=low, 2=med, 3=high, 4=xhigh. Mapped to each provider's native mechanism (OpenAI/OpenRouter reasoning effort, Gemini thinking level, Anthropic adaptive thinking). 0 reaches the vendor's explicit off switch, and floors to a little thinking only on always-thinking models. 4 reaches the rung above high where the vendor has one (OpenAI/OpenRouter xhigh, Anthropic max) and clamps to high where it doesn't (Gemini) \u2014 never an error. Pin 1 (low) for most work; pick 0 deliberately, when you want the raw model or latency is the constraint. Omitting is NOT off \u2014 it buys the model's own default (medium on GPT-5.6), which reasons and bills invisibly. Ignored on the courtesy model, which runs at the level Typebulb sets. */
@@ -2405,9 +2405,11 @@ type AiAccess = "own" | "courtesy" | "none";
   /**
    * Get the canonical URL of this bulb.
    *
-   * Returns the parent typebulb.com URL (including path, query, and \`#tb=\` fragment),
-   * resolving correctly from inside the cross-origin sandbox iframe.
-   * Use this instead of \`location.href\` or \`document.referrer\`.
+   * Returns the parent typebulb.com URL (including query and \`#tb=\` fragment), resolving
+   * correctly from inside the cross-origin sandbox iframe. That is the published \`/full\` page
+   * even while authoring in the IDE, because it is the link someone you send it to can open.
+   * Locally it is the served localhost URL. Use this instead of \`location.href\` or
+   * \`document.referrer\`.
    *
    * @returns The full canonical URL
    */

package/dist/render.js

@@ -701,8 +701,8 @@ ${B1}
   // tb.setData / tb.setInsight (TB-State.md), on the engine both hosts share. The globals and the
   // transport are all this host owns: encoding round-trips to the server because the page carries
   // no fflate on purpose, and the fragment write is the address bar the setters exist to fill.
-  // Resolves the shareable URL, or undefined when there is no address bar to put it in (inline) or
-  // the state is too large to encode \u2014 the one failure an author must handle.
+  // Resolves once that write has landed, and hands back nothing: the link is then tb.url() like
+  // any other. An inline bulb has no address bar, so its swap is page-local and never encodes.
   window.__tbState.init({
     applyData: (chunks) => { window.__TB_DATA__ = chunks; },
     applyInsight: (json) => { window.__TB_INSIGHT__ = json; },
@@ -720,7 +720,6 @@ ${B1}
           // earlier fragment, or the address bar keeps addressing a run the page is no longer
           // showing \u2014 and a reload would silently revert to it.
           history.replaceState(null, '', location.pathname + location.search + hash);
-          return hash ? location.href : undefined;
         });
     }
   });

package/dist/servers.js

@@ -355,8 +355,8 @@ ${s}`}function b1(t){let e=dr.filter(n=>t[n]).map(n=>U0(n,t[n]));return["---",`f
   // tb.setData / tb.setInsight (TB-State.md), on the engine both hosts share. The globals and the
   // transport are all this host owns: encoding round-trips to the server because the page carries
   // no fflate on purpose, and the fragment write is the address bar the setters exist to fill.
-  // Resolves the shareable URL, or undefined when there is no address bar to put it in (inline) or
-  // the state is too large to encode \u2014 the one failure an author must handle.
+  // Resolves once that write has landed, and hands back nothing: the link is then tb.url() like
+  // any other. An inline bulb has no address bar, so its swap is page-local and never encodes.
   window.__tbState.init({
     applyData: (chunks) => { window.__TB_DATA__ = chunks; },
     applyInsight: (json) => { window.__TB_INSIGHT__ = json; },
@@ -374,7 +374,6 @@ ${s}`}function b1(t){let e=dr.filter(n=>t[n]).map(n=>U0(n,t[n]));return["---",`f
           // earlier fragment, or the address bar keeps addressing a run the page is no longer
           // showing \u2014 and a reload would silently revert to it.
           history.replaceState(null, '', location.pathname + location.search + hash);
-          return hash ? location.href : undefined;
         });
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typebulb",
-  "version": "0.58.0",
+  "version": "0.58.1",
   "description": "Typebulb CLI to run single-file markdown apps called bulbs, either as standalone web apps or embedded in agent responses.",
   "keywords": [
     "bulb",