@deepseek-ai/dsh-settings 0.1.1-rc.2 → 0.1.2-alpha.2

package/lib/invariant.js

@@ -1,149 +1,4 @@
-import { Service } from "@deepseek-ai/cordis";
-//#region lib/types/redact.js
-/**
-* Structural secret redaction for settings values. `role('secret')` fields are
-* removed from a value before it crosses a wire boundary; a sidecar records
-* each schema-declared secret position and whether it currently holds a value,
-* so a configuration surface can render a write-only input without ever
-* receiving the secret itself.
-* @module @deepseek-ai/dsh-settings/redact
-*/
-/** Whether a value is a plain data object the walker may recurse into. */
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function walk(node, value, path, secrets) {
-	if (node === void 0) return value;
-	if (node.meta?.role === "secret") {
-		secrets.push({
-			path,
-			set: value !== void 0
-		});
-		return;
-	}
-	switch (node.type) {
-		case "object": {
-			const properties = node.dict ?? {};
-			const source = isRecord(value) ? value : void 0;
-			const rebuilt = {};
-			if (source !== void 0) for (const [key, entry] of Object.entries(source)) {
-				if (key in properties) continue;
-				rebuilt[key] = entry;
-			}
-			for (const [key, child] of Object.entries(properties)) {
-				const stripped = walk(child, source?.[key], [...path, key], secrets);
-				if (stripped !== void 0) rebuilt[key] = stripped;
-			}
-			return source === void 0 && Object.keys(rebuilt).length === 0 ? value : rebuilt;
-		}
-		case "dict": {
-			if (!isRecord(value)) return value;
-			const rebuilt = {};
-			for (const [key, entry] of Object.entries(value)) {
-				const stripped = walk(node.inner, entry, [...path, key], secrets);
-				if (stripped !== void 0) rebuilt[key] = stripped;
-			}
-			return rebuilt;
-		}
-		case "array":
-			if (!Array.isArray(value)) return value;
-			return value.map((entry, index) => walk(node.inner, entry, [...path, String(index)], secrets));
-		default: return value;
-	}
-}
-//#endregion
-//#region lib/types/index.js
-/**
-* Service Definition for the user-settings capability seam (`ctx.settings`). Providers store one raw document of
-* per-namespace sections; plugins register a namespace schema and read the
-* resolved value, which layers schema defaults, the registrant's composition
-* `base`, and the user document section, in that order.
-* @module @deepseek-ai/dsh-settings
-*/
-/**
-* Deep equality over JSON-compatible data (objects, arrays, primitives) — the
-* Service Definition's single change-detection predicate, exported so the invariant
-* companion checks exactly the implementation's relation.
-* @param a - one JSON-compatible value.
-* @param b - the other JSON-compatible value.
-* @returns whether the two values are structurally equal.
-*/
-function deepEqualJson(a, b) {
-	if (a === b) return true;
-	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
-	if (Array.isArray(a) || Array.isArray(b)) {
-		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
-		return a.every((entry, index) => deepEqualJson(entry, b[index]));
-	}
-	const left = a;
-	const right = b;
-	const keys = Object.keys(left);
-	if (keys.length !== Object.keys(right).length) return false;
-	return keys.every((key) => key in right && deepEqualJson(left[key], right[key]));
-}
-/** Whether a value is a plain data object (not an array, null, or class instance). */
-function isPlainObject(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const proto = Object.getPrototypeOf(value);
-	return proto === Object.prototype || proto === null;
-}
-/** Apply one path op to a detached section, returning the next section. */
-function applyPathOp(section, op) {
-	const [head, ...rest] = op.path;
-	if (head === void 0) {
-		if (op.op === "unset") return {};
-		if (!isPlainObject(op.value)) throw new TypeError("settings mutate: setting the section root requires a plain object");
-		return { ...op.value };
-	}
-	if (rest.length === 0) {
-		if (op.op === "set") return {
-			...section,
-			[head]: op.value
-		};
-		const { [head]: _removed, ...kept } = section;
-		return kept;
-	}
-	const child = section[head];
-	if (!isPlainObject(child)) {
-		if (op.op === "unset") return section;
-		return {
-			...section,
-			[head]: applyPathOp({}, {
-				...op,
-				path: rest
-			})
-		};
-	}
-	return {
-		...section,
-		[head]: applyPathOp(child, {
-			...op,
-			path: rest
-		})
-	};
-}
-/**
-* Layer `over` onto `under`: plain objects merge recursively, every other
-* value (arrays included) replaces the lower layer wholesale. `over` never
-* carries `undefined` entries — sections come from parsed documents and write
-* snapshots pass {@link cloneJsonShaped}, which strips them so a sparse patch
-* cannot erase lower keys.
-*/
-function mergeLayers(under, over) {
-	if (over === void 0) return under;
-	if (!isPlainObject(under) || !isPlainObject(over)) return over;
-	const merged = { ...under };
-	for (const [key, value] of Object.entries(over)) merged[key] = key in merged ? mergeLayers(merged[key], value) : value;
-	return merged;
-}
-/** Recursively freeze one resolved value so handed-out snapshots stay immutable. */
-function deepFreeze(value) {
-	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
-	for (const entry of Object.values(value)) deepFreeze(entry);
-	return Object.freeze(value);
-}
-Service.init;
-//#endregion
+import { deepEqualJson } from "@deepseek-ai/dsh-util-values";
 //#region lib/types/invariant.js
 /**
 * Package-owned invariant companion for `@deepseek-ai/dsh-settings`.

package/lib/types/index.d.ts

@@ -12,12 +12,11 @@ import type { SettingsNamespace, SettingsUpdateSource } from './types.ts';
 export { redactSecrets } from './redact.ts';
 export type { RedactedSecret, RedactedValue } from './redact.ts';
 export type { SettingsNamespace, SettingsUpdateSource } from './types.ts';
-/**
- * Brand a raw string as a {@link SettingsNamespace}.
- * @param value - candidate namespace; lowercase kebab-case, as in plugin short names.
- * @returns the branded namespace.
- */
-export declare function settingsNamespace(value: string): SettingsNamespace;
+type LowercaseLetter = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type DecimalDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type NamespaceCharacter = LowercaseLetter | DecimalDigit | '-';
+type ValidNamespaceTail<Value extends string> = Value extends '' ? true : Value extends `${NamespaceCharacter}${infer Rest}` ? ValidNamespaceTail<Rest> : false;
+type SettingsNamespaceInput<Value extends string> = Value extends SettingsNamespace ? Value : string extends Value ? string : Value extends `${LowercaseLetter}${infer Rest}` ? ValidNamespaceTail<Rest> extends true ? Value : never : never;
 /** When a namespace's changes take effect for its owner. */
 export type SettingsApplies = 'live' | 'restart';
 /** Registration options beyond the namespace schema. */
@@ -114,15 +113,6 @@ declare module '@deepseek-ai/cordis' {
         settings: SettingsProvider;
     }
 }
-/**
- * Deep equality over JSON-compatible data (objects, arrays, primitives) — the
- * Service Definition's single change-detection predicate, exported so the invariant
- * companion checks exactly the implementation's relation.
- * @param a - one JSON-compatible value.
- * @param b - the other JSON-compatible value.
- * @returns whether the two values are structurally equal.
- */
-export declare function deepEqualJson(a: unknown, b: unknown): boolean;
 /**
  * A write refused because the namespace moved since the caller read it. The
  * Service Definition's serialized write queue orders writes; it cannot tell a fresh writer
@@ -221,8 +211,21 @@ export declare abstract class SettingsProvider extends Service {
      * @param schema - schemastery schema resolving this namespace's value.
      * @param options - composition `base` layer and effect timing.
      * @returns the owner scope for reads, observation, and updates.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
      */
-    register<T>(ns: SettingsNamespace, schema: z<T>, options?: SettingsRegisterOptions<T>): SettingsScope<T>;
+    register<const Namespace extends string, T>(ns: Namespace & SettingsNamespaceInput<Namespace>, schema: z<T>, options?: SettingsRegisterOptions<T>): SettingsScope<T>;
+    /**
+     * Attach one optional-settings consumer to this provider. The consumer
+     * registers its composition entry as the base layer while this provider is
+     * present, then falls back to that entry if the provider detaches.
+     * @param owner - consumer context whose unload suppresses fallback work.
+     * @param ns - consumer-owned settings namespace.
+     * @param schema - schema resolving the namespace.
+     * @param entry - composition entry used as the base and fallback value.
+     * @param hooks - source sink, change notification, and optional validation.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
+     */
+    installSection<const Namespace extends string, T>(owner: Context, ns: Namespace & SettingsNamespaceInput<Namespace>, schema: z<T>, entry: T, hooks: SettingsSectionHooks<T>): void;
     /**
      * Describe every registered namespace for configuration surfaces, including
      * the composition `base` and raw user layers so a form can mark which fields
@@ -235,8 +238,9 @@ export declare abstract class SettingsProvider extends Service {
      * Read one registered namespace's resolved value.
      * @param ns - the namespace to read.
      * @returns the resolved value, or `undefined` while unregistered.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
      */
-    get(ns: SettingsNamespace): unknown;
+    get<const Namespace extends string>(ns: Namespace & SettingsNamespaceInput<Namespace>): unknown;
     /**
      * Merge a patch into one registered namespace's user layer, validate the
      * resolved candidate, persist through the provider, then commit and emit.
@@ -247,8 +251,9 @@ export declare abstract class SettingsProvider extends Service {
      * @param patch - plain-object patch over the user section.
      * @param expectedRevision - the descriptor `revision` the caller read; a
      *   namespace that moved past it rejects with {@link SettingsConflictError}.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
      */
-    update(ns: SettingsNamespace, patch: object, expectedRevision?: number): Promise<void>;
+    update<const Namespace extends string>(ns: Namespace & SettingsNamespaceInput<Namespace>, patch: object, expectedRevision?: number): Promise<void>;
     /**
      * Replace one registered namespace's user section wholesale, validate,
      * persist, then commit and emit. Keys absent from `section` fall back to the
@@ -258,8 +263,9 @@ export declare abstract class SettingsProvider extends Service {
      * @param section - the complete next user section.
      * @param expectedRevision - the descriptor `revision` the caller read; a
      *   namespace that moved past it rejects with {@link SettingsConflictError}.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
      */
-    replace(ns: SettingsNamespace, section: object, expectedRevision?: number): Promise<void>;
+    replace<const Namespace extends string>(ns: Namespace & SettingsNamespaceInput<Namespace>, section: object, expectedRevision?: number): Promise<void>;
     /**
      * Apply path-addressed edits to one registered namespace's user section,
      * validate, persist, then commit and emit. The ops are applied to the
@@ -271,8 +277,9 @@ export declare abstract class SettingsProvider extends Service {
      * @param ops - ordered path edits; later ops observe earlier ones.
      * @param expectedRevision - the descriptor `revision` the caller read; a
      *   namespace that moved past it rejects with {@link SettingsConflictError}.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
      */
-    mutate(ns: SettingsNamespace, ops: readonly SettingsPathOp[], expectedRevision?: number): Promise<void>;
+    mutate<const Namespace extends string>(ns: Namespace & SettingsNamespaceInput<Namespace>, ops: readonly SettingsPathOp[], expectedRevision?: number): Promise<void>;
     /** Validate a write, then queue it on the namespace's serialized write chain. */
     private write;
     /**
@@ -304,7 +311,7 @@ export declare abstract class SettingsProvider extends Service {
     /** Contained-listener diagnostic shared by the sync and async failure paths. */
     private warnListenerFailure;
 }
-/** Hooks a consumer hands to {@link installSettingsSection}. */
+/** Hooks a consumer hands to {@link SettingsProvider.installSection}. */
 export interface SettingsSectionHooks<T> {
     /**
      * Receive the active configuration source: the resolved settings scope
@@ -325,19 +332,5 @@ export interface SettingsSectionHooks<T> {
      */
     validate?: (value: T) => void;
 }
-/**
- * Install the canonical optional-settings consumer wiring: while a settings
- * service exists, register `ns` with the consumer's composition entry as the
- * `base` layer and point the source thunk at the resolved scope; when the
- * service goes away (disposal, provider reload), fall back to the entry so
- * the consumer keeps working exactly as composed. The registration rides the
- * scoped fiber, so no settings service ever mounted means none of this runs.
- * @param ctx - consumer plugin context owning the wiring.
- * @param ns - the consumer-owned settings namespace.
- * @param schema - schema resolving the namespace (typically the plugin Config).
- * @param entry - the consumer's composition entry config, used as `base`.
- * @param hooks - source sink and change notification.
- */
-export declare function installSettingsSection<T>(ctx: Context, ns: SettingsNamespace, schema: z<T>, entry: T, hooks: SettingsSectionHooks<T>): void;
 export default SettingsProvider;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -6,45 +6,16 @@
  * @module @deepseek-ai/dsh-settings
  */
 import { Service } from '@deepseek-ai/cordis';
+import { deepEqualJson, deepFreeze } from '@deepseek-ai/dsh-util-values';
 import { redactSecrets } from "./redact.js";
 export { redactSecrets } from "./redact.js";
 const NAMESPACE_PATTERN = /^[a-z][a-z0-9-]*$/;
-/**
- * Brand a raw string as a {@link SettingsNamespace}.
- * @param value - candidate namespace; lowercase kebab-case, as in plugin short names.
- * @returns the branded namespace.
- */
-export function settingsNamespace(value) {
+function parseSettingsNamespace(value) {
     if (!NAMESPACE_PATTERN.test(value)) {
         throw new TypeError(`settings namespace "${value}" must match ${String(NAMESPACE_PATTERN)}`);
     }
     return value;
 }
-/**
- * Deep equality over JSON-compatible data (objects, arrays, primitives) — the
- * Service Definition's single change-detection predicate, exported so the invariant
- * companion checks exactly the implementation's relation.
- * @param a - one JSON-compatible value.
- * @param b - the other JSON-compatible value.
- * @returns whether the two values are structurally equal.
- */
-export function deepEqualJson(a, b) {
-    if (a === b)
-        return true;
-    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
-        return false;
-    if (Array.isArray(a) || Array.isArray(b)) {
-        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
-            return false;
-        return a.every((entry, index) => deepEqualJson(entry, b[index]));
-    }
-    const left = a;
-    const right = b;
-    const keys = Object.keys(left);
-    if (keys.length !== Object.keys(right).length)
-        return false;
-    return keys.every(key => key in right && deepEqualJson(left[key], right[key]));
-}
 /**
  * A write refused because the namespace moved since the caller read it. The
  * Service Definition's serialized write queue orders writes; it cannot tell a fresh writer
@@ -183,14 +154,6 @@ function mergeLayers(under, over) {
     }
     return merged;
 }
-/** Recursively freeze one resolved value so handed-out snapshots stay immutable. */
-function deepFreeze(value) {
-    if (typeof value !== 'object' || value === null || Object.isFrozen(value))
-        return value;
-    for (const entry of Object.values(value))
-        deepFreeze(entry);
-    return Object.freeze(value);
-}
 /**
  * Abstract settings service. Providers implement raw-document storage
  * (`load`/`persist`) and push external changes through {@link Settings.publish};
@@ -259,29 +222,31 @@ export class SettingsProvider extends Service {
      * @param schema - schemastery schema resolving this namespace's value.
      * @param options - composition `base` layer and effect timing.
      * @returns the owner scope for reads, observation, and updates.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
      */
     register(ns, schema, options) {
-        if (this.registrations.has(ns)) {
-            throw new Error(`settings namespace "${ns}" is already registered`);
+        const parsedNs = parseSettingsNamespace(ns);
+        if (this.registrations.has(parsedNs)) {
+            throw new Error(`settings namespace "${parsedNs}" is already registered`);
         }
         const registration = {
-            ns,
+            ns: parsedNs,
             schema: schema,
             base: options?.base,
             applies: options?.applies ?? 'live',
             ...options?.validate === undefined
                 ? {}
                 : { validate: options.validate },
-            resolved: deepFreeze(this.resolve(schema, options?.base, this.section(ns), options?.validate)),
+            resolved: deepFreeze(this.resolve(schema, options?.base, this.section(parsedNs), options?.validate)),
             revision: 0,
             watchers: new Set(),
         };
         this.ctx.effect(() => {
-            this.registrations.set(ns, registration);
+            this.registrations.set(parsedNs, registration);
             // TODO(settings-registration-quiescence): Deactivate every watcher and await
             // its tail on disposal so callbacks cannot outlive the registrant fiber.
-            return () => this.registrations.delete(ns);
-        }, `settings.register(${JSON.stringify(String(ns))})`);
+            return () => this.registrations.delete(parsedNs);
+        }, `settings.register(${JSON.stringify(String(parsedNs))})`);
         return {
             get: () => registration.resolved,
             watch: (callback) => {
@@ -292,10 +257,42 @@ export class SettingsProvider extends Service {
                     registration.watchers.delete(watcher);
                 };
             },
-            update: patch => this.update(ns, patch),
-            replace: section => this.replace(ns, section),
+            update: patch => this.update(parsedNs, patch),
+            replace: section => this.replace(parsedNs, section),
         };
     }
+    /**
+     * Attach one optional-settings consumer to this provider. The consumer
+     * registers its composition entry as the base layer while this provider is
+     * present, then falls back to that entry if the provider detaches.
+     * @param owner - consumer context whose unload suppresses fallback work.
+     * @param ns - consumer-owned settings namespace.
+     * @param schema - schema resolving the namespace.
+     * @param entry - composition entry used as the base and fallback value.
+     * @param hooks - source sink, change notification, and optional validation.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
+     */
+    installSection(owner, ns, schema, entry, hooks) {
+        const scope = this.register(ns, schema, {
+            base: entry,
+            ...hooks.validate === undefined ? {} : { validate: hooks.validate },
+        });
+        hooks.setSource(() => scope.get());
+        this.ctx.effect(() => () => {
+            // Losing the provider leaves the consumer running; unloading the
+            // consumer does not, so only the former needs fallback work.
+            if (isUnloading(owner))
+                return;
+            hooks.setSource(() => entry);
+            hooks.onChange();
+        });
+        hooks.onChange();
+        scope.watch(() => {
+            if (isUnloading(owner))
+                return;
+            hooks.onChange();
+        });
+    }
     /**
      * Describe every registered namespace for configuration surfaces, including
      * the composition `base` and raw user layers so a form can mark which fields
@@ -343,9 +340,10 @@ export class SettingsProvider extends Service {
      * Read one registered namespace's resolved value.
      * @param ns - the namespace to read.
      * @returns the resolved value, or `undefined` while unregistered.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
      */
     get(ns) {
-        return this.registrations.get(ns)?.resolved;
+        return this.registrations.get(parseSettingsNamespace(ns))?.resolved;
     }
     /**
      * Merge a patch into one registered namespace's user layer, validate the
@@ -357,9 +355,10 @@ export class SettingsProvider extends Service {
      * @param patch - plain-object patch over the user section.
      * @param expectedRevision - the descriptor `revision` the caller read; a
      *   namespace that moved past it rejects with {@link SettingsConflictError}.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
      */
     async update(ns, patch, expectedRevision) {
-        return this.write(ns, patch, 'merge', expectedRevision);
+        return this.write(parseSettingsNamespace(ns), patch, 'merge', expectedRevision);
     }
     /**
      * Replace one registered namespace's user section wholesale, validate,
@@ -370,9 +369,10 @@ export class SettingsProvider extends Service {
      * @param section - the complete next user section.
      * @param expectedRevision - the descriptor `revision` the caller read; a
      *   namespace that moved past it rejects with {@link SettingsConflictError}.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
      */
     async replace(ns, section, expectedRevision) {
-        return this.write(ns, section, 'replace', expectedRevision);
+        return this.write(parseSettingsNamespace(ns), section, 'replace', expectedRevision);
     }
     /**
      * Apply path-addressed edits to one registered namespace's user section,
@@ -385,19 +385,21 @@ export class SettingsProvider extends Service {
      * @param ops - ordered path edits; later ops observe earlier ones.
      * @param expectedRevision - the descriptor `revision` the caller read; a
      *   namespace that moved past it rejects with {@link SettingsConflictError}.
+     * @throws {TypeError} when `ns` is not a lowercase hyphenated identifier.
      */
     async mutate(ns, ops, expectedRevision) {
+        const parsedNs = parseSettingsNamespace(ns);
         if (!Array.isArray(ops))
-            throw new TypeError(`settings mutate for "${ns}" must be an array of path ops`);
+            throw new TypeError(`settings mutate for "${parsedNs}" must be an array of path ops`);
         for (const op of ops) {
             if (!isPlainObject(op) || (op['op'] !== 'set' && op['op'] !== 'unset')) {
-                throw new TypeError(`settings mutate for "${ns}" ops must be {op:'set'|'unset', path}`);
+                throw new TypeError(`settings mutate for "${parsedNs}" ops must be {op:'set'|'unset', path}`);
             }
             if (!Array.isArray(op['path']) || op['path'].some(part => typeof part !== 'string')) {
-                throw new TypeError(`settings mutate for "${ns}" op paths must be arrays of strings`);
+                throw new TypeError(`settings mutate for "${parsedNs}" op paths must be arrays of strings`);
             }
         }
-        return this.write(ns, ops, 'mutate', expectedRevision);
+        return this.write(parsedNs, ops, 'mutate', expectedRevision);
     }
     /** Validate a write, then queue it on the namespace's serialized write chain. */
     write(ns, input, mode, expectedRevision) {
@@ -640,49 +642,5 @@ function isUnloading(ctx) {
     const state = ctx.fiber.state;
     return state === FIBER_UNLOADING || state === FIBER_DISPOSED;
 }
-/**
- * Install the canonical optional-settings consumer wiring: while a settings
- * service exists, register `ns` with the consumer's composition entry as the
- * `base` layer and point the source thunk at the resolved scope; when the
- * service goes away (disposal, provider reload), fall back to the entry so
- * the consumer keeps working exactly as composed. The registration rides the
- * scoped fiber, so no settings service ever mounted means none of this runs.
- * @param ctx - consumer plugin context owning the wiring.
- * @param ns - the consumer-owned settings namespace.
- * @param schema - schema resolving the namespace (typically the plugin Config).
- * @param entry - the consumer's composition entry config, used as `base`.
- * @param hooks - source sink and change notification.
- */
-export function installSettingsSection(ctx, ns, schema, entry, hooks) {
-    ctx.inject(['settings'], (sctx) => {
-        const scope = sctx.settings.register(ns, schema, {
-            base: entry,
-            ...hooks.validate === undefined ? {} : { validate: hooks.validate },
-        });
-        hooks.setSource(() => scope.get());
-        sctx.effect(() => () => {
-            // This disposer runs for two different reasons. A settings provider
-            // detaching leaves the consumer running, so it must fall back to its
-            // composition entry and re-judge what it derived. The consumer's own
-            // unload runs it too — and there `onChange` would re-register routes
-            // and touch resources the teardown is releasing, so the fallback is
-            // pointless and the notification actively harmful.
-            if (isUnloading(ctx))
-                return;
-            hooks.setSource(() => entry);
-            hooks.onChange();
-        });
-        hooks.onChange();
-        scope.watch(() => {
-            // A stored change landing while the consumer unloads reaches the watcher
-            // before the registration is released, and `onChange` is exactly as
-            // harmful here as in the disposer above: it re-registers routes against
-            // a fiber whose resources are being let go.
-            if (isUnloading(ctx))
-                return;
-            hooks.onChange();
-        });
-    });
-}
 export default SettingsProvider;
 //# sourceMappingURL=index.js.map

package/lib/types/invariant.js

@@ -2,7 +2,7 @@
  * Package-owned invariant companion for `@deepseek-ai/dsh-settings`.
  * @module @deepseek-ai/dsh-settings/invariant
  */
-import { deepEqualJson } from "./index.js";
+import { deepEqualJson } from '@deepseek-ai/dsh-util-values';
 const PACKAGE_NAME = '@deepseek-ai/dsh-settings';
 /** Cordis companion plugin name. */
 export const name = 'settings-invariant';

package/lib/types/types.d.ts

@@ -1,16 +1,74 @@
 /**
  * Client-safe type surface of the user-settings seam: the namespace brand, the
- * commit-origin union, and the seam's Cordis event declarations. Types only —
- * no runtime code, and nothing here reaches a Host-only symbol, so a Client
+ * commit-origin union, the redacted views a configuration surface reads over
+ * the Remote wire, and the seam's Cordis event declarations. Types only — no
+ * runtime code, and nothing here reaches a Host-only symbol, so a Client
  * compilation face reads exactly the signatures the Host emits.
  *
  * @module @deepseek-ai/dsh-settings/types
  */
 import type { Branded } from '@deepseek-ai/dsh-brand';
+import type { JsonValue } from '@deepseek-ai/dsh-util-values';
 /** Nominal id of one registered settings namespace. */
 export type SettingsNamespace = Branded<'SettingsNamespace'>;
 /** Origin of one committed settings change. */
 export type SettingsUpdateSource = 'update' | 'provider';
+/** One schema-declared secret slot inside a redacted namespace value. */
+export interface SettingsSecretView {
+    /** Path from the section root to the removed field. */
+    path: string[];
+    /** Whether the slot currently holds a value; the value itself never rides. */
+    set: boolean;
+}
+/**
+ * Wire view of one registered namespace, always read under `redactSecrets`. The
+ * JSON-valued fields are `JsonValue` rather than the descriptor's `unknown`
+ * because the Remote boundary admits no unconstrained data.
+ */
+export interface SettingsNamespaceView {
+    /** Namespace key (`llm-deepseek`, `llm-pi-ai`, …). */
+    ns: string;
+    /** Serialized schemastery schema envelope (`schema.toJSON()`); rehydrate with `new Schema(json)`. */
+    schema: JsonValue;
+    /** Redacted resolved value (schema defaults → composition base → user layer). */
+    value: JsonValue;
+    /** Redacted composition base layer, when the registrant declared one. */
+    base?: JsonValue;
+    /** Redacted raw user section, when one exists; a field's presence here marks it user-overridden. */
+    user?: JsonValue;
+    /** When the owner applies changes. */
+    applies: 'live' | 'restart';
+    /** Every schema-declared secret slot with its configured state. */
+    secrets: SettingsSecretView[];
+    /**
+     * Monotonic revision of the raw user section this view was read at. Send it
+     * back as `expectedRevision` on a write so a stale editor is refused rather
+     * than silently overwriting a concurrent change.
+     */
+    revision: number;
+}
+/**
+ * One path-addressed edit carried by a remote settings write. `set` writes the
+ * value at the path, creating intermediate objects; `unset` removes it. The
+ * empty path addresses the section root.
+ */
+export type SettingsPathOpView = {
+    op: 'set';
+    path: string[];
+    value: JsonValue;
+} | {
+    op: 'unset';
+    path: string[];
+};
+/** Every registered namespace with the deployment facts a configuration page renders around them. */
+export interface SettingsDescribeValue {
+    /** Whether the provider accepts writes; `false` disables every write control. */
+    writable: boolean;
+    /** Whether a file-backed provider owns a local document, without exposing its Host path. */
+    hasDocument: boolean;
+    /** One view per registered namespace. */
+    namespaces: SettingsNamespaceView[];
+}
 declare module '@deepseek-ai/cordis' {
     interface Events {
         /**

package/lib/types/types.js

@@ -1,7 +1,8 @@
 /**
  * Client-safe type surface of the user-settings seam: the namespace brand, the
- * commit-origin union, and the seam's Cordis event declarations. Types only —
- * no runtime code, and nothing here reaches a Host-only symbol, so a Client
+ * commit-origin union, the redacted views a configuration surface reads over
+ * the Remote wire, and the seam's Cordis event declarations. Types only — no
+ * runtime code, and nothing here reaches a Host-only symbol, so a Client
  * compilation face reads exactly the signatures the Host emits.
  *
  * @module @deepseek-ai/dsh-settings/types