@jini-ai/admin 0.4.12 → 0.4.13

package/dist/widgets/conformance/widgets-api.conformance.js

@@ -9,6 +9,14 @@ export async function runWidgetsApiConformance({ api }, _optional = {}) {
     catch {
         rejected = true;
     } assert(rejected, name); }
+    const probe = { api, assert, rejects };
+    const { widget, updated } = await checkInstanceLifecycle({ probe });
+    await checkRegionPlacements({ probe, widget, updated });
+    await checkAbortsAndMissing({ probe, widget, updated });
+    await checkTrash({ probe, widget });
+    return checks;
+}
+async function checkInstanceLifecycle({ probe: { api, assert, rejects } }, _optional = {}) {
     const input = { widgetType: 'text', title: 'Conformance widget', config: { body: 'initial' } };
     const { widget } = await api.createWidget(input);
     assert(widget.id.length > 0 && widget.slug.length > 0 && widget.status === 'active', 'create active instance');
@@ -22,6 +30,9 @@ export async function runWidgetsApiConformance({ api }, _optional = {}) {
     assert(updated.title === widget.title && updated.version > widget.version, 'omitted title preserved and version advances');
     assert(widget.config.body === 'initial' && firstList.widgets.find(w => w.id === widget.id)?.version === widget.version, 'prior snapshots stay detached');
     await rejects(() => api.updateWidget({ id: widget.id, baseVersion: widget.version, config: {} }), 'stale instance write rejects');
+    return { widget, updated };
+}
+async function checkRegionPlacements({ probe: { api, assert, rejects }, widget, updated }, _optional = {}) {
     const regionKey = `conformance-${widget.id}`;
     const { area } = await api.bindWidgetRegion({ regionKey });
     const initialAreaVersion = area.version;
@@ -40,6 +51,8 @@ export async function runWidgetsApiConformance({ api }, _optional = {}) {
     assert(placed.placements[2]?.broken === true, 'broken reference remains visible');
     assert((await api.listWidgetRegions({})).regions.find(r => r.regionKey === regionKey)?.placementCount === placements.length, 'region list placement count updates');
     await rejects(() => api.mutateWidgetRegionPlacements({ regionKey, baseVersion: area.version, placements: [] }), 'stale region write rejects');
+}
+async function checkAbortsAndMissing({ probe: { api, assert, rejects }, widget, updated }, _optional = {}) {
     const abort = new AbortController();
     abort.abort();
     await rejects(() => api.listWidgets({}, { signal: abort.signal }), 'aborted list rejects');
@@ -47,9 +60,10 @@ export async function runWidgetsApiConformance({ api }, _optional = {}) {
     assert((await api.getWidget({ id: widget.id })).widget.title === widget.title, 'aborted write has no effects');
     await rejects(() => api.getWidget({ id: 'missing-conformance-widget' }), 'missing instance rejects');
     await rejects(() => api.getWidgetRegion({ regionKey: 'missing-conformance-region' }), 'missing region rejects');
+}
+async function checkTrash({ probe: { api, assert }, widget }, _optional = {}) {
     await api.trashWidget({ id: widget.id });
     assert(!(await api.listWidgets({})).widgets.some(w => w.id === widget.id), 'trash removes active listing');
     assert((await api.listWidgets({ includeInactive: true })).widgets.find(w => w.id === widget.id)?.status === 'trash', 'trash retained for shared lifecycle');
-    return checks;
 }
 //# sourceMappingURL=widgets-api.conformance.js.map

package/dist/widgets/controllers/instance-editor.controller.js

@@ -14,6 +14,8 @@ export function createWidgetInstanceEditorController({ api, params: initialParam
             config: isNew ? defaultConfig(params.widgetType ?? 'text') : {}, message: null, error: null, fieldErrors: [],
             loading: !isNew, saving: false, widgetType: resolveEditorWidgetType({ isNew, queryWidgetType: params.widgetType, widget: null }),
         } });
+    const isLiveLoad = ({ ticket }) => ticket === generation && !store.signal.aborted;
+    const isLiveSave = ({ savingFor }) => currentKey() === savingFor && !store.signal.aborted;
     async function load(_required = {}, _optional = {}) {
         const ticket = ++generation;
         const isNew = params.widgetId === null;
@@ -22,27 +24,31 @@ export function createWidgetInstanceEditorController({ api, params: initialParam
             store.set({ patch: { widget: null, title: '', config: defaultConfig(params.widgetType ?? 'text'), whereUsed: { count: 0, references: [] }, loading: false, widgetType: params.widgetType } });
             return;
         }
-        const requestedId = params.widgetId;
+        await loadExisting({ ticket, requestedId: params.widgetId });
+    }
+    async function loadExisting({ ticket, requestedId }, _optional = {}) {
         store.set({ patch: { loading: true, error: null } });
         try {
             const result = await api.getWidget({ id: requestedId }, { signal: store.signal });
-            if (ticket !== generation || store.signal.aborted)
-                return;
-            store.set({ patch: { widget: result.widget, title: result.widget.title, config: result.widget.config, whereUsed: result.whereUsed, widgetType: result.widget.widgetType } });
-            // Replace rather than push: an old id bookmark should not add a Back-button stop.
-            const redirect = widgetSlugRedirectPath({ requestedId, widget: result.widget }, { slugRedirectPath });
-            if (redirect)
-                navigate?.(redirect, { replace: true });
+            if (isLiveLoad({ ticket }))
+                applyLoaded({ requestedId, result });
         }
         catch (error) {
-            if (ticket === generation && !store.signal.aborted)
+            if (isLiveLoad({ ticket }))
                 store.set({ patch: { error: describeApiError({ e: widgetApiError({ error }) ?? error, fallback: t('failed to load widget') }) } });
         }
         finally {
-            if (ticket === generation && !store.signal.aborted)
+            if (isLiveLoad({ ticket }))
                 store.set({ patch: { loading: false } });
         }
     }
+    function applyLoaded({ requestedId, result }, _optional = {}) {
+        store.set({ patch: { widget: result.widget, title: result.widget.title, config: result.widget.config, whereUsed: result.whereUsed, widgetType: result.widget.widgetType } });
+        // Replace rather than push: an old id bookmark should not add a Back-button stop.
+        const redirect = widgetSlugRedirectPath({ requestedId, widget: result.widget }, { slugRedirectPath });
+        if (redirect)
+            navigate?.(redirect, { replace: true });
+    }
     async function save(_required = {}, _optional = {}) {
         const { widgetType, isNew, widget, title, config } = store.getSnapshot();
         if (!widgetType)
@@ -50,28 +56,31 @@ export function createWidgetInstanceEditorController({ api, params: initialParam
         const savingFor = currentKey();
         store.set({ patch: { saving: true, message: null, error: null, fieldErrors: [] } });
         try {
-            if (isNew) {
-                const { widget: created } = await api.createWidget({ widgetType, title, config }, { signal: store.signal });
-                // Creation intentionally navigates even if route identity changed while it was in flight.
-                navigate?.(`/widgets/${created.slug}`);
-                return;
-            }
-            if (!widget)
-                return;
-            const { widget: saved } = await api.updateWidget({ id: widget.id, baseVersion: widget.version, title, config }, { signal: store.signal });
-            if (currentKey() !== savingFor || store.signal.aborted)
-                return;
-            store.set({ patch: { widget: saved, title: saved.title, config: saved.config, widgetType: saved.widgetType, message: t('Saved · version {version}').replace('{version}', String(saved.version)) } });
+            if (isNew)
+                await createAndOpen({ widgetType, title, config });
+            else if (widget)
+                await updateExisting({ widget, title, config, savingFor });
         }
         catch (error) {
-            if (currentKey() === savingFor && !store.signal.aborted)
+            if (isLiveSave({ savingFor }))
                 store.set({ patch: resolveWidgetSaveError({ error }, { t }) });
         }
         finally {
-            if (currentKey() === savingFor && !store.signal.aborted)
+            if (isLiveSave({ savingFor }))
                 store.set({ patch: { saving: false } });
         }
     }
+    async function createAndOpen({ widgetType, title, config }, _optional = {}) {
+        const { widget: created } = await api.createWidget({ widgetType, title, config }, { signal: store.signal });
+        // Creation intentionally navigates even if route identity changed while it was in flight.
+        navigate?.(`/widgets/${created.slug}`);
+    }
+    async function updateExisting({ widget, title, config, savingFor }, _optional = {}) {
+        const { widget: saved } = await api.updateWidget({ id: widget.id, baseVersion: widget.version, title, config }, { signal: store.signal });
+        if (!isLiveSave({ savingFor }))
+            return;
+        store.set({ patch: { widget: saved, title: saved.title, config: saved.config, widgetType: saved.widgetType, message: t('Saved · version {version}').replace('{version}', String(saved.version)) } });
+    }
     return {
         getSnapshot: store.getSnapshot, subscribe: store.subscribe, load, save,
         setParams({ params: next }, _optional = {}) {

package/dist/widgets/controllers/library.controller.js

@@ -6,17 +6,17 @@ import { widgetsEnglish } from '../messages.en.js';
 export function createWidgetsLibraryController({ api }, { t = widgetsEnglish } = {}) {
     const store = createControllerStore({ initial: { widgets: null, error: null, skippedCount: 0, skippedIds: [], createType: 'text', pendingTrash: null, trashingId: null } });
     let generation = 0;
+    const isLiveRead = ({ ticket }) => ticket === generation && !store.signal.aborted;
     async function load(_required = {}, _optional = {}) {
         const ticket = ++generation;
         try {
             // No includeInactive: trashed widgets belong to the shared Trash screen.
             const result = await api.listWidgets({}, { signal: store.signal });
-            if (ticket !== generation || store.signal.aborted)
-                return;
-            store.set({ patch: { widgets: result.widgets, skippedCount: result.skippedCount ?? 0, skippedIds: result.skippedIds ?? [] } });
+            if (isLiveRead({ ticket }))
+                store.set({ patch: { widgets: result.widgets, skippedCount: result.skippedCount ?? 0, skippedIds: result.skippedIds ?? [] } });
         }
         catch (e) {
-            if (ticket === generation && !store.signal.aborted)
+            if (isLiveRead({ ticket }))
                 store.set({ patch: { error: describeApiError({ e: widgetApiError({ error: e }) ?? e, fallback: t('failed to load widgets') }) } });
         }
     }
@@ -30,18 +30,24 @@ export function createWidgetsLibraryController({ api }, { t = widgetsEnglish } =
             void load();
         }
         catch (error) {
-            const e = widgetApiError({ error });
-            if (e?.code === 'NOT_FOUND')
-                void load();
-            else
-                store.set({ patch: { error: e?.code === 'TRASH_VERSION_CHANGED' ? t('This item changed since you loaded it. Reload and try again.') : describeApiError({ e: e ?? error, fallback: t('delete failed') }) } });
+            handleTrashFailure({ error });
         }
         finally {
-            // A's completion cannot close a newly opened confirmation for B.
-            const current = store.getSnapshot();
-            store.set({ patch: { trashingId: current.trashingId === widget.id ? null : current.trashingId, pendingTrash: current.pendingTrash?.id === widget.id ? null : current.pendingTrash } });
+            settleTrash({ widget });
         }
     }
+    function handleTrashFailure({ error }, _optional = {}) {
+        const e = widgetApiError({ error });
+        if (e?.code === 'NOT_FOUND')
+            void load();
+        else
+            store.set({ patch: { error: e?.code === 'TRASH_VERSION_CHANGED' ? t('This item changed since you loaded it. Reload and try again.') : describeApiError({ e: e ?? error, fallback: t('delete failed') }) } });
+    }
+    function settleTrash({ widget }, _optional = {}) {
+        // A's completion cannot close a newly opened confirmation for B.
+        const current = store.getSnapshot();
+        store.set({ patch: { trashingId: current.trashingId === widget.id ? null : current.trashingId, pendingTrash: current.pendingTrash?.id === widget.id ? null : current.pendingTrash } });
+    }
     return {
         getSnapshot: store.getSnapshot, subscribe: store.subscribe, load, confirmTrash,
         setCreateType({ type }, _optional = {}) { store.set({ patch: { createType: type } }); },

package/dist/widgets/controllers/region-editor.controller.js

@@ -6,20 +6,21 @@ import { widgetsEnglish } from '../messages.en.js';
 export function createWidgetRegionEditorController({ api, regionKey: initialKey }, { t = widgetsEnglish } = {}) {
     const store = createControllerStore({ initial: { area: null, placements: [], message: null, error: null, loading: true, saving: false } });
     let regionKey = initialKey, generation = 0;
+    const isLiveRead = ({ ticket }) => ticket === generation && !store.signal.aborted;
     async function load(_required = {}, _optional = {}) {
         const ticket = ++generation;
         store.set({ patch: { loading: true, error: null, saving: false } });
         try {
             const result = await api.getWidgetRegion({ regionKey }, { signal: store.signal });
-            if (ticket === generation && !store.signal.aborted)
+            if (isLiveRead({ ticket }))
                 store.set({ patch: { area: result.area, placements: result.placements } });
         }
         catch (error) {
-            if (ticket === generation && !store.signal.aborted)
+            if (isLiveRead({ ticket }))
                 store.set({ patch: { error: describeApiError({ e: widgetApiError({ error }) ?? error, fallback: t('failed to load region') }) } });
         }
         finally {
-            if (ticket === generation && !store.signal.aborted)
+            if (isLiveRead({ ticket }))
                 store.set({ patch: { loading: false } });
         }
     }
@@ -40,7 +41,7 @@ export function createWidgetRegionEditorController({ api, regionKey: initialKey
         let stale = false;
         try {
             const { area: saved } = await api.mutateWidgetRegionPlacements({ regionKey, baseVersion: area.version, placements: placements.map(p => ({ placementId: p.placementId, widgetEntryId: p.widgetEntryId, enabled: p.enabled })) }, { signal: store.signal });
-            stale = ticket !== generation || store.signal.aborted;
+            stale = !isLiveRead({ ticket });
             if (stale)
                 return;
             store.set({ patch: { area: saved, message: t('Saved · version {version}').replace('{version}', String(saved.version)) } });
@@ -48,7 +49,7 @@ export function createWidgetRegionEditorController({ api, regionKey: initialKey
             void load();
         }
         catch (error) {
-            stale = ticket !== generation || store.signal.aborted;
+            stale = !isLiveRead({ ticket });
             if (!stale)
                 store.set({ patch: { error: resolveWidgetRegionSaveError({ error }, { t }) } });
         }

package/dist/widgets/react/hooks/page-views.hooks.d.ts

@@ -61,6 +61,7 @@ export declare function useWidgetInstanceEditorView({ widgetId, widgetType, widg
     widgetTypes: readonly WidgetTypeOption[];
     useWidgetInstanceEditorHook?: typeof useWiredWidgetInstanceEditor | undefined;
 }, _optional?: Record<string, never>): {
+    gate: import("../../rules.js").WidgetEditorGate;
     guard: import("../../rules.js").WidgetInstanceGuard | null;
     onBackClick: (event: MouseEvent<HTMLAnchorElement>) => void;
     isNew: boolean;

package/dist/widgets/react/hooks/page-views.hooks.js

@@ -19,12 +19,13 @@ export function useWidgetRegionEditorView({ regionKey, useWidgetRegionEditorHook
     const state = useWidgetRegionEditorHook(regionKey);
     return { ...state, placementHandles: buildAgentListHandles({ prefix: 'widget-region-placement', ids: state.placements.map(p => p.placementId) }) };
 }
-import { widgetInstanceGuard } from '../../rules.js';
+import { widgetEditorGate } from '../../rules.js';
 import { useWiredWidgetInstanceEditor } from './use-widget-instance-editor.hooks.js';
 /** The back-link cancellation also stops the host's document-level internal-link interceptor. */
 export function useWidgetInstanceEditorView({ widgetId, widgetType, widgetTypes, useWidgetInstanceEditorHook = useWiredWidgetInstanceEditor }, _optional = {}) {
     const state = useWidgetInstanceEditorHook({ widgetId, widgetType });
-    return { ...state, guard: widgetInstanceGuard({ ...state, types: widgetTypes }), onBackClick: (event) => { if (!state.confirmLeave())
+    const gate = widgetEditorGate({ ...state, types: widgetTypes });
+    return { ...state, gate, guard: gate.guard, onBackClick: (event) => { if (!state.confirmLeave())
             event.preventDefault(); } };
 }
 //# sourceMappingURL=page-views.hooks.js.map

package/dist/widgets/react/hooks/use-widget-regions.hooks.d.ts

@@ -13,7 +13,7 @@ export interface WidgetRegionsController {
 import type { AdminWidgetsPort, WidgetsEventsPort } from '../../ports.js';
 export declare function useWidgetRegions({ api }: {
     api: AdminWidgetsPort;
-}, { t, locale, events, navigate }?: {
+}, { t, events, navigate }?: {
     t?: Translate | undefined;
     locale?: string | undefined;
     events?: WidgetsEventsPort | undefined;

package/dist/widgets/react/hooks/use-widget-regions.hooks.js

@@ -6,7 +6,8 @@ import { createWidgetRegionsController } from '../../controllers/regions.control
 import { widgetsEnglish } from '../../messages.en.js';
 import { WIDGETS_REGIONS_RESOURCE } from '../../rules.js';
 import { useWidgetsPorts, useWidgetsOptions } from './WidgetsPorts.hooks.js';
-export function useWidgetRegions({ api }, { t = widgetsEnglish, locale = 'en', events, navigate } = {}) {
+import { useWidgetsNavigate } from './navigation.hooks.js';
+export function useWidgetRegions({ api }, { t = widgetsEnglish, events, navigate } = {}) {
     const cached = useWidgetRegionsQuery({ api });
     const invalidate = useInvalidate();
     const latest = useRef({ t, navigate });
@@ -14,7 +15,13 @@ export function useWidgetRegions({ api }, { t = widgetsEnglish, locale = 'en', e
     const { controller, snapshot } = useController({ create: () => createWidgetRegionsController({ api: cached.api }, { t: key => latest.current.t(key), navigate: path => latest.current.navigate?.(path) }), dependencies: [cached.api] }, { start: ({ controller }) => { void controller.load(); } });
     useEffect(() => { if (!controller)
         return; return events?.subscribe({ resource: WIDGETS_REGIONS_RESOURCE, onRefresh: () => invalidate({ key: WIDGET_QUERY_KEYS.regions }) }); }, [controller, events, invalidate]);
-    return { ...(snapshot ?? { regions: null, error: null, newRegionKey: '', binding: false }), regions: cached.query.data?.regions ?? snapshot?.regions ?? null, error: snapshot?.error ?? cached.query.error?.message ?? null, setNewRegionKey: value => controller?.setNewRegionKey({ value }), bind: async () => { await controller?.bind(); }, t };
+    return { ...mergeRegionsState({ snapshot, data: cached.query.data, queryError: cached.query.error }), setNewRegionKey: value => controller?.setNewRegionKey({ value }), bind: async () => { await controller?.bind(); }, t };
+}
+const EMPTY_REGIONS_STATE = { regions: null, error: null, newRegionKey: '', binding: false };
+/** Cached query data wins for the list; a controller error wins over a query error. */
+function mergeRegionsState({ snapshot, data, queryError }, _optional = {}) {
+    const state = snapshot ?? EMPTY_REGIONS_STATE;
+    return { ...state, regions: data?.regions ?? state.regions, error: state.error ?? queryError?.message ?? null };
 }
 export function useWiredWidgetRegions() {
     const { widgetsApi: api, widgetsEvents: events, widgetsNavigation } = useWidgetsPorts();
@@ -22,5 +29,4 @@ export function useWiredWidgetRegions() {
     const navigate = useWidgetsNavigate({ navigation: widgetsNavigation, navigationBase });
     return useWidgetRegions({ api }, { t, locale, events, navigate });
 }
-import { useWidgetsNavigate } from './navigation.hooks.js';
 //# sourceMappingURL=use-widget-regions.hooks.js.map

package/dist/widgets/react/hooks/use-widgets-library.hooks.js

@@ -14,11 +14,18 @@ export function useWidgetsLibrary({ api }, { t = widgetsEnglish, locale = 'en',
     const { controller, snapshot } = useController({ create: () => createWidgetsLibraryController({ api: cached.api }, { t: key => latestT.current(key) }), dependencies: [cached.api] }, { start: ({ controller }) => { void controller.load(); } });
     useEffect(() => { if (!controller)
         return; return events?.subscribe({ resource: WIDGETS_LIBRARY_RESOURCE, onRefresh: () => invalidate({ key: WIDGET_QUERY_KEYS.library }) }); }, [controller, events, invalidate]);
-    const state = snapshot ?? { widgets: null, error: null, skippedCount: 0, skippedIds: [], createType: 'text', pendingTrash: null, trashingId: null };
-    return { ...state, widgets: cached.query.data?.widgets ?? state.widgets, skippedCount: cached.query.data?.skippedCount ?? state.skippedCount, skippedIds: cached.query.data?.skippedIds ?? state.skippedIds, error: state.error ?? cached.query.error?.message ?? null, trashing: state.pendingTrash !== null && state.trashingId === state.pendingTrash.id,
+    return { ...mergeLibraryState({ snapshot, data: cached.query.data, queryError: cached.query.error }),
         setCreateType: type => controller?.setCreateType({ type }), requestTrash: widget => controller?.requestTrash({ widget }),
         confirmTrash: async () => { await controller?.confirmTrash(); }, cancelTrash: () => controller?.cancelTrash(), t, locale };
 }
+const EMPTY_LIBRARY_STATE = { widgets: null, error: null, skippedCount: 0, skippedIds: [], createType: 'text', pendingTrash: null, trashingId: null };
+function mergeLibraryState({ snapshot, data, queryError }, _optional = {}) {
+    const state = snapshot ?? EMPTY_LIBRARY_STATE;
+    return { ...state, ...cachedListFields({ state, data }), error: state.error ?? queryError?.message ?? null, trashing: state.pendingTrash !== null && state.trashingId === state.pendingTrash.id };
+}
+function cachedListFields({ state, data }, _optional = {}) {
+    return { widgets: data?.widgets ?? state.widgets, skippedCount: data?.skippedCount ?? state.skippedCount, skippedIds: data?.skippedIds ?? state.skippedIds };
+}
 export function useWiredWidgetsLibrary() {
     const { widgetsApi: api, widgetsEvents: events } = useWidgetsPorts();
     const { t, locale } = useWidgetsOptions();

package/dist/widgets/react/pages/WidgetInstanceEditor.d.ts

@@ -18,6 +18,6 @@ export interface WidgetInstanceEditorProps {
      */
     useWidgetInstanceEditorHook?: typeof useWiredWidgetInstanceEditor | undefined;
 }
-export declare function WidgetInstanceEditor(props: WidgetInstanceEditorProps): import("react").JSX.Element | null;
+export declare function WidgetInstanceEditor(props: WidgetInstanceEditorProps): import("react").JSX.Element;
 export default WidgetInstanceEditor;
 //# sourceMappingURL=WidgetInstanceEditor.d.ts.map

package/dist/widgets/react/pages/WidgetInstanceEditor.js

@@ -18,14 +18,13 @@ import { WhereUsedBanner, WidgetInstanceGuardNotice } from '../components/Widget
 export function WidgetInstanceEditor(props) {
     const { slots: { ConfigFields: WidgetConfigFields }, widgetTypes } = useWidgetsOptions();
     const { widgetId, widgetType: queryWidgetType, useWidgetInstanceEditorHook = useWiredWidgetInstanceEditor } = props;
-    const { isNew, widget, whereUsed, title, setTitle, config, setConfig, message, error, fieldErrors, loading, saving, widgetType, save, confirmLeave, t, locale, guard, onBackClick, } = useWidgetInstanceEditorView({ widgetId, widgetType: queryWidgetType, useWidgetInstanceEditorHook, widgetTypes });
-    if (guard)
-        return _jsx(WidgetInstanceGuardNotice, { guard: guard, t: t });
-    // Unreachable in practice — `widgetInstanceGuard`'s "no-type" case already covers a null
-    // `widgetType` above — but TS can't see through that opaque function call, so this narrows the
-    // type for the JSX below rather than asserting it with `!`.
-    if (!widgetType)
-        return null;
+    const { isNew, widget, whereUsed, title, setTitle, config, setConfig, message, error, fieldErrors, loading, saving, save, confirmLeave, t, locale, gate, onBackClick, } = useWidgetInstanceEditorView({ widgetId, widgetType: queryWidgetType, useWidgetInstanceEditorHook, widgetTypes });
+    if (gate.guard !== null)
+        return _jsx(WidgetInstanceGuardNotice, { guard: gate.guard, t: t });
+    // `widgetInstanceGuard`'s "no-type" case already covers a null `widgetType` above, but TS can't
+    // see through that opaque function call; `widgetEditorGate` hands back the narrowed type so the
+    // JSX below needs neither a `!` assertion nor a never-taken null check.
+    const { widgetType } = gate;
     // The host slot binds shared-component translations; screen copy uses the module t.
     const sharedT = t;
     return (_jsxs("div", { className: "page", children: [_jsxs("div", { className: "page-header page-header-split", ...agentHandle({ handle: "widget-instance-header" }, {

package/dist/widgets/rules.d.ts

@@ -79,14 +79,26 @@ export type WidgetInstanceGuard = {
     widgetType: string;
 };
 /** Catch a garbage ?type= before a live create editor can save it; existing types are server-validated. */
-export declare function widgetInstanceGuard({ error, isNew, widget, loading, widgetType, types }: {
+export declare function widgetInstanceGuard(required: WidgetInstanceGuardInput, _optional?: Record<string, never>): WidgetInstanceGuard | null;
+export interface WidgetInstanceGuardInput {
     error: string | null;
     isNew: boolean;
     widget: AdminWidget | null;
     loading: boolean;
     widgetType: string | null | undefined;
     types: readonly WidgetTypeOption[];
-}, _optional?: Record<string, never>): WidgetInstanceGuard | null;
+}
+/** The editor's gate: either the guard to render, or the widget type the live editor needs. Once no
+ *  guard applies the "no-type" case has already ruled out a missing type, and returning it here
+ *  carries that narrowing to the page, which otherwise needed its own never-taken null check. */
+export type WidgetEditorGate = {
+    guard: WidgetInstanceGuard;
+    widgetType?: undefined;
+} | {
+    guard: null;
+    widgetType: string;
+};
+export declare function widgetEditorGate({ error, isNew, widget, loading, widgetType, types }: WidgetInstanceGuardInput, _optional?: Record<string, never>): WidgetEditorGate;
 /** Match the original save identity, including the query type on /new. */
 export declare function widgetEntityKey({ params }: {
     params: WidgetEditorParams;

package/dist/widgets/rules.js

@@ -65,16 +65,19 @@ export function widgetSlugRedirectPath({ requestedId, widget }, { slugRedirectPa
     return slugRedirectPath?.('/widgets', requestedId, widget) ?? null;
 }
 /** Catch a garbage ?type= before a live create editor can save it; existing types are server-validated. */
-export function widgetInstanceGuard({ error, isNew, widget, loading, widgetType, types }, _optional = {}) {
+export function widgetInstanceGuard(required, _optional = {}) {
+    return widgetEditorGate(required).guard;
+}
+export function widgetEditorGate({ error, isNew, widget, loading, widgetType, types }, _optional = {}) {
     if (error && !isNew && !widget)
-        return { kind: 'fetch-error', message: error };
+        return { guard: { kind: 'fetch-error', message: error } };
     if (loading)
-        return { kind: 'loading' };
+        return { guard: { kind: 'loading' } };
     if (!widgetType)
-        return { kind: 'no-type' };
+        return { guard: { kind: 'no-type' } };
     if (isNew && !isKnownWidgetType({ widgetType, types }))
-        return { kind: 'unknown-type', widgetType };
-    return null;
+        return { guard: { kind: 'unknown-type', widgetType } };
+    return { guard: null, widgetType };
 }
 /** Match the original save identity, including the query type on /new. */
 export function widgetEntityKey({ params }, _optional = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/admin",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "description": "Composable admin surface for Jini-hosted products: framework-free contracts, panel registry, and route model in `/core`; React shell and panels in `/react`. Import only the layers you need.",
   "license": "Apache-2.0",
   "repository": {
@@ -13,6 +13,9 @@
     "kind": "state",
     "runtime": "universal",
     "entries": {
+      "./themes/default/admin.css": "browser",
+      "./themes/default/chat.css": "browser",
+      "./themes/default/manifest.json": "universal",
       ".": "universal",
       "./core": "universal",
       "./browser": "browser",
@@ -95,10 +98,15 @@
     }
   },
   "type": "module",
-  "sideEffects": false,
+  "sideEffects": [
+    "./src/themes/**/*.css"
+  ],
   "main": "./dist/core/index.js",
   "types": "./dist/core/index.d.ts",
   "exports": {
+    "./themes/default/admin.css": "./src/themes/default/admin.css",
+    "./themes/default/chat.css": "./src/themes/default/chat.css",
+    "./themes/default/manifest.json": "./src/themes/default/manifest.json",
     ".": {
       "types": "./dist/core/index.d.ts",
       "import": "./dist/core/index.js",
@@ -421,6 +429,7 @@
     }
   },
   "files": [
+    "src/themes",
     "dist",
     "README.md",
     "CHANGELOG.md",
@@ -482,12 +491,12 @@
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "@testing-library/user-event": "^14.6.1",
-    "@jini-ai/agentic": "^0.4.4",
-    "@jini-ai/agent-plugins": "^0.4.7",
-    "@jini-ai/ui-kit": "^0.1.4",
-    "@jini-ai/cms": "^0.5.13",
-    "@jini-ai/core": "^0.4.7",
-    "@jini-ai/ui": "^0.5.5"
+    "@jini-ai/ui-kit": "^0.1.5",
+    "@jini-ai/cms": "^0.5.14",
+    "@jini-ai/core": "^0.4.9",
+    "@jini-ai/agent-plugins": "^0.4.8",
+    "@jini-ai/agentic": "^0.4.5",
+    "@jini-ai/ui": "^0.5.6"
   },
   "typesVersions": {
     "*": {

package/src/themes/default/admin.css

@@ -0,0 +1,51 @@
+/* Default theme values, owned by @jini-ai/admin. Load after @jini-ai/ui structural CSS.
+   The UI contract keeps its legacy fallbacks during migration; these inputs equal them. */
+:root {
+  --jini-theme-light-bg: #ffffff;
+  --jini-theme-light-surface: #f5f5f5;
+  --jini-theme-light-text: #202020;
+  --jini-theme-light-muted: #666666;
+  --jini-theme-light-border: #d9d9d9;
+  --jini-theme-light-primary: #363636;
+  --jini-theme-light-primary-ink: #ffffff;
+  --jini-theme-light-danger: #b42318;
+  --jini-theme-light-success: #18763b;
+  --jini-theme-light-warning: #845800;
+  --jini-theme-dark-bg: #171717;
+  --jini-theme-dark-surface: #242424;
+  --jini-theme-dark-text: #f0f0f0;
+  --jini-theme-dark-muted: #b3b3b3;
+  --jini-theme-dark-border: #454545;
+  --jini-theme-dark-primary: #e0e0e0;
+  --jini-theme-dark-primary-ink: #202020;
+  --jini-theme-dark-danger: #ff8b80;
+  --jini-theme-dark-success: #79d69b;
+  --jini-theme-dark-warning: #ebc36b;
+  --jini-font-body: system-ui, sans-serif;
+  --jini-font-heading: system-ui, sans-serif;
+  --jini-font-mono: ui-monospace, monospace;
+  --jini-radius: 8px;
+  --jini-density: 1;
+
+  --jini-theme-panel-backdrop: none;
+  --jini-theme-panel-texture: none;
+  --jini-theme-overlay-backdrop: blur(4px);
+  --jini-theme-control-shadow: none;
+  --jini-theme-control-shadow-hover: none;
+  --jini-theme-control-shadow-pressed: none;
+  --jini-theme-control-shadow-inset: none;
+  --jini-theme-border-width: 1px;
+}
+
+/* Match existing neutral panels, tabbed-dialog scrims and controls. Role wiring is deferred. */
+/* Re-resolve scheme defaults here without shadowing inherited host --jini-theme-* inputs. */
+:root, [data-admin-theme], [data-color-scheme] {
+  --jini-default-app-bg: var(--jini-bg);
+  --jini-default-panel-bg: var(--jini-bg-panel);
+  --jini-default-panel-border: var(--jini-border);
+  --jini-default-panel-shadow: var(--jini-shadow-sm);
+  --jini-default-overlay-bg: var(--jini-backdrop);
+  --jini-default-overlay-shadow: var(--jini-shadow-lg);
+  --jini-default-control-bg: var(--jini-bg-elevated);
+  --jini-default-control-border: var(--jini-border-strong);
+}

package/src/themes/default/chat.css

@@ -0,0 +1,21 @@
+/* Standalone default chat palette: exactly ChatPane's existing injected values, including
+   its scheme-independent sent bubbles. Component defaults are migrated in a later step. */
+:root {
+  --jini-theme-chat-bg: #faf9f7;
+  --jini-theme-chat-panel: #fdfcfa;
+  --jini-theme-chat-text: #1a1916;
+  --jini-theme-chat-text-strong: #0d0c0a;
+  --jini-theme-chat-muted: #74716b;
+  --jini-theme-chat-faint: #b3b0a8;
+  --jini-theme-chat-border: #e1e5eb;
+  --jini-theme-chat-border-strong: #c9d0da;
+  --jini-theme-chat-border-soft: #edf0f4;
+  --jini-theme-chat-subtle: #f4f5f7;
+  --jini-theme-chat-accent: #c96442;
+  --jini-theme-chat-accent-soft: #fbeee5;
+  --jini-theme-chat-danger: #e5484d;
+  --jini-theme-chat-radius: 8px;
+  --jini-theme-chat-radius-lg: 12px;
+  --jini-theme-chat-user-bubble: #1a1b1c;
+  --jini-theme-chat-user-bubble-ink: #fff;
+}

package/src/themes/default/manifest.json

@@ -0,0 +1,29 @@
+{
+  "id": "default",
+  "name": "Jini Default",
+  "schemes": [
+    "light",
+    "dark"
+  ],
+  "stylesheets": {
+    "admin": "./admin.css",
+    "chat": "./chat.css"
+  },
+  "fonts": [],
+  "preview": {
+    "light": {
+      "bg": "#ffffff",
+      "surface": "#f5f5f5",
+      "text": "#202020",
+      "accent": "#363636",
+      "border": "#d9d9d9"
+    },
+    "dark": {
+      "bg": "#171717",
+      "surface": "#242424",
+      "text": "#f0f0f0",
+      "accent": "#e0e0e0",
+      "border": "#454545"
+    }
+  }
+}

package/dist/media/styles.d.ts

@@ -1,4 +0,0 @@
-/** Scoped feature presentation travels with compiled JS. It also overrides host dialog
- * CSS that can accidentally display a closed dialog or shrink a large media preview. */
-export declare const mediaStyles = "";
-//# sourceMappingURL=styles.d.ts.map

package/dist/media/styles.js

@@ -1,5 +0,0 @@
-/** Scoped feature presentation travels with compiled JS. It also overrides host dialog
- * CSS that can accidentally display a closed dialog or shrink a large media preview. */
-// Host CSS now supplies presentation and the closed-dialog safeguards on jini- classes.
-export const mediaStyles = '';
-//# sourceMappingURL=styles.js.map