@jini-ai/admin 0.4.12 → 0.6.10

package/dist/react/entities/use-entity-edit.js

@@ -1,6 +1,48 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { draftForRow, invalidDraftFields, missingRequiredFields } from './rules.js';
 import { loadEntityRow, useEntityRead } from './use-entity-read.js';
+/** The first form for a loaded row, or null while it is loading or an edited row was not found. */
+function initialForm({ descriptor, loaded, id }) {
+    if (!loaded || (id !== null && loaded.row === null))
+        return null;
+    const draft = draftForRow({ descriptor, row: loaded.row });
+    const jsonText = Object.create(null);
+    for (const field of descriptor.fields) {
+        if (field.kind === 'json')
+            jsonText[field.name] = draft[field.name] === undefined ? '' : JSON.stringify(draft[field.name], null, 2);
+    }
+    return { draft, jsonText, jsonErrors: {} };
+}
+function canSaveForm({ form, missing, invalid, pending }) {
+    if (form === null || pending !== null)
+        return false;
+    return missing.length === 0 && invalid.length === 0 && !Object.values(form.jsonErrors).some(Boolean);
+}
+function parseJsonText(text) {
+    try {
+        return { value: text.trim() === '' ? undefined : JSON.parse(text), failed: false };
+    }
+    catch {
+        return { value: undefined, failed: true };
+    }
+}
+function mutationAllowed({ kind, canSave, id, port }) {
+    if (kind === 'save')
+        return canSave;
+    return id !== null && port.remove !== undefined;
+}
+/** Run the port call; resolves to the saved row's id, or null after a removal. */
+async function performMutation({ kind, port, id, draft }) {
+    if (kind === 'remove' && id !== null && port.remove) {
+        await port.remove(id);
+        return null;
+    }
+    // A create omits blanks; an update carries explicit undefined to clear optional fields.
+    const saved = id === null
+        ? await port.create(Object.fromEntries(Object.entries(draft).filter(([, value]) => value !== undefined)))
+        : await port.update(id, draft);
+    return saved.id;
+}
 /** Called by the editor mounted for one entity/id pair. */
 export function useEntityEdit({ port, ...props }) {
     const { entityName, id, registry, routes } = props;
@@ -15,22 +57,16 @@ export function useEntityEdit({ port, ...props }) {
     const [mutation, setMutation] = useState({ scope, kind: null, failed: false });
     const busy = useRef(false);
     let form = formState?.scope === scope ? formState.form : null;
-    if (read.data && form === null && (id === null || read.data.row !== null)) {
-        const draft = draftForRow({ descriptor: port.descriptor, row: read.data.row });
-        const jsonText = Object.create(null);
-        for (const field of port.descriptor.fields) {
-            if (field.kind === 'json')
-                jsonText[field.name] = draft[field.name] === undefined ? '' : JSON.stringify(draft[field.name], null, 2);
-        }
-        form = { draft, jsonText, jsonErrors: {} };
-        setFormState({ scope, form });
+    if (form === null) {
+        form = initialForm({ descriptor: port.descriptor, loaded: read.data, id });
+        if (form !== null)
+            setFormState({ scope, form });
     }
     const draft = form?.draft ?? {};
     const missing = missingRequiredFields({ descriptor: port.descriptor, draft });
     const invalid = invalidDraftFields({ descriptor: port.descriptor, draft });
     const pending = mutation.scope === scope ? mutation.kind : null;
-    const canSave = form !== null && missing.length === 0 && invalid.length === 0 &&
-        !Object.values(form.jsonErrors).some(Boolean) && pending === null;
+    const canSave = canSaveForm({ form, missing, invalid, pending });
     function setField({ name, value }) {
         if (!port.descriptor.fields.some((field) => field.name === name) || busy.current)
             return;
@@ -39,14 +75,7 @@ export function useEntityEdit({ port, ...props }) {
     function setJsonText({ name, text }) {
         if (!port.descriptor.fields.some((field) => field.name === name && field.kind === 'json') || busy.current)
             return;
-        let value;
-        let failed = false;
-        try {
-            value = text.trim() === '' ? undefined : JSON.parse(text);
-        }
-        catch {
-            failed = true;
-        }
+        const { value, failed } = parseJsonText(text);
         setFormState((state) => state?.scope === scope ? {
             scope,
             form: {
@@ -57,25 +86,15 @@ export function useEntityEdit({ port, ...props }) {
         } : state);
     }
     async function mutate({ kind }) {
-        if (busy.current || (kind === 'save' && !canSave) || (kind === 'remove' && (id === null || port.remove === undefined)))
+        if (busy.current || !mutationAllowed({ kind, canSave, id, port }))
             return;
         busy.current = true;
         setMutation({ scope, kind, failed: false });
         const active = () => mounted.current && currentScope.current === scope;
         try {
-            if (kind === 'remove' && id !== null && port.remove) {
-                await port.remove(id);
-                if (active())
-                    routes.navigate({ entity: entityName });
-            }
-            else {
-                // A create omits blanks; an update carries explicit undefined to clear optional fields.
-                const saved = id === null
-                    ? await port.create(Object.fromEntries(Object.entries(draft).filter(([, value]) => value !== undefined)))
-                    : await port.update(id, draft);
-                if (active())
-                    routes.navigate({ entity: entityName, id: saved.id });
-            }
+            const savedId = await performMutation({ kind, port, id, draft });
+            if (active())
+                routes.navigate(savedId === null ? { entity: entityName } : { entity: entityName, id: savedId });
             if (active())
                 setMutation({ scope, kind: null, failed: false });
         }

package/dist/react/shell/AdminShell.js

@@ -5,6 +5,40 @@ import { useShellDrawer, useShellRoute } from './AdminShell.hooks.js';
 import { resolveAdminShellModel } from './model.js';
 import { useAdminShellSession } from './use-admin-shell-session.js';
 import { useAdminTheme } from './use-admin-theme.js';
+/** Copy only the theme props the host supplied, so absent ones keep the hook's own defaults. */
+function themeOptions(props) {
+    return {
+        ...(props.theme ? { theme: props.theme } : {}),
+        ...(props.colorScheme ? { colorScheme: props.colorScheme } : {}),
+        ...(props.themeEnvironment ? { environment: props.themeEnvironment } : {}),
+        ...(props.themePreferenceStore ? { preferenceStore: props.themePreferenceStore } : {}),
+        ...(props.onColorSchemeChange ? { onColorSchemeChange: props.onColorSchemeChange } : {}),
+    };
+}
+/** Loading, login or session-error UI for every state except an authenticated one. */
+function renderSessionGate({ props, context, state, refresh }) {
+    if (state.status === 'checking')
+        return _jsx("div", { className: "boot-screen", role: "status", children: props.labels.loading });
+    if (state.status === 'anonymous')
+        return props.slots.login({ context, refreshSession: refresh });
+    if (props.slots.sessionError)
+        return props.slots.sessionError({ error: state.error, retry: refresh });
+    return _jsxs("div", { role: "alert", children: [_jsx("p", { children: props.labels.sessionError }), _jsx("button", { type: "button", onClick: () => { void refresh(); }, children: props.labels.retry })] });
+}
+/** Resolve the authenticated route, nav and slot arguments from the session's contributions. */
+function resolveShellView({ props, context, session, routePath, controller }, { appearance }) {
+    const model = resolveAdminShellModel({ panels: props.panels, session, routePath, defaultPanelId: props.defaultPanelId }, { capabilities: props.capabilities ?? [] });
+    const slotArgs = {
+        context, session, route: model.route, logout: controller.logout, refreshSession: controller.refresh,
+        ...(appearance ? { appearance } : {}),
+    };
+    const nav = props.translateNav ? props.translateNav({ groups: model.nav }) : model.nav;
+    return { model, slotArgs, nav };
+}
+/** The manifest-driven sidebar: header slot, nav groups, rail toggle and footer slot. */
+function ShellSidebar({ props, view, open, id }) {
+    return (_jsxs(Sidebar, { activeId: view.model.route.panelId, base: props.adminBase, open: open, id: id, label: props.labels.navigation, railStorageKey: props.railStorageKey, railDefaultCollapsed: props.railDefaultCollapsed ?? false, children: [props.slots.sidebarHeader, _jsx(Sidebar.Nav, { groups: view.nav, soonLabel: props.labels.soon, collapsibleGroups: props.collapsibleGroups ?? [] }), _jsxs(Sidebar.Footer, { children: [_jsx(Sidebar.RailToggle, { expandLabel: props.labels.expandSidebar, collapseLabel: props.labels.collapseSidebar }), props.slots.sidebarFooter?.(view.slotArgs)] })] }));
+}
 /**
  * A host-composed admin layout with manifest navigation and a session gate.
  * @param props Required host scope, ports, contributions, labels and slots; optional layout settings.
@@ -13,34 +47,17 @@ import { useAdminTheme } from './use-admin-theme.js';
 export function AdminShell(props) {
     const context = useMemo(() => ({ apiBase: props.apiBase, workspace: props.workspace }), [props.apiBase, props.workspace]);
     const session = useAdminShellSession({ port: props.session, context });
-    const appearance = useAdminTheme({ userId: session.state.status === 'authenticated' ? session.state.session.user.id : null, workspace: context.workspace }, {
-        ...(props.theme ? { theme: props.theme } : {}),
-        ...(props.colorScheme ? { colorScheme: props.colorScheme } : {}),
-        ...(props.themeEnvironment ? { environment: props.themeEnvironment } : {}),
-        ...(props.themePreferenceStore ? { preferenceStore: props.themePreferenceStore } : {}),
-        ...(props.onColorSchemeChange ? { onColorSchemeChange: props.onColorSchemeChange } : {}),
-    });
+    const appearance = useAdminTheme({ userId: session.state.status === 'authenticated' ? session.state.session.user.id : null, workspace: context.workspace }, themeOptions(props));
     const routePath = useShellRoute({ navigation: props.navigation, base: props.adminBase });
     const drawer = useShellDrawer({ routePath });
     const id = useId();
     const sidebarId = `${id}-sidebar`;
     const mainId = `${id}-main`;
-    if (session.state.status === 'checking')
-        return _jsx("div", { className: "boot-screen", role: "status", children: props.labels.loading });
-    if (session.state.status === 'anonymous')
-        return props.slots.login({ context, refreshSession: session.refresh });
-    if (session.state.status === 'error') {
-        if (props.slots.sessionError)
-            return props.slots.sessionError({ error: session.state.error, retry: session.refresh });
-        return _jsxs("div", { role: "alert", children: [_jsx("p", { children: props.labels.sessionError }), _jsx("button", { type: "button", onClick: () => { void session.refresh(); }, children: props.labels.retry })] });
-    }
-    const model = resolveAdminShellModel({ panels: props.panels, session: session.state.session, routePath, defaultPanelId: props.defaultPanelId }, { capabilities: props.capabilities ?? [] });
-    const slotArgs = {
-        context, session: session.state.session, route: model.route, logout: session.logout, refreshSession: session.refresh,
-        ...(appearance ? { appearance } : {}),
-    };
-    const nav = props.translateNav ? props.translateNav({ groups: model.nav }) : model.nav;
+    if (session.state.status !== 'authenticated')
+        return renderSessionGate({ props, context, state: session.state, refresh: session.refresh });
+    const view = resolveShellView({ props, context, session: session.state.session, routePath, controller: session }, { appearance });
+    const { model, slotArgs } = view;
     const assistant = props.slots.assistant;
-    return (_jsxs("div", { className: ['admin-layout', props.className].filter(Boolean).join(' '), children: [_jsx("a", { href: `#${mainId}`, className: "skip-link", children: props.labels.skipToContent }), _jsxs(Sidebar, { activeId: model.route.panelId ?? '', base: props.adminBase, open: drawer.open, id: sidebarId, label: props.labels.navigation, railStorageKey: props.railStorageKey, railDefaultCollapsed: props.railDefaultCollapsed ?? false, children: [props.slots.sidebarHeader, _jsx(Sidebar.Nav, { groups: nav, soonLabel: props.labels.soon, collapsibleGroups: props.collapsibleGroups ?? [] }), _jsxs(Sidebar.Footer, { children: [_jsx(Sidebar.RailToggle, { expandLabel: props.labels.expandSidebar, collapseLabel: props.labels.collapseSidebar }), props.slots.sidebarFooter?.(slotArgs)] })] }), drawer.open && _jsx("button", { type: "button", className: "sidebar-backdrop", "aria-label": props.labels.closeNavigation, onClick: () => drawer.setOpen(false) }), _jsxs("div", { className: "admin-main-col", children: [_jsxs("div", { className: "admin-topbar", children: [_jsx("button", { type: "button", className: "admin-topbar-toggle", "aria-expanded": drawer.open, "aria-controls": sidebarId, "aria-label": drawer.open ? props.labels.closeNavigation : props.labels.openNavigation, onClick: () => drawer.setOpen((open) => !open), children: _jsx("svg", { viewBox: "0 0 18 18", fill: "none", stroke: "currentColor", strokeWidth: 1.5, "aria-hidden": "true", children: _jsx("path", { d: "M2.5 5h13M2.5 9h13M2.5 13h13" }) }) }), _jsx("span", { className: "admin-topbar-title", children: props.title }), props.slots.topbar] }), _jsx("main", { ref: props.mainRef, id: mainId, className: "admin-content", tabIndex: -1, "data-agent-page": model.agentPageId ?? undefined, children: model.panel?.render(slotArgs) })] }), assistant && _jsx("aside", { className: "admin-assistant-pane", "aria-label": assistant.label, hidden: !assistant.open, children: assistant.content }), props.slots.overlays?.(slotArgs)] }));
+    return (_jsxs("div", { className: ['admin-layout', props.className].filter(Boolean).join(' '), children: [_jsx("a", { href: `#${mainId}`, className: "skip-link", children: props.labels.skipToContent }), _jsx(ShellSidebar, { props: props, view: view, open: drawer.open, id: sidebarId }), drawer.open && _jsx("button", { type: "button", className: "sidebar-backdrop", "aria-label": props.labels.closeNavigation, onClick: () => drawer.setOpen(false) }), _jsxs("div", { className: "admin-main-col", children: [_jsxs("div", { className: "admin-topbar", children: [_jsx("button", { type: "button", className: "admin-topbar-toggle", "aria-expanded": drawer.open, "aria-controls": sidebarId, "aria-label": drawer.open ? props.labels.closeNavigation : props.labels.openNavigation, onClick: () => drawer.setOpen((open) => !open), children: _jsx("svg", { viewBox: "0 0 18 18", fill: "none", stroke: "currentColor", strokeWidth: 1.5, "aria-hidden": "true", children: _jsx("path", { d: "M2.5 5h13M2.5 9h13M2.5 13h13" }) }) }), _jsx("span", { className: "admin-topbar-title", children: props.title }), props.slots.topbar] }), _jsx("main", { ref: props.mainRef, id: mainId, className: "admin-content", tabIndex: -1, "data-agent-page": model.agentPageId ?? undefined, children: model.panel?.render(slotArgs) })] }), assistant && _jsx("aside", { className: "admin-assistant-pane", "aria-label": assistant.label, hidden: !assistant.open, children: assistant.content }), props.slots.overlays?.(slotArgs)] }));
 }
 //# sourceMappingURL=AdminShell.js.map

package/dist/react/shell/model.d.ts

@@ -4,7 +4,10 @@ import type { AdminShellPanel, AdminShellSession } from './types.js';
 export interface AdminShellModel {
     readonly panels: readonly AdminShellPanel[];
     readonly panel: AdminShellPanel | undefined;
-    readonly route: AdminRoute;
+    /** Always names a panel: an unmatched or root path resolves to the host's default panel. */
+    readonly route: AdminRoute & {
+        readonly panelId: string;
+    };
     readonly nav: readonly AdminNavGroup[];
     readonly agentPageId: string | null;
 }

package/dist/react/shell/model.js

@@ -12,12 +12,13 @@ export function resolveAdminShellModel(args, options = {}) {
         permissions: args.session.effectivePermissions ?? [],
     });
     const matched = matchRoute({ routePath: args.routePath, panels });
-    const rawPath = args.routePath.split('?')[0] ?? '';
+    // `split` with a string separator always returns at least one element, so index 0 exists.
+    const rawPath = args.routePath.split('?')[0];
     const isRoot = rawPath.split('/').filter(Boolean).length === 0;
     // The existing matcher maps root to dashboard. The shell's default is host-owned.
     const route = isRoot || matched.panelId === null
         ? { panelId: args.defaultPanelId, view: null, params: {}, query: matched.query }
-        : matched;
+        : { ...matched, panelId: matched.panelId };
     return {
         panels,
         panel: panels.find((panel) => panel.id === route.panelId),

package/dist/react/shell/use-admin-shell-session.js

@@ -1,4 +1,24 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
+/** Run one port operation and map its outcome, including adapter failures, to the next gate state. */
+async function settleOperation({ operation, port, context }) {
+    try {
+        if (operation === 'logout') {
+            await port.logout(context);
+            return { status: 'anonymous' };
+        }
+        const session = await port.read(context);
+        return session === null
+            ? { status: 'anonymous' }
+            : { status: 'authenticated', session };
+    }
+    catch (error) {
+        // Local sign-out must complete even when the server cannot revoke its cookie. A read
+        // retry here would quietly restore that still-valid session instead of showing login.
+        return operation === 'logout'
+            ? { status: 'anonymous' }
+            : { status: 'error', error };
+    }
+}
 /**
  * Own session reads and invalidation without any host API imports.
  * @param args Stable context and session port. Changing either starts a new session check.
@@ -22,33 +42,12 @@ export function useAdminShellSession(args) {
         const request = ++generation.current;
         const isCurrent = () => active.current === owner && generation.current === request;
         setOwned({ context, port, state: { status: 'checking' } });
-        try {
-            if (operation === 'logout') {
-                await port.logout(context);
-                if (isCurrent())
-                    setOwned({ context, port, state: { status: 'anonymous' } });
-                return;
-            }
-            const session = await port.read(context);
-            if (!isCurrent())
-                return;
-            const state = session === null
-                ? { status: 'anonymous' }
-                : { status: 'authenticated', session };
+        // settleOperation never rejects, so the logout latch below always clears.
+        const state = await settleOperation({ operation, port, context });
+        if (isCurrent())
             setOwned({ context, port, state });
-        }
-        catch (error) {
-            // Local sign-out must complete even when the server cannot revoke its cookie. A read
-            // retry here would quietly restore that still-valid session instead of showing login.
-            if (isCurrent())
-                setOwned({ context, port, state: operation === 'logout'
-                        ? { status: 'anonymous' }
-                        : { status: 'error', error } });
-        }
-        finally {
-            if (operation === 'logout' && loggingOut.current === owner)
-                loggingOut.current = null;
-        }
+        if (operation === 'logout' && loggingOut.current === owner)
+            loggingOut.current = null;
     }, [context, port]);
     const refresh = useCallback(() => run('read'), [run]);
     const logout = useCallback(() => run('logout'), [run]);

package/dist/redirects/adapters/memory.js

@@ -6,6 +6,8 @@ import { AdminApiError } from '../../core/transport/errors.js';
 export function createMemoryRedirectsApi({ redirects = [], hits = {} }, { validate, onImport } = {}) {
     const rows = new Map(redirects.map(row => [row.id, Object.freeze({ ...row })]));
     const stats = new Map(Object.entries(hits).map(([id, value]) => [id, Object.freeze({ ...value })]));
+    // Ids removed to the Trash: hidden from the list, still readable by id, restored by `status: 'active'`.
+    const trashed = new Set();
     let nextId = 1;
     function get(id) {
         const row = rows.get(id);
@@ -32,7 +34,8 @@ export function createMemoryRedirectsApi({ redirects = [], hits = {} }, { valida
     }
     return {
         async listRedirects(_required, filter = {}) {
-            return Object.freeze([...rows.values()].filter(row => (filter.status === undefined || row.status === filter.status) &&
+            return Object.freeze([...rows.values()].filter(row => !trashed.has(row.id) &&
+                (filter.status === undefined || row.status === filter.status) &&
                 (filter.source === undefined || row.source === filter.source) &&
                 (filter.matchType === undefined || row.matchType === filter.matchType)));
         },
@@ -47,14 +50,18 @@ export function createMemoryRedirectsApi({ redirects = [], hits = {} }, { valida
                 throw new AdminApiError({ message: 'regex match type is not supported', status: 400 }, { code: 'REDIRECT_VALIDATION_ERROR' });
             const row = Object.freeze({ ...next, version: before.version + 1 });
             rows.set(id, row);
+            if (patch.status === 'active')
+                trashed.delete(id);
             return row;
         },
         async tombstoneRedirect({ id }) {
             const row = get(id);
-            if (row.status === 'disabled')
+            // Keyed on the Trash, not on `status`: a rule already toggled off still moves to the Trash.
+            if (trashed.has(id))
                 return row;
             const disabled = Object.freeze({ ...row, status: 'disabled', version: row.version + 1 });
             rows.set(id, disabled);
+            trashed.add(id);
             return disabled;
         },
         async getRedirectHitStats({ id }) {

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

@@ -1,17 +1,14 @@
 import { AdminApiError } from '../../core/transport/errors.js';
-/** Destructive framework-free checklist: use an isolated backend with no production data.
- * Validates core soft-delete, snapshots, lazy-read data and per-item partial import contracts.
- * Reference regex rejection probes can be disabled for a host implementing the port's open vocabulary.
- * @example await runRedirectsApiConformance({ api: createMemoryRedirectsApi({}, {}) }, {});
- */
-export async function runRedirectsApiConformance({ api }, { referenceRegexRejection = true } = {}) {
-    const checks = [];
-    function assert(ok, name) {
+/** The id every not-found probe asks for; no conforming backend may hold it. */
+const MISSING = { id: 'missing-conformance-rule' };
+function createChecklist(_required = {}, _optional = {}) {
+    const passed = [];
+    function check({ ok, name }) {
         if (!ok)
             throw new AdminApiError({ message: `Redirects API conformance: ${name}`, status: 0 }, { code: 'CONFORMANCE_FAILED' });
-        checks.push(name);
+        passed.push(name);
     }
-    async function rejects(run, name) {
+    async function rejects({ run, name }) {
         let rejected = false;
         try {
             await run();
@@ -19,48 +16,81 @@ export async function runRedirectsApiConformance({ api }, { referenceRegexReject
         catch {
             rejected = true;
         }
-        assert(rejected, name);
+        check({ ok: rejected, name });
     }
-    const input = { matchType: 'exact', fromPattern: '/redirects-conformance-a', toTarget: '/redirects-conformance-b', statusCode: 301 };
+    return { passed, check, rejects };
+}
+async function checkCreateAndRead({ api, list, input }, _optional = {}) {
     const created = await api.createRedirect(input, { override: true, priority: 7 });
-    assert(created.status === 'active' && created.override && created.priority === 7, 'create preserves fields and options');
+    list.check({ ok: created.status === 'active' && created.override && created.priority === 7, name: 'create preserves fields and options' });
     const before = await api.listRedirects({});
-    assert(before.some(row => row.id === created.id), 'list contains the created rule');
-    assert((await api.getRedirect({ id: created.id })).id === created.id, 'get reads by id');
+    list.check({ ok: before.some(row => row.id === created.id), name: 'list contains the created rule' });
+    list.check({ ok: (await api.getRedirect({ id: created.id })).id === created.id, name: 'get reads by id' });
     const hits = await api.getRedirectHitStats({ id: created.id });
-    assert(hits.redirectId === created.id && hits.hitCount === 0 && hits.lastHitAt === null, 'new rule has zero hits');
+    list.check({ ok: hits.redirectId === created.id && hits.hitCount === 0 && hits.lastHitAt === null, name: 'new rule has zero hits' });
+    return { created, before };
+}
+async function checkUpdate({ api, list, created, before }, _optional = {}) {
     const updated = await api.updateRedirect({ id: created.id }, { status: 'disabled' });
-    assert(updated.status === 'disabled' && updated.toTarget === created.toTarget, 'partial update preserves other fields');
-    assert(created.status === 'active' && before.find(row => row.id === created.id)?.status === 'active', 'prior snapshots stay unchanged');
-    assert((await api.listRedirects({}, { status: 'disabled' })).every(row => row.status === 'disabled'), 'status filter');
+    list.check({ ok: updated.status === 'disabled' && updated.toTarget === created.toTarget, name: 'partial update preserves other fields' });
+    list.check({ ok: created.status === 'active' && before.find(row => row.id === created.id)?.status === 'active', name: 'prior snapshots stay unchanged' });
+    list.check({ ok: (await api.listRedirects({}, { status: 'disabled' })).every(row => row.status === 'disabled'), name: 'status filter' });
     await api.updateRedirect({ id: created.id }, { status: 'active' });
-    const disabled = await api.tombstoneRedirect({ id: created.id });
-    assert(disabled.status === 'disabled', 'tombstone returns the disabled rule');
-    assert((await api.listRedirects({})).some(row => row.id === created.id), 'soft deletion retains the rule');
-    assert((await api.getRedirect({ id: created.id })).status === 'disabled', 'tombstoned rule remains readable');
-    await rejects(() => api.getRedirect({ id: 'missing-conformance-rule' }), 'missing rule rejects');
-    await rejects(() => api.getRedirectHitStats({ id: 'missing-conformance-rule' }), 'missing hits differs from zero hits');
-    await rejects(() => api.updateRedirect({ id: 'missing-conformance-rule' }, { status: 'disabled' }), 'missing update rejects');
-    await rejects(() => api.tombstoneRedirect({ id: 'missing-conformance-rule' }), 'missing tombstone rejects');
-    if (referenceRegexRejection) {
-        await rejects(() => api.createRedirect({ ...input, fromPattern: '/regex-conformance', matchType: 'regex' }), 'reference regex create is loudly rejected');
-        await rejects(() => api.updateRedirect({ id: created.id }, { matchType: 'regex' }), 'reference regex update is loudly rejected');
-    }
+}
+async function checkSoftDelete({ api, list, id }, _optional = {}) {
+    const disabled = await api.tombstoneRedirect({ id });
+    list.check({ ok: disabled.status === 'disabled', name: 'tombstone returns the disabled rule' });
+    // Removal moves the rule to the Trash: it leaves the list and is shown only there (Bug B).
+    list.check({ ok: !(await api.listRedirects({})).some(row => row.id === id), name: 'removed rule leaves the list' });
+    list.check({ ok: (await api.getRedirect({ id })).status === 'disabled', name: 'tombstoned rule remains readable' });
+    // A pure `status: 'active'` update is the restore; remove the rule again so the run leaves it in the Trash.
+    await api.updateRedirect({ id }, { status: 'active' });
+    list.check({ ok: (await api.listRedirects({})).some(row => row.id === id), name: 'restore returns the rule to the list' });
+    await api.tombstoneRedirect({ id });
+}
+async function checkMissingRule({ api, list }, _optional = {}) {
+    await list.rejects({ run: () => api.getRedirect(MISSING), name: 'missing rule rejects' });
+    await list.rejects({ run: () => api.getRedirectHitStats(MISSING), name: 'missing hits differs from zero hits' });
+    await list.rejects({ run: () => api.updateRedirect(MISSING, { status: 'disabled' }), name: 'missing update rejects' });
+    await list.rejects({ run: () => api.tombstoneRedirect(MISSING), name: 'missing tombstone rejects' });
+}
+async function checkReferenceRegexRejection({ api, list, input, id }, _optional = {}) {
+    await list.rejects({ run: () => api.createRedirect({ ...input, fromPattern: '/regex-conformance', matchType: 'regex' }), name: 'reference regex create is loudly rejected' });
+    await list.rejects({ run: () => api.updateRedirect({ id }, { matchType: 'regex' }), name: 'reference regex update is loudly rejected' });
+}
+/** With reference rejection, a regex item sits between two valid ones to prove per-item partial success. */
+async function checkImport({ api, list, input }, { referenceRegexRejection }) {
     const batch = await api.importRedirects({ rules: [
             { ...input, fromPattern: '/import-conformance-a' },
             ...(referenceRegexRejection ? [{ ...input, fromPattern: '/import-conformance-regex', matchType: 'regex' }] : []),
             { ...input, fromPattern: '/import-conformance-c' },
         ] });
     if (referenceRegexRejection) {
-        assert(batch.created.length === 2 && batch.failed.length === 1 && batch.failed[0]?.index === 1, 'middle failure preserves both successful siblings');
-        assert(batch.created.every(row => row.fromPattern !== '/import-conformance-regex'), 'invalid item is never reported created');
+        list.check({ ok: batch.created.length === 2 && batch.failed.length === 1 && batch.failed[0]?.index === 1, name: 'middle failure preserves both successful siblings' });
+        list.check({ ok: batch.created.every(row => row.fromPattern !== '/import-conformance-regex'), name: 'invalid item is never reported created' });
     }
     else {
-        assert(batch.created.length === 2 && batch.failed.length === 0, 'valid import batch succeeds');
+        list.check({ ok: batch.created.length === 2 && batch.failed.length === 0, name: 'valid import batch succeeds' });
     }
-    assert(batch.created.every(row => row.source === 'import'), 'import provenance is stamped by the backend');
+    list.check({ ok: batch.created.every(row => row.source === 'import'), name: 'import provenance is stamped by the backend' });
     for (const row of batch.created)
         await api.tombstoneRedirect({ id: row.id });
-    return Object.freeze(checks);
+}
+/** Destructive framework-free checklist: use an isolated backend with no production data.
+ * Validates core soft-delete, snapshots, lazy-read data and per-item partial import contracts.
+ * Reference regex rejection probes can be disabled for a host implementing the port's open vocabulary.
+ * @example await runRedirectsApiConformance({ api: createMemoryRedirectsApi({}, {}) }, {});
+ */
+export async function runRedirectsApiConformance({ api }, { referenceRegexRejection = true } = {}) {
+    const list = createChecklist();
+    const input = { matchType: 'exact', fromPattern: '/redirects-conformance-a', toTarget: '/redirects-conformance-b', statusCode: 301 };
+    const { created, before } = await checkCreateAndRead({ api, list, input });
+    await checkUpdate({ api, list, created, before });
+    await checkSoftDelete({ api, list, id: created.id });
+    await checkMissingRule({ api, list });
+    if (referenceRegexRejection)
+        await checkReferenceRegexRejection({ api, list, input, id: created.id });
+    await checkImport({ api, list, input }, { referenceRegexRejection });
+    return Object.freeze(list.passed);
 }
 //# sourceMappingURL=redirects-api.conformance.js.map

package/dist/redirects/react/hooks/use-import-redirects-form.hooks.d.ts

@@ -9,7 +9,7 @@ export declare function useImportRedirectsForm({ api }: {
     locale?: string;
 }): {
     raw: string;
-    setRaw: (raw: string) => void | undefined;
+    setRaw: (next: string) => void | undefined;
     error: string | null;
     result: import("../../index.js").AdminRedirectImportResult | null;
     importing: boolean;

package/dist/redirects/react/hooks/use-import-redirects-form.hooks.js

@@ -5,6 +5,13 @@ import { useController } from '../../../core/react/use-controller.js';
 import { createImportRedirectsController } from '../../controllers/import-redirects.controller.js';
 import { KEYS } from '../../rules.js';
 import { translateRedirectsEn } from '../../messages.en.js';
+/** Before the controller mounts there is no snapshot: an empty form. A parse error wins over a
+ * request error, so a later parse failure replaces an earlier request failure instead of stacking. */
+function deriveFormState({ snapshot, requestError }, _optional = {}) {
+    return { raw: snapshot?.raw ?? '',
+        error: snapshot?.parseError ?? (requestError ? describeApiError({ e: requestError, fallback: 'Import failed' }) : null),
+        result: snapshot?.result ?? null };
+}
 /** A resolved 207 is a result, including failed items; only transport failures enter error state. */
 export function useImportRedirectsForm({ api }, { t = translateRedirectsEn, locale = 'en' } = {}) {
     const mutation = useFetchMutation({ run: ({ input: rules }) => api.importRedirects({ rules }) }, { invalidates: [KEYS.list] });
@@ -18,8 +25,8 @@ export function useImportRedirectsForm({ api }, { t = translateRedirectsEn, loca
         e.preventDefault();
         return controller?.submit() ?? Promise.resolve();
     }
-    return { raw: snapshot?.raw ?? '', setRaw: (raw) => controller?.setRaw({ raw }),
-        error: snapshot?.parseError ?? (mutation.error ? describeApiError({ e: mutation.error, fallback: 'Import failed' }) : null),
-        result: snapshot?.result ?? null, importing: mutation.status === 'pending', submit, t, locale };
+    const { raw, error, result } = deriveFormState({ snapshot, requestError: mutation.error });
+    return { raw, setRaw: (next) => controller?.setRaw({ raw: next }),
+        error, result, importing: mutation.status === 'pending', submit, t, locale };
 }
 //# sourceMappingURL=use-import-redirects-form.hooks.js.map

package/dist/redirects/react/hooks/wired.hooks.d.ts

@@ -44,7 +44,7 @@ export declare function useWiredImportRedirectsForm({ t, locale }: {
     createdText: string;
     failedLabel: (failure: AdminRedirectImportFailure) => string;
     raw: string;
-    setRaw: (raw: string) => void | undefined;
+    setRaw: (next: string) => void | undefined;
     error: string | null;
     result: import("../../index.js").AdminRedirectImportResult | null;
     importing: boolean;

package/dist/security/adapters/http.js

@@ -3,8 +3,17 @@ function summary(row, kind) {
     return Object.freeze({ kind, id: row.id, providerId: row.providerId ?? '', label: row.label, configured: row.configured, isDefault: row.isDefault ?? false, createdAt: row.createdAt, updatedAt: row.updatedAt,
         ...(row.accountLabel !== undefined ? { accountLabel: row.accountLabel } : {}), ...(kind === 'custom' ? { category: row.category ?? 'general', baseUrl: row.baseUrl ?? '', additionalHosts: Object.freeze([...(row.additionalHosts ?? [])]), ...(row.username ? { username: row.username } : {}) } : {}) });
 }
+function trimBase({ workspacePath }, _optional = {}) { return workspacePath.replace(/\/$/, ''); }
+function descriptorExtras({ credential }, _optional = {}) {
+    const help = credential?.userHelp ?? credential?.help;
+    return { ...(credential?.tokenPageUrl ? { tokenPageUrl: credential.tokenPageUrl } : {}), ...(help ? { help } : {}) };
+}
+function providerFromDescriptor({ kind, descriptor: d }, _optional = {}) {
+    const c = d.credential;
+    return { kind, id: d.id, label: d.label, vendorLabel: c?.vendorLabel ?? d.label, category: kind === 'publish' ? 'hosting' : 'source-control', tokenField: c?.tokenField ?? 'token', fields: c?.fields ?? [], ...descriptorExtras({ credential: c }) };
+}
 export function createHttpSecurityApi({ transport, workspacePath }, _optional = {}) {
-    const base = workspacePath.replace(/\/$/, '');
+    const base = trimBase({ workspacePath });
     function store(kind, suffix) {
         const path = `${base}/system/${suffix}/credentials`;
         async function mutate(method, target, body, options) { options.signal?.throwIfAborted(); const r = await transport.request({ method, path: target, body }, options); return summary(r.credential, kind); }
@@ -22,24 +31,28 @@ export function createHttpSecurityApi({ transport, workspacePath }, _optional =
                 transport.request({ method: 'GET', path: `${base}/system/publish-targets` }, options),
                 transport.request({ method: 'GET', path: `${base}/system/source-control/providers` }, options),
             ]);
-            const map = (kind, d) => ({ kind, id: d.id, label: d.label, vendorLabel: d.credential?.vendorLabel ?? d.label, category: kind === 'publish' ? 'hosting' : 'source-control', tokenField: d.credential?.tokenField ?? 'token', fields: d.credential?.fields ?? [], ...(d.credential?.tokenPageUrl ? { tokenPageUrl: d.credential.tokenPageUrl } : {}), ...((d.credential?.userHelp ?? d.credential?.help) ? { help: d.credential.userHelp ?? d.credential.help } : {}) });
-            return [...publish.targets.filter(d => d.credential).map(d => map('publish', d)), ...source.providers.map(d => map('source-control', d))];
+            return [...publish.targets.filter(d => d.credential).map(descriptor => providerFromDescriptor({ kind: 'publish', descriptor })), ...source.providers.map(descriptor => providerFromDescriptor({ kind: 'source-control', descriptor }))];
         },
         publish: store('publish', 'publish'), sourceControl: store('source-control', 'source-control'), custom: store('custom', 'custom'),
     };
 }
+/** Only non-secret settings are echoed back; apiKey is sent solely for the entry being replaced. */
+function mediaEntry({ entry }, { apiKey } = {}) {
+    return { ...(entry.baseUrl !== undefined ? { baseUrl: entry.baseUrl } : {}), ...(entry.model !== undefined ? { model: entry.model } : {}), ...(apiKey !== undefined ? { apiKey } : {}) };
+}
 /** Replacing the ENTIRE map requires sibling settings unchanged. Blank apiKey preserves their stored keys. */
 function rebuildMedia(current, id, token) {
     const next = {};
     for (const [key, entry] of Object.entries(current)) {
-        if (key === id && token === undefined)
-            continue;
-        next[key] = { ...(entry.baseUrl !== undefined ? { baseUrl: entry.baseUrl } : {}), ...(entry.model !== undefined ? { model: entry.model } : {}), ...(key === id && token !== undefined ? { apiKey: token } : {}) };
+        if (key !== id)
+            next[key] = mediaEntry({ entry });
+        else if (token !== undefined)
+            next[key] = mediaEntry({ entry }, { apiKey: token });
     }
     return next;
 }
 export function createHttpOtherCredentials({ transport, workspacePath }, { mediaLabels = {} } = {}) {
-    const base = workspacePath.replace(/\/$/, '');
+    const base = trimBase({ workspacePath });
     const singles = { 'site-assistant': { path: '/assistant/site-credential', label: 'Assistant model key' }, 'admin-byok': { path: '/assistant/execution-credential', label: 'Admin model key' } };
     async function request(path, method, options, body) { options.signal?.throwIfAborted(); return transport.request({ path: `${base}${path}`, method, ...(body !== undefined ? { body } : {}) }, options); }
     return {
@@ -79,15 +92,17 @@ export function createHttpOtherCredentials({ transport, workspacePath }, { media
         },
     };
 }
+/** Explicit projection: receivers carry signing secrets the UI must never hold. */
+function webhookTargets({ webhooks }, _optional = {}) { return webhooks.map(w => ({ label: w.label, targetUrl: w.targetUrl })); }
 export function createHttpRootKey({ transport, workspacePath }, _optional = {}) {
-    const path = `${workspacePath.replace(/\/$/, '')}/system/site-token`;
+    const path = `${trimBase({ workspacePath })}/system/site-token`;
     async function request(suffix, method, options, body) { options.signal?.throwIfAborted(); return transport.request({ path: `${path}${suffix}`, method, ...(body !== undefined ? { body } : {}) }, options); }
-    function result(r) { return { outcome: r.outcome, fingerprint: r.fingerprint, keyFilePath: r.keyFilePath, runtimeMode: r.runtimeMode, ...(r.resealed !== undefined ? { resealed: r.resealed } : {}), ...(r.discarded !== undefined ? { discarded: r.discarded } : {}), ...(r.kept !== undefined ? { kept: r.kept } : {}), ...(r.restorePointId ? { restorePointId: r.restorePointId } : {}), ...(r.affectedWebhooks ? { affectedWebhooks: r.affectedWebhooks.map(w => ({ label: w.label, targetUrl: w.targetUrl })) } : {}) }; }
+    function result(r) { return { outcome: r.outcome, fingerprint: r.fingerprint, keyFilePath: r.keyFilePath, runtimeMode: r.runtimeMode, ...(r.resealed !== undefined ? { resealed: r.resealed } : {}), ...(r.discarded !== undefined ? { discarded: r.discarded } : {}), ...(r.kept !== undefined ? { kept: r.kept } : {}), ...(r.restorePointId ? { restorePointId: r.restorePointId } : {}), ...(r.affectedWebhooks ? { affectedWebhooks: webhookTargets({ webhooks: r.affectedWebhooks }) } : {}) }; }
     return {
         async status(_r, o = {}) { const r = await request('', 'GET', o); return { active: r.active, source: r.source, state: r.state, keyFilePath: r.keyFilePath, runtimeMode: r.runtimeMode, ...(r.fingerprint ? { fingerprint: r.fingerprint } : {}), ...(r.invalid !== undefined ? { invalid: r.invalid } : {}) }; },
         async generate(_r, o = {}) { return result(await request('/generate', 'POST', o)); },
         async importToken({ token }, o = {}) { return result(await request('/import', 'POST', o, { token })); },
-        async previewStartFresh(_r, o = {}) { const r = await request('/start-fresh', 'GET', o); return { removes: r.removes, detail: r.detail, runtimeMode: r.runtimeMode, affectedWebhooks: r.affectedWebhooks.map(w => ({ label: w.label, targetUrl: w.targetUrl })) }; },
+        async previewStartFresh(_r, o = {}) { const r = await request('/start-fresh', 'GET', o); return { removes: r.removes, detail: r.detail, runtimeMode: r.runtimeMode, affectedWebhooks: webhookTargets({ webhooks: r.affectedWebhooks }) }; },
         async startFresh({ confirm }, o = {}) { return result(await request('/start-fresh', 'POST', o, { confirm })); },
     };
 }