dsh-permission-rules 0.7.4 → 0.7.6

package/lib/index.js

@@ -1643,61 +1643,146 @@ function resolveBuiltinRulesPath(custom) {
 * a validated {@link Config} field changeable from cordis.yml; the
 * resolution step validates the numeric bounds and compiles nothing — rule
 * files are external documents resolved per session cwd at load time.
+*
+* Since the `0.1.7-alpha` settings contract every field is declared
+* `.volatile()`, so the Loader hands `apply` a live reference per field
+* ({@link LiveConfig}) and the settings surface edits them in place. The
+* numeric bounds live in the SCHEMA (`min`/`max`/`step`) as well as in
+* {@link resolveConfig}: the config editor resolves the merged config
+* against this schema before it persists anything, so an out-of-range value
+* is still refused at write time — the tradeoff the removed
+* `settings.register(..., { validate })` callback used to carry.
 * @module dsh-permission-rules/config
 */
-/** Schemastery schema: the loader validates and fills defaults before `apply`. */
+/**
+* Mark one schema field as a live reference, where the host can.
+*
+* `.volatile()` first appeared in `@deepseek-ai/schemastery` 3.18.3, and this
+* schema is built while the plugin module is evaluated — an unguarded call
+* would turn every host line the package's peer ranges still advertise
+* (`0.1.2-rc`, `0.1.5-alpha`, `0.1.6-0`) into a hard mount crash. Probed
+* instead: on a Schemastery without the method the field stays an ordinary
+* value, the Loader hands `apply` a plain config ({@link plainConfig} passes
+* it straight through), and the plugin runs exactly as it did before live
+* forms existed — only the settings form is unavailable there, which is the
+* same degradation as a host that composes no settings service at all.
+* @param schema - the field schema.
+* @returns the same field schema, live where supported.
+*/
+function live(schema) {
+	const builder = schema;
+	return typeof builder.volatile === "function" ? builder.volatile() : schema;
+}
+/**
+* Schemastery schema: the loader validates and fills defaults before
+* `apply`. Every field is live (see {@link live}), so on a `0.1.7-alpha`
+* host the Loader hands `apply` a reference per field and the settings
+* surface can edit each one in place. `network` and `builtin` are marked
+* live as WHOLE objects — Schemastery refuses a volatile inside a volatile,
+* and the only supported shape is a fixed object path.
+*
+* The numeric bounds are declared here (not only in {@link resolveConfig})
+* because the config editor resolves the merged config against THIS schema
+* before persisting it: an out-of-range edit is refused at write time
+* instead of disabling the plugin on the next read.
+*/
 const Config = z.object({
-	rulesFile: z.string().default(".dsh/rules.yaml"),
-	fallbackPath: z.string(),
-	badFilePolicy: z.union(["fail", "ignore-with-warning"]).default("fail"),
-	maxRules: z.number().default(256),
-	maxCachedWorkspaces: z.number().default(512),
-	patternMode: z.union(["glob", "regex"]).default("glob"),
-	watch: z.boolean().default(true),
-	watchStabilityThresholdMs: z.number().default(200),
-	language: z.union([
+	rulesFile: live(z.string().default(".dsh/rules.yaml")),
+	fallbackPath: live(z.string()),
+	badFilePolicy: live(z.union(["fail", "ignore-with-warning"]).default("fail")),
+	maxRules: live(z.number().step(1).min(1).default(256)),
+	maxCachedWorkspaces: live(z.number().step(1).min(1).default(512)),
+	patternMode: live(z.union(["glob", "regex"]).default("glob")),
+	watch: live(z.boolean().default(true)),
+	watchStabilityThresholdMs: live(z.number().step(1).min(0).default(200)),
+	language: live(z.union([
 		"en",
 		"zh",
 		"es",
 		"pt",
 		"hi"
-	]).default("en"),
-	caseInsensitivePaths: z.boolean().default(process.platform === "win32"),
-	audit: z.union(["all", "hits"]).default("all"),
-	searchUp: z.boolean().default(false),
-	maxGlobStars: z.number().default(2),
-	enforce: z.boolean().default(true),
-	allowUnmarkedAudit: z.boolean().default(false),
-	network: z.object({
+	]).default("en")),
+	caseInsensitivePaths: live(z.boolean().default(process.platform === "win32")),
+	audit: live(z.union(["all", "hits"]).default("all")),
+	searchUp: live(z.boolean().default(false)),
+	maxGlobStars: live(z.number().step(1).min(1).default(2)),
+	enforce: live(z.boolean().default(true)),
+	allowUnmarkedAudit: live(z.boolean().default(false)),
+	network: live(z.object({
 		enabled: z.boolean().default(true),
 		mode: z.union(["auto", ...NETWORK_MODES]).default("auto"),
 		autoFallback: z.union(NETWORK_MODES).default("allow-all"),
 		unlisted: z.union(["ask", "deny"]).default("ask"),
 		proxyBind: z.string().default("127.0.0.1"),
-		proxyPort: z.number().default(0),
-		proxyMaxRecent: z.number().default(100),
+		proxyPort: z.number().step(1).min(0).max(65535).default(0),
+		proxyMaxRecent: z.number().step(1).min(1).default(100),
 		loopback: z.union(["allow", "policy"]).default("allow"),
 		injectEnv: z.boolean().default(true),
 		noProxy: z.union(["clear", "preserve"]).default("clear"),
 		upstreamProxy: z.string().default("off"),
 		allowHostAction: z.boolean().default(true)
-	}),
-	builtin: z.object({
+	})),
+	builtin: live(z.object({
 		enabled: z.boolean().default(true),
 		path: z.string()
-	})
+	}))
 });
 /**
+* Whether `value` is the Loader's live config rather than a plain one.
+* `rulesFile` is the discriminator: it always has a schema default, so the
+* Loader always materializes its reference, plain or absent.
+* @param value - a raw or live config.
+* @returns true when the fields are live references.
+*/
+function isLiveConfig(value) {
+	return typeof value.rulesFile?.get === "function";
+}
+/**
+* Unwrap the Loader's live references into the plain config
+* {@link resolveConfig} validates. Reading each reference HERE is what keeps
+* a caller's config source lazy: call it inside the closure, never at
+* closure-construction time, or a live edit stops being visible.
+* @param config - the raw config, or the Loader's live one.
+* @returns the plain raw config (the input itself when it was already plain).
+*/
+function plainConfig(config) {
+	if (!isLiveConfig(config)) return config;
+	return {
+		rulesFile: config.rulesFile.get(),
+		fallbackPath: config.fallbackPath.get(),
+		badFilePolicy: config.badFilePolicy.get(),
+		maxRules: config.maxRules.get(),
+		maxCachedWorkspaces: config.maxCachedWorkspaces.get(),
+		patternMode: config.patternMode.get(),
+		watch: config.watch.get(),
+		watchStabilityThresholdMs: config.watchStabilityThresholdMs.get(),
+		language: config.language.get(),
+		caseInsensitivePaths: config.caseInsensitivePaths.get(),
+		audit: config.audit.get(),
+		searchUp: config.searchUp.get(),
+		maxGlobStars: config.maxGlobStars.get(),
+		enforce: config.enforce.get(),
+		allowUnmarkedAudit: config.allowUnmarkedAudit.get(),
+		network: config.network.get(),
+		builtin: config.builtin.get()
+	};
+}
+/**
 * Validate raw values and fill explicit defaults. A `maxRules`,
 * `maxCachedWorkspaces`, or `maxGlobStars` that is not a positive safe
 * integer, a non-positive stability window, `searchUp` combined with an
 * absolute `rulesFile`, a value outside a closed enum, or a non-boolean
 * flag throws here — misconfiguration fails loud at mount even when the
 * plugin is mounted without the Schemastery loader.
-* @param config - raw (possibly partial) plugin config.
+*
+* Accepts the Loader's live config directly and unwraps it through
+* {@link plainConfig}, so a caller can keep this call inside its config
+* source and see every live edit on the next read.
+* @param input - raw (possibly partial) plugin config, or the Loader's live one.
 * @returns the fully resolved config.
 */
-function resolveConfig(config = {}) {
+function resolveConfig(input = {}) {
+	const config = plainConfig(input);
 	const rulesFile = config.rulesFile ?? ".dsh/rules.yaml";
 	const searchUp = config.searchUp ?? false;
 	if (searchUp && isAbsolute(rulesFile)) throw new TypeError(`searchUp cannot be combined with an absolute rulesFile (${JSON.stringify(rulesFile)}): parent-directory walking needs a relative file name`);
@@ -2954,33 +3039,32 @@ var PermissionRulesRemoteService = class extends TypertRemoteService {
 };
 //#endregion
 //#region src/settings.ts
-/** The settings namespace this plugin owns (kebab-case, per the provider contract). */
-const SETTINGS_NAMESPACE = "permission-rules";
 /**
-* Register the settings section and bind the runtime's live config
-* source. Runs only where a settings service is composed.
+* Point the runtime's live config source at the Loader's references and
+* register this instance's settings-page policy.
 * @param ctx - the plugin context.
-* @param runtime - the runtime whose config source follows the section.
-* @param entry - the composition entry config (the section's `base` layer).
+* @param runtime - the runtime whose config source follows the references.
+* @param config - the Loader-delivered live config (references to the entry's values).
 */
-function attachSettingsSection(ctx, runtime, entry) {
+function attachSettingsSection(ctx, runtime, config) {
 	ctx.inject(["settings"], (scope) => {
 		const settings = scope.get("settings");
-		if (settings === void 0) return;
-		const registration = settings.register(SETTINGS_NAMESPACE, Config, {
-			base: entry,
-			expose: true,
-			applies: "live",
-			validate: (value) => {
-				resolveConfig(value);
-			}
-		});
-		runtime.setConfigSource(() => resolveConfig(registration.get()));
-		registration.watch((next, prev) => {
-			const nextConfig = resolveConfig(next);
-			const prevConfig = resolveConfig(prev);
-			if (nextConfig.network.proxyPort !== prevConfig.network.proxyPort || nextConfig.network.proxyBind !== prevConfig.network.proxyBind || nextConfig.network.injectEnv !== prevConfig.network.injectEnv || nextConfig.network.noProxy !== prevConfig.network.noProxy) runtime.onNetworkConfigChanged();
-		});
+		if (settings?.configure === void 0) return;
+		scope.effect(() => settings.configure({ auto: false }, ctx.fiber));
+	});
+	runtime.setConfigSource(() => resolveConfig(config));
+	let previous = resolveConfig(config);
+	ctx.on("loader/volatile-update", () => {
+		let next;
+		try {
+			next = resolveConfig(config);
+		} catch (error) {
+			ctx.logger.warn(`permission-rules: live config update is not usable: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		const rebind = next.network.proxyPort !== previous.network.proxyPort || next.network.proxyBind !== previous.network.proxyBind || next.network.injectEnv !== previous.network.injectEnv || next.network.noProxy !== previous.network.noProxy;
+		previous = next;
+		if (rebind) runtime.onNetworkConfigChanged();
 	});
 }
 //#endregion
@@ -4581,8 +4665,13 @@ var PermissionRulesRuntime = class {
 /**
 * Mount the plugin: resolve config, validate deployment-level rule files,
 * register the pre-execute listener and the `/rules` command.
+*
+* The `config` argument is the Loader's LIVE config (every field a
+* `.volatile()` reference, see {@link LiveConfig}); `resolveConfig` unwraps
+* it, and the same object is handed to {@link attachSettingsSection} so the
+* runtime keeps reading the current values instead of a mount-time snapshot.
 * @param ctx - the host context.
-* @param config - raw plugin config.
+* @param config - the Loader-delivered live plugin config.
 */
 async function apply(ctx, config) {
 	const resolved = resolveConfig(config);
@@ -4744,4 +4833,4 @@ const name = "permission-rules";
 /** Consumer — the /rules command handler and the tools/pre-execute waterfall listener consume the injected commands/tools services. */
 const inject = ["commands", "tools"];
 //#endregion
-export { BUILTIN_RULES_FILE, Config, GlobError, NETWORK_MODES, NO_PROXY_ENV_NAMES, NetworkProxy, PATH_CANDIDATE_KEYS, PLATFORMS, PROXY_ENV_NAMES, PermissionRulesRuntime, RULE_ACTIONS, RuleError, SCHEMES, SHIPPED_BUILTIN_RULES, URL_CANDIDATE_KEYS, apply, blockMessage, compileGlob, compilePatternRegex, compileRules, compileRulesChain, compileSourceRules, decideNetworkTarget, decomposeShellCommand, defaultDecision, describeRule, extractPathCandidates, extractUrlCandidates, findUnreachableRules, inject, injectProxyEnv, isIpLiteral, isLoopbackTarget, isMarkedAuditEvent, isShellTool, isUnmarkedHostVersion, matchRules, matchTools, matchWhen, mergeCompiledRules, name, networkModeForSandbox, normalizeHost, normalizeWorkspacePath, parseRulesDocument, parseUrlTarget, readAmbientProxy, redactProxyUrl, resolveBuiltinRulesPath, resolveConfig, targetMatchesNetwork };
+export { BUILTIN_RULES_FILE, Config, GlobError, NETWORK_MODES, NO_PROXY_ENV_NAMES, NetworkProxy, PATH_CANDIDATE_KEYS, PLATFORMS, PROXY_ENV_NAMES, PermissionRulesRuntime, RULE_ACTIONS, RuleError, SCHEMES, SHIPPED_BUILTIN_RULES, URL_CANDIDATE_KEYS, apply, blockMessage, compileGlob, compilePatternRegex, compileRules, compileRulesChain, compileSourceRules, decideNetworkTarget, decomposeShellCommand, defaultDecision, describeRule, extractPathCandidates, extractUrlCandidates, findUnreachableRules, inject, injectProxyEnv, isIpLiteral, isLoopbackTarget, isMarkedAuditEvent, isShellTool, isUnmarkedHostVersion, matchRules, matchTools, matchWhen, mergeCompiledRules, name, networkModeForSandbox, normalizeHost, normalizeWorkspacePath, parseRulesDocument, parseUrlTarget, plainConfig, readAmbientProxy, redactProxyUrl, resolveBuiltinRulesPath, resolveConfig, targetMatchesNetwork };

package/lib/typert.host.js

@@ -4099,17 +4099,17 @@ function superRefine(fn, params) {
 * @module dsh-permission-rules/wire
 */
 /**
-* Strict wire codec carrying BOTH published and checkout faces: the `schema`
-* field feeds the npm-published 0.1.5-rc.2 line, while `create` feeds the
-* 0.1.6-alpha.2+ line, whose typert-loader requires the factory on every
-* codec and materializes schemas lazily on first use. Built through a
-* variable, so neither typecheck ruler flags the other face's field as excess.
+* Strict wire codec. `create` is the ONLY schema face the `0.1.7-alpha`
+* `TypertCodec` declares — it materializes the process-realm schema on first
+* boundary use — and the typert-loader rejects any codec without it. The
+* older published lines also carried a literal `schema` field on the codec;
+* that face is gone from the contract, so carrying it here would be dead
+* weight (and only the `create` factory is ever consulted at run time).
 */
 function strictWire(typeSymbol, schema) {
 	return Object.freeze({
 		mode: "strict",
 		typeSymbol,
-		schema,
 		create: () => schema
 	});
 }

package/lib/types/client/remote.d.ts

@@ -46,47 +46,9 @@ export declare const PERMISSION_RULES_REMOTE: Readonly<{
         }>;
         readonly parameters: readonly never[];
         readonly result: Readonly<{
-            create: () => import("zod").ZodObject<{
-                enabled: import("zod").ZodBoolean;
-                mode: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"deny-all">, import("zod").ZodLiteral<"whitelist">, import("zod").ZodLiteral<"allow-all">]>;
-                configuredMode: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"auto">, import("zod").ZodLiteral<"deny-all">, import("zod").ZodLiteral<"whitelist">, import("zod").ZodLiteral<"allow-all">]>;
-                sandboxMode: import("zod").ZodNullable<import("zod").ZodString>;
-                proxyPort: import("zod").ZodNumber;
-                proxyActive: import("zod").ZodBoolean;
-                denied: import("zod").ZodNumber;
-                askBlocked: import("zod").ZodNumber;
-                recent: import("zod").ZodArray<import("zod").ZodObject<{
-                    time: import("zod").ZodNumber;
-                    tool: import("zod").ZodString;
-                    attributed: import("zod").ZodBoolean;
-                    domain: import("zod").ZodString;
-                    scheme: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"http">, import("zod").ZodLiteral<"https">, import("zod").ZodNull]>;
-                    port: import("zod").ZodNullable<import("zod").ZodNumber>;
-                    action: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"deny">, import("zod").ZodLiteral<"ask">]>;
-                    mode: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"deny-all">, import("zod").ZodLiteral<"whitelist">, import("zod").ZodLiteral<"allow-all">]>;
-                    matched: import("zod").ZodBoolean;
-                    source: import("zod").ZodString;
-                    ruleIndex: import("zod").ZodNullable<import("zod").ZodNumber>;
-                    reason: import("zod").ZodNullable<import("zod").ZodString>;
-                    cwd: import("zod").ZodNullable<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-                sources: import("zod").ZodArray<import("zod").ZodObject<{
-                    path: import("zod").ZodString;
-                    exists: import("zod").ZodBoolean;
-                    cwd: import("zod").ZodNullable<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-                allowHostAction: import("zod").ZodBoolean;
-                upstream: import("zod").ZodObject<{
-                    mode: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"off">, import("zod").ZodLiteral<"inherit">, import("zod").ZodLiteral<"url">]>;
-                    http: import("zod").ZodNullable<import("zod").ZodString>;
-                    https: import("zod").ZodNullable<import("zod").ZodString>;
-                    active: import("zod").ZodBoolean;
-                    chained: import("zod").ZodNumber;
-                }, import("zod/v4/core").$strip>;
-            }, import("zod/v4/core").$strip>;
             mode: "strict";
             typeSymbol: string;
-            schema: import("zod").ZodObject<{
+            create: () => import("zod").ZodObject<{
                 enabled: import("zod").ZodBoolean;
                 mode: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"deny-all">, import("zod").ZodLiteral<"whitelist">, import("zod").ZodLiteral<"allow-all">]>;
                 configuredMode: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"auto">, import("zod").ZodLiteral<"deny-all">, import("zod").ZodLiteral<"whitelist">, import("zod").ZodLiteral<"allow-all">]>;
@@ -143,22 +105,15 @@ export declare const PERMISSION_RULES_REMOTE: Readonly<{
             wire: string;
             source: "json";
             codec: Readonly<{
-                create: () => import("zod").ZodString;
                 mode: "strict";
                 typeSymbol: string;
-                schema: import("zod").ZodString;
+                create: () => import("zod").ZodString;
             }>;
         }>[];
         readonly result: Readonly<{
-            create: () => import("zod").ZodObject<{
-                path: import("zod").ZodString;
-                exists: import("zod").ZodBoolean;
-                text: import("zod").ZodString;
-                error: import("zod").ZodNullable<import("zod").ZodString>;
-            }, import("zod/v4/core").$strip>;
             mode: "strict";
             typeSymbol: string;
-            schema: import("zod").ZodObject<{
+            create: () => import("zod").ZodObject<{
                 path: import("zod").ZodString;
                 exists: import("zod").ZodBoolean;
                 text: import("zod").ZodString;
@@ -183,21 +138,15 @@ export declare const PERMISSION_RULES_REMOTE: Readonly<{
             wire: string;
             source: "json";
             codec: Readonly<{
-                create: () => import("zod").ZodString;
                 mode: "strict";
                 typeSymbol: string;
-                schema: import("zod").ZodString;
+                create: () => import("zod").ZodString;
             }>;
         }>[];
         readonly result: Readonly<{
-            create: () => import("zod").ZodObject<{
-                ok: import("zod").ZodBoolean;
-                error: import("zod").ZodNullable<import("zod").ZodString>;
-                reloaded: import("zod").ZodNullable<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>;
             mode: "strict";
             typeSymbol: string;
-            schema: import("zod").ZodObject<{
+            create: () => import("zod").ZodObject<{
                 ok: import("zod").ZodBoolean;
                 error: import("zod").ZodNullable<import("zod").ZodString>;
                 reloaded: import("zod").ZodNullable<import("zod").ZodNumber>;
@@ -218,13 +167,9 @@ export declare const PERMISSION_RULES_REMOTE: Readonly<{
         }>;
         readonly parameters: readonly never[];
         readonly result: Readonly<{
-            create: () => import("zod").ZodObject<{
-                ok: import("zod").ZodBoolean;
-                error: import("zod").ZodNullable<import("zod").ZodString>;
-            }, import("zod/v4/core").$strip>;
             mode: "strict";
             typeSymbol: string;
-            schema: import("zod").ZodObject<{
+            create: () => import("zod").ZodObject<{
                 ok: import("zod").ZodBoolean;
                 error: import("zod").ZodNullable<import("zod").ZodString>;
             }, import("zod/v4/core").$strip>;
@@ -247,15 +192,9 @@ export declare const PERMISSION_RULES_REMOTE: Readonly<{
             wire: string;
             source: "json";
             codec: Readonly<{
-                create: () => import("zod").ZodObject<{
-                    host: import("zod").ZodString;
-                    scheme: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"http">, import("zod").ZodLiteral<"https">, import("zod").ZodNull]>;
-                    port: import("zod").ZodNullable<import("zod").ZodNumber>;
-                    cwd: import("zod").ZodNullable<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>;
                 mode: "strict";
                 typeSymbol: string;
-                schema: import("zod").ZodObject<{
+                create: () => import("zod").ZodObject<{
                     host: import("zod").ZodString;
                     scheme: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"http">, import("zod").ZodLiteral<"https">, import("zod").ZodNull]>;
                     port: import("zod").ZodNullable<import("zod").ZodNumber>;
@@ -264,18 +203,9 @@ export declare const PERMISSION_RULES_REMOTE: Readonly<{
             }>;
         }>[];
         readonly result: Readonly<{
-            create: () => import("zod").ZodObject<{
-                ok: import("zod").ZodBoolean;
-                path: import("zod").ZodNullable<import("zod").ZodString>;
-                created: import("zod").ZodBoolean;
-                reloaded: import("zod").ZodNumber;
-                outcome: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"allow">, import("zod").ZodLiteral<"deny">, import("zod").ZodLiteral<"ask">, import("zod").ZodNull]>;
-                alreadyAllowed: import("zod").ZodBoolean;
-                error: import("zod").ZodNullable<import("zod").ZodString>;
-            }, import("zod/v4/core").$strip>;
             mode: "strict";
             typeSymbol: string;
-            schema: import("zod").ZodObject<{
+            create: () => import("zod").ZodObject<{
                 ok: import("zod").ZodBoolean;
                 path: import("zod").ZodNullable<import("zod").ZodString>;
                 created: import("zod").ZodBoolean;

package/lib/types/client/remote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../../../src/client/remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAA4B,MAAM,kCAAkC,CAAA;AAE9F,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,uBAAuB,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjJ,OAAO,QAAQ,kCAAkC,CAAC;IAChD,UAAU,qCAAqC;QAC7C,+FAA+F;QAC/F,aAAa,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC,CAAA;QACnE,+CAA+C;QAC/C,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;QACnE,8CAA8C;QAC9C,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;QACjF,4CAA4C;QAC5C,MAAM,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC,CAAA;QACtD,4FAA4F;QAC5F,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;KACjF;IACD,UAAU,eAAe;QACvB,+BAA+B,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC,CAAA;QACrF,2BAA2B,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;QACrF,2BAA2B,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;QACnG,wBAAwB,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC,CAAA;QACxE,2BAA2B,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;KACnG;IACD,UAAU,wBAAwB;QAChC,eAAe,EAAE,qCAAqC,CAAA;KACvD;CACF;AAED,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGC,CAAA"}
+{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../../../src/client/remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAA4B,MAAM,kCAAkC,CAAA;AAE9F,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,uBAAuB,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjJ,OAAO,QAAQ,kCAAkC,CAAC;IAChD,UAAU,qCAAqC;QAC7C,+FAA+F;QAC/F,aAAa,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC,CAAA;QACnE,+CAA+C;QAC/C,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;QACnE,8CAA8C;QAC9C,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;QACjF,4CAA4C;QAC5C,MAAM,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC,CAAA;QACtD,4FAA4F;QAC5F,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;KACjF;IACD,UAAU,eAAe;QACvB,+BAA+B,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC,CAAA;QACrF,2BAA2B,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;QACrF,2BAA2B,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;QACnG,wBAAwB,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC,CAAA;QACxE,2BAA2B,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAA;KACnG;IACD,UAAU,wBAAwB;QAChC,eAAe,EAAE,qCAAqC,CAAA;KACvD;CACF;AAED,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGC,CAAA"}

package/lib/types/config.d.ts

@@ -3,6 +3,15 @@
  * a validated {@link Config} field changeable from cordis.yml; the
  * resolution step validates the numeric bounds and compiles nothing — rule
  * files are external documents resolved per session cwd at load time.
+ *
+ * Since the `0.1.7-alpha` settings contract every field is declared
+ * `.volatile()`, so the Loader hands `apply` a live reference per field
+ * ({@link LiveConfig}) and the settings surface edits them in place. The
+ * numeric bounds live in the SCHEMA (`min`/`max`/`step`) as well as in
+ * {@link resolveConfig}: the config editor resolves the merged config
+ * against this schema before it persists anything, so an out-of-range value
+ * is still refused at write time — the tradeoff the removed
+ * `settings.register(..., { validate })` callback used to carry.
  * @module dsh-permission-rules/config
  */
 import z from '@deepseek-ai/schemastery';
@@ -86,8 +95,10 @@ export interface Config {
     /**
      * Fallback rule file used when per-cwd discovery finds no rule file.
      * Absolute, or relative to `process.cwd()`. Unset = an empty rule set.
+     * Declared `| undefined` because a live reference to a field the schema
+     * gives no default reports an absent value explicitly.
      */
-    fallbackPath?: string;
+    fallbackPath?: string | undefined;
     /**
      * How an unreadable/invalid rule file is handled at load: `'fail'` throws
      * (the pending tool call errors loudly; HMR reloads keep the previous
@@ -134,9 +145,9 @@ export interface Config {
      */
     allowUnmarkedAudit?: boolean;
     /** Process-level network policy (all optional; defaults inside). */
-    network?: NetworkConfig;
+    network?: NetworkConfig | undefined;
     /** Built-in high-risk baseline (all optional; defaults inside). */
-    builtin?: BuiltinConfig;
+    builtin?: BuiltinConfig | undefined;
 }
 /** Network config after {@link resolveConfig}: every optional field has its explicit default. */
 export interface ResolvedNetworkConfig {
@@ -179,8 +190,133 @@ export interface ResolvedConfig {
     readonly network: ResolvedNetworkConfig;
     readonly builtin: ResolvedBuiltinConfig;
 }
-/** Schemastery schema: the loader validates and fills defaults before `apply`. */
-export declare const Config: z<Config>;
+/**
+ * Schemastery schema: the loader validates and fills defaults before
+ * `apply`. Every field is live (see {@link live}), so on a `0.1.7-alpha`
+ * host the Loader hands `apply` a reference per field and the settings
+ * surface can edit each one in place. `network` and `builtin` are marked
+ * live as WHOLE objects — Schemastery refuses a volatile inside a volatile,
+ * and the only supported shape is a fixed object path.
+ *
+ * The numeric bounds are declared here (not only in {@link resolveConfig})
+ * because the config editor resolves the merged config against THIS schema
+ * before persisting it: an out-of-range edit is refused at write time
+ * instead of disabling the plugin on the next read.
+ */
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    rulesFile: z<string, string, "volatile-defined">;
+    fallbackPath: z<string, string, "volatile">;
+    badFilePolicy: z<"fail" | "ignore-with-warning", "fail" | "ignore-with-warning", "volatile-defined">;
+    maxRules: z<number, number, "volatile-defined">;
+    maxCachedWorkspaces: z<number, number, "volatile-defined">;
+    patternMode: z<"glob" | "regex", "glob" | "regex", "volatile-defined">;
+    watch: z<boolean, boolean, "volatile-defined">;
+    watchStabilityThresholdMs: z<number, number, "volatile-defined">;
+    language: z<"en" | "zh" | "es" | "pt" | "hi", "en" | "zh" | "es" | "pt" | "hi", "volatile-defined">;
+    caseInsensitivePaths: z<boolean, boolean, "volatile-defined">;
+    audit: z<"all" | "hits", "all" | "hits", "volatile-defined">;
+    searchUp: z<boolean, boolean, "volatile-defined">;
+    maxGlobStars: z<number, number, "volatile-defined">;
+    enforce: z<boolean, boolean, "volatile-defined">;
+    allowUnmarkedAudit: z<boolean, boolean, "volatile-defined">;
+    network: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        mode: z<"deny-all" | "whitelist" | "allow-all" | "auto", "deny-all" | "whitelist" | "allow-all" | "auto", "defined">;
+        autoFallback: z<"deny-all" | "whitelist" | "allow-all", "deny-all" | "whitelist" | "allow-all", "defined">;
+        unlisted: z<"deny" | "ask", "deny" | "ask", "defined">;
+        proxyBind: z<string, string, "defined">;
+        proxyPort: z<number, number, "defined">;
+        proxyMaxRecent: z<number, number, "defined">;
+        loopback: z<"allow" | "policy", "allow" | "policy", "defined">;
+        injectEnv: z<boolean, boolean, "defined">;
+        noProxy: z<"clear" | "preserve", "clear" | "preserve", "defined">;
+        upstreamProxy: z<string, string, "defined">;
+        allowHostAction: z<boolean, boolean, "defined">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        mode: z<"deny-all" | "whitelist" | "allow-all" | "auto", "deny-all" | "whitelist" | "allow-all" | "auto", "defined">;
+        autoFallback: z<"deny-all" | "whitelist" | "allow-all", "deny-all" | "whitelist" | "allow-all", "defined">;
+        unlisted: z<"deny" | "ask", "deny" | "ask", "defined">;
+        proxyBind: z<string, string, "defined">;
+        proxyPort: z<number, number, "defined">;
+        proxyMaxRecent: z<number, number, "defined">;
+        loopback: z<"allow" | "policy", "allow" | "policy", "defined">;
+        injectEnv: z<boolean, boolean, "defined">;
+        noProxy: z<"clear" | "preserve", "clear" | "preserve", "defined">;
+        upstreamProxy: z<string, string, "defined">;
+        allowHostAction: z<boolean, boolean, "defined">;
+    }>>>, "volatile">;
+    builtin: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        path: z<string, string, "plain">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        path: z<string, string, "plain">;
+    }>>>, "volatile">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    rulesFile: z<string, string, "volatile-defined">;
+    fallbackPath: z<string, string, "volatile">;
+    badFilePolicy: z<"fail" | "ignore-with-warning", "fail" | "ignore-with-warning", "volatile-defined">;
+    maxRules: z<number, number, "volatile-defined">;
+    maxCachedWorkspaces: z<number, number, "volatile-defined">;
+    patternMode: z<"glob" | "regex", "glob" | "regex", "volatile-defined">;
+    watch: z<boolean, boolean, "volatile-defined">;
+    watchStabilityThresholdMs: z<number, number, "volatile-defined">;
+    language: z<"en" | "zh" | "es" | "pt" | "hi", "en" | "zh" | "es" | "pt" | "hi", "volatile-defined">;
+    caseInsensitivePaths: z<boolean, boolean, "volatile-defined">;
+    audit: z<"all" | "hits", "all" | "hits", "volatile-defined">;
+    searchUp: z<boolean, boolean, "volatile-defined">;
+    maxGlobStars: z<number, number, "volatile-defined">;
+    enforce: z<boolean, boolean, "volatile-defined">;
+    allowUnmarkedAudit: z<boolean, boolean, "volatile-defined">;
+    network: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        mode: z<"deny-all" | "whitelist" | "allow-all" | "auto", "deny-all" | "whitelist" | "allow-all" | "auto", "defined">;
+        autoFallback: z<"deny-all" | "whitelist" | "allow-all", "deny-all" | "whitelist" | "allow-all", "defined">;
+        unlisted: z<"deny" | "ask", "deny" | "ask", "defined">;
+        proxyBind: z<string, string, "defined">;
+        proxyPort: z<number, number, "defined">;
+        proxyMaxRecent: z<number, number, "defined">;
+        loopback: z<"allow" | "policy", "allow" | "policy", "defined">;
+        injectEnv: z<boolean, boolean, "defined">;
+        noProxy: z<"clear" | "preserve", "clear" | "preserve", "defined">;
+        upstreamProxy: z<string, string, "defined">;
+        allowHostAction: z<boolean, boolean, "defined">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        mode: z<"deny-all" | "whitelist" | "allow-all" | "auto", "deny-all" | "whitelist" | "allow-all" | "auto", "defined">;
+        autoFallback: z<"deny-all" | "whitelist" | "allow-all", "deny-all" | "whitelist" | "allow-all", "defined">;
+        unlisted: z<"deny" | "ask", "deny" | "ask", "defined">;
+        proxyBind: z<string, string, "defined">;
+        proxyPort: z<number, number, "defined">;
+        proxyMaxRecent: z<number, number, "defined">;
+        loopback: z<"allow" | "policy", "allow" | "policy", "defined">;
+        injectEnv: z<boolean, boolean, "defined">;
+        noProxy: z<"clear" | "preserve", "clear" | "preserve", "defined">;
+        upstreamProxy: z<string, string, "defined">;
+        allowHostAction: z<boolean, boolean, "defined">;
+    }>>>, "volatile">;
+    builtin: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        path: z<string, string, "plain">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        path: z<string, string, "plain">;
+    }>>>, "volatile">;
+}>>, "plain">;
+/** The Loader-delivered config: every field is a live reference to its current value. */
+export type LiveConfig = ReturnType<typeof Config>;
+/** What {@link resolveConfig} accepts: the raw config, or the Loader's live one. */
+export type ConfigInput = Config | LiveConfig;
+/**
+ * Unwrap the Loader's live references into the plain config
+ * {@link resolveConfig} validates. Reading each reference HERE is what keeps
+ * a caller's config source lazy: call it inside the closure, never at
+ * closure-construction time, or a live edit stops being visible.
+ * @param config - the raw config, or the Loader's live one.
+ * @returns the plain raw config (the input itself when it was already plain).
+ */
+export declare function plainConfig(config: ConfigInput): Config;
 /**
  * Validate raw values and fill explicit defaults. A `maxRules`,
  * `maxCachedWorkspaces`, or `maxGlobStars` that is not a positive safe
@@ -188,8 +324,12 @@ export declare const Config: z<Config>;
  * absolute `rulesFile`, a value outside a closed enum, or a non-boolean
  * flag throws here — misconfiguration fails loud at mount even when the
  * plugin is mounted without the Schemastery loader.
- * @param config - raw (possibly partial) plugin config.
+ *
+ * Accepts the Loader's live config directly and unwraps it through
+ * {@link plainConfig}, so a caller can keep this call inside its config
+ * source and see every live edit on the next read.
+ * @param input - raw (possibly partial) plugin config, or the Loader's live one.
  * @returns the fully resolved config.
  */
-export declare function resolveConfig(config?: Config): ResolvedConfig;
+export declare function resolveConfig(input?: ConfigInput): ResolvedConfig;
 //# sourceMappingURL=config.d.ts.map