@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/pricing-DusBEhwm.mjs

@@ -0,0 +1,593 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { p as LRUCache } from "./src-BhinCSpi.mjs";
+import { f as parseRevisionPrefix, h as isRecord, l as formatRevision, s as taxonomy, t as globMatch } from "./cascade-BWjRTD1q.mjs";
+import "./utils-DrDwmNtu.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/compat/taxonomy.ts
+/**
+* Runtime model-identity taxonomy: classifies wire model ids into
+* `(class, family, revision)` ranks, applies reviewed identity overrides, and
+* exposes the collapse/discovery vocabularies.
+*
+* Faithful port of the o2 reference (`taxonomy.rs` / `classify.rs`):
+* matchers rank `exact(4) > bounded(3) > namespace(2) > prefix(1) > glob(0)`
+* with token byte length as tiebreak; equal cross-class or cross-family ranks
+* throw unless classification is `lenient` (discovery normalization).
+*/
+/** Two classes, families, or reviewed override patterns tie for one model id. */
+var AmbiguousIdentityError = class extends Error {
+	model;
+	first;
+	second;
+	constructor(model, first, second, kind) {
+		super(`ambiguous ${kind} for \`${model}\`: \`${first}\` and \`${second}\` tie`);
+		this.model = model;
+		this.first = first;
+		this.second = second;
+		this.name = "AmbiguousIdentityError";
+	}
+};
+const MATCHER_RANK = {
+	exact: 4,
+	bounded: 3,
+	namespace: 2,
+	prefix: 1,
+	glob: 0
+};
+function bareOf(id) {
+	const slash = id.lastIndexOf("/");
+	return slash === -1 ? id : id.slice(slash + 1);
+}
+function boundedMatch(value, token) {
+	if (value === token) return true;
+	if (!value.startsWith(token)) return false;
+	const next = value.charCodeAt(token.length);
+	return next === 45 || next === 95 || next === 46 || next === 58 || next >= 48 && next <= 57;
+}
+function matcherMatches(matcher, lower, bare) {
+	switch (matcher.kind) {
+		case "exact": return bare === matcher.token;
+		case "bounded": return boundedMatch(bare, matcher.token);
+		case "namespace": {
+			const parts = matcher.bounded ? lower.split(/[/.:]/) : lower.split("/");
+			for (const part of parts) {
+				if (!part) continue;
+				if (matcher.bounded ? boundedMatch(part, matcher.token) : part === matcher.token) return true;
+			}
+			return false;
+		}
+		case "prefix": return bare.startsWith(matcher.token);
+		case "glob": return globMatch(matcher.token, bare);
+	}
+}
+function nonWildcardBytes(glob) {
+	let count = 0;
+	for (let i = 0; i < glob.length; i++) if (glob[i] !== "*") count++;
+	return count;
+}
+function rankFamilies(cls, subject) {
+	let winner;
+	let tied;
+	for (const family of cls.families) {
+		if (!globMatch(family.glob, subject)) continue;
+		const rank = [family.priority, nonWildcardBytes(family.glob)];
+		if (winner && winner.rank[0] === rank[0] && winner.rank[1] === rank[1] && winner.id !== family.id) tied = [winner.id, family.id];
+		else if (!winner || winner.rank[0] < rank[0] || winner.rank[0] === rank[0] && winner.rank[1] < rank[1]) {
+			winner = {
+				rank,
+				id: family.id
+			};
+			tied = void 0;
+		}
+	}
+	return {
+		winner,
+		tied
+	};
+}
+function stripClassNamespace(cls, bare) {
+	const separator = bare.search(/[.:]/);
+	if (separator <= 0 || separator === bare.length - 1) return void 0;
+	const namespace = bare.slice(0, separator);
+	if (!cls.matchers.some((matcher) => matcher.token === namespace)) return void 0;
+	return bare.slice(separator + 1);
+}
+function classifyFamily(cls, bare, model, lenient) {
+	const initial = rankFamilies(cls, bare);
+	const tied = initial.tied;
+	if (!tied) return initial.winner?.id;
+	const scoped = stripClassNamespace(cls, bare);
+	if (scoped !== void 0) {
+		const rescored = rankFamilies(cls, scoped);
+		if (rescored.winner && !rescored.tied) return rescored.winner.id;
+	}
+	if (lenient) return void 0;
+	throw new AmbiguousIdentityError(model, tied[0], tied[1], "family");
+}
+function extractRevision(cls, bare) {
+	if (cls.skipBare.includes(bare)) return void 0;
+	for (const rule of cls.revisionPrefixes) {
+		let tail;
+		if (rule.anywhere) {
+			const start = bare.indexOf(rule.prefix);
+			if (start !== -1) tail = bare.slice(start + rule.prefix.length);
+		} else if (bare.startsWith(rule.prefix)) tail = bare.slice(rule.prefix.length);
+		if (tail === void 0) continue;
+		const digit = tail.search(/[0-9]/);
+		if (digit === -1) return void 0;
+		const revision = parseRevisionPrefix(tail.slice(digit));
+		return revision ? formatRevision(revision) : void 0;
+	}
+}
+function classifyRanks(model, lenient) {
+	const lower = model.trim().toLowerCase();
+	const bare = bareOf(lower);
+	let winner;
+	let tied;
+	for (const cls of taxonomy.classes) for (const matcher of cls.matchers) {
+		if (!matcherMatches(matcher, lower, bare)) continue;
+		const rank = [MATCHER_RANK[matcher.kind], matcher.token.length];
+		if (winner && winner.rank[0] === rank[0] && winner.rank[1] === rank[1] && winner.cls.id !== cls.id) tied = [winner.cls.id, cls.id];
+		else if (!winner || winner.rank[0] < rank[0] || winner.rank[0] === rank[0] && winner.rank[1] < rank[1]) {
+			winner = {
+				rank,
+				cls
+			};
+			tied = void 0;
+		}
+	}
+	if (tied) {
+		if (lenient) return { class: "unknown" };
+		throw new AmbiguousIdentityError(lower, tied[0], tied[1], "class");
+	}
+	if (!winner) return { class: "unknown" };
+	const ranks = { class: winner.cls.id };
+	const family = classifyFamily(winner.cls, bare, lower, lenient);
+	if (family !== void 0) ranks.family = family;
+	const revision = extractRevision(winner.cls, bare);
+	if (revision !== void 0) ranks.revision = revision;
+	return ranks;
+}
+function ranksInClass(classId, model, lenient) {
+	const cls = taxonomy.classes.find((candidate) => candidate.id === classId);
+	if (!cls) return {};
+	const lower = model.trim().toLowerCase();
+	const bare = bareOf(lower);
+	const out = {};
+	const family = classifyFamily(cls, bare, lower, lenient);
+	if (family !== void 0) out.family = family;
+	const revision = extractRevision(cls, bare);
+	if (revision !== void 0) out.revision = revision;
+	return out;
+}
+let overrideIndexes;
+function getOverrideIndexes() {
+	if (overrideIndexes !== void 0) return overrideIndexes;
+	const exact = /* @__PURE__ */ new Map();
+	const patterns = [];
+	const classes = taxonomy.classes;
+	for (const cls of classes) for (const override of cls.overrides) {
+		if (override.model === void 0) {
+			if (override.glob !== void 0) patterns.push({
+				override,
+				glob: override.glob,
+				provider: override.provider?.toLowerCase(),
+				specificity: nonWildcardBytes(override.glob)
+			});
+			continue;
+		}
+		const key = override.model.toLowerCase();
+		let bucket = exact.get(key);
+		if (bucket === void 0) {
+			bucket = {
+				byProvider: /* @__PURE__ */ new Map(),
+				agnostic: void 0
+			};
+			exact.set(key, bucket);
+		}
+		if (override.provider !== void 0) {
+			const providerKey = override.provider.toLowerCase();
+			if (!bucket.byProvider.has(providerKey)) bucket.byProvider.set(providerKey, override);
+		} else bucket.agnostic ??= override;
+	}
+	overrideIndexes = {
+		exact,
+		patterns
+	};
+	return overrideIndexes;
+}
+function overrideIsActive(override, observedAtMs) {
+	return override.expiresAtMs === void 0 || observedAtMs === void 0 || observedAtMs < override.expiresAtMs;
+}
+function rankPatternOverrides(patterns, provider, bareModel, observedAtMs) {
+	let winner;
+	let tied;
+	for (const pattern of patterns) {
+		const { override, specificity } = pattern;
+		if (pattern.provider !== provider || !overrideIsActive(override, observedAtMs)) continue;
+		if (!globMatch(pattern.glob, bareModel)) continue;
+		if (winner?.specificity === specificity) tied = [winner.override, override];
+		else if (winner === void 0 || winner.specificity < specificity) {
+			winner = {
+				specificity,
+				override
+			};
+			tied = void 0;
+		}
+	}
+	return {
+		winner,
+		tied
+	};
+}
+function findIdentityOverride(provider, bareModel, observedAtMs, lenient) {
+	const lowerProvider = provider.toLowerCase();
+	const lowerBareModel = bareModel.toLowerCase();
+	const indexes = getOverrideIndexes();
+	const bucket = indexes.exact.get(lowerBareModel);
+	if (bucket !== void 0) {
+		const scoped = bucket.byProvider.get(lowerProvider);
+		if (scoped !== void 0 && overrideIsActive(scoped, observedAtMs)) return scoped;
+		const agnostic = bucket.agnostic;
+		if (agnostic !== void 0 && overrideIsActive(agnostic, observedAtMs)) return agnostic;
+	}
+	const scoped = rankPatternOverrides(indexes.patterns, lowerProvider, lowerBareModel, observedAtMs);
+	const ranked = scoped.winner === void 0 && scoped.tied === void 0 ? rankPatternOverrides(indexes.patterns, void 0, lowerBareModel, observedAtMs) : scoped;
+	if (ranked.tied !== void 0) {
+		if (lenient) return void 0;
+		throw new AmbiguousIdentityError(lowerBareModel, ranked.tied[0].id, ranked.tied[1].id, "override");
+	}
+	return ranked.winner?.override;
+}
+/**
+* Collapses a declared thinking or effort suffix from a model identifier.
+* Exact `effort-family` aliases collapse to the family's logical model
+* without assigning an effort; provider-scoped effort lanes additionally
+* collapse an effort suffix wedged before the lane token.
+*/
+function collapseVariantId(provider, model) {
+	const { collapse } = taxonomy;
+	const lower = model.toLowerCase();
+	for (const family of collapse.effortFamilies) if (family.provider === provider.toLowerCase() && family.aliases.includes(lower)) return {
+		logicalId: family.logical,
+		thinkingVariant: false
+	};
+	const bare = bareOf(lower);
+	let winner;
+	for (const rule of collapse.suffixes) {
+		if (!lower.endsWith(rule.suffix)) continue;
+		if (rule.exceptBarePrefix !== void 0 && bare.startsWith(rule.exceptBarePrefix)) continue;
+		if (!winner || rule.suffix.length > winner.suffix.length) winner = rule;
+	}
+	if (winner) {
+		const collapsed = {
+			logicalId: model.slice(0, model.length - winner.suffix.length),
+			thinkingVariant: winner.thinking === true
+		};
+		if (winner.effort !== void 0) collapsed.effort = winner.effort;
+		return collapsed;
+	}
+	for (const lane of collapse.lanes) {
+		if (!lane.providers.some((candidate) => candidate === provider.toLowerCase()) || !lower.endsWith(lane.suffix)) continue;
+		const trimmed = lower.slice(0, lower.length - lane.suffix.length);
+		const trimmedBare = bareOf(trimmed);
+		if (lane.barePrefix !== void 0 && !trimmedBare.startsWith(lane.barePrefix)) continue;
+		let effortRule;
+		for (const rule of collapse.suffixes) {
+			if (rule.effort === void 0 || !trimmed.endsWith(rule.suffix)) continue;
+			if (rule.exceptBarePrefix !== void 0 && trimmedBare.startsWith(rule.exceptBarePrefix)) continue;
+			if (!effortRule || rule.suffix.length > effortRule.suffix.length) effortRule = rule;
+		}
+		if (!effortRule) continue;
+		const base = model.slice(0, trimmed.length - effortRule.suffix.length);
+		if (!base || base.endsWith("/")) continue;
+		return {
+			logicalId: `${base}${model.slice(trimmed.length)}`,
+			effort: effortRule.effort,
+			thinkingVariant: false
+		};
+	}
+	return {
+		logicalId: model,
+		thinkingVariant: false
+	};
+}
+/**
+* Removes the first declared thinking-variant suffix token from a model id.
+*
+* Unlike {@link collapseVariantId}, this vocabulary-only helper also handles an
+* infix token used to pair live discovery siblings. Negated forms such as
+* `non-thinking` and `no-thinking` are not variants.
+*/
+function stripThinkingVariantSuffix(model) {
+	const lower = model.toLowerCase();
+	for (const token of taxonomy.collapse.pairTokens) {
+		const needle = `-${token}`;
+		let searchFrom = 0;
+		while (searchFrom < lower.length) {
+			const index = lower.indexOf(needle, searchFrom);
+			if (index === -1) break;
+			const end = index + needle.length;
+			const next = lower.charCodeAt(end);
+			const followedByTokenCharacter = next >= 48 && next <= 57 || next >= 97 && next <= 122;
+			let wordStart = index;
+			while (wordStart > 0) {
+				const code = lower.charCodeAt(wordStart - 1);
+				if (!(code >= 48 && code <= 57 || code >= 97 && code <= 122)) break;
+				wordStart--;
+			}
+			const preceding = lower.slice(wordStart, index);
+			if (!followedByTokenCharacter && preceding !== "non" && preceding !== "no") {
+				const stripped = model.slice(0, index) + model.slice(end);
+				return stripped.length > 0 ? stripped : void 0;
+			}
+			searchFrom = index + 1;
+		}
+	}
+}
+/**
+* Classifies a model into its structured identity: reviewed override first,
+* then suffix collapse, then class/family/revision ranks over the logical id.
+*
+* Results are memoized per (provider, model, lenient) — the rule tree is
+* static per process. Cached identities are frozen and each caller receives
+* a shallow copy, so a consumer that mutates its copy (e.g. `buildModel`
+* storing `policy.identity` on the model) cannot poison the cache or any
+* other model classified under the same key. Calls with an explicit
+* observedAtMs skip the memo so override expiry stays exact.
+*
+* @throws AmbiguousIdentityError on equal-rank cross-class, cross-family, or
+* reviewed-pattern matches unless `opts.lenient`.
+*/
+const classifyMemo = new LRUCache({ max: 16384 });
+function classifyMemoKey(provider, modelId, lenient) {
+	return `${provider.length}:${provider}${modelId.length}:${modelId}${lenient ? 1 : 0}`;
+}
+function classifyModel(provider, modelId, opts) {
+	if (opts?.observedAtMs === void 0) {
+		const key = classifyMemoKey(provider, modelId, opts?.lenient === true);
+		const cached = classifyMemo.get(key);
+		if (cached !== void 0) return { ...cached };
+		const identity = classifyModelUncached(provider, modelId, opts);
+		classifyMemo.set(key, Object.freeze(identity));
+		return { ...identity };
+	}
+	return classifyModelUncached(provider, modelId, opts);
+}
+function classifyModelUncached(provider, modelId, opts) {
+	const lenient = opts?.lenient === true;
+	const trimmed = modelId.trim();
+	const override = findIdentityOverride(provider, bareOf(trimmed), opts?.observedAtMs, lenient);
+	if (override) {
+		const logical = override.logical ?? trimmed;
+		const cls = override.class ?? classifyRanks(logical, lenient).class;
+		const inferred = ranksInClass(cls, logical, lenient);
+		const identity = { class: cls };
+		const family = override.family ?? inferred.family;
+		if (family !== void 0) identity.family = family;
+		const revision = override.revision ?? inferred.revision;
+		if (revision !== void 0) identity.revision = revision;
+		if (override.effort !== void 0) identity.effort = override.effort;
+		if (override.thinkingVariant) identity.thinkingVariant = true;
+		if (logical !== trimmed) identity.logicalId = logical;
+		return identity;
+	}
+	const collapsed = trimmed.length === modelId.length ? collapseVariantId(provider, trimmed) : {
+		logicalId: trimmed,
+		thinkingVariant: false
+	};
+	const ranks = classifyRanks(collapsed.logicalId, lenient);
+	const identity = { class: ranks.class };
+	if (ranks.family !== void 0) identity.family = ranks.family;
+	if (ranks.revision !== void 0) identity.revision = ranks.revision;
+	if (collapsed.effort !== void 0) identity.effort = collapsed.effort;
+	if (collapsed.thinkingVariant) identity.thinkingVariant = true;
+	if (collapsed.logicalId !== trimmed) identity.logicalId = collapsed.logicalId;
+	return identity;
+}
+/**
+* Strips a declared billing-variant suffix (`-free`, `-contributor`) from a
+* wire identifier, returning the base id it shares a transport with.
+*/
+function billingVariantPlain(wireModel) {
+	for (const suffix of taxonomy.discovery.billingVariantSuffixes) {
+		const split = wireModel.length - suffix.length;
+		if (split <= 0) continue;
+		if (wireModel.slice(split).toLowerCase() === suffix) return wireModel.slice(0, split);
+	}
+}
+/** The declared collapse suffix vocabulary (read-only view for collapse logic). */
+function collapseVocabulary() {
+	return taxonomy.collapse;
+}
+/** The declared discovery vocabulary (read-only view). */
+function discoveryVocabulary() {
+	return taxonomy.discovery;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/pricing.ts
+function nonnegative(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isRates(value) {
+	return isRecord(value) && nonnegative(value.input) && nonnegative(value.output) && nonnegative(value.cacheRead) && nonnegative(value.cacheWrite);
+}
+function isLongContext(value) {
+	return isRecord(value) && isRates(value) && typeof value.inputThreshold === "number" && Number.isFinite(value.inputThreshold) && value.inputThreshold > 0 && (value.inputThresholdInclusive === void 0 || typeof value.inputThresholdInclusive === "boolean");
+}
+function isPeakWindow(value) {
+	return isRecord(value) && Array.isArray(value.weekdays) && value.weekdays.length > 0 && value.weekdays.every((day) => Number.isInteger(day) && day >= 0 && day <= 6) && new Set(value.weekdays).size === value.weekdays.length && typeof value.startMinute === "number" && Number.isInteger(value.startMinute) && typeof value.endMinute === "number" && Number.isInteger(value.endMinute) && value.startMinute >= 0 && value.endMinute <= 1440 && value.startMinute < value.endMinute;
+}
+function isEffectiveRate(value) {
+	return isRecord(value) && isRates(value) && typeof value.effectiveFrom === "number" && Number.isSafeInteger(value.effectiveFrom) && Math.abs(value.effectiveFrom) <= 864e13 && (value.longContext === void 0 || isLongContext(value.longContext));
+}
+/** Validate serialized schedules before admitting cached model rows. */
+function isTimeBasedCost(value) {
+	if (!isRecord(value) || !nonnegative(value.offPeakMultiplier) || !Array.isArray(value.peakWindows) || !value.peakWindows.every(isPeakWindow)) return false;
+	if (value.effectiveRates === void 0) return true;
+	if (!Array.isArray(value.effectiveRates) || !value.effectiveRates.every(isEffectiveRate)) return false;
+	const dates = /* @__PURE__ */ new Set();
+	for (const rate of value.effectiveRates) {
+		if (dates.has(rate.effectiveFrom)) return false;
+		dates.add(rate.effectiveFrom);
+	}
+	return true;
+}
+function payload(value, keys, field) {
+	if (!isRecord(value) || Object.keys(value).some((key) => !keys.includes(key))) throw new Error(`Invalid time-based-cost ${field}`);
+	return value;
+}
+function namedEntries(value, field) {
+	if (!isRecord(value)) throw new Error(`Invalid time-based-cost ${field}: expected named objects`);
+	return Object.values(value);
+}
+/** Parse a KDL ISO UTC instant (`YYYY-MM-DDTHH:mm:ssZ`, optional milliseconds) to Unix ms. */
+function parseUtcInstant(date, axis) {
+	if (typeof date !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/.test(date)) throw new Error(`Invalid ${axis} effective-from: expected an ISO UTC timestamp`);
+	const instant = Date.parse(date);
+	if (!Number.isFinite(instant) || new Date(instant).toISOString() !== (date.includes(".") ? date : date.replace("Z", ".000Z"))) throw new Error(`Invalid ${axis} effective-from: invalid UTC date`);
+	return instant;
+}
+/** KDL object children are named records; normalize them once while constructing the model. */
+function materializeTimeBasedCost(value) {
+	const source = payload(value, [
+		"offPeakMultiplier",
+		"peakWindows",
+		"effectiveRates"
+	], "schedule");
+	const peakWindows = namedEntries(source.peakWindows, "peak-windows").map((entry) => {
+		const window = payload(entry, [
+			"weekdays",
+			"startMinute",
+			"endMinute"
+		], "peak-window");
+		if (typeof window.weekdays !== "string" || !/^[0-6](,[0-6])*$/.test(window.weekdays)) throw new Error("Invalid time-based-cost weekdays: expected comma-separated UTC weekday numbers");
+		return {
+			...window,
+			weekdays: window.weekdays.split(",").map(Number)
+		};
+	});
+	const effectiveRates = source.effectiveRates === void 0 ? void 0 : namedEntries(source.effectiveRates, "effective-rates").map((entry) => {
+		const rate = payload(entry, [
+			"effectiveFrom",
+			"input",
+			"output",
+			"cacheRead",
+			"cacheWrite",
+			"longContext"
+		], "effective-rate");
+		const effectiveFrom = parseUtcInstant(rate.effectiveFrom, "time-based-cost");
+		if (rate.longContext !== void 0) payload(rate.longContext, [
+			"inputThreshold",
+			"inputThresholdInclusive",
+			"input",
+			"output",
+			"cacheRead",
+			"cacheWrite"
+		], "long-context");
+		return {
+			...rate,
+			effectiveFrom
+		};
+	});
+	const schedule = {
+		offPeakMultiplier: source.offPeakMultiplier,
+		peakWindows,
+		...effectiveRates && { effectiveRates }
+	};
+	if (!isTimeBasedCost(schedule)) throw new Error("Invalid time-based-cost schedule: invalid windows, rates, or multiplier");
+	return schedule;
+}
+/**
+* The latest `effectiveRates` card of a materialized schedule due at
+* `timestamp`, or undefined before the first one (or without a schedule).
+*/
+function dueEffectiveRate(schedule, timestamp) {
+	let due;
+	for (const candidate of schedule?.effectiveRates ?? []) if (candidate.effectiveFrom <= timestamp && (due === void 0 || candidate.effectiveFrom > due.effectiveFrom)) due = candidate;
+	return due;
+}
+const TOKEN_COST_LEGS = [
+	"input",
+	"output",
+	"cacheRead",
+	"cacheWrite"
+];
+const DATED_CARD_KEYS = ["effectiveFrom", ...TOKEN_COST_LEGS];
+/**
+* Parse the compiled `effective-rates` block of a `cost-patch` or
+* `cost-fallback` payload into dated cards, ascending by date. Throws on a
+* malformed card, so a typo in a rule fails the build instead of silently
+* leaving the old price in force.
+*/
+function parseDatedCostCards(costAxis, axis) {
+	const effectiveRates = isRecord(costAxis) ? costAxis.effectiveRates : void 0;
+	if (effectiveRates === void 0) return [];
+	if (!isRecord(effectiveRates)) throw new Error(`Invalid ${axis} effective-rates: expected named objects`);
+	const cards = Object.values(effectiveRates).map((entry) => {
+		if (!isRecord(entry) || Object.keys(entry).some((key) => !DATED_CARD_KEYS.includes(key))) throw new Error(`Invalid ${axis} effective-rate: unknown or malformed fields`);
+		const card = { effectiveFrom: parseUtcInstant(entry.effectiveFrom, axis) };
+		for (const leg of TOKEN_COST_LEGS) {
+			const value = entry[leg];
+			if (value === void 0) continue;
+			if (!nonnegative(value)) throw new Error(`Invalid ${axis} effective-rate ${leg}: expected a nonnegative number`);
+			card[leg] = value;
+		}
+		return card;
+	});
+	cards.sort((a, b) => a.effectiveFrom - b.effectiveFrom);
+	for (let index = 1; index < cards.length; index++) if (cards[index].effectiveFrom === cards[index - 1].effectiveFrom) throw new Error(`Invalid ${axis} effective-rates: duplicate effective-from`);
+	return cards;
+}
+/**
+* Earliest instant a rate card can name (the `Date` range minimum). A leading
+* card from here holds the price in force before the first dated change.
+*/
+const EARLIEST_EFFECTIVE_FROM = -864e13;
+/** A schedule of dated rate cards alone: no peak windows, no off-peak discount. */
+const NO_RECURRING_TARIFF = {
+	offPeakMultiplier: 1,
+	peakWindows: []
+};
+/**
+* A flat card plus its dated overrides as a request-time `ModelCost`: the
+* card due at `now` in the scalar legs, and every period (a leading card for
+* the base price, then each dated card over the previous one) in a
+* `timeBased` schedule without a recurring tariff. The plain card when no
+* dated card exists.
+*/
+function datedCost(base, cards, now = Date.now()) {
+	if (cards.length === 0) return base;
+	const effectiveRates = [{
+		effectiveFrom: EARLIEST_EFFECTIVE_FROM,
+		...base
+	}];
+	for (const card of cards) effectiveRates.push({
+		...effectiveRates.at(-1),
+		...card
+	});
+	const timeBased = {
+		...NO_RECURRING_TARIFF,
+		effectiveRates
+	};
+	const { effectiveFrom: _effectiveFrom, ...due } = dueEffectiveRate(timeBased, now);
+	return {
+		...due,
+		timeBased
+	};
+}
+/**
+* Overwrite `cost` legs with the latest dated card due at `now`. Leaves
+* `cost` unchanged before the first card.
+*/
+function applyDueDatedCostCard(cost, cards, now = Date.now()) {
+	let due;
+	for (const card of cards) if (card.effectiveFrom <= now) due = card;
+	if (due === void 0) return;
+	for (const leg of TOKEN_COST_LEGS) {
+		const value = due[leg];
+		if (value !== void 0) cost[leg] = value;
+	}
+}
+//#endregion
+export { dueEffectiveRate as a, billingVariantPlain as c, collapseVocabulary as d, discoveryVocabulary as f, datedCost as i, classifyModel as l, NO_RECURRING_TARIFF as n, materializeTimeBasedCost as o, stripThinkingVariantSuffix as p, applyDueDatedCostCard as r, parseDatedCostCards as s, EARLIEST_EFFECTIVE_FROM as t, collapseVariantId as u };