@jini-ai/ui 0.4.7 → 0.4.8

package/dist/react/components/RemixIcon.stylesheet.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Marks whichever stylesheet is currently serving `.ri-*` glyphs — this package's own default, or
+ * a host override that got inserted first. `ensureRemixIconStylesheet` checks for this attribute
+ * (not a specific `href`) before injecting, so a host that wants its own icon set/font just needs
+ * to add a `<link data-jini-remixicon rel="stylesheet" href="...">` (or an equivalent `<style
+ * data-jini-remixicon>`) anywhere in `<head>` before the first `RemixIcon` mounts, and this
+ * package's default never loads.
+ *
+ * Exported because every host that has needed the override so far re-declared this string
+ * literally rather than importing it -- three copies outside this file, across two apps of the
+ * one downstream checkout inspected (2026-09-06), and they do not agree on element type: one
+ * installs a `<style>`, the other a `<link>`. A copied magic string is a rename away from
+ * silently double-loading the font; importing the constant is not.
+ */
+export declare const REMIXICON_STYLESHEET_MARKER = "data-jini-remixicon";
+/**
+ * Installs a caller-supplied stylesheet as the one serving `.ri-*` glyphs, claiming
+ * {@link REMIXICON_STYLESHEET_MARKER} so this package's own default never loads.
+ *
+ * This is the supported opt-in for any host whose bundler defeats the default's `import.meta.url`
+ * resolution (see {@link ensureRemixIconStylesheet}) — point it at
+ * `@jini-ai/ui/remixicon.css`, which is a normal subpath export a bundler resolves and rewrites
+ * like any other asset. Call it before the first `RemixIcon` mounts; module top level in the
+ * host's entry file is the usual place, since the default injection runs from a `useEffect` and
+ * therefore only has to lose a race against React's commit phase.
+ *
+ * Idempotent and safe to call unconditionally: it no-ops if any marked stylesheet is already
+ * present (including one a previous call installed), and no-ops outside a DOM.
+ *
+ * @param options.href URL of a stylesheet defining the `.ri-*` classes and its own `@font-face`.
+ *   Resolved by the browser against the document, so relative values follow the page's base URL —
+ *   pass a bundler-produced URL rather than a hand-written relative path.
+ * @returns `true` if this call inserted the stylesheet, `false` if it no-opped.
+ * @sideEffects Appends one `<link>` to `document.head`; probes and retries its icon font.
+ * @complexity O(n + r) including recovery, for n stylesheet rules and r bounded retries.
+ * @overallScore 100
+ */
+export declare function installRemixIconStylesheet(options: {
+    href: string;
+}, _optional?: object): boolean;
+/**
+ * Idempotently loads this package's default RemixIcon webfont/CSS on first use, so a host gets
+ * working icons out of the box with zero setup — see {@link REMIXICON_STYLESHEET_MARKER} for how a
+ * host overrides this and {@link installRemixIconStylesheet} for the supported way to do it.
+ *
+ * **This default only survives unbundled ESM, and that is not a fixable property of this
+ * function.** It resolves the CSS with `new URL('./remixicon-font/remixicon.css',
+ * import.meta.url)`, which is correct exactly while this module is still a real ES module sitting
+ * next to its own `remixicon-font/` directory. Three bundler transformations break it three
+ * different ways. The first two were confirmed live against this component; the third was
+ * confirmed live against its sibling, and is listed because nothing exempts this file from it:
+ *
+ * - **`iife`/`umd` output** cannot express the reference at all and degrades it to an inlined
+ *   `data:` URL whose own relative `@font-face` src can never resolve. Confirmed live in a
+ *   downstream `lib`/`iife` widget bundle, where `document.fonts` reported the `remixicon` face
+ *   as `status: "error"` with no matching resource entry at all — an unattempted fetch, not a
+ *   404. Detected and refused by {@link resolveDefaultStylesheetHref}.
+ * - **Production ESM builds** may copy the CSS as an opaque asset without descending into its
+ *   `url(./remixicon.woff2)`, emitting the stylesheet without the font beside it. Confirmed live
+ *   in a downstream admin SPA build, which is why that host imports the CSS through its
+ *   bundler's real CSS pipeline instead of letting this default run.
+ * - **Vite dev-server dependency pre-bundling** flattens a package module into a `.vite/deps/`
+ *   chunk, so an `import.meta.url`-relative URL resolves against the chunk's location instead.
+ *   Observed live for this package's `AgentIcon` (fixed in 58bf42fa by inlining those assets as
+ *   `data:` URIs — not an option here, see {@link installRemixIconStylesheet}), *not* observed
+ *   for this component, whose two known hosts both claim the marker before this default ever
+ *   runs. Worth knowing how it presented there: not as a 404, but as the dev server's SPA
+ *   history fallback answering `200 text/html`.
+ *
+ * A previous version of this comment claimed "Vite/Rollup/webpack all rewrite this correctly at
+ * build time". They do not, and each downstream host that hit it rediscovered a different half
+ * of the above independently. There is no runtime-resolvable URL that survives all of it — the
+ * cannot know where, or whether, its sibling asset was emitted — so the honest contract is: the
+ * default is a convenience for unbundled ESM, and any bundled host should call
+ * {@link installRemixIconStylesheet} instead. This function's job is to make that failure *loud*
+ * rather than silent, since tofu glyphs give no clue where to look.
+ *
+ * @sideEffects Appends at most one `<link>` to `document.head`; may emit one `console.warn`.
+ *   Probes and retries the installed font, including a host-provided marked override.
+ * @complexity O(n + r) including recovery, for n stylesheet rules and r bounded retries.
+ * @overallScore 100
+ */
+export declare function ensureRemixIconStylesheet(_input: object, _optional?: object): void;
+//# sourceMappingURL=RemixIcon.stylesheet.d.ts.map

package/dist/react/components/RemixIcon.stylesheet.js

@@ -0,0 +1,208 @@
+import { startRemixIconStylesheetRecovery } from './remixicon-font-recovery.js';
+/** Start once per installed sheet, waiting for linked CSS before inspecting its font source. */
+function recoverFont({ stylesheet }) {
+    if (!document.fonts || typeof FontFace === 'undefined')
+        return;
+    if (stylesheet.tagName !== 'STYLE' && stylesheet.tagName !== 'LINK')
+        return;
+    const sheet = stylesheet;
+    const start = () => startRemixIconStylesheetRecovery({
+        stylesheet: sheet,
+        fonts: document.fonts,
+        baseUrl: document.baseURI,
+        createFontFace: ({ family, source, descriptors }) => new FontFace(family, source, descriptors),
+        timers: {
+            setTimeout: (run, delay) => globalThis.setTimeout(run, delay),
+            clearTimeout: (handle) => globalThis.clearTimeout(handle),
+        },
+    });
+    if (sheet.sheet) {
+        start();
+        return;
+    }
+    sheet.addEventListener('load', start, { once: true });
+}
+/**
+ * Marks whichever stylesheet is currently serving `.ri-*` glyphs — this package's own default, or
+ * a host override that got inserted first. `ensureRemixIconStylesheet` checks for this attribute
+ * (not a specific `href`) before injecting, so a host that wants its own icon set/font just needs
+ * to add a `<link data-jini-remixicon rel="stylesheet" href="...">` (or an equivalent `<style
+ * data-jini-remixicon>`) anywhere in `<head>` before the first `RemixIcon` mounts, and this
+ * package's default never loads.
+ *
+ * Exported because every host that has needed the override so far re-declared this string
+ * literally rather than importing it -- three copies outside this file, across two apps of the
+ * one downstream checkout inspected (2026-09-06), and they do not agree on element type: one
+ * installs a `<style>`, the other a `<link>`. A copied magic string is a rename away from
+ * silently double-loading the font; importing the constant is not.
+ */
+export const REMIXICON_STYLESHEET_MARKER = 'data-jini-remixicon';
+let injected = false;
+let warned = false;
+/**
+ * One diagnostic per page load, not one per `RemixIcon` mount — the failure this reports is a
+ * build/bundler property, so it is the same failure every time and a per-mount warning would bury
+ * the rest of the console under it.
+ *
+ * @complexity O(1) time, O(1) space.
+ * @overallScore 100
+ */
+function warnOnce(message) {
+    if (warned)
+        return;
+    warned = true;
+    console.warn(`[@jini-ai/ui] RemixIcon: ${message}`);
+}
+const OPT_IN_HINT = 'Import the stylesheet yourself and install it via ' +
+    "`installRemixIconStylesheet({ href })` — the subpath export `@jini-ai/ui/remixicon.css` " +
+    'resolves through your bundler normally, unlike this runtime default.';
+/**
+ * Installs a caller-supplied stylesheet as the one serving `.ri-*` glyphs, claiming
+ * {@link REMIXICON_STYLESHEET_MARKER} so this package's own default never loads.
+ *
+ * This is the supported opt-in for any host whose bundler defeats the default's `import.meta.url`
+ * resolution (see {@link ensureRemixIconStylesheet}) — point it at
+ * `@jini-ai/ui/remixicon.css`, which is a normal subpath export a bundler resolves and rewrites
+ * like any other asset. Call it before the first `RemixIcon` mounts; module top level in the
+ * host's entry file is the usual place, since the default injection runs from a `useEffect` and
+ * therefore only has to lose a race against React's commit phase.
+ *
+ * Idempotent and safe to call unconditionally: it no-ops if any marked stylesheet is already
+ * present (including one a previous call installed), and no-ops outside a DOM.
+ *
+ * @param options.href URL of a stylesheet defining the `.ri-*` classes and its own `@font-face`.
+ *   Resolved by the browser against the document, so relative values follow the page's base URL —
+ *   pass a bundler-produced URL rather than a hand-written relative path.
+ * @returns `true` if this call inserted the stylesheet, `false` if it no-opped.
+ * @sideEffects Appends one `<link>` to `document.head`; probes and retries its icon font.
+ * @complexity O(n + r) including recovery, for n stylesheet rules and r bounded retries.
+ * @overallScore 100
+ */
+export function installRemixIconStylesheet(options, _optional = {}) {
+    if (typeof document === 'undefined')
+        return false;
+    const existing = document.querySelector(`[${REMIXICON_STYLESHEET_MARKER}]`);
+    if (existing) {
+        if (!injected)
+            recoverFont({ stylesheet: existing });
+        injected = true;
+        return false;
+    }
+    const link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.setAttribute(REMIXICON_STYLESHEET_MARKER, '');
+    link.href = options.href;
+    recoverFont({ stylesheet: link });
+    document.head.appendChild(link);
+    injected = true;
+    return true;
+}
+/**
+ * Resolves this package's bundled RemixIcon CSS relative to its own module URL, or `null` when
+ * that resolution has provably produced something unusable.
+ *
+ * The `null` case is not hypothetical. Bundling a `new URL(..., import.meta.url)` asset reference
+ * into a non-ESM output (Vite/Rollup `iife`, for one) makes Rollup inline the referenced file as a
+ * `data:text/css;base64,...` href instead. That stylesheet then loads, but its own
+ * `@font-face { src: url("./remixicon.woff2") }` is relative and a `data:` URL has no location to
+ * be relative *to*, so the font request is never even attempted and every glyph renders as tofu.
+ * Injecting it is strictly worse than injecting nothing, because it also claims
+ * {@link REMIXICON_STYLESHEET_MARKER} and so suppresses any override installed later.
+ *
+ * @returns An absolute URL string, or `null` if resolution failed or yielded a `data:`/`blob:` URL.
+ * @complexity O(1) time, O(1) space.
+ * @overallScore 100
+ */
+function resolveDefaultStylesheetHref() {
+    let resolved;
+    try {
+        resolved = new URL('./remixicon-font/remixicon.css', import.meta.url);
+    }
+    catch {
+        return null;
+    }
+    if (resolved.protocol === 'data:' || resolved.protocol === 'blob:')
+        return null;
+    return resolved.href;
+}
+/**
+ * Idempotently loads this package's default RemixIcon webfont/CSS on first use, so a host gets
+ * working icons out of the box with zero setup — see {@link REMIXICON_STYLESHEET_MARKER} for how a
+ * host overrides this and {@link installRemixIconStylesheet} for the supported way to do it.
+ *
+ * **This default only survives unbundled ESM, and that is not a fixable property of this
+ * function.** It resolves the CSS with `new URL('./remixicon-font/remixicon.css',
+ * import.meta.url)`, which is correct exactly while this module is still a real ES module sitting
+ * next to its own `remixicon-font/` directory. Three bundler transformations break it three
+ * different ways. The first two were confirmed live against this component; the third was
+ * confirmed live against its sibling, and is listed because nothing exempts this file from it:
+ *
+ * - **`iife`/`umd` output** cannot express the reference at all and degrades it to an inlined
+ *   `data:` URL whose own relative `@font-face` src can never resolve. Confirmed live in a
+ *   downstream `lib`/`iife` widget bundle, where `document.fonts` reported the `remixicon` face
+ *   as `status: "error"` with no matching resource entry at all — an unattempted fetch, not a
+ *   404. Detected and refused by {@link resolveDefaultStylesheetHref}.
+ * - **Production ESM builds** may copy the CSS as an opaque asset without descending into its
+ *   `url(./remixicon.woff2)`, emitting the stylesheet without the font beside it. Confirmed live
+ *   in a downstream admin SPA build, which is why that host imports the CSS through its
+ *   bundler's real CSS pipeline instead of letting this default run.
+ * - **Vite dev-server dependency pre-bundling** flattens a package module into a `.vite/deps/`
+ *   chunk, so an `import.meta.url`-relative URL resolves against the chunk's location instead.
+ *   Observed live for this package's `AgentIcon` (fixed in 58bf42fa by inlining those assets as
+ *   `data:` URIs — not an option here, see {@link installRemixIconStylesheet}), *not* observed
+ *   for this component, whose two known hosts both claim the marker before this default ever
+ *   runs. Worth knowing how it presented there: not as a 404, but as the dev server's SPA
+ *   history fallback answering `200 text/html`.
+ *
+ * A previous version of this comment claimed "Vite/Rollup/webpack all rewrite this correctly at
+ * build time". They do not, and each downstream host that hit it rediscovered a different half
+ * of the above independently. There is no runtime-resolvable URL that survives all of it — the
+ * cannot know where, or whether, its sibling asset was emitted — so the honest contract is: the
+ * default is a convenience for unbundled ESM, and any bundled host should call
+ * {@link installRemixIconStylesheet} instead. This function's job is to make that failure *loud*
+ * rather than silent, since tofu glyphs give no clue where to look.
+ *
+ * @sideEffects Appends at most one `<link>` to `document.head`; may emit one `console.warn`.
+ *   Probes and retries the installed font, including a host-provided marked override.
+ * @complexity O(n + r) including recovery, for n stylesheet rules and r bounded retries.
+ * @overallScore 100
+ */
+export function ensureRemixIconStylesheet(_input, _optional = {}) {
+    if (injected || typeof document === 'undefined')
+        return;
+    const existing = document.querySelector(`[${REMIXICON_STYLESHEET_MARKER}]`);
+    if (existing) {
+        recoverFont({ stylesheet: existing });
+        injected = true;
+        return;
+    }
+    const href = resolveDefaultStylesheetHref();
+    if (href === null) {
+        // Claiming the marker with a stylesheet that cannot work would block a later override, so
+        // stay out of the way entirely and let the host know why its icons are blank.
+        injected = true;
+        warnOnce(`this bundle defeated the default stylesheet's own URL resolution. ${OPT_IN_HINT}`);
+        return;
+    }
+    const link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.setAttribute(REMIXICON_STYLESHEET_MARKER, '');
+    link.href = href;
+    link.addEventListener('error', () => {
+        // The pre-bundling case above: undetectable synchronously, because the href looked perfectly
+        // well formed. Drop the dead <link> so it stops holding the marker hostage — a host can
+        // still recover by calling installRemixIconStylesheet — but leave `injected` set so a later
+        // mount does not re-request the same missing file.
+        //
+        // UNVERIFIED, and deliberately not relied on: whether this also fires for the `200 text/html`
+        // SPA-fallback shape that case actually takes. A stylesheet served as `text/html` is refused
+        // under strict MIME checking, which is specified to fire `error` — but that has not been
+        // exercised here, so treat the warning as a bonus in that shape, not a guarantee.
+        link.remove();
+        warnOnce(`the default stylesheet failed to load from ${href}. ${OPT_IN_HINT}`);
+    });
+    recoverFont({ stylesheet: link });
+    document.head.appendChild(link);
+    injected = true;
+}
+//# sourceMappingURL=RemixIcon.stylesheet.js.map

package/dist/react/components/remixicon-font-recovery.d.ts

@@ -0,0 +1,55 @@
+/** Native font/timer ports keep retries testable without module mocks or a real clock. */
+export interface RemixIconFontSet {
+    load(font: string, text?: string): Promise<FontFace[]>;
+    check(font: string, text?: string): boolean;
+    add(face: FontFace): void;
+}
+export interface FontRetryTimers {
+    setTimeout(run: () => void, delay: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+interface RecoveryInput {
+    fonts: RemixIconFontSet;
+    timers: FontRetryTimers;
+    createFace(input: {
+        attempt: number;
+    }): Pick<FontFace, 'load'>;
+}
+/**
+ * Probe the existing icon face once, then retry with fresh faces after bounded backoff.
+ * A failed FontFace retains its rejected load promise, so loading that same face again cannot
+ * recover. Adding the loaded replacement to the set makes existing icons repaint automatically.
+ * Network/parse failures are consumed; exhaustion leaves the existing fallback in place.
+ * @param input Explicit font set, fresh-face factory, and timer ports.
+ * @param options Backoff delays in milliseconds, defaulting to 1s, 3s, 10s.
+ * @returns Dispose function cancelling pending work and suppressing late font registration.
+ * @complexity O(r) attempts and O(1) working space, where r is the supplied retry count.
+ * @example startRemixIconFontRecovery({ fonts, timers, createFace });
+ */
+export declare function startRemixIconFontRecovery({ fonts, timers, createFace }: RecoveryInput, { retryDelays }?: {
+    retryDelays?: readonly number[];
+}): () => void;
+interface StylesheetRecoveryInput {
+    stylesheet: HTMLStyleElement | HTMLLinkElement;
+    fonts: RemixIconFontSet;
+    timers: FontRetryTimers;
+    baseUrl: string;
+    createFontFace(input: {
+        family: string;
+        source: string;
+        descriptors: FontFaceDescriptors;
+    }): FontFace;
+}
+/**
+ * Recover this package's single WOFF2 face using the owning stylesheet's resolved URL.
+ * CSSOM, rather than a bundled-module URL, preserves host asset rewriting and linked CSS bases.
+ * Cross-origin inaccessible sheets and overrides without our face are left to their owner.
+ * @returns Retry disposer, or a no-op when this sheet does not expose the RemixIcon face.
+ * @complexity O(n + r), where n is the owning sheet's rule count and r is the retry count.
+ * @example startRemixIconStylesheetRecovery({ stylesheet, fonts, timers, baseUrl, createFontFace });
+ */
+export declare function startRemixIconStylesheetRecovery({ stylesheet, fonts, timers, baseUrl, createFontFace }: StylesheetRecoveryInput, options?: {
+    retryDelays?: readonly number[];
+}): () => void;
+export {};
+//# sourceMappingURL=remixicon-font-recovery.d.ts.map

package/dist/react/components/remixicon-font-recovery.js

@@ -0,0 +1,110 @@
+const FONT = '16px "remixicon"';
+// Use a real private-use glyph: FontFaceSet.check alone also returns true for absent fonts.
+const GLYPH = '\uea01';
+/**
+ * Probe the existing icon face once, then retry with fresh faces after bounded backoff.
+ * A failed FontFace retains its rejected load promise, so loading that same face again cannot
+ * recover. Adding the loaded replacement to the set makes existing icons repaint automatically.
+ * Network/parse failures are consumed; exhaustion leaves the existing fallback in place.
+ * @param input Explicit font set, fresh-face factory, and timer ports.
+ * @param options Backoff delays in milliseconds, defaulting to 1s, 3s, 10s.
+ * @returns Dispose function cancelling pending work and suppressing late font registration.
+ * @complexity O(r) attempts and O(1) working space, where r is the supplied retry count.
+ * @example startRemixIconFontRecovery({ fonts, timers, createFace });
+ */
+export function startRemixIconFontRecovery({ fonts, timers, createFace }, { retryDelays = [1000, 3000, 10000] } = {}) {
+    let stopped = false;
+    let attempt = 0;
+    let pending;
+    function scheduleRetry() {
+        if (stopped)
+            return;
+        const delay = retryDelays[attempt];
+        if (delay === undefined) {
+            stopped = true;
+            return;
+        }
+        pending = timers.setTimeout(() => {
+            pending = undefined;
+            void retry();
+        }, delay);
+    }
+    async function retry() {
+        if (stopped)
+            return;
+        attempt++;
+        try {
+            const face = await createFace({ attempt }).load();
+            if (stopped)
+                return;
+            fonts.add(face);
+            stopped = true;
+        }
+        catch {
+            scheduleRetry();
+        }
+    }
+    async function probe() {
+        try {
+            const faces = await fonts.load(FONT, GLYPH);
+            if (stopped)
+                return;
+            if (faces.length > 0 && fonts.check(FONT, GLYPH)) {
+                stopped = true;
+                return;
+            }
+            scheduleRetry();
+        }
+        catch {
+            scheduleRetry();
+        }
+    }
+    void probe();
+    return () => {
+        stopped = true;
+        if (pending !== undefined)
+            timers.clearTimeout(pending);
+    };
+}
+/**
+ * Recover this package's single WOFF2 face using the owning stylesheet's resolved URL.
+ * CSSOM, rather than a bundled-module URL, preserves host asset rewriting and linked CSS bases.
+ * Cross-origin inaccessible sheets and overrides without our face are left to their owner.
+ * @returns Retry disposer, or a no-op when this sheet does not expose the RemixIcon face.
+ * @complexity O(n + r), where n is the owning sheet's rule count and r is the retry count.
+ * @example startRemixIconStylesheetRecovery({ stylesheet, fonts, timers, baseUrl, createFontFace });
+ */
+export function startRemixIconStylesheetRecovery({ stylesheet, fonts, timers, baseUrl, createFontFace }, options = {}) {
+    let rules;
+    try {
+        rules = stylesheet.sheet?.cssRules;
+    }
+    catch {
+        return () => { };
+    }
+    if (!rules)
+        return () => { };
+    for (const rule of Array.from(rules)) {
+        if (rule.type !== 5)
+            continue; // CSSRule.FONT_FACE_RULE (no global constructor in SSR/fakes).
+        const style = rule.style;
+        const family = style.getPropertyValue('font-family').replace(/["']/g, '').trim();
+        if (family !== 'remixicon')
+            continue;
+        // This package owns one url(...) WOFF2 source, not a general CSS font-source parser.
+        const source = style.getPropertyValue('src').match(/url\(\s*["']?([^"')]+)["']?\s*\)/)?.[1];
+        if (!source)
+            return () => { };
+        const url = new URL(source.trim(), stylesheet.sheet?.href ?? baseUrl);
+        return startRemixIconFontRecovery({ fonts, timers, createFace({ attempt }) {
+                // A distinct URL also bypasses the browser's cached failed font resource after a restart.
+                const freshUrl = new URL(url.href);
+                if (freshUrl.protocol === 'http:' || freshUrl.protocol === 'https:') {
+                    freshUrl.searchParams.set('jini-font-retry', String(attempt));
+                }
+                return createFontFace({ family: 'remixicon', source: `url("${freshUrl.href}") format("woff2")`, descriptors: { display: 'swap' } });
+            } }, options);
+    }
+    return () => { };
+}
+//# sourceMappingURL=remixicon-font-recovery.js.map

package/dist/styles/admin.css

@@ -188,6 +188,12 @@
 }
 
 .info-tip { position: relative; display: inline-flex; margin-left: 0.35rem; vertical-align: middle; }
+/* In a wrapping label row, inline help takes a full row and pushes fields down safely. */
+.info-tip.info-tip--inline { display: contents; }
+.info-tip-inline-copy {
+  flex-basis: 100%; font-size: var(--jini-font-size-xs, 12px); font-weight: 400;
+  line-height: 1.5; color: var(--jini-text-muted); overflow-wrap: anywhere;
+}
 .info-tip-icon {
   display: inline-flex; align-items: center; justify-content: center;
   width: 1.1rem; height: 1.1rem; border-radius: 50%; color: var(--jini-text-disabled);
@@ -197,14 +203,14 @@
 .info-tip-icon:focus-visible { outline: 2px solid var(--jini-accent); outline-offset: 2px; border-radius: 50%; }
 .info-tip-bubble {
   position: fixed; transform: translate(-50%, calc(-100% - 8px));
-  width: max-content; max-width: 18rem; padding: 0.55rem 0.75rem; border-radius: var(--jini-radius-sm);
+  width: max-content; max-width: min(18rem, calc(100vw - 16px)); padding: 0.55rem 0.75rem; border-radius: var(--jini-radius-sm);
   background: var(--jini-bg-panel); color: var(--jini-text); font-size: 0.78rem; font-weight: 400;
   line-height: 1.4; letter-spacing: normal; text-transform: none;
   box-shadow: 0 4px 16px var(--jini-backdrop); border: 1px solid var(--jini-border);
   pointer-events: none; z-index: 1000;
 }
 .info-tip-bubble::after {
-  content: ""; position: absolute; top: 100%; left: 50%; transform: translateX(-50%);
+  content: ""; position: absolute; top: 100%; left: var(--info-tip-arrow-left, 50%); transform: translateX(-50%);
   border: 5px solid transparent; border-top-color: var(--jini-bg-panel);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/ui",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "description": "Generic, product-neutral React UI primitives and feature domains. Framework-free types, decision rules, catalogs, and host port contracts live behind ./core (no React, no DOM). The Excalidraw and Lexical editors live behind ./sketch-editor and ./lexical-rich-text-editor; the GrapesJS-backed inline HTML editor lives behind ./html-editor.",
   "license": "Apache-2.0",
   "repository": {
@@ -210,14 +210,16 @@
     "shiki": "^1.24.4",
     "tailwind-merge": "^2.6.0",
     "zod": "^3.25.76",
-    "@jini-ai/platform": "^0.5.2",
-    "@jini-ai/core": "^0.4.2",
-    "@jini-ai/agentic": "^0.4.3"
+    "@jini-ai/integrations": "^0.4.2",
+    "@jini-ai/platform": "^0.5.3",
+    "@jini-ai/core": "^0.4.3",
+    "@jini-ai/agentic": "^0.4.4"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.2"
+    "@jini-ai/core": "^0.4.3"
   },
   "peerDependencies": {
+    "@jini-ai/integrations": "^0.4.2",
     "@tanstack/react-query": "^5.0.0",
     "@excalidraw/excalidraw": "0.18.1",
     "@lexical/react": "0.36.2",
@@ -233,8 +235,8 @@
     "react": "^18.3.0 || ^19.0.0",
     "react-dom": "^18.3.0 || ^19.0.0",
     "recharts": "^3.10.1",
-    "@jini-ai/platform": "^0.5.1",
-    "@jini-ai/agentic": "^0.4.2",
+    "@jini-ai/platform": "^0.5.3",
+    "@jini-ai/agentic": "^0.4.4",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "micromark": "^4.0.0",
@@ -245,6 +247,9 @@
     "zod": "^3.25.76"
   },
   "peerDependenciesMeta": {
+    "@jini-ai/integrations": {
+      "optional": true
+    },
     "@tanstack/react-query": {
       "optional": true
     },

package/dist/features/panel-kit/fetch-query/cache.d.ts

@@ -1,125 +0,0 @@
-import type { Clock } from '@jini-ai/core/primitives';
-import type { QueryKey } from './types.js';
-/**
- * Ten seconds covers reading, closing and reopening a record or bouncing between screens
- * without paying for another identical request. Five seconds was too short for that read
- * cycle; thirty seconds exposed more other-operator staleness than the conservative initial
- * shared default should allow. There is no default polling/focus refresh, so this bounds
- * the extra exposure on a quick revisit. Write invalidation bypasses freshness; reads that
- * must be fresh on every mount can choose staleTime: 0 without lowering every query default.
- */
-export declare const DEFAULT_STALE_TIME = 10000;
-/** Minimum time an unobserved entry is kept; both adapters retain max(this, staleTime). */
-export declare const IDLE_RETENTION: number;
-export interface QueryCacheSchedulerPort {
-    schedule(required: {
-        callback: () => void;
-        delayMs: number;
-    }): unknown;
-    cancel(required: {
-        handle: unknown;
-    }): void;
-}
-/** Host connectivity and focus signals; the cache itself has no DOM dependency. */
-export interface FetchQueryEnvironmentPort {
-    isOnline(): boolean;
-    subscribeOnline(required: {
-        listener: (online: boolean) => void;
-    }): () => void;
-    subscribeFocus(required: {
-        listener: () => void;
-    }): () => void;
-}
-export interface FetchQueryCacheOptions {
-    clock?: Clock;
-    scheduler?: QueryCacheSchedulerPort;
-    environment?: FetchQueryEnvironmentPort;
-}
-export interface QueryState {
-    data: unknown;
-    error: Error | null;
-    status: 'pending' | 'success' | 'error';
-    isFetching: boolean;
-}
-export interface QueryObserver {
-    fetch: () => Promise<unknown>;
-    staleTime: number;
-    focus: boolean;
-}
-export interface CacheEntry {
-    key: QueryKey;
-    state: QueryState;
-    updatedAt: number;
-    invalidated: boolean;
-    replacement: number;
-    pending: Promise<unknown> | undefined;
-    refreshAfterPending: boolean;
-    listeners: Set<() => void>;
-    observers: Set<QueryObserver>;
-    retention: number;
-    eviction: unknown;
-}
-export declare function toQueryError(value: unknown): Error;
-/** One provider-owned cache. Requests are shared by structural primitive keys.
- * Failed reads retain earlier data; replacement writes supersede older requests.
- * Idle entries live for at least five minutes or their declared freshness period. */
-export declare class FetchQueryCache {
-    private readonly entries;
-    private disposed;
-    private readonly clock;
-    private readonly scheduler;
-    private readonly environment;
-    private online;
-    private readonly onlineWaiters;
-    private releaseEnvironment;
-    constructor(_required?: Record<string, never>, { clock, scheduler, environment }?: FetchQueryCacheOptions);
-    entry({ key }: {
-        key: QueryKey;
-    }, { staleTime }?: {
-        staleTime?: number;
-    }): CacheEntry;
-    fresh({ entry, staleTime }: {
-        entry: CacheEntry;
-        staleTime: number;
-    }): boolean;
-    subscribe({ entry, listener }: {
-        entry: CacheEntry;
-        listener: () => void;
-    }): () => void;
-    observe({ entry, observer }: {
-        entry: CacheEntry;
-        observer: QueryObserver;
-    }): () => void;
-    /** Cache hits respect freshness; explicit refreshes restart background reads.
-     * Initial reads still deduplicate because no earlier successful data exists to refresh. */
-    load<T>({ entry, fetch, staleTime }: {
-        entry: CacheEntry;
-        fetch: () => Promise<T>;
-        staleTime: number;
-    }, { force }?: {
-        force?: boolean;
-    }): Promise<T>;
-    replace({ entry, data }: {
-        entry: CacheEntry;
-        data: unknown;
-    }): void;
-    invalidate({ prefix }: {
-        prefix: QueryKey;
-    }): void;
-    onFocus(): void;
-    /** Execute a read/write once connectivity returns; failures are not retried.
-     * @param required.run Operation to invoke online.
-     * @returns The operation's original result or rejection. */
-    runOnline<T>({ run }: {
-        run: () => Promise<T>;
-    }): Promise<T>;
-    /** Stop timers on provider disposal; reactivate for React's effect replay. */
-    activate(): void;
-    dispose(): void;
-    private onOnline;
-    private refresh;
-    private publish;
-    private cancelEviction;
-    private scheduleEviction;
-}
-//# sourceMappingURL=cache.d.ts.map