@jini-ai/admin 0.4.11 → 0.4.13

package/dist/source-control/conformance/source-control-api.conformance.js

@@ -1,47 +1,77 @@
-/** Creates/deletes named test credentials: run only on a disposable authorized backend.
- * Supply connectionFields for providers with required fields beyond the canonical token. */
-export async function runSourceControlApiConformance({ api, providerId }, { connectionFields = {} } = {}) {
-    const checks = [], ids = [];
-    const assert = (ok, name) => { if (!ok)
-        throw new Error(`Source control conformance: ${name}`); checks.push(name); };
-    async function rejects(run, name) { let rejected = false; try {
-        await run();
+/** Records `name` as passed, or throws naming the provider and the failed check. */
+function pass({ run, ok, name }) {
+    if (!ok)
+        throw new Error(`Source control conformance failed for provider "${run.providerId}": ${name}`);
+    run.checks.push(name);
+}
+/** Passes `name` only when `attempt` rejects; the rejection reason itself is irrelevant to the contract. */
+async function refuses({ run, attempt, name }) {
+    let rejected = false;
+    try {
+        await attempt();
     }
     catch {
         rejected = true;
-    } assert(rejected, name); }
-    const connection = { ...connectionFields, providerId, token: 'conformance-only-token' };
+    }
+    pass({ run, ok: rejected, name });
+}
+async function checkCreate({ run }) {
+    const { api, providerId, connection } = run;
+    pass({ run, ok: (await api.providers({})).some(p => p.id === providerId), name: 'provider is listed' });
+    const first = await api.create({ label: 'conformance-first', connection });
+    run.ids.push(first.id);
+    pass({ run, ok: first.configured && !!first.id, name: 'create returns configured summary' });
+    pass({ run, ok: !('token' in first) && !('connection' in first), name: 'saved secrets never read back' });
+    pass({ run, ok: (await api.list({})).some(r => r.id === first.id), name: 'list contains created row' });
+    await refuses({ run, attempt: () => api.create({ label: 'conformance-first', connection }), name: 'duplicate label rejects' });
+    return first;
+}
+async function checkDefaultSlot({ run }) {
+    const { api, providerId, connection } = run;
+    const second = await api.create({ label: 'conformance-second', connection, isDefault: true });
+    run.ids.push(second.id);
+    const list = await api.list({});
+    pass({ run, ok: list.filter(r => r.providerId === providerId && r.isDefault).length === 1 && list.find(r => r.id === second.id)?.isDefault === true, name: 'server owns unique default slot' });
+}
+async function checkUpdates({ run, first }) {
+    const { api, providerId, connection } = run;
+    const renamed = await api.update({ id: first.id, patch: { label: 'conformance-renamed' } });
+    pass({ run, ok: renamed.label === 'conformance-renamed' && renamed.configured, name: 'metadata-only update preserves configured credential' });
+    pass({ run, ok: first.label === 'conformance-first', name: 'prior snapshots remain immutable' });
+    const replaced = await api.update({ id: first.id, patch: { connection } });
+    pass({ run, ok: replaced.id === first.id && replaced.label === renamed.label, name: 'replacement retains identity and label' });
+    await refuses({ run, attempt: () => api.update({ id: first.id, patch: { connection: { providerId, token: '' } } }), name: 'blank replacement rejects' });
+    return renamed;
+}
+async function checkAborts({ run, first, renamed }) {
+    const { api } = run;
+    const abort = new AbortController();
+    abort.abort();
+    await refuses({ run, attempt: () => api.list({}, { signal: abort.signal }), name: 'aborted list rejects' });
+    await refuses({ run, attempt: () => api.update({ id: first.id, patch: { label: 'bad' } }, { signal: abort.signal }), name: 'aborted write rejects' });
+    pass({ run, ok: (await api.list({})).find(r => r.id === first.id)?.label === renamed.label, name: 'aborted write has no effects' });
+}
+async function checkRemove({ run, first }) {
+    const { api } = run;
+    await api.remove({ id: first.id });
+    await api.remove({ id: first.id });
+    pass({ run, ok: !(await api.list({})).some(r => r.id === first.id), name: 'remove is idempotent' });
+    await refuses({ run, attempt: () => api.update({ id: first.id, patch: {} }), name: 'missing update rejects' });
+}
+/** Creates/deletes named test credentials: run only on a disposable authorized backend.
+ * Supply connectionFields for providers with required fields beyond the canonical token. */
+export async function runSourceControlApiConformance({ api, providerId }, { connectionFields = {} } = {}) {
+    const run = { api, providerId, connection: { ...connectionFields, providerId, token: 'conformance-only-token' }, ids: [], checks: [] };
     try {
-        assert((await api.providers({})).some(p => p.id === providerId), 'provider is listed');
-        const first = await api.create({ label: 'conformance-first', connection });
-        ids.push(first.id);
-        assert(first.configured && !!first.id, 'create returns configured summary');
-        assert(!('token' in first) && !('connection' in first), 'saved secrets never read back');
-        assert((await api.list({})).some(r => r.id === first.id), 'list contains created row');
-        await rejects(() => api.create({ label: 'conformance-first', connection }), 'duplicate label rejects');
-        const second = await api.create({ label: 'conformance-second', connection, isDefault: true });
-        ids.push(second.id);
-        const list = await api.list({});
-        assert(list.filter(r => r.providerId === providerId && r.isDefault).length === 1 && list.find(r => r.id === second.id)?.isDefault === true, 'server owns unique default slot');
-        const renamed = await api.update({ id: first.id, patch: { label: 'conformance-renamed' } });
-        assert(renamed.label === 'conformance-renamed' && renamed.configured, 'metadata-only update preserves configured credential');
-        assert(first.label === 'conformance-first', 'prior snapshots remain immutable');
-        const replaced = await api.update({ id: first.id, patch: { connection } });
-        assert(replaced.id === first.id && replaced.label === renamed.label, 'replacement retains identity and label');
-        await rejects(() => api.update({ id: first.id, patch: { connection: { providerId, token: '' } } }), 'blank replacement rejects');
-        const abort = new AbortController();
-        abort.abort();
-        await rejects(() => api.list({}, { signal: abort.signal }), 'aborted list rejects');
-        await rejects(() => api.update({ id: first.id, patch: { label: 'bad' } }, { signal: abort.signal }), 'aborted write rejects');
-        assert((await api.list({})).find(r => r.id === first.id)?.label === renamed.label, 'aborted write has no effects');
-        await api.remove({ id: first.id });
-        await api.remove({ id: first.id });
-        assert(!(await api.list({})).some(r => r.id === first.id), 'remove is idempotent');
-        await rejects(() => api.update({ id: first.id, patch: {} }), 'missing update rejects');
-        return Object.freeze(checks);
+        const first = await checkCreate({ run });
+        await checkDefaultSlot({ run });
+        const renamed = await checkUpdates({ run, first });
+        await checkAborts({ run, first, renamed });
+        await checkRemove({ run, first });
+        return Object.freeze(run.checks);
     }
     finally {
-        for (const id of ids)
+        for (const id of run.ids)
             await api.remove({ id });
     }
 }

package/dist/source-control/controllers/source-control.controller.js

@@ -1,5 +1,16 @@
 import { createControllerStore } from '../../core/module/controller-store.js';
 import { blankSourceControlDraft, sourceControlProviders, defaultSourceControlCredential, sourceControlReady, buildSourceControlConnection, sourceControlSummary, sourceControlErrorMessage } from '../rules.js';
+/** The provider and draft a save would submit, or null when the loaded state cannot accept a save for `providerId`. */
+function readySaveTarget({ state, providerId }) {
+    const draft = state.drafts[providerId] ?? blankSourceControlDraft({});
+    const info = sourceControlProviders({ providers: state.providers, credentials: state.credentials }).find(p => p.id === providerId);
+    return state.loaded && !draft.saving && info && sourceControlReady({ info, draft }) ? { info, draft } : null;
+}
+/** Replaces the row with `summary`'s id in place, or appends `summary` when it is new. */
+function spliceCredential({ credentials, summary }) {
+    // Preserve server order: the first row is the defensive default when no row is marked default.
+    return Object.freeze(credentials.some(c => c.id === summary.id) ? credentials.map(c => c.id === summary.id ? summary : c) : [...credentials, summary]);
+}
 export function createSourceControlController({ api, permissions = [] }, _optional = {}) {
     const grants = new Set(permissions), store = createControllerStore({ initial: { providers: [], credentials: [], drafts: {}, loading: false, loaded: false, error: null, catalogError: null } });
     let generation = 0, credentialRevision = 0;
@@ -35,22 +46,23 @@ export function createSourceControlController({ api, permissions = [] }, _option
         if (ticket === generation)
             store.set({ patch: { loading: false } });
     }
+    /** Replaces the provider's current default credential, or creates one labelled 'default'. */
+    function writeCredential({ current, connection }) {
+        return current ? api.update({ id: current.id, patch: { connection } }, { signal: store.signal }) : api.create({ label: 'default', connection }, { signal: store.signal });
+    }
     async function save({ providerId }, _optional = {}) {
-        const state = store.getSnapshot(), draft = state.drafts[providerId] ?? blankSourceControlDraft({});
-        const info = sourceControlProviders({ providers: state.providers, credentials: state.credentials }).find(p => p.id === providerId);
-        if (!canWrite() || !state.loaded || draft.saving || !info || !sourceControlReady({ info, draft }))
+        const state = store.getSnapshot(), target = canWrite() ? readySaveTarget({ state, providerId }) : null;
+        if (!target)
             return false;
-        const current = defaultSourceControlCredential({ credentials: state.credentials, providerId }), connection = buildSourceControlConnection({ info, draft });
+        const current = defaultSourceControlCredential({ credentials: state.credentials, providerId }), connection = buildSourceControlConnection(target);
         patchDraft(providerId, { saving: true, error: null });
         try {
-            const row = current ? await api.update({ id: current.id, patch: { connection } }, { signal: store.signal }) : await api.create({ label: 'default', connection }, { signal: store.signal });
+            const row = await writeCredential({ current, connection });
             if (store.signal.aborted)
                 return false;
             credentialRevision++;
             // One round trip per write: splice the summary, then erase accepted secret drafts immediately.
-            const credentials = store.getSnapshot().credentials, summary = sourceControlSummary({ row });
-            // Preserve server order: the first row is the defensive default when no row is marked default.
-            store.set({ patch: { credentials: Object.freeze(credentials.some(c => c.id === row.id) ? credentials.map(c => c.id === row.id ? summary : c) : [...credentials, summary]) } });
+            store.set({ patch: { credentials: spliceCredential({ credentials: store.getSnapshot().credentials, summary: sourceControlSummary({ row }) }) } });
             patchDraft(providerId, blankSourceControlDraft({}));
             return true;
         }

package/dist/source-control/react/hooks/ProvidersTab.hooks.d.ts

@@ -1,4 +1,5 @@
 import type { TabViewProps } from '../../../core/react/bind-react.js';
+import type { SourceControlCredential } from '../../models.js';
 export declare function useProvidersTab({ permissions }: TabViewProps, _optional?: {}): {
     denied: boolean;
     loading: boolean;
@@ -6,7 +7,7 @@ export declare function useProvidersTab({ permissions }: TabViewProps, _optional
         id: string;
         label: string;
         heading: string;
-        saved: import("../../models.js").SourceControlCredential | undefined;
+        saved: SourceControlCredential | undefined;
         defaultOpen: boolean;
         canEdit: boolean;
         unlisted: boolean;

package/dist/source-control/react/hooks/ProvidersTab.hooks.js

@@ -2,19 +2,26 @@ import { useController } from '../../../core/react/use-controller.js';
 import { createSourceControlController } from '../../controllers/source-control.controller.js';
 import { blankSourceControlDraft, sourceControlProviders, defaultSourceControlCredential, sourceControlReady, safeSourceControlUrl } from '../../rules.js';
 import { useSourceControlPorts } from './SourceControlPorts.hooks.js';
+/** Stand-in snapshot until the controller mounts: nothing listed yet, still loading. */
+const UNMOUNTED = { providers: [], credentials: [], drafts: {}, loading: true, loaded: false, error: null, catalogError: null };
+function fieldView({ info, field, draft }, { controller }) {
+    return { name: field.name, label: `${info.label} ${field.label}`, value: draft.values[field.name] ?? '', secret: !!field.secret, required: !!field.required, hint: field.userHelp ?? field.hint ?? field.help, onValueChange({ value }) { controller?.setField({ providerId: info.id, name: field.name, value }); } };
+}
+function rowView({ info, context }, { controller }) {
+    const { credentials, drafts, first, canWrite } = context;
+    const saved = defaultSourceControlCredential({ credentials, providerId: info.id }), draft = drafts[info.id] ?? blankSourceControlDraft({}), tokenPageUrl = safeSourceControlUrl({ url: info.tokenPageUrl });
+    return { id: info.id, label: info.label, heading: saved ? info.label : `Connect ${info.label}`, saved, defaultOpen: info.id === first, canEdit: canWrite && info.listed, unlisted: !info.listed, connected: !!saved,
+        token: draft.token, tokenLabel: `${info.label} ${info.tokenLabel}`, hint: saved ? 'Leave blank to keep the current token.' : 'Once saved, the token is never displayed again.', saving: draft.saving, error: draft.error,
+        disabled: !canWrite || !sourceControlReady({ info, draft }), help: info.help, tokenPageUrl, hasGuidance: !!info.help || !!tokenPageUrl,
+        fields: info.fields.map(field => fieldView({ info, field, draft }, { controller })),
+        onToken({ value }) { controller?.setToken({ providerId: info.id, value }); }, save() { void controller?.save({ providerId: info.id }); }, };
+}
 export function useProvidersTab({ permissions = [] }, _optional = {}) {
     const ports = useSourceControlPorts({}), key = permissions.join('\0'), canRead = permissions.includes('source-control.read'), canWrite = canRead && permissions.includes('source-control.credentials.write');
-    const { controller, snapshot: state } = useController({ create: () => createSourceControlController({ api: ports.sourceControlApi, permissions }), dependencies: [ports.sourceControlApi, key] }, { start: ({ controller }) => { void controller.load({}); } });
-    const credentials = state?.credentials ?? [], infos = sourceControlProviders({ providers: state?.providers ?? [], credentials });
+    const { controller, snapshot } = useController({ create: () => createSourceControlController({ api: ports.sourceControlApi, permissions }), dependencies: [ports.sourceControlApi, key] }, { start: ({ controller }) => { void controller.load({}); } });
+    const state = snapshot ?? UNMOUNTED, credentials = state.credentials, infos = sourceControlProviders({ providers: state.providers, credentials });
     const first = infos.find(p => p.listed && !defaultSourceControlCredential({ credentials, providerId: p.id }))?.id;
-    const rows = infos.map(info => {
-        const saved = defaultSourceControlCredential({ credentials, providerId: info.id }), draft = state?.drafts[info.id] ?? blankSourceControlDraft({});
-        return { id: info.id, label: info.label, heading: saved ? info.label : `Connect ${info.label}`, saved, defaultOpen: info.id === first, canEdit: canWrite && info.listed, unlisted: !info.listed, connected: !!saved,
-            token: draft.token, tokenLabel: `${info.label} ${info.tokenLabel}`, hint: saved ? 'Leave blank to keep the current token.' : 'Once saved, the token is never displayed again.', saving: draft.saving, error: draft.error,
-            disabled: !canWrite || !sourceControlReady({ info, draft }), help: info.help, tokenPageUrl: safeSourceControlUrl({ url: info.tokenPageUrl }), hasGuidance: !!info.help || !!safeSourceControlUrl({ url: info.tokenPageUrl }),
-            fields: info.fields.map(field => ({ name: field.name, label: `${info.label} ${field.label}`, value: draft.values[field.name] ?? '', secret: !!field.secret, required: !!field.required, hint: field.userHelp ?? field.hint ?? field.help, onValueChange({ value }) { controller?.setField({ providerId: info.id, name: field.name, value }); } })),
-            onToken({ value }) { controller?.setToken({ providerId: info.id, value }); }, save() { void controller?.save({ providerId: info.id }); }, };
-    });
-    return { denied: !canRead, loading: !state || state.loading, rows, errors: [state?.error, state?.catalogError].filter((s) => !!s), reload() { void controller?.load({}); }, canManage: !!ports.sourceControlNavigation, manage() { ports.sourceControlNavigation?.open({ kind: 'source-control' }); } };
+    const rows = infos.map(info => rowView({ info, context: { credentials, drafts: state.drafts, first, canWrite } }, { controller }));
+    return { denied: !canRead, loading: state.loading, rows, errors: [state.error, state.catalogError].filter((s) => !!s), reload() { void controller?.load({}); }, canManage: !!ports.sourceControlNavigation, manage() { ports.sourceControlNavigation?.open({ kind: 'source-control' }); } };
 }
 //# sourceMappingURL=ProvidersTab.hooks.js.map

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" }, {