@jini-ai/admin 0.4.1 → 0.4.3

package/dist/react/components/RowMenu/RowMenu.hooks.js

@@ -1,6 +1,56 @@
-import { useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 /** 8px clearance kept between the menu and the viewport edge on every side it's tested against. */
 const VIEWPORT_MARGIN = 8;
+/**
+ * Starts the listeners one open menu needs and returns the matching stop. Called from the menu's
+ * callback ref, so both elements are in hand: `trigger` is the button the menu opened from and
+ * `menu` is the just-attached popup — neither is ever null here.
+ *
+ * Positioning runs immediately, at ref-attach time in the commit, i.e. after the (initially
+ * off-screen, `visibility: hidden`) menu has actually laid out, so its real dimensions are known
+ * before deciding above-vs-below — a plain `useEffect` would run one paint too late and produce a
+ * visible jump. Recomputed on scroll and resize too: a portaled menu is a DOM sibling of its anchor,
+ * not a child, so it does not track the anchor's position on its own the way an in-flow popup would.
+ *
+ * Click-outside closes. Scoped to the open window only, same lifecycle discipline as
+ * `ConfirmButton`'s armed-only document listeners — a closed, idle `RowMenu` costs nothing beyond
+ * its trigger button even with many mounted per table.
+ *
+ * @complexity O(1) per call and per scroll/resize/mousedown event.
+ */
+function trackOpenMenu({ trigger, menu }, { window, document, onPosition, onDismiss }) {
+    function reposition() {
+        const rect = trigger.getBoundingClientRect();
+        const menuHeight = menu.offsetHeight;
+        const menuWidth = menu.offsetWidth;
+        const spaceBelow = window.innerHeight - rect.bottom;
+        const fitsBelow = spaceBelow >= menuHeight + VIEWPORT_MARGIN;
+        const placement = fitsBelow || rect.top < menuHeight + VIEWPORT_MARGIN ? 'below' : 'above';
+        // Right-aligned to the trigger by default (the trigger is the table's last column), clamped
+        // so it never overflows the viewport's left or right edge.
+        const left = Math.min(Math.max(VIEWPORT_MARGIN, rect.right - menuWidth), window.innerWidth - menuWidth - VIEWPORT_MARGIN);
+        onPosition({
+            top: placement === 'below' ? rect.bottom + 4 : rect.top - 4,
+            left,
+            placement,
+        });
+    }
+    function onDocMouseDown(e) {
+        const target = e.target;
+        if (menu.contains(target) || trigger.contains(target))
+            return;
+        onDismiss();
+    }
+    reposition();
+    window.addEventListener('scroll', reposition, true);
+    window.addEventListener('resize', reposition);
+    document.addEventListener('mousedown', onDocMouseDown);
+    return () => {
+        window.removeEventListener('scroll', reposition, true);
+        window.removeEventListener('resize', reposition);
+        document.removeEventListener('mousedown', onDocMouseDown);
+    };
+}
 /**
  * Owns `RowMenu`'s open/close state, positioning, and keyboard/focus behavior.
  *
@@ -8,74 +58,44 @@ const VIEWPORT_MARGIN = 8;
  *   needs, for `ArrowUp`-to-last-item and wraparound navigation.
  */
 export function useRowMenu({ itemCount, window, document }) {
-    const [open, setOpen] = useState(false);
+    // The trigger the menu is open against; `null` while closed. Held as state (not just a boolean)
+    // so the menu's callback ref below is built with the element already in hand. Read from
+    // `triggerRef` at open time: an unattached trigger leaves this `null`, so a menu with nothing to
+    // anchor to never opens.
+    const [anchor, setAnchor] = useState(null);
+    const open = anchor !== null;
     const [position, setPosition] = useState(null);
     const [activeIndex, setActiveIndex] = useState(0);
     const triggerRef = useRef(null);
-    const menuRef = useRef(null);
     const itemRefs = useRef([]);
     itemRefs.current = itemRefs.current.slice(0, itemCount);
     function close(returnFocus) {
-        setOpen(false);
+        setAnchor(null);
         setPosition(null);
         if (returnFocus)
             triggerRef.current?.focus();
     }
     function openAt(index) {
         setActiveIndex(index);
-        setOpen(true);
+        setAnchor(triggerRef.current);
     }
-    // Measured after the (initially off-screen, `visibility: hidden`) menu has actually laid out, so
-    // `menuRef.current`'s real dimensions are known before deciding above-vs-below — a plain
-    // `useEffect` would run one paint too late and produce a visible jump. Recomputed on scroll and
-    // resize too: a portaled menu is a DOM sibling of its anchor, not a child, so it does not track
-    // the anchor's position on its own the way an in-flow popup would.
-    useLayoutEffect(() => {
-        if (!open)
-            return;
-        function reposition() {
-            const trigger = triggerRef.current;
-            if (!trigger)
-                return;
-            const rect = trigger.getBoundingClientRect();
-            const menuHeight = menuRef.current?.offsetHeight ?? 0;
-            const menuWidth = menuRef.current?.offsetWidth ?? 0;
-            const spaceBelow = window.innerHeight - rect.bottom;
-            const fitsBelow = spaceBelow >= menuHeight + VIEWPORT_MARGIN;
-            const placement = fitsBelow || rect.top < menuHeight + VIEWPORT_MARGIN ? 'below' : 'above';
-            // Right-aligned to the trigger by default (the trigger is the table's last column), clamped
-            // so it never overflows the viewport's left or right edge.
-            const left = Math.min(Math.max(VIEWPORT_MARGIN, rect.right - menuWidth), window.innerWidth - menuWidth - VIEWPORT_MARGIN);
-            setPosition({
-                top: placement === 'below' ? rect.bottom + 4 : rect.top - 4,
-                left,
-                placement,
-            });
-        }
-        reposition();
-        window.addEventListener('scroll', reposition, true);
-        window.addEventListener('resize', reposition);
-        return () => {
-            window.removeEventListener('scroll', reposition, true);
-            window.removeEventListener('resize', reposition);
+    // Only the open menu renders this ref, so it only exists once there is an anchor. React calls it
+    // with the menu element on attach and `null` on detach (React 18 and 19 alike; attach always comes
+    // first, so `stop` is set by then). A new anchor or new `window`/`document` ports make a new ref,
+    // which React detaches and re-attaches — the same re-subscribe an effect's deps would give.
+    const menuRef = useMemo(() => {
+        if (!anchor)
+            return null;
+        let stop;
+        return (menu) => {
+            if (menu)
+                stop = trackOpenMenu({ trigger: anchor, menu }, { window, document, onPosition: setPosition, onDismiss: () => close(false) });
+            else
+                stop();
         };
-    }, [open, window, document]);
-    // Click-outside closes. Scoped to the open window only, same lifecycle discipline as
-    // `ConfirmButton`'s armed-only document listeners — a closed, idle `RowMenu` costs nothing beyond
-    // its trigger button even with many mounted per table.
-    useEffect(() => {
-        if (!open)
-            return;
-        function onDocMouseDown(e) {
-            const target = e.target;
-            if (menuRef.current?.contains(target) || triggerRef.current?.contains(target))
-                return;
-            close(false);
-        }
-        document.addEventListener('mousedown', onDocMouseDown);
-        return () => document.removeEventListener('mousedown', onDocMouseDown);
+        // `close` only touches state setters and `triggerRef`, all stable across renders.
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [open, window, document]);
+    }, [anchor, window, document]);
     // Keeps real DOM focus on the active item (roving focus via `tabIndex={-1}` on every item except
     // the active one) rather than only tracking `activeIndex` in state — arrow-key navigation needs
     // to move the browser's actual focus for a screen reader to announce it.

package/dist/react/entities/EntityField.d.ts

@@ -1,5 +1,5 @@
 import type { AdminEntityField } from '../../core/ports/entities.js';
-import type { EntityTranslate } from './types.js';
+import { type EntityTranslate } from './types.js';
 import { type RelationIndex } from './rules.js';
 export declare function EntityField(props: {
     readonly inputId: string;

package/dist/react/entities/EntityField.js

@@ -1,16 +1,18 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Select } from '@jini-ai/ui/admin-widgets';
+import { selectTranslate } from './types.js';
 import { fromDatetimeLocalValue, toDatetimeLocalValue } from './rules.js';
 export function EntityField(props) {
     const { inputId, field, value, translate, disabled, invalid, onChange } = props;
     const common = { id: inputId, disabled, 'aria-invalid': invalid };
+    const selectT = selectTranslate({ translate });
     switch (field.kind) {
         case 'json': return _jsx("textarea", { ...common, value: props.text, onChange: (e) => props.onTextChange({ text: e.target.value }) });
         case 'relation': {
             const options = props.relations[field.target]?.options ?? [];
             const selectedId = typeof value === 'string' ? value : '';
             const missing = selectedId !== '' && !options.some((option) => option.id === selectedId);
-            return _jsx(Select, { id: inputId, disabled: disabled, value: selectedId, translate: (key) => translate({ key }), "aria-label": translate({ key: field.label ?? field.name }), options: [
+            return _jsx(Select, { id: inputId, disabled: disabled, value: selectedId, translate: selectT, "aria-label": translate({ key: field.label ?? field.name }), options: [
                     { value: '', label: translate({ key: 'No value' }) },
                     ...(missing ? [{ value: selectedId, label: `${selectedId} (${translate({ key: 'Unresolved' })})` }] : []),
                     ...options.map((option) => ({ value: option.id, label: option.title })),
@@ -19,7 +21,7 @@ export function EntityField(props) {
         case 'boolean':
             if (field.required)
                 return _jsx("input", { ...common, type: "checkbox", checked: value === true, onChange: (e) => onChange({ value: e.target.checked }) });
-            return _jsx(Select, { id: inputId, disabled: disabled, value: value === undefined ? '' : value === true ? 'true' : 'false', translate: (key) => translate({ key }), "aria-label": translate({ key: field.label ?? field.name }), options: [
+            return _jsx(Select, { id: inputId, disabled: disabled, value: value === undefined ? '' : value === true ? 'true' : 'false', translate: selectT, "aria-label": translate({ key: field.label ?? field.name }), options: [
                     { value: '', label: translate({ key: 'No value' }) }, { value: 'true', label: translate({ key: 'Yes' }) }, { value: 'false', label: translate({ key: 'No' }) },
                 ], onChange: (selected) => onChange({ value: selected === '' ? undefined : selected === 'true' }) });
         case 'datetime': return _jsx("input", { ...common, type: "datetime-local", step: "0.001", value: toDatetimeLocalValue({ value }), onChange: (e) => onChange({ value: fromDatetimeLocalValue({ raw: e.target.value }) }) });

package/dist/react/entities/types.d.ts

@@ -42,4 +42,13 @@ export declare function entityText({ translate, key, values }: {
     readonly key: string;
     readonly values: Readonly<Record<string, string | number>>;
 }): string;
+/**
+ * Adapts the host's object-arg {@link EntityTranslate} to the positional `(key) => string` form the
+ * shared `Select` widget takes. One adapter for every `Select` an entity form renders, so each one
+ * routes its own copy (search box, empty state) through the host dictionary — even the short boolean
+ * select, which never shows that copy today.
+ */
+export declare function selectTranslate({ translate }: {
+    readonly translate: EntityTranslate;
+}): (key: string) => string;
 //# sourceMappingURL=types.d.ts.map

package/dist/react/entities/types.js

@@ -2,4 +2,13 @@
 export function entityText({ translate, key, values }) {
     return translate({ key: key }).replace(/\{([\w]+)\}/g, (match, name) => Object.hasOwn(values, name) ? String(values[name]) : match);
 }
+/**
+ * Adapts the host's object-arg {@link EntityTranslate} to the positional `(key) => string` form the
+ * shared `Select` widget takes. One adapter for every `Select` an entity form renders, so each one
+ * routes its own copy (search box, empty state) through the host dictionary — even the short boolean
+ * select, which never shows that copy today.
+ */
+export function selectTranslate({ translate }) {
+    return (key) => translate({ key });
+}
 //# sourceMappingURL=types.js.map

package/dist/react/use-controller.d.ts

@@ -1,16 +1,2 @@
-import type { DependencyList } from 'react';
-import type { ControllerStore } from '../core/module/controller-store.js';
-/** Factory runs after commit, never during render. Each effect attachment owns a fresh
- * controller, so StrictMode's cleanup/replay cannot revive a disposed controller. */
-export declare function useController<C extends ControllerStore<unknown>>({ create, dependencies }: {
-    create: () => C;
-    dependencies: DependencyList;
-}, { start, }?: {
-    start?: (required: {
-        controller: C;
-    }, optional?: Record<string, never>) => void;
-}): {
-    controller: C | null;
-    snapshot: ReturnType<C["getSnapshot"]> | null;
-};
+export * from '../core/react/use-controller.js';
 //# sourceMappingURL=use-controller.d.ts.map

package/dist/react/use-controller.js

@@ -1,18 +1,3 @@
-import { useEffect, useState, useSyncExternalStore, useCallback } from 'react';
-/** Factory runs after commit, never during render. Each effect attachment owns a fresh
- * controller, so StrictMode's cleanup/replay cannot revive a disposed controller. */
-export function useController({ create, dependencies }, { start, } = {}) {
-    const [controller, setController] = useState(null);
-    useEffect(() => {
-        const current = create();
-        setController(current);
-        start?.({ controller: current });
-        return () => current.dispose();
-        // Dependencies are explicitly supplied by the owning hook, like useMemo's contract.
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, dependencies);
-    const subscribe = useCallback((listener) => controller?.subscribe({ listener }) ?? (() => { }), [controller]);
-    const snapshot = useSyncExternalStore(subscribe, () => (controller?.getSnapshot() ?? null), () => null);
-    return { controller, snapshot };
-}
+// Compatibility path; the shared implementation lives in core.
+export * from '../core/react/use-controller.js';
 //# sourceMappingURL=use-controller.js.map

package/dist/redirects/adapters/http.d.ts

@@ -0,0 +1,20 @@
+import type { AdminRedirectsPort } from '../../core/ports/redirects.js';
+/** Host owns authentication, addressing, retries and error decoding, as in media's adapter. */
+export interface RedirectsTransportPort {
+    request<T>(required: {
+        path: string;
+        method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+        body?: unknown;
+    }, optional?: Record<string, never>): Promise<T>;
+    url(required: {
+        path: string;
+    }, optional?: Record<string, never>): string;
+}
+/** Map existing HTTP envelopes to the core API without validating or rewriting operator inputs.
+ * @example createHttpRedirectsApi({ transport, basePath: workspacePath + '/redirects' }, {});
+ */
+export declare function createHttpRedirectsApi({ transport, basePath }: {
+    transport: RedirectsTransportPort;
+    basePath: string;
+}, _optional?: Record<string, never>): AdminRedirectsPort;
+//# sourceMappingURL=http.d.ts.map

package/dist/redirects/adapters/http.js

@@ -0,0 +1,31 @@
+/** Map existing HTTP envelopes to the core API without validating or rewriting operator inputs.
+ * @example createHttpRedirectsApi({ transport, basePath: workspacePath + '/redirects' }, {});
+ */
+export function createHttpRedirectsApi({ transport, basePath }, _optional = {}) {
+    const base = basePath.replace(/\/$/, '');
+    const path = (id) => `${base}/${encodeURIComponent(id)}`;
+    async function record(method, target, body) {
+        const response = await transport.request({ path: target, method, ...(body === undefined ? {} : { body }) });
+        return response.data;
+    }
+    return {
+        async listRedirects(_required, filter = {}) {
+            const query = new URLSearchParams();
+            for (const key of ['status', 'source', 'matchType']) {
+                if (filter[key] !== undefined)
+                    query.set(key, filter[key]);
+            }
+            const suffix = query.size ? `?${query.toString()}` : '';
+            return (await transport.request({ path: `${base}${suffix}`, method: 'GET' })).data;
+        },
+        getRedirect: ({ id }) => record('GET', path(id)),
+        createRedirect: (input, options = {}) => record('POST', base, { ...input, ...options }),
+        updateRedirect: ({ id }, patch = {}) => record('PATCH', path(id), patch),
+        tombstoneRedirect: ({ id }) => record('DELETE', path(id)),
+        async getRedirectHitStats({ id }) {
+            return (await transport.request({ path: `${path(id)}/hits`, method: 'GET' })).data;
+        },
+        importRedirects: ({ rules }) => transport.request({ path: `${base}/import`, method: 'POST', body: { rules } }),
+    };
+}
+//# sourceMappingURL=http.js.map

package/dist/redirects/adapters/memory.d.ts

@@ -0,0 +1,13 @@
+import type { AdminRedirect, AdminRedirectCreateInput, AdminRedirectHitStats, AdminRedirectImportResult, AdminRedirectsPort } from '../../core/ports/redirects.js';
+/** Presentation backend, not a routing engine: host validators/origin policy remain server owned.
+ * Optional validation lets a host model its own open match vocabulary without a second schema.
+ * @example createMemoryRedirectsApi({ redirects: [] }, {});
+ */
+export declare function createMemoryRedirectsApi({ redirects, hits }: {
+    redirects?: readonly AdminRedirect[];
+    hits?: Readonly<Record<string, AdminRedirectHitStats>>;
+}, { validate, onImport }?: {
+    validate?: (input: AdminRedirectCreateInput) => void;
+    onImport?: (rules: readonly AdminRedirectCreateInput[]) => AdminRedirectImportResult | undefined;
+}): AdminRedirectsPort;
+//# sourceMappingURL=memory.d.ts.map

package/dist/redirects/adapters/memory.js

@@ -0,0 +1,83 @@
+import { AdminApiError } from '../../core/transport/errors.js';
+/** Presentation backend, not a routing engine: host validators/origin policy remain server owned.
+ * Optional validation lets a host model its own open match vocabulary without a second schema.
+ * @example createMemoryRedirectsApi({ redirects: [] }, {});
+ */
+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 })]));
+    let nextId = 1;
+    function get(id) {
+        const row = rows.get(id);
+        if (!row)
+            throw new AdminApiError({ message: `redirect '${id}' was not found`, status: 404 }, { code: 'REDIRECT_NOT_FOUND' });
+        return row;
+    }
+    function create(input, source) {
+        // The core port documents reference-host rejection. A supplied validator owns alternate hosts.
+        if (validate)
+            validate(input);
+        else if (input.matchType === 'regex')
+            throw new AdminApiError({ message: 'regex match type is not supported', status: 400 }, { code: 'REDIRECT_VALIDATION_ERROR' });
+        let id;
+        do {
+            id = `memory-redirect-${nextId++}`;
+        } while (rows.has(id));
+        const row = Object.freeze({ ...input, id, status: 'active', override: input.override ?? false,
+            priority: input.priority ?? 0, source, sourceEntryId: null, fromPathAtCapture: null, toPathAtCapture: null,
+            createdByPrincipal: 'memory-principal', createdByPluginId: null,
+            createdAt: new Date(0).toISOString(), updatedAt: new Date(0).toISOString(), version: 1 });
+        rows.set(id, row);
+        return row;
+    }
+    return {
+        async listRedirects(_required, filter = {}) {
+            return Object.freeze([...rows.values()].filter(row => (filter.status === undefined || row.status === filter.status) &&
+                (filter.source === undefined || row.source === filter.source) &&
+                (filter.matchType === undefined || row.matchType === filter.matchType)));
+        },
+        async getRedirect({ id }) { return get(id); },
+        async createRedirect(input, options = {}) { return create({ ...input, ...options }, 'manual'); },
+        async updateRedirect({ id }, patch = {}) {
+            const before = get(id);
+            const next = { ...before, ...patch };
+            if (validate)
+                validate(next);
+            else if (patch.matchType === 'regex')
+                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);
+            return row;
+        },
+        async tombstoneRedirect({ id }) {
+            const row = get(id);
+            if (row.status === 'disabled')
+                return row;
+            const disabled = Object.freeze({ ...row, status: 'disabled', version: row.version + 1 });
+            rows.set(id, disabled);
+            return disabled;
+        },
+        async getRedirectHitStats({ id }) {
+            get(id);
+            return stats.get(id) ?? Object.freeze({ redirectId: id, hitCount: 0, lastHitAt: null });
+        },
+        async importRedirects({ rules }) {
+            const overridden = onImport?.(rules);
+            if (overridden)
+                return overridden;
+            const created = [], failed = [];
+            // One failed item never discards successful siblings; no per-item network I/O.
+            for (const [index, input] of rules.entries()) {
+                try {
+                    created.push(create(input, 'import'));
+                }
+                catch (error) {
+                    failed.push({ index, code: error instanceof AdminApiError ? error.code ?? 'INTERNAL_ERROR' : 'INTERNAL_ERROR',
+                        message: error instanceof AdminApiError ? error.message : 'an internal error occurred' });
+                }
+            }
+            return { created: Object.freeze(created), failed: Object.freeze(failed) };
+        },
+    };
+}
+//# sourceMappingURL=memory.js.map

package/dist/redirects/conformance/redirects-api.conformance.d.ts

@@ -0,0 +1,12 @@
+import type { AdminRedirectsPort } from '../../core/ports/redirects.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 declare function runRedirectsApiConformance({ api }: {
+    api: AdminRedirectsPort;
+}, { referenceRegexRejection }?: {
+    referenceRegexRejection?: boolean;
+}): Promise<readonly string[]>;
+//# sourceMappingURL=redirects-api.conformance.d.ts.map

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

@@ -0,0 +1,66 @@
+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) {
+        if (!ok)
+            throw new AdminApiError({ message: `Redirects API conformance: ${name}`, status: 0 }, { code: 'CONFORMANCE_FAILED' });
+        checks.push(name);
+    }
+    async function rejects(run, name) {
+        let rejected = false;
+        try {
+            await run();
+        }
+        catch {
+            rejected = true;
+        }
+        assert(rejected, name);
+    }
+    const input = { matchType: 'exact', fromPattern: '/redirects-conformance-a', toTarget: '/redirects-conformance-b', statusCode: 301 };
+    const created = await api.createRedirect(input, { override: true, priority: 7 });
+    assert(created.status === 'active' && created.override && created.priority === 7, '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');
+    const hits = await api.getRedirectHitStats({ id: created.id });
+    assert(hits.redirectId === created.id && hits.hitCount === 0 && hits.lastHitAt === null, 'new rule has zero hits');
+    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');
+    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');
+    }
+    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');
+    }
+    else {
+        assert(batch.created.length === 2 && batch.failed.length === 0, 'valid import batch succeeds');
+    }
+    assert(batch.created.every(row => row.source === 'import'), 'import provenance is stamped by the backend');
+    for (const row of batch.created)
+        await api.tombstoneRedirect({ id: row.id });
+    return Object.freeze(checks);
+}
+//# sourceMappingURL=redirects-api.conformance.js.map

package/dist/redirects/controllers/hit-count.controller.d.ts

@@ -0,0 +1,14 @@
+/** Button-controlled query gate: many mounted rows never cause a burst of hit requests.
+ * @example createHitCountController({}, {});
+ */
+export declare function createHitCountController(_required: Record<string, never>, _optional?: {}): {
+    getSnapshot: () => Readonly<{
+        requested: boolean;
+    }>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    request(_input?: Record<string, never>, _options?: {}): void;
+};
+//# sourceMappingURL=hit-count.controller.d.ts.map

package/dist/redirects/controllers/hit-count.controller.js

@@ -0,0 +1,10 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+/** Button-controlled query gate: many mounted rows never cause a burst of hit requests.
+ * @example createHitCountController({}, {});
+ */
+export function createHitCountController(_required, _optional = {}) {
+    const store = createControllerStore({ initial: { requested: false } });
+    return { getSnapshot: store.getSnapshot, subscribe: store.subscribe, dispose: store.dispose,
+        request(_input = {}, _options = {}) { store.set({ patch: { requested: true } }); } };
+}
+//# sourceMappingURL=hit-count.controller.js.map

package/dist/redirects/controllers/import-redirects.controller.d.ts

@@ -0,0 +1,28 @@
+import type { AdminRedirectCreateInput, AdminRedirectImportResult } from '../../core/ports/redirects.js';
+import type { RedirectsTranslate } from '../models.js';
+export interface ImportRedirectsActions {
+    reset(): void;
+    run(rules: readonly AdminRedirectCreateInput[]): Promise<AdminRedirectImportResult>;
+}
+/** Parse errors are local; the existing query mutation owns request errors and pending state.
+ * @example createImportRedirectsController({ actions: () => currentMutation, t }, {});
+ */
+export declare function createImportRedirectsController({ actions, t }: {
+    actions: () => ImportRedirectsActions;
+    t: () => RedirectsTranslate;
+}, _optional?: {}): {
+    getSnapshot: () => Readonly<{
+        raw: string;
+        parseError: string | null;
+        result: AdminRedirectImportResult | null;
+    }>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    setRaw({ raw }: {
+        raw: string;
+    }, _options?: {}): void;
+    submit(_required?: Record<string, never>, _options?: {}): Promise<void>;
+};
+//# sourceMappingURL=import-redirects.controller.d.ts.map

package/dist/redirects/controllers/import-redirects.controller.js

@@ -0,0 +1,29 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { parseImportPayload } from '../rules.js';
+/** Parse errors are local; the existing query mutation owns request errors and pending state.
+ * @example createImportRedirectsController({ actions: () => currentMutation, t }, {});
+ */
+export function createImportRedirectsController({ actions, t }, _optional = {}) {
+    const store = createControllerStore({
+        initial: { raw: '', parseError: null, result: null },
+    });
+    return {
+        getSnapshot: store.getSnapshot, subscribe: store.subscribe, dispose: store.dispose,
+        setRaw({ raw }, _options = {}) { store.set({ patch: { raw } }); },
+        async submit(_required = {}, _options = {}) {
+            store.set({ patch: { parseError: null, result: null } });
+            actions().reset();
+            // Check JSON + array only: the server remains the validator and returns each item's 207 outcome.
+            const parsed = parseImportPayload({ raw: store.getSnapshot().raw, translate: t() });
+            if (!parsed.ok) {
+                store.set({ patch: { parseError: parsed.error } });
+                return;
+            }
+            try {
+                store.set({ patch: { result: await actions().run(parsed.rules) } });
+            }
+            catch { /* already surfaced by the mutation's request-error channel */ }
+        },
+    };
+}
+//# sourceMappingURL=import-redirects.controller.js.map

package/dist/redirects/controllers/redirects.controller.d.ts

@@ -0,0 +1,37 @@
+import type { AdminRedirect } from '../../core/ports/redirects.js';
+/** Fetch-query owns request/cache states; this controller owns confirmation and write sequencing. */
+export interface RedirectsActions {
+    saving: boolean;
+    create(form: FormData): Promise<unknown>;
+    toggle(rule: AdminRedirect): Promise<unknown>;
+    remove(rule: AdminRedirect): Promise<unknown>;
+    resetOthers(active: 'create' | 'toggle' | 'remove'): void;
+}
+/** The action getter reads the current query mutations, preserving independent errors and guards.
+ * @example createRedirectsController({ actions: () => currentActions }, {});
+ */
+export declare function createRedirectsController({ actions }: {
+    actions: () => RedirectsActions;
+}, _optional?: {}): {
+    getSnapshot: () => Readonly<{
+        pendingDelete: AdminRedirect | null;
+    }>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    setPendingDelete({ rule }: {
+        rule: AdminRedirect | null;
+    }, _options?: {}): void;
+    createRedirect({ form }: {
+        form: FormData;
+    }, _options?: {}): Promise<boolean>;
+    onToggleStatus({ rule }: {
+        rule: AdminRedirect;
+    }, _options?: {}): void;
+    onRequestDelete({ rule }: {
+        rule: AdminRedirect;
+    }, _options?: {}): void;
+    confirmDelete(_required?: Record<string, never>, _options?: {}): void;
+};
+//# sourceMappingURL=redirects.controller.d.ts.map