alepha 0.22.0 → 0.24.0

package/dist/api/parameters/index.js

@@ -1,6 +1,6 @@
-import { $hook, $inject, $module, Alepha, AlephaError, KIND, Primitive, SchemaValidator, createPrimitive, t } from "alepha";
+import { $hook, $inject, $module, Alepha, AlephaError, KIND, Primitive, SchemaValidator, createPrimitive, z } from "alepha";
 import { $audit } from "alepha/api/audits";
-import { $secure } from "alepha/security";
+import { $secure, currentTenantAtom, currentUserAtom } from "alepha/security";
 import { $action, okSchema } from "alepha/server";
 import { $entity, $repository, RepositoryProvider, db } from "alepha/orm";
 import { CryptoProvider } from "alepha/crypto";
@@ -41,63 +41,81 @@ var ParameterAudits = class {
 */
 const parameters = $entity({
 	name: "parameters",
-	schema: t.object({
-		id: db.primaryKey(t.uuid()),
+	schema: z.object({
+		id: db.primaryKey(z.uuid()),
 		createdAt: db.createdAt(),
 		updatedAt: db.updatedAt(),
 		/**
+		* Tenant scope. NULLABLE on purpose (backward compatible): single-tenant
+		* apps keep writing org-less (NULL) rows with the historic global
+		* semantics. In a MULTI-TENANT process (e.g. one pooled worker serving
+		* many orgs), the active tenant is stamped by the Repository
+		* (`stampOrganization`) and reads/writes auto-filter by it — so one org's
+		* `app.settings`/`portal.site`/… can never be read or overwritten by
+		* another. The provider's in-memory value caches are keyed by org too.
+		*/
+		organizationId: db.organization(),
+		/**
 		* Configuration name using dot notation for tree hierarchy.
 		* Examples: "app.features", "app.pricing.tiers", "system.limits"
 		*/
-		name: t.text(),
+		name: z.text(),
 		/**
 		* The configuration content as JSON.
 		*/
-		content: t.json(),
+		content: z.json(),
 		/**
 		* Schema version hash for detecting schema changes.
 		* Used for auto-migration when schema evolves.
 		*/
-		schemaHash: t.text(),
+		schemaHash: z.text(),
 		/**
 		* When this version should become active.
 		* Default is immediate (now).
 		*/
-		activationDate: t.datetime(),
+		activationDate: z.datetime(),
 		/**
 		* Version number for this configuration.
 		* Auto-incremented per config name.
 		*/
-		version: t.integer(),
+		version: z.integer(),
 		/**
 		* Optional description of changes in this version.
 		*/
-		changeDescription: t.optional(t.text()),
+		changeDescription: z.text().optional(),
 		/**
 		* Optional tags for filtering/categorization.
 		*/
-		tags: t.optional(t.array(t.text())),
+		tags: z.array(z.text()).optional(),
 		/**
 		* Creator user ID (if available).
 		*/
-		creatorId: t.optional(t.uuid()),
+		creatorId: z.uuid().optional(),
 		/**
 		* Creator display name for audit trail.
 		*/
-		creatorName: t.optional(t.text()),
+		creatorName: z.text().optional(),
 		/**
 		* Previous content before this change (for rollback reference).
 		*/
-		previousContent: t.optional(t.json()),
+		previousContent: z.json().optional(),
 		/**
 		* Migration log if schema changed.
 		*/
-		migrationLog: t.optional(t.text())
+		migrationLog: z.text().optional()
 	}),
 	indexes: [
-		{ columns: ["name", "activationDate"] },
+		{ columns: [
+			"organizationId",
+			"name",
+			"activationDate"
+		] },
 		{
-			columns: ["name", "version"],
+			columns: [
+				"organizationId",
+				"name",
+				"version"
+			],
 			unique: true
 		},
 		{ columns: ["activationDate"] }
@@ -111,22 +129,22 @@ const parameters = $entity({
 * Creator fields are omitted; the controller captures the authenticated user
 * server-side.
 */
-const activateParameterBodySchema = t.pick(parameters.schema, ["version"]);
+const activateParameterBodySchema = parameters.schema.pick({ version: true });
 //#endregion
 //#region ../../src/api/parameters/schemas/createParameterVersionBodySchema.ts
 /**
 * Create parameter version body schema.
-* Uses t.pick to derive from entity, with required fields made non-optional.
+* Uses z.pick to derive from entity, with required fields made non-optional.
 *
 * Creator fields are intentionally omitted: the controller captures the
 * authenticated user server-side, so they cannot be spoofed by the client.
 */
-const createParameterVersionBodySchema = t.extend(t.pick(parameters.schema, [
-	"content",
-	"schemaHash",
-	"changeDescription",
-	"tags"
-]), { activationDate: t.optional(t.datetime({ description: "When to activate (default: now)" })) });
+const createParameterVersionBodySchema = parameters.schema.pick({
+	content: true,
+	schemaHash: true,
+	changeDescription: true,
+	tags: true
+}).extend({ activationDate: z.datetime().describe("When to activate (default: now)").optional() });
 //#endregion
 //#region ../../src/api/parameters/schemas/parameterCreatorSummarySchema.ts
 /**
@@ -141,22 +159,22 @@ const createParameterVersionBodySchema = t.extend(t.pick(parameters.schema, [
 * realm — comes back with `creator` undefined. Callers fall back to the raw
 * `creatorId`.
 */
-const parameterCreatorSummarySchema = t.object({
-	id: t.uuid(),
-	email: t.optional(t.string({ format: "email" })),
-	username: t.optional(t.shortText({
+const parameterCreatorSummarySchema = z.object({
+	id: z.uuid(),
+	email: z.string().meta({ format: "email" }).optional(),
+	username: z.shortText({
 		minLength: 3,
 		maxLength: 30
-	})),
-	firstName: t.optional(t.string()),
-	lastName: t.optional(t.string())
+	}).optional(),
+	firstName: z.string().optional(),
+	lastName: z.string().optional()
 });
 //#endregion
 //#region ../../src/api/parameters/schemas/parameterStatusSchema.ts
 /**
 * Parameter status enum schema.
 */
-const parameterStatusSchema = t.enum([
+const parameterStatusSchema = z.enum([
 	"expired",
 	"current",
 	"next",
@@ -172,9 +190,9 @@ const parameterStatusSchema = t.enum([
 * `creator` is embedded on read via a best-effort left join on `creatorId`
 * (see `parameterCreatorSummarySchema`); it is not a stored column.
 */
-const parameterResponseSchema = t.extend(parameters.schema, {
+const parameterResponseSchema = parameters.schema.extend({
 	status: parameterStatusSchema,
-	creator: t.optional(parameterCreatorSummarySchema)
+	creator: parameterCreatorSummarySchema.optional()
 });
 //#endregion
 //#region ../../src/api/parameters/schemas/parameterCurrentResponseSchema.ts
@@ -182,56 +200,59 @@ const parameterResponseSchema = t.extend(parameters.schema, {
 * Current parameter response schema.
 * Includes current version, next scheduled version, and defaults.
 */
-const parameterCurrentResponseSchema = t.object({
-	current: t.optional(parameterResponseSchema),
-	next: t.optional(parameterResponseSchema),
-	defaultValue: t.optional(t.json()),
-	currentValue: t.optional(t.json()),
-	schema: t.optional(t.json())
+const parameterCurrentResponseSchema = z.object({
+	current: parameterResponseSchema.optional(),
+	next: parameterResponseSchema.optional(),
+	defaultValue: z.json().optional(),
+	currentValue: z.json().optional(),
+	schema: z.json().optional()
 });
 //#endregion
 //#region ../../src/api/parameters/schemas/parameterHistoryResponseSchema.ts
 /**
 * Parameter history response schema.
 */
-const parameterHistoryResponseSchema = t.object({ versions: t.array(parameterResponseSchema) });
+const parameterHistoryResponseSchema = z.object({ versions: z.array(parameterResponseSchema) });
 //#endregion
 //#region ../../src/api/parameters/schemas/parameterNameParamSchema.ts
 /**
 * Parameter name param schema.
-* Uses t.pick from entity for consistency.
+* Uses z.pick from entity for consistency.
 */
-const parameterNameParamSchema = t.pick(parameters.schema, ["name"]);
+const parameterNameParamSchema = parameters.schema.pick({ name: true });
 //#endregion
 //#region ../../src/api/parameters/schemas/parameterNamesResponseSchema.ts
 /**
 * Parameter names list response schema.
 */
-const parameterNamesResponseSchema = t.object({ names: t.array(t.text()) });
+const parameterNamesResponseSchema = z.object({ names: z.array(z.text()) });
 //#endregion
 //#region ../../src/api/parameters/schemas/parameterTreeNodeSchema.ts
 /**
 * Tree node schema for parameter tree navigation.
 */
-const parameterTreeNodeSchema = t.object({
-	name: t.text(),
-	path: t.text(),
-	isLeaf: t.boolean(),
-	children: t.array(t.any())
+const parameterTreeNodeSchema = z.object({
+	name: z.text(),
+	path: z.text(),
+	isLeaf: z.boolean(),
+	children: z.array(z.any())
 });
 //#endregion
 //#region ../../src/api/parameters/schemas/parameterVersionParamSchema.ts
 /**
 * Parameter name and version param schema.
-* Uses t.pick from entity for consistency.
+* Uses z.pick from entity for consistency.
 */
-const parameterVersionParamSchema = t.pick(parameters.schema, ["name", "version"]);
+const parameterVersionParamSchema = parameters.schema.pick({
+	name: true,
+	version: true
+});
 //#endregion
 //#region ../../src/api/parameters/schemas/parameterVersionResponseSchema.ts
 /**
 * Parameter version response schema.
 */
-const parameterVersionResponseSchema = t.object({ parameter: t.optional(parameterResponseSchema) });
+const parameterVersionResponseSchema = z.object({ parameter: parameterResponseSchema.optional() });
 //#endregion
 //#region ../../src/api/parameters/schemas/rollbackParameterBodySchema.ts
 /**
@@ -240,7 +261,7 @@ const parameterVersionResponseSchema = t.object({ parameter: t.optional(paramete
 * Creator fields are omitted; the controller captures the authenticated user
 * server-side.
 */
-const rollbackParameterBodySchema = t.extend(t.pick(parameters.schema, ["changeDescription"]), { targetVersion: t.integer({ description: "Version number to rollback to" }) });
+const rollbackParameterBodySchema = parameters.schema.pick({ changeDescription: true }).extend({ targetVersion: z.integer().describe("Version number to rollback to") });
 //#endregion
 //#region ../../src/api/parameters/services/ParameterProvider.ts
 /**
@@ -272,7 +293,32 @@ var ParameterProvider = class {
 	}
 	_instanceId;
 	/**
-	* In-memory cache of registered parameter primitives.
+	* Resolve the active tenant for cache keying — MIRRORS the Repository's
+	* `resolveOrganizationValue` (tenant atom → user org) so the in-memory
+	* value caches partition exactly the way the DB rows do. Returns a sentinel
+	* for the org-less (single-tenant / no-request) case.
+	*
+	* Why this matters: the DB table is now org-scoped, but these process-global
+	* Maps are keyed by parameter NAME — without folding the org into the key, a
+	* pooled multi-tenant worker would hand org A's cached `club.settings` to a
+	* request for org B. (Cross-instance topic sync + the `ready` preload run
+	* with no request atom → the sentinel key; they refresh only org-less rows,
+	* leaving per-org caches to lazy-load + the immediate local update on `set`.
+	* That is bounded staleness, never a cross-tenant read.)
+	*/
+	orgKey() {
+		const tenant = this.alepha.store.get(currentTenantAtom);
+		if (tenant?.id) return tenant.id;
+		return this.alepha.store.get(currentUserAtom)?.organization ?? "~global";
+	}
+	/** Per-org cache key for the value caches (`${org}:${name}`). */
+	cacheKey(name) {
+		return `${this.orgKey()}:${name}`;
+	}
+	/**
+	* In-memory cache of registered parameter primitives. Keyed by NAME only —
+	* the `$parameter` definition (schema + default) is identical for every
+	* tenant; only the stored VALUE is per-org (see the value caches below).
 	*/
 	primitives = /* @__PURE__ */ new Map();
 	/**
@@ -288,6 +334,28 @@ var ParameterProvider = class {
 	*/
 	loaded = /* @__PURE__ */ new Set();
 	/**
+	* Epoch millis of the last successful load (or local set) per cache key.
+	* Drives the serverless revalidation TTL (see `revalidateAfterMs`).
+	*/
+	loadedAt = /* @__PURE__ */ new Map();
+	/**
+	* How long a cached value may serve before `get()` re-reads the DB.
+	*
+	* The in-memory caches are PER ISOLATE. On serverless runtimes
+	* (Cloudflare Workers) many isolates serve the same app and the
+	* cross-instance `syncTopic` rides the queue provider — in-memory by
+	* default, so a `set()` handled by one isolate never reaches the others:
+	* without a TTL they serve the stale value until they are recycled.
+	*
+	* Defaults: 30 s on serverless, 0 (= never revalidate, the historical
+	* behaviour) elsewhere. Override with the `PARAMETERS_CACHE_TTL_MS` env.
+	*/
+	get revalidateAfterMs() {
+		const raw = this.alepha.env.PARAMETERS_CACHE_TTL_MS;
+		if (raw !== void 0 && raw !== "") return Number(raw);
+		return this.alepha.isServerless() ? 3e4 : 0;
+	}
+	/**
 	* Shared promises for deduplicating concurrent load() calls.
 	*/
 	loadPromises = /* @__PURE__ */ new Map();
@@ -324,9 +392,9 @@ var ParameterProvider = class {
 	*/
 	syncTopic = $topic({
 		name: "parameter:sync",
-		schema: { payload: t.object({
-			name: t.text(),
-			instanceId: t.text()
+		schema: { payload: z.object({
+			name: z.text(),
+			instanceId: z.text()
 		}) },
 		handler: async ({ payload }) => {
 			await this.handleChangeNotification(payload);
@@ -346,21 +414,22 @@ var ParameterProvider = class {
 	* Checks if a cached next version has become current.
 	*/
 	async get(name) {
-		if (!this.loaded.has(name)) {
-			if (!this.loadPromises.has(name)) this.loadPromises.set(name, this.doLoad(name));
-			await this.loadPromises.get(name);
+		const ck = this.cacheKey(name);
+		if (!this.loaded.has(ck) || this.isStale(ck)) {
+			if (!this.loadPromises.has(ck)) this.loadPromises.set(ck, this.doLoad(name));
+			await this.loadPromises.get(ck);
 		}
-		const cachedNext = this.cachedNext.get(name);
+		const cachedNext = this.cachedNext.get(ck);
 		if (cachedNext) {
 			const now = this.dateTimeProvider.now().toDate();
 			if (new Date(cachedNext.activationDate) <= now) {
-				this.cachedCurrent.set(name, cachedNext.content);
-				this.cachedNext.delete(name);
+				this.cachedCurrent.set(ck, cachedNext.content);
+				this.cachedNext.delete(ck);
 				this.reloadNextInBackground(name);
 			}
 		}
 		const param = this.primitives.get(name);
-		return this.cachedCurrent.has(name) ? this.cachedCurrent.get(name) : param?.options.default;
+		return this.cachedCurrent.has(ck) ? this.cachedCurrent.get(ck) : param?.options.default;
 	}
 	/**
 	* Set a new parameter value.
@@ -374,25 +443,35 @@ var ParameterProvider = class {
 			creatorId: options.creatorId,
 			creatorName: options.creatorName
 		});
+		const ck = this.cacheKey(name);
 		const now = this.dateTimeProvider.now().toDate();
 		if (!options.activationDate || options.activationDate <= now) {
-			const prev = this.cachedCurrent.get(name);
-			this.cachedCurrent.set(name, value);
+			const prev = this.cachedCurrent.get(ck);
+			this.cachedCurrent.set(ck, value);
 			if (JSON.stringify(prev) !== JSON.stringify(value)) this.notifySubscribers(name);
-		} else this.cachedNext.set(name, {
+		} else this.cachedNext.set(ck, {
 			content: value,
 			activationDate: options.activationDate.toISOString()
 		});
+		this.loadedAt.set(ck, this.dateTimeProvider.nowMillis());
+	}
+	/** Whether the cached value outlived the revalidation TTL. */
+	isStale(ck) {
+		const ttl = this.revalidateAfterMs;
+		if (ttl <= 0) return false;
+		const at = this.loadedAt.get(ck);
+		return at === void 0 ? true : this.dateTimeProvider.nowMillis() - at > ttl;
 	}
 	/**
 	* Subscribe to parameter changes.
 	* Returns an unsubscribe function.
 	*/
 	sub(name, fn) {
-		if (!this.subscribers.has(name)) this.subscribers.set(name, []);
-		this.subscribers.get(name).push(fn);
+		const ck = this.cacheKey(name);
+		if (!this.subscribers.has(ck)) this.subscribers.set(ck, []);
+		this.subscribers.get(ck).push(fn);
 		return () => {
-			const subs = this.subscribers.get(name);
+			const subs = this.subscribers.get(ck);
 			if (subs) {
 				const idx = subs.indexOf(fn);
 				if (idx >= 0) subs.splice(idx, 1);
@@ -404,22 +483,24 @@ var ParameterProvider = class {
 	* Deduplicates concurrent calls via shared promise.
 	*/
 	async load(name) {
-		this.loadPromises.set(name, this.doLoad(name));
-		await this.loadPromises.get(name);
+		const ck = this.cacheKey(name);
+		this.loadPromises.set(ck, this.doLoad(name));
+		await this.loadPromises.get(ck);
 	}
 	/**
 	* Get the cached current content, falling back to default.
 	* Synchronous access for admin API.
 	*/
 	getCachedCurrentContent(name) {
-		if (this.cachedCurrent.has(name)) return this.cachedCurrent.get(name);
+		const ck = this.cacheKey(name);
+		if (this.cachedCurrent.has(ck)) return this.cachedCurrent.get(ck);
 		return this.primitives.get(name)?.options.default;
 	}
 	/**
 	* Whether the parameter is using its default value (no DB value loaded).
 	*/
 	isUsingDefault(name) {
-		return !this.cachedCurrent.has(name);
+		return !this.cachedCurrent.has(this.cacheKey(name));
 	}
 	/**
 	* Load the current and next parameter values from database.
@@ -583,12 +664,7 @@ var ParameterProvider = class {
 	*/
 	async delete(name) {
 		await this.repo.deleteMany({ name: { eq: name } });
-		this.cachedCurrent.delete(name);
-		this.cachedNext.delete(name);
-		this.loaded.delete(name);
-		this.loadPromises.delete(name);
-		this.loadGeneration.delete(name);
-		this.migrationChecked.delete(name);
+		this.evictCaches(name);
 		this.log.info("Parameter deleted", { name });
 	}
 	/**
@@ -597,17 +673,20 @@ var ParameterProvider = class {
 	async deleteMany(names) {
 		if (names.length === 0) return [];
 		await this.repo.deleteMany({ name: { inArray: names } });
-		for (const name of names) {
-			this.cachedCurrent.delete(name);
-			this.cachedNext.delete(name);
-			this.loaded.delete(name);
-			this.loadPromises.delete(name);
-			this.loadGeneration.delete(name);
-			this.migrationChecked.delete(name);
-		}
+		for (const name of names) this.evictCaches(name);
 		this.log.info("Parameters deleted", { count: names.length });
 		return names;
 	}
+	/** Drop every per-org value cache entry for `name` in the active org. */
+	evictCaches(name) {
+		const ck = this.cacheKey(name);
+		this.cachedCurrent.delete(ck);
+		this.cachedNext.delete(ck);
+		this.loaded.delete(ck);
+		this.loadPromises.delete(ck);
+		this.loadGeneration.delete(ck);
+		this.migrationChecked.delete(ck);
+	}
 	/**
 	* Get a specific version of a parameter.
 	*/
@@ -662,7 +741,7 @@ var ParameterProvider = class {
 		}
 		const defaultValue = param?.options.default ?? null;
 		const currentValue = this.getCachedCurrentContent(name) ?? null;
-		const schema = param?.schema ?? null;
+		const schema = param?.schema ? z.toJSONSchema(param.schema) : null;
 		return {
 			current: current ? {
 				...current,
@@ -697,7 +776,7 @@ var ParameterProvider = class {
 	async getParameterTree() {
 		const dbNames = await this.getParameterNames();
 		const registeredNames = Array.from(this.primitives.keys());
-		const allNames = [...new Set([...dbNames, ...registeredNames])].sort();
+		const allNames = [.../* @__PURE__ */ new Set([...dbNames, ...registeredNames])].sort();
 		return this.buildTree(allNames);
 	}
 	/**
@@ -705,13 +784,14 @@ var ParameterProvider = class {
 	* Fetches current and next from database, updates cache.
 	*/
 	async doLoad(name) {
-		const gen = (this.loadGeneration.get(name) ?? 0) + 1;
-		this.loadGeneration.set(name, gen);
+		const ck = this.cacheKey(name);
+		const gen = (this.loadGeneration.get(ck) ?? 0) + 1;
+		this.loadGeneration.set(ck, gen);
 		const { current, next } = await this.loadCurrentAndNext(name);
 		const schemaHash = this.schemaHashes.get(name) ?? "";
-		if (this.loadGeneration.get(name) !== gen) return;
-		if (current && !this.migrationChecked.has(name)) {
-			this.migrationChecked.add(name);
+		if (this.loadGeneration.get(ck) !== gen) return;
+		if (current && !this.migrationChecked.has(ck)) {
+			this.migrationChecked.add(ck);
 			const migration = this.migrateValue(name, current.content, current.schemaHash);
 			if (migration) {
 				this.log.info("Auto-migrating parameter", {
@@ -720,31 +800,33 @@ var ParameterProvider = class {
 				});
 				await this.save(name, migration.value, schemaHash, { changeDescription: migration.description });
 				const updated = await this.loadCurrentAndNext(name);
-				if (updated.current) this.cachedCurrent.set(name, updated.current.content);
-				else this.cachedCurrent.delete(name);
-				if (updated.next) this.cachedNext.set(name, {
+				if (updated.current) this.cachedCurrent.set(ck, updated.current.content);
+				else this.cachedCurrent.delete(ck);
+				if (updated.next) this.cachedNext.set(ck, {
 					content: updated.next.content,
 					activationDate: updated.next.activationDate
 				});
-				else this.cachedNext.delete(name);
-				this.loaded.add(name);
-				this.loadPromises.delete(name);
+				else this.cachedNext.delete(ck);
+				this.loaded.add(ck);
+				this.loadedAt.set(ck, this.dateTimeProvider.nowMillis());
+				this.loadPromises.delete(ck);
 				this.notifySubscribers(name);
 				return;
 			}
 		}
-		const prev = this.cachedCurrent.get(name);
-		const hadPrev = this.cachedCurrent.has(name);
-		if (current) this.cachedCurrent.set(name, current.content);
-		else this.cachedCurrent.delete(name);
-		if (next) this.cachedNext.set(name, {
+		const prev = this.cachedCurrent.get(ck);
+		const hadPrev = this.cachedCurrent.has(ck);
+		if (current) this.cachedCurrent.set(ck, current.content);
+		else this.cachedCurrent.delete(ck);
+		if (next) this.cachedNext.set(ck, {
 			content: next.content,
 			activationDate: next.activationDate
 		});
-		else this.cachedNext.delete(name);
-		this.loaded.add(name);
-		this.loadPromises.delete(name);
-		if (hadPrev && JSON.stringify(prev) !== JSON.stringify(this.cachedCurrent.get(name))) this.notifySubscribers(name);
+		else this.cachedNext.delete(ck);
+		this.loaded.add(ck);
+		this.loadedAt.set(ck, this.dateTimeProvider.nowMillis());
+		this.loadPromises.delete(ck);
+		if (hadPrev && JSON.stringify(prev) !== JSON.stringify(this.cachedCurrent.get(ck))) this.notifySubscribers(name);
 	}
 	/**
 	* Run migration with a distributed lock (Node.js only).
@@ -837,12 +919,13 @@ var ParameterProvider = class {
 	* Reload next version info in background (non-blocking).
 	*/
 	reloadNextInBackground(name) {
+		const ck = this.cacheKey(name);
 		this.loadCurrentAndNext(name).then(({ next }) => {
-			if (next) this.cachedNext.set(name, {
+			if (next) this.cachedNext.set(ck, {
 				content: next.content,
 				activationDate: next.activationDate
 			});
-			else this.cachedNext.delete(name);
+			else this.cachedNext.delete(ck);
 		}).catch((err) => {
 			this.log.warn("Failed to reload next parameter version", {
 				name,
@@ -854,10 +937,11 @@ var ParameterProvider = class {
 	* Notify all subscribers of a value change.
 	*/
 	notifySubscribers(name) {
-		const subs = this.subscribers.get(name);
+		const ck = this.cacheKey(name);
+		const subs = this.subscribers.get(ck);
 		if (!subs) return;
 		const param = this.primitives.get(name);
-		const value = this.cachedCurrent.has(name) ? this.cachedCurrent.get(name) : param?.options.default;
+		const value = this.cachedCurrent.has(ck) ? this.cachedCurrent.get(ck) : param?.options.default;
 		for (const fn of subs) fn(value);
 	}
 	/**
@@ -965,7 +1049,7 @@ var AdminParameterController = class {
 		description: "Get tree structure of all parameter names for navigation.",
 		path: "/parameters/tree",
 		method: "GET",
-		schema: { response: t.array(parameterTreeNodeSchema) },
+		schema: { response: z.array(parameterTreeNodeSchema) },
 		handler: async () => {
 			return this.provider.getParameterTree();
 		}
@@ -996,12 +1080,9 @@ var AdminParameterController = class {
 		method: "GET",
 		schema: {
 			params: parameterNameParamSchema,
-			query: t.object({
-				limit: t.optional(t.integer({
-					minimum: 1,
-					maximum: 100
-				})),
-				offset: t.optional(t.integer({ minimum: 0 }))
+			query: z.object({
+				limit: z.integer().min(1).max(100).optional(),
+				offset: z.integer().min(0).optional()
 			}),
 			response: parameterHistoryResponseSchema
 		},
@@ -1177,11 +1258,8 @@ var AdminParameterController = class {
 		path: "/parameters/delete",
 		method: "POST",
 		schema: {
-			body: t.object({ names: t.array(t.string({ minLength: 1 }), {
-				minItems: 1,
-				maxItems: 1e3
-			}) }),
-			response: t.object({ deleted: t.array(t.string()) })
+			body: z.object({ names: z.array(z.string().min(1)).min(1).max(1e3) }),
+			response: z.object({ deleted: z.array(z.string()) })
 		},
 		handler: async ({ body }) => {
 			const deleted = await this.provider.deleteMany(body.names);