@jini-ai/ui 0.4.6 → 0.4.8

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.6",
+  "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": {
@@ -32,6 +32,7 @@
       "./admin-widgets": "browser",
       "./panel-kit": "browser",
       "./fetch-query": "browser",
+      "./fetch-query/tanstack": "browser",
       "./tab-strip": "browser",
       "./admin-widgets.css": "browser",
       "./theme": "browser",
@@ -39,7 +40,8 @@
     },
     "isolation": {
       "entries": {
-        "./fetch-query": "panel-kit"
+        "./fetch-query": "panel-kit",
+        "./fetch-query/tanstack": "panel-kit"
       },
       "shared": [
         "src/theme/default.ts",
@@ -140,6 +142,11 @@
       "import": "./dist/features/panel-kit/fetch-query/index.js",
       "default": "./dist/features/panel-kit/fetch-query/index.js"
     },
+    "./fetch-query/tanstack": {
+      "types": "./dist/features/panel-kit/fetch-query/tanstack.d.ts",
+      "import": "./dist/features/panel-kit/fetch-query/tanstack.js",
+      "default": "./dist/features/panel-kit/fetch-query/tanstack.js"
+    },
     "./tab-strip": {
       "types": "./dist/features/tab-strip/index.d.ts",
       "import": "./dist/features/tab-strip/index.js",
@@ -171,6 +178,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "devDependencies": {
+    "@tanstack/react-query": "^5.0.0",
     "@excalidraw/excalidraw": "0.18.1",
     "@lexical/react": "0.36.2",
     "@lexical/utils": "0.36.2",
@@ -202,14 +210,17 @@
     "shiki": "^1.24.4",
     "tailwind-merge": "^2.6.0",
     "zod": "^3.25.76",
-    "@jini-ai/platform": "^0.5.2",
-    "@jini-ai/agentic": "^0.4.3",
-    "@jini-ai/core": "^0.4.2"
+    "@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",
     "@lexical/utils": "0.36.2",
@@ -224,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",
@@ -236,6 +247,12 @@
     "zod": "^3.25.76"
   },
   "peerDependenciesMeta": {
+    "@jini-ai/integrations": {
+      "optional": true
+    },
+    "@tanstack/react-query": {
+      "optional": true
+    },
     "@excalidraw/excalidraw": {
       "optional": true
     },

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

@@ -1,123 +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;
-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

package/dist/features/panel-kit/fetch-query/cache.js

@@ -1,231 +0,0 @@
-/**
- * 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 const DEFAULT_STALE_TIME = 10_000;
-const IDLE_RETENTION = 5 * 60_000;
-const browserScheduler = {
-    schedule: ({ callback, delayMs }) => setTimeout(callback, delayMs),
-    cancel: ({ handle }) => clearTimeout(handle),
-};
-// Normalize unknown promise rejections once so consumers receive Error without repeating
-// the same narrowing boilerplate at every read and write call site.
-export function toQueryError(value) {
-    return value instanceof Error ? value : new Error(typeof value === 'string' && value.trim() ? value : 'request failed');
-}
-/** 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 class FetchQueryCache {
-    entries = new Map();
-    disposed = false;
-    clock;
-    scheduler;
-    environment;
-    online;
-    onlineWaiters = new Set();
-    releaseEnvironment;
-    constructor(_required = {}, { clock = { nowMs: () => Date.now() }, scheduler = browserScheduler, environment } = {}) {
-        this.clock = clock;
-        this.scheduler = scheduler;
-        this.environment = environment;
-        this.online = environment?.isOnline() ?? true;
-    }
-    entry({ key }, { staleTime = DEFAULT_STALE_TIME } = {}) {
-        const hash = JSON.stringify(key);
-        let entry = this.entries.get(hash);
-        if (!entry) {
-            entry = {
-                key: [...key], state: { data: undefined, error: null, status: 'pending', isFetching: false },
-                updatedAt: 0, invalidated: false, replacement: 0, pending: undefined,
-                refreshAfterPending: false, listeners: new Set(), observers: new Set(),
-                retention: IDLE_RETENTION, eviction: undefined,
-            };
-            this.entries.set(hash, entry);
-        }
-        // An imperative load has no standing observer: idle eviction must not drop a value
-        // earlier than its declared freshness and unexpectedly force another network request.
-        entry.retention = Math.max(entry.retention, staleTime);
-        return entry;
-    }
-    fresh({ entry, staleTime }) {
-        return entry.state.data !== undefined && !entry.invalidated && this.clock.nowMs() - entry.updatedAt < staleTime;
-    }
-    subscribe({ entry, listener }) {
-        this.cancelEviction(entry);
-        entry.listeners.add(listener);
-        return () => { entry.listeners.delete(listener); this.scheduleEviction(entry); };
-    }
-    observe({ entry, observer }) {
-        entry.observers.add(observer);
-        return () => { entry.observers.delete(observer); this.scheduleEviction(entry); };
-    }
-    /** Cache hits respect freshness; explicit refreshes restart background reads.
-     * Initial reads still deduplicate because no earlier successful data exists to refresh. */
-    load({ entry, fetch, staleTime }, { force = false } = {}) {
-        this.cancelEviction(entry);
-        if (entry.pending && (!force || entry.state.data === undefined))
-            return entry.pending;
-        if (!force && this.fresh({ entry: entry, staleTime: staleTime })) {
-            this.scheduleEviction(entry);
-            return Promise.resolve(entry.state.data);
-        }
-        // Shared per key across loader instances: a replacement while this request is out
-        // must win over its older answer, not just protect the instance that issued the write.
-        const replacement = entry.replacement;
-        const run = () => {
-            // A queued offline refresh may have been superseded before reconnection.
-            if (entry.pending !== pending)
-                return (entry.pending ?? Promise.resolve(entry.state.data));
-            this.publish(entry, { ...entry.state, isFetching: true });
-            return fetch();
-        };
-        const pending = Promise.resolve().then(() => {
-            if (this.online)
-                return run();
-            this.publish(entry, { ...entry.state, isFetching: false });
-            return this.runOnline({ run });
-        }).then(value => {
-            const data = replacement === entry.replacement ? value : entry.state.data;
-            // Undefined is never successful query data, including an initial or background read.
-            if (data === undefined)
-                throw new Error(`${JSON.stringify(entry.key)} data is undefined`);
-            return data;
-        }).then(data => {
-            // Only the current request may publish or clear invalidation. An older transport
-            // need not support abort: its callers follow the replacement request instead.
-            if (entry.pending !== pending)
-                return (entry.pending ?? entry.state.data);
-            entry.updatedAt = this.clock.nowMs();
-            entry.invalidated = false;
-            this.publish(entry, { data, error: null, status: 'success', isFetching: false });
-            return data;
-        }, error => {
-            if (entry.pending !== pending)
-                return (entry.pending ?? entry.state.data);
-            // A replacement write is newer than this read's failure as well as its data.
-            // Keep the write's timestamp and freshness; only settle the obsolete fetch flag.
-            if (replacement !== entry.replacement) {
-                this.publish(entry, { ...entry.state, isFetching: false });
-                return entry.state.data;
-            }
-            entry.invalidated = true;
-            this.publish(entry, { ...entry.state, error: toQueryError(error), status: 'error', isFetching: false });
-            throw error;
-        }).finally(() => {
-            if (entry.pending !== pending)
-                return;
-            entry.pending = undefined;
-            if (entry.refreshAfterPending) {
-                entry.refreshAfterPending = false;
-                this.refresh(entry);
-            }
-            this.scheduleEviction(entry);
-        });
-        entry.pending = pending;
-        // Mark handled even when a UI caller deliberately discards the promise.
-        void pending.catch(() => { });
-        // Like TanStack's background refetches, retain the last error until success clears it
-        // or another failure replaces it. Extend that rule to retries without cached data:
-        // starting a request is not evidence of recovery; isFetching reports its progress.
-        const state = entry.state.data === undefined ? { ...entry.state, status: 'pending' } : entry.state;
-        this.publish(entry, { ...state, isFetching: this.online });
-        return pending;
-    }
-    replace({ entry, data }) {
-        entry.replacement += 1;
-        entry.updatedAt = this.clock.nowMs();
-        entry.invalidated = false;
-        this.publish(entry, { data, error: null, status: 'success', isFetching: entry.state.isFetching });
-        this.scheduleEviction(entry);
-    }
-    invalidate({ prefix }) {
-        for (const entry of this.entries.values()) {
-            if (!prefix.every((part, index) => entry.key[index] === part))
-                continue;
-            entry.invalidated = true;
-            this.refresh(entry);
-        }
-    }
-    onFocus() {
-        for (const entry of this.entries.values()) {
-            const observer = [...entry.observers].find(value => value.focus && !this.fresh({ entry: entry, staleTime: value.staleTime }));
-            // Environmental refreshes share a request already underway, unlike an explicit gesture.
-            if (observer && !entry.pending)
-                void this.load({ entry: entry, fetch: observer.fetch, staleTime: observer.staleTime });
-        }
-    }
-    /** 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({ run }) {
-        if (this.online)
-            return Promise.resolve().then(() => {
-                // Connectivity may change between queuing the operation and its invocation.
-                if (!this.online)
-                    return this.runOnline({ run });
-                return run();
-            });
-        return new Promise(resolve => { this.onlineWaiters.add(resolve); }).then(() => this.runOnline({ run }));
-    }
-    /** Stop timers on provider disposal; reactivate for React's effect replay. */
-    activate() {
-        this.disposed = false;
-        if (!this.environment || this.releaseEnvironment)
-            return;
-        const releaseOnline = this.environment.subscribeOnline({ listener: online => this.onOnline({ online }) });
-        const releaseFocus = this.environment.subscribeFocus({ listener: () => this.onFocus() });
-        this.releaseEnvironment = () => { releaseOnline(); releaseFocus(); };
-        this.onOnline({ online: this.environment.isOnline() });
-    }
-    dispose() {
-        this.disposed = true;
-        this.releaseEnvironment?.();
-        this.releaseEnvironment = undefined;
-        for (const entry of this.entries.values())
-            this.cancelEviction(entry);
-    }
-    onOnline({ online }) {
-        const reconnect = online && !this.online;
-        this.online = online;
-        if (!online)
-            return;
-        for (const resume of this.onlineWaiters)
-            resume();
-        this.onlineWaiters.clear();
-        if (!reconnect)
-            return;
-        for (const entry of this.entries.values()) {
-            const observer = [...entry.observers].find(value => !this.fresh({ entry, staleTime: value.staleTime }));
-            // A paused request already owns its resumption; restarting it here would double-fetch.
-            if (observer && !entry.pending)
-                void this.load({ entry, fetch: observer.fetch, staleTime: observer.staleTime });
-        }
-    }
-    refresh(entry) {
-        const observer = entry.observers.values().next().value;
-        if (observer)
-            void this.load({ entry: entry, fetch: observer.fetch, staleTime: observer.staleTime }, { force: true });
-    }
-    publish(entry, state) {
-        entry.state = state;
-        for (const listener of entry.listeners)
-            listener();
-    }
-    cancelEviction(entry) {
-        if (entry.eviction !== undefined)
-            this.scheduler.cancel({ handle: entry.eviction });
-        entry.eviction = undefined;
-    }
-    scheduleEviction(entry) {
-        this.cancelEviction(entry);
-        if (this.disposed || entry.listeners.size || entry.observers.size || entry.pending || !Number.isFinite(entry.retention))
-            return;
-        entry.eviction = this.scheduler.schedule({ callback: () => this.entries.delete(JSON.stringify(entry.key)), delayMs: entry.retention });
-    }
-}
-//# sourceMappingURL=cache.js.map