@jini-ai/core 0.4.1 → 0.4.3

package/dist/settings/ensure-definitions.d.ts

@@ -0,0 +1,101 @@
+import type { Clock, IdGenerator, JsonValue, UUID } from "../primitives/index.js";
+import type { SettingsPrincipalLookupPort } from "./principal-lookup.js";
+import type { SettingsRepoPort } from "./ports.js";
+import { type SettingValueSchema } from "./types.js";
+/**
+ * @file The one boot-time "register these definitions if they aren't already,
+ * and keep their defaults honest if they are" loop, shared by every registrar
+ * that backs a settings-dialog tab.
+ *
+ * This exists because the loop is genuinely identical everywhere it appears —
+ * the first host to use this library had one hand-written copy per tab before
+ * this helper existed, and each additional tab would have added another. A
+ * host's per-tab modules keep what actually differs (the namespace, the key
+ * list, each key's schema and default) and hand it to
+ * `ensureSettingDefinitions` as data.
+ *
+ * Site-owned groups also share registration, but keep their bespoke get/set
+ * services, validation and domain permissions. Unlike code-owned core defaults,
+ * an existing site definition is never reconciled: its stored default belongs
+ * to the site. The explicit site target preserves that ownership difference.
+ */
+/** One key's registration data — everything `registerDefinitions` needs that
+ *  varies per key. */
+export interface SettingDefinitionSpec<Key extends string = string> {
+    key: Key;
+    schema: SettingValueSchema;
+    /**
+     * Every non-secret definition needs a NON-NULL default.
+     * `validateDefinitionInput` (`settings.ts`) rejects a null `default_json` for
+     * every non-secret definition, full stop — there is no nullable-schema
+     * carve-out in the actual check, regardless of what a nullable schema might
+     * suggest. A field that is nullable in spirit needs a sentinel instead (a
+     * distinguished non-null value the host's own code treats as "unset"). See
+     * `docs/decisions/settings-json-schema-variant.md` for why this diverges
+     * from this ledger's own originating design notes.
+     *
+     * Typed `Exclude<…, null>` rather than a bare primitive union: `DefinitionInput`
+     * already accepts any `JsonValue`, and a `{ type: "json" }` definition needs an
+     * array/object default. Excluding `null` at the type level keeps the non-null
+     * rule above a compile error rather than a boot-time throw.
+     */
+    defaultValue: Exclude<JsonValue, null>;
+    /**
+     * Bitmask over `SCOPE_BIT`. Defaults to `workspace`, which is what most
+     * settings-dialog tabs want: one operator's choice shouldn't silently
+     * become every workspace's. Pass `SCOPE_BIT.user` (or a mask including it)
+     * for a genuinely per-operator preference.
+     */
+    scopes?: number;
+}
+export interface EnsureSettingDefinitionsDeps {
+    settingsRepo: SettingsRepoPort;
+    clock: Clock;
+    ids: IdGenerator;
+    principals: SettingsPrincipalLookupPort;
+}
+interface SettingDefinitionsInput {
+    namespace: string;
+    definitions: readonly SettingDefinitionSpec[];
+    /** The trusted boot-time actor these writes are attributed to (mirrors a
+     *  host's other boot-time registrars' identical convention). */
+    systemPrincipalId: UUID;
+}
+/** Core definitions are platform-wide; site definitions require a workspace.
+ * Omitting the target retains the existing core-default reconciliation policy. */
+export type EnsureSettingDefinitionsInput = SettingDefinitionsInput & ({
+    ownerKind?: "core";
+    workspaceId?: never;
+} | {
+    ownerKind: "site";
+    workspaceId: UUID;
+});
+/**
+ * Idempotently registers every definition in `input.definitions` under
+ * `input.namespace`, and reconciles the stored default of any that already
+ * exist to the default source declares. Safe to call on every boot.
+ *
+ * The reconcile half matters as much as the register half: registration is
+ * once-only, so without it a `defaultValue` edited in source never reaches an
+ * install that has booted before. Code owns `core` defaults; the stored row
+ * does not get to outvote it.
+ *
+ * By default definitions are `ownerKind: "core"` — a settings-dialog
+ * tab configures a platform-level capability, not per-site content. Per the
+ * namespace-fence CHECK, `owner_kind='core'` requires `workspaceId: null` at
+ * the DEFINITION level regardless of which workspace is booting, while the
+ * `scopes` bitmask still lets each workspace (or user) hold its own VALUE row.
+ *
+ * Site targets instead use their workspace for lookup, registration and the
+ * authorization context, and skip every existing row without changing defaults.
+ * Writes are sequential so boot never overlaps transactions on one connection.
+ * Errors from the ledger propagate to the caller's readiness promise.
+ *
+ * @example ensureSettingDefinitions(deps, { namespace: "site.seo", definitions,
+ *   systemPrincipalId, ownerKind: "site", workspaceId });
+ * @complexity O(n) time, O(1) auxiliary space for n definitions — each is one
+ * lookup plus at most one registration or default reconciliation.
+ */
+export declare function ensureSettingDefinitions(deps: EnsureSettingDefinitionsDeps, input: EnsureSettingDefinitionsInput): Promise<void>;
+export {};
+//# sourceMappingURL=ensure-definitions.d.ts.map

package/dist/settings/ensure-definitions.js

@@ -0,0 +1,101 @@
+import { resolveDefinitionRaw } from "./settings.js";
+import { SCOPE_BIT } from "./types.js";
+import { reconcileDefinitionDefault, registerDefinitions } from "./write-service.js";
+/** Boot-time infra work is trusted by construction — mirrors every other
+ *  `ensure*SettingDefinitions`'s identical shim. */
+const alwaysAllowBoot = async () => ({ allowed: true, reason: "system_boot" });
+/**
+ * Idempotently registers every definition in `input.definitions` under
+ * `input.namespace`, and reconciles the stored default of any that already
+ * exist to the default source declares. Safe to call on every boot.
+ *
+ * The reconcile half matters as much as the register half: registration is
+ * once-only, so without it a `defaultValue` edited in source never reaches an
+ * install that has booted before. Code owns `core` defaults; the stored row
+ * does not get to outvote it.
+ *
+ * By default definitions are `ownerKind: "core"` — a settings-dialog
+ * tab configures a platform-level capability, not per-site content. Per the
+ * namespace-fence CHECK, `owner_kind='core'` requires `workspaceId: null` at
+ * the DEFINITION level regardless of which workspace is booting, while the
+ * `scopes` bitmask still lets each workspace (or user) hold its own VALUE row.
+ *
+ * Site targets instead use their workspace for lookup, registration and the
+ * authorization context, and skip every existing row without changing defaults.
+ * Writes are sequential so boot never overlaps transactions on one connection.
+ * Errors from the ledger propagate to the caller's readiness promise.
+ *
+ * @example ensureSettingDefinitions(deps, { namespace: "site.seo", definitions,
+ *   systemPrincipalId, ownerKind: "site", workspaceId });
+ * @complexity O(n) time, O(1) auxiliary space for n definitions — each is one
+ * lookup plus at most one registration or default reconciliation.
+ */
+export async function ensureSettingDefinitions(deps, input) {
+    const ownerKind = input.ownerKind ?? "core";
+    const workspaceId = input.ownerKind === "site" ? input.workspaceId : null;
+    const authWorkspaceId = workspaceId ?? input.systemPrincipalId;
+    const writeDeps = {
+        repo: deps.settingsRepo,
+        clock: deps.clock,
+        ids: deps.ids,
+        authorize: alwaysAllowBoot,
+        principals: deps.principals,
+    };
+    for (const def of input.definitions) {
+        const existing = await resolveDefinitionRaw({ repo: deps.settingsRepo }, { namespace: input.namespace, key: def.key, workspaceId });
+        if (existing) {
+            // Core registration is once-only, but the DEFAULT is not. Without this, a
+            // `defaultValue` changed in source is unreachable in any install that
+            // has already booted — the stored `default_json` from first boot keeps
+            // winning, for every settings-dialog tab. See `reconcileDefinitionDefault`
+            // for the bug this closes.
+            //
+            // Three slots are deliberately left alone rather than reconciled:
+            // a non-`active` row (deprecated/tombstoned) is not ours to rewrite; a
+            // non-`core` row is operator-owned; and a row whose identity differs
+            // from the slot we asked for means `resolveDefinitionRaw` followed an
+            // alias, so rewriting it would silently change a DIFFERENT definition's
+            // default. `reconcileDefinitionDefault` would throw on the first two —
+            // this skips them quietly because boot must not fail on them.
+            const isSameSlot = existing.namespace === input.namespace && existing.key === def.key;
+            if (ownerKind === "core" && existing.status === "active" && existing.ownerKind === "core" && isSameSlot) {
+                await reconcileDefinitionDefault({
+                    deps: writeDeps,
+                    input: {
+                        namespace: input.namespace,
+                        key: def.key,
+                        workspaceId: null,
+                        defaultValue: def.defaultValue,
+                        callerPrincipalId: input.systemPrincipalId,
+                        authWorkspaceId,
+                    },
+                });
+            }
+            continue;
+        }
+        await registerDefinitions({
+            deps: writeDeps,
+            input: {
+                callerPrincipalId: input.systemPrincipalId,
+                // Platform (core) definitions aren't scoped to any one workspace, but
+                // `registerDefinitions`'s authorization check still needs a workspace
+                // context to authorize against — the seeded workspace mirrors every
+                // other boot-time registrar's identical `authWorkspaceId` shape.
+                authWorkspaceId,
+                definitions: [
+                    {
+                        namespace: input.namespace,
+                        key: def.key,
+                        ownerKind,
+                        workspaceId,
+                        schema: def.schema,
+                        defaultValue: def.defaultValue,
+                        scopes: def.scopes ?? SCOPE_BIT.workspace,
+                        secret: false,
+                    },
+                ],
+            },
+        });
+    }
+}
+//# sourceMappingURL=ensure-definitions.js.map

package/dist/settings/errors.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @file Typed domain errors for `settings`.
+ *
+ * Purpose:
+ * One class per error this module originates, mirroring the
+ * `PresentationSettingsNotFoundError`/`PresentationSettingsValidationError`
+ * convention a host's own presentation-settings module may use. Route
+ * handlers map these 1:1 to HTTP codes.
+ */
+export declare class DefinitionInvalidError extends Error {
+}
+export declare class ScopeNotAllowedError extends Error {
+}
+export declare class SecretNotSupportedError extends Error {
+    constructor({ message }: {
+        message: string;
+    }, optional?: ErrorOptions);
+}
+export declare class ValueValidationFailedError extends Error {
+}
+export declare class RenameRetypeConflictError extends Error {
+}
+export declare class AliasDepthExceededError extends Error {
+}
+export declare class DefinitionTombstonedError extends Error {
+}
+export declare class DefinitionNotFoundError extends Error {
+}
+export declare class PurgeRequiredError extends Error {
+    constructor({ message }: {
+        message: string;
+    }, optional?: ErrorOptions);
+}
+export declare class ForbiddenError extends Error {
+}
+/** : the target `principalId` does not resolve to an active principal in the request's workspace. See docs/decisions/DR-003-settings-ledger-invariants.md. */
+export declare class PrincipalNotFoundError extends Error {
+    readonly principalId: string;
+    readonly workspaceId: string;
+    constructor(message: string, principalId: string, workspaceId: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/settings/errors.js

@@ -0,0 +1,46 @@
+/**
+ * @file Typed domain errors for `settings`.
+ *
+ * Purpose:
+ * One class per error this module originates, mirroring the
+ * `PresentationSettingsNotFoundError`/`PresentationSettingsValidationError`
+ * convention a host's own presentation-settings module may use. Route
+ * handlers map these 1:1 to HTTP codes.
+ */
+export class DefinitionInvalidError extends Error {
+}
+export class ScopeNotAllowedError extends Error {
+}
+export class SecretNotSupportedError extends Error {
+    constructor({ message }, optional = {}) {
+        super(message, optional);
+    }
+}
+export class ValueValidationFailedError extends Error {
+}
+export class RenameRetypeConflictError extends Error {
+}
+export class AliasDepthExceededError extends Error {
+}
+export class DefinitionTombstonedError extends Error {
+}
+export class DefinitionNotFoundError extends Error {
+}
+export class PurgeRequiredError extends Error {
+    constructor({ message }, optional = {}) {
+        super(message, optional);
+    }
+}
+export class ForbiddenError extends Error {
+}
+/** : the target `principalId` does not resolve to an active principal in the request's workspace. See docs/decisions/DR-003-settings-ledger-invariants.md. */
+export class PrincipalNotFoundError extends Error {
+    principalId;
+    workspaceId;
+    constructor(message, principalId, workspaceId) {
+        super(message);
+        this.principalId = principalId;
+        this.workspaceId = workspaceId;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/settings/express/cms-adapter.d.ts

@@ -0,0 +1,20 @@
+import { type SettingsWriteServiceDeps, type SettingsRepoPort } from "../index.js";
+import type { SettingsService, SettingsPermissions, SettingsChangeFeed } from "./contracts.js";
+/** Keep the CMS write chokepoint while translating its permission vocabulary to host policy. */
+/** Bind the CMS ledger and write chokepoint without copying their domain logic.
+ * Effective reads scan definitions and resolve each namespace key; mutations inherit CMS transactions/errors.
+ * @complexity O(1) setup. Per operation: O(definitions + keys) reads, or O(batch size) writes.
+ * @example createCmsSettingsService({ deps: cmsPorts, permissions });
+ */
+export declare function createCmsSettingsService(required: {
+    deps: SettingsWriteServiceDeps;
+    permissions: SettingsPermissions;
+}): SettingsService;
+/** Adapt the ledger through CMS tenant/principal disclosure rules, returning names and cursors only.
+ * @complexity O(1) setup; collect is O(page size), with namespace lookup per visible revision.
+ * @example createCmsSettingsChangeFeed({ repo });
+ */
+export declare function createCmsSettingsChangeFeed(required: {
+    repo: SettingsRepoPort;
+}): SettingsChangeFeed;
+//# sourceMappingURL=cms-adapter.d.ts.map

package/dist/settings/express/cms-adapter.js

@@ -0,0 +1,124 @@
+import { getEffective, resolveDefinition, set, clear, resetNamespace, registerDefinitions, NON_REGISTER_DEFINITION_OPS, parseNonRegisterDefinitionOp, collectChangedNamespaces, } from "../index.js";
+/** Keep the CMS write chokepoint while translating its permission vocabulary to host policy. */
+/** Bind the CMS ledger and write chokepoint without copying their domain logic.
+ * Effective reads scan definitions and resolve each namespace key; mutations inherit CMS transactions/errors.
+ * @complexity O(1) setup. Per operation: O(definitions + keys) reads, or O(batch size) writes.
+ * @example createCmsSettingsService({ deps: cmsPorts, permissions });
+ */
+export function createCmsSettingsService(required) {
+    const { deps: original, permissions } = required;
+    const permissionMap = new Map([
+        ["settings.definitions.manage", permissions.manageDefinitions],
+        ["settings.global.write", permissions.writeGlobal],
+        ["settings.workspace.write", permissions.writeWorkspace],
+        ["settings.user.self.write", permissions.writeUserSelf],
+        ["settings.user.write", permissions.writeUserOther],
+        ["settings.reset.global", permissions.reset.global],
+        ["settings.reset.workspace", permissions.reset.workspace],
+        ["settings.reset.user", permissions.reset.user],
+    ]);
+    const deps = { ...original,
+        authorize: (input) => {
+            const permission = permissionMap.get(input.permission);
+            if (permission === undefined)
+                return Promise.resolve({ allowed: false, reason: "unknown_settings_permission" });
+            return original.authorize({ ...input, permission });
+        },
+    };
+    const repo = deps.repo;
+    const listDefinitions = async ({ workspaceId }) => {
+        const [platform, workspace] = await Promise.all([
+            repo.listActiveDefinitions({ workspaceId: null }), repo.listActiveDefinitions({ workspaceId }),
+        ]);
+        return [...platform, ...workspace];
+    };
+    return {
+        listDefinitions,
+        effective: async ({ namespace, workspaceId, principalId }) => {
+            const defs = await listDefinitions({ workspaceId });
+            const keys = new Set(defs.filter((d) => d.namespace === namespace).map((d) => d.key));
+            const data = [];
+            for (const key of keys) {
+                const result = await getEffective({ repo }, { namespace, key, scopeContext: { workspaceId, principalId } });
+                if (result)
+                    data.push({ key, value: result.value, sourceLayer: result.sourceLayer, defVersion: result.defVersion });
+            }
+            return data;
+        },
+        raw: async ({ namespace, key, workspaceId, principalId }) => {
+            const definition = await resolveDefinition({ repo }, { namespace, key, workspaceId });
+            if (!definition)
+                return null;
+            const settingId = definition.settingId;
+            const records = await Promise.all([
+                repo.getGlobalValue(settingId), repo.getWorkspaceValue({ workspaceId, settingId }),
+                principalId ? repo.getUserValue({ workspaceId, principalId, settingId }) : Promise.resolve(null),
+            ]);
+            const values = records.map((r) => r?.state === "set" ? r.valueJson : null);
+            return { key: `${namespace}.${key}`, global: values[0], workspace: values[1], user: values[2], default: definition.defaultValue };
+        },
+        set: (input) => set({ deps, input }),
+        clear: (input) => clear({ deps, input }),
+        reset: async (input) => {
+            const definitions = await repo.listActiveDefinitions({ workspaceId: input.scope === "global" ? null : (input.workspaceId ?? input.authWorkspaceId ?? null) });
+            const keys = definitions.filter((d) => d.namespace === input.namespace).map((d) => d.key);
+            return resetNamespace({ deps, input }, keys);
+        },
+        definitions: ({ items, callerPrincipalId, authWorkspaceId }) => applyDefinitions({ deps, items, callerPrincipalId, authWorkspaceId }),
+    };
+}
+/** Preserve register batching and ordered non-register writes over existing CMS operation contracts.
+ * Unknown operations return their name. Earlier non-register writes are not rolled back by later failures.
+ * @complexity O(item count) time/space plus CMS effects; this batch is not atomic.
+ */
+async function applyDefinitions(required) {
+    const { deps, items, callerPrincipalId, authWorkspaceId } = required;
+    const toRegister = [];
+    const applied = [];
+    for (const raw of items) {
+        const item = raw;
+        const op = String(item.op ?? "register");
+        const namespace = String(item.namespace ?? "");
+        const key = String(item.key ?? "");
+        const ownerKind = item.ownerKind;
+        const workspaceId = ownerKind === "site" ? authWorkspaceId : null;
+        const defaultValue = (item.defaultJson ?? null);
+        if (op === "register") {
+            toRegister.push({ namespace, key, ownerKind, workspaceId, schema: item.schemaJson,
+                defaultValue, scopes: Number(item.scopes), secret: Boolean(item.secret ?? false) });
+        }
+        else {
+            const parsedOp = parseNonRegisterDefinitionOp({ op });
+            if (!parsedOp)
+                return { unknownOp: op };
+            const opItem = { namespace, key, ownerKind, workspaceId, defaultJson: defaultValue,
+                ...(item.newNamespace === undefined ? {} : { newNamespace: item.newNamespace }),
+                ...(item.newKey === undefined ? {} : { newKey: item.newKey }),
+                ...(item.schemaJson === undefined ? {} : { schemaJson: item.schemaJson }),
+                ...(item.coercionJson === undefined ? {} : { coercionJson: item.coercionJson }),
+            };
+            await NON_REGISTER_DEFINITION_OPS[parsedOp]({ ctx: { deps, callerPrincipalId, authWorkspaceId }, item: opItem });
+        }
+        applied.push({ key: `${namespace}.${key}`, op, status: "applied" });
+    }
+    if (toRegister.length)
+        await registerDefinitions({ deps, input: { definitions: toRegister, callerPrincipalId, authWorkspaceId } });
+    return { applied };
+}
+/** Adapt the ledger through CMS tenant/principal disclosure rules, returning names and cursors only.
+ * @complexity O(1) setup; collect is O(page size), with namespace lookup per visible revision.
+ * @example createCmsSettingsChangeFeed({ repo });
+ */
+export function createCmsSettingsChangeFeed(required) {
+    const { repo } = required;
+    return {
+        head: () => repo.maxRevisionSeq(),
+        collect: async ({ sinceSeq, limit, viewer }) => {
+            const revisions = await repo.listRevisionsSince({ sinceSeq, limit, workspaceId: viewer.workspaceId });
+            // Resolve afresh each batch: a rename must never leave a stale namespace cached forever.
+            const batch = await collectChangedNamespaces({ revisions, viewer, resolveNamespace: async ({ settingId }) => (await repo.findDefinitionBySettingId({ settingId }))?.namespace ?? null });
+            return { ...batch, examinedCount: revisions.length };
+        },
+    };
+}
+//# sourceMappingURL=cms-adapter.js.map

package/dist/settings/express/contracts.d.ts

@@ -0,0 +1,135 @@
+import type { Request, Response, Express } from "express";
+import type { SettingScope, SettingDefinitionRecord, SetValueRequired, ClearValueRequired, ResetNamespaceRequired, ChangeFeedViewer, ChangeFeedBatch } from "../index.js";
+export type Authorize = (required: {
+    principalId: string;
+    workspaceId: string;
+    permission: string;
+    entityType: string;
+}) => Promise<{
+    allowed: boolean;
+    reason: string;
+}>;
+export type PrincipalResolver = (required: {
+    request: Request;
+    response: Response;
+}) => Promise<{
+    id: string;
+} | null> | {
+    id: string;
+} | null;
+export interface Scheduler {
+    /** Return an idempotent cancellation callback. */
+    every(required: {
+        intervalMs: number;
+        callback: () => void;
+    }): () => void;
+}
+export interface SettingsPermissions {
+    read: string;
+    readRaw: string;
+    readDefinitions: string;
+    readOtherUser: string;
+    manageDefinitions: string;
+    writeGlobal: string;
+    writeWorkspace: string;
+    writeUserSelf: string;
+    writeUserOther: string;
+    reset: Record<SettingScope, string>;
+}
+export interface SettingsRoutes {
+    definitions: string;
+    effective: string;
+    raw: string;
+    value: string;
+    reset: string;
+    events: string;
+    workspaceParam: string;
+}
+export type EffectiveSettingRow = {
+    key: string;
+    value: unknown;
+    sourceLayer: string;
+    defVersion: number;
+};
+export type RawSetting = {
+    key: string;
+    global: unknown;
+    workspace: unknown;
+    user: unknown;
+    default: unknown;
+};
+export type DefinitionResult = {
+    applied: Array<{
+        key: string;
+        op: string;
+        status: string;
+    }>;
+} | {
+    unknownOp: string;
+};
+export interface SettingsService {
+    listDefinitions(required: {
+        workspaceId: string;
+    }): Promise<SettingDefinitionRecord[]>;
+    effective(required: {
+        namespace: string;
+        workspaceId: string;
+        principalId: string | undefined;
+    }): Promise<EffectiveSettingRow[]>;
+    raw(required: {
+        namespace: string;
+        key: string;
+        workspaceId: string;
+        principalId: string | undefined;
+    }): Promise<RawSetting | null>;
+    set(required: SetValueRequired["input"]): Promise<{
+        value: unknown;
+        revisionSeq: number;
+    }>;
+    clear(required: ClearValueRequired["input"]): Promise<{
+        revisionSeq: number;
+    }>;
+    reset(required: ResetNamespaceRequired["input"]): Promise<{
+        clearedCount: number;
+        revisionSeqs: number[];
+    }>;
+    definitions(required: {
+        items: readonly unknown[];
+        callerPrincipalId: string;
+        authWorkspaceId: string;
+    }): Promise<DefinitionResult>;
+}
+export interface SettingsChangeFeed {
+    head(required: Record<string, never>): Promise<number>;
+    /** Cursor advances across invisible rows. The emitted id MUST use batch.cursor, never head. */
+    collect(required: {
+        sinceSeq: number;
+        limit: number;
+        viewer: ChangeFeedViewer;
+    }): Promise<ChangeFeedBatch & {
+        examinedCount: number;
+    }>;
+}
+export interface SettingsHttpRequired {
+    app: Pick<Express, "get" | "post" | "put" | "delete">;
+    workspaceId: string;
+    ready: Promise<void>;
+    service: SettingsService;
+    changeFeed: SettingsChangeFeed;
+    principalResolver: PrincipalResolver;
+    authorize: Authorize;
+    scheduler: Scheduler;
+    routes: SettingsRoutes;
+    permissions: SettingsPermissions;
+}
+export interface SettingsHttpOptions {
+    pollIntervalMs?: number;
+    keepaliveIntervalMs?: number;
+    reauthorizeIntervalMs?: number;
+    revisionPageSize?: number;
+    onError?: (required: {
+        operation: string;
+        error: unknown;
+    }) => void;
+}
+//# sourceMappingURL=contracts.d.ts.map

package/dist/settings/express/contracts.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=contracts.js.map

package/dist/settings/express/http.d.ts

@@ -0,0 +1,10 @@
+import type { SettingsHttpRequired, SettingsHttpOptions } from "./contracts.js";
+/** Mount all eight endpoints. The returned disposer closes active feeds and cancels their schedules. */
+/** Injected policy and services preserve the settings HTTP response envelopes.
+ * O(1) mounting; read/mutation work is delegated. Feed resources are bounded per connection.
+ * @example registerSettingsRoutes({ app, workspaceId, ready, service, changeFeed, principalResolver, authorize, scheduler, routes, permissions });
+ */
+export declare function registerSettingsRoutes(required: SettingsHttpRequired, optional?: SettingsHttpOptions): {
+    dispose(): void;
+};
+//# sourceMappingURL=http.d.ts.map