@jini-ai/ui 0.3.13 → 0.4.0

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

@@ -0,0 +1,91 @@
+/**
+ * Keep the contract independent of any query library so an adapter swap does not require
+ * rewriting callers. Add narrow required capabilities here rather than exporting library
+ * result/client types that would bypass this boundary.
+ */
+/**
+ * Keys contain primitive array parts so parameterised resources compose without fragile
+ * string formatting or object-identity mismatches. Invalidation matches by PREFIX: a list
+ * key also refreshes its derived child keys. Exact-key equality would compile while quietly
+ * breaking that guarantee; avoid a shared prefix for resources that merely sound related,
+ * or writes will fan out unnecessary refetches.
+ */
+export type QueryKey = readonly (string | number)[];
+export type QueryStatus = "loading" | "success" | "error";
+export interface QueryResult<T> {
+    data: T | undefined;
+    error: Error | null;
+    status: QueryStatus;
+    isFetching: boolean;
+    refetch: () => void;
+}
+export interface FetchQueryOptions<T> {
+    key: QueryKey;
+    fetch: () => Promise<T>;
+    /**
+     * Gate on user intent or prerequisites to avoid fetching an undefined id. Disabling does
+     * not erase cached failures: without any successful data, report loading/error:null so
+     * a gesture-gated read cannot show an old failure before the user asks for it. With
+     * earlier data, report success but retain a later background error so known-stale data
+     * need not be presented as an unqualified success.
+     */
+    enabled?: boolean;
+    staleTime?: number;
+    refetchOnWindowFocus?: boolean;
+}
+export type MutationStatus = "idle" | "pending" | "success" | "error";
+export interface MutationResult<TInput, TOutput> {
+    /**
+     * Awaiting the write receives its result or rejection; discarding the same promise and
+     * reading state is safe because it already has a rejection handler. Returning a bare
+     * rejecting promise would make only the awaiting form safe. Node unhandledRejection
+     * can verify this contract even where a DOM unhandledrejection event does not fire.
+     */
+    mutate: (required: {
+        input: TInput;
+    }) => Promise<TOutput>;
+    status: MutationStatus;
+    error: Error | null;
+    reset: () => void;
+}
+export interface FetchMutationOptions<TInput, TOutput> {
+    run: (required: {
+        input: TInput;
+    }) => Promise<TOutput>;
+    invalidates?: readonly QueryKey[];
+}
+/**
+ * Keep key and fetch references stable: they are memo dependencies of the loader handle.
+ * Failed fetches reject and are not cached, so the next load retries instead of replaying
+ * a failure as data. Retain an idle value at least as long as its declared freshness: an
+ * imperative loader has no persistent observer to keep it alive.
+ */
+export interface CachedLoaderOptions<T> {
+    key: QueryKey;
+    fetch: () => Promise<T>;
+    staleTime?: number;
+}
+/**
+ * A plain promise loader serves components that own their loading UI rather than consuming
+ * a hook result. It shares the provider cache, including one in-flight request per key.
+ */
+export interface CachedLoader<T> {
+    peek: () => T | undefined;
+    load: () => Promise<T>;
+    replace: (required: {
+        value: T;
+    }) => void;
+}
+/**
+ * Keep the provider-facing hooks, loader and invalidator behind one binding so replacing
+ * the cache implementation does not leave different consumers on different adapters.
+ */
+export interface FetchQueryAdapter {
+    useFetchQuery: <T>(required: Pick<FetchQueryOptions<T>, "key" | "fetch">, optional?: Omit<FetchQueryOptions<T>, "key" | "fetch">) => QueryResult<T>;
+    useFetchMutation: <TInput, TOutput>(required: Pick<FetchMutationOptions<TInput, TOutput>, "run">, optional?: Omit<FetchMutationOptions<TInput, TOutput>, "run">) => MutationResult<TInput, TOutput>;
+    useInvalidate: () => (required: {
+        key: QueryKey;
+    }) => void;
+    useCachedLoader: <T>(required: Pick<CachedLoaderOptions<T>, "key" | "fetch">, optional?: Omit<CachedLoaderOptions<T>, "key" | "fetch">) => CachedLoader<T>;
+}
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/features/panel-kit/helpers/format-timestamp.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Centralize the historical fixed-width display so formatting changes have one owner. Preserve
+ * the stored timestamp's prefix byte for byte: no parsing, locale formatting or timezone conversion.
+ * Trailing seconds, milliseconds and zone suffix are intentionally dropped; callers supply ISO text.
+ */
+/** Render the ISO prefix as YYYY-MM-DD HH:MM without timezone conversion. */
+export declare function formatTimestamp({ iso }: {
+    iso: string;
+}): string;
+/** Inject 'now' to keep relative-time display deterministic. The fallback wording uses simple
+ * English singular/plural templates; hosts can translate them, but this is not full locale pluralization. */
+export declare function formatRelativeMinutesAgo({ iso, nowMs }: {
+    iso: string;
+    nowMs: number;
+}, { translate }?: {
+    translate?: ((key: string) => string) | undefined;
+}): string;
+//# sourceMappingURL=format-timestamp.d.ts.map

package/dist/features/panel-kit/helpers/format-timestamp.js

@@ -0,0 +1,20 @@
+/**
+ * Centralize the historical fixed-width display so formatting changes have one owner. Preserve
+ * the stored timestamp's prefix byte for byte: no parsing, locale formatting or timezone conversion.
+ * Trailing seconds, milliseconds and zone suffix are intentionally dropped; callers supply ISO text.
+ */
+/** Render the ISO prefix as YYYY-MM-DD HH:MM without timezone conversion. */
+export function formatTimestamp({ iso }) {
+    return iso.slice(0, 16).replace("T", " ");
+}
+/** Inject 'now' to keep relative-time display deterministic. The fallback wording uses simple
+ * English singular/plural templates; hosts can translate them, but this is not full locale pluralization. */
+export function formatRelativeMinutesAgo({ iso, nowMs }, { translate = (key) => key } = {}) {
+    const minutes = Math.max(0, Math.round((nowMs - new Date(iso).getTime()) / 60000));
+    if (minutes < 1)
+        return translate("less than a minute ago");
+    if (minutes === 1)
+        return translate("1 minute ago");
+    return translate("{minutes} minutes ago").replace(/\{minutes\}/g, String(minutes));
+}
+//# sourceMappingURL=format-timestamp.js.map

package/dist/features/panel-kit/helpers/permissions.d.ts

@@ -0,0 +1,11 @@
+/** UI affordance check for exact grants or the literal * wildcard; server authorization remains host-owned. */
+/**
+ * A flattened permission list has lost resource scopes and constraints. Treating '*' as an ordinary
+ * name would hide every gated control from wildcard holders, but matching it here only controls UI.
+ * Never use this helper to authorize an operation: the server must evaluate the full grants again.
+ */
+export declare function hasPermission({ permissions, permission }: {
+    permissions: readonly string[];
+    permission: string;
+}): boolean;
+//# sourceMappingURL=permissions.d.ts.map

package/dist/features/panel-kit/helpers/permissions.js

@@ -0,0 +1,10 @@
+/** UI affordance check for exact grants or the literal * wildcard; server authorization remains host-owned. */
+/**
+ * A flattened permission list has lost resource scopes and constraints. Treating '*' as an ordinary
+ * name would hide every gated control from wildcard holders, but matching it here only controls UI.
+ * Never use this helper to authorize an operation: the server must evaluate the full grants again.
+ */
+export function hasPermission({ permissions, permission }) {
+    return permissions.includes("*") || permissions.includes(permission);
+}
+//# sourceMappingURL=permissions.js.map

package/dist/features/panel-kit/helpers/resolve-active-tab-id.d.ts

@@ -0,0 +1,13 @@
+/** Keep an allowed selection or choose the allowed default/first id; an empty list keeps defaultId. */
+/**
+ * URL query values can come from stale bookmarks or typos; validating against allowed ids prevents
+ * a blank panel. The default is supplied by the caller because some screens compute it from settings.
+ * Validate that default too: a computed default can widen the type to string, letting drift from
+ * the allowed list type-check successfully. For a nonempty list, the first id keeps the fallback valid.
+ */
+export declare function resolveActiveTabId<T extends string>({ tabId, validIds, defaultId }: {
+    tabId: string | null | undefined;
+    validIds: readonly T[];
+    defaultId: T;
+}): T;
+//# sourceMappingURL=resolve-active-tab-id.d.ts.map

package/dist/features/panel-kit/helpers/resolve-active-tab-id.js

@@ -0,0 +1,13 @@
+/** Keep an allowed selection or choose the allowed default/first id; an empty list keeps defaultId. */
+/**
+ * URL query values can come from stale bookmarks or typos; validating against allowed ids prevents
+ * a blank panel. The default is supplied by the caller because some screens compute it from settings.
+ * Validate that default too: a computed default can widen the type to string, letting drift from
+ * the allowed list type-check successfully. For a nonempty list, the first id keeps the fallback valid.
+ */
+export function resolveActiveTabId({ tabId, validIds, defaultId }) {
+    const ids = validIds;
+    const safeDefault = ids.includes(defaultId) ? defaultId : (validIds[0] ?? defaultId);
+    return tabId && ids.includes(tabId) ? tabId : safeDefault;
+}
+//# sourceMappingURL=resolve-active-tab-id.js.map

package/dist/features/panel-kit/helpers/retry-unreachable.d.ts

@@ -0,0 +1,20 @@
+/** About 60 seconds of waits spans a short restart/redeploy while still bounding downtime reporting. */
+export declare const UNREACHABLE_RETRY_DELAYS_MS: readonly number[];
+/** Duck-type the name: DOMException's instanceof Error result depends on its browser realm. */
+export declare function isAbortError({ error }: {
+    error: unknown;
+}): boolean;
+/** Retry only errors classified by the injected predicate, within a bounded delay schedule.
+ * Abort cancels a pending wait, but the host remains responsible for cancelling its own request. */
+export declare function retryWhileUnreachable<T>({ load, signal, isUnreachable }: {
+    load: () => Promise<T>;
+    signal: AbortSignal;
+    isUnreachable: (error: unknown) => boolean;
+}, { delaysMs, wait }?: {
+    delaysMs?: readonly number[];
+    wait?: (required: {
+        ms: number;
+        signal: AbortSignal;
+    }) => Promise<void>;
+}): Promise<T>;
+//# sourceMappingURL=retry-unreachable.d.ts.map

package/dist/features/panel-kit/helpers/retry-unreachable.js

@@ -0,0 +1,39 @@
+/** About 60 seconds of waits spans a short restart/redeploy while still bounding downtime reporting. */
+export const UNREACHABLE_RETRY_DELAYS_MS = [1_000, 2_000, 4_000, 8_000, 15_000, 30_000];
+/** Duck-type the name: DOMException's instanceof Error result depends on its browser realm. */
+export function isAbortError({ error }) {
+    return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+/** Clear the timer on abort and detach the listener on completion so unmounts leave no scheduled wait. */
+function waitUnlessAborted(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            clearTimeout(timer);
+            reject(new DOMException("retry cancelled", "AbortError"));
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", abort);
+            resolve();
+        }, ms);
+        if (signal.aborted)
+            abort();
+        else
+            signal.addEventListener("abort", abort, { once: true });
+    });
+}
+/** Retry only errors classified by the injected predicate, within a bounded delay schedule.
+ * Abort cancels a pending wait, but the host remains responsible for cancelling its own request. */
+export async function retryWhileUnreachable({ load, signal, isUnreachable }, { delaysMs = UNREACHABLE_RETRY_DELAYS_MS, wait = ({ ms, signal }) => waitUnlessAborted(ms, signal) } = {}) {
+    for (const delayMs of delaysMs) {
+        try {
+            return await load();
+        }
+        catch (error) {
+            if (!isUnreachable(error))
+                throw error;
+        }
+        await wait({ ms: delayMs, signal });
+    }
+    return load();
+}
+//# sourceMappingURL=retry-unreachable.js.map

package/dist/features/panel-kit/hooks/use-async-action.hooks.d.ts

@@ -0,0 +1,13 @@
+import { type Dispatch, type SetStateAction } from "react";
+export interface AsyncActionState {
+    saving: boolean;
+    error: string | null;
+    setError: Dispatch<SetStateAction<string | null>>;
+    run: (required: {
+        action: () => Promise<void>;
+        describeError: (e: unknown) => string;
+    }) => Promise<void>;
+}
+/** Expose saving/error state for an action; cancellations stay silent and other failures use caller copy. */
+export declare function useAsyncAction(): AsyncActionState;
+//# sourceMappingURL=use-async-action.hooks.d.ts.map

package/dist/features/panel-kit/hooks/use-async-action.hooks.js

@@ -0,0 +1,27 @@
+import { useState } from "react";
+import { isAbortError } from "../helpers/retry-unreachable.js";
+/** Expose saving/error state for an action; cancellations stay silent and other failures use caller copy. */
+export function useAsyncAction() {
+    const [saving, setSaving] = useState(false);
+    const [error, setError] = useState(null);
+    async function run({ action, describeError }) {
+        // Each screen interprets server codes differently; inject the describer instead of importing
+        // one feature's wording. action includes success effects, all completed before saving turns off.
+        setSaving(true);
+        setError(null);
+        try {
+            await action();
+        }
+        catch (e) {
+            // An aborted action must not leave a stale failure banner after browser history restoration.
+            if (isAbortError({ error: e }))
+                return;
+            setError(describeError(e));
+        }
+        finally {
+            setSaving(false);
+        }
+    }
+    return { saving, error, setError, run };
+}
+//# sourceMappingURL=use-async-action.hooks.js.map

package/dist/features/panel-kit/hooks/use-dirty-guard.hooks.d.ts

@@ -0,0 +1,18 @@
+import type { Translate } from "../../i18n/dictionary-translator.js";
+export type DirtyGuardHostPort = Pick<Window, "addEventListener" | "removeEventListener" | "confirm">;
+export interface DirtyGuard {
+    isDirty: boolean;
+    confirmLeave: (required?: Record<string, never>, optional?: {
+        unsavedBeyondTracked?: boolean;
+    }) => boolean;
+}
+/** Compare small JSON-serializable form states (including key order). Null original is clean.
+ * Warn on unload and offer a translated native confirmation for caller-owned navigation. */
+export declare function useDirtyGuard<T>({ current, original }: {
+    current: T;
+    original: T | null;
+}, { translate, host }?: {
+    translate?: Translate | undefined;
+    host?: DirtyGuardHostPort | undefined;
+}): DirtyGuard;
+//# sourceMappingURL=use-dirty-guard.hooks.d.ts.map

package/dist/features/panel-kit/hooks/use-dirty-guard.hooks.js

@@ -0,0 +1,33 @@
+import { useEffect } from "react";
+// JSON equality is intentionally limited to small form states built with consistent key order.
+// This avoids a general deep-equality dependency; large documents or arbitrary values need another seam.
+function shallowJsonEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+/** Compare small JSON-serializable form states (including key order). Null original is clean.
+ * Warn on unload and offer a translated native confirmation for caller-owned navigation. */
+export function useDirtyGuard({ current, original }, { translate = (key) => key, host = window } = {}) {
+    // beforeunload covers close/reload/browser navigation, but does not fire for in-app routing.
+    // Callers must wire confirmLeave to their own navigation actions or edits can be lost silently.
+    const isDirty = original !== null && !shallowJsonEqual(current, original);
+    useEffect(() => {
+        if (!isDirty)
+            return;
+        function onBeforeUnload(e) {
+            e.preventDefault();
+            // Both assignments are the standard cross-browser incantation (the returned string is
+            // ignored by every modern browser in favor of their own fixed prompt copy, but the property
+            // still has to be set for the prompt to appear at all in some engines).
+            e.returnValue = "";
+        }
+        host.addEventListener("beforeunload", onBeforeUnload);
+        return () => host.removeEventListener("beforeunload", onBeforeUnload);
+    }, [isDirty, host]);
+    function confirmLeave(_required = {}, { unsavedBeyondTracked = false } = {}) {
+        if (!isDirty && !unsavedBeyondTracked)
+            return true;
+        return host.confirm(translate("You have unsaved changes. Leave without saving?"));
+    }
+    return { isDirty, confirmLeave };
+}
+//# sourceMappingURL=use-dirty-guard.hooks.js.map

package/dist/features/panel-kit/hooks/use-focus-trap.hooks.d.ts

@@ -0,0 +1,8 @@
+import { type RefObject } from "react";
+/** Trap Tab/Shift+Tab in the most recently activated container; outer traps resume on cleanup. */
+export declare function useFocusTrap({ containerRef }: {
+    containerRef: RefObject<HTMLElement | null>;
+}, { active }?: {
+    active?: boolean | undefined;
+}): void;
+//# sourceMappingURL=use-focus-trap.hooks.d.ts.map

package/dist/features/panel-kit/hooks/use-focus-trap.hooks.js

@@ -0,0 +1,66 @@
+import { useEffect } from "react";
+const FOCUSABLE = [
+    "a[href]",
+    "button:not([disabled])",
+    "input:not([disabled]):not([type='hidden'])",
+    "select:not([disabled])",
+    "textarea:not([disabled])",
+    "[tabindex]:not([tabindex='-1'])",
+].join(",");
+// aria-modal tells assistive technology that the background is unavailable; without a trap,
+// Tab can still escape to those controls. Share this stack across unrelated components so only
+// the innermost active dialog traps focus, and the outer dialog resumes when it closes.
+const activeTraps = [];
+function isAvailableForFocus(element) {
+    if (element.matches(":disabled") || element.closest("[hidden], [inert]"))
+        return false;
+    const visibility = getComputedStyle(element).visibility;
+    if (visibility === "hidden" || visibility === "collapse")
+        return false;
+    for (let ancestor = element; ancestor; ancestor = ancestor.parentElement) {
+        if (getComputedStyle(ancestor).display === "none")
+            return false;
+    }
+    return true;
+}
+function redirectTarget(container, shiftKey) {
+    const focusable = Array.from(container.querySelectorAll(FOCUSABLE)).filter(isAvailableForFocus);
+    if (focusable.length === 0)
+        return null;
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    const active = document.activeElement;
+    if (!(active instanceof Node) || !container.contains(active))
+        return shiftKey ? last : first;
+    if (shiftKey && active === first)
+        return last;
+    if (!shiftKey && active === last)
+        return first;
+    return null;
+}
+/** Trap Tab/Shift+Tab in the most recently activated container; outer traps resume on cleanup. */
+export function useFocusTrap({ containerRef }, { active = true } = {}) {
+    useEffect(() => {
+        if (!active)
+            return;
+        activeTraps.push(containerRef);
+        function onKeyDown(event) {
+            if (event.key !== "Tab" || activeTraps[activeTraps.length - 1] !== containerRef)
+                return;
+            const container = containerRef.current;
+            if (!container)
+                return;
+            const target = redirectTarget(container, event.shiftKey);
+            if (!target)
+                return;
+            event.preventDefault();
+            target.focus();
+        }
+        document.addEventListener("keydown", onKeyDown);
+        return () => {
+            document.removeEventListener("keydown", onKeyDown);
+            activeTraps.splice(activeTraps.lastIndexOf(containerRef), 1);
+        };
+    }, [containerRef, active]);
+}
+//# sourceMappingURL=use-focus-trap.hooks.js.map

package/dist/features/panel-kit/hooks/use-serial-writes.hooks.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Writes on one lane must reach persistence in call order: a later write must not race an
+ * earlier one, and rejecting a write must neither poison the lane nor drop queued work.
+ * Independent row writes can use separate keys. Cancellation, deduplication and newest-result
+ * UI ownership belong to the caller; queued final writes may still be needed after unmount.
+ * When composing with useSettlementGeneration, mint the generation BEFORE run({ task }),
+ * not inside task: otherwise each delayed task can claim to be current when it finally starts.
+ *
+ * Even an idle lane starts its task one microtask later, leaving synchronous busy/error and
+ * generation bookkeeping ahead of execution. run returns the task's own outcome; internal
+ * lane cleanup does not swallow a discarded rejecting promise's unhandled rejection.
+ * Re-entrant run calls queue normally, but awaiting an inner call from a task on the same
+ * lane deadlocks: the inner task is waiting for the outer task to release that lane.
+ */
+export interface SerialWrites {
+    /** Each caller observes its own task result or rejection, never the internal lane tail. */
+    run<T>({ task }: {
+        task: () => Promise<T>;
+    }, options?: {
+        key?: string;
+    }): Promise<T>;
+}
+/** Stable promise lane: queue writes in call order without poisoning later work after rejection.
+ * Already queued persistence continues after unmount; callers guard their own state updates. */
+export declare function useSerialWrites(): SerialWrites;
+//# sourceMappingURL=use-serial-writes.hooks.d.ts.map

package/dist/features/panel-kit/hooks/use-serial-writes.hooks.js

@@ -0,0 +1,41 @@
+import { useRef } from "react";
+const DEFAULT_LANE = Symbol("useSerialWrites default lane");
+const IDLE = Promise.resolve();
+function createSerialWrites() {
+    // Each lane's tail is the promise the NEXT queued task waits on; a lane is dropped from the
+    // map once its own tail settles and nothing newer has replaced it, so a keyed caller (only
+    // `use-external-mcp.hooks.ts` today) cannot grow this map without bound.
+    const tails = new Map();
+    return {
+        run({ task }, options) {
+            const lane = options?.key ?? DEFAULT_LANE;
+            const prior = tails.get(lane) ?? IDLE;
+            let release;
+            const tail = new Promise((resolve) => {
+                release = resolve;
+            });
+            tails.set(lane, tail);
+            return prior.then(async () => {
+                try {
+                    return await task();
+                }
+                finally {
+                    if (tails.get(lane) === tail)
+                        tails.delete(lane);
+                    release();
+                }
+            });
+        },
+    };
+}
+/** Stable promise lane: queue writes in call order without poisoning later work after rejection.
+ * Already queued persistence continues after unmount; callers guard their own state updates. */
+export function useSerialWrites() {
+    // Stable identity over a mutable ref, same reason as `useSettlementGeneration`: several
+    // adopting call sites put this in a `useCallback`/`useMemo` dependency list.
+    const ref = useRef(undefined);
+    if (!ref.current)
+        ref.current = createSerialWrites();
+    return ref.current;
+}
+//# sourceMappingURL=use-serial-writes.hooks.js.map

package/dist/features/panel-kit/hooks/use-settlement-generation.hooks.d.ts

@@ -0,0 +1,9 @@
+export interface SettlementGeneration {
+    next: () => number;
+    isCurrent: (required: {
+        generation: number;
+    }) => boolean;
+}
+/** Stable monotonic generation handle for rejecting stale asynchronous settlements. */
+export declare function useSettlementGeneration(): SettlementGeneration;
+//# sourceMappingURL=use-settlement-generation.hooks.d.ts.map

package/dist/features/panel-kit/hooks/use-settlement-generation.hooks.js

@@ -0,0 +1,25 @@
+import { useRef } from "react";
+/** Stable monotonic generation handle for rejecting stale asynchronous settlements. */
+export function useSettlementGeneration() {
+    const ref = useRef(0);
+    // Same-tick calls must observe each other's increment. A state counter would let both read the
+    // pre-commit value. This API models self-minted settlements, not field-edit versions or a counter
+    // another operation only peeks at; those ambient guards need their own accurately scoped refs.
+    // The returned object's IDENTITY must be stable across renders, not just the counter it closes
+    // over: several adopting call sites (`use-access-tokens.hooks.ts`'s `reloadAllStores`, `use-sites
+    // .hooks.ts`'s `activate`) are themselves wrapped in a `useCallback` that other code relies on
+    // keeping a stable identity (e.g. `triggerReload`, so `useContentRefreshSubscription` doesn't
+    // resubscribe on every render) — an object literal rebuilt every render would force either an
+    // ESLint exhaustive-deps addition that defeats that memoization, or an intentional lint
+    // suppression to omit it. Built once via a lazily-initialized ref, the same "stable handle over a
+    // mutable ref" shape `useState`'s own setter uses.
+    const apiRef = useRef(undefined);
+    if (!apiRef.current) {
+        apiRef.current = {
+            next: () => (ref.current += 1),
+            isCurrent: ({ generation }) => ref.current === generation,
+        };
+    }
+    return apiRef.current;
+}
+//# sourceMappingURL=use-settlement-generation.hooks.js.map

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

@@ -0,0 +1,19 @@
+export * from './fetch-query/index.js';
+export { useFocusTrap } from './hooks/use-focus-trap.hooks.js';
+export { useDirtyGuard } from './hooks/use-dirty-guard.hooks.js';
+export type { DirtyGuard } from './hooks/use-dirty-guard.hooks.js';
+export { useAsyncAction } from './hooks/use-async-action.hooks.js';
+export type { AsyncActionState } from './hooks/use-async-action.hooks.js';
+export { useSerialWrites } from './hooks/use-serial-writes.hooks.js';
+export type { SerialWrites } from './hooks/use-serial-writes.hooks.js';
+export { useSettlementGeneration } from './hooks/use-settlement-generation.hooks.js';
+export type { SettlementGeneration } from './hooks/use-settlement-generation.hooks.js';
+export { formatTimestamp, formatRelativeMinutesAgo } from './helpers/format-timestamp.js';
+export { resolveActiveTabId } from './helpers/resolve-active-tab-id.js';
+export { hasPermission } from './helpers/permissions.js';
+export { isAbortError, retryWhileUnreachable, UNREACHABLE_RETRY_DELAYS_MS } from './helpers/retry-unreachable.js';
+export { buildAgentListHandles } from '@jini-ai/agentic';
+export { createDictionaryTranslator, interpolate, splitOnPlaceholders, pickPlural } from '../i18n/index.js';
+export type { Translate, DictionaryTranslator, LocaleDictionary } from '../i18n/index.js';
+export type { DirtyGuardHostPort } from './hooks/use-dirty-guard.hooks.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/features/panel-kit/index.js

@@ -0,0 +1,13 @@
+export * from './fetch-query/index.js';
+export { useFocusTrap } from './hooks/use-focus-trap.hooks.js';
+export { useDirtyGuard } from './hooks/use-dirty-guard.hooks.js';
+export { useAsyncAction } from './hooks/use-async-action.hooks.js';
+export { useSerialWrites } from './hooks/use-serial-writes.hooks.js';
+export { useSettlementGeneration } from './hooks/use-settlement-generation.hooks.js';
+export { formatTimestamp, formatRelativeMinutesAgo } from './helpers/format-timestamp.js';
+export { resolveActiveTabId } from './helpers/resolve-active-tab-id.js';
+export { hasPermission } from './helpers/permissions.js';
+export { isAbortError, retryWhileUnreachable, UNREACHABLE_RETRY_DELAYS_MS } from './helpers/retry-unreachable.js';
+export { buildAgentListHandles } from '@jini-ai/agentic';
+export { createDictionaryTranslator, interpolate, splitOnPlaceholders, pickPlural } from '../i18n/index.js';
+//# sourceMappingURL=index.js.map

package/dist/features/privacy/react/components/PrivacyTab.js

@@ -4,7 +4,7 @@ import { useT } from '../../../i18n/index.js';
 import { Icon } from '../../../../react/components/Icon.js';
 import { hasMadeConsentDecision, isSharingEnabled, nextStateForDeclineAll, nextStateForDeleteMyData, nextStateForShareAll, nextStateForTelemetryPatch, } from '../../rules.js';
 function ToggleRow({ label, hint, checked, onChange, agentHandle }) {
-    return (_jsxs("button", { type: "button", className: `jini-toggle-row${checked ? ' on' : ''}`, onClick: () => onChange(!checked), "aria-pressed": checked, ...agentHandleProps(agentHandle, { role: 'checkbox', label }), children: [_jsxs("div", { className: "jini-toggle-row-text", children: [_jsx("span", { className: "jini-toggle-row-label", children: label }), _jsx("span", { className: "jini-toggle-row-hint", children: hint })] }), _jsx("span", { className: "jini-toggle-row-switch", "aria-hidden": true })] }));
+    return (_jsxs("button", { type: "button", className: `jini-toggle-row${checked ? ' on' : ''}`, onClick: () => onChange(!checked), "aria-pressed": checked, ...agentHandleProps({}, { base: agentHandle, ...({ role: 'checkbox', label }) }), children: [_jsxs("div", { className: "jini-toggle-row-text", children: [_jsx("span", { className: "jini-toggle-row-label", children: label }), _jsx("span", { className: "jini-toggle-row-hint", children: hint })] }), _jsx("span", { className: "jini-toggle-row-switch", "aria-hidden": true })] }));
 }
 /**
  * Telemetry consent card (share/decline + two per-category toggles) over a
@@ -32,6 +32,6 @@ export function PrivacyTab({ state, onChange, labels, now = Date.now, agentHandl
     const installationIdHint = labels?.installationIdHint ?? t('An anonymous id used to group your shared data.');
     const optedOutLabel = labels?.optedOutLabel ?? t('Not sharing');
     const deleteMyDataLabel = labels?.deleteMyDataLabel ?? t('Delete my data');
-    return (_jsxs("section", { className: "jini-settings-section jini-settings-privacy", children: [_jsxs("div", { className: "jini-settings-subsection", children: [_jsx("div", { className: "jini-section-head", children: _jsxs("div", { children: [_jsx("h4", { children: consentKicker }), _jsx("p", { className: "jini-hint", children: consentLead })] }) }), _jsxs("dl", { className: "jini-settings-privacy-disclosure", children: [_jsxs("div", { children: [_jsx("dt", { children: metricsLabel }), _jsx("dd", { children: metricsHint })] }), _jsxs("div", { children: [_jsx("dt", { children: contentLabel }), _jsx("dd", { children: contentHint })] })] }), _jsx("p", { className: "jini-hint", children: consentFooter }), _jsxs("div", { className: "jini-privacy-consent-actions", role: "group", "aria-label": consentKicker, children: [_jsx("button", { type: "button", className: `jini-privacy-consent-action${sharing === false ? ' is-active' : ''}`, "aria-pressed": sharing === false, onClick: () => onChange(nextStateForDeclineAll(state, now())), ...agentHandleProps(agentHandle, { action: 'decline', role: 'button', label: declineLabel }), children: declineLabel }), _jsx("button", { type: "button", className: `jini-privacy-consent-action jini-privacy-consent-action--primary${sharing === true ? ' is-active' : ''}`, "aria-pressed": sharing === true, onClick: () => onChange(nextStateForShareAll(state, now())), ...agentHandleProps(agentHandle, { action: 'share', role: 'button', label: shareLabel }), children: shareLabel })] })] }), decided ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: "jini-settings-privacy-toggles", children: [_jsx(ToggleRow, { label: metricsLabel, hint: metricsHint, checked: state.telemetry.metrics === true, onChange: (v) => onChange(nextStateForTelemetryPatch(state, { metrics: v }, now())), ...(agentHandle ? { agentHandle: agentSubHandle(agentHandle, 'metrics-toggle') } : {}) }), _jsx(ToggleRow, { label: contentLabel, hint: contentHint, checked: state.telemetry.content === true, onChange: (v) => onChange(nextStateForTelemetryPatch(state, { content: v }, now())), ...(agentHandle ? { agentHandle: agentSubHandle(agentHandle, 'content-toggle') } : {}) })] }), _jsxs("div", { className: "jini-settings-subsection", children: [_jsx("div", { className: "jini-section-head", children: _jsxs("div", { children: [_jsx("h4", { children: installationIdLabel }), _jsx("p", { className: "jini-hint", children: installationIdHint })] }) }), _jsx("div", { className: "jini-settings-field", children: _jsx("input", { type: "text", readOnly: true, value: state.installationId ?? optedOutLabel, "aria-label": installationIdLabel, ...agentHandleProps(agentHandle, { action: 'installation-id', role: 'field', label: installationIdLabel }) }) }), _jsxs("button", { type: "button", className: "jini-button jini-button-ghost", onClick: () => onChange(nextStateForDeleteMyData(state, now())), ...agentHandleProps(agentHandle, { action: 'delete-my-data', role: 'button', label: deleteMyDataLabel }), children: [_jsx(Icon, { name: "trash", size: 13 }), _jsx("span", { children: deleteMyDataLabel })] })] })] })) : null] }));
+    return (_jsxs("section", { className: "jini-settings-section jini-settings-privacy", children: [_jsxs("div", { className: "jini-settings-subsection", children: [_jsx("div", { className: "jini-section-head", children: _jsxs("div", { children: [_jsx("h4", { children: consentKicker }), _jsx("p", { className: "jini-hint", children: consentLead })] }) }), _jsxs("dl", { className: "jini-settings-privacy-disclosure", children: [_jsxs("div", { children: [_jsx("dt", { children: metricsLabel }), _jsx("dd", { children: metricsHint })] }), _jsxs("div", { children: [_jsx("dt", { children: contentLabel }), _jsx("dd", { children: contentHint })] })] }), _jsx("p", { className: "jini-hint", children: consentFooter }), _jsxs("div", { className: "jini-privacy-consent-actions", role: "group", "aria-label": consentKicker, children: [_jsx("button", { type: "button", className: `jini-privacy-consent-action${sharing === false ? ' is-active' : ''}`, "aria-pressed": sharing === false, onClick: () => onChange(nextStateForDeclineAll(state, now())), ...agentHandleProps({}, { base: agentHandle, ...({ action: 'decline', role: 'button', label: declineLabel }) }), children: declineLabel }), _jsx("button", { type: "button", className: `jini-privacy-consent-action jini-privacy-consent-action--primary${sharing === true ? ' is-active' : ''}`, "aria-pressed": sharing === true, onClick: () => onChange(nextStateForShareAll(state, now())), ...agentHandleProps({}, { base: agentHandle, ...({ action: 'share', role: 'button', label: shareLabel }) }), children: shareLabel })] })] }), decided ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: "jini-settings-privacy-toggles", children: [_jsx(ToggleRow, { label: metricsLabel, hint: metricsHint, checked: state.telemetry.metrics === true, onChange: (v) => onChange(nextStateForTelemetryPatch(state, { metrics: v }, now())), ...(agentHandle ? { agentHandle: agentSubHandle({ base: agentHandle, action: 'metrics-toggle' }) } : {}) }), _jsx(ToggleRow, { label: contentLabel, hint: contentHint, checked: state.telemetry.content === true, onChange: (v) => onChange(nextStateForTelemetryPatch(state, { content: v }, now())), ...(agentHandle ? { agentHandle: agentSubHandle({ base: agentHandle, action: 'content-toggle' }) } : {}) })] }), _jsxs("div", { className: "jini-settings-subsection", children: [_jsx("div", { className: "jini-section-head", children: _jsxs("div", { children: [_jsx("h4", { children: installationIdLabel }), _jsx("p", { className: "jini-hint", children: installationIdHint })] }) }), _jsx("div", { className: "jini-settings-field", children: _jsx("input", { type: "text", readOnly: true, value: state.installationId ?? optedOutLabel, "aria-label": installationIdLabel, ...agentHandleProps({}, { base: agentHandle, ...({ action: 'installation-id', role: 'field', label: installationIdLabel }) }) }) }), _jsxs("button", { type: "button", className: "jini-button jini-button-ghost", onClick: () => onChange(nextStateForDeleteMyData(state, now())), ...agentHandleProps({}, { base: agentHandle, ...({ action: 'delete-my-data', role: 'button', label: deleteMyDataLabel }) }), children: [_jsx(Icon, { name: "trash", size: 13 }), _jsx("span", { children: deleteMyDataLabel })] })] })] })) : null] }));
 }
 //# sourceMappingURL=PrivacyTab.js.map

package/dist/features/privacy/types.d.ts

@@ -4,7 +4,7 @@
  * telemetry-consent card (share/decline + two per-category toggles) over a
  * generic `{ metrics, content }` shape, plus an installation-id
  * generate/rotate flow. Verified generic for this task (see
- * `packages/ui/source-map.md` for the full note): the only OD coupling was
+ * `packages/ui/archived provenance ledger` for the full note): the only OD coupling was
  * the `AppConfig`/`TelemetryConfig` type import (replaced by the local
  * types below) and the analytics tracking calls (dropped, same as every
  * other tab in this feature).

package/dist/features/privacy/types.js

@@ -4,7 +4,7 @@
  * telemetry-consent card (share/decline + two per-category toggles) over a
  * generic `{ metrics, content }` shape, plus an installation-id
  * generate/rotate flow. Verified generic for this task (see
- * `packages/ui/source-map.md` for the full note): the only OD coupling was
+ * `packages/ui/archived provenance ledger` for the full note): the only OD coupling was
  * the `AppConfig`/`TelemetryConfig` type import (replaced by the local
  * types below) and the analytics tracking calls (dropped, same as every
  * other tab in this feature).

package/dist/features/progress-card/reference-adapters.d.ts

@@ -6,7 +6,7 @@
  * on that package, and any host whose real types are a structural superset
  * can pass them in directly. Field-level provenance and what was
  * deliberately dropped (a Bash `rm`-command heuristic from the file-ops
- * derivation) are documented in `packages/ui/source-map.md`.
+ * derivation) are documented in `packages/ui/archived provenance ledger`.
  *
  * These adapters are shipped as documented reference material, not as the
  * package's primary port surface — a host with its own run/job shape maps