@jini-ai/ui 0.4.7 → 0.4.9

package/dist/features/panel-kit/fetch-query/adapter.tanstack.js

@@ -2,7 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 /** Optional TanStack translation layer. No library types escape the fetch-query contract. */
 import { createContext, useCallback, useContext, useEffect, useMemo, useSyncExternalStore } from 'react';
 import { isCancelledError, QueryClient, QueryClientProvider, useMutation, useQuery } from '@tanstack/react-query';
-import { DEFAULT_STALE_TIME, FetchQueryCache, IDLE_RETENTION, toQueryError } from './cache.js';
+import { DEFAULT_STALE_TIME, FetchQueryCache, IDLE_RETENTION, toQueryError } from '@jini-ai/core/fetch';
 import { browserFetchQueryEnvironment } from './environment.browser.js';
 import { resolveFetchQueryError, resolveFetchQueryStatus } from './adapter.react.js';
 import { FetchQueryBinding } from './binding.react.js';
@@ -106,13 +106,14 @@ function useFetchQuery({ key, fetch }, { enabled = true, staleTime = DEFAULT_STA
     const { refetch: refresh } = query;
     const refetch = useCallback(() => {
         if (scope.environment.isOnline()) {
+            supersedeInitialRead({ scope, key });
             void refresh();
             return;
         }
         // Reconnect may already have started a fetch (re-enabled observer or provider refetch);
         // that request postdates this one, so join it instead of cancelling it into a duplicate.
         void scope.gate.runOnline({ run: () => refresh({ cancelRefetch: false }) });
-    }, [scope, refresh]);
+    }, [scope, refresh, JSON.stringify(key)]);
     useEffect(() => {
         if (!enabled || !refetchOnWindowFocus)
             return;
@@ -143,7 +144,7 @@ function useFetchMutation({ run }, { invalidates } = {}) {
             // Do not await dependent reads: the mutation promise means the write succeeded,
             // not that every list finished reloading. Refetches proceed on their own schedule.
             for (const key of invalidates ?? [])
-                void scope.client.invalidateQueries({ queryKey: key });
+                invalidateResource({ scope, key });
         },
     }, scope.client);
     const { mutateAsync, reset } = mutation;
@@ -163,14 +164,21 @@ function useCachedLoader({ key, fetch }, { staleTime = DEFAULT_STALE_TIME } = {}
         const options = { queryKey: key, queryFn: () => read({ scope, key, fetch }), staleTime, gcTime: gcTimeFor({ staleTime }) };
         return {
             peek: () => scope.client.getQueryData(key),
-            load: () => scope.client.fetchQuery(options).catch(error => {
-                // A forced refresh can supersede a loader's request without aborting its transport.
-                // Follow the new request instead of exposing TanStack's cancellation vocabulary.
-                if (!isCancelledError(error))
-                    throw error;
-                const query = scope.client.getQueryCache().find({ queryKey: key, exact: true });
-                return (query.promise ?? scope.client.getQueryData(key));
-            }),
+            load: (required = { key, fetch }) => {
+                const selected = { ...options, queryKey: required.key, queryFn: () => read({ scope, key: required.key, fetch: required.fetch }) };
+                return scope.client.fetchQuery(selected).catch(error => {
+                    // A forced refresh can supersede a loader's request without aborting its transport.
+                    // Follow the new request instead of exposing TanStack's cancellation vocabulary.
+                    if (!isCancelledError(error))
+                        throw error;
+                    // Invalidation also supersedes loader-only reads. Join (or start) the post-write
+                    // request rather than returning an obsolete value while the key is invalidated.
+                    const query = scope.client.getQueryCache().find({ queryKey: required.key, exact: true });
+                    if (query.state.isInvalidated)
+                        return scope.client.fetchQuery(selected);
+                    return (query.promise ?? scope.client.getQueryData(required.key));
+                });
+            },
             replace: ({ value }) => {
                 const query = scope.client.getQueryCache().build(scope.client, options);
                 const history = historyFor({ scope, query });
@@ -181,10 +189,24 @@ function useCachedLoader({ key, fetch }, { staleTime = DEFAULT_STALE_TIME } = {}
         };
     }, [scope, key, fetch, staleTime]);
 }
+/** A host write/refresh postdates the initial GET as well as a background GET. TanStack
+ * normally joins an initial fetch with no data, which would let that pre-write snapshot win.
+ * Cancel its cache ownership before requesting the replacement; transports need no abort API. */
+function supersedeInitialRead({ scope, key }, { exact = true } = {}) {
+    void scope.client.cancelQueries({ queryKey: key, exact, predicate: query => query.isActive() && query.state.data === undefined && query.state.fetchStatus === 'fetching' });
+}
+/** One invalidation path serves both imperative refreshes and accepted writes. */
+function invalidateResource({ scope, key }, _optional = {}) {
+    // A loader-only detail request may feed an active parent query. It is just as stale
+    // after a write as an observed read, even though TanStack considers it inactive.
+    // Silent cancellation follows the replacement promise instead of resolving old cached data.
+    void scope.client.cancelQueries({ queryKey: key, predicate: query => query.state.fetchStatus === 'fetching' }, { silent: true });
+    void scope.client.invalidateQueries({ queryKey: key });
+}
 /** Prefix invalidation also reaches child keys read by other mounted consumers. */
 function useInvalidate() {
-    const { client } = useScope();
-    return useCallback(({ key }) => { void client.invalidateQueries({ queryKey: key }); }, [client]);
+    const scope = useScope();
+    return useCallback(({ key }) => { invalidateResource({ scope, key }); }, [scope]);
 }
 const adapter = { useFetchQuery, useFetchMutation, useCachedLoader, useInvalidate };
 //# sourceMappingURL=adapter.tanstack.js.map

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

@@ -1,5 +1,5 @@
 import { type ReactNode } from 'react';
-import type { FetchQueryAdapter } from './types.js';
+import type { FetchQueryAdapter } from '@jini-ai/core/fetch';
 /** Internal composition seam: hooks and imperative loaders always use the same provider.
  * Keep the adapter fixed for this provider's lifetime to preserve React hook ordering. */
 export declare function FetchQueryBinding({ adapter, children }: {

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

@@ -1,4 +1,4 @@
-import type { FetchQueryEnvironmentPort } from './cache.js';
+import type { FetchQueryEnvironmentPort } from '@jini-ai/core/fetch';
 /** Browser-only adapter: subscriptions are owned by the provider effect, never module scope. */
 export declare const browserFetchQueryEnvironment: FetchQueryEnvironmentPort;
 //# sourceMappingURL=environment.browser.d.ts.map

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

@@ -1,5 +1,7 @@
 export { FetchQueryProvider } from './adapter.react.js';
 export { useFetchQuery, useFetchMutation, useCachedLoader, useInvalidate } from './binding.react.js';
-export type { FetchQueryEnvironmentPort } from './cache.js';
-export type { QueryKey, QueryStatus, QueryResult, FetchQueryOptions, MutationStatus, MutationResult, FetchMutationOptions, CachedLoaderOptions, CachedLoader, FetchQueryAdapter } from './types.js';
+/** @deprecated Import the framework-neutral environment port from @jini-ai/core/fetch. */
+export type { FetchQueryEnvironmentPort } from '@jini-ai/core/fetch';
+/** @deprecated Import framework-neutral query contracts from @jini-ai/core/fetch. */
+export type { QueryKey, QueryStatus, QueryResult, FetchQueryOptions, MutationStatus, MutationResult, FetchMutationOptions, CachedLoaderOptions, CachedLoader, FetchQueryAdapter } from '@jini-ai/core/fetch';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,6 +1,8 @@
 /** Optional adapter entry. Importing the default entry never loads TanStack. */
 export { FetchQueryProvider } from './adapter.tanstack.js';
 export { useFetchQuery, useFetchMutation, useCachedLoader, useInvalidate } from './binding.react.js';
-export type { FetchQueryEnvironmentPort } from './cache.js';
-export type { QueryKey, QueryStatus, QueryResult, FetchQueryOptions, MutationStatus, MutationResult, FetchMutationOptions, CachedLoaderOptions, CachedLoader, FetchQueryAdapter } from './types.js';
+/** @deprecated Import the framework-neutral environment port from @jini-ai/core/fetch. */
+export type { FetchQueryEnvironmentPort } from '@jini-ai/core/fetch';
+/** @deprecated Import framework-neutral query contracts from @jini-ai/core/fetch. */
+export type { QueryKey, QueryStatus, QueryResult, FetchQueryOptions, MutationStatus, MutationResult, FetchMutationOptions, CachedLoaderOptions, CachedLoader, FetchQueryAdapter } from '@jini-ai/core/fetch';
 //# sourceMappingURL=tanstack.d.ts.map

package/dist/features/panel-kit/helpers/standing-draft-recovery-message.d.ts

@@ -4,5 +4,7 @@ export declare function standingDraftRecoveryMessage({ draft, t, serverUpdatedAt
     draft: StandingDraftAutosaveSnapshot;
     t: (key: string) => string;
     serverUpdatedAt?: string;
-}, _options?: {}): string;
+}, { formatSavedAt }?: {
+    formatSavedAt?: (iso: string) => string;
+}): string;
 //# sourceMappingURL=standing-draft-recovery-message.d.ts.map

package/dist/features/panel-kit/helpers/standing-draft-recovery-message.js

@@ -1,10 +1,17 @@
+import { formatTimestamp } from "./format-timestamp.js";
+/** The viewer's wall-clock time of the capture, `YYYY-MM-DD HH:MM`. The raw ISO string read as
+ *  "from 2026-10-11T19:26:00.665Z" in the restore banner (2026-10-11): UTC and milliseconds the
+ *  operator never thinks in. The draft was captured in this browser, so local time is the honest one. */
+function formatSavedAtLocal(iso) {
+    return formatTimestamp({ iso }, { timeZone: "local" });
+}
 /** Compare timestamps explicitly; restoration only changes the working copy, never the server. */
-export function standingDraftRecoveryMessage({ draft, t, serverUpdatedAt }, _options = {}) {
+export function standingDraftRecoveryMessage({ draft, t, serverUpdatedAt }, { formatSavedAt = formatSavedAtLocal } = {}) {
     const captured = Date.parse(draft.savedAt);
     const server = Date.parse(serverUpdatedAt ?? draft.serverUpdatedAt ?? "");
     const comparison = server > captured ? "Server content is newer."
         : server < captured ? "Local changes are newer."
             : server === captured ? "Both copies have the same timestamp." : "";
-    return `${t("Restore unsaved changes from")} ${draft.savedAt}${comparison ? ` · ${t(comparison)}` : ""}`;
+    return `${t("Restore unsaved changes from")} ${formatSavedAt(draft.savedAt)}${comparison ? ` · ${t(comparison)}` : ""}`;
 }
 //# sourceMappingURL=standing-draft-recovery-message.js.map

package/dist/features/settings/dialog/styles/settings-dialog.css

@@ -95,6 +95,8 @@
 }
 
 .jini-input {
+  min-height: var(--jini-control-h, 37px);
+  box-sizing: border-box;
   width: 100%;
   min-width: 0;
   padding: 8px 10px;
@@ -107,6 +109,17 @@
   transition: border-color 120ms var(--jini-ease-out), box-shadow 120ms var(--jini-ease-out);
 }
 
+/* Native selects share one affordance across execution settings and host forms. */
+select.jini-input {
+  appearance: none;
+  padding-right: 2rem;
+  cursor: pointer;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='6' viewBox='0 0 10 6'%3E%3Cpath d='M1 1l4 4 4-4' fill='none' stroke='%236b7280' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E");
+  background-repeat: no-repeat;
+  background-position: right 0.7rem center;
+  background-size: 10px 6px;
+}
+
 .jini-input:focus {
   outline: none;
   border-color: var(--jini-accent);
@@ -127,6 +140,8 @@
 .jini-settings-section .jini-btn,
 .jini-settings-section .jini-button,
 .jini-settings-section a.jini-button {
+  min-height: var(--jini-control-h, 37px);
+  box-sizing: border-box;
   display: inline-flex;
   align-items: center;
   justify-content: center;
@@ -394,6 +409,21 @@
 
    `align-items: start` so a field with a two-line hint (an invalid base URL) does not stretch its
    neighbour's input to match. */
+/* `ByokProviderForm`'s `collapseAdvanced`: Base URL + Max tokens behind one disclosure after Model. */
+.jini-byok-advanced > summary {
+  cursor: pointer;
+  width: max-content;
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--jini-text-muted);
+}
+.jini-byok-advanced > summary:hover { color: var(--jini-text-strong); }
+.jini-byok-advanced[open] > summary { margin-bottom: 12px; }
+
+/* `ByokProviderForm`'s `apiKeyActions`: the host's button row directly under the key input (Show
+   stays on the input's line). Wraps on a narrow card. */
+.jini-byok-key-actions { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin-top: 2px; }
+
 .jini-byok-field-row {
   display: flex;
   flex-wrap: wrap;
@@ -479,13 +509,25 @@
 
 /* Agent cards. The origin drew a responsive grid of selectable vendor cards;
    `auto-fill` keeps it one column inside a narrow settings panel and two or
-   more when the host gives the dialog room. */
+   more when the host gives the dialog room.
+
+   Settings grow inside the selected card's own column; top alignment keeps
+   its neighbour at its normal height. */
 .jini-agent-grid {
   display: grid;
+  align-items: start;
   grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
   gap: 10px;
 }
 
+/* "Show N not installed" — the uninstalled tail of the grid sits behind this toggle. */
+.jini-local-cli-more {
+  display: block;
+  width: auto;
+  align-self: flex-start;
+  margin: 10px 0;
+}
+
 .jini-agent-card {
   display: flex;
   flex-direction: column;
@@ -500,6 +542,7 @@
 }
 
 .jini-agent-card.is-selected {
+  grid-column: span 1;
   border-color: var(--jini-accent);
   box-shadow: 0 0 0 1px var(--jini-accent);
 }
@@ -532,30 +575,26 @@
 
 /* The whole card is the click target, not just the text at the top of it.
  *
- * `.jini-agent-grid` is a grid, so selecting one CLI stretches every card in
- * that row to match the expanded one — while `-select` keeps its natural
- * content height. The space the row-mate's expansion added was therefore
- * inert: clicking the lower two-thirds of a stretched-but-unselected card did
- * nothing, which reads as a broken card rather than as "aim higher".
+ * The select button owns the whole header, including its padding, when no
+ * other controls need that space.
  *
  * `:last-child` is load-bearing. A card renders its diagnostics, model config,
  * test result and path-repair actions as SIBLINGS after `-main`, and those
  * blocks contain their own buttons; growing `-main` unconditionally would push
  * them to the card's bottom edge, and a full-card overlay would swallow their
  * clicks outright. `-main:last-child` is true exactly when nothing rendered
- * after it — the unselected, no-diagnostics case this bug is about.
+ * after it — the no-diagnostics case this bug is about.
  *
- * `:not(.is-selected)` guards the padding move specifically: a SELECTED card
- * can render its Test button inside `-main`, and zeroing the padding there
- * would shove that button flush against the card edge. */
-.jini-agent-card:not(.is-selected) .jini-agent-card-main:last-child {
+ * Test stays in the selected card's header; settings follow `-main`, keeping
+ * both their controls and the header's Test button independently clickable. */
+.jini-agent-card .jini-agent-card-main:last-child {
   flex: 1 1 auto;
   /* Handed to the button below — left here it would ring the card in 12px of
      unclickable margin, a smaller version of the same bug. */
   padding: 0;
 }
 
-.jini-agent-card:not(.is-selected) .jini-agent-card-main:last-child > .jini-agent-card-select {
+.jini-agent-card .jini-agent-card-main:last-child > .jini-agent-card-select {
   /* The row is `align-items: flex-start` so the Test button never stretches;
      this opts the select button alone into filling the card. Its own
      `align-items: flex-start` keeps icon and text at the top — only the hit
@@ -605,15 +644,15 @@
   color: var(--jini-text);
 }
 
-.jini-agent-card-name-divider {
-  color: var(--jini-text-disabled);
-}
-
 .jini-agent-card-tagline {
   font-size: 12px;
   color: var(--jini-text-muted);
 }
 
+.jini-agent-card.is-selected .jini-agent-card-tagline:not(:empty)::before {
+  content: '·\00a0';
+}
+
 .jini-agent-card-badges {
   display: flex;
   flex-wrap: wrap;
@@ -657,14 +696,98 @@
   opacity: 0.7;
 }
 
-.jini-agent-card-config {
+/* Selection reads as the accent ring plus this check, never as a bigger card. */
+.jini-agent-card-check {
+  flex: 0 0 auto;
+  display: grid;
+  place-items: center;
+  width: 18px;
+  height: 18px;
+  margin-left: auto;
+  border-radius: 50%;
+  background: var(--jini-accent);
+  color: var(--jini-accent-ink);
+  font-size: 11px;
+  font-weight: 700;
+  line-height: 1;
+}
+
+/* Settings stay inside the selected card, with each label above its control
+   and the model's provenance sentence visible below the picker. */
+.jini-agent-settings {
   display: flex;
   flex-direction: column;
-  gap: 4px;
-  padding: 0 12px 12px;
+  gap: 8px;
+  padding: 10px 12px;
   border-top: 1px solid var(--jini-border);
-  margin-top: 2px;
-  padding-top: 10px;
+}
+
+.jini-agent-settings-row,
+.jini-agent-settings-tail {
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+  gap: 8px 16px;
+}
+
+.jini-agent-settings-tail {
+  gap: 8px 10px;
+}
+
+/* Wide enough for "Testing…", so starting a test never reflows its controls. */
+.jini-agent-settings-tail > .jini-agent-card-test {
+  min-width: 5.5rem;
+}
+
+.jini-agent-settings-field {
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+  gap: 4px;
+  min-width: 0;
+}
+
+.jini-agent-settings-label {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+
+.jini-agent-settings-field > .jini-field-label {
+  white-space: nowrap;
+}
+
+.jini-agent-settings .jini-searchable-select,
+.jini-agent-settings select.jini-input,
+.jini-agent-settings .jini-agent-settings-custom {
+  width: 100%;
+  min-width: 0;
+  max-width: none;
+}
+
+.jini-agent-settings-source {
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
+}
+
+.jini-agent-settings-source > .jini-agent-model-source {
+  margin-left: 0;
+  white-space: nowrap;
+}
+
+.jini-agent-settings .jini-agent-card-test-result {
+  padding: 0;
+}
+
+.jini-agent-settings .jini-agent-card-path-repair {
+  margin: 0;
+}
+
+.jini-agent-settings .jini-agent-cli-env {
+  margin: 0;
+  padding-top: 8px;
 }
 
 /* The source badge is load-bearing, not decoration: a built-in list can be
@@ -895,7 +1018,21 @@
   width: 100%;
 }
 
+/* Hosts may pass the input class to the wrapper; only the trigger paints the control. */
+.jini-select.jini-input {
+  padding: 0;
+  border: 0;
+  background: none;
+  box-shadow: none;
+  min-height: 0;
+}
+.jini-select.is-missing > .jini-select-trigger {
+  border-color: color-mix(in srgb, var(--jini-danger) 55%, var(--jini-border));
+}
+
 .jini-select-trigger {
+  min-height: var(--jini-control-h, 37px);
+  box-sizing: border-box;
   display: flex;
   align-items: center;
   justify-content: space-between;
@@ -912,6 +1049,17 @@
   cursor: pointer;
 }
 
+.jini-select-trigger:focus-visible {
+  outline: none;
+  border-color: var(--jini-accent);
+  box-shadow: 0 0 0 3px color-mix(in srgb, var(--jini-accent) 18%, transparent);
+}
+
+@media (max-width: 640px) {
+  .jini-input,
+  .jini-select-trigger { font-size: 16px; min-height: 40px; }
+}
+
 .jini-select-trigger:hover:not(:disabled) {
   border-color: var(--jini-border-strong);
 }

package/dist/features/tabbed-dialog/styles/tabbed-dialog.css

@@ -35,6 +35,10 @@
   border-radius: var(--jini-radius-lg);
   box-shadow: var(--jini-shadow-lg);
   overflow: hidden;
+  /* Layout follows the dialog's OWN width, not the viewport's: an inline settings page beside an
+     expanded nav and an open assistant dock is narrow on a wide screen, and a 375px modal is narrow
+     on any screen. See the `@container jini-tabbed-dialog` block at the end. */
+  container: jini-tabbed-dialog / inline-size;
 }
 
 /* Page (non-modal) variant: the shell renders without `onClose`, so it should
@@ -271,3 +275,90 @@
 .jini-tabbed-dialog-sidebar-toggle:focus-visible {
   opacity: 1;
 }
+
+/* ============================================================
+   Narrow dialog: the side nav becomes one top tab row
+   ============================================================
+   A 240px side nav inside a ~500px dialog left the form a thin column with
+   its controls spilling past the edge (Chat settings at 500px, Chrome check
+   2026-10-11). Below 600px of DIALOG width (a 40rem dialog, e.g. Sites
+   settings, keeps its desktop look) the nav turns into a horizontal,
+   swipeable tab row over a full-width panel. The collapse chevron has
+   nothing to reclaim there, so it hides, and a collapsed nav reappears as
+   the row: a narrow dialog never loses its tabs. Modal-only spacing skips
+   the inline (page) variant, whose host owns its page insets. */
+@container jini-tabbed-dialog (max-width: 600px) {
+  .jini-tabbed-dialog:not(.jini-tabbed-dialog--inline) .jini-tabbed-dialog-head {
+    padding: 20px 56px 8px 16px;
+  }
+
+  .jini-tabbed-dialog:not(.jini-tabbed-dialog--inline) .jini-tabbed-dialog-chrome {
+    top: 16px;
+    right: 16px;
+  }
+
+  .jini-tabbed-dialog:not(.jini-tabbed-dialog--inline) .jini-tabbed-dialog-head-line h2,
+  .jini-tabbed-dialog:not(.jini-tabbed-dialog--inline) .jini-tabbed-dialog-head h2 {
+    font-size: 22px;
+  }
+
+  .jini-tabbed-dialog-body,
+  .jini-tabbed-dialog-sidebar-collapsed .jini-tabbed-dialog-body {
+    grid-template-columns: minmax(0, 1fr);
+    grid-template-rows: auto minmax(0, 1fr);
+  }
+
+  .jini-tabbed-dialog-sidebar,
+  .jini-tabbed-dialog-sidebar-collapsed .jini-tabbed-dialog-sidebar {
+    display: flex;
+    flex-direction: row;
+    gap: 2px;
+    padding: 0 16px;
+    background: transparent;
+    border-right: 0;
+    box-shadow: inset 0 -1px 0 var(--jini-border);
+    overflow-x: auto;
+    overflow-y: hidden;
+    overscroll-behavior-x: contain;
+    scrollbar-width: none;
+  }
+
+  .jini-tabbed-dialog-sidebar::-webkit-scrollbar {
+    display: none;
+  }
+
+  .jini-tabbed-dialog-nav-item {
+    flex: 0 0 auto;
+    width: auto;
+    grid-template-columns: auto auto;
+    gap: 6px;
+    padding: 9px 10px;
+    border: 0;
+    border-bottom: 2px solid transparent;
+    border-radius: 0;
+    white-space: nowrap;
+  }
+
+  .jini-tabbed-dialog-nav-item:hover {
+    background: transparent;
+    color: var(--jini-text);
+  }
+
+  .jini-tabbed-dialog-nav-item.active,
+  .jini-tabbed-dialog-nav-item.active:hover {
+    background: transparent;
+    border-bottom-color: var(--jini-accent);
+  }
+
+  .jini-tabbed-dialog-nav-text small {
+    display: none;
+  }
+
+  .jini-tabbed-dialog-sidebar-toggle {
+    display: none;
+  }
+
+  .jini-tabbed-dialog:not(.jini-tabbed-dialog--inline) .jini-tabbed-dialog-content {
+    padding: 14px 16px 18px;
+  }
+}

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

@@ -1,50 +1,11 @@
 import type { CSSProperties } from 'react';
+export { installRemixIconStylesheet, REMIXICON_STYLESHEET_MARKER } from './RemixIcon.stylesheet.js';
 interface RemixIconProps {
     name: string;
     size?: number;
     className?: string;
     style?: CSSProperties;
 }
-/**
- * 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`.
- * @complexity O(1) time (one `querySelector` on an attribute selector), O(1) space.
- * @overallScore 100
- */
-export declare function installRemixIconStylesheet(options: {
-    href: string;
-}): boolean;
 /**
  * Thin wrapper around a RemixIcon webfont glyph (`ri-<name>`). Loads this package's own default
  * RemixIcon CSS/font the first time any `RemixIcon` mounts — see
@@ -52,5 +13,4 @@ export declare function installRemixIconStylesheet(options: {
  * {@link installRemixIconStylesheet} for what a bundled host should call instead.
  */
 export declare function RemixIcon({ name, size, className, style }: RemixIconProps): import("react").JSX.Element;
-export {};
 //# sourceMappingURL=RemixIcon.d.ts.map