ccusage 0.4.1 → 0.5.0

package/dist/data-loader.d.ts

@@ -1,2 +1,5 @@
-import { DailyUsage, DailyUsageSchema$1 as DailyUsageSchema, DateFilter, LoadOptions, SessionUsage, SessionUsageSchema$1 as SessionUsageSchema, UsageData, UsageDataSchema$1 as UsageDataSchema, calculateCostForEntry$1 as calculateCostForEntry, formatDate$1 as formatDate, getDefaultClaudePath$1 as getDefaultClaudePath, loadSessionData$1 as loadSessionData, loadUsageData$1 as loadUsageData } from "./data-loader-D1LHcGfa.js";
+import "./index-BurjgCfW.js";
+import "./pricing-fetcher-DygIroMj.js";
+import "./types-B3ib19os.js";
+import { DailyUsage, DailyUsageSchema$1 as DailyUsageSchema, DateFilter, LoadOptions, SessionUsage, SessionUsageSchema$1 as SessionUsageSchema, UsageData, UsageDataSchema$1 as UsageDataSchema, calculateCostForEntry$1 as calculateCostForEntry, formatDate$1 as formatDate, getDefaultClaudePath$1 as getDefaultClaudePath, loadSessionData$1 as loadSessionData, loadUsageData$1 as loadUsageData } from "./data-loader-LMCrJ-lW.js";
 export { DailyUsage, DailyUsageSchema, DateFilter, LoadOptions, SessionUsage, SessionUsageSchema, UsageData, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadSessionData, loadUsageData };

package/dist/data-loader.js

@@ -1,3 +1,6 @@
-import { DailyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadSessionData, loadUsageData } from "./data-loader-BBdPk24U.js";
+import { DailyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadSessionData, loadUsageData } from "./data-loader-r5ZcMQy7.js";
+import "./dist-FwNhpFrW.js";
+import "./logger-Cu4Ir1a5.js";
+import "./pricing-fetcher-B5yPtoTB.js";
 
 export { DailyUsageSchema, SessionUsageSchema, UsageDataSchema, calculateCostForEntry, formatDate, getDefaultClaudePath, loadSessionData, loadUsageData };

package/dist/debug-BVxGf4UL.js

@@ -0,0 +1,142 @@
+import { UsageDataSchema, glob } from "./data-loader-r5ZcMQy7.js";
+import { safeParse } from "./dist-FwNhpFrW.js";
+import { logger } from "./logger-Cu4Ir1a5.js";
+import { calculateCostFromTokens, fetchModelPricing, getModelPricing } from "./pricing-fetcher-B5yPtoTB.js";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+
+//#region src/debug.ts
+const MATCH_THRESHOLD_PERCENT = .1;
+async function detectMismatches(claudePath) {
+	const claudeDir = claudePath || path.join(homedir(), ".claude", "projects");
+	const files = await glob(["**/*.jsonl"], {
+		cwd: claudeDir,
+		absolute: true
+	});
+	const modelPricing = await fetchModelPricing();
+	const stats = {
+		totalEntries: 0,
+		entriesWithBoth: 0,
+		matches: 0,
+		mismatches: 0,
+		discrepancies: [],
+		modelStats: new Map(),
+		versionStats: new Map()
+	};
+	for (const file of files) {
+		const content = await readFile(file, "utf-8");
+		const lines = content.trim().split("\n").filter((line) => line.length > 0);
+		for (const line of lines) try {
+			const parsed = JSON.parse(line);
+			const result = safeParse(UsageDataSchema, parsed);
+			if (!result.success) continue;
+			const data = result.output;
+			stats.totalEntries++;
+			if (data.costUSD !== void 0 && data.message.model && data.message.model !== "<synthetic>") {
+				stats.entriesWithBoth++;
+				const model = data.message.model;
+				const pricing = getModelPricing(model, modelPricing);
+				if (pricing) {
+					const calculatedCost = calculateCostFromTokens(data.message.usage, pricing);
+					const difference = Math.abs(data.costUSD - calculatedCost);
+					const percentDiff = data.costUSD > 0 ? difference / data.costUSD * 100 : 0;
+					const modelStat = stats.modelStats.get(model) || {
+						total: 0,
+						matches: 0,
+						mismatches: 0,
+						avgPercentDiff: 0
+					};
+					modelStat.total++;
+					if (data.version) {
+						const versionStat = stats.versionStats.get(data.version) || {
+							total: 0,
+							matches: 0,
+							mismatches: 0,
+							avgPercentDiff: 0
+						};
+						versionStat.total++;
+						if (percentDiff < MATCH_THRESHOLD_PERCENT) versionStat.matches++;
+						else versionStat.mismatches++;
+						versionStat.avgPercentDiff = (versionStat.avgPercentDiff * (versionStat.total - 1) + percentDiff) / versionStat.total;
+						stats.versionStats.set(data.version, versionStat);
+					}
+					if (percentDiff < .1) {
+						stats.matches++;
+						modelStat.matches++;
+					} else {
+						stats.mismatches++;
+						modelStat.mismatches++;
+						stats.discrepancies.push({
+							file: path.basename(file),
+							timestamp: data.timestamp,
+							model,
+							originalCost: data.costUSD,
+							calculatedCost,
+							difference,
+							percentDiff,
+							usage: data.message.usage
+						});
+					}
+					modelStat.avgPercentDiff = (modelStat.avgPercentDiff * (modelStat.total - 1) + percentDiff) / modelStat.total;
+					stats.modelStats.set(model, modelStat);
+				}
+			}
+		} catch (e) {}
+	}
+	return stats;
+}
+function printMismatchReport(stats, sampleCount = 5) {
+	if (stats.entriesWithBoth === 0) {
+		logger.info("No pricing data found to analyze.");
+		return;
+	}
+	const matchRate = stats.matches / stats.entriesWithBoth * 100;
+	logger.info("\n=== Pricing Mismatch Debug Report ===");
+	logger.info(`Total entries processed: ${stats.totalEntries.toLocaleString()}`);
+	logger.info(`Entries with both costUSD and model: ${stats.entriesWithBoth.toLocaleString()}`);
+	logger.info(`Matches (within 0.1%): ${stats.matches.toLocaleString()}`);
+	logger.info(`Mismatches: ${stats.mismatches.toLocaleString()}`);
+	logger.info(`Match rate: ${matchRate.toFixed(2)}%`);
+	if (stats.mismatches > 0 && stats.modelStats.size > 0) {
+		logger.info("\n=== Model Statistics ===");
+		const sortedModels = Array.from(stats.modelStats.entries()).sort((a, b) => b[1].mismatches - a[1].mismatches);
+		for (const [model, modelStat] of sortedModels) if (modelStat.mismatches > 0) {
+			const modelMatchRate = modelStat.matches / modelStat.total * 100;
+			logger.info(`${model}:`);
+			logger.info(`  Total entries: ${modelStat.total.toLocaleString()}`);
+			logger.info(`  Matches: ${modelStat.matches.toLocaleString()} (${modelMatchRate.toFixed(1)}%)`);
+			logger.info(`  Mismatches: ${modelStat.mismatches.toLocaleString()}`);
+			logger.info(`  Avg % difference: ${modelStat.avgPercentDiff.toFixed(1)}%`);
+		}
+	}
+	if (stats.mismatches > 0 && stats.versionStats.size > 0) {
+		logger.info("\n=== Version Statistics ===");
+		const sortedVersions = Array.from(stats.versionStats.entries()).filter(([_, versionStat]) => versionStat.mismatches > 0).sort((a, b) => b[1].mismatches - a[1].mismatches);
+		for (const [version, versionStat] of sortedVersions) {
+			const versionMatchRate = versionStat.matches / versionStat.total * 100;
+			logger.info(`${version}:`);
+			logger.info(`  Total entries: ${versionStat.total.toLocaleString()}`);
+			logger.info(`  Matches: ${versionStat.matches.toLocaleString()} (${versionMatchRate.toFixed(1)}%)`);
+			logger.info(`  Mismatches: ${versionStat.mismatches.toLocaleString()}`);
+			logger.info(`  Avg % difference: ${versionStat.avgPercentDiff.toFixed(1)}%`);
+		}
+	}
+	if (stats.discrepancies.length > 0 && sampleCount > 0) {
+		logger.info(`\n=== Sample Discrepancies (first ${sampleCount}) ===`);
+		const samples = stats.discrepancies.slice(0, sampleCount);
+		for (const disc of samples) {
+			logger.info(`File: ${disc.file}`);
+			logger.info(`Timestamp: ${disc.timestamp}`);
+			logger.info(`Model: ${disc.model}`);
+			logger.info(`Original cost: $${disc.originalCost.toFixed(6)}`);
+			logger.info(`Calculated cost: $${disc.calculatedCost.toFixed(6)}`);
+			logger.info(`Difference: $${disc.difference.toFixed(6)} (${disc.percentDiff.toFixed(2)}%)`);
+			logger.info(`Tokens: ${JSON.stringify(disc.usage)}`);
+			logger.info("---");
+		}
+	}
+}
+
+//#endregion
+export { detectMismatches, printMismatchReport };

package/dist/debug.d.ts

@@ -0,0 +1,39 @@
+//#region src/debug.d.ts
+interface Discrepancy {
+  file: string;
+  timestamp: string;
+  model: string;
+  originalCost: number;
+  calculatedCost: number;
+  difference: number;
+  percentDiff: number;
+  usage: {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+  };
+}
+interface MismatchStats {
+  totalEntries: number;
+  entriesWithBoth: number;
+  matches: number;
+  mismatches: number;
+  discrepancies: Discrepancy[];
+  modelStats: Map<string, {
+    total: number;
+    matches: number;
+    mismatches: number;
+    avgPercentDiff: number;
+  }>;
+  versionStats: Map<string, {
+    total: number;
+    matches: number;
+    mismatches: number;
+    avgPercentDiff: number;
+  }>;
+}
+declare function detectMismatches(claudePath?: string): Promise<MismatchStats>;
+declare function printMismatchReport(stats: MismatchStats, sampleCount?: number): void;
+//#endregion
+export { detectMismatches, printMismatchReport };

package/dist/debug.js

@@ -0,0 +1,7 @@
+import "./data-loader-r5ZcMQy7.js";
+import "./dist-FwNhpFrW.js";
+import "./logger-Cu4Ir1a5.js";
+import "./pricing-fetcher-B5yPtoTB.js";
+import { detectMismatches, printMismatchReport } from "./debug-BVxGf4UL.js";
+
+export { detectMismatches, printMismatchReport };

package/dist/dist-C_i5I27w.js

@@ -0,0 +1,469 @@
+import { getDefault } from "./dist-FwNhpFrW.js";
+
+//#region node_modules/@valibot/to-json-schema/dist/index.js
+/**
+* Adds an error message to the errors array.
+*
+* @param errors The array of error messages.
+* @param message The error message to add.
+*
+* @returns The new errors.
+*/
+function addError(errors, message) {
+	if (errors) {
+		errors.push(message);
+		return errors;
+	}
+	return [message];
+}
+/**
+* Throws an error or logs a warning based on the configuration.
+*
+* @param message The message to throw or log.
+* @param config The conversion configuration.
+*/
+function handleError(message, config) {
+	switch (config?.errorMode) {
+		case "ignore": break;
+		case "warn": {
+			console.warn(message);
+			break;
+		}
+		default: throw new Error(message);
+	}
+}
+/**
+* Converts any supported Valibot action to the JSON Schema format.
+*
+* @param jsonSchema The JSON Schema object.
+* @param valibotAction The Valibot action object.
+* @param config The conversion configuration.
+*
+* @returns The converted JSON Schema.
+*/
+function convertAction(jsonSchema, valibotAction, config) {
+	if (config?.ignoreActions?.includes(valibotAction.type)) return jsonSchema;
+	let errors;
+	switch (valibotAction.type) {
+		case "base64": {
+			jsonSchema.contentEncoding = "base64";
+			break;
+		}
+		case "bic":
+		case "cuid2":
+		case "decimal":
+		case "digits":
+		case "emoji":
+		case "hexadecimal":
+		case "hex_color":
+		case "nanoid":
+		case "octal":
+		case "ulid": {
+			jsonSchema.pattern = valibotAction.requirement.source;
+			break;
+		}
+		case "description": {
+			jsonSchema.description = valibotAction.description;
+			break;
+		}
+		case "email": {
+			jsonSchema.format = "email";
+			break;
+		}
+		case "empty": {
+			if (jsonSchema.type === "array") jsonSchema.maxItems = 0;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.maxLength = 0;
+			}
+			break;
+		}
+		case "entries": {
+			jsonSchema.minProperties = valibotAction.requirement;
+			jsonSchema.maxProperties = valibotAction.requirement;
+			break;
+		}
+		case "integer": {
+			jsonSchema.type = "integer";
+			break;
+		}
+		case "ipv4": {
+			jsonSchema.format = "ipv4";
+			break;
+		}
+		case "ipv6": {
+			jsonSchema.format = "ipv6";
+			break;
+		}
+		case "iso_date": {
+			jsonSchema.format = "date";
+			break;
+		}
+		case "iso_date_time":
+		case "iso_timestamp": {
+			jsonSchema.format = "date-time";
+			break;
+		}
+		case "iso_time": {
+			jsonSchema.format = "time";
+			break;
+		}
+		case "length": {
+			if (jsonSchema.type === "array") {
+				jsonSchema.minItems = valibotAction.requirement;
+				jsonSchema.maxItems = valibotAction.requirement;
+			} else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = valibotAction.requirement;
+				jsonSchema.maxLength = valibotAction.requirement;
+			}
+			break;
+		}
+		case "max_entries": {
+			jsonSchema.maxProperties = valibotAction.requirement;
+			break;
+		}
+		case "max_length": {
+			if (jsonSchema.type === "array") jsonSchema.maxItems = valibotAction.requirement;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.maxLength = valibotAction.requirement;
+			}
+			break;
+		}
+		case "max_value": {
+			if (jsonSchema.type !== "number") errors = addError(errors, `The "max_value" action is not supported on type "${jsonSchema.type}".`);
+			jsonSchema.maximum = valibotAction.requirement;
+			break;
+		}
+		case "metadata": {
+			if (typeof valibotAction.metadata.title === "string") jsonSchema.title = valibotAction.metadata.title;
+			if (typeof valibotAction.metadata.description === "string") jsonSchema.description = valibotAction.metadata.description;
+			if (Array.isArray(valibotAction.metadata.examples)) jsonSchema.examples = valibotAction.metadata.examples;
+			break;
+		}
+		case "min_entries": {
+			jsonSchema.minProperties = valibotAction.requirement;
+			break;
+		}
+		case "min_length": {
+			if (jsonSchema.type === "array") jsonSchema.minItems = valibotAction.requirement;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = valibotAction.requirement;
+			}
+			break;
+		}
+		case "min_value": {
+			if (jsonSchema.type !== "number") errors = addError(errors, `The "min_value" action is not supported on type "${jsonSchema.type}".`);
+			jsonSchema.minimum = valibotAction.requirement;
+			break;
+		}
+		case "multiple_of": {
+			jsonSchema.multipleOf = valibotAction.requirement;
+			break;
+		}
+		case "non_empty": {
+			if (jsonSchema.type === "array") jsonSchema.minItems = 1;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = 1;
+			}
+			break;
+		}
+		case "regex": {
+			if (valibotAction.requirement.flags) errors = addError(errors, "RegExp flags are not supported by JSON Schema.");
+			jsonSchema.pattern = valibotAction.requirement.source;
+			break;
+		}
+		case "title": {
+			jsonSchema.title = valibotAction.title;
+			break;
+		}
+		case "url": {
+			jsonSchema.format = "uri";
+			break;
+		}
+		case "uuid": {
+			jsonSchema.format = "uuid";
+			break;
+		}
+		case "value": {
+			jsonSchema.const = valibotAction.requirement;
+			break;
+		}
+		default: errors = addError(errors, `The "${valibotAction.type}" action cannot be converted to JSON Schema.`);
+	}
+	if (config?.overrideAction) {
+		const actionOverride = config.overrideAction({
+			valibotAction,
+			jsonSchema,
+			errors
+		});
+		if (actionOverride) return { ...actionOverride };
+	}
+	if (errors) for (const message of errors) handleError(message, config);
+	return jsonSchema;
+}
+/**
+* Flattens a Valibot pipe by recursively expanding nested pipes.
+*
+* @param pipe The pipeline to flatten.
+*
+* @returns A flat pipeline.
+*/
+function flattenPipe(pipe) {
+	return pipe.flatMap((item) => "pipe" in item ? flattenPipe(item.pipe) : item);
+}
+let refCount = 0;
+/**
+* Converts any supported Valibot schema to the JSON Schema format.
+*
+* @param jsonSchema The JSON Schema object.
+* @param valibotSchema The Valibot schema object.
+* @param config The conversion configuration.
+* @param context The conversion context.
+* @param skipRef Whether to skip using a reference.
+*
+* @returns The converted JSON Schema.
+*/
+function convertSchema(jsonSchema, valibotSchema, config, context, skipRef = false) {
+	if (!skipRef) {
+		const referenceId = context.referenceMap.get(valibotSchema);
+		if (referenceId) {
+			jsonSchema.$ref = `#/$defs/${referenceId}`;
+			if (config?.overrideRef) {
+				const refOverride = config.overrideRef({
+					...context,
+					referenceId,
+					valibotSchema,
+					jsonSchema
+				});
+				if (refOverride) jsonSchema.$ref = refOverride;
+			}
+			return jsonSchema;
+		}
+	}
+	if ("pipe" in valibotSchema) {
+		const flatPipe = flattenPipe(valibotSchema.pipe);
+		let startIndex = 0;
+		let stopIndex = flatPipe.length - 1;
+		if (config?.typeMode === "input") {
+			const inputStopIndex = flatPipe.slice(1).findIndex((item) => item.kind === "schema" || item.kind === "transformation" && (item.type === "find_item" || item.type === "parse_json" || item.type === "raw_transform" || item.type === "reduce_items" || item.type === "stringify_json" || item.type === "transform"));
+			if (inputStopIndex !== -1) stopIndex = inputStopIndex;
+		} else if (config?.typeMode === "output") {
+			const outputStartIndex = flatPipe.findLastIndex((item) => item.kind === "schema");
+			if (outputStartIndex !== -1) startIndex = outputStartIndex;
+		}
+		for (let index = startIndex; index <= stopIndex; index++) {
+			const valibotPipeItem = flatPipe[index];
+			if (valibotPipeItem.kind === "schema") {
+				if (index > startIndex) handleError("Set the \"typeMode\" config to \"input\" or \"output\" to convert pipelines with multiple schemas.", config);
+				jsonSchema = convertSchema(jsonSchema, valibotPipeItem, config, context, true);
+			} else jsonSchema = convertAction(jsonSchema, valibotPipeItem, config);
+		}
+		return jsonSchema;
+	}
+	let errors;
+	switch (valibotSchema.type) {
+		case "boolean": {
+			jsonSchema.type = "boolean";
+			break;
+		}
+		case "null": {
+			jsonSchema.type = "null";
+			break;
+		}
+		case "number": {
+			jsonSchema.type = "number";
+			break;
+		}
+		case "string": {
+			jsonSchema.type = "string";
+			break;
+		}
+		case "array": {
+			jsonSchema.type = "array";
+			jsonSchema.items = convertSchema({}, valibotSchema.item, config, context);
+			break;
+		}
+		case "tuple":
+		case "tuple_with_rest":
+		case "loose_tuple":
+		case "strict_tuple": {
+			jsonSchema.type = "array";
+			jsonSchema.items = [];
+			jsonSchema.minItems = valibotSchema.items.length;
+			for (const item of valibotSchema.items) jsonSchema.items.push(convertSchema({}, item, config, context));
+			if (valibotSchema.type === "tuple_with_rest") jsonSchema.additionalItems = convertSchema({}, valibotSchema.rest, config, context);
+			else if (valibotSchema.type === "strict_tuple") jsonSchema.additionalItems = false;
+			break;
+		}
+		case "object":
+		case "object_with_rest":
+		case "loose_object":
+		case "strict_object": {
+			jsonSchema.type = "object";
+			jsonSchema.properties = {};
+			jsonSchema.required = [];
+			for (const key in valibotSchema.entries) {
+				const entry = valibotSchema.entries[key];
+				jsonSchema.properties[key] = convertSchema({}, entry, config, context);
+				if (entry.type !== "nullish" && entry.type !== "optional") jsonSchema.required.push(key);
+			}
+			if (valibotSchema.type === "object_with_rest") jsonSchema.additionalProperties = convertSchema({}, valibotSchema.rest, config, context);
+			else if (valibotSchema.type === "strict_object") jsonSchema.additionalProperties = false;
+			break;
+		}
+		case "record": {
+			if ("pipe" in valibotSchema.key) errors = addError(errors, "The \"record\" schema with a schema for the key that contains a \"pipe\" cannot be converted to JSON Schema.");
+			if (valibotSchema.key.type !== "string") errors = addError(errors, `The "record" schema with the "${valibotSchema.key.type}" schema for the key cannot be converted to JSON Schema.`);
+			jsonSchema.type = "object";
+			jsonSchema.additionalProperties = convertSchema({}, valibotSchema.value, config, context);
+			break;
+		}
+		case "any":
+		case "unknown": break;
+		case "nullable":
+		case "nullish": {
+			jsonSchema.anyOf = [convertSchema({}, valibotSchema.wrapped, config, context), { type: "null" }];
+			if (valibotSchema.default !== void 0) jsonSchema.default = getDefault(valibotSchema);
+			break;
+		}
+		case "exact_optional":
+		case "optional":
+		case "undefinedable": {
+			jsonSchema = convertSchema(jsonSchema, valibotSchema.wrapped, config, context);
+			if (valibotSchema.default !== void 0) jsonSchema.default = getDefault(valibotSchema);
+			break;
+		}
+		case "literal": {
+			if (typeof valibotSchema.literal !== "boolean" && typeof valibotSchema.literal !== "number" && typeof valibotSchema.literal !== "string") errors = addError(errors, "The value of the \"literal\" schema is not JSON compatible.");
+			jsonSchema.const = valibotSchema.literal;
+			break;
+		}
+		case "enum": {
+			jsonSchema.enum = valibotSchema.options;
+			break;
+		}
+		case "picklist": {
+			if (valibotSchema.options.some((option) => typeof option !== "number" && typeof option !== "string")) errors = addError(errors, "An option of the \"picklist\" schema is not JSON compatible.");
+			jsonSchema.enum = valibotSchema.options;
+			break;
+		}
+		case "union":
+		case "variant": {
+			jsonSchema.anyOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+			break;
+		}
+		case "intersect": {
+			jsonSchema.allOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+			break;
+		}
+		case "lazy": {
+			let wrappedValibotSchema = context.getterMap.get(valibotSchema.getter);
+			if (!wrappedValibotSchema) {
+				wrappedValibotSchema = valibotSchema.getter(void 0);
+				context.getterMap.set(valibotSchema.getter, wrappedValibotSchema);
+			}
+			let referenceId = context.referenceMap.get(wrappedValibotSchema);
+			if (!referenceId) {
+				referenceId = `${refCount++}`;
+				context.referenceMap.set(wrappedValibotSchema, referenceId);
+				context.definitions[referenceId] = convertSchema({}, wrappedValibotSchema, config, context, true);
+			}
+			jsonSchema.$ref = `#/$defs/${referenceId}`;
+			if (config?.overrideRef) {
+				const refOverride = config.overrideRef({
+					...context,
+					referenceId,
+					valibotSchema: wrappedValibotSchema,
+					jsonSchema
+				});
+				if (refOverride) jsonSchema.$ref = refOverride;
+			}
+			break;
+		}
+		default: errors = addError(errors, `The "${valibotSchema.type}" schema cannot be converted to JSON Schema.`);
+	}
+	if (config?.overrideSchema) {
+		const schemaOverride = config.overrideSchema({
+			...context,
+			referenceId: context.referenceMap.get(valibotSchema),
+			valibotSchema,
+			jsonSchema,
+			errors
+		});
+		if (schemaOverride) return { ...schemaOverride };
+	}
+	if (errors) for (const message of errors) handleError(message, config);
+	return jsonSchema;
+}
+let store;
+/**
+* Adds new definitions to the global schema definitions.
+*
+* @param definitions The schema definitions.
+*
+* @beta
+*/
+function addGlobalDefs(definitions) {
+	store = {
+		...store ?? {},
+		...definitions
+	};
+}
+/**
+* Returns the current global schema definitions.
+*
+* @returns The schema definitions.
+*
+* @beta
+*/
+function getGlobalDefs() {
+	return store;
+}
+/**
+* Converts a Valibot schema to the JSON Schema format.
+*
+* @param schema The Valibot schema object.
+* @param config The JSON Schema configuration.
+*
+* @returns The converted JSON Schema.
+*/
+function toJsonSchema(schema, config) {
+	const context = {
+		definitions: {},
+		referenceMap: new Map(),
+		getterMap: new Map()
+	};
+	const definitions = config?.definitions ?? getGlobalDefs();
+	if (definitions) {
+		for (const key in definitions) context.referenceMap.set(definitions[key], key);
+		for (const key in definitions) context.definitions[key] = convertSchema({}, definitions[key], config, context, true);
+	}
+	const jsonSchema = convertSchema({ $schema: "http://json-schema.org/draft-07/schema#" }, schema, config, context);
+	if (context.referenceMap.size) jsonSchema.$defs = context.definitions;
+	return jsonSchema;
+}
+/**
+* Converts Valibot schema definitions to JSON Schema definitions.
+*
+* @param definitions The Valibot schema definitions.
+* @param config The JSON Schema configuration.
+*
+* @returns The converted JSON Schema definitions.
+*/
+function toJsonSchemaDefs(definitions, config) {
+	const context = {
+		definitions: {},
+		referenceMap: new Map(),
+		getterMap: new Map()
+	};
+	for (const key in definitions) context.referenceMap.set(definitions[key], key);
+	for (const key in definitions) context.definitions[key] = convertSchema({}, definitions[key], config, context, true);
+	return context.definitions;
+}
+
+//#endregion
+export { addGlobalDefs, getGlobalDefs, toJsonSchema, toJsonSchemaDefs };