@jini-ai/ui 0.1.2 → 0.3.1

package/dist/renderers/srcdoc/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/renderers/srcdoc/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,wBAAwB,EACxB,0BAA0B,EAC1B,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,GAGpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,kBAAkB,EAA+C,MAAM,aAAa,CAAC"}

package/dist/renderers/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * `ArtifactKind`/`ArtifactRendererId`/`ArtifactExportKind`/`ArtifactStatus`/
+ * `ArtifactManifest` below were previously re-exported from `@jini-ai/chat`.
+ * They are now owned here instead: a renderer registry package must not
+ * depend on a chat package (folding this package into `@jini-ai/ui`, which
+ * `@jini-ai/chat` already depends on, would otherwise create a `ui ↔ chat`
+ * cycle). Shapes are copied verbatim from `@jini-ai/chat`'s
+ * `src/core/util/types.ts` — keep the two in sync by hand if that shape
+ * changes.
+ */
+export type ArtifactKind = 'html' | 'deck' | 'react-component' | 'markdown-document' | 'svg' | 'diagram' | 'code-snippet' | 'mini-app' | 'design-system';
+export type ArtifactRendererId = 'html' | 'deck-html' | 'react-component' | 'markdown' | 'svg' | 'diagram' | 'code' | 'mini-app' | 'design-system';
+export type ArtifactExportKind = 'html' | 'pdf' | 'zip' | 'jsx' | 'md' | 'svg' | 'txt';
+export type ArtifactStatus = 'streaming' | 'complete' | 'error';
+/**
+ * The sidecar manifest an artifact-producing turn writes alongside its
+ * generated file, describing how to render/export it. Generic across
+ * artifact kinds — a host's own artifact-file type carries this manifest,
+ * not the other way around (see `ArtifactFile` below).
+ */
+export interface ArtifactManifest {
+    version: 1;
+    kind: ArtifactKind;
+    title: string;
+    entry: string;
+    renderer: ArtifactRendererId;
+    /** Optional for backward compatibility with older manifests; treat missing as `'complete'`. */
+    status?: ArtifactStatus | undefined;
+    exports: ArtifactExportKind[];
+    /** Optional primary-entry hint for multi-file outputs; fall back to renderable-file heuristics when omitted. */
+    primary?: string | boolean | undefined;
+    /** Reserved for future multi-file artifact packaging; not yet populated by any known generator. */
+    supportingFiles?: string[] | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    sourceSkillId?: string | undefined;
+    designSystemId?: string | null | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
+export interface SandboxedDocumentOptions {
+    /**
+     * Value for the document's `<base href>`, so relative asset/link
+     * references in the artifact HTML resolve against it instead of the
+     * host page's own URL. Omit to leave relative references as-is.
+     */
+    baseHref?: string;
+    /**
+     * Shim `localStorage`/`sessionStorage` with an in-memory store when the
+     * real Storage API throws. A sandboxed iframe using
+     * `sandbox="allow-scripts"` without `allow-same-origin` raises a
+     * `SecurityError` on first access to either — many hand-written or
+     * model-generated pages call `localStorage.getItem(...)` at the top of
+     * an IIFE with no try/catch, so without this shim the whole script
+     * aborts and the page never renders. Also installs a click-time
+     * interceptor for `<a href>` clicks so hash-only links scroll within the
+     * document instead of navigating the sandboxed frame, and
+     * `target="_blank"` links open through `window.open` with a scheme
+     * allow-list instead of being silently blocked by the sandbox. Defaults
+     * to `true`.
+     */
+    storageShim?: boolean;
+    /**
+     * Suppress `focus()` calls (on `window` or any element) that aren't the
+     * direct result of a real pointer/keyboard event within the last second.
+     * Without this, embedded content can call `.focus()` on load or on a
+     * timer and steal keyboard focus away from the host page around it.
+     * Defaults to `false` — most hosts only need this for content mounted
+     * alongside other interactive UI (e.g. a toolbar) that the sandboxed
+     * frame shouldn't be able to steal focus from.
+     */
+    focusGuard?: boolean;
+}
+export interface SandboxedDocumentResult {
+    /** The final HTML string, ready to assign to an iframe's `srcdoc`. */
+    html: string;
+    /** Whether the input was already a full `<!doctype>`/`<html>` document (vs. a bare fragment that got wrapped). */
+    isFullDocument: boolean;
+}
+export interface SandboxBridgeMessage {
+    type: string;
+    [key: string]: unknown;
+}
+export type SandboxBridgeHandler<M extends SandboxBridgeMessage = SandboxBridgeMessage> = (message: M) => void;
+/**
+ * A host's artifact/file representation, generified from a product's own
+ * project-file type. A host's real file type carries far more (ids,
+ * timestamps, storage refs, …) — this is only the shape the renderer
+ * registry needs to resolve and render one.
+ */
+export interface ArtifactFile {
+    name: string;
+    /** Host-defined coarse file kind (e.g. 'html' | 'text' | 'image' | 'sketch'). Not the same vocabulary as `ArtifactManifest.kind`. */
+    kind: string;
+    content?: string | undefined;
+    url?: string | undefined;
+    manifest?: ArtifactManifest | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/renderers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/renderers/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GACpB,MAAM,GACN,MAAM,GACN,iBAAiB,GACjB,mBAAmB,GACnB,KAAK,GACL,SAAS,GACT,cAAc,GACd,UAAU,GACV,eAAe,CAAC;AAEpB,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN,WAAW,GACX,iBAAiB,GACjB,UAAU,GACV,KAAK,GACL,SAAS,GACT,MAAM,GACN,UAAU,GACV,eAAe,CAAC;AAEpB,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;AAEvF,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,CAAC,CAAC;IACX,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,+FAA+F;IAC/F,MAAM,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IACpC,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,gHAAgH;IAChH,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;IACvC,mGAAmG;IACnG,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACvC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CAChD;AAED,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,uBAAuB;IACtC,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,kHAAkH;IAClH,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,oBAAoB,GAAG,oBAAoB,IAAI,CACxF,OAAO,EAAE,CAAC,KACP,IAAI,CAAC;AAEV;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,qIAAqI;IACrI,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,QAAQ,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;CACzC"}

package/dist/renderers/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/renderers/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/renderers/types.ts"],"names":[],"mappings":""}

package/dist/renderers/url-load-decision.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Decide between two HTML preview render strategies: load a URL directly in
+ * an `<iframe src>` (per-asset requests, working source maps, real DevTools
+ * filenames, one broken file doesn't blank the whole iframe — the right
+ * default for multi-file artifacts) vs. build a self-contained `srcDoc`
+ * document (`buildSrcDoc`, required whenever a host-injected bridge needs to
+ * run inside the artifact, or when Web Storage access needs the sandbox
+ * shim).
+ *
+ * Origin: `apps/web/src/components/file-viewer-render-mode.ts` in the origin
+ * project. Generified: the original's `UrlLoadDecision` had one named
+ * boolean flag per product-specific bridge (`commentMode`, `inspectMode`,
+ * `editMode`, `paletteActive`, `drawMode`, `tweaksBridge`, …) — this version
+ * replaces that fixed list with `activeBridgeIds`, so any host-registered
+ * `SrcDocBridge` (see `srcdoc/bridge.ts`) can force srcDoc mode by declaring
+ * itself active, without this package knowing the bridge's name in advance.
+ * See `source-map.md`.
+ */
+export interface UrlLoadDecision {
+    /** Whether the viewer is showing the rendered preview vs. the raw source. */
+    mode: 'preview' | 'source';
+    /** User explicitly opted into the inline (srcDoc) path. */
+    forceInline: boolean;
+    /** The artifact has its own script that listens for edit postMessages while URL-loaded — a host-specific bridge concern; only meaningful if the host sets it. */
+    urlModeBridge?: boolean | undefined;
+    /** The HTML source contains patterns that steal focus on load (see {@link htmlNeedsFocusGuard}). */
+    needsFocusGuard?: boolean | undefined;
+    /** IDs of currently-active `SrcDocBridge` plugins (see `srcdoc/bridge.ts`) that require srcDoc mode to function — a raw URL-loaded iframe has no parent-injected listener for them. */
+    activeBridgeIds?: readonly string[] | undefined;
+}
+/**
+ * Returns true when an HTML file's preview iframe should load directly from
+ * its raw URL rather than through the srcDoc inline path. Pure function —
+ * caller is responsible for the non-HTML / source-mode early returns.
+ *
+ * `bridgesRequiringSrcDoc` is the set of bridge ids (from the host's own
+ * `SrcDocBridge` registrations) that need the srcDoc path to function; any
+ * of `d.activeBridgeIds` matching one of them forces srcDoc mode.
+ */
+export declare function shouldUrlLoadHtmlPreview(d: UrlLoadDecision, bridgesRequiringSrcDoc?: ReadonlySet<string>): boolean;
+/**
+ * Read the `forceInline` opt-out from a URL search string or an existing
+ * `URLSearchParams`. Accepts `1`, `true`, `yes`, `on` (case-insensitive).
+ * Anything else — including `0`, `false`, an unrelated value, or a missing
+ * parameter — returns false.
+ */
+export declare function parseForceInline(search: string | URLSearchParams | null | undefined): boolean;
+/**
+ * Return true when the HTML source may call `.focus()` at load time, which
+ * would steal focus from the host page in a URL-loaded (or unguarded
+ * srcDoc) iframe. `buildSrcDoc`'s `previewFocusGuard` option suppresses
+ * this; URL-load has no such guard, so a host routes matching artifacts
+ * through srcDoc instead (or forces `previewFocusGuard: true`).
+ *
+ *   1. Inline `.focus(` calls and `autofocus` attributes — directly visible
+ *      in the document source.
+ *   2. External `<script src=...>` references — the linked file's content
+ *      can't be inspected, so it's conservatively assumed it may call focus.
+ *
+ * False positives just route the artifact through the slightly slower
+ * srcDoc path, which is the safe direction.
+ */
+export declare function htmlNeedsFocusGuard(source: string): boolean;
+/**
+ * Return true when the HTML source contains patterns that fail under a
+ * URL-load iframe's bare `sandbox="allow-scripts"` (no `allow-same-origin`):
+ * `localStorage`/`sessionStorage` access that throws `SecurityError` under
+ * that sandbox and can unmount the whole page. `buildSrcDoc` always installs
+ * a same-origin storage shim before any user script runs, so routing a
+ * matching artifact through srcDoc (via `forceInline`) fixes it.
+ *
+ * Scope is narrow on purpose — three reliable signals visible in the
+ * *document* source:
+ *
+ *   - `<script type="text/babel">` (quoted or unquoted): a babel-standalone
+ *     runtime that XHR-fetches and evals sibling files, commonly reading Web
+ *     Storage from a `useState` initializer.
+ *   - Direct `localStorage`/`sessionStorage` mentions in the document
+ *     source (covers inline scripts and plain HTML that calls them).
+ *   - Any external `<script src="…">` (including `type="module"`): the
+ *     linked subresource's body isn't visible to this scan, and generated
+ *     artifacts commonly read Web Storage from an external entry script at
+ *     module eval. Conservatively routes any external script through
+ *     srcDoc rather than fetching every script URL ahead of the iframe to
+ *     check it.
+ *
+ * Known limitation: dynamically injected scripts
+ * (`document.createElement('script'); s.src = '…'`) are invisible to this
+ * scan since the literal `<script src=…>` tag never appears in the source;
+ * such artifacts still URL-load and can still throw on Web Storage access.
+ */
+export declare function htmlNeedsSandboxShim(source: string): boolean;
+//# sourceMappingURL=url-load-decision.d.ts.map

package/dist/renderers/url-load-decision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-load-decision.d.ts","sourceRoot":"","sources":["../../src/renderers/url-load-decision.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC3B,2DAA2D;IAC3D,WAAW,EAAE,OAAO,CAAC;IACrB,iKAAiK;IACjK,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC,oGAAoG;IACpG,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACtC,uLAAuL;IACvL,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;CACjD;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,eAAe,EAClB,sBAAsB,GAAE,WAAW,CAAC,MAAM,CAAa,GACtD,OAAO,CAMT;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAO7F;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAK3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAK5D"}

package/dist/renderers/url-load-decision.js

@@ -0,0 +1,116 @@
+/**
+ * Decide between two HTML preview render strategies: load a URL directly in
+ * an `<iframe src>` (per-asset requests, working source maps, real DevTools
+ * filenames, one broken file doesn't blank the whole iframe — the right
+ * default for multi-file artifacts) vs. build a self-contained `srcDoc`
+ * document (`buildSrcDoc`, required whenever a host-injected bridge needs to
+ * run inside the artifact, or when Web Storage access needs the sandbox
+ * shim).
+ *
+ * Origin: `apps/web/src/components/file-viewer-render-mode.ts` in the origin
+ * project. Generified: the original's `UrlLoadDecision` had one named
+ * boolean flag per product-specific bridge (`commentMode`, `inspectMode`,
+ * `editMode`, `paletteActive`, `drawMode`, `tweaksBridge`, …) — this version
+ * replaces that fixed list with `activeBridgeIds`, so any host-registered
+ * `SrcDocBridge` (see `srcdoc/bridge.ts`) can force srcDoc mode by declaring
+ * itself active, without this package knowing the bridge's name in advance.
+ * See `source-map.md`.
+ */
+/**
+ * Returns true when an HTML file's preview iframe should load directly from
+ * its raw URL rather than through the srcDoc inline path. Pure function —
+ * caller is responsible for the non-HTML / source-mode early returns.
+ *
+ * `bridgesRequiringSrcDoc` is the set of bridge ids (from the host's own
+ * `SrcDocBridge` registrations) that need the srcDoc path to function; any
+ * of `d.activeBridgeIds` matching one of them forces srcDoc mode.
+ */
+export function shouldUrlLoadHtmlPreview(d, bridgesRequiringSrcDoc = new Set()) {
+    if (d.mode !== 'preview')
+        return false;
+    if (d.forceInline)
+        return false;
+    if (d.needsFocusGuard)
+        return false;
+    if (d.activeBridgeIds?.some((id) => bridgesRequiringSrcDoc.has(id)))
+        return false;
+    return true;
+}
+/**
+ * Read the `forceInline` opt-out from a URL search string or an existing
+ * `URLSearchParams`. Accepts `1`, `true`, `yes`, `on` (case-insensitive).
+ * Anything else — including `0`, `false`, an unrelated value, or a missing
+ * parameter — returns false.
+ */
+export function parseForceInline(search) {
+    if (!search)
+        return false;
+    const params = typeof search === 'string' ? new URLSearchParams(search) : search;
+    const value = params.get('forceInline');
+    if (value === null)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+/**
+ * Return true when the HTML source may call `.focus()` at load time, which
+ * would steal focus from the host page in a URL-loaded (or unguarded
+ * srcDoc) iframe. `buildSrcDoc`'s `previewFocusGuard` option suppresses
+ * this; URL-load has no such guard, so a host routes matching artifacts
+ * through srcDoc instead (or forces `previewFocusGuard: true`).
+ *
+ *   1. Inline `.focus(` calls and `autofocus` attributes — directly visible
+ *      in the document source.
+ *   2. External `<script src=...>` references — the linked file's content
+ *      can't be inspected, so it's conservatively assumed it may call focus.
+ *
+ * False positives just route the artifact through the slightly slower
+ * srcDoc path, which is the safe direction.
+ */
+export function htmlNeedsFocusGuard(source) {
+    if (/\.\s*focus\s*\(/i.test(source))
+        return true;
+    if (/\bautofocus\b/i.test(source))
+        return true;
+    if (/<script\b[^>]*\bsrc\s*=/i.test(source))
+        return true;
+    return false;
+}
+/**
+ * Return true when the HTML source contains patterns that fail under a
+ * URL-load iframe's bare `sandbox="allow-scripts"` (no `allow-same-origin`):
+ * `localStorage`/`sessionStorage` access that throws `SecurityError` under
+ * that sandbox and can unmount the whole page. `buildSrcDoc` always installs
+ * a same-origin storage shim before any user script runs, so routing a
+ * matching artifact through srcDoc (via `forceInline`) fixes it.
+ *
+ * Scope is narrow on purpose — three reliable signals visible in the
+ * *document* source:
+ *
+ *   - `<script type="text/babel">` (quoted or unquoted): a babel-standalone
+ *     runtime that XHR-fetches and evals sibling files, commonly reading Web
+ *     Storage from a `useState` initializer.
+ *   - Direct `localStorage`/`sessionStorage` mentions in the document
+ *     source (covers inline scripts and plain HTML that calls them).
+ *   - Any external `<script src="…">` (including `type="module"`): the
+ *     linked subresource's body isn't visible to this scan, and generated
+ *     artifacts commonly read Web Storage from an external entry script at
+ *     module eval. Conservatively routes any external script through
+ *     srcDoc rather than fetching every script URL ahead of the iframe to
+ *     check it.
+ *
+ * Known limitation: dynamically injected scripts
+ * (`document.createElement('script'); s.src = '…'`) are invisible to this
+ * scan since the literal `<script src=…>` tag never appears in the source;
+ * such artifacts still URL-load and can still throw on Web Storage access.
+ */
+export function htmlNeedsSandboxShim(source) {
+    if (/<script\s[^>]*\btype\s*=\s*["']?text\/babel\b/i.test(source))
+        return true;
+    if (/\b(?:local|session)Storage\b/.test(source))
+        return true;
+    if (/<script\s[^>]*?\bsrc\s*=/i.test(source))
+        return true;
+    return false;
+}
+//# sourceMappingURL=url-load-decision.js.map

package/dist/renderers/url-load-decision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-load-decision.js","sourceRoot":"","sources":["../../src/renderers/url-load-decision.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAeH;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CACtC,CAAkB,EAClB,yBAA8C,IAAI,GAAG,EAAE;IAEvD,IAAI,CAAC,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACvC,IAAI,CAAC,CAAC,WAAW;QAAE,OAAO,KAAK,CAAC;IAChC,IAAI,CAAC,CAAC,eAAe;QAAE,OAAO,KAAK,CAAC;IACpC,IAAI,CAAC,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,sBAAsB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IAClF,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAmD;IAClF,IAAI,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IAC1B,MAAM,MAAM,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IACjF,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;IACxC,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACjC,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC9C,OAAO,UAAU,KAAK,GAAG,IAAI,UAAU,KAAK,MAAM,IAAI,UAAU,KAAK,KAAK,IAAI,UAAU,KAAK,IAAI,CAAC;AACpG,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAc;IAChD,IAAI,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IACjD,IAAI,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/C,IAAI,0BAA0B,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IACzD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAc;IACjD,IAAI,gDAAgD,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/E,IAAI,8BAA8B,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7D,IAAI,2BAA2B,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1D,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/utils/appearance.d.ts

@@ -1,20 +1,6 @@
+export { ACCENT_SWATCHES, DEFAULT_ACCENT_COLOR } from '../features/appearance/constants.js';
+export { normalizeAccentColor, resolveAccentColor } from '../features/appearance/rules.js';
 export type AppearanceTheme = 'light' | 'dark';
-/** Neutral default accent — hosts are expected to override via their own
- *  config/branding; this only guarantees the CSS vars are always set. */
-export declare const DEFAULT_ACCENT_COLOR = "#2563eb";
-export declare const ACCENT_SWATCHES: readonly ["#2563eb", "#c96442", "#7c3aed", "#059669", "#dc2626", "#d97706", "#0891b2", "#db2777"];
-/**
- * Validate and lowercase a `#rrggbb` accent color string.
- *
- * @param value - Candidate accent color, typically from persisted config.
- * @returns The lowercased 6-digit hex string, or `null` if `value` is not a
- *   string or does not match `#rrggbb`.
- * @complexity O(1).
- */
-export declare function normalizeAccentColor(value: unknown): string | null;
-/** `normalizeAccentColor(value) ?? DEFAULT_ACCENT_COLOR` — always returns a
- *  usable color. */
-export declare function resolveAccentColor(value: unknown): string;
 /**
  * Apply a theme + accent color to `document.documentElement`: sets/clears
  * `data-theme` and writes the five `--accent*` custom properties (using

package/dist/utils/appearance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"appearance.d.ts","sourceRoot":"","sources":["../../src/utils/appearance.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,MAAM,CAAC;AAU/C;yEACyE;AACzE,eAAO,MAAM,oBAAoB,YAAY,CAAC;AAE9C,eAAO,MAAM,eAAe,mGASlB,CAAC;AAEX;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAIlE;AAED;oBACoB;AACpB,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEzD;AAYD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,KAAK,EACL,WAAW,GACZ,EAAE;IACD,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,IAAI,CAaP"}
+{"version":3,"file":"appearance.d.ts","sourceRoot":"","sources":["../../src/utils/appearance.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAG3F,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,MAAM,CAAC;AAE/C;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,KAAK,EACL,WAAW,GACZ,EAAE;IACD,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,IAAI,CAYP"}

package/dist/utils/appearance.js

@@ -3,54 +3,15 @@
 // properties onto `document.documentElement`. Framework-free — a host
 // calls `applyAppearanceToDocument` from whatever state layer it uses
 // (a settings store, a React effect, etc.).
-const ACCENT_VARS = [
-    '--accent',
-    '--accent-strong',
-    '--accent-soft',
-    '--accent-tint',
-    '--accent-hover',
-];
-/** Neutral default accent — hosts are expected to override via their own
- *  config/branding; this only guarantees the CSS vars are always set. */
-export const DEFAULT_ACCENT_COLOR = '#2563eb';
-export const ACCENT_SWATCHES = [
-    DEFAULT_ACCENT_COLOR,
-    '#c96442',
-    '#7c3aed',
-    '#059669',
-    '#dc2626',
-    '#d97706',
-    '#0891b2',
-    '#db2777',
-];
-/**
- * Validate and lowercase a `#rrggbb` accent color string.
- *
- * @param value - Candidate accent color, typically from persisted config.
- * @returns The lowercased 6-digit hex string, or `null` if `value` is not a
- *   string or does not match `#rrggbb`.
- * @complexity O(1).
- */
-export function normalizeAccentColor(value) {
-    if (typeof value !== 'string')
-        return null;
-    const trimmed = value.trim();
-    return /^#[0-9a-fA-F]{6}$/.test(trimmed) ? trimmed.toLowerCase() : null;
-}
-/** `normalizeAccentColor(value) ?? DEFAULT_ACCENT_COLOR` — always returns a
- *  usable color. */
-export function resolveAccentColor(value) {
-    return normalizeAccentColor(value) ?? DEFAULT_ACCENT_COLOR;
-}
-function accentVars(accentColor) {
-    return {
-        '--accent': accentColor,
-        '--accent-strong': `color-mix(in srgb, ${accentColor} 86%, var(--text-strong))`,
-        '--accent-soft': `color-mix(in srgb, ${accentColor} 22%, var(--bg-panel))`,
-        '--accent-tint': `color-mix(in srgb, ${accentColor} 12%, var(--bg-panel))`,
-        '--accent-hover': `color-mix(in srgb, ${accentColor} 90%, var(--text-strong))`,
-    };
-}
+//
+// The accent-color validation and the color-mix formulas behind the five
+// `--accent*` values have no DOM dependency and live in
+// `features/appearance/{constants,rules}.ts` instead — re-exported below so
+// every existing importer of this module (including this package's own
+// public `index.ts`) keeps working unchanged.
+import { accentVars, resolveAccentColor } from '../features/appearance/rules.js';
+export { ACCENT_SWATCHES, DEFAULT_ACCENT_COLOR } from '../features/appearance/constants.js';
+export { normalizeAccentColor, resolveAccentColor } from '../features/appearance/rules.js';
 /**
  * Apply a theme + accent color to `document.documentElement`: sets/clears
  * `data-theme` and writes the five `--accent*` custom properties (using
@@ -69,9 +30,8 @@ export function applyAppearanceToDocument({ theme, accentColor, }) {
     else {
         root.removeAttribute('data-theme');
     }
-    const normalized = resolveAccentColor(accentColor);
-    const vars = accentVars(normalized);
-    for (const name of ACCENT_VARS) {
+    const vars = accentVars(resolveAccentColor(accentColor));
+    for (const name of Object.keys(vars)) {
         root.style.setProperty(name, vars[name]);
     }
 }

package/dist/utils/appearance.js.map

@@ -1 +1 @@
-{"version":3,"file":"appearance.js","sourceRoot":"","sources":["../../src/utils/appearance.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,mEAAmE;AACnE,sEAAsE;AACtE,sEAAsE;AACtE,4CAA4C;AAI5C,MAAM,WAAW,GAAG;IAClB,UAAU;IACV,iBAAiB;IACjB,eAAe;IACf,eAAe;IACf,gBAAgB;CACR,CAAC;AAEX;yEACyE;AACzE,MAAM,CAAC,MAAM,oBAAoB,GAAG,SAAS,CAAC;AAE9C,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,oBAAoB;IACpB,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;CACD,CAAC;AAEX;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC3C,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,OAAO,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAC1E,CAAC;AAED;oBACoB;AACpB,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,OAAO,oBAAoB,CAAC,KAAK,CAAC,IAAI,oBAAoB,CAAC;AAC7D,CAAC;AAED,SAAS,UAAU,CAAC,WAAmB;IACrC,OAAO;QACL,UAAU,EAAE,WAAW;QACvB,iBAAiB,EAAE,sBAAsB,WAAW,2BAA2B;QAC/E,eAAe,EAAE,sBAAsB,WAAW,wBAAwB;QAC1E,eAAe,EAAE,sBAAsB,WAAW,wBAAwB;QAC1E,gBAAgB,EAAE,sBAAsB,WAAW,2BAA2B;KAC/E,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,yBAAyB,CAAC,EACxC,KAAK,EACL,WAAW,GAIZ;IACC,MAAM,IAAI,GAAG,QAAQ,CAAC,eAAe,CAAC;IACtC,IAAI,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,MAAM,EAAE,CAAC;QAC1C,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;SAAM,CAAC;QACN,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;IACrC,CAAC;IAED,MAAM,UAAU,GAAG,kBAAkB,CAAC,WAAW,CAAC,CAAC;IACnD,MAAM,IAAI,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;IACpC,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;QAC/B,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3C,CAAC;AACH,CAAC"}
+{"version":3,"file":"appearance.js","sourceRoot":"","sources":["../../src/utils/appearance.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,mEAAmE;AACnE,sEAAsE;AACtE,sEAAsE;AACtE,4CAA4C;AAC5C,EAAE;AACF,yEAAyE;AACzE,wDAAwD;AACxD,4EAA4E;AAC5E,uEAAuE;AACvE,8CAA8C;AAE9C,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAK3F;;;;;;;;;GASG;AACH,MAAM,UAAU,yBAAyB,CAAC,EACxC,KAAK,EACL,WAAW,GAIZ;IACC,MAAM,IAAI,GAAG,QAAQ,CAAC,eAAe,CAAC;IACtC,IAAI,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,MAAM,EAAE,CAAC;QAC1C,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;SAAM,CAAC;QACN,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;IACrC,CAAC;IAED,MAAM,IAAI,GAAG,UAAU,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC,CAAC;IACzD,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAA0B,EAAE,CAAC;QAC9D,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3C,CAAC;AACH,CAAC"}

package/dist/utils/endpoint-policy.d.ts

@@ -0,0 +1,65 @@
+/**
+ * One place that decides whether an operator-supplied endpoint URL is
+ * acceptable, shared by every tab that takes one.
+ *
+ * ## Why this is a copy rather than an import
+ *
+ * `@jini-ai/agent-runtime`'s `providers/connection-guard.ts` already implements
+ * this policy, and it stays the richer implementation: it adds
+ * `validateBaseUrlResolved`, which resolves DNS and re-checks every address the
+ * host would actually connect to, catching `internal.example.com -> 10.0.0.5`
+ * that no string inspection can. That function needs `node:dns`, and this file
+ * has ZERO imports of its own precisely so it can run in a browser bundle
+ * — the same reasoning `features/execution/types.ts` gives for mirroring that
+ * package's shapes instead of depending on it. Importing it here would pull a
+ * Node-only module into every host that renders a settings dialog.
+ *
+ * So the split is deliberate and layered, not accidental duplication:
+ *
+ * - **Here (sync, browser-safe):** scheme allow-list plus a literal-hostname
+ *   block-list. Runs in render logic, on every keystroke, in any runtime.
+ * - **`connection-guard.ts` (async, Node):** the same check plus DNS
+ *   resolution, run where a connection is actually attempted.
+ *
+ * The predicates below are ported from that file's synchronous half verbatim
+ * in behavior. **If one side's block-list changes, change the other.** A gap
+ * between them is a request the UI accepted and the runtime then refused, or
+ * worse, the reverse.
+ *
+ * That instruction is now enforced rather than merely written down:
+ * `__tests__/utils/endpoint-policy.parity.test.ts` runs both implementations
+ * over the cross-product of address forms and whitespace padding and fails on
+ * any disagreement. It exists because the sentence above was not enough — the
+ * two drifted on Unicode whitespace (this side trimmed, the other did not), and
+ * a hand-written 46-URL audit corpus rated them identical because it happened
+ * not to contain a padded case. A corpus only proves the axis it samples.
+ *
+ * ## What this is for
+ *
+ * These fields are BYOK-style base URLs: operator-supplied, persisted, and
+ * paired with a real API key that gets sent to whatever they name. Accepting
+ * `http://169.254.169.254/` there points a credentialed request at the cloud
+ * metadata service; RFC1918 and loopback-disguised forms are the same hazard
+ * pointed at internal infrastructure. A scheme check alone does not see any of
+ * it.
+ *
+ * Loopback is allowed on purpose — local model servers (Ollama and friends)
+ * are a first-class configuration, not an attack.
+ */
+/** True for `localhost`, `::1`, `127.0.0.0/8`, and their IPv4-mapped-IPv6 forms. Allowed — local model servers live here. */
+export declare function isLoopbackEndpointHost(hostname: string): boolean;
+/** True for RFC1918/link-local/CGNAT/multicast/unspecified/unique-local-IPv6 literals — private space a credentialed request must not be steered into. */
+export declare function isBlockedEndpointHost(hostname: string): boolean;
+/**
+ * Whether `raw` is an endpoint this UI will accept: an absolute `http(s)` URL
+ * whose literal hostname is not private address space.
+ *
+ * Blank is NOT valid here; callers decide whether blank is allowed (it is, for
+ * fixed-origin gateways that resolve their own endpoint, and for optional
+ * fields). A hostname that merely RESOLVES to private space still passes —
+ * catching that needs DNS, which is `connection-guard.ts`'s job at connection
+ * time. This is the cheap check that runs on every keystroke, not the last
+ * line of defense.
+ */
+export declare function isAllowedEndpointUrl(raw: string): boolean;
+//# sourceMappingURL=endpoint-policy.d.ts.map

package/dist/utils/endpoint-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-policy.d.ts","sourceRoot":"","sources":["../../src/utils/endpoint-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AA2DH,6HAA6H;AAC7H,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAMhE;AAED,0JAA0J;AAC1J,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAQ/D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAazD"}