@jini-ai/ui 0.4.7 → 0.4.8

package/dist/features/media-providers/constants.js

@@ -1,3 +1,4 @@
+import { findProvider, canonicalMediaProviderId } from '@jini-ai/integrations/media-providers/catalog';
 /**
  * A small, vendor-shaped starting catalog — same convention as `execution/constants.ts`'s
  * `DEFAULT_PROVIDER_PRESETS`. Sourced by driving Open Design's own Settings → Media providers
@@ -5,17 +6,15 @@
  * models. Pass your own `catalog` to `MediaProvidersTab` to replace this wholesale; Zana or any
  * other host is expected to do so once it has its own provider roster.
  */
-export const DEFAULT_MEDIA_PROVIDER_CATALOG = [
+const starterCatalog = [
     {
         id: 'nano-banana',
         label: 'Nano Banana',
-        defaultBaseUrl: 'https://generativelanguage.googleapis.com',
         models: ['gemini-3.1-flash-image-preview'],
     },
     {
         id: 'aihubmix',
         label: 'AIHubMix',
-        defaultBaseUrl: 'https://aihubmix.com/v1',
         models: ['gemini-3.1-flash-image-preview'],
     },
     {
@@ -26,65 +25,58 @@ export const DEFAULT_MEDIA_PROVIDER_CATALOG = [
     {
         id: 'elevenlabs',
         label: 'ElevenLabs',
-        defaultBaseUrl: 'https://api.elevenlabs.io',
     },
     {
         id: 'fal-ai',
         label: 'Fal.ai',
-        defaultBaseUrl: 'https://fal.run',
         models: ['gemini-3.1-flash-image-preview'],
     },
     {
         id: 'fishaudio',
         label: 'FishAudio',
-        defaultBaseUrl: 'https://api.fish.audio',
     },
     {
         id: 'imagerouter',
         label: 'ImageRouter',
-        defaultBaseUrl: 'https://api.imagerouter.io/v1/openai',
         models: ['gemini-3.1-flash-image-preview'],
     },
     {
         id: 'leonardo-ai',
         label: 'Leonardo.ai',
-        defaultBaseUrl: 'https://cloud.leonardo.ai/api/rest/v1',
     },
     {
         id: 'minimax',
         label: 'MiniMax',
-        defaultBaseUrl: 'https://api.minimaxi.chat/v1',
     },
     {
         id: 'openai',
         label: 'OpenAI',
-        defaultBaseUrl: 'https://api.openai.com/v1',
         models: ['gpt-image-2', 'dall-e-3'],
     },
     {
         id: 'openrouter',
         label: 'OpenRouter',
-        defaultBaseUrl: 'https://openrouter.ai/api/v1',
     },
     {
         id: 'senseaudio',
         label: 'SenseAudio',
-        defaultBaseUrl: 'https://api.senseaudio.cn',
     },
     {
         id: 'tavily-search',
         label: 'Tavily Search',
-        defaultBaseUrl: 'https://api.tavily.com',
     },
     {
         id: 'volcengine-ark',
         label: 'Volcengine Ark (Doubao)',
-        defaultBaseUrl: 'https://ark.cn-beijing.volces.com/api/v3',
     },
     {
         id: 'xai-grok-imagine',
         label: 'xAI Grok Imagine',
-        defaultBaseUrl: 'https://api.x.ai/v1',
     },
 ];
+export const DEFAULT_MEDIA_PROVIDER_CATALOG = starterCatalog.map((entry) => {
+    const id = canonicalMediaProviderId({ id: entry.id });
+    const provider = findProvider({ id });
+    return { ...entry, id, label: provider.label, ...(provider.defaultBaseUrl ? { defaultBaseUrl: provider.defaultBaseUrl } : {}) };
+});
 //# sourceMappingURL=constants.js.map

package/dist/features/media-providers/react/components/MediaProvidersTab.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { canonicalMediaProviderId } from '@jini-ai/integrations/media-providers/catalog';
 import { Fragment, useState } from 'react';
 import { agentHandleProps, buildAgentListHandles } from '@jini-ai/agentic';
 import { useT } from '../../../i18n/index.js';
@@ -55,7 +56,7 @@ export function MediaProvidersTab({ port, catalog = DEFAULT_MEDIA_PROVIDER_CATAL
             return next;
         });
     };
-    const orderedCatalog = sortProvidersByConfigured(catalog, providers, pinnedProviderIds);
+    const orderedCatalog = sortProvidersByConfigured(catalog.map((entry) => ({ ...entry, id: canonicalMediaProviderId({ id: entry.id }) })), providers, pinnedProviderIds?.map((id) => canonicalMediaProviderId({ id })));
     const providerHandles = agentHandle
         ? buildAgentListHandles({ prefix: agentHandle, ids: orderedCatalog.map((option) => option.id) })
         : undefined;
@@ -63,7 +64,7 @@ export function MediaProvidersTab({ port, catalog = DEFAULT_MEDIA_PROVIDER_CATAL
     // pinned id absent from `catalog` never appears in `orderedCatalog` either (see
     // `sortProvidersByConfigured`'s own "silently skipped" doc), so this stays correct without
     // re-deriving which pinned ids actually resolved to a real card.
-    const pinnedIdSet = new Set(pinnedProviderIds ?? []);
+    const pinnedIdSet = new Set(pinnedProviderIds?.map((id) => canonicalMediaProviderId({ id })) ?? []);
     const hasPendingChanges = pendingProviderIds.size > 0;
     // Save writes every provider at once, so ONE unacceptable endpoint blocks the
     // whole button rather than being silently persisted alongside the good ones.

package/dist/features/media-providers/react/hooks/useMediaProvidersTab.js

@@ -1,3 +1,4 @@
+import { normalizeMediaProviderMap, canonicalMediaProviderId } from '@jini-ai/integrations/media-providers/catalog';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { hasAnyConfiguredProvider, isEntryEmpty, mergeDaemonProviders, shouldSyncLocalProvidersToDaemon, } from '../../rules.js';
 /**
@@ -18,7 +19,7 @@ import { hasAnyConfiguredProvider, isEntryEmpty, mergeDaemonProviders, shouldSyn
  * server manages nothing" and silently wipe local edits.
  */
 export function useMediaProvidersTab({ port, initialProviders }) {
-    const [providers, setProviders] = useState(() => ({ ...(initialProviders ?? {}) }));
+    const [providers, setProviders] = useState(() => normalizeMediaProviderMap({ providers: initialProviders ?? {} }));
     const [pendingProviderIds, setPendingProviderIds] = useState(() => new Set());
     const [load, setLoad] = useState({ status: 'loading' });
     const [save, setSave] = useState({ status: 'idle' });
@@ -113,7 +114,7 @@ export function useMediaProvidersTab({ port, initialProviders }) {
                 if (!touched.has(providerId))
                     clearedProviderIds.current.delete(providerId);
             }
-            const next = { ...saved };
+            const next = normalizeMediaProviderMap({ providers: saved });
             for (const providerId of touched) {
                 const local = providersRef.current[providerId];
                 if (local === undefined)
@@ -205,7 +206,7 @@ export function useMediaProvidersTab({ port, initialProviders }) {
                 setLoad({ status: 'unreachable' });
                 return;
             }
-            const merged = mergeDaemonProviders(providersRef.current, daemonResult, {
+            const merged = mergeDaemonProviders(providersRef.current, normalizeMediaProviderMap({ providers: daemonResult }), {
                 preserveLocalProviderIds: pendingRef.current,
                 dropProviderIds: clearedProviderIds.current,
             });
@@ -226,6 +227,7 @@ export function useMediaProvidersTab({ port, initialProviders }) {
         fetchAndReconcile(false);
     }, [fetchAndReconcile]);
     const updateProvider = useCallback((providerId, patch) => {
+        providerId = canonicalMediaProviderId({ id: providerId });
         const current = providersRef.current;
         const nextEntry = { ...(current[providerId] ?? {}), ...patch };
         const nextMap = { ...current };
@@ -242,6 +244,7 @@ export function useMediaProvidersTab({ port, initialProviders }) {
         mutatedSinceSend.current.add(providerId);
     }, [applyProviders, applyPending]);
     const clearProvider = useCallback((providerId) => {
+        providerId = canonicalMediaProviderId({ id: providerId });
         void (async () => {
             const previousEntry = providersRef.current[providerId];
             const next = { ...providersRef.current };

package/dist/features/memory/dependencies.d.ts

@@ -9,6 +9,7 @@ export declare function createMemoryHttpPorts(_required: Record<string, never>,
     entries: MemoryEntriesPort;
     extractions: MemoryExtractionsPort;
 };
+/** @deprecated Explicit legacy REST binding. Host UI composition must use MemoryPortsProvider. */
 export declare const memoryConfigPort: MemoryConfigPort, memoryEntriesPort: MemoryEntriesPort, memoryExtractionsPort: MemoryExtractionsPort;
 /** Standalone default read shares the entries port's validated REST implementation. */
 export declare const fetchMemoryList: () => Promise<MemoryListResponse>;
@@ -25,5 +26,6 @@ export interface FakeMemoryConnectorsPortOptions {
  * above — only the connector catalogue/status/suggest transport is faked.
  */
 export declare function createFakeMemoryConnectorsPort(options?: FakeMemoryConnectorsPortOptions): MemoryConnectorsPort;
+/** @deprecated Demo catalogue; hosts supply their own connectors port through MemoryPortsProvider. */
 export declare const memoryConnectorsPort: MemoryConnectorsPort;
 //# sourceMappingURL=dependencies.d.ts.map

package/dist/features/memory/dependencies.js

@@ -1,29 +1,11 @@
 /**
- * The only file in this feature allowed to touch a concrete transport
- * adapter. Everything else in the slice depends on `ports.ts`.
- *
- * Split, deliberately, into two different defaults:
- *
- * - `memoryConfigPort`/`memoryEntriesPort`/`memoryExtractionsPort` bind REAL
- *   `fetch`-based adapters against a plain `/api/memory*` REST surface (list/
- *   tree/entry CRUD, config PATCH, extraction history CRUD). Unlike
- *   `features/connectors`' data port — which fakes its transport by design,
- *   because the real one is a specific third-party OAuth-catalog vendor's
- *   API shape — this is a generic JSON/REST contract with no vendor coupling,
- *   and the pinned source's one open bug (`fetchMemoryList()` trusting an
- *   under-validated response — see the fix below and
- *   `packages/ui/archived provenance ledger`) only exists to fix in a real, testable
- *   adapter. A host is still free to supply its own binding; this default
- *   just isn't a fake.
- * - `memoryConnectorsPort` binds a fake/in-memory connector catalogue (same
- *   reasoning as `features/connectors`' own fake — the real catalogue is a
- *   vendor-specific OAuth discovery transport this package doesn't assume),
- *   plus REAL browser-only bridges for the two pieces that touch only
- *   generic browser APIs: pending-authorization persistence (sessionStorage)
- *   and the cross-tab "connectors changed" signal (a `CustomEvent`).
- *   `saveMemoryEntry` on this port is the same real HTTP adapter the entries
- *   cluster uses — saving a connector suggestion is an ordinary memory write,
- *   not a connector-transport concern.
+ * Explicit legacy/test transport bindings; Memory's wired hooks never select them implicitly.
+ * Production hosts supply MemoryPortsProvider with authorized config/entries/extractions and
+ * connector ports. createMemoryHttpPorts binds a host-selected REST contract; exported singletons
+ * retain the old /api/memory* paths for compatibility only. memoryConnectorsPort is a demo catalogue
+ * with sessionStorage/CustomEvent bridges and real REST memory writes, not production discovery.
+ * Removal plan: migrate singleton consumers to host factories/providers, then remove deprecated
+ * defaults in an owner-approved breaking release. Do not silently turn a demo into a live port.
  */
 import { requestWithTimeout } from '../../utils/browser-request.js';
 import { DEFAULT_CONNECTOR_PROVIDER, MEMORY_CONNECTOR_PENDING_AUTH_STORAGE_KEY, } from './constants.js';
@@ -163,6 +145,7 @@ export function createMemoryHttpPorts(_required, { fetch } = {}) {
     };
     return { config: memoryConfigPort, entries: memoryEntriesPort, extractions: memoryExtractionsPort };
 }
+/** @deprecated Explicit legacy REST binding. Host UI composition must use MemoryPortsProvider. */
 export const { config: memoryConfigPort, entries: memoryEntriesPort, extractions: memoryExtractionsPort } = createMemoryHttpPorts({});
 /** Standalone default read shares the entries port's validated REST implementation. */
 export const fetchMemoryList = memoryEntriesPort.fetchMemoryList;
@@ -251,5 +234,6 @@ function notifyConnectorsChanged() {
         return;
     window.dispatchEvent(new CustomEvent(CONNECTORS_CHANGED_EVENT));
 }
+/** @deprecated Demo catalogue; hosts supply their own connectors port through MemoryPortsProvider. */
 export const memoryConnectorsPort = createFakeMemoryConnectorsPort();
 //# sourceMappingURL=dependencies.js.map

package/dist/features/memory/index.d.ts

@@ -1,3 +1,4 @@
+export { MemoryPortsProvider, useMemoryPorts, type MemoryPorts } from './react/MemoryPorts.js';
 export { FIELD_LABEL_STYLE } from './react/styles.js';
 export { type AsyncCommitGuard, createAsyncCommitGuard } from './async-commit-guard.js';
 export { CONNECTOR_CALLBACK_MESSAGE_TYPE, connectorAppLabel, DEFAULT_CONNECTOR_PROVIDER, EMPTY_DRAFT, MEMORY_CONNECTOR_APP_IDS, MEMORY_CONNECTOR_APP_LABELS, MEMORY_CONNECTOR_PENDING_AUTH_STORAGE_KEY, STARTERS, TYPES, } from './constants.js';

package/dist/features/memory/index.js

@@ -1,3 +1,4 @@
+export { MemoryPortsProvider, useMemoryPorts } from './react/MemoryPorts.js';
 export { FIELD_LABEL_STYLE } from './react/styles.js';
 export { createAsyncCommitGuard } from './async-commit-guard.js';
 export { CONNECTOR_CALLBACK_MESSAGE_TYPE, connectorAppLabel, DEFAULT_CONNECTOR_PROVIDER, EMPTY_DRAFT, MEMORY_CONNECTOR_APP_IDS, MEMORY_CONNECTOR_APP_LABELS, MEMORY_CONNECTOR_PENDING_AUTH_STORAGE_KEY, STARTERS, TYPES, } from './constants.js';

package/dist/features/memory/react/MemoryPorts.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+import type { MemoryConfigPort, MemoryConnectorsPort, MemoryEntriesPort, MemoryExtractionsPort } from '../ports.js';
+/** Hosts own authentication, endpoint paths and connector discovery; memory UI owns no transport. */
+export interface MemoryPorts {
+    config: MemoryConfigPort;
+    entries: MemoryEntriesPort;
+    extractions: MemoryExtractionsPort;
+    connectors: MemoryConnectorsPort;
+}
+/** Bind one host's memory services to its subtree. Independent hosts never share these ports. */
+export declare function MemoryPortsProvider({ ports, children }: {
+    ports: MemoryPorts;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Fail at composition when no host was bound, before a hook can attempt network I/O. */
+export declare function useMemoryPorts(_required?: Record<string, never>, _optional?: Record<string, never>): MemoryPorts;
+//# sourceMappingURL=MemoryPorts.d.ts.map

package/dist/features/memory/react/MemoryPorts.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+const MemoryPortsContext = createContext(null);
+/** Bind one host's memory services to its subtree. Independent hosts never share these ports. */
+export function MemoryPortsProvider({ ports, children }) {
+    return _jsx(MemoryPortsContext.Provider, { value: ports, children: children });
+}
+/** Fail at composition when no host was bound, before a hook can attempt network I/O. */
+export function useMemoryPorts(_required = {}, _optional = {}) {
+    const ports = useContext(MemoryPortsContext);
+    if (!ports)
+        throw new Error('Memory hooks require MemoryPortsProvider');
+    return ports;
+}
+//# sourceMappingURL=MemoryPorts.js.map

package/dist/features/memory/react/hooks/useMemoryConfig.hooks.d.ts

@@ -22,8 +22,8 @@ export interface MemoryConfigController {
 }
 export declare function useMemoryConfig(port: MemoryConfigPort): MemoryConfigController;
 /**
- * Wirer: binds the real provider port and returns a ready-to-call hook. This is
- * the default a host injects; swap it via the component prop in tests.
+ * Reads the host-injected config port from MemoryPortsProvider (required).
+ * Hosts own authorization/transport; tests may inject a fake into useMemoryConfig.
  */
 export declare function useWiredMemoryConfig(): MemoryConfigController;
 //# sourceMappingURL=useMemoryConfig.hooks.d.ts.map

package/dist/features/memory/react/hooks/useMemoryConfig.hooks.js

@@ -8,13 +8,13 @@
 //     mocks, no global `fetch` stub.
 //   - business logic (the pure `rules`) is imported directly; only the
 //     side-effecting transport is injected.
-//   - `useWiredMemoryConfig()` (the wirer, bottom of file) binds the real
-//     provider port and is the default a host injects, so production callers
-//     pass nothing while tests swap the whole hook.
+//   - useWiredMemoryConfig() (below) reads the host-injected config port from
+//     MemoryPortsProvider. Production hosts must mount that provider; tests inject
+//     a fake port directly or swap the hook. There is no implicit REST fallback.
 import { useCallback, useMemo, useRef, useState } from 'react';
 import { createAsyncCommitGuard } from '../../async-commit-guard.js';
 import { enabledPatch, singleFlagPatch } from '../../rules.js';
-import { memoryConfigPort } from '../../dependencies.js';
+import { useMemoryPorts } from '../MemoryPorts.js';
 const CONFIG_SAVE_ERROR_MESSAGE = "Memory settings couldn't be saved. Try again shortly.";
 function newConfigWriteQueue() {
     return { inFlight: false, pending: null };
@@ -210,10 +210,10 @@ export function useMemoryConfig(port) {
     };
 }
 /**
- * Wirer: binds the real provider port and returns a ready-to-call hook. This is
- * the default a host injects; swap it via the component prop in tests.
+ * Reads the host-injected config port from MemoryPortsProvider (required).
+ * Hosts own authorization/transport; tests may inject a fake into useMemoryConfig.
  */
 export function useWiredMemoryConfig() {
-    return useMemoryConfig(memoryConfigPort);
+    return useMemoryConfig(useMemoryPorts().config);
 }
 //# sourceMappingURL=useMemoryConfig.hooks.js.map

package/dist/features/memory/react/hooks/useMemoryConnectors.hooks.d.ts

@@ -91,9 +91,8 @@ export declare function applyMemoryConnectorConnectResult({ connectorId, result,
 }): boolean;
 export declare function useMemoryConnectors(port: MemoryConnectorsPort, coord: MemoryConnectorsCoordination): MemoryConnectorsController;
 /**
- * Wirer: binds the real connectors transport + OAuth bridges and returns a
- * hook that still takes a host's runtime coordination. The default a host
- * injects; swap it via the component prop in tests.
+ * Reads the host-injected connector catalogue/OAuth bridges from MemoryPortsProvider
+ * (required), retaining runtime coordination. The deprecated demo catalogue is never a fallback.
  */
 export declare function useWiredMemoryConnectors(coord: MemoryConnectorsCoordination): MemoryConnectorsController;
 //# sourceMappingURL=useMemoryConnectors.hooks.d.ts.map

package/dist/features/memory/react/hooks/useMemoryConnectors.hooks.js

@@ -38,7 +38,7 @@ import { createAsyncCommitGuard } from '../../async-commit-guard.js';
 import { DEFAULT_CONNECTOR_PROVIDER, MEMORY_CONNECTOR_APP_IDS, MEMORY_CONNECTOR_APP_LABELS, } from '../../constants.js';
 import { describeExtractionFailure } from '../../formatters.js';
 import { applyMemoryConnectorStatus, connectorWithPendingAuthorization, memoryEntryIdForConnectorSuggestion, upsertMemoryConnector, } from '../../rules.js';
-import { memoryConnectorsPort } from '../../dependencies.js';
+import { useMemoryPorts } from '../MemoryPorts.js';
 import { describeConnectorSuggestionOutcome, describeConnectorSuggestionsSaveOutcome, isRecentFailedConnectorExtraction, withoutKey, withoutSetMember, } from './useMemoryConnectors.rules.js';
 /** `onSaveConnectorSuggestions`'s save loop, isolated: writes each selected
  *  suggestion as a memory entry in order, collecting which ones landed and
@@ -507,11 +507,10 @@ export function useMemoryConnectors(port, coord) {
     };
 }
 /**
- * Wirer: binds the real connectors transport + OAuth bridges and returns a
- * hook that still takes a host's runtime coordination. The default a host
- * injects; swap it via the component prop in tests.
+ * Reads the host-injected connector catalogue/OAuth bridges from MemoryPortsProvider
+ * (required), retaining runtime coordination. The deprecated demo catalogue is never a fallback.
  */
 export function useWiredMemoryConnectors(coord) {
-    return useMemoryConnectors(memoryConnectorsPort, coord);
+    return useMemoryConnectors(useMemoryPorts().connectors, coord);
 }
 //# sourceMappingURL=useMemoryConnectors.hooks.js.map

package/dist/features/memory/react/hooks/useMemoryEntries.hooks.d.ts

@@ -44,9 +44,8 @@ export interface MemoryEntriesController {
 }
 export declare function useMemoryEntries(port: MemoryEntriesPort, coord: MemoryEntriesCoordination): MemoryEntriesController;
 /**
- * Wirer: binds the real entries transport and returns a hook that still takes
- * a host's runtime coordination. The default a host injects; swap it via the
- * component prop in tests.
+ * Reads the host-injected entries port from MemoryPortsProvider (required),
+ * retaining the host's runtime coordination. No /api/memory* transport is chosen implicitly.
  */
 export declare function useWiredMemoryEntries(coord: MemoryEntriesCoordination): MemoryEntriesController;
 //# sourceMappingURL=useMemoryEntries.hooks.d.ts.map

package/dist/features/memory/react/hooks/useMemoryEntries.hooks.js

@@ -10,7 +10,7 @@ import { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
 import { copyToClipboard } from '../../../../utils/copy-to-clipboard.js';
 import { createAsyncCommitGuard } from '../../async-commit-guard.js';
 import { EMPTY_DRAFT } from '../../constants.js';
-import { memoryEntriesPort } from '../../dependencies.js';
+import { useMemoryPorts } from '../MemoryPorts.js';
 const LOAD_ERROR_MESSAGE = "Memory data couldn't be loaded. Try again shortly.";
 const MUTATION_ERROR_MESSAGE = "Memory changes couldn't be saved. Try again shortly.";
 export function useMemoryEntries(port, coord) {
@@ -331,11 +331,10 @@ export function useMemoryEntries(port, coord) {
     };
 }
 /**
- * Wirer: binds the real entries transport and returns a hook that still takes
- * a host's runtime coordination. The default a host injects; swap it via the
- * component prop in tests.
+ * Reads the host-injected entries port from MemoryPortsProvider (required),
+ * retaining the host's runtime coordination. No /api/memory* transport is chosen implicitly.
  */
 export function useWiredMemoryEntries(coord) {
-    return useMemoryEntries(memoryEntriesPort, coord);
+    return useMemoryEntries(useMemoryPorts().entries, coord);
 }
 //# sourceMappingURL=useMemoryEntries.hooks.js.map

package/dist/features/memory/react/hooks/useMemoryExtractions.hooks.js

@@ -13,7 +13,7 @@
 // store's synchronous transitions to React state.
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { createAsyncCommitGuard } from '../../async-commit-guard.js';
-import { memoryExtractionsPort } from '../../dependencies.js';
+import { useMemoryPorts } from '../MemoryPorts.js';
 import { createExtractionHistoryStore } from './useMemoryExtractions.store.js';
 const LOAD_ERROR_MESSAGE = "Memory extraction history couldn't be loaded. Try again shortly.";
 const MUTATION_ERROR_MESSAGE = "Memory extraction history couldn't be updated. Try again shortly.";
@@ -176,6 +176,6 @@ export function useMemoryExtractions(port) {
     };
 }
 export function useWiredMemoryExtractions() {
-    return useMemoryExtractions(memoryExtractionsPort);
+    return useMemoryExtractions(useMemoryPorts().extractions);
 }
 //# sourceMappingURL=useMemoryExtractions.hooks.js.map

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

@@ -1,6 +1,6 @@
 import { type ReactNode } from 'react';
-import { type FetchQueryEnvironmentPort } from './cache.js';
-import type { CachedLoader, CachedLoaderOptions, FetchMutationOptions, FetchQueryOptions, MutationResult, QueryKey, QueryResult } from './types.js';
+import { type FetchQueryEnvironmentPort } from '@jini-ai/core/fetch';
+import type { CachedLoader, CachedLoaderOptions, FetchMutationOptions, FetchQueryOptions, MutationResult, QueryKey, QueryResult } from '@jini-ai/core/fetch';
 /** Isolated cache scope; no external provider or query-library singleton is needed. */
 export declare function FetchQueryProvider({ children, environment }: {
     children: ReactNode;

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

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
-import { DEFAULT_STALE_TIME, FetchQueryCache, toQueryError } from './cache.js';
+import { DEFAULT_STALE_TIME, FetchQueryCache, toQueryError } from '@jini-ai/core/fetch';
 import { browserFetchQueryEnvironment } from './environment.browser.js';
 import { FetchQueryBinding } from './binding.react.js';
 const CacheContext = createContext(null);
@@ -109,7 +109,7 @@ export function useCachedLoader({ key, fetch }, { staleTime = DEFAULT_STALE_TIME
     const cache = useCache();
     return useMemo(() => ({
         peek: () => cache.entry({ key: key }, { staleTime: staleTime }).state.data,
-        load: () => cache.load({ entry: cache.entry({ key: key }, { staleTime: staleTime }), fetch: fetch, staleTime: staleTime }),
+        load: (required = { key, fetch }) => cache.load({ entry: cache.entry({ key: required.key }, { staleTime }), fetch: required.fetch, staleTime }),
         replace: ({ value }) => cache.replace({ entry: cache.entry({ key: key }, { staleTime: staleTime }), data: value }),
     }), [cache, key, fetch, staleTime]);
 }

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

@@ -1,6 +1,6 @@
 /** Optional TanStack translation layer. No library types escape the fetch-query contract. */
 import { type ReactNode } from 'react';
-import { type FetchQueryEnvironmentPort } from './cache.js';
+import { type FetchQueryEnvironmentPort } from '@jini-ai/core/fetch';
 /** Provider-owned TanStack cache and binding, compatible with hooks from the default entry.
  * @example <FetchQueryProvider><ResourceScreen /></FetchQueryProvider>
  * @param props Children and optional host connectivity/focus port. */

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