@jini-ai/admin 0.4.12 → 0.6.10

package/dist/core/module/create-admin.js

@@ -6,79 +6,116 @@ export class AdminConfigError extends Error {
         this.issues = Object.freeze([...issues]);
     }
 }
-export function createAdmin({ modules, ports, }, options = {}) {
-    const issues = [];
-    const tokens = new Map();
-    const identities = new Map();
-    const providers = new Map();
-    const ids = new Set(), paths = new Set(), tabIds = new Set();
-    const requiredNames = new Set();
-    const host = ports;
-    const values = { ...host };
-    const omitted = new Set(options.omit ?? []);
-    const grants = new Set(options.permissions ?? []);
-    const allowed = (permissions = []) => permissions.every((p) => grants.has(p));
-    function collect(map = {}, required = false) {
-        for (const [name, tok] of Object.entries(map)) {
-            const old = tokens.get(name);
-            if (!tok.id || tok.cardinality !== 'one' || !Number.isInteger(tok.version) || tok.version < 1)
-                issues.push(`Invalid token: ${name}`);
-            if (old && (old.id !== tok.id || old.version !== tok.version))
-                issues.push(`Incompatible token: ${name}`);
-            const alias = identities.get(tok.id);
-            if (alias && alias !== name)
-                issues.push(`Token ${tok.id} has conflicting names: ${alias}, ${name}`);
-            identities.set(tok.id, name);
-            tokens.set(name, tok);
-            if (required)
-                requiredNames.add(name);
+function isValidToken(tok) {
+    return (Boolean(tok.id) &&
+        tok.cardinality === 'one' &&
+        Number.isInteger(tok.version) &&
+        tok.version >= 1);
+}
+function checkToken({ registry, name, tok }, _optional = {}) {
+    const { issues } = registry;
+    if (!isValidToken(tok))
+        issues.push(`Invalid token: ${name}`);
+    const old = registry.tokens.get(name);
+    if (old && (old.id !== tok.id || old.version !== tok.version))
+        issues.push(`Incompatible token: ${name}`);
+    const alias = registry.identities.get(tok.id);
+    if (alias && alias !== name)
+        issues.push(`Token ${tok.id} has conflicting names: ${alias}, ${name}`);
+}
+function collectTokens({ registry, map }, { required = false } = {}) {
+    for (const [name, tok] of Object.entries(map ?? {})) {
+        checkToken({ registry, name, tok });
+        registry.identities.set(tok.id, name);
+        registry.tokens.set(name, tok);
+        if (required)
+            registry.requiredNames.add(name);
+    }
+}
+function checkProvider({ registry, module, name, overrides, }, _optional = {}) {
+    const { issues, providers } = registry;
+    if (providers.has(name))
+        issues.push(`Duplicate provider: ${name}`);
+    providers.set(name, module);
+    const hosted = registry.host[name] != null;
+    if (hosted && !overrides.includes(name))
+        issues.push(`Provider collision: ${name}; declare an override`);
+    if (!module.factories?.[name] && !hosted)
+        issues.push(`Missing provider factory: ${name}`);
+}
+function registerProviders({ registry, module, overrides, }, _optional = {}) {
+    const provides = module.provides ?? {};
+    for (const name of Object.keys(provides))
+        checkProvider({ registry, module, name, overrides });
+    for (const name of Object.keys(module.factories ?? {}))
+        if (!(name in provides))
+            registry.issues.push(`Undeclared provider factory: ${name}`);
+}
+function registerPages({ registry, module, omitted, }, _optional = {}) {
+    const { issues, paths, tabIds } = registry;
+    for (const [pageId, page] of Object.entries(module.pages)) {
+        if (paths.has(page.path))
+            issues.push(`Duplicate route: ${page.path}`);
+        paths.add(page.path);
+        for (const [tabId, tab] of Object.entries(page.tabs)) {
+            const full = `${module.id}.${pageId}.${tabId}`;
+            tabIds.add(full);
+            collectTokens({ registry, map: tab.requires }, { required: !omitted.has(full) });
+            collectTokens({ registry, map: tab.optional });
         }
     }
+}
+function registerModules({ modules, host, omitted, overrides, }, _optional = {}) {
+    const registry = {
+        host,
+        issues: [],
+        tokens: new Map(),
+        identities: new Map(),
+        providers: new Map(),
+        requiredNames: new Set(),
+        ids: new Set(),
+        paths: new Set(),
+        tabIds: new Set(),
+    };
     for (const module of modules) {
-        if (ids.has(module.id))
-            issues.push(`Duplicate module: ${module.id}`);
-        ids.add(module.id);
-        collect(module.requires, true);
-        collect(module.optional);
-        collect(module.provides);
-        for (const name of Object.keys(module.provides ?? {})) {
-            if (providers.has(name))
-                issues.push(`Duplicate provider: ${name}`);
-            providers.set(name, module);
-            if (host[name] != null &&
-                !options.overrides?.includes(name))
-                issues.push(`Provider collision: ${name}; declare an override`);
-            if (!module.factories?.[name] && host[name] == null)
-                issues.push(`Missing provider factory: ${name}`);
-        }
-        for (const name of Object.keys(module.factories ?? {}))
-            if (!(name in (module.provides ?? {})))
-                issues.push(`Undeclared provider factory: ${name}`);
-        for (const [pageId, page] of Object.entries(module.pages)) {
-            if (paths.has(page.path))
-                issues.push(`Duplicate route: ${page.path}`);
-            paths.add(page.path);
-            for (const [tabId, tab] of Object.entries(page.tabs)) {
-                const full = `${module.id}.${pageId}.${tabId}`;
-                tabIds.add(full);
-                collect(tab.requires, !omitted.has(full));
-                collect(tab.optional);
-            }
-        }
+        if (registry.ids.has(module.id))
+            registry.issues.push(`Duplicate module: ${module.id}`);
+        registry.ids.add(module.id);
+        collectTokens({ registry, map: module.requires }, { required: true });
+        collectTokens({ registry, map: module.optional });
+        collectTokens({ registry, map: module.provides });
+        registerProviders({ registry, module, overrides });
+        registerPages({ registry, module, omitted });
     }
+    return registry;
+}
+function checkOptions({ registry, omitted, overrides, }, _optional = {}) {
+    const { issues } = registry;
     for (const id of omitted)
-        if (!tabIds.has(id))
+        if (!registry.tabIds.has(id))
             issues.push(`Unknown tab: ${id}`);
-    for (const name of options.overrides ?? [])
-        if (!providers.has(String(name)))
-            issues.push(`Unknown provider override: ${String(name)}`);
+    for (const name of overrides)
+        if (!registry.providers.has(name))
+            issues.push(`Unknown provider override: ${name}`);
+}
+function checkPorts({ registry }, _optional = {}) {
+    const { host, issues, providers } = registry;
     for (const name of Object.keys(host))
-        if (!tokens.has(name))
+        if (!registry.tokens.has(name))
             issues.push(`Unknown port: ${name}`);
-    for (const name of requiredNames)
+    for (const name of registry.requiredNames)
         if (host[name] == null && !providers.has(name))
             issues.push(`Missing port: ${name}`);
-    // Validate the graph before executing factories, so a boot error has no partial side effects.
+}
+function dependencies(module) {
+    const tabPorts = Object.values(module.pages)
+        .flatMap((page) => Object.values(page.tabs))
+        .reduce((result, tab) => ({ ...result, ...tab.requires, ...tab.optional }), {});
+    return { ...module.requires, ...module.optional, ...tabPorts };
+}
+/** Depth-first topological order of the providers the host does not already supply. */
+function orderProviders({ registry }, _optional = {}) {
+    const { host, issues, providers } = registry;
     const sorted = [], visiting = new Set(), visited = new Set();
     function visit(name, chain) {
         if (visited.has(name) || host[name] != null)
@@ -88,8 +125,7 @@ export function createAdmin({ modules, ports, }, options = {}) {
             return;
         }
         visiting.add(name);
-        const module = providers.get(name);
-        for (const dep of Object.keys(dependencies(module)))
+        for (const dep of Object.keys(dependencies(providers.get(name))))
             if (providers.has(dep))
                 visit(dep, [...chain, name]);
         visiting.delete(name);
@@ -98,68 +134,84 @@ export function createAdmin({ modules, ports, }, options = {}) {
     }
     for (const name of providers.keys())
         visit(name, []);
-    if (issues.length)
-        throw new AdminConfigError({ issues: [...new Set(issues)] });
+    return sorted;
+}
+function narrow({ module, values }) {
+    return Object.freeze(Object.fromEntries(Object.keys(dependencies(module)).map((name) => [name, values[name]])));
+}
+function isDisposable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'dispose' in value &&
+        typeof value.dispose === 'function');
+}
+function disposeAll(disposables) {
+    for (const value of [...disposables].reverse())
+        value.dispose();
+}
+/** Runs factories in dependency order; a failure disposes what was built and reports one issue. */
+function instantiate({ providers, sorted, values, grants, }, _optional = {}) {
     const disposables = [];
-    function dependencies(module) {
-        const tabPorts = Object.values(module.pages)
-            .flatMap((page) => Object.values(page.tabs))
-            .reduce((result, tab) => ({ ...result, ...tab.requires, ...tab.optional }), {});
-        return { ...module.requires, ...module.optional, ...tabPorts };
-    }
-    function narrow(module) {
-        return Object.freeze(Object.fromEntries(Object.keys(dependencies(module)).map((name) => [name, values[name]])));
-    }
     try {
         for (const name of sorted) {
-            const value = providers.get(name).factories[name]({ ports: narrow(providers.get(name)), permissions: [...grants] }, {});
+            const module = providers.get(name);
+            const value = module.factories[name]({ ports: narrow({ module, values }), permissions: [...grants] }, {});
             if (value == null)
                 throw new Error(`Provider returned no value: ${name}`);
             values[name] = value;
-            if (typeof value === 'object' && 'dispose' in value && typeof value.dispose === 'function')
+            if (isDisposable(value))
                 disposables.push(value);
         }
     }
     catch (error) {
-        for (const value of disposables.reverse())
-            value.dispose();
+        disposeAll(disposables);
         throw new AdminConfigError({
             issues: [error instanceof Error ? error.message : 'Provider initialization failed'],
         });
     }
-    const description = Object.freeze({
-        modules: Object.freeze([...ids]),
-        pages: Object.freeze(modules.flatMap((module) => Object.entries(module.pages).map(([id, page]) => ({
-            id: `${module.id}.${id}`,
-            path: page.path,
-            label: page.label,
-            visible: allowed(page.permissions),
-            agentReachable: page.agentReachable === true && allowed(page.permissions),
-            permissions: page.permissions ?? [],
-            grants: Object.freeze([...grants]),
-            ...(page.nav ? { nav: page.nav } : {}),
-            tabs: Object.entries(page.tabs).map(([tabId, tab]) => {
-                const full = `${module.id}.${id}.${tabId}`;
-                const absent = Object.keys(tab.optional ?? {}).find((name) => values[name] == null);
-                const reason = omitted.has(full)
-                    ? 'omitted'
-                    : !allowed(page.permissions) || !allowed(tab.permissions)
-                        ? 'permission denied'
-                        : absent
-                            ? `optional port unavailable: ${absent}`
-                            : null;
-                return {
-                    id: full,
-                    label: tab.label,
-                    visible: reason === null,
-                    reason,
-                    params: tab.params ?? {},
-                    agentReachable: reason === null && page.agentReachable === true && tab.agentReachable === true,
-                };
-            }),
-        })))),
-        ports: Object.freeze([...tokens]
-            .filter(([name]) => values[name] != null)
+    return disposables;
+}
+const allowed = ({ grants }, permissions = []) => permissions.every((p) => grants.has(p));
+function tabReason({ context, full, page, tab, }, _optional = {}) {
+    if (context.omitted.has(full))
+        return 'omitted';
+    if (!allowed(context, page.permissions) || !allowed(context, tab.permissions))
+        return 'permission denied';
+    const absent = Object.keys(tab.optional ?? {}).find((name) => context.values[name] == null);
+    return absent ? `optional port unavailable: ${absent}` : null;
+}
+function describePage({ context, module, id, page, }, _optional = {}) {
+    const visible = allowed(context, page.permissions);
+    return {
+        id: `${module.id}.${id}`,
+        path: page.path,
+        label: page.label,
+        visible,
+        agentReachable: page.agentReachable === true && visible,
+        permissions: page.permissions ?? [],
+        grants: Object.freeze([...context.grants]),
+        ...(page.nav ? { nav: page.nav } : {}),
+        tabs: Object.entries(page.tabs).map(([tabId, tab]) => {
+            const full = `${module.id}.${id}.${tabId}`;
+            const reason = tabReason({ context, full, page, tab });
+            return {
+                id: full,
+                label: tab.label,
+                visible: reason === null,
+                reason,
+                params: tab.params ?? {},
+                agentReachable: reason === null && page.agentReachable === true && tab.agentReachable === true,
+            };
+        }),
+    };
+}
+function describeAdmin({ modules, registry, context, }, _optional = {}) {
+    const { host } = registry;
+    return Object.freeze({
+        modules: Object.freeze([...registry.ids]),
+        pages: Object.freeze(modules.flatMap((module) => Object.entries(module.pages).map(([id, page]) => describePage({ context, module, id, page })))),
+        ports: Object.freeze([...registry.tokens]
+            .filter(([name]) => context.values[name] != null)
             .map(([name, tok]) => ({
             name,
             token: tok.id,
@@ -167,19 +219,45 @@ export function createAdmin({ modules, ports, }, options = {}) {
             source: host[name] != null ? 'host' : 'module',
         }))),
     });
+}
+export function createAdmin({ modules, ports, }, options = {}) {
+    const host = ports;
+    const values = { ...host };
+    const omitted = new Set(options.omit ?? []);
+    const overrides = (options.overrides ?? []).map(String);
+    const grants = new Set(options.permissions ?? []);
+    const registry = registerModules({ modules, host, omitted, overrides });
+    checkOptions({ registry, omitted, overrides });
+    checkPorts({ registry });
+    // Validate the graph before executing factories, so a boot error has no partial side effects.
+    const sorted = orderProviders({ registry });
+    if (registry.issues.length)
+        throw new AdminConfigError({ issues: [...new Set(registry.issues)] });
+    const disposables = instantiate({
+        providers: registry.providers,
+        sorted,
+        values,
+        grants: [...grants],
+    });
+    const description = describeAdmin({
+        modules,
+        registry,
+        context: { values, omitted, grants },
+    });
     let disposed = false;
     return {
         describe: () => description,
         scope: ({ module }) => {
             if (disposed || !modules.includes(module))
-                throw new AdminConfigError({ issues: [`Module scope unavailable: ${module.id}`] });
-            return narrow(module);
+                throw new AdminConfigError({
+                    issues: [`Module scope unavailable: ${module.id}`],
+                });
+            return narrow({ module, values });
         },
         dispose: () => {
             if (!disposed) {
                 disposed = true;
-                for (const value of disposables.reverse())
-                    value.dispose();
+                disposeAll(disposables);
             }
         },
     };

package/dist/core/ports/redirects.d.ts

@@ -18,12 +18,14 @@
  * has no `slug` field at all) — kept here because the union is OPEN and a different host may
  * legitimately implement `regex` even though the reference implementation refuses it.
  *
- * ## `tombstoneRedirect` is a soft delete
+ * ## `tombstoneRedirect` moves the rule to the Trash
  *
- * Mirrors `AdminIntegrationsPort.deleteIntegrationSubscription`, not `AdminMediaPort.deleteMedia`:
- * the rule's `status` flips to `"disabled"` and the row is retained (audit trail, still readable
- * via `listRedirects`/`getRedirect`), never hard-purged. The method resolves to the updated record
- * (200-style), not `void` — a panel can render the new state without a re-fetch.
+ * The rule's `status` flips to `"disabled"` and the row is retained (audit trail, still readable
+ * via `getRedirect`), never hard-purged here — but it LEAVES `listRedirects` (Bug B, 2026-10-22):
+ * a removed rule is shown only in the host's Trash, unlike a rule merely toggled off, which stays
+ * listed as `"disabled"`. Removing a toggled-off rule moves it to the Trash too. A pure
+ * `updateRedirect({ status: "active" })` (or the host's Trash restore) brings it back to the list.
+ * The method resolves to the updated record (200-style), not `void`.
  *
  * ## `source: "auto_slug_change"` is read-only provenance
  *
@@ -131,7 +133,7 @@ export interface AdminRedirectsPort {
     updateRedirect(requiredArgs: {
         id: string;
     }, optionalArgs?: AdminRedirectUpdatePatch): Promise<AdminRedirect>;
-    /** Soft delete — returns the tombstoned record, not `void`. See file header. */
+    /** Moves the rule to the Trash (off `listRedirects`) — returns the tombstoned record, not `void`. See file header. */
     tombstoneRedirect(requiredArgs: {
         id: string;
     }): Promise<AdminRedirect>;

package/dist/core/ports/redirects.js

@@ -18,12 +18,14 @@
  * has no `slug` field at all) — kept here because the union is OPEN and a different host may
  * legitimately implement `regex` even though the reference implementation refuses it.
  *
- * ## `tombstoneRedirect` is a soft delete
- *
- * Mirrors `AdminIntegrationsPort.deleteIntegrationSubscription`, not `AdminMediaPort.deleteMedia`:
- * the rule's `status` flips to `"disabled"` and the row is retained (audit trail, still readable
- * via `listRedirects`/`getRedirect`), never hard-purged. The method resolves to the updated record
- * (200-style), not `void` — a panel can render the new state without a re-fetch.
+ * ## `tombstoneRedirect` moves the rule to the Trash
+ *
+ * The rule's `status` flips to `"disabled"` and the row is retained (audit trail, still readable
+ * via `getRedirect`), never hard-purged here — but it LEAVES `listRedirects` (Bug B, 2026-10-22):
+ * a removed rule is shown only in the host's Trash, unlike a rule merely toggled off, which stays
+ * listed as `"disabled"`. Removing a toggled-off rule moves it to the Trash too. A pure
+ * `updateRedirect({ status: "active" })` (or the host's Trash restore) brings it back to the list.
+ * The method resolves to the updated record (200-style), not `void`.
  *
  * ## `source: "auto_slug_change"` is read-only provenance
  *

package/dist/core/routing/rules.js

@@ -46,8 +46,10 @@ export function adminHref({ routePath }, { base = DEFAULT_ADMIN_BASE } = {}) {
 export function currentRoutePath({ pathname }, { base = DEFAULT_ADMIN_BASE } = {}) {
     if (pathname === base)
         return '/';
+    // The slice keeps the `/` the `startsWith` check just matched, so it is never empty and needs no
+    // `'/'` fallback.
     if (pathname.startsWith(`${base}/`))
-        return pathname.slice(base.length) || '/';
+        return pathname.slice(base.length);
     // Reached only if the app is mounted somewhere unexpected; treat the whole path as the route
     // rather than silently returning the dashboard, so the mismatch is visible in the URL.
     return pathname || '/';
@@ -63,7 +65,8 @@ export function currentRoutePath({ pathname }, { base = DEFAULT_ADMIN_BASE } = {
  */
 export function matchRoute({ routePath, panels }) {
     const [rawPath, rawQuery] = routePath.split('?');
-    const segments = (rawPath ?? '').split('/').filter(Boolean);
+    // `split` with a string separator always returns at least one element, so the path part exists.
+    const segments = rawPath.split('/').filter(Boolean);
     const query = new URLSearchParams(rawQuery ?? '');
     const miss = (panelId) => ({ panelId, view: null, params: {}, query });
     // Root is the dashboard by convention, and `dashboard` need not be registered for `/` to
@@ -99,8 +102,10 @@ function matchPattern(pattern, segments) {
         return null;
     const params = {};
     for (let i = 0; i < patternSegments.length; i += 1) {
-        const patternSegment = patternSegments[i] ?? '';
-        const segment = segments[i] ?? '';
+        // Both indexes exist: the loop is bounded by `patternSegments.length`, which the length check
+        // above made equal to `segments.length`.
+        const patternSegment = patternSegments[i];
+        const segment = segments[i];
         if (patternSegment.startsWith(':')) {
             params[patternSegment.slice(1)] = segment;
             continue;

package/dist/core/transport/http.js

@@ -18,16 +18,21 @@ function unreachableApiMessage({ status } = {}) {
     return `cannot reach the API${detail} — is the server running?`;
 }
 /** Timeout DOMExceptions can come from another realm; instanceof Error alone is unreliable. */
+function errorName(cause) {
+    return cause && typeof cause === 'object' && 'name' in cause ? cause.name : undefined;
+}
+function requestTimeoutError({ cause, timeoutMs }, _optional = {}) {
+    const message = `the API did not respond within ${timeoutMs / 1000}s — the browser may be out of free connections for this origin (try closing other admin tabs) or the server is unresponsive`;
+    return new AdminApiError({ message, status: 0 }, {
+        code: 'REQUEST_TIMEOUT', body: { cause: cause instanceof Error ? cause.message : String(cause) },
+    });
+}
 function throwTranslatedFetchFailure({ cause, timeoutMs }, { isPageUnloading } = {}) {
-    const name = cause && typeof cause === 'object' && 'name' in cause ? cause.name : undefined;
+    const name = errorName(cause);
     if (name === 'AbortError')
         throw cause;
-    if (name === 'TimeoutError') {
-        const message = `the API did not respond within ${timeoutMs / 1000}s — the browser may be out of free connections for this origin (try closing other admin tabs) or the server is unresponsive`;
-        throw new AdminApiError({ message, status: 0 }, {
-            code: 'REQUEST_TIMEOUT', body: { cause: cause instanceof Error ? cause.message : String(cause) },
-        });
-    }
+    if (name === 'TimeoutError')
+        throw requestTimeoutError({ cause, timeoutMs });
     // Only fetch's TypeError proves a network failure. Adapter bugs retain their original type.
     if (!(cause instanceof TypeError))
         throw cause;
@@ -37,6 +42,26 @@ function throwTranslatedFetchFailure({ cause, timeoutMs }, { isPageUnloading } =
         code: 'API_UNREACHABLE', body: { cause: cause.message },
     });
 }
+/**
+ * Headers normalizes names and accepts every HeadersInit form; object spreads lose
+ * Headers instances and treat tuple arrays as numeric keys instead of header entries.
+ * Later sources win: the JSON default, then the transport's own, then the call's.
+ */
+function mergeHeaders(sources) {
+    const headers = new Headers({ 'Content-Type': 'application/json' });
+    for (const source of sources)
+        new Headers(source).forEach((value, name) => headers.set(name, value));
+    return headers;
+}
+/** The error a non-2xx response throws, given its parsed (or unparseable) body. */
+function responseError({ res, body, wasUnparseable }, _optional = {}) {
+    // Valid JSON proves the application answered. Only unparseable 5xx responses indicate
+    // an unreachable upstream or a server crash outside the application's JSON envelope.
+    const noAppEnvelope = wasUnparseable && res.status >= 500;
+    const fallback = noAppEnvelope ? unreachableApiMessage({ status: res.status }) : `request failed (${res.status})`;
+    const serverCode = typeof body?.code === 'string' ? body.code : undefined;
+    return new AdminApiError({ message: String(body?.error ?? fallback), status: res.status }, { code: noAppEnvelope ? 'API_UNREACHABLE' : serverCode, body });
+}
 /**
  * The standard `fetch`-backed transport.
  *
@@ -44,14 +69,10 @@ function throwTranslatedFetchFailure({ cause, timeoutMs }, { isPageUnloading } =
  * server's `error` string, HTTP status, canonical `code` when present, and the raw parsed body.
  */
 export function createHttpTransport({ baseUrl, fetch: doFetch }, { headers: baseHeaders, credentials = 'same-origin', timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, isPageUnloading } = {}) {
+    const unloading = isPageUnloading ? { isPageUnloading } : {};
     return {
         async request({ path }, options = {}) {
             const { onOk, ...init } = options;
-            // Headers normalizes names and accepts every HeadersInit form; object spreads lose
-            // Headers instances and treat tuple arrays as numeric keys instead of header entries.
-            const headers = new Headers({ 'Content-Type': 'application/json' });
-            new Headers(baseHeaders).forEach((value, name) => headers.set(name, value));
-            new Headers(init.headers).forEach((value, name) => headers.set(name, value));
             // An explicit signal owns cancellation and its deadline; never replace it with ours.
             const signal = init.signal ?? AbortSignal.timeout(timeoutMs);
             const res = await doFetch({ url: `${baseUrl}${path}` }, {
@@ -61,19 +82,15 @@ export function createHttpTransport({ baseUrl, fetch: doFetch }, { headers: base
                 // Assign last so a per-call header overrides both the JSON default and the transport's
                 // own. The reference implementation's original spread `...init` last, which meant a call passing `headers` lost
                 // the `Content-Type` default rather than merging with it.
-                headers,
-            }).catch((cause) => throwTranslatedFetchFailure({ cause, timeoutMs }, isPageUnloading ? { isPageUnloading } : {}));
+                headers: mergeHeaders([baseHeaders, init.headers]),
+            }).catch((cause) => throwTranslatedFetchFailure({ cause, timeoutMs }, unloading));
             // A 204 or an empty body is not a JSON parse failure worth surfacing — it is a successful
             // mutation with nothing to return. Same `.catch(() => ({}))` as the original.
             const parsed = await res.json().catch(() => UNPARSEABLE_BODY);
             const wasUnparseable = parsed === UNPARSEABLE_BODY;
             const body = (wasUnparseable ? {} : parsed);
-            if (!res.ok) {
-                // Valid JSON proves the application answered. Only unparseable 5xx responses indicate
-                // an unreachable upstream or a server crash outside the application's JSON envelope.
-                const noAppEnvelope = wasUnparseable && res.status >= 500;
-                throw new AdminApiError({ message: String(body?.error ?? (noAppEnvelope ? unreachableApiMessage({ status: res.status }) : `request failed (${res.status})`)), status: res.status }, { code: noAppEnvelope ? 'API_UNREACHABLE' : typeof body?.code === 'string' ? body.code : undefined, body });
-            }
+            if (!res.ok)
+                throw responseError({ res, body, wasUnparseable });
             onOk?.({ response: res });
             return body;
         },

package/dist/forms/adapters/memory.js

@@ -1,21 +1,38 @@
 import { AdminApiError } from '../../core/transport/errors.js';
+// The contract excludes slug; runtime callers cannot smuggle it through a cast either.
+const PATCHABLE_KEYS = ['name', 'fields', 'notify', 'status', 'mode', 'html'];
+/** The allowlisted patch keys the caller actually supplied (an explicit `undefined` is not a value). */
+function suppliedPatch(patch) {
+    return Object.fromEntries(PATCHABLE_KEYS.filter(key => patch[key] !== undefined).map(key => [key, patch[key]]));
+}
+/** The core contract's add/edit-only invariant: a fields replacement must keep every current id. */
+function assertNoFieldRemoved({ current, patch }) {
+    if (!patch.fields)
+        return;
+    const incomingIds = new Set(patch.fields.map(field => field.id));
+    if (current.fields.some(field => !incomingIds.has(field.id))) {
+        throw new AdminApiError({ message: 'existing form fields cannot be removed', status: 400 }, { code: 'FORMS_FIELD_VALIDATION_ERROR' });
+    }
+}
 /** A scoped, deterministic in-memory API with the core contract's add/edit-only invariant. */
 export function createMemoryFormsApi(_required = {}, { forms = [], submissions = [], now = () => new Date(0).toISOString(), nextId } = {}) {
     const definitions = structuredClone([...forms]);
     const answers = structuredClone([...submissions]);
     let sequence = definitions.length;
-    const missing = (id) => { throw new AdminApiError({ message: `form definition '${id}' was not found`, status: 404 }); };
+    const missing = (id, { kind = 'form definition' } = {}) => {
+        throw new AdminApiError({ message: `${kind} '${id}' was not found`, status: 404 });
+    };
     const find = (id) => definitions.find(form => form.slug === id) ?? definitions.find(form => form.id === id) ?? missing(id);
     const definitionId = (id) => definitions.find(form => form.slug === id)?.id ?? id;
     const findSubmission = (formId, id) => {
         const resolvedId = definitionId(formId);
-        return answers.find(item => item.id === id && item.formDefinitionId === resolvedId && item.status !== 'trash') ?? missing(id);
+        return answers.find(item => item.id === id && item.formDefinitionId === resolvedId && item.status !== 'trash') ?? missing(id, { kind: 'form submission' });
     };
     const remove = (type, id) => {
         const rows = type === 'form' ? definitions : answers;
         const index = rows.findIndex(row => row.id === id);
         if (index < 0)
-            missing(id);
+            missing(id, { kind: type === 'form' ? 'form definition' : 'form submission' });
         // The fixture retains submission payloads just as the generic Trash owner does. Definitions
         // keep their existing separate fixture projection; the core has no definition-delete method.
         if (type === 'form_submission')
@@ -42,14 +59,8 @@ export function createMemoryFormsApi(_required = {}, { forms = [], submissions =
         },
         async updateFormDefinition({ id }, patch = {}) {
             const current = definitions.find(form => form.id === id) ?? missing(id);
-            const incomingIds = patch.fields ? new Set(patch.fields.map(field => field.id)) : null;
-            if (incomingIds && current.fields.some(field => !incomingIds.has(field.id))) {
-                throw new AdminApiError({ message: 'existing form fields cannot be removed', status: 400 }, { code: 'FORMS_FIELD_VALIDATION_ERROR' });
-            }
-            // The contract excludes slug; runtime callers cannot smuggle it through a cast either.
-            const { name, fields, notify, status, mode, html } = patch;
-            const applied = { ...(name !== undefined ? { name } : {}), ...(fields !== undefined ? { fields } : {}), ...(notify !== undefined ? { notify } : {}), ...(status !== undefined ? { status } : {}), ...(mode !== undefined ? { mode } : {}), ...(html !== undefined ? { html } : {}) };
-            const updated = { ...current, ...structuredClone(applied), updatedAt: now() };
+            assertNoFieldRemoved({ current, patch });
+            const updated = { ...current, ...structuredClone(suppliedPatch(patch)), updatedAt: now() };
             definitions[definitions.indexOf(current)] = updated;
             return structuredClone(updated);
         },

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

@@ -3,15 +3,17 @@ export interface FormsConformanceResult {
     readonly passed: number;
     readonly failures: readonly string[];
 }
+type SubmissionSeed = {
+    formId: string;
+    submissionId: string;
+};
 /** Run on an isolated API: creates definitions and trashes seeded submissions.
  * The host provides a disposable seed so conformance never touches an operator's live data. */
 export declare function runFormsApiConformance({ api }: {
     api: AdminFormsPort;
 }, { slug, submission }?: {
     slug?: string;
-    submission?: {
-        formId: string;
-        submissionId: string;
-    };
+    submission?: SubmissionSeed;
 }): Promise<FormsConformanceResult>;
+export {};
 //# sourceMappingURL=forms-api.conformance.d.ts.map