@jini-ai/admin 0.4.2 → 0.4.4

package/dist/react/components/ConfirmDialog/ConfirmDialog.d.ts

@@ -1,4 +1,4 @@
-import { type ReactNode } from 'react';
+import type { ReactNode } from 'react';
 import { type ConfirmTone } from '../../types.js';
 import { type UseConfirmDialog } from './ConfirmDialog.hooks.js';
 /**
@@ -10,8 +10,8 @@ import { type UseConfirmDialog } from './ConfirmDialog.hooks.js';
  * overlay + backdrop idiom: that shape hand-rolls focus trapping, Escape handling, and a backdrop
  * element, all of which the browser's own top layer gives a real `<dialog>` for free, including
  * correct stacking above everything else on the page without a chosen `z-index`. The `showModal`/
- * `close` calls themselves, and the jsdom fallback they need, live in `ConfirmDialog.hooks.tsx` —
- * see that file's doc comment.
+ * `close` calls themselves, and the jsdom fallback they need, are delegated by
+ * `ConfirmDialog.hooks.tsx` to UI-kit's native hook — see that adapter's doc comment.
  *
  * Unstyled, like everything in this layer: the `.confirm-dialog` / `.btn-secondary` /
  * `.btn-danger` / `.btn-warning` class names are emitted for the host stylesheet to define.
@@ -51,7 +51,7 @@ import { type UseConfirmDialog } from './ConfirmDialog.hooks.js';
  * Labels state both the action and its consequence tier, derived from this component's own
  * three-tier `ConfirmTone` vocabulary rather than reparsed from `title`/`body`: `body` is arbitrary
  * `ReactNode` (a caller can pass JSX), not guaranteed to be a string at all, so it cannot be safely
- * folded into agent-facing text — see {@link confirmDialogConsequencePhrase}.
+ * folded into agent-facing text — the shared UI-kit confirmation planner owns those phrases.
  */
 export interface ConfirmDialogProps {
     open: boolean;
@@ -90,6 +90,23 @@ export interface ConfirmDialogProps {
      *  effect without `agentHandle`. @default true */
     agentMayConfirm?: boolean;
 }
+/**
+ * UI-kit's confirmation planner owns the sub-handle segments appended to the caller's base:
+ * literals chosen by the mechanism, never host data. Neither needs sanitizing, unlike
+ * `RowMenu`'s per-item keys (see this file's "Agent handles" contract).
+ *
+ * Its plain-language consequence phrase is keyed off the dialog's three-tier `ConfirmTone`
+ * vocabulary (`"default"` / `"warning"` / `"danger"`, documented in `../../types.js`), rather
+ * than reparsed from `title` or `body`, which cannot safely supply agent-facing consequence text.
+ * The confirm label names the action (`confirmLabel`), target (`title`) and declared consequence;
+ * the planner does not parse `body` to decide whether an action is safe.
+ *
+ * The cancel label's consequence is a guarantee of the contract (cancelling never calls
+ * `onConfirm`), rather than something read off `tone`, so it needs no tone input at all.
+ * Agent attributes retain the shape used by `RowMenu`'s local `rowMenuAgentProps`; injecting
+ * admin's attribute port into the shared owner preserves that shape and handle validation
+ * without keeping a second local implementation. No base handle means no agent attributes.
+ */
 /**
  * Controlled modal confirm — renders the `<dialog>` markup and delegates its open/close and focus
  * lifecycle to {@link useConfirmDialog} (injectable via the `useDialog` prop, defaulted to the real
@@ -99,5 +116,5 @@ export interface ConfirmDialogProps {
  * is no browser-assigned "default button" for Enter to reach for at all; confirm can only ever fire
  * from an explicit click or explicit Tab-then-Enter onto it.
  */
-export declare function ConfirmDialog({ useDialog, agentHandle: baseHandle, agentMayConfirm, ...props }: ConfirmDialogProps): import("react").JSX.Element;
+export declare function ConfirmDialog({ useDialog, agentHandle: baseHandle, agentMayConfirm, ...props }: ConfirmDialogProps, _optional?: Record<string, never>): import("react").JSX.Element;
 //# sourceMappingURL=ConfirmDialog.d.ts.map

package/dist/react/components/ConfirmDialog/ConfirmDialog.hooks.d.ts

@@ -78,10 +78,10 @@ export declare function useConfirmDialogCancelLabel(_requiredArgs: Record<string
     readonly explicit?: string | undefined;
 }): string;
 /**
- * Owns the `<dialog>` element's open/close lifecycle and focus management for `ConfirmDialog`.
+ * Adapts UI-kit's `<dialog>` element open/close lifecycle and focus management for `ConfirmDialog`.
  *
  * The caller keeps `ConfirmDialog` mounted and toggles `open` — it is never conditionally rendered
- * by its parent — so the effect below has a stable `<dialog>` element to call `showModal()`/
+ * by its parent — so the shared native hook has a stable `<dialog>` element to call `showModal()`/
  * `close()` on and to restore focus through when it closes.
  *
  * Focus moves to the *cancel* action on open, not confirm — an operator whose first keystroke after

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

@@ -1,5 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useEffect, useId, useMemo, useRef, } from 'react';
+import { createContext, useContext, useMemo, useRef, } from 'react';
+import { useNativeDialog } from '@jini-ai/ui-kit/react/native';
 /** Empty object, not `undefined` — {@link useConfirmDialogCancelLabel} can always read `cancelLabel`
  *  off it without an extra null check, whether or not a provider is mounted. */
 const ConfirmDialogDefaultsContext = createContext({});
@@ -41,10 +42,10 @@ export function useConfirmDialogCancelLabel(_requiredArgs, { explicit } = {}) {
     return explicit ?? cancelLabel ?? DEFAULT_CANCEL_LABEL;
 }
 /**
- * Owns the `<dialog>` element's open/close lifecycle and focus management for `ConfirmDialog`.
+ * Adapts UI-kit's `<dialog>` element open/close lifecycle and focus management for `ConfirmDialog`.
  *
  * The caller keeps `ConfirmDialog` mounted and toggles `open` — it is never conditionally rendered
- * by its parent — so the effect below has a stable `<dialog>` element to call `showModal()`/
+ * by its parent — so the shared native hook has a stable `<dialog>` element to call `showModal()`/
  * `close()` on and to restore focus through when it closes.
  *
  * Focus moves to the *cancel* action on open, not confirm — an operator whose first keystroke after
@@ -60,63 +61,24 @@ export function useConfirmDialog({ open, onCancel, document }, { pending } = {})
     // in document order regardless of which dialog is actually open — a screen reader announcing
     // "Delete role?" while the operator is about to confirm "Delete policy?", on a destructive
     // action. `useId()` gives every mounted instance its own id for free.
-    const titleId = useId();
-    const dialogRef = useRef(null);
-    const cancelRef = useRef(null);
     // Captured at the moment `open` flips true, before focus moves into the dialog — the element that
     // had focus then is, by construction, whatever triggered this dialog (a `RowMenu` item's
     // "Delete", a plain trigger button, …). Restored on close rather than left wherever the browser's
     // own modal-focus algorithm happened to land (its default without this is `<body>`, which drops a
     // keyboard user back to the top of the page).
-    const triggerRef = useRef(null);
-    useEffect(() => {
-        const dialog = dialogRef.current;
-        if (!dialog)
-            return;
-        if (open) {
-            triggerRef.current = document.activeElement;
-            if (typeof dialog.showModal === 'function') {
-                if (!dialog.open)
-                    dialog.showModal();
-            }
-            else {
-                dialog.setAttribute('open', '');
-            }
-            cancelRef.current?.focus();
-        }
-        else {
-            if (typeof dialog.close === 'function') {
-                if (dialog.open)
-                    dialog.close();
-            }
-            else {
-                dialog.removeAttribute('open');
-            }
-            if (triggerRef.current instanceof HTMLElement)
-                triggerRef.current.focus();
-        }
-    }, [open, document]);
-    function handleNativeCancel(e) {
-        // Fires on Escape while a real `showModal()`-opened dialog has focus. Always prevented: the
-        // effect above is the single source of truth for open/closed (driven by `open`), so
-        // letting the browser close the element on its own would desync DOM state from React state.
-        // Escape still closes the dialog — it just does so by routing through `onCancel`, same as a
-        // Cancel-button click, so the caller's `open` state (and therefore this same effect) is what
-        // actually calls `dialog.close()`.
-        e.preventDefault();
-        if (pending)
-            return;
-        onCancel();
-    }
-    function handleBackdropClick(e) {
-        // A `<dialog>` element's own box is sized to its content, not the viewport — a click that lands
-        // on the `<dialog>` element itself (as opposed to one of its children) is therefore a click on
-        // the backdrop area outside that content box.
-        if (pending)
-            return;
-        if (e.target === dialogRef.current)
-            onCancel();
-    }
+    // Fires on Escape while a real `showModal()`-opened dialog has focus. Always prevented: the
+    // shared native hook is the single source of truth for open/closed (driven by `open`), so
+    // letting the browser close the element on its own would desync DOM state from React state.
+    // Escape still closes the dialog — it just does so by routing through `onCancel`, same as a
+    // Cancel-button click, so the caller's `open` state (and therefore this same effect) is what
+    // actually calls `dialog.close()`.
+    // A `<dialog>` element's own box is sized to its content, not the viewport — a click that lands
+    // on the `<dialog>` element itself (as opposed to one of its children) is therefore a click on
+    // the backdrop area outside that content box.
+    const cancelRef = useRef(null);
+    const vm = useNativeDialog({ open, title: '', onClose: () => onCancel(), ...(pending === undefined ? {} : { pending }) }, { document, initialFocus: () => cancelRef.current?.focus() });
+    const titleId = vm.titleId, dialogRef = vm.props.ref;
+    const handleNativeCancel = vm.props.onCancel, handleBackdropClick = vm.props.onClick;
     return { titleId, dialogRef, cancelRef, handleNativeCancel, handleBackdropClick };
 }
 //# sourceMappingURL=ConfirmDialog.hooks.js.map

package/dist/react/components/ConfirmDialog/ConfirmDialog.js

@@ -1,72 +1,25 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import {} from 'react';
 import { agentHandle } from '@jini-ai/agentic';
+import { useConfirmController } from '@jini-ai/ui-kit/react';
 import { resolveTone, toneClassName } from '../../types.js';
 import { useConfirmDialog, useConfirmDialogCancelLabel } from './ConfirmDialog.hooks.js';
-/** Sub-handle segments appended to the caller's base — literals this component chooses itself,
- *  never host data (see this file's "Agent handles" doc comment for why that means neither needs
- *  sanitizing, unlike `RowMenu`'s per-item keys). */
-const CONFIRM_HANDLE_ACTION = 'confirm';
-const CANCEL_HANDLE_ACTION = 'cancel';
 /**
- * Plain-language phrase for what confirming actually changes, keyed off the dialog's own
- * three-tier `ConfirmTone` vocabulary (`"default"` / `"warning"` / `"danger"`, documented in
- * `../../types.js`) rather than reparsed from `title` or `body` — see this file's doc comment for
- * why those cannot be safely folded into agent-facing text.
+ * UI-kit's confirmation planner owns the sub-handle segments appended to the caller's base:
+ * literals chosen by the mechanism, never host data. Neither needs sanitizing, unlike
+ * `RowMenu`'s per-item keys (see this file's "Agent handles" contract).
  *
- * @param tone - The dialog's resolved tone (see `resolveTone`).
- * @returns The tier's consequence phrase, or `undefined` for `"default"`, which declares no tier.
- * @complexity O(1).
- */
-function confirmDialogConsequencePhrase(tone) {
-    if (tone === 'danger')
-        return 'cannot be undone';
-    if (tone === 'warning')
-        return 'changes access, but is reversible';
-    return undefined;
-}
-/**
- * The confirm action's agent-facing label: what it does (`confirmLabel`), what it applies to
- * (`title`), and — when the tone declares one — its consequence tier.
- *
- * @param confirmLabel - The button's own visible text, e.g. `"Delete"`.
- * @param title - The dialog's title, e.g. `"Delete role?"`.
- * @param tone - The dialog's resolved tone.
- * @returns A label an agent can use to judge whether confirming is safe, without having read
- *   `body` (which this function never receives — see this file's doc comment for why).
- * @complexity O(1).
- */
-function confirmDialogConfirmLabel(confirmLabel, title, tone) {
-    const consequence = confirmDialogConsequencePhrase(tone);
-    return consequence === undefined ? `${confirmLabel} — ${title}` : `${confirmLabel} — ${title}; ${consequence}`;
-}
-/**
- * The cancel action's agent-facing label. Unlike {@link confirmDialogConfirmLabel}, its consequence
- * is a guarantee of this component's own contract (cancelling never calls `onConfirm`) rather than
- * something read off `tone`, so it needs no tone input at all.
- *
- * @param cancelLabel - The button's own visible text, already defaulted by the caller.
- * @param title - The dialog's title, e.g. `"Delete role?"`.
- * @returns A label stating that this action leaves the titled action unconfirmed.
- * @complexity O(1).
- */
-function confirmDialogCancelLabel(cancelLabel, title) {
-    return `${cancelLabel} — leaves "${title}" unconfirmed; no action taken`;
-}
-/**
- * Builds the `data-agent-*` attribute props for one of this dialog's two actions, or nothing at
- * all when the dialog published no base handle — same shape as `RowMenu.tsx`'s local
- * `rowMenuAgentProps`, kept local and unexported here since only this one component needs it.
+ * Its plain-language consequence phrase is keyed off the dialog's three-tier `ConfirmTone`
+ * vocabulary (`"default"` / `"warning"` / `"danger"`, documented in `../../types.js`), rather
+ * than reparsed from `title` or `body`, which cannot safely supply agent-facing consequence text.
+ * The confirm label names the action (`confirmLabel`), target (`title`) and declared consequence;
+ * the planner does not parse `body` to decide whether an action is safe.
  *
- * @param base - The dialog's own handle from the caller, or `undefined` when it published none.
- * @param action - Which action this is — see {@link CONFIRM_HANDLE_ACTION}/{@link CANCEL_HANDLE_ACTION}.
- * @param options - Role and this action's already-composed label.
- * @returns Spreadable attribute props, or `{}` when `base` is `undefined`.
- * @complexity O(1).
+ * The cancel label's consequence is a guarantee of the contract (cancelling never calls
+ * `onConfirm`), rather than something read off `tone`, so it needs no tone input at all.
+ * Agent attributes retain the shape used by `RowMenu`'s local `rowMenuAgentProps`; injecting
+ * admin's attribute port into the shared owner preserves that shape and handle validation
+ * without keeping a second local implementation. No base handle means no agent attributes.
  */
-function confirmDialogAgentProps(base, action, options) {
-    return base === undefined ? {} : agentHandle({ handle: `${base}-${action}` }, options);
-}
 /**
  * Controlled modal confirm — renders the `<dialog>` markup and delegates its open/close and focus
  * lifecycle to {@link useConfirmDialog} (injectable via the `useDialog` prop, defaulted to the real
@@ -76,16 +29,26 @@ function confirmDialogAgentProps(base, action, options) {
  * is no browser-assigned "default button" for Enter to reach for at all; confirm can only ever fire
  * from an explicit click or explicit Tab-then-Enter onto it.
  */
-export function ConfirmDialog({ useDialog = useConfirmDialog, agentHandle: baseHandle, agentMayConfirm = true, ...props }) {
-    const { titleId, dialogRef, cancelRef, handleNativeCancel, handleBackdropClick } = useDialog({ open: props.open, onCancel: props.onCancel, document }, { pending: props.pending });
+export function ConfirmDialog({ useDialog = useConfirmDialog, agentHandle: baseHandle, agentMayConfirm = true, ...props }, _optional = {}) {
     const tone = resolveTone({}, props);
     const cancelLabel = useConfirmDialogCancelLabel({}, { explicit: props.cancelLabel });
-    return (_jsxs("dialog", { ref: dialogRef, className: "confirm-dialog", "aria-labelledby": titleId, onCancel: handleNativeCancel, onClick: handleBackdropClick, children: [_jsx("h2", { id: titleId, children: props.title }), _jsx("div", { className: "confirm-dialog-body", children: props.body }), _jsxs("div", { className: "confirm-dialog-actions", children: [_jsx("button", { ref: cancelRef, type: "button", className: "btn-secondary", disabled: props.pending, onClick: props.onCancel, ...confirmDialogAgentProps(baseHandle, CANCEL_HANDLE_ACTION, {
-                            role: 'button',
-                            label: confirmDialogCancelLabel(cancelLabel, props.title),
-                        }), children: cancelLabel }), _jsx("button", { type: "button", className: toneClassName({ tone }), disabled: props.pending, onClick: () => props.onConfirm(), ...confirmDialogAgentProps(agentMayConfirm ? baseHandle : undefined, CONFIRM_HANDLE_ACTION, {
-                            role: 'button',
-                            label: confirmDialogConfirmLabel(props.confirmLabel, props.title, tone),
-                        }), children: props.confirmLabel })] })] }));
+    const controller = useConfirmController({
+        open: props.open, title: props.title, body: props.body, confirmLabel: props.confirmLabel,
+        cancelLabel, tone, agentMayConfirm,
+        ...(baseHandle === undefined ? {} : { agentHandle: baseHandle }),
+        ...(props.pending === undefined ? {} : { pending: props.pending }),
+        onConfirm: () => props.onConfirm(), onCancel: () => props.onCancel(),
+    }, {
+        // UI-kit names selects separately; agentic publishes them as fields and still owns handle validation.
+        agent: ((required, optional = {}) => agentHandle(required, {
+            ...(optional.role === undefined ? {} : { role: optional.role === 'select' ? 'field' : optional.role }),
+            ...(optional.label === undefined ? {} : { label: optional.label }),
+        })),
+    });
+    const { titleId, dialogRef, cancelRef, handleNativeCancel, handleBackdropClick } = useDialog({ open: props.open, onCancel: () => { controller.requestDismiss({ reason: 'close' }); }, document }, { pending: controller.pending });
+    // Keep admin's concise accessible names; the shared planner still supplies consequence-aware agent labels.
+    const { 'aria-label': _cancelName, ...cancelAttrs } = controller.cancel.attrs ?? {};
+    const { 'aria-label': _confirmName, ...confirmAttrs } = controller.confirm.attrs ?? {};
+    return (_jsxs("dialog", { ref: dialogRef, className: "confirm-dialog", "aria-labelledby": titleId, onCancel: handleNativeCancel, onClick: handleBackdropClick, children: [_jsx("h2", { id: titleId, children: props.title }), _jsxs("div", { className: "confirm-dialog-body", children: [props.body, controller.error] }), _jsxs("div", { className: "confirm-dialog-actions", children: [_jsx("button", { ref: cancelRef, type: "button", className: "btn-secondary", disabled: controller.pending, onClick: () => controller.cancel.onPress?.({}), ...cancelAttrs, children: cancelLabel }), _jsx("button", { type: "button", className: toneClassName({ tone }), disabled: controller.pending, onClick: () => controller.confirm.onPress?.({}), ...confirmAttrs, children: props.confirmLabel })] })] }));
 }
 //# sourceMappingURL=ConfirmDialog.js.map

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

@@ -12,13 +12,14 @@ const VIEWPORT_MARGIN = 8;
  * 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
+ * Click-outside and Escape close. Escape is document-scoped so it also works after focus
+ * moves away from the popup. 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 trackOpenMenu({ trigger, menu }, { window, document, onPosition, onDismiss, onEscape }) {
     function reposition() {
         const rect = trigger.getBoundingClientRect();
         const menuHeight = menu.offsetHeight;
@@ -41,14 +42,23 @@ function trackOpenMenu({ trigger, menu }, { window, document, onPosition, onDism
             return;
         onDismiss();
     }
+    function onDocKeyDown(e) {
+        if (e.key !== 'Escape' || e.defaultPrevented)
+            return;
+        e.preventDefault();
+        e.stopPropagation();
+        onEscape();
+    }
     reposition();
     window.addEventListener('scroll', reposition, true);
     window.addEventListener('resize', reposition);
     document.addEventListener('mousedown', onDocMouseDown);
+    document.addEventListener('keydown', onDocKeyDown);
     return () => {
         window.removeEventListener('scroll', reposition, true);
         window.removeEventListener('resize', reposition);
         document.removeEventListener('mousedown', onDocMouseDown);
+        document.removeEventListener('keydown', onDocKeyDown);
     };
 }
 /**
@@ -89,7 +99,7 @@ export function useRowMenu({ itemCount, window, document }) {
         let stop;
         return (menu) => {
             if (menu)
-                stop = trackOpenMenu({ trigger: anchor, menu }, { window, document, onPosition: setPosition, onDismiss: () => close(false) });
+                stop = trackOpenMenu({ trigger: anchor, menu }, { window, document, onPosition: setPosition, onDismiss: () => close(false), onEscape: () => close(true) });
             else
                 stop();
         };
@@ -140,6 +150,7 @@ export function useRowMenu({ itemCount, window, document }) {
                 break;
             case 'Escape':
                 e.preventDefault();
+                e.stopPropagation();
                 close(true);
                 break;
             case 'Tab':

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