dsh-update-status 0.1.8 → 0.1.9

package/lib/index.d.ts

@@ -1,5 +1,5 @@
-import z from "@deepseek-ai/schemastery";
 import { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
 //#region src/shared/types.d.ts
 declare const RELEASE_CHANNELS: readonly ['latest', 'next', 'alpha'];
 type ReleaseChannel = (typeof RELEASE_CHANNELS)[number];
@@ -38,6 +38,18 @@ type UpdateWarning = {
   code: 'preview-unverified';
   channel: ReleaseChannel;
   version: string;
+} |
+/**
+ * The Host resolved a `@deepseek-ai/schemastery` that DSH does not ship, so the
+ * Loader's volatile projection is unavailable and the preference fields cannot
+ * be marked volatile. Advisory: the version answer itself is complete, and the
+ * text carries the exact directory to remove. See `host/schemastery.ts`.
+ */
+{
+  code: 'stale-schemastery';
+  version: string | null;
+  path: string;
+  nodeModulesDir: string | null;
 };
 interface ChannelRelease {
   channel: ReleaseChannel;
@@ -98,7 +110,8 @@ interface UpdateStatusConfig {
  * The explicit two-argument annotation is load-bearing: a `.volatile()` field's
  * output is a stable reference (`Volatile<T>`) rather than the bare value the
  * input side takes, so the inferred schema type cannot be named by the emitted
- * `.d.ts` (TS2883) without stating the input side here.
+ * `.d.ts` (TS2883) without stating the input side here. The builder preserves
+ * that contract even on the degraded path, where no field is volatile.
  */
 export declare const Config: z<UpdateStatusConfig, Record<string, unknown>>;
 //#endregion
@@ -123,6 +136,11 @@ interface UpdateStatusServiceOptions {
   now?: () => number;
   ttlMs?: number;
   releaseUrl?: string;
+  /**
+   * Facts about this process's own runtime, appended to every status. The schema
+   * resolution is the only producer today; the registry read never sets these.
+   */
+  runtimeWarnings?: readonly UpdateWarning[];
 }
 export declare class UpdateStatusService {
   private readonly installation;
@@ -130,6 +148,7 @@ export declare class UpdateStatusService {
   private readonly now;
   private readonly ttlMs;
   private readonly releaseUrl;
+  private readonly runtimeWarnings;
   private cache;
   private inFlight;
   constructor(options: UpdateStatusServiceOptions);
@@ -142,6 +161,59 @@ export declare class UpdateStatusService {
   private statusWithoutRemoteRelease;
 }
 //#endregion
+//#region src/host/schemastery.d.ts
+/** Where a candidate copy of schemastery was looked for. */
+type SchemaCandidateSource = 'dsh-install' | 'profile-peers' | 'profile-local' | 'plugin-local';
+interface SchemaCandidate {
+  source: SchemaCandidateSource;
+  /** Absolute file path `createRequire` anchors on; the file need not exist. */
+  anchor: string;
+}
+interface SchemaCandidateReport {
+  source: SchemaCandidateSource;
+  anchor: string;
+  /** Absolute path of the module that loaded, or null when it did not load. */
+  path: string | null;
+  version: string | null;
+  /** The loaded module exposes `volatile()`. */
+  volatile: boolean;
+  /** Why this candidate was skipped, or null when it loaded. */
+  error: string | null;
+}
+interface SchemaRuntime {
+  /** The loaded schemastery factory — structurally the package's default export. */
+  z: unknown;
+  volatile: boolean;
+  source: SchemaCandidateSource;
+  path: string | null;
+  version: string | null;
+  /** Every candidate that was tried, in order, for diagnostics. */
+  candidates: SchemaCandidateReport[];
+  /** Set when the resolved copy cannot project volatile preferences. */
+  warning: UpdateWarning | null;
+}
+interface ResolveSchemaRuntimeOptions {
+  /** Override the candidate order; used by tests and by an embedding host. */
+  candidates?: readonly SchemaCandidate[];
+}
+/**
+ * Resolve schemastery once, preferring the copy that can actually do the job.
+ *
+ * Only a total miss throws, and only with the per-candidate reasons attached:
+ * that state means the plugin is not running inside a working DSH installation,
+ * so there is no schema system to build a settings form with. Every other
+ * outcome loads.
+ */
+export declare function resolveSchemaRuntime(options?: ResolveSchemaRuntimeOptions): SchemaRuntime;
+/**
+ * The process-wide resolution, computed on first use.
+ *
+ * The settings schema is built at module scope — the Loader reads the exported
+ * `Config` before `apply` runs — so the resolution cannot wait for a Host
+ * context. Every input here comes from the process environment or the filesystem.
+ */
+export declare function schemaRuntime(): SchemaRuntime;
+//#endregion
 //#region src/index.d.ts
 export declare const name = "dsh-update-status";
 /** Connection supplies the authenticated transport; settings remains optional. */
@@ -149,4 +221,4 @@ export declare const inject: string[];
 export type Config = UpdateStatusConfig;
 export declare function apply(ctx: Context, config?: Config): void;
 //#endregion
-export type { InstallKind, UpdateStatus };
+export type { InstallKind, SchemaRuntime, UpdateStatus };

package/lib/index.js

@@ -1,7 +1,8 @@
 import { createRequire } from "node:module";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { dirname, join, normalize, sep } from "node:path";
-import z from "@deepseek-ai/schemastery";
+import { basename, dirname, join, normalize, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
 //#region src/shared/types.ts
 const PACKAGE_NAME = "@deepseek-ai/dsh";
 /** Shared Connection RPC channel. Custom prefixes 405 on the SPA fallback. */
@@ -51,7 +52,7 @@ function manifestAt(path) {
 		return;
 	}
 }
-function realPath(path) {
+function realPath$1(path) {
 	try {
 		return realpathSync(path);
 	} catch {
@@ -60,14 +61,14 @@ function realPath(path) {
 }
 /** Ascend from an entry file until the owning DSH package manifest is found. */
 function manifestFromEntry(entryPath) {
-	let directory = dirname(realPath(entryPath));
+	let directory = dirname(realPath$1(entryPath));
 	for (let depth = 0; depth < 10; depth += 1) {
 		const manifest = join(directory, "package.json");
 		if (existsSync(manifest)) {
 			const found = manifestAt(manifest);
 			if (found !== void 0) return {
 				...found,
-				root: realPath(found.root)
+				root: realPath$1(found.root)
 			};
 		}
 		const parent = dirname(directory);
@@ -80,7 +81,7 @@ function manifestFromResolver(resolve) {
 		const found = manifestAt(resolve(PACKAGE_NAME + "/package.json"));
 		if (found !== void 0) return {
 			...found,
-			root: realPath(found.root)
+			root: realPath$1(found.root)
 		};
 	} catch {}
 	try {
@@ -114,7 +115,7 @@ function ownResolver(selfUrl) {
 */
 function classifyInstallRoot(packageRoot, nodePrefix = process.execPath) {
 	if (packageRoot === void 0) return "unknown";
-	const root = normalize(realPath(packageRoot)).split(sep).join("/");
+	const root = normalize(realPath$1(packageRoot)).split(sep).join("/");
 	const prefix = nodePrefix === void 0 ? "" : normalize(dirname(dirname(nodePrefix))).split(sep).join("/");
 	if (!root.includes("/node_modules/") && /\/apps\/cli(?:\/|$)/.test(root)) return "source-checkout";
 	if (root.includes("/.pnpm/") || /\/pnpm\/global(?:\/|$)/.test(root)) return "pnpm-global";
@@ -257,6 +258,278 @@ function installUpdateStatusRpc(ctx, service) {
 	});
 }
 //#endregion
+//#region src/host/schemastery.ts
+/**
+* dsh-update-status — shadow-proof resolution of the platform's schemastery.
+*
+* `@deepseek-ai/schemastery` is a peer dependency: DSH ships it, and DSH's copy
+* is the one carrying `volatile()` — the Loader's volatile-field projection this
+* plugin's settings form is built on. A plain
+* `import z from '@deepseek-ai/schemastery'` is resolved by Node's own directory
+* walk *from the importing file*, so any copy sitting next to the plugin wins
+* over the platform's copy. That is not hypothetical: an unmanaged tree left
+* inside the install directory — a dev `node_modules` copied in by a
+* local-directory install, which pnpm never removes — made `lib/index.js` throw
+* `TypeError: …volatile is not a function` while it was being imported, so the
+* whole host half disappeared before one line of plugin code ran.
+*
+* Nothing inside the plugin can repair that state: the failure precedes every
+* plugin entry point. The resolution itself is made immune instead, trying
+* platform copies before anything else:
+*
+* 1. the DSH installation running this process,
+* 2. the profile peer farm DSH maintains (`$DSH_HOME/profiles/node_modules`),
+* 3. the active profile's own tree,
+* 4. whatever Node's walk finds next to this file — last resort.
+*
+* The first candidate that actually exposes `volatile()` wins, and the
+* capability is verified rather than assumed. When no candidate provides it, the
+* plugin still loads on the best copy it could load and reports exactly what it
+* resolved: the missing capability becomes a `stale-schemastery` warning the
+* panel renders instead of a dead plugin.
+*/
+const SCHEMASTERY_NAME = "@deepseek-ai/schemastery";
+/** Anchor file name; it never has to exist, only to give `createRequire` a base. */
+const PROBE_FILE = "dsh-update-status-peer-probe.cjs";
+const MAX_ASCENT = 10;
+function realPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+function boundedMessage$1(error) {
+	const trimmed = (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim();
+	return trimmed === "" ? "unknown error" : trimmed.slice(0, 220);
+}
+function environmentDirectory(name) {
+	const value = process.env[name];
+	return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+/** The DSH home directory, from the environment first and `~/.dsh` as a fallback. */
+function dshHomeDirectory() {
+	const configured = environmentDirectory("DSH_HOME");
+	if (configured !== null) return configured;
+	try {
+		return join(homedir(), ".dsh");
+	} catch {
+		return null;
+	}
+}
+/** The active profile directory, from `$DSH_PROFILE_DIR` or `$DSH_HOME/profiles/<profile>`. */
+function profileDirectory() {
+	const configured = environmentDirectory("DSH_PROFILE_DIR");
+	if (configured !== null) return configured;
+	const home = dshHomeDirectory();
+	const profile = environmentDirectory("DSH_PROFILE");
+	return home === null || profile === null ? null : join(home, "profiles", profile);
+}
+/**
+* Anchor on the DSH package that owns the running entry point.
+*
+* The entry is the CLI file Node was started with, so ascending from it reaches
+* the DSH installation whose `node_modules` holds the platform's schemastery.
+* Reusing `manifestFromEntry` keeps this probe identical to the installation
+* detection the status read already performs.
+*/
+function dshInstallAnchor() {
+	const entry = process.argv[1];
+	if (typeof entry !== "string" || entry === "") return null;
+	const found = manifestFromEntry(entry);
+	return found === void 0 || found.root === "" ? null : join(found.root, "package.json");
+}
+/** Candidate order: platform copies first, the shadowable walk last. */
+function defaultSchemaCandidates() {
+	const candidates = [];
+	const install = dshInstallAnchor();
+	if (install !== null) candidates.push({
+		source: "dsh-install",
+		anchor: install
+	});
+	const home = dshHomeDirectory();
+	if (home !== null) candidates.push({
+		source: "profile-peers",
+		anchor: join(home, "profiles", PROBE_FILE)
+	});
+	const profile = profileDirectory();
+	if (profile !== null) candidates.push({
+		source: "profile-local",
+		anchor: join(profile, PROBE_FILE)
+	});
+	candidates.push({
+		source: "plugin-local",
+		anchor: fileURLToPath(import.meta.url)
+	});
+	return candidates;
+}
+function manifestVersion(manifestPath) {
+	try {
+		const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+		if (parsed.name !== "@deepseek-ai/schemastery" || typeof parsed.version !== "string") return null;
+		const version = parsed.version.trim();
+		return version === "" ? null : version;
+	} catch {
+		return null;
+	}
+}
+/** Read the version of the schemastery package that owns a resolved entry path. */
+function versionOfResolved(resolvedPath) {
+	let directory = dirname(realPath(resolvedPath));
+	for (let depth = 0; depth < MAX_ASCENT; depth += 1) {
+		const manifestPath = join(directory, "package.json");
+		if (existsSync(manifestPath)) {
+			const version = manifestVersion(manifestPath);
+			if (version !== null) return version;
+		}
+		const parent = dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+	return null;
+}
+/** The nearest `node_modules` directory above a resolved package entry. */
+function nodeModulesDirectoryOf(resolvedPath) {
+	if (resolvedPath === null) return null;
+	let directory = dirname(realPath(resolvedPath));
+	for (let depth = 0; depth < MAX_ASCENT; depth += 1) {
+		if (basename(directory) === "node_modules") return directory;
+		const parent = dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+	return null;
+}
+/**
+* Does this module expose the Loader's volatile projection?
+*
+* The probe builds a throwaway field because the capability is a prototype
+* method, not a flag: 3.18.2 has no `volatile` at all, 3.18.4 (the copy DSH
+* ships) does. Never throws — an unusable module is simply not a candidate.
+*/
+function supportsVolatile(factory) {
+	if (factory === null || typeof factory !== "object" && typeof factory !== "function") return false;
+	try {
+		const boolean = factory.boolean;
+		if (typeof boolean !== "function") return false;
+		const field = boolean.call(factory);
+		if (field === null || field === void 0 || typeof field.default !== "function") return false;
+		const defined = field.default(true);
+		return defined !== null && defined !== void 0 && typeof defined.volatile === "function";
+	} catch {
+		return false;
+	}
+}
+/** Can this value build a schema? A wrapper object that cannot is never chosen. */
+function isSchemaFactory(value) {
+	if (value === null || typeof value !== "object" && typeof value !== "function") return false;
+	const record = value;
+	return typeof record.object === "function" && typeof record.boolean === "function" && typeof record.number === "function";
+}
+/**
+* Pick the factory out of the shapes a CommonJS build can expose.
+*
+* The package assigns `module.exports` directly, but a bundler or an interop
+* wrapper can put the same factory behind `default`. A shape that cannot build a
+* schema is never chosen even as a fallback, because the degraded path still has
+* to produce a `Config` — a wrapper object would throw while the entry loads,
+* which is the failure this module exists to prevent.
+*/
+function factoryOf(loaded) {
+	const shapes = [loaded, (loaded !== null && (typeof loaded === "object" || typeof loaded === "function") ? loaded : void 0)?.default].filter(isSchemaFactory);
+	return shapes.find(supportsVolatile) ?? shapes[0];
+}
+function loadCandidate(candidate) {
+	const report = {
+		source: candidate.source,
+		anchor: candidate.anchor,
+		path: null,
+		version: null,
+		volatile: false,
+		error: null
+	};
+	try {
+		const require = createRequire(candidate.anchor);
+		const resolved = require.resolve(SCHEMASTERY_NAME);
+		const factory = factoryOf(require(resolved));
+		if (factory === void 0) throw new Error("module does not export a schemastery factory");
+		report.path = realPath(resolved);
+		report.version = versionOfResolved(resolved);
+		report.volatile = supportsVolatile(factory);
+		return {
+			report,
+			factory
+		};
+	} catch (error) {
+		report.error = boundedMessage$1(error);
+		return {
+			report,
+			factory: void 0
+		};
+	}
+}
+/**
+* Resolve schemastery once, preferring the copy that can actually do the job.
+*
+* Only a total miss throws, and only with the per-candidate reasons attached:
+* that state means the plugin is not running inside a working DSH installation,
+* so there is no schema system to build a settings form with. Every other
+* outcome loads.
+*/
+function resolveSchemaRuntime(options = {}) {
+	const candidates = options.candidates ?? defaultSchemaCandidates();
+	const reports = [];
+	let usable;
+	let loaded;
+	for (const candidate of candidates) {
+		const attempt = loadCandidate(candidate);
+		reports.push(attempt.report);
+		if (attempt.factory === void 0) continue;
+		loaded ??= attempt;
+		if (attempt.report.volatile) {
+			usable = attempt;
+			break;
+		}
+	}
+	const chosen = usable ?? loaded;
+	if (chosen === void 0) {
+		const tried = reports.map((report) => `${report.source}: ${report.error ?? "not loadable"}`).join("; ");
+		throw new Error(`dsh-update-status could not resolve ${SCHEMASTERY_NAME} (${tried})`);
+	}
+	return {
+		z: chosen.factory,
+		volatile: chosen.report.volatile,
+		source: chosen.report.source,
+		path: chosen.report.path,
+		version: chosen.report.version,
+		candidates: reports,
+		warning: chosen.report.volatile ? null : {
+			code: "stale-schemastery",
+			version: chosen.report.version,
+			path: chosen.report.path ?? chosen.report.anchor,
+			nodeModulesDir: nodeModulesDirectoryOf(chosen.report.path)
+		}
+	};
+}
+let resolved;
+/**
+* The process-wide resolution, computed on first use.
+*
+* The settings schema is built at module scope — the Loader reads the exported
+* `Config` before `apply` runs — so the resolution cannot wait for a Host
+* context. Every input here comes from the process environment or the filesystem.
+*/
+function schemaRuntime() {
+	resolved ??= resolveSchemaRuntime();
+	return resolved;
+}
+/** English, single-line summary of a resolution, for the Host log. */
+function describeSchemaRuntime(runtime) {
+	const where = runtime.path === null ? runtime.source : `${runtime.path} (${runtime.source})`;
+	const version = runtime.version === null ? "" : `@${runtime.version}`;
+	return `${SCHEMASTERY_NAME}${version} from ${where}; volatile preferences ${runtime.volatile ? "available" : "unavailable"}`;
+}
+//#endregion
 //#region src/shared/semver.ts
 const SEMVER = /^(?:v)?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 const NUMERIC_IDENTIFIER = /^(0|[1-9]\d*)$/;
@@ -317,20 +590,34 @@ function boundedMessage(error) {
 	const trimmed = (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim();
 	return trimmed === "" ? "unknown error" : trimmed.slice(0, 220);
 }
-function warningText(warning) {
+/** English, single-line rendering of one warning; the Host log uses it directly. */
+function describeWarning(warning) {
 	switch (warning.code) {
 		case "registry-unavailable": return `Unable to check the npm registry: ${warning.detail}`;
 		case "channel-unavailable": return `The npm registry does not publish a ${warning.channel} channel.`;
 		case "version-incomparable": return `Unable to compare the current version ${warning.currentVersion} with ${warning.channel} channel version ${warning.selectedVersion} using SemVer.`;
 		case "preview-unverified": return `${warning.channel} is a preview channel; version ${warning.version} has not been verified as compatible with this plugin.`;
+		case "stale-schemastery": {
+			const version = warning.version === null ? "" : ` ${warning.version}`;
+			const remedy = warning.nodeModulesDir === null ? `Remove the stale ${SCHEMASTERY_NAME} directory there and restart DSH.` : `Remove the stale copy and restart DSH: rm -rf ${warning.nodeModulesDir}`;
+			return `This plugin resolved ${SCHEMASTERY_NAME}${version} from ${warning.path} instead of the copy DSH provides, so preference fields cannot be marked volatile. ${remedy}`;
+		}
 	}
 }
 function warningFallback(warnings) {
-	return warnings.length === 0 ? null : warnings.map(warningText).join(" ");
+	return warnings.length === 0 ? null : warnings.map(describeWarning).join(" ");
 }
+/**
+* Advisory codes leave the chip alone; everything else is a failed read.
+*
+* `stale-schemastery` belongs here: the version answer is complete and usable,
+* and only the settings form is degraded, so repainting the brand row would
+* misreport a plugin-runtime fact as a failed update check.
+*/
+const ADVISORY_CODES = ["preview-unverified", "stale-schemastery"];
 function warningKindOf(warnings) {
 	if (warnings.length === 0) return null;
-	return warnings.every((warning) => warning.code === "preview-unverified") ? "notice" : "failure";
+	return warnings.every((warning) => ADVISORY_CODES.includes(warning.code)) ? "notice" : "failure";
 }
 function dateOrNull(value) {
 	if (typeof value !== "string" || value === "") return null;
@@ -399,6 +686,7 @@ var UpdateStatusService = class {
 	now;
 	ttlMs;
 	releaseUrl;
+	runtimeWarnings;
 	cache;
 	inFlight;
 	constructor(options) {
@@ -407,6 +695,7 @@ var UpdateStatusService = class {
 		this.now = options.now ?? Date.now;
 		this.ttlMs = Math.max(1, Math.floor(options.ttlMs ?? DEFAULT_TTL_MS));
 		this.releaseUrl = options.releaseUrl ?? "https://github.com/deepseek-ai/deepseek-harness/releases";
+		this.runtimeWarnings = options.runtimeWarnings ?? [];
 	}
 	getStatus(channel = "latest", cacheTtlMinutes) {
 		return this.check(false, channel, cacheTtlMinutes);
@@ -470,6 +759,7 @@ var UpdateStatusService = class {
 			channel,
 			version: selected.version
 		});
+		warnings.push(...this.runtimeWarnings);
 		return {
 			currentVersion: this.installation.currentVersion,
 			latestVersion: selected.version,
@@ -491,15 +781,16 @@ var UpdateStatusService = class {
 		};
 	}
 	statusWithoutRemoteRelease(channel, warnings) {
+		const combined = [...warnings, ...this.runtimeWarnings];
 		return {
 			currentVersion: this.installation.currentVersion,
 			latestVersion: null,
 			hasUpdate: false,
 			cached: false,
 			checkedAt: null,
-			warning: warningFallback(warnings),
-			warningKind: warningKindOf(warnings),
-			warnings,
+			warning: warningFallback(combined),
+			warningKind: warningKindOf(combined),
+			warnings: combined,
 			installKind: this.installation.installKind,
 			upgradeCommand: upgradeCommandFor(this.installation.installKind, this.installation.packageName || "@deepseek-ai/dsh", channel),
 			releaseUrl: this.releaseUrl,
@@ -520,25 +811,46 @@ var UpdateStatusService = class {
 //#endregion
 //#region src/host/settings.ts
 /**
+* Build the Config schema from a resolved schemastery factory.
+*
+* `volatileAvailable` is the capability the resolver *verified*, not an
+* assumption. On a copy without `volatile()` the three preferences stay ordinary
+* fields — the plugin keeps loading and reports why through
+* `schemaRuntime().warning` instead of throwing while its own entry is imported.
+*
+* @param factory - A schemastery factory, structurally the package's default export.
+* @param volatileAvailable - Whether `factory` exposes the Loader's volatile projection.
+*/
+function buildConfigSchema(factory, volatileAvailable) {
+	const volatile = (field) => {
+		if (!volatileAvailable) return field;
+		const method = field.volatile;
+		return typeof method === "function" ? method.call(field) : field;
+	};
+	return factory.object({
+		cacheTtlHours: factory.number().step(1).min(1).max(24).default(6),
+		timeoutMs: factory.number().step(1).min(1e3).max(3e4).default(DEFAULT_TIMEOUT_MS),
+		autoCheckOnMount: factory.boolean().default(true),
+		sidebarEnabled: volatile(factory.boolean().default(true)),
+		channel: volatile(factory.union([
+			"latest",
+			"next",
+			"alpha"
+		]).default("latest").loose()),
+		cacheTtlMinutes: volatile(factory.number().min(30).max(1440).default(360))
+	});
+}
+const runtime = schemaRuntime();
+/**
 * The plugin's Config schema; its volatile fields ARE the settings form.
 *
 * The explicit two-argument annotation is load-bearing: a `.volatile()` field's
 * output is a stable reference (`Volatile<T>`) rather than the bare value the
 * input side takes, so the inferred schema type cannot be named by the emitted
-* `.d.ts` (TS2883) without stating the input side here.
+* `.d.ts` (TS2883) without stating the input side here. The builder preserves
+* that contract even on the degraded path, where no field is volatile.
 */
-const Config = z.object({
-	cacheTtlHours: z.number().step(1).min(1).max(24).default(6),
-	timeoutMs: z.number().step(1).min(1e3).max(3e4).default(DEFAULT_TIMEOUT_MS),
-	autoCheckOnMount: z.boolean().default(true),
-	sidebarEnabled: z.boolean().default(true).volatile(),
-	channel: z.union([
-		"latest",
-		"next",
-		"alpha"
-	]).default("latest").loose().volatile(),
-	cacheTtlMinutes: z.number().min(30).max(1440).default(360).volatile()
-});
+const Config = buildConfigSchema(runtime.z, runtime.volatile);
 /**
 * Suppress the auto-generated settings page for this entry.
 *
@@ -576,14 +888,17 @@ function boundedNumber(value, fallback, min, max) {
 function apply(ctx, config = {}) {
 	const ttlHours = boundedNumber(config.cacheTtlHours, 6, 1, 24);
 	const timeoutMs = boundedNumber(config.timeoutMs, DEFAULT_TIMEOUT_MS, 1e3, 3e4);
+	const schema = schemaRuntime();
+	if (schema.warning !== null) console.warn(`[dsh-update-status] ${describeSchemaRuntime(schema)} — ${describeWarning(schema.warning)}`);
 	const service = new UpdateStatusService({
 		installation: detectInstallation(ctx),
 		fetchLatest: createRegistryFetcher(timeoutMs),
-		ttlMs: ttlHours * 60 * 60 * 1e3
+		ttlMs: ttlHours * 60 * 60 * 1e3,
+		runtimeWarnings: schema.warning === null ? [] : [schema.warning]
 	});
 	installSettings(ctx);
 	installUpdateStatusRpc(ctx, service);
 	if (config.autoCheckOnMount !== false) service.getStatus();
 }
 //#endregion
-export { Config, UpdateStatusService, apply, inject, name };
+export { Config, UpdateStatusService, apply, inject, name, resolveSchemaRuntime, schemaRuntime };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-update-status",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Read-only DeepSeek Harness Web plugin that shows the running DSH version, discovers latest/next/alpha releases, warns about compatibility, and generates copy-only upgrade commands.",
   "type": "module",
   "main": "lib/index.js",
@@ -99,6 +99,7 @@
     "test": "pnpm run typecheck && vitest run",
     "test:unit": "vitest run",
     "clean": "rm -rf lib coverage",
-    "verify": "pnpm run test && pnpm run build && pnpm pack --dry-run"
+    "guard:shadowed-peer": "node tests/guards/shadowed-peer.mjs",
+    "verify": "pnpm run test && pnpm run build && pnpm run guard:shadowed-peer && pnpm pack --dry-run"
   }
 }