@gamegeek-saikel/dsh-cost-meter 0.1.0

package/lib/index.js

@@ -0,0 +1,2403 @@
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { defineDomain } from "@deepseek-ai/dsh-storage-domain";
+import { z } from "zod";
+import { canonicalHeader } from "@deepseek-ai/dsh-session";
+//#region node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.2/node_modules/@deepseek-ai/cosmokit/lib/index.js
+/** Return true when a value is `null` or `undefined`. */
+function isNullable(value) {
+	return value === null || value === void 0;
+}
+/** Return true for non-array object values. */
+function isPlainObject(data) {
+	return data && typeof data === "object" && !Array.isArray(data);
+}
+/** Filter object entries and return a new object. */
+function filterKeys(object, filter) {
+	return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+/** Map object values while preserving the original key set. */
+function mapValues(object, transform) {
+	return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+/** Pick selected keys from an object, optionally including `undefined` values. */
+function pick(source, keys, forced) {
+	if (!keys) return { ...source };
+	const result = {};
+	for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
+	return result;
+}
+/** Test values using `instanceof` with a `toStringTag` fallback. */
+function is(type, value) {
+	if (arguments.length === 1) return (value) => is(type, value);
+	return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+function isArrayBufferLike(value) {
+	return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+function isArrayBufferSource(value) {
+	return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+/** Binary source detection and base64/hex conversion helpers. */
+var Binary;
+(function(Binary) {
+	Binary.is = isArrayBufferLike;
+	Binary.isSource = isArrayBufferSource;
+	function fromSource(source) {
+		if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+		else return source;
+	}
+	Binary.fromSource = fromSource;
+	function toBase64(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
+		let binary = "";
+		const bytes = new Uint8Array(source);
+		for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	Binary.toBase64 = toBase64;
+	function fromBase64(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+		return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+	}
+	Binary.fromBase64 = fromBase64;
+	function toHex(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+		return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	Binary.toHex = toHex;
+	function fromHex(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+		const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+		const buffer = [];
+		for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+		return Uint8Array.from(buffer).buffer;
+	}
+	Binary.fromHex = fromHex;
+})(Binary || (Binary = {}));
+Binary.fromBase64;
+Binary.toBase64;
+Binary.fromHex;
+Binary.toHex;
+/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
+function clone(source, refs = /* @__PURE__ */ new Map()) {
+	if (!source || typeof source !== "object") return source;
+	if (is("Date", source)) return new Date(source.valueOf());
+	if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+	if (isArrayBufferLike(source)) return source.slice(0);
+	if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+	const cached = refs.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const result = [];
+		refs.set(source, result);
+		source.forEach((value, index) => {
+			result[index] = Reflect.apply(clone, null, [value, refs]);
+		});
+		return result;
+	}
+	const result = Object.create(Object.getPrototypeOf(source));
+	refs.set(source, result);
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+		if ("value" in descriptor) descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+		Reflect.defineProperty(result, key, descriptor);
+	}
+	return result;
+}
+/** Deeply compare arrays, dates, regexps, buffers, and plain object fields. */
+function deepEqual(a, b, strict) {
+	if (a === b) return true;
+	if (!strict && isNullable(a) && isNullable(b)) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a !== "object") return false;
+	if (!a || !b) return false;
+	function check(test, then) {
+		return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+	}
+	return check(Array.isArray, (a, b) => a.length === b.length && a.every((item, index) => deepEqual(item, b[index]))) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
+		if (a.byteLength !== b.byteLength) return false;
+		const viewA = new Uint8Array(a);
+		const viewB = new Uint8Array(b);
+		for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+		return true;
+	}) ?? Object.keys({
+		...a,
+		...b
+	}).every((key) => deepEqual(a[key], b[key], strict));
+}
+/** Time constants plus parsing and formatting helpers. */
+var Time;
+(function(Time) {
+	Time.millisecond = 1;
+	Time.second = 1e3;
+	Time.minute = Time.second * 60;
+	Time.hour = Time.minute * 60;
+	Time.day = Time.hour * 24;
+	Time.week = Time.day * 7;
+	let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+	function setTimezoneOffset(offset) {
+		timezoneOffset = offset;
+	}
+	Time.setTimezoneOffset = setTimezoneOffset;
+	function getTimezoneOffset() {
+		return timezoneOffset;
+	}
+	Time.getTimezoneOffset = getTimezoneOffset;
+	function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+		if (typeof date === "number") date = new Date(date);
+		if (offset === void 0) offset = timezoneOffset;
+		return Math.floor((date.valueOf() / Time.minute - offset) / 1440);
+	}
+	Time.getDateNumber = getDateNumber;
+	function fromDateNumber(value, offset) {
+		const date = new Date(value * Time.day);
+		if (offset === void 0) offset = timezoneOffset;
+		return new Date(+date + offset * Time.minute);
+	}
+	Time.fromDateNumber = fromDateNumber;
+	const numeric = /\d+(?:\.\d+)?/.source;
+	const timeRegExp = new RegExp(`^${[
+		"w(?:eek(?:s)?)?",
+		"d(?:ay(?:s)?)?",
+		"h(?:our(?:s)?)?",
+		"m(?:in(?:ute)?(?:s)?)?",
+		"s(?:ec(?:ond)?(?:s)?)?"
+	].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+	function parseTime(source) {
+		const capture = timeRegExp.exec(source);
+		if (!capture) return 0;
+		return (parseFloat(capture[1]) * Time.week || 0) + (parseFloat(capture[2]) * Time.day || 0) + (parseFloat(capture[3]) * Time.hour || 0) + (parseFloat(capture[4]) * Time.minute || 0) + (parseFloat(capture[5]) * Time.second || 0);
+	}
+	Time.parseTime = parseTime;
+	function parseDate(date) {
+		const parsed = parseTime(date);
+		if (parsed) date = Date.now() + parsed;
+		else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+		else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+		return date ? new Date(date) : /* @__PURE__ */ new Date();
+	}
+	Time.parseDate = parseDate;
+	function format(ms) {
+		const abs = Math.abs(ms);
+		if (abs >= Time.day - Time.hour / 2) return Math.round(ms / Time.day) + "d";
+		else if (abs >= Time.hour - Time.minute / 2) return Math.round(ms / Time.hour) + "h";
+		else if (abs >= Time.minute - Time.second / 2) return Math.round(ms / Time.minute) + "m";
+		else if (abs >= Time.second) return Math.round(ms / Time.second) + "s";
+		return ms + "ms";
+	}
+	Time.format = format;
+	function toDigits(source, length = 2) {
+		return source.toString().padStart(length, "0");
+	}
+	Time.toDigits = toDigits;
+	function template(template, time = /* @__PURE__ */ new Date()) {
+		return template.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+	}
+	Time.template = template;
+})(Time || (Time = {}));
+//#endregion
+//#region node_modules/.pnpm/@deepseek-ai+schemastery@3.18.1/node_modules/@deepseek-ai/schemastery/lib/index.mjs
+const kSchema = Symbol.for("schemastery");
+const kValidationError = Symbol.for("ValidationError");
+globalThis.__schemastery_index__ ??= 0;
+globalThis.__schemastery_refs__ = void 0;
+var ValidationError = class extends TypeError {
+	options;
+	name = "ValidationError";
+	constructor(message, options) {
+		let prefix = "$";
+		for (const segment of options.path || []) if (typeof segment === "string") prefix += "." + segment;
+		else if (typeof segment === "number") prefix += "[" + segment + "]";
+		else if (typeof segment === "symbol") prefix += `[Symbol(${segment.toString()})]`;
+		if (prefix.startsWith(".")) prefix = prefix.slice(1);
+		super((prefix === "$" ? "" : `${prefix} `) + message);
+		this.options = options;
+	}
+	static is(error) {
+		return !!error?.[kValidationError];
+	}
+};
+Object.defineProperty(ValidationError.prototype, kValidationError, { value: true });
+const Schema = function(options) {
+	const schema = function(data, options = {}) {
+		return Schema.resolve(data, schema, options)[0];
+	};
+	if (options.refs) {
+		const refs = mapValues(options.refs, (options) => new Schema(options));
+		const getRef = (uid) => refs[uid];
+		for (const key in refs) {
+			const options = refs[key];
+			options.sKey = getRef(options.sKey);
+			options.inner = getRef(options.inner);
+			options.list = options.list && options.list.map(getRef);
+			options.dict = options.dict && mapValues(options.dict, getRef);
+		}
+		return refs[options.uid];
+	}
+	Object.assign(schema, options);
+	if (typeof schema.callback === "string") try {
+		schema.callback = new Function("return " + schema.callback)();
+	} catch {}
+	Object.defineProperty(schema, "uid", { value: globalThis.__schemastery_index__++ });
+	Object.setPrototypeOf(schema, Schema.prototype);
+	schema.meta ||= {};
+	schema.toString = schema.toString.bind(schema);
+	return schema;
+};
+Schema.prototype = Object.create(Function.prototype);
+Schema.prototype[kSchema] = true;
+Object.defineProperty(Schema.prototype, "~standard", { get() {
+	return {
+		version: 1,
+		vendor: "schemastery",
+		validate: (value) => {
+			try {
+				return { value: Schema.resolve(value, this, {})[0] };
+			} catch (error) {
+				if (ValidationError.is(error)) return { issues: [{
+					message: error.message,
+					path: error.options.path
+				}] };
+				throw error;
+			}
+		}
+	};
+} });
+Schema.ValidationError = ValidationError;
+Schema.prototype.toJSON = function toJSON() {
+	if (globalThis.__schemastery_refs__) {
+		globalThis.__schemastery_refs__[this.uid] ??= JSON.parse(JSON.stringify({ ...this }));
+		return this.uid;
+	}
+	globalThis.__schemastery_refs__ = { [this.uid]: { ...this } };
+	globalThis.__schemastery_refs__[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+	const result = {
+		uid: this.uid,
+		refs: globalThis.__schemastery_refs__
+	};
+	globalThis.__schemastery_refs__ = void 0;
+	return result;
+};
+Schema.prototype.set = function set(key, value) {
+	this.dict[key] = value;
+	return this;
+};
+Schema.prototype.push = function push(value) {
+	this.list.push(value);
+	return this;
+};
+function mergeDesc(original, messages) {
+	const result = typeof original === "string" ? { "": original } : { ...original };
+	for (const locale in messages) {
+		const value = messages[locale];
+		if (value?.$description || value?.$desc) result[locale] = value.$description || value.$desc;
+		else if (typeof value === "string") result[locale] = value;
+	}
+	return result;
+}
+function getInner(value) {
+	return value?.$value ?? value?.$inner;
+}
+function extractKeys(data) {
+	return filterKeys(data ?? {}, (key) => !key.startsWith("$"));
+}
+Schema.prototype.i18n = function i18n(messages) {
+	const schema = Schema(this);
+	const desc = mergeDesc(schema.meta.description, messages);
+	if (Object.keys(desc).length) schema.meta.description = desc;
+	if (schema.dict) schema.dict = mapValues(schema.dict, (inner, key) => {
+		return inner.i18n(mapValues(messages, (data) => getInner(data)?.[key] ?? data?.[key]));
+	});
+	if (schema.list) schema.list = schema.list.map((inner, index) => {
+		return inner.i18n(mapValues(messages, (data = {}) => {
+			if (Array.isArray(getInner(data))) return getInner(data)[index];
+			if (Array.isArray(data)) return data[index];
+			return extractKeys(data);
+		}));
+	});
+	if (schema.inner) schema.inner = schema.inner.i18n(mapValues(messages, (data) => {
+		if (getInner(data)) return getInner(data);
+		return extractKeys(data);
+	}));
+	if (schema.sKey) schema.sKey = schema.sKey.i18n(mapValues(messages, (data) => data?.$key));
+	return schema;
+};
+Schema.prototype.extra = function extra(key, value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+};
+for (const key of [
+	"required",
+	"disabled",
+	"collapse",
+	"hidden",
+	"loose"
+]) Object.assign(Schema.prototype, { [key](value = true) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+Schema.prototype.deprecated = function deprecated() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "deprecated",
+		type: "danger"
+	});
+	return schema;
+};
+Schema.prototype.experimental = function experimental() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "experimental",
+		type: "warning"
+	});
+	return schema;
+};
+Schema.prototype.pattern = function pattern(regexp) {
+	const schema = Schema(this);
+	const pattern = pick(regexp, ["source", "flags"]);
+	schema.meta = {
+		...schema.meta,
+		pattern
+	};
+	return schema;
+};
+Schema.prototype.simplify = function simplify(value) {
+	if (deepEqual(value, this.meta.default, this.type === "dict")) return null;
+	if (isNullable(value)) return value;
+	if (this.type === "object" || this.type === "dict") {
+		const result = {};
+		for (const key in value) {
+			const item = (this.type === "object" ? this.dict[key] : this.inner)?.simplify(value[key]);
+			if (this.type === "dict" || !isNullable(item)) result[key] = item;
+		}
+		if (deepEqual(result, this.meta.default, this.type === "dict")) return null;
+		return result;
+	} else if (this.type === "array" || this.type === "tuple") {
+		const result = [];
+		value.forEach((value, index) => {
+			const schema = this.type === "array" ? this.inner : this.list[index];
+			const item = schema ? schema.simplify(value) : value;
+			result.push(item);
+		});
+		return result;
+	} else if (this.type === "intersect") {
+		const result = {};
+		for (const item of this.list) Object.assign(result, item.simplify(value));
+		return result;
+	} else if (this.type === "union") for (const schema of this.list) try {
+		Schema.resolve(value, schema, {});
+		return schema.simplify(value);
+	} catch {}
+	return value;
+};
+Schema.prototype.toString = function toString(inline) {
+	return formatters[this.type]?.(this, inline) ?? `Schema<${this.type}>`;
+};
+Schema.prototype.role = function role(role, extra) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		role,
+		extra
+	};
+	return schema;
+};
+for (const key of [
+	"default",
+	"link",
+	"comment",
+	"description",
+	"max",
+	"min",
+	"step"
+]) Object.assign(Schema.prototype, { [key](value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+const resolvers = {};
+Schema.extend = function extend(type, resolve) {
+	resolvers[type] = resolve;
+};
+Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
+	if (!schema) return [data];
+	if (options.ignore?.(data, schema)) return [data];
+	if (isNullable(data) && schema.type !== "lazy") {
+		if (schema.meta.required) throw new ValidationError(`missing required value`, options);
+		let current = schema;
+		let fallback = schema.meta.default;
+		while (current?.type === "intersect" && isNullable(fallback)) {
+			current = current.list[0];
+			fallback = current?.meta.default;
+		}
+		if (isNullable(fallback)) return [data];
+		data = clone(fallback);
+	}
+	const callback = resolvers[schema.type];
+	if (!callback) throw new ValidationError(`unsupported type "${schema.type}"`, options);
+	try {
+		return callback(data, schema, options, strict);
+	} catch (error) {
+		if (!schema.meta.loose) throw error;
+		return [schema.meta.default];
+	}
+};
+Schema.from = function from(source) {
+	if (isNullable(source)) return Schema.any();
+	else if ([
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof source)) return Schema.const(source).required();
+	else if (source[kSchema]) return source;
+	else if (typeof source === "function") switch (source) {
+		case String: return Schema.string().required();
+		case Number: return Schema.number().required();
+		case Boolean: return Schema.boolean().required();
+		case Function: return Schema.function().required();
+		default: return Schema.is(source).required();
+	}
+	else throw new TypeError(`cannot infer schema from ${source}`);
+};
+Schema.lazy = function lazy(builder) {
+	const toJSON = () => {
+		if (!schema.inner[kSchema]) {
+			schema.inner = schema.builder();
+			schema.inner.meta = {
+				...schema.meta,
+				...schema.inner.meta
+			};
+		}
+		return schema.inner.toJSON();
+	};
+	const schema = new Schema({
+		type: "lazy",
+		builder,
+		inner: { toJSON }
+	});
+	return schema;
+};
+Schema.natural = function natural() {
+	return Schema.number().step(1).min(0);
+};
+Schema.percent = function percent() {
+	return Schema.number().step(.01).min(0).max(1).role("slider");
+};
+Schema.date = function date() {
+	return Schema.union([Schema.is(Date), Schema.transform(Schema.string().role("datetime"), (value, options) => {
+		const date = new Date(value);
+		if (isNaN(+date)) throw new ValidationError(`invalid date "${value}"`, options);
+		return date;
+	}, true)]);
+};
+Schema.regExp = function regExp(flag = "") {
+	return Schema.union([Schema.is(RegExp), Schema.transform(Schema.string().role("regexp", { flag }), (value, options) => {
+		try {
+			return new RegExp(value, flag);
+		} catch (e) {
+			throw new ValidationError(e.message, options);
+		}
+	}, true)]);
+};
+Schema.arrayBuffer = function arrayBuffer(encoding) {
+	return Schema.union([
+		Schema.is(ArrayBuffer),
+		Schema.is(SharedArrayBuffer),
+		Schema.transform(Schema.any(), (value, options) => {
+			if (Binary.isSource(value)) return Binary.fromSource(value);
+			throw new ValidationError(`expected ArrayBufferSource but got ${value}`, options);
+		}, true),
+		...encoding ? [Schema.transform(Schema.string(), (value, options) => {
+			try {
+				return encoding === "base64" ? Binary.fromBase64(value) : Binary.fromHex(value);
+			} catch (e) {
+				throw new ValidationError(e.message, options);
+			}
+		}, true)] : []
+	]);
+};
+Schema.extend("lazy", (data, schema, options, strict) => {
+	if (!schema.inner[kSchema]) {
+		schema.inner = schema.builder();
+		schema.inner.meta = {
+			...schema.meta,
+			...schema.inner.meta
+		};
+	}
+	return Schema.resolve(data, schema.inner, options, strict);
+});
+Schema.extend("any", (data) => {
+	return [data];
+});
+Schema.extend("never", (data, _, options) => {
+	throw new ValidationError(`expected nullable but got ${data}`, options);
+});
+Schema.extend("const", (data, { value }, options) => {
+	if (deepEqual(data, value)) return [value];
+	throw new ValidationError(`expected ${value} but got ${data}`, options);
+});
+function checkWithinRange(data, meta, description, options, skipMin = false) {
+	const { max = Infinity, min = -Infinity } = meta;
+	if (data > max) throw new ValidationError(`expected ${description} <= ${max} but got ${data}`, options);
+	if (data < min && !skipMin) throw new ValidationError(`expected ${description} >= ${min} but got ${data}`, options);
+}
+Schema.extend("string", (data, { meta }, options) => {
+	if (typeof data !== "string") throw new ValidationError(`expected string but got ${data}`, options);
+	if (meta.pattern) {
+		const regexp = new RegExp(meta.pattern.source, meta.pattern.flags);
+		if (!regexp.test(data)) throw new ValidationError(`expect string to match regexp ${regexp}`, options);
+	}
+	checkWithinRange(data.length, meta, "string length", options);
+	return [data];
+});
+function decimalShift(data, digits) {
+	const str = data.toString();
+	if (str.includes("e")) return data * Math.pow(10, digits);
+	const index = str.indexOf(".");
+	if (index === -1) return data * Math.pow(10, digits);
+	const frac = str.slice(index + 1);
+	const integer = str.slice(0, index);
+	if (frac.length <= digits) return +(integer + frac.padEnd(digits, "0"));
+	return +(integer + frac.slice(0, digits) + "." + frac.slice(digits));
+}
+function isMultipleOf(data, min, step) {
+	step = Math.abs(step);
+	if (!/^\d+\.\d+$/.test(step.toString())) return (data - min) % step === 0;
+	const index = step.toString().indexOf(".");
+	const digits = step.toString().slice(index + 1).length;
+	return Math.abs(decimalShift(data, digits) - decimalShift(min, digits)) % decimalShift(step, digits) === 0;
+}
+Schema.extend("number", (data, { meta }, options) => {
+	if (typeof data !== "number") throw new ValidationError(`expected number but got ${data}`, options);
+	checkWithinRange(data, meta, "number", options);
+	const { step } = meta;
+	if (step && !isMultipleOf(data, meta.min ?? 0, step)) throw new ValidationError(`expected number multiple of ${step} but got ${data}`, options);
+	return [data];
+});
+Schema.extend("boolean", (data, _, options) => {
+	if (typeof data === "boolean") return [data];
+	throw new ValidationError(`expected boolean but got ${data}`, options);
+});
+Schema.extend("bitset", (data, { bits, meta }, options) => {
+	let value = 0, keys = [];
+	if (typeof data === "number") {
+		value = data;
+		for (const key in bits) if (data & bits[key]) keys.push(key);
+	} else if (Array.isArray(data)) {
+		keys = data;
+		for (const key of keys) {
+			if (typeof key !== "string") throw new ValidationError(`expected string but got ${key}`, options);
+			if (key in bits) value |= bits[key];
+		}
+	} else throw new ValidationError(`expected number or array but got ${data}`, options);
+	if (value === meta.default) return [value];
+	return [value, keys];
+});
+Schema.extend("function", (data, _, options) => {
+	if (typeof data === "function") return [data];
+	throw new ValidationError(`expected function but got ${data}`, options);
+});
+Schema.extend("is", (data, { constructor }, options) => {
+	if (typeof constructor === "function") {
+		if (data instanceof constructor) return [data];
+		throw new ValidationError(`expected ${constructor.name} but got ${data}`, options);
+	} else {
+		if (isNullable(data)) throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+		let prototype = Object.getPrototypeOf(data);
+		while (prototype) {
+			if (prototype.constructor?.name === constructor) return [data];
+			prototype = Object.getPrototypeOf(prototype);
+		}
+		throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+	}
+});
+function property(data, key, schema, options) {
+	try {
+		const [value, adapted] = Schema.resolve(data[key], schema, {
+			...options,
+			path: [...options.path || [], key]
+		});
+		if (adapted !== void 0) data[key] = adapted;
+		return value;
+	} catch (e) {
+		if (!options?.autofix) throw e;
+		delete data[key];
+		return schema.meta.default;
+	}
+}
+Schema.extend("array", (data, { inner, meta }, options) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	checkWithinRange(data.length, meta, "array length", options, !isNullable(inner.meta.default));
+	return [data.map((_, index) => property(data, index, inner, options))];
+});
+Schema.extend("dict", (data, { inner, sKey }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in data) {
+		let rKey;
+		try {
+			rKey = Schema.resolve(key, sKey, options)[0];
+		} catch (error) {
+			if (strict) continue;
+			throw error;
+		}
+		result[rKey] = property(data, key, inner, options);
+		data[rKey] = data[key];
+		if (key !== rKey) delete data[key];
+	}
+	return [result];
+});
+Schema.extend("tuple", (data, { list }, options, strict) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	const result = list.map((inner, index) => property(data, index, inner, options));
+	if (strict) return [result];
+	result.push(...data.slice(list.length));
+	return [result];
+});
+function merge(result, data) {
+	for (const key in data) {
+		if (key in result) continue;
+		result[key] = data[key];
+	}
+}
+Schema.extend("object", (data, { dict }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in dict) {
+		const value = property(data, key, dict[key], options);
+		if (!isNullable(value) || key in data) result[key] = value;
+	}
+	if (!strict) merge(result, data);
+	return [result];
+});
+Schema.extend("union", (data, { list, toString }, options, strict) => {
+	const messages = [];
+	for (const inner of list) try {
+		return Schema.resolve(data, inner, options, strict);
+	} catch (error) {
+		messages.push(error);
+	}
+	throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+});
+Schema.extend("intersect", (data, { list, toString }, options, strict) => {
+	if (!list.length) return [data];
+	let result;
+	for (const inner of list) {
+		const value = Schema.resolve(data, inner, options, true)[0];
+		if (isNullable(value)) continue;
+		if (isNullable(result)) result = value;
+		else if (typeof result !== typeof value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+		else if (typeof value === "object") merge(result ??= {}, value);
+		else if (result !== value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+	}
+	if (!strict && isPlainObject(data)) merge(result, data);
+	return [result];
+});
+Schema.extend("transform", (data, { inner, callback, preserve }, options) => {
+	const [result, adapted = data] = Schema.resolve(data, inner, options, true);
+	if (preserve) return [callback(result)];
+	else return [callback(result), callback(adapted)];
+});
+const formatters = {};
+function defineMethod(name, keys, format) {
+	formatters[name] = format;
+	Object.assign(Schema, { [name](...args) {
+		const schema = new Schema({ type: name });
+		keys.forEach((key, index) => {
+			switch (key) {
+				case "sKey":
+					schema.sKey = args[index] ?? Schema.string();
+					break;
+				case "inner":
+					schema.inner = Schema.from(args[index]);
+					break;
+				case "list":
+					schema.list = args[index].map(Schema.from);
+					break;
+				case "dict":
+					schema.dict = mapValues(args[index], Schema.from);
+					break;
+				case "bits":
+					schema.bits = {};
+					for (const key in args[index]) {
+						if (typeof args[index][key] !== "number") continue;
+						schema.bits[key] = args[index][key];
+					}
+					break;
+				case "callback": {
+					const callback = schema.callback = args[index];
+					callback["toJSON"] ||= () => callback.toString();
+					break;
+				}
+				case "constructor": {
+					const constructor = schema.constructor = args[index];
+					if (typeof constructor === "function") constructor["toJSON"] ||= () => constructor["name"];
+					break;
+				}
+				default: schema[key] = args[index];
+			}
+		});
+		if (name === "object" || name === "dict") schema.meta.default = {};
+		else if (name === "array" || name === "tuple") schema.meta.default = [];
+		else if (name === "bitset") schema.meta.default = 0;
+		return schema;
+	} });
+}
+defineMethod("is", ["constructor"], ({ constructor }) => {
+	if (typeof constructor === "function") return constructor.name;
+	else return constructor;
+});
+defineMethod("any", [], () => "any");
+defineMethod("never", [], () => "never");
+defineMethod("const", ["value"], ({ value }) => typeof value === "string" ? JSON.stringify(value) : value);
+defineMethod("string", [], () => "string");
+defineMethod("number", [], () => "number");
+defineMethod("boolean", [], () => "boolean");
+defineMethod("bitset", ["bits"], () => "bitset");
+defineMethod("function", [], () => "function");
+defineMethod("array", ["inner"], ({ inner }) => `${inner.toString(true)}[]`);
+defineMethod("dict", ["inner", "sKey"], ({ inner, sKey }) => `{ [key: ${sKey.toString()}]: ${inner.toString()} }`);
+defineMethod("tuple", ["list"], ({ list }) => `[${list.map((inner) => inner.toString()).join(", ")}]`);
+defineMethod("object", ["dict"], ({ dict }) => {
+	if (Object.keys(dict).length === 0) return "{}";
+	return `{ ${Object.entries(dict).map(([key, inner]) => {
+		return `${key}${inner.meta.required ? "" : "?"}: ${inner.toString()}`;
+	}).join(", ")} }`;
+});
+defineMethod("union", ["list"], ({ list }, inline) => {
+	const result = list.map(({ toString: format }) => format()).join(" | ");
+	return inline ? `(${result})` : result;
+});
+defineMethod("intersect", ["list"], ({ list }) => {
+	return `${list.map((inner) => inner.toString(true)).join(" & ")}`;
+});
+defineMethod("transform", [
+	"inner",
+	"callback",
+	"preserve"
+], ({ inner }, isInner) => inner.toString(isInner));
+//#endregion
+//#region src/pricing.ts
+/** Official pricing page URL (zh-cn). */
+const PRICING_URL = "https://api-docs.deepseek.com/zh-cn/quick_start/pricing/";
+/** Official pricing page URL (en). */
+const PRICING_URL_EN = "https://api-docs.deepseek.com/quick_start/pricing/";
+/** Official peak-pricing rollout: 2026-08-17 00:00 Beijing time (UTC+8). */
+const PEAK_PRICING_START_MS = Date.UTC(2026, 7, 16, 16, 0, 0);
+/**
+* Built-in fallback prices: the official list for deepseek-v4-flash and
+* deepseek-v4-pro (CNY per 1M tokens). DeepSeek bills cache writes at the
+* uncached input price (its wire usage reports only cache-hit vs cache-miss
+* buckets), so no separate cache-write rate exists.
+*/
+const FALLBACK_CURRENT = {
+	flash: {
+		cacheReadPerMillion: .02,
+		inputPerMillion: 1,
+		outputPerMillion: 2
+	},
+	pro: {
+		cacheReadPerMillion: .025,
+		inputPerMillion: 3,
+		outputPerMillion: 6
+	}
+};
+/**
+* Built-in fallback for the upcoming peak table: the 2026-08-17 schedule
+* (peak hours double the off-peak half).
+*/
+const FALLBACK_PEAK = {
+	flash: {
+		offPeak: {
+			cacheReadPerMillion: .05,
+			inputPerMillion: 1.5,
+			outputPerMillion: 4.5
+		},
+		peak: {
+			cacheReadPerMillion: .1,
+			inputPerMillion: 3,
+			outputPerMillion: 9
+		}
+	},
+	pro: {
+		offPeak: {
+			cacheReadPerMillion: .15,
+			inputPerMillion: 4.5,
+			outputPerMillion: 13.5
+		},
+		peak: {
+			cacheReadPerMillion: .3,
+			inputPerMillion: 9,
+			outputPerMillion: 27
+		}
+	}
+};
+/** Built-in fallback USD prices from the English pricing page. */
+const FALLBACK_CURRENT_USD = {
+	flash: {
+		cacheReadPerMillion: .007,
+		inputPerMillion: .22,
+		outputPerMillion: .66
+	},
+	pro: {
+		cacheReadPerMillion: .022,
+		inputPerMillion: .66,
+		outputPerMillion: 1.98
+	}
+};
+/** Built-in fallback USD peak table from the English pricing page. */
+const FALLBACK_PEAK_USD = {
+	flash: {
+		offPeak: { ...FALLBACK_CURRENT_USD.flash },
+		peak: {
+			cacheReadPerMillion: .014,
+			inputPerMillion: .44,
+			outputPerMillion: 1.32
+		}
+	},
+	pro: {
+		offPeak: { ...FALLBACK_CURRENT_USD.pro },
+		peak: {
+			cacheReadPerMillion: .044,
+			inputPerMillion: 1.32,
+			outputPerMillion: 3.96
+		}
+	}
+};
+/** Number regex: `0.02`, `1`, `2`, `3.0` etc. Deliberately non-global: a
+* shared global regex leaks `lastIndex` across `exec` calls and would skip
+* the second price cell (the pro price). */
+const PRICE_RE = /(\d+(?:\.\d+)?)\s*元/;
+/** Strip HTML tags to plain text (keeps cell order). */
+function stripHtml(html) {
+	return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/\s+/g, " ").trim();
+}
+/** Parse one price cell text like `0.02元` into a number; undefined when absent. */
+function parsePriceCell(text) {
+	const match = PRICE_RE.exec(text);
+	if (match === null) return void 0;
+	const value = Number(match[1]);
+	return Number.isFinite(value) ? value : void 0;
+}
+function secondPriceCell(text) {
+	return text.replace(/^\s*(\d+(?:\.\d+)?元)/, "");
+}
+/**
+* Parse the current single-price table: three rows labeled with the bucket
+* names, each carrying the flash and pro price cells.
+* @param html - the raw pricing page.
+* @returns the parsed table, or undefined when the labels are absent.
+*/
+function parseCurrentTable(html) {
+	const hit = /百万tokens输入（缓存命中）([\s\S]{0,400}?)百万tokens输入（缓存未命中）([\s\S]{0,400}?)百万tokens输出([\s\S]{0,400}?)(?:并发限制|<\/table)/i.exec(stripHtml(html));
+	if (hit === null) return void 0;
+	const cacheReadCell = hit[1] ?? "";
+	const inputCell = hit[2] ?? "";
+	const outputCell = hit[3] ?? "";
+	const cacheReadFlash = parsePriceCell(cacheReadCell);
+	const cacheReadPro = parsePriceCell(secondPriceCell(cacheReadCell));
+	const inputFlash = parsePriceCell(inputCell);
+	const inputPro = parsePriceCell(secondPriceCell(inputCell));
+	const outputFlash = parsePriceCell(outputCell);
+	const outputPro = parsePriceCell(secondPriceCell(outputCell));
+	if (cacheReadFlash === void 0 || inputFlash === void 0 || outputFlash === void 0) return;
+	return {
+		flash: {
+			cacheReadPerMillion: cacheReadFlash,
+			inputPerMillion: inputFlash,
+			outputPerMillion: outputFlash
+		},
+		pro: {
+			cacheReadPerMillion: cacheReadPro ?? cacheReadFlash,
+			inputPerMillion: inputPro ?? inputFlash,
+			outputPerMillion: outputPro ?? outputFlash
+		}
+	};
+}
+/**
+* Parse the upcoming peak-pricing table: model rows with off-peak and peak
+* cells, e.g. `deepseek-v4-flash 空闲时段 0.05 1.5 4.5 高峰时段 0.10 3.0 9.0`.
+* @param html - the raw pricing page.
+* @returns the parsed table, or undefined when either model row is absent.
+*/
+function parsePeakTable(html) {
+	const text = stripHtml(html);
+	const flash = /deepseek-v4-flash\s+空闲时段\s+(\d+(?:\.\d+)?)元\s+(\d+(?:\.\d+)?)元\s+(\d+(?:\.\d+)?)元\s+高峰时段\s+(\d+(?:\.\d+)?)元\s+(\d+(?:\.\d+)?)元\s+(\d+(?:\.\d+)?)元/i.exec(text);
+	const pro = /deepseek-v4-pro\s+空闲时段\s+(\d+(?:\.\d+)?)元\s+(\d+(?:\.\d+)?)元\s+(\d+(?:\.\d+)?)元\s+高峰时段\s+(\d+(?:\.\d+)?)元\s+(\d+(?:\.\d+)?)元\s+(\d+(?:\.\d+)?)元/i.exec(text);
+	if (flash === null || pro === null) return void 0;
+	return {
+		flash: {
+			offPeak: {
+				cacheReadPerMillion: Number(flash[1]),
+				inputPerMillion: Number(flash[2]),
+				outputPerMillion: Number(flash[3])
+			},
+			peak: {
+				cacheReadPerMillion: Number(flash[4]),
+				inputPerMillion: Number(flash[5]),
+				outputPerMillion: Number(flash[6])
+			}
+		},
+		pro: {
+			offPeak: {
+				cacheReadPerMillion: Number(pro[1]),
+				inputPerMillion: Number(pro[2]),
+				outputPerMillion: Number(pro[3])
+			},
+			peak: {
+				cacheReadPerMillion: Number(pro[4]),
+				inputPerMillion: Number(pro[5]),
+				outputPerMillion: Number(pro[6])
+			}
+		}
+	};
+}
+/**
+* Parse the English current single-price table.
+* @param html - the raw English pricing page.
+* @returns the parsed table, or undefined when the labels are absent.
+*/
+/**
+* Parse the English combined pricing table. The English page lists all three
+* buckets as rows with OFF-PEAK and PEAK cells, so we extract both the current
+* off-peak list and the peak table from the same markup.
+*/
+function parseEnglishPricing(html) {
+	const text = stripHtml(html);
+	const hit = /1M INPUT TOKENS \(CACHE HIT\)\s+OFF-PEAK\s+\$?\s*(\d+(?:\.\d+)?)\s+\$?\s*(\d+(?:\.\d+)?)\s+PEAK\s+\$?\s*(\d+(?:\.\d+)?)\s+\$?\s*(\d+(?:\.\d+)?)\s+1M INPUT TOKENS \(CACHE MISS\)\s+OFF-PEAK\s+\$?\s*(\d+(?:\.\d+)?)\s+\$?\s*(\d+(?:\.\d+)?)\s+PEAK\s+\$?\s*(\d+(?:\.\d+)?)\s+\$?\s*(\d+(?:\.\d+)?)\s+1M OUTPUT TOKENS\s+OFF-PEAK\s+\$?\s*(\d+(?:\.\d+)?)\s+\$?\s*(\d+(?:\.\d+)?)\s+PEAK\s+\$?\s*(\d+(?:\.\d+)?)\s+\$?\s*(\d+(?:\.\d+)?)/i.exec(text);
+	if (hit === null) return void 0;
+	const n = (index) => Number(hit[index]);
+	return {
+		current: {
+			flash: {
+				cacheReadPerMillion: n(1),
+				inputPerMillion: n(5),
+				outputPerMillion: n(9)
+			},
+			pro: {
+				cacheReadPerMillion: n(2),
+				inputPerMillion: n(6),
+				outputPerMillion: n(10)
+			}
+		},
+		peak: {
+			flash: {
+				offPeak: {
+					cacheReadPerMillion: n(1),
+					inputPerMillion: n(5),
+					outputPerMillion: n(9)
+				},
+				peak: {
+					cacheReadPerMillion: n(3),
+					inputPerMillion: n(7),
+					outputPerMillion: n(11)
+				}
+			},
+			pro: {
+				offPeak: {
+					cacheReadPerMillion: n(2),
+					inputPerMillion: n(6),
+					outputPerMillion: n(10)
+				},
+				peak: {
+					cacheReadPerMillion: n(4),
+					inputPerMillion: n(8),
+					outputPerMillion: n(12)
+				}
+			}
+		}
+	};
+}
+/**
+* Parse the English current single-price table.
+* @param html - the raw English pricing page.
+* @returns the parsed table, or undefined when the labels are absent.
+*/
+function parseCurrentTableEn(html) {
+	return parseEnglishPricing(html)?.current;
+}
+/**
+* Parse the English upcoming peak-pricing table.
+* @param html - the raw English pricing page.
+* @returns the parsed table, or undefined when either model row is absent.
+*/
+function parsePeakTableEn(html) {
+	return parseEnglishPricing(html)?.peak;
+}
+/**
+* Fetch and parse the official pricing page.
+* @param fetchImpl - fetch-compatible function (injected for testability).
+* @param timeoutMs - abort timeout.
+* @returns the parsed snapshot; `error` is set when fetch/parse failed.
+*/
+async function fetchPricing(fetchImpl = globalThis.fetch, timeoutMs = 15e3, locale = "zh") {
+	const fetchedAt = Date.now();
+	const currency = locale === "en" ? "USD" : "CNY";
+	const url = locale === "en" ? PRICING_URL_EN : PRICING_URL;
+	const parseCurrent = locale === "en" ? parseCurrentTableEn : parseCurrentTable;
+	const parsePeak = locale === "en" ? parsePeakTableEn : parsePeakTable;
+	const fallbackCurrent = locale === "en" ? FALLBACK_CURRENT_USD : FALLBACK_CURRENT;
+	try {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), timeoutMs);
+		let response;
+		try {
+			response = await fetchImpl(url, { signal: controller.signal });
+		} finally {
+			clearTimeout(timer);
+		}
+		if (!response.ok) return {
+			fetchedAt,
+			currency,
+			current: fallbackCurrent,
+			peakActive: false,
+			effective: fallbackCurrent,
+			error: `pricing page HTTP ${response.status}`
+		};
+		const html = await response.text();
+		const current = parseCurrent(html);
+		if (current === void 0) return {
+			fetchedAt,
+			currency,
+			current: fallbackCurrent,
+			peakActive: false,
+			effective: fallbackCurrent,
+			error: "pricing table not found"
+		};
+		const peak = parsePeak(html);
+		const now = Date.now();
+		const peakActive = now >= PEAK_PRICING_START_MS;
+		return {
+			fetchedAt,
+			currency,
+			current,
+			...peak === void 0 ? {} : { peak },
+			peakActive,
+			effective: effectivePricing(current, peak, peakActive, new Date(now)),
+			...peakActive ? { band: isPeakHour(new Date(now)) ? "peak" : "offPeak" } : {}
+		};
+	} catch (error) {
+		return {
+			fetchedAt,
+			currency,
+			current: fallbackCurrent,
+			peakActive: false,
+			effective: fallbackCurrent,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/**
+* Whether the current moment is a peak-pricing hour in Beijing time:
+* 09:00-12:00 and 14:00-18:00 (peak); everything else is off-peak.
+* @param now - the instant to classify.
+* @returns true during peak hours.
+*/
+function isPeakHour(now = /* @__PURE__ */ new Date()) {
+	const parts = new Intl.DateTimeFormat("en-US", {
+		timeZone: "Asia/Shanghai",
+		hour: "numeric",
+		hour12: false
+	}).formatToParts(now);
+	const hour = Number(parts.find((part) => part.type === "hour")?.value);
+	if (Number.isNaN(hour)) return false;
+	return hour >= 9 && hour < 12 || hour >= 14 && hour < 18;
+}
+/**
+* The price bucket in effect for one model at the given moment: the
+* peak/off-peak band once the rollout is live (with the parsed table, or the
+* built-in fallback), otherwise the current official list.
+* @param current - the current list prices.
+* @param peak - the upcoming peak table, when parsed.
+* @param peakActive - whether the rollout has started.
+* @param now - the instant to price for.
+* @param model - `flash` or `pro`.
+* @returns the bucket to apply.
+*/
+function effectiveBucket(current, peak, peakActive, now, model) {
+	if (peakActive) {
+		const table = peak?.[model] ?? FALLBACK_PEAK[model];
+		return isPeakHour(now) ? table.peak : table.offPeak;
+	}
+	return current[model];
+}
+/** Per-model effective prices at the given moment. */
+function effectivePricing(current, peak, peakActive, now) {
+	return {
+		flash: effectiveBucket(current, peak, peakActive, now, "flash"),
+		pro: effectiveBucket(current, peak, peakActive, now, "pro")
+	};
+}
+//#endregion
+//#region src/pricebook.ts
+/** Default manual rate used when auto-fetch fails and nothing was ever fetched. */
+const DEFAULT_FX_RATE = 7.2;
+/** Default OpenRouter cache-read fraction of the uncached input price. */
+const DEFAULT_CACHE_READ_DISCOUNT = .25;
+/** Default OpenRouter model-id → canonical key aliases (editable). */
+const DEFAULT_ALIASES = {
+	"deepseek/deepseek-chat": "deepseek-v4-flash",
+	"deepseek/deepseek-reasoner": "deepseek-v4-pro"
+};
+/** Free exchange-rate endpoint (no key); returns `rates.CNY` for USD base. */
+const FX_API_URL = "https://open.er-api.com/v6/latest/USD";
+/** OpenRouter models directory (prices in USD per token). */
+const OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+/** Default cap on the persisted snapshot history. */
+const DEFAULT_SNAPSHOT_HISTORY_LIMIT = 50;
+const bucketSchema = z.object({
+	cacheReadPerMillion: z.number().nonnegative(),
+	inputPerMillion: z.number().nonnegative(),
+	outputPerMillion: z.number().nonnegative()
+}).strict();
+const modelPriceSchema$1 = z.object({
+	source: z.enum([
+		"manual",
+		"official",
+		"fallback",
+		"openrouter",
+		"none"
+	]),
+	single: bucketSchema.optional(),
+	offPeak: bucketSchema.optional(),
+	peak: bucketSchema.optional()
+}).strict();
+const snapshotSchema = z.object({
+	version: z.number().int().positive(),
+	currency: z.enum(["CNY", "USD"]).default("CNY"),
+	effectiveAt: z.number().int().nonnegative(),
+	source: z.enum([
+		"manual",
+		"official",
+		"fallback",
+		"openrouter",
+		"none"
+	]),
+	usdCnyRate: z.number().nullable(),
+	prices: z.record(z.string(), modelPriceSchema$1)
+}).strict();
+const fxSchema = z.object({
+	mode: z.enum(["auto", "manual"]),
+	manualRate: z.number().positive(),
+	lastAutoRate: z.number().positive().optional(),
+	rateFetchedAt: z.number().int().nonnegative().optional()
+}).strict();
+const pricebookStateSchema = z.object({
+	snapshots: z.array(snapshotSchema),
+	overrides: z.record(z.string(), modelPriceSchema$1),
+	aliases: z.record(z.string(), z.string()),
+	cacheReadDiscount: z.number().min(0).max(1),
+	fx: fxSchema,
+	balanceEnabled: z.boolean(),
+	openRouterEnabled: z.boolean(),
+	updatedAt: z.number().int().nonnegative()
+}).strict();
+/** Fresh pricebook state before any user configuration exists. */
+function initialPricebookState() {
+	return {
+		snapshots: [],
+		overrides: {},
+		aliases: { ...DEFAULT_ALIASES },
+		cacheReadDiscount: DEFAULT_CACHE_READ_DISCOUNT,
+		fx: {
+			mode: "auto",
+			manualRate: DEFAULT_FX_RATE
+		},
+		balanceEnabled: true,
+		openRouterEnabled: true,
+		updatedAt: 0
+	};
+}
+/**
+* The pricebook storage domain. One global slot holds the whole state; the
+* domain name (`pricebook`) is unused by any shipped row, so the open never
+* collides with `already-open`.
+*/
+const PRICEBOOK_DOMAIN = defineDomain({
+	name: "pricebook",
+	version: 1,
+	global: {
+		schema: pricebookStateSchema,
+		initial: initialPricebookState()
+	},
+	tables: {}
+});
+/** USD pricebook storage domain, kept separate from the CNY domain. */
+const PRICEBOOK_DOMAIN_USD = defineDomain({
+	name: "pricebook_usd",
+	version: 1,
+	global: {
+		schema: pricebookStateSchema,
+		initial: initialPricebookState()
+	},
+	tables: {}
+});
+/**
+* Map a model id to its official pricing key: anything containing `pro`
+* prices as pro, `flash` as flash. Mirror of the client-side helper.
+* @param model - the model id.
+* @returns the pricing key.
+*/
+function pricingKeyOfModel(model) {
+	return model.toLowerCase().includes("pro") ? "pro" : "flash";
+}
+/**
+* Candidate canonical price keys for one model, most specific first. The
+* pricing-key fallbacks (`pro`/`flash`) only apply to DeepSeek-family models
+* (id or provider names deepseek): an unrelated model must NOT silently pick
+* up the flash list price — it either resolves through an override, an
+* OpenRouter alias, or stays unpriced.
+* @param provider - the provider route, when known.
+* @param model - the model id.
+* @returns candidate keys in lookup order.
+*/
+function modelKeys(provider, model) {
+	const keys = [];
+	if (provider !== void 0 && provider.length > 0) keys.push(`${provider}/${model}`);
+	keys.push(model);
+	if (model.toLowerCase().includes("deepseek") || provider !== void 0 && provider.toLowerCase().includes("deepseek")) keys.push(pricingKeyOfModel(model));
+	return keys;
+}
+/**
+* The price band in effect at one instant: pre-rollout single price, or the
+* peak/off-peak band once the rollout is live.
+* @param time - epoch millis.
+* @returns the band.
+*/
+function bandForTime(time) {
+	if (time < PEAK_PRICING_START_MS) return "single";
+	return isPeakHour(new Date(time)) ? "peak" : "offPeak";
+}
+/**
+* The bucket of one model's price entry for one band, with graceful
+* degradation to whatever tier exists.
+* @param modelPrice - the model's price entry.
+* @param band - the band to price for.
+* @returns the bucket, or undefined when the entry carries no tier at all.
+*/
+function bucketOf(modelPrice, band) {
+	if (band === "single") return modelPrice.single ?? modelPrice.offPeak ?? modelPrice.peak;
+	if (band === "peak") return modelPrice.peak ?? modelPrice.offPeak ?? modelPrice.single;
+	return modelPrice.offPeak ?? modelPrice.peak ?? modelPrice.single;
+}
+/**
+* Resolve one model's bucket at one instant from its price entry.
+* @param modelPrice - the model's price entry.
+* @param time - the instant to price for.
+* @returns the bucket and band, or null when the entry has no tier.
+*/
+function priceAt(modelPrice, time) {
+	const band = bandForTime(time);
+	const bucket = bucketOf(modelPrice, band);
+	return bucket === void 0 ? null : {
+		bucket,
+		band
+	};
+}
+/**
+* Pick the snapshot effective at `time`: the newest with `effectiveAt <=
+* time`, or the earliest available when no snapshot predates it (pre-install
+* sessions anchor to the first snapshot once, as required).
+* @param snapshots - the snapshot history, any order.
+* @param time - the instant to anchor.
+* @returns the snapshot, or undefined when the history is empty.
+*/
+function snapshotForTime(snapshots, time) {
+	let best;
+	for (const snapshot of snapshots) if (snapshot.effectiveAt <= time && (best === void 0 || snapshot.effectiveAt >= best.effectiveAt)) best = snapshot;
+	return best ?? (snapshots.length > 0 ? snapshots[0] : void 0);
+}
+/**
+* The official cost formula, per million tokens: uncached input + cache
+* reads at the hit rate + cache writes at the uncached input rate (DeepSeek
+* reports only hit/miss buckets and bills writes as misses) + output.
+* @param usage - the step's token buckets.
+* @param bucket - the effective price bucket.
+* @returns the cost in the bucket's currency (CNY).
+*/
+function stepCost(usage, bucket) {
+	return (usage.uncached * bucket.inputPerMillion + usage.cacheRead * bucket.cacheReadPerMillion + usage.cacheWrite * bucket.inputPerMillion + usage.output * bucket.outputPerMillion) / 1e6;
+}
+function bucketEqual(left, right) {
+	if (left === void 0 || right === void 0) return left === right;
+	return Math.abs(left.cacheReadPerMillion - right.cacheReadPerMillion) < 1e-9 && Math.abs(left.inputPerMillion - right.inputPerMillion) < 1e-9 && Math.abs(left.outputPerMillion - right.outputPerMillion) < 1e-9;
+}
+function modelPriceEqual(left, right) {
+	if (left.source !== right.source) return false;
+	return bucketEqual(left.single, right.single) && bucketEqual(left.offPeak, right.offPeak) && bucketEqual(left.peak, right.peak);
+}
+/**
+* Whether two per-model price tables are equivalent (epsilon-compared).
+* Used to skip a new snapshot when a refresh changed nothing user-visible.
+*/
+function pricesEqual(left, right) {
+	const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
+	for (const key of keys) {
+		const a = left[key];
+		const b = right[key];
+		if (a === void 0 || b === void 0) return false;
+		if (!modelPriceEqual(a, b)) return false;
+	}
+	return true;
+}
+/** Effective USD→CNY rate from the configured mode plus fallbacks. */
+function effectiveRate(fx, defaultRate) {
+	if (fx.mode === "manual") return fx.manualRate;
+	return fx.lastAutoRate ?? fx.manualRate ?? defaultRate;
+}
+/** Whether one canonical key already resolves to a non-OpenRouter (domestic) price. */
+function hasDomesticPrice(prices, key) {
+	return (key.includes("/") ? [key] : [key, pricingKeyOfModel(key)]).some((candidate) => {
+		const entry = prices[candidate];
+		return entry !== void 0 && entry.source !== "openrouter";
+	});
+}
+/**
+* Merge every source into one per-model price table through the priority
+* chain: manual overrides win; official (or the built-in fallback when the
+* page failed) covers the flash/pro pricing keys; OpenRouter covers only
+* models with no domestic price (fallback-only, USD→CNY, cache reads at the
+* configured discount). OpenRouter prices land under the aliased canonical
+* key so unaliased model ids still resolve through the key chain.
+* @param state - the pricebook state (overrides, aliases, discount, fx).
+* @param official - the official-page input (fallback table on failure).
+* @param openrouter - the OpenRouter input, or null when disabled/failed.
+* @param usdCnyRate - the effective exchange rate.
+* @param defaultRate - the configuration default rate (fallback chain end).
+* @returns the merged table and the highest-priority contributing source.
+*/
+function computePricebook(state, official, openrouter, usdCnyRate, defaultRate, fallbackPeak = FALLBACK_PEAK, currency = "CNY") {
+	const prices = {};
+	for (const [key, override] of Object.entries(state.overrides)) prices[key] = {
+		...override,
+		source: "manual"
+	};
+	const officialSource = official.error === void 0 ? "official" : "fallback";
+	for (const key of ["flash", "pro"]) {
+		if (prices[key] !== void 0) continue;
+		const peakTable = official.peak ?? fallbackPeak;
+		prices[key] = {
+			source: officialSource,
+			single: official.current[key],
+			offPeak: peakTable[key].offPeak,
+			peak: peakTable[key].peak
+		};
+	}
+	const openRouterFx = currency === "USD" ? 1 : usdCnyRate;
+	if (openrouter !== null && openrouter.error === void 0 && (currency === "USD" || usdCnyRate > 0)) {
+		const discount = state.cacheReadDiscount;
+		for (const [orId, usd] of Object.entries(openrouter.usdPrices)) {
+			const alias = state.aliases[orId] ?? orId;
+			if (hasDomesticPrice(prices, alias)) continue;
+			if (hasDomesticPrice(prices, orId)) continue;
+			const entry = {
+				source: "openrouter",
+				single: {
+					cacheReadPerMillion: usd.inputPerMillionUsd * discount * openRouterFx,
+					inputPerMillion: usd.inputPerMillionUsd * openRouterFx,
+					outputPerMillion: usd.outputPerMillionUsd * openRouterFx
+				}
+			};
+			prices[alias] = entry;
+			if (alias !== orId) prices[orId] = entry;
+		}
+	}
+	let primary = "none";
+	for (const candidate of [
+		"manual",
+		"official",
+		"fallback",
+		"openrouter"
+	]) if (Object.values(prices).some((entry) => entry.source === candidate)) {
+		primary = candidate;
+		break;
+	}
+	return {
+		prices,
+		primarySource: primary
+	};
+}
+/**
+* Fetch the USD→CNY rate from the free endpoint. Never throws; the caller
+* applies the fallback chain (last auto rate → manual/default rate).
+* @param fetchImpl - fetch-compatible function (injected for testability).
+* @param url - the endpoint.
+* @param timeoutMs - abort timeout.
+* @returns the fresh rate, or an error result.
+*/
+async function fetchFxRate(fetchImpl = globalThis.fetch, url = FX_API_URL, timeoutMs = 1e4) {
+	try {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), timeoutMs);
+		let response;
+		try {
+			response = await fetchImpl(url, { signal: controller.signal });
+		} finally {
+			clearTimeout(timer);
+		}
+		if (!response.ok) return {
+			rate: null,
+			error: `fx endpoint HTTP ${response.status}`
+		};
+		const wire = await response.json();
+		const cny = Number(wire.rates?.CNY);
+		if (!Number.isFinite(cny) || cny <= 0) return {
+			rate: null,
+			error: "fx response carries no rates.CNY"
+		};
+		return { rate: cny };
+	} catch (error) {
+		return {
+			rate: null,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/**
+* Fetch the OpenRouter models directory and fold it into USD-per-1M-token
+* buckets. Every entry with a valid prompt/completion price is kept: the
+* directory is small (a few hundred rows) and the alias map is editable, so
+* a newly aliased model must resolve without waiting for the next refresh.
+* Never throws.
+* @param fetchImpl - fetch-compatible function (injected for testability).
+* @param url - the directory endpoint.
+* @param timeoutMs - abort timeout.
+* @param aliases - the current alias map (kept for parity, not used as a filter).
+* @returns the model price table, or an error result.
+*/
+async function fetchOpenRouter(fetchImpl = globalThis.fetch, url = OPENROUTER_MODELS_URL, timeoutMs = 15e3, aliases = DEFAULT_ALIASES) {
+	try {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), timeoutMs);
+		let response;
+		try {
+			response = await fetchImpl(url, { signal: controller.signal });
+		} finally {
+			clearTimeout(timer);
+		}
+		if (!response.ok) return {
+			usdPrices: {},
+			error: `openrouter models HTTP ${response.status}`
+		};
+		const wire = await response.json();
+		const usdPrices = {};
+		for (const entry of wire.data ?? []) {
+			if (typeof entry.id !== "string" || entry.pricing === void 0) continue;
+			const prompt = Number(entry.pricing.prompt);
+			const completion = Number(entry.pricing.completion);
+			if (!Number.isFinite(prompt) || !Number.isFinite(completion) || prompt <= 0 || completion <= 0) continue;
+			usdPrices[entry.id] = {
+				inputPerMillionUsd: prompt * 1e6,
+				outputPerMillionUsd: completion * 1e6
+			};
+		}
+		return { usdPrices };
+	} catch (error) {
+		return {
+			usdPrices: {},
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/** Fold a raw {@link PricingSnapshot} into the pricebook's official input. */
+function officialInputOf(snapshot) {
+	return {
+		current: snapshot.current,
+		...snapshot.peak === void 0 ? {} : { peak: snapshot.peak },
+		...snapshot.error === void 0 ? {} : { error: snapshot.error }
+	};
+}
+/**
+* The synchronous read face the sessionCost projection folds against, plus
+* the mutation/refresh/persist surface the plugin's apply and route use.
+* Reads never touch the domain (mirror only); writes update the mirror first,
+* then queue a fail-soft durable write.
+*/
+var PricebookHandle = class {
+	ctx;
+	config;
+	currency;
+	/** The authoritative in-memory state (mirror of the domain global). */
+	state;
+	domain;
+	persistTail = Promise.resolve();
+	lastOfficial;
+	lastOpenRouter = null;
+	lastFxError;
+	fetchedAt = 0;
+	constructor(ctx, config, persisted, currency = "CNY") {
+		this.ctx = ctx;
+		this.config = config;
+		this.currency = currency;
+		this.state = persisted ?? {
+			...initialPricebookState(),
+			openRouterEnabled: config.openRouterEnabled
+		};
+		this.lastOfficial = { current: currency === "USD" ? FALLBACK_CURRENT_USD : FALLBACK_CURRENT };
+	}
+	/**
+	* Open the storage domain and adopt the persisted state. Never throws:
+	* a missing storageDomain or a failed open degrades to in-memory only.
+	*/
+	async init() {
+		const storageDomain = this.ctx.get("storageDomain");
+		if (storageDomain === void 0) return;
+		try {
+			const domain = this.currency === "USD" ? PRICEBOOK_DOMAIN_USD : PRICEBOOK_DOMAIN;
+			this.domain = await storageDomain.open(domain);
+			this.state = this.domain.global.get();
+		} catch (error) {
+			console.warn(`cost-meter: pricebook domain unavailable, keeping in-memory state: ${error instanceof Error ? error.message : String(error)}`);
+			this.domain = void 0;
+		}
+	}
+	/** Queue one durable write of the whole state (fail-soft, serialized). */
+	persist() {
+		if (this.domain === void 0) return;
+		const state = this.state;
+		this.persistTail = this.persistTail.then(() => this.domain.global.set(state)).catch((error) => {
+			console.warn(`cost-meter: pricebook persist failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
+	}
+	/** Resolve once every queued durable write has settled. */
+	async whenIdle() {
+		await this.persistTail;
+	}
+	/** Release the domain (called from the plugin's disposer). */
+	async close() {
+		await this.whenIdle();
+		if (this.domain !== void 0) {
+			const domain = this.domain;
+			this.domain = void 0;
+			await domain.close();
+		}
+	}
+	/** The newest snapshot, or undefined before the first refresh. */
+	currentSnapshot() {
+		const snapshots = this.state.snapshots;
+		return snapshots.length > 0 ? snapshots[snapshots.length - 1] : void 0;
+	}
+	/** Pick the snapshot effective at `time`. */
+	snapshotFor(time) {
+		return snapshotForTime(this.state.snapshots, time);
+	}
+	/**
+	* Resolve the price of one model at one instant through the key chain and
+	* the anchored snapshot. Synchronous: the fold calls this per usage event.
+	* @param provider - the provider route, when known.
+	* @param model - the model id.
+	* @param time - the instant to price for.
+	* @returns the hit, or null when no source carries a price.
+	*/
+	priceFor(provider, model, time) {
+		const snapshot = this.snapshotFor(time);
+		if (snapshot === void 0) return null;
+		for (const key of modelKeys(provider, model)) {
+			const entry = snapshot.prices[key];
+			if (entry === void 0) continue;
+			const hit = priceAt(entry, time);
+			if (hit === null) continue;
+			return {
+				bucket: hit.bucket,
+				band: hit.band,
+				source: entry.source,
+				snapshotVersion: snapshot.version,
+				snapshotEffectiveAt: snapshot.effectiveAt
+			};
+		}
+		return null;
+	}
+	/** The effective USD→CNY rate under the current configuration. */
+	rate() {
+		return effectiveRate(this.state.fx, this.config.defaultFxRate);
+	}
+	/** Cap the snapshot history to the configured limit (newest kept). */
+	capSnapshots() {
+		const limit = this.config.snapshotHistoryLimit;
+		if (this.state.snapshots.length > limit) this.state = {
+			...this.state,
+			snapshots: this.state.snapshots.slice(-limit)
+		};
+	}
+	/**
+	* Recompute the resolved table from the cached inputs and start a new
+	* snapshot when anything user-visible changed. Shared by the startup
+	* refresh, the periodic refresh, the manual refresh, and every settings
+	* mutation.
+	*/
+	recompute(now) {
+		const openrouter = this.config.openRouterEnabled ? this.lastOpenRouter : null;
+		const { prices, primarySource } = computePricebook(this.state, this.lastOfficial, openrouter, this.rate(), this.config.defaultFxRate, this.currency === "USD" ? FALLBACK_PEAK_USD : FALLBACK_PEAK, this.currency);
+		const last = this.currentSnapshot();
+		if (last !== void 0 && pricesEqual(last.prices, prices)) return;
+		const snapshot = {
+			version: (last?.version ?? 0) + 1,
+			currency: this.currency,
+			effectiveAt: now,
+			source: primarySource,
+			usdCnyRate: this.rate(),
+			prices
+		};
+		this.state = {
+			...this.state,
+			snapshots: [...this.state.snapshots, snapshot],
+			updatedAt: now
+		};
+		this.capSnapshots();
+		this.persist();
+	}
+	/**
+	* Refresh every remote source (official page, exchange rate, OpenRouter
+	* when enabled) and re-anchor a snapshot on change. Never throws.
+	* @param options - injected results (testability); omitted values are fetched.
+	*/
+	async refresh(options) {
+		const official = options?.official ?? await fetchPricing(globalThis.fetch, 15e3, this.currency === "USD" ? "en" : "zh");
+		this.lastOfficial = officialInputOf(official);
+		this.lastFxError = void 0;
+		if (options?.fx !== void 0) this.applyFxResult(options.fx.rate, options.fx.error);
+		else if (this.state.fx.mode === "auto") {
+			const fx = await fetchFxRate(globalThis.fetch, this.config.fxApiUrl);
+			this.applyFxResult(fx.rate, fx.error);
+		}
+		if (this.state.openRouterEnabled) this.lastOpenRouter = options?.openrouter ?? await fetchOpenRouter(globalThis.fetch, this.config.openRouterModelsUrl, 15e3, this.state.aliases);
+		else this.lastOpenRouter = null;
+		this.fetchedAt = Date.now();
+		this.recompute(this.fetchedAt);
+	}
+	applyFxResult(rate, error) {
+		this.lastFxError = error;
+		if (rate !== null) this.state = {
+			...this.state,
+			fx: {
+				...this.state.fx,
+				lastAutoRate: rate,
+				rateFetchedAt: Date.now()
+			}
+		};
+	}
+	/** Apply a settings mutation and re-anchor (snapshot on change). */
+	mutate(mutator) {
+		this.state = mutator(this.state);
+		this.recompute(Date.now());
+		this.persist();
+	}
+	async setOverrides(overrides) {
+		this.mutate((state) => ({
+			...state,
+			overrides
+		}));
+		await this.whenIdle();
+	}
+	async setAliases(aliases) {
+		this.state = {
+			...this.state,
+			aliases
+		};
+		if (this.state.openRouterEnabled) this.lastOpenRouter = await fetchOpenRouter(globalThis.fetch, this.config.openRouterModelsUrl, 15e3, aliases);
+		this.recompute(Date.now());
+		await this.whenIdle();
+	}
+	async setCacheReadDiscount(discount) {
+		this.mutate((state) => ({
+			...state,
+			cacheReadDiscount: discount
+		}));
+		await this.whenIdle();
+	}
+	async setFx(mode, manualRate) {
+		this.mutate((state) => ({
+			...state,
+			fx: {
+				...state.fx,
+				mode,
+				manualRate
+			}
+		}));
+		await this.whenIdle();
+	}
+	async setBalanceEnabled(enabled) {
+		this.mutate((state) => ({
+			...state,
+			balanceEnabled: enabled
+		}));
+		await this.whenIdle();
+	}
+	async setOpenRouterEnabled(enabled) {
+		this.mutate((state) => ({
+			...state,
+			openRouterEnabled: enabled
+		}));
+		await this.whenIdle();
+	}
+	/**
+	* Apply a resolved plugin-settings snapshot (the `cost-meter`
+	* settings namespace) to the pricebook: the editable configuration fields
+	* overwrite the persisted state and the resolved table re-anchors (a new
+	* snapshot starts when anything user-visible changed). Never throws.
+	* @param settings - the settings-section value (may carry only a subset).
+	*/
+	applySettings(settings) {
+		try {
+			let next = this.state;
+			if (settings.overrides !== void 0) next = {
+				...next,
+				overrides: settings.overrides
+			};
+			if (settings.aliases !== void 0) next = {
+				...next,
+				aliases: settings.aliases
+			};
+			if (settings.cacheReadDiscount !== void 0) next = {
+				...next,
+				cacheReadDiscount: settings.cacheReadDiscount
+			};
+			if (settings.fxMode !== void 0 || settings.manualRate !== void 0) next = {
+				...next,
+				fx: {
+					...next.fx,
+					...settings.fxMode === void 0 ? {} : { mode: settings.fxMode },
+					...settings.manualRate === void 0 ? {} : { manualRate: settings.manualRate }
+				}
+			};
+			if (settings.balanceEnabled !== void 0) next = {
+				...next,
+				balanceEnabled: settings.balanceEnabled
+			};
+			if (settings.openRouterEnabled !== void 0) next = {
+				...next,
+				openRouterEnabled: settings.openRouterEnabled
+			};
+			if (next === this.state) return;
+			this.state = next;
+			if (settings.aliases !== void 0 && next.openRouterEnabled) fetchOpenRouter(globalThis.fetch, this.config.openRouterModelsUrl, 15e3, next.aliases).then((result) => {
+				if (result.error === void 0) this.lastOpenRouter = result;
+			}).catch(() => {});
+			this.recompute(Date.now());
+			this.persist();
+		} catch (error) {
+			console.warn(`cost-meter: settings apply failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/** The read-side payload for the route. */
+	view() {
+		const errors = {};
+		if (this.lastOfficial.error !== void 0) errors.official = this.lastOfficial.error;
+		if (this.lastFxError !== void 0) errors.fx = this.lastFxError;
+		if (this.lastOpenRouter?.error !== void 0) errors.openRouter = this.lastOpenRouter.error;
+		return {
+			currency: this.currency,
+			current: this.currentSnapshot() ?? null,
+			snapshots: this.state.snapshots,
+			overrides: this.state.overrides,
+			aliases: this.state.aliases,
+			cacheReadDiscount: this.state.cacheReadDiscount,
+			fx: this.state.fx,
+			balanceEnabled: this.state.balanceEnabled,
+			openRouterEnabled: this.state.openRouterEnabled,
+			fetchedAt: this.fetchedAt,
+			...Object.keys(errors).length > 0 ? { errors } : {}
+		};
+	}
+};
+//#endregion
+//#region src/session-cost-projection.ts
+const zeroTotals = () => ({
+	uncachedCost: 0,
+	cacheReadCost: 0,
+	outputCost: 0,
+	cost: 0,
+	pricedSteps: 0,
+	unpricedSteps: 0,
+	steps: 0
+});
+/** Wire schema of the projection value (validated before it leaves the host). */
+const projectionSchema = z.object({
+	model: z.object({
+		provider: z.string(),
+		model: z.string()
+	}).nullable(),
+	steps: z.array(z.object({
+		turn: z.number().int().nonnegative(),
+		step: z.number().int().nonnegative(),
+		time: z.number().int().nonnegative(),
+		model: z.string(),
+		provider: z.string().optional(),
+		uncachedInputTokens: z.number().int().nonnegative(),
+		cacheReadTokens: z.number().int().nonnegative(),
+		cacheWriteTokens: z.number().int().nonnegative(),
+		outputTokens: z.number().int().nonnegative(),
+		uncachedCost: z.number().nonnegative(),
+		cacheReadCost: z.number().nonnegative(),
+		outputCost: z.number().nonnegative(),
+		cost: z.number().nullable(),
+		priced: z.boolean(),
+		unpricedReason: z.enum(["NO_MODEL", "NO_PRICE"]).optional(),
+		snapshotVersion: z.number().int().nonnegative().nullable(),
+		snapshotEffectiveAt: z.number().int().nonnegative().nullable(),
+		band: z.enum([
+			"peak",
+			"offPeak",
+			"single"
+		]).nullable()
+	}).strict()),
+	totals: z.object({
+		uncachedCost: z.number().nonnegative(),
+		cacheReadCost: z.number().nonnegative(),
+		outputCost: z.number().nonnegative(),
+		cost: z.number().nonnegative(),
+		pricedSteps: z.number().int().nonnegative(),
+		unpricedSteps: z.number().int().nonnegative(),
+		steps: z.number().int().nonnegative()
+	}).strict()
+}).strict();
+/** Extract the disjoint token buckets from a wire usage object. */
+function usageBuckets(usage) {
+	return {
+		uncached: usage.inputTokens,
+		cacheRead: usage.cacheReadTokens ?? 0,
+		cacheWrite: usage.cacheWriteTokens ?? 0,
+		output: usage.outputTokens
+	};
+}
+function bucketsEmpty(usage) {
+	return usage.uncached === 0 && usage.cacheRead === 0 && usage.cacheWrite === 0 && usage.output === 0;
+}
+/** Replace totals with one step, subtracting its predecessor when present. */
+function replaceTotals(totals, step, previous) {
+	const subtract = (value) => previous === void 0 ? 0 : value;
+	return {
+		uncachedCost: totals.uncachedCost - subtract(previous?.uncachedCost ?? 0) + step.uncachedCost,
+		cacheReadCost: totals.cacheReadCost - subtract(previous?.cacheReadCost ?? 0) + step.cacheReadCost,
+		outputCost: totals.outputCost - subtract(previous?.outputCost ?? 0) + step.outputCost,
+		cost: totals.cost - subtract(previous?.cost ?? 0) + (step.cost ?? 0),
+		pricedSteps: totals.pricedSteps - (previous?.priced === true ? 1 : 0) + (step.priced ? 1 : 0),
+		unpricedSteps: totals.unpricedSteps - (previous?.priced === false ? 1 : 0) + (step.priced ? 0 : 1),
+		steps: totals.steps - (previous === void 0 ? 0 : 1) + 1
+	};
+}
+function sameStep(left, right) {
+	return left.uncachedInputTokens === right.uncachedInputTokens && left.cacheReadTokens === right.cacheReadTokens && left.cacheWriteTokens === right.cacheWriteTokens && left.outputTokens === right.outputTokens && left.cost === right.cost && left.snapshotVersion === right.snapshotVersion && left.band === right.band;
+}
+/**
+* Fold one committed event onto the ledger. Pure except for synchronous
+* pricebook mirror reads; returns the same state reference for events the
+* unit does not own (the framework's zero-work contract).
+* @param state - the state covering all prior events.
+* @param event - the next committed session event.
+* @param pricebook - the pricebook read face.
+* @returns the next state.
+*/
+function foldSessionCost(state, event, pricebook) {
+	if (event.type === "request/header") {
+		const header = canonicalHeader(event.data.header);
+		const model = {
+			provider: header.config.provider,
+			model: header.config.model
+		};
+		if (state.model !== null && state.model.provider === model.provider && state.model.model === model.model) return state;
+		return {
+			...state,
+			model
+		};
+	}
+	let turn;
+	let step;
+	let usage;
+	if (event.type === "assistant/chunk" && event.data.chunk.type === "usage") {
+		turn = event.data.turn;
+		step = event.data.step;
+		usage = event.data.chunk.usage;
+	} else if (event.type === "assistant/message" && event.data.usage !== void 0) {
+		turn = event.data.turn;
+		step = event.data.step;
+		usage = event.data.usage;
+	} else return state;
+	const buckets = usageBuckets(usage);
+	if (bucketsEmpty(buckets)) return state;
+	const key = `${turn}:${step}`;
+	const previous = state.steps[key];
+	const model = state.model;
+	const hit = model === null ? null : pricebook.priceFor(model.provider, model.model, event.time);
+	const unpricedReason = hit === null ? model === null ? "NO_MODEL" : "NO_PRICE" : void 0;
+	const uncachedCost = hit === null ? 0 : (buckets.uncached + buckets.cacheWrite) * hit.bucket.inputPerMillion / 1e6;
+	const cacheReadCost = hit === null ? 0 : buckets.cacheRead * hit.bucket.cacheReadPerMillion / 1e6;
+	const outputCost = hit === null ? 0 : buckets.output * hit.bucket.outputPerMillion / 1e6;
+	const record = {
+		turn,
+		step,
+		time: event.time,
+		model: model?.model ?? "unknown",
+		...model?.provider === void 0 ? {} : { provider: model.provider },
+		uncachedInputTokens: buckets.uncached,
+		cacheReadTokens: buckets.cacheRead,
+		cacheWriteTokens: buckets.cacheWrite,
+		outputTokens: buckets.output,
+		uncachedCost,
+		cacheReadCost,
+		outputCost,
+		cost: hit === null ? null : uncachedCost + cacheReadCost + outputCost,
+		priced: hit !== null,
+		...unpricedReason === void 0 ? {} : { unpricedReason },
+		snapshotVersion: hit?.snapshotVersion ?? null,
+		snapshotEffectiveAt: hit?.snapshotEffectiveAt ?? null,
+		band: hit?.band ?? null
+	};
+	if (previous !== void 0 && sameStep(previous, record)) return state;
+	return {
+		...state,
+		steps: {
+			...state.steps,
+			[key]: record
+		},
+		totals: replaceTotals(state.totals, record, previous)
+	};
+}
+/** State → wire payload: steps ordered by turn then step. */
+function viewSessionCost(state) {
+	const steps = Object.values(state.steps).sort((left, right) => left.turn - right.turn || left.step - right.step);
+	return {
+		model: state.model,
+		steps,
+		totals: state.totals
+	};
+}
+/**
+* The projection unit. The fold reads the pricebook mirror synchronously;
+* the unit never touches the domain itself.
+* @param pricebook - the pricebook read face (in-memory mirror).
+* @returns the definition to register with `ctx.sessionProjections`.
+*/
+function sessionCostProjection(pricebook, key) {
+	return {
+		key,
+		schema: projectionSchema,
+		init: () => ({
+			model: null,
+			steps: {},
+			totals: zeroTotals()
+		}),
+		apply: (state, event) => foldSessionCost(state, event, pricebook),
+		view: viewSessionCost,
+		stateVersion: 1
+	};
+}
+//#endregion
+//#region src/subagent-cost.ts
+const ZERO_TOTALS = {
+	uncachedCost: 0,
+	cacheReadCost: 0,
+	outputCost: 0,
+	cost: 0,
+	pricedSteps: 0,
+	unpricedSteps: 0,
+	steps: 0
+};
+/**
+* Collect every live descendant session of `rootSessionId` (BFS over the
+* runtime ownership relation) with its anchored cost totals.
+* @param rootSessionId - the root conversation's session id.
+* @param agents - the agents service (live registry).
+* @param sessions - the sessions service (session store).
+* @param projections - the sessionProjections service.
+* @returns one entry per descendant with a priced or unpriced ledger;
+*   empty when the root has no live agent or no descendants.
+*/
+function collectSubagentCosts(rootSessionId, agents, sessions, projections, projectionKey = "sessionCost") {
+	const rootAgent = agents.get(rootSessionId);
+	if (rootAgent === void 0) return [];
+	const result = [];
+	const seen = /* @__PURE__ */ new Set([rootSessionId]);
+	const queue = [rootAgent];
+	while (queue.length > 0) {
+		const parent = queue.shift();
+		for (const candidate of agents.list()) {
+			const candidateId = String(candidate.session.id);
+			if (seen.has(candidateId)) continue;
+			if (!agents.isOwnedBy(candidateId, parent)) continue;
+			seen.add(candidateId);
+			queue.push(candidate);
+			const session = sessions.get(candidateId);
+			if (session === void 0) continue;
+			const cost = projections.snapshot(session).values[projectionKey];
+			if (cost === void 0) continue;
+			result.push({
+				sessionId: candidateId,
+				totals: cost.totals ?? { ...ZERO_TOTALS }
+			});
+		}
+	}
+	return result;
+}
+/** Sum several totals into one (empty list → the zero totals). */
+function sumTotals(totals) {
+	const sum = { ...ZERO_TOTALS };
+	for (const totalsEntry of totals) {
+		sum.uncachedCost += totalsEntry.uncachedCost;
+		sum.cacheReadCost += totalsEntry.cacheReadCost;
+		sum.outputCost += totalsEntry.outputCost;
+		sum.cost += totalsEntry.cost;
+		sum.pricedSteps += totalsEntry.pricedSteps;
+		sum.unpricedSteps += totalsEntry.unpricedSteps;
+		sum.steps += totalsEntry.steps;
+	}
+	return sum;
+}
+//#endregion
+//#region src/index.ts
+/** Stable Cordis plugin name. */
+const name = "cost-meter";
+/** Services required before the route and the projection can register. */
+const inject = ["webServer", "sessionProjections"];
+/** Public DeepSeek API base; the internal endpoint comes from config `baseURL`. */
+const PUBLIC_BASE_URL = "https://api.deepseek.com";
+/** Default credential reference, matching the llm-deepseek adapter. */
+const DEFAULT_API_KEY_ENV = "DEEPSEEK_API_KEY";
+/** How long a successful balance snapshot stays fresh (milliseconds). */
+const DEFAULT_REFRESH_MS = 6e4;
+/** How long a failed refresh stays cached before retrying (milliseconds). */
+const FAILED_REFRESH_MS = 1e4;
+/** Per-request timeout for the provider balance call (milliseconds). */
+const BALANCE_TIMEOUT_MS = 1e4;
+/** Default cadence for re-fetching the official pricing page (hours). */
+const DEFAULT_PRICING_REFRESH_HOURS = 6;
+/** Max POST body accepted by the settings route (bytes). */
+const MAX_BODY_BYTES = 262144;
+const modelPriceSchema = Schema.object({
+	single: Schema.object({
+		cacheReadPerMillion: Schema.number().min(0),
+		inputPerMillion: Schema.number().min(0),
+		outputPerMillion: Schema.number().min(0)
+	}),
+	offPeak: Schema.object({
+		cacheReadPerMillion: Schema.number().min(0),
+		inputPerMillion: Schema.number().min(0),
+		outputPerMillion: Schema.number().min(0)
+	}),
+	peak: Schema.object({
+		cacheReadPerMillion: Schema.number().min(0),
+		inputPerMillion: Schema.number().min(0),
+		outputPerMillion: Schema.number().min(0)
+	})
+});
+const Config = Schema.object({
+	apiKeyEnv: Schema.string().role("credential-ref").default(DEFAULT_API_KEY_ENV),
+	baseURL: Schema.string().default(PUBLIC_BASE_URL),
+	refreshMs: Schema.natural().min(1e3).default(DEFAULT_REFRESH_MS),
+	pricingRefreshHours: Schema.number().min(1).default(6),
+	trustedHosts: Schema.array(Schema.string()).default([]),
+	fxApiUrl: Schema.string().default(FX_API_URL),
+	defaultFxRate: Schema.number().min(.001).default(DEFAULT_FX_RATE),
+	openRouterModelsUrl: Schema.string().default(OPENROUTER_MODELS_URL),
+	openRouterEnabled: Schema.boolean().default(true),
+	snapshotHistoryLimit: Schema.natural().min(1).default(50),
+	overrides: Schema.dict(modelPriceSchema, Schema.string()).default({}),
+	aliases: Schema.dict(Schema.string(), Schema.string()).default({ ...DEFAULT_ALIASES }),
+	cacheReadDiscount: Schema.number().min(0).max(1).default(DEFAULT_CACHE_READ_DISCOUNT),
+	fxMode: Schema.union(["auto", "manual"]).default("auto"),
+	manualRate: Schema.number().min(.001).default(DEFAULT_FX_RATE),
+	balanceEnabled: Schema.boolean().default(true)
+});
+/** Normalized authority of a Host-header value, or undefined when unparsable. */
+function parseAuthority(authority) {
+	try {
+		return new URL(`http://${authority}`);
+	} catch {
+		return;
+	}
+}
+/**
+* Whether a normalized URL hostname names the local loopback authority.
+* @param hostname - WHATWG URL hostname (IPv6 literals retain brackets).
+* @returns true for localhost, IPv6 loopback, or any IPv4 address in 127/8.
+*/
+function isLoopbackHostname(hostname) {
+	if (hostname === "localhost" || hostname === "[::1]") return true;
+	const parts = hostname.split(".");
+	return parts.length === 4 && parts[0] === "127" && parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255);
+}
+/**
+* Browser-trust fence for the balance route, mirroring the /api fence: the
+* Host header is the one header DNS rebinding cannot forge, and loopback or
+* a declared trusted authority passes.
+* @param headers - request headers.
+* @param trustedHosts - non-loopback authorities this deployment serves.
+* @returns true when the request Host is ours.
+*/
+function isTrustedRequest(headers, trustedHosts) {
+	const host = headers.host;
+	if (typeof host !== "string" || host.length === 0) return false;
+	const hostUrl = parseAuthority(host);
+	if (hostUrl === void 0) return false;
+	if (isLoopbackHostname(hostUrl.hostname)) return true;
+	return trustedHosts.some((entry) => {
+		const entryUrl = parseAuthority(entry);
+		return entryUrl !== void 0 && entryUrl.host === hostUrl.host;
+	});
+}
+/**
+* Resolve the API key for one refresh: the credential seam first, the
+* process environment as fallback when no seam is composed.
+* @param ctx - host context.
+* @param env - the credential reference name.
+* @returns the resolved key, or undefined when absent everywhere.
+*/
+async function resolveApiKey(ctx, env) {
+	const credentials = ctx.get("credentials");
+	if (credentials !== void 0) {
+		const hit = await credentials.resolve(credentialRef(env));
+		if (hit !== void 0 && hit.value.length > 0) return hit.value;
+	}
+	const ambient = process.env[env];
+	return ambient !== void 0 && ambient.length > 0 ? ambient : void 0;
+}
+/**
+* Parse the first balance row, converting the provider's decimal strings to
+* numbers.
+* @param wire - the parsed provider response.
+* @returns the first row, or null when the response carried no rows.
+*/
+function pickBalanceInfo(wire) {
+	const info = wire.balance_infos?.[0];
+	if (info === void 0) return null;
+	return {
+		currency: info.currency,
+		total: Number(info.total_balance),
+		granted: Number(info.granted_balance ?? 0),
+		toppedUp: Number(info.topped_up_balance ?? 0)
+	};
+}
+/**
+* One provider balance call: resolve the key, GET /user/balance, and fold
+* the result into a {@link BalanceSnapshot}. Never throws — every failure
+* becomes an ok:false snapshot.
+* @param ctx - host context.
+* @param config - resolved plugin facts.
+* @returns the folded snapshot.
+*/
+async function fetchBalance(ctx, config) {
+	const key = await resolveApiKey(ctx, config.apiKeyEnv);
+	if (key === void 0) return {
+		ok: false,
+		code: "MISSING_CREDENTIAL",
+		message: `cost-meter: no API key for "${config.apiKeyEnv}"; store it through the credentials service or export it in the launching environment`
+	};
+	let response;
+	try {
+		response = await fetch(`${config.baseURL}/user/balance`, {
+			headers: { authorization: `Bearer ${key}` },
+			signal: AbortSignal.timeout(BALANCE_TIMEOUT_MS)
+		});
+	} catch (error) {
+		return {
+			ok: false,
+			code: "NETWORK",
+			message: `cost-meter: balance request failed: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+	if (!response.ok) return {
+		ok: false,
+		code: `HTTP_${response.status}`,
+		message: `cost-meter: balance endpoint answered ${response.status} ${response.statusText}`
+	};
+	let wire;
+	try {
+		wire = await response.json();
+	} catch (error) {
+		return {
+			ok: false,
+			code: "INVALID_RESPONSE",
+			message: `cost-meter: balance body unparsable: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+	return {
+		ok: true,
+		isAvailable: wire.is_available === true,
+		balance: pickBalanceInfo(wire),
+		fetchedAt: Date.now()
+	};
+}
+/** Read a bounded JSON request body. */
+async function readBody(req) {
+	const chunks = [];
+	let total = 0;
+	for await (const chunk of req) {
+		const part = chunk;
+		total += part.length;
+		if (total > MAX_BODY_BYTES) throw new Error("body too large");
+		chunks.push(part);
+	}
+	const text = Buffer.concat(chunks).toString("utf8");
+	if (text.length === 0) return {};
+	return JSON.parse(text);
+}
+/** The `cost-meter` settings namespace (plugin configuration page). */
+const SETTINGS_NAMESPACE = settingsNamespace("cost-meter");
+/**
+* Mount the plugin: open the pricebook domain, refresh every remote source,
+* register the `sessionCost` projection, register the /cost-meter
+* route (GET view + POST settings/refresh), and keep the balance and the
+* official pricing fresh.
+* @param ctx - host context.
+* @param config - plugin config (schema defaults applied by the Loader).
+*/
+async function apply(ctx, config) {
+	const resolved = {
+		apiKeyEnv: config?.apiKeyEnv ?? "DEEPSEEK_API_KEY",
+		baseURL: config?.baseURL ?? "https://api.deepseek.com",
+		refreshMs: config?.refreshMs ?? 6e4,
+		pricingRefreshHours: config?.pricingRefreshHours ?? 6,
+		trustedHosts: config?.trustedHosts ?? [],
+		fxApiUrl: config?.fxApiUrl ?? "https://open.er-api.com/v6/latest/USD",
+		defaultFxRate: config?.defaultFxRate ?? 7.2,
+		openRouterModelsUrl: config?.openRouterModelsUrl ?? "https://openrouter.ai/api/v1/models",
+		openRouterEnabled: config?.openRouterEnabled ?? true,
+		snapshotHistoryLimit: config?.snapshotHistoryLimit ?? 50
+	};
+	const pricebookConfig = {
+		fxApiUrl: resolved.fxApiUrl,
+		defaultFxRate: resolved.defaultFxRate,
+		openRouterModelsUrl: resolved.openRouterModelsUrl,
+		openRouterEnabled: resolved.openRouterEnabled,
+		snapshotHistoryLimit: resolved.snapshotHistoryLimit
+	};
+	const pricebookCny = new PricebookHandle(ctx, pricebookConfig, void 0, "CNY");
+	const pricebookUsd = new PricebookHandle(ctx, pricebookConfig, void 0, "USD");
+	await Promise.all([pricebookCny.init(), pricebookUsd.init()]);
+	await Promise.all([pricebookCny.refresh(), pricebookUsd.refresh()]);
+	ctx.effect(() => () => {
+		pricebookCny.close();
+		pricebookUsd.close();
+	}, "cost-meter: pricebook domains");
+	let currentSettings = () => config ?? {};
+	installSettingsSection(ctx, SETTINGS_NAMESPACE, Config, config ?? {}, {
+		setSource: (source) => {
+			currentSettings = source;
+		},
+		onChange: () => {
+			const settings = currentSettings();
+			pricebookCny.applySettings(settings);
+			pricebookUsd.applySettings(settings);
+		}
+	});
+	ctx.effect(() => ctx.sessionProjections.register(sessionCostProjection(pricebookCny, "sessionCost")), "cost-meter: sessionCost projection");
+	ctx.effect(() => ctx.sessionProjections.register(sessionCostProjection(pricebookUsd, "sessionCostUsd")), "cost-meter: sessionCostUsd projection");
+	let lastBalance;
+	let inflight;
+	const refresh = () => {
+		const now = Date.now();
+		const ttl = lastBalance === void 0 ? 0 : lastBalance.snapshot.ok ? resolved.refreshMs : FAILED_REFRESH_MS;
+		if (lastBalance !== void 0 && now - lastBalance.at < ttl) return Promise.resolve(lastBalance.snapshot);
+		if (inflight === void 0) inflight = fetchBalance(ctx, resolved).then((snapshot) => {
+			lastBalance = {
+				at: Date.now(),
+				snapshot
+			};
+			inflight = void 0;
+			return snapshot;
+		}, (error) => {
+			inflight = void 0;
+			return {
+				ok: false,
+				code: "INTERNAL",
+				message: `cost-meter: ${error instanceof Error ? error.message : String(error)}`
+			};
+		});
+		return inflight;
+	};
+	const pricingTimer = setInterval(() => {
+		pricebookCny.refresh();
+		pricebookUsd.refresh();
+	}, resolved.pricingRefreshHours * 36e5);
+	pricingTimer.unref?.();
+	ctx.effect(() => () => clearInterval(pricingTimer), "cost-meter: pricing refresh timer");
+	const respond = (res, status, body) => {
+		res.writeHead(status, {
+			"content-type": "application/json; charset=utf-8",
+			"cache-control": "no-store"
+		});
+		res.end(JSON.stringify(body));
+	};
+	/** Parse the `session` query parameter (the requesting session id). */
+	const sessionOf = (req) => {
+		try {
+			const value = new URL(req.url ?? "/", "http://localhost").searchParams.get("session");
+			return value === null || value.length === 0 ? void 0 : value;
+		} catch {
+			return;
+		}
+	};
+	/** Parse the `currency` query parameter; defaults to CNY. */
+	const currencyOf = (req) => {
+		try {
+			return new URL(req.url ?? "/", "http://localhost").searchParams.get("currency") === "USD" ? "USD" : "CNY";
+		} catch {
+			return "CNY";
+		}
+	};
+	const buildResponse = async (rootSessionId, currency) => {
+		const agents = ctx.get("agents");
+		const sessionsStore = ctx.get("sessions");
+		const pricebook = currency === "USD" ? pricebookUsd : pricebookCny;
+		const projectionKey = currency === "USD" ? "sessionCostUsd" : "sessionCost";
+		const subagents = rootSessionId === void 0 || agents === void 0 || sessionsStore === void 0 ? [] : collectSubagentCosts(rootSessionId, agents, sessionsStore, ctx.sessionProjections, projectionKey);
+		return {
+			balance: await refresh(),
+			pricebook: pricebook.view(),
+			subagents
+		};
+	};
+	const route = {
+		kind: "exact",
+		path: "/cost-meter",
+		handler: async (req, res) => {
+			if (req.method !== "GET" && req.method !== "POST") {
+				res.writeHead(405, { allow: "GET, POST" });
+				res.end("method not allowed");
+				return;
+			}
+			if (!isTrustedRequest(req.headers, resolved.trustedHosts)) {
+				res.writeHead(403);
+				res.end("forbidden");
+				return;
+			}
+			if (req.method === "POST") {
+				try {
+					const body = await readBody(req);
+					if (body.action !== "refresh") throw new Error(`unknown action "${String(body.action)}"`);
+				} catch (error) {
+					respond(res, 400, { error: error instanceof Error ? error.message : String(error) });
+					return;
+				}
+				try {
+					await Promise.all([pricebookCny.refresh(), pricebookUsd.refresh()]);
+				} catch (error) {
+					respond(res, 500, { error: error instanceof Error ? error.message : String(error) });
+					return;
+				}
+				respond(res, 200, await buildResponse(sessionOf(req), currencyOf(req)));
+				return;
+			}
+			respond(res, 200, await buildResponse(sessionOf(req), currencyOf(req)));
+		}
+	};
+	ctx.effect(() => ctx.webServer.register(route), "cost-meter: /cost-meter route");
+}
+//#endregion
+export { Config, DEFAULT_ALIASES, DEFAULT_API_KEY_ENV, DEFAULT_CACHE_READ_DISCOUNT, DEFAULT_FX_RATE, DEFAULT_PRICING_REFRESH_HOURS, DEFAULT_REFRESH_MS, DEFAULT_SNAPSHOT_HISTORY_LIMIT, FALLBACK_CURRENT, FALLBACK_CURRENT_USD, FALLBACK_PEAK, FALLBACK_PEAK_USD, FX_API_URL, OPENROUTER_MODELS_URL, PEAK_PRICING_START_MS, PRICEBOOK_DOMAIN, PRICEBOOK_DOMAIN_USD, PRICING_URL, PRICING_URL_EN, PUBLIC_BASE_URL, PricebookHandle, SETTINGS_NAMESPACE, apply, bandForTime, bucketOf, collectSubagentCosts, computePricebook, effectiveBucket, effectivePricing, effectiveRate, fetchBalance, fetchFxRate, fetchOpenRouter, fetchPricing, foldSessionCost, initialPricebookState, inject, isLoopbackHostname, isPeakHour, isTrustedRequest, modelKeys, name, officialInputOf, parseCurrentTable, parseCurrentTableEn, parsePeakTable, parsePeakTableEn, pickBalanceInfo, priceAt, pricesEqual, pricingKeyOfModel, resolveApiKey, sessionCostProjection, snapshotForTime, stepCost, stripHtml, sumTotals, usageBuckets, viewSessionCost };