@chainflip/processor 2.1.0-alpha.3 → 2.1.0-alpha.4

package/dist/packages/chainspec/src/BaseCodeGenerator.cjs

@@ -0,0 +1,151 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_utils = require('./utils.cjs');
+let fs_promises = require("fs/promises");
+fs_promises = require_rolldown_runtime.__toESM(fs_promises);
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path);
+let _chainflip_utils_string = require("@chainflip/utils/string");
+let _chainflip_utils_assertion = require("@chainflip/utils/assertion");
+
+//#region ../chainspec/src/BaseCodeGenerator.ts
+var CodegenResult = class {
+	declarationType = "const";
+	constructor(code, dependencies = []) {
+		this.code = code;
+		this.dependencies = dependencies;
+	}
+	toString() {
+		return this.code;
+	}
+	asType() {
+		this.declarationType = "type";
+		return this;
+	}
+};
+var Identifier = class extends CodegenResult {
+	constructor(identifier, pkg = "common") {
+		super(identifier);
+		this.pkg = pkg;
+	}
+	getDependencies() {
+		return [this];
+	}
+	[Symbol.toStringTag]() {
+		return "Identifier";
+	}
+};
+var Code = class extends CodegenResult {
+	getDependencies() {
+		return this.dependencies.flatMap((d) => d.getDependencies());
+	}
+	[Symbol.toStringTag]() {
+		return "Code";
+	}
+};
+var Module = class {
+	constructor(name, exports, globalImports, pallet) {
+		this.name = name;
+		this.exports = exports;
+		this.globalImports = globalImports;
+		this.pallet = pallet;
+	}
+	isCommon() {
+		return this.name === "common";
+	}
+	toString() {
+		const generated = [];
+		const dependencies = {};
+		for (const [identifier, type] of this.exports.entries()) {
+			const exportDeps = type.getDependencies();
+			for (const ident of exportDeps) {
+				if (ident.pkg === this.name) continue;
+				dependencies[ident.pkg] ??= /* @__PURE__ */ new Map();
+				dependencies[ident.pkg].set(ident.toString(), ident);
+			}
+			generated.push(`export ${type.declarationType} ${identifier} = ${type.toString()};`);
+			generated.push("");
+		}
+		return [
+			...this.globalImports,
+			...Object.entries(dependencies).map(([pkg, depsSet]) => {
+				const pkgPath = pkg === "common" ? "../common" : pkg;
+				const deps = [...depsSet.entries()].sort(([a], [b]) => a.toLowerCase() < b.toLowerCase() ? -1 : 1).map(([name, type]) => type.declarationType === "const" ? name : `type ${name}`);
+				return `import ${deps.length === 1 && deps[0].startsWith("*") ? deps[0] : `{ ${deps.join(", ")} }`} from '${pkgPath}';`;
+			}),
+			"",
+			...generated
+		].join("\n");
+	}
+	toFormattedString() {
+		return require_utils.formatCode(this.toString());
+	}
+	async writeFile(specDir, changelog) {
+		const outDir = this.pallet ? path.join(specDir, (0, _chainflip_utils_string.uncapitalize)(this.pallet)) : specDir;
+		await fs_promises.mkdir(outDir, { recursive: true });
+		await fs_promises.writeFile(path.join(outDir, (0, _chainflip_utils_string.uncapitalize)(`${this.name}.ts`)), await this.toFormattedString(), "utf8");
+		if (changelog) await fs_promises.writeFile(path.join(outDir, "CHANGELOG.md"), changelog, "utf8");
+	}
+};
+var CodeGenerator = class {
+	registry = { types: /* @__PURE__ */ new Map() };
+	trackedItems;
+	constructor({ trackedItems } = {}) {
+		if (trackedItems) this.trackedItems = new Set(trackedItems);
+	}
+	generateResolvedType(def) {
+		switch (def.type) {
+			case "array": return this.generateArray(def);
+			case "enum": return this.generateEnum(def);
+			case "map": return this.generateMap(def);
+			case "option": return this.generateOption(def);
+			case "primitive": return this.generatePrimitive(def);
+			case "range": return this.generateRange(def);
+			case "struct": return this.generateStruct(def);
+			case "tuple": return this.generateTuple(def);
+			default: return (0, _chainflip_utils_assertion.unreachable)(def, `Unsupported type: ${def.type}`);
+		}
+	}
+	generateItem(itemName, def) {
+		return this.generateResolvedType(def);
+	}
+	getName(palletName, itemName) {
+		return this.getParserName(palletName, itemName);
+	}
+	getGlobalImports() {
+		return [];
+	}
+	getFileName(palletName, itemName) {
+		return itemName;
+	}
+	*generate(def) {
+		const unhandledItems = new Set(this.trackedItems);
+		const generatedItems = /* @__PURE__ */ new Set();
+		for (const [palletName, items] of Object.entries(def)) for (const [itemName, item] of Object.entries(items)) {
+			const parserName = this.getParserName(palletName, itemName);
+			if (this.trackedItems && !unhandledItems.delete(parserName)) continue;
+			generatedItems.add(parserName);
+			let generatedCode;
+			try {
+				generatedCode = this.generateItem(itemName, item);
+			} catch (e) {
+				console.error(`failed to parse: ${parserName}`);
+				console.error(JSON.stringify(item, null, 2));
+				console.error(e);
+				throw e;
+			}
+			const name = this.getName(palletName, itemName);
+			yield new Module(this.getFileName(palletName, itemName), new Map([[name, generatedCode]]), this.getGlobalImports(), palletName);
+		}
+		if (unhandledItems.size !== 0) {
+			console.error("Unhandled items:", unhandledItems);
+			throw new Error("Not all items were generated");
+		}
+		if (generatedItems.size === 0) return;
+		yield new Module("common", new Map(this.registry.types), this.getGlobalImports());
+	}
+};
+
+//#endregion
+exports.Code = Code;
+exports.Identifier = Identifier;
+exports.default = CodeGenerator;

package/dist/packages/chainspec/src/BaseParser.cjs

@@ -0,0 +1,212 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_types = require('../../../node_modules/.pnpm/@polkadot_types-create@16.5.4/node_modules/@polkadot/types-create/types/types.cjs');
+const require_SpecVersion = require('./SpecVersion.cjs');
+let fs_promises = require("fs/promises");
+fs_promises = require_rolldown_runtime.__toESM(fs_promises);
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path);
+let _chainflip_utils_guard = require("@chainflip/utils/guard");
+let _chainflip_utils_string = require("@chainflip/utils/string");
+let assert = require("assert");
+assert = require_rolldown_runtime.__toESM(assert);
+
+//#region ../chainspec/src/BaseParser.ts
+const hasName = (obj) => obj.name !== void 0;
+const hasSubs = (type, count) => Array.isArray(type.sub) && (count === void 0 || type.sub.length === count);
+const hasSub = (type) => !Array.isArray(type.sub) && type.sub !== void 0;
+const isSi = (type) => type.info === require_types.TypeDefInfo.Si && /^Lookup\d+$/.test(type.type);
+var BaseParser = class {
+	hash;
+	network;
+	generatedDir;
+	metadata;
+	specVersion;
+	currentPallet;
+	constructor(opts, specVersionCache) {
+		this.specVersionCache = specVersionCache;
+		this.hash = opts.hash;
+		this.network = opts.network ?? "backspin";
+		this.generatedDir = opts.generatedDir;
+	}
+	shouldParsePallet(_palletName) {
+		return true;
+	}
+	shouldParseItem(_palletName, _itemName) {
+		return true;
+	}
+	resolveType(type) {
+		const metadata = this.getMetadataSync();
+		switch (type.info) {
+			case require_types.TypeDefInfo.Enum: {
+				(0, assert.default)(hasSubs(type));
+				(0, assert.default)(type.lookupName, "Enum type must have a lookupName");
+				const result = {
+					type: "enum",
+					$name: (0, _chainflip_utils_string.uncapitalize)(type.lookupName),
+					values: []
+				};
+				for (const sub of type.sub) result.values[sub.index] = {
+					name: sub.name,
+					value: this.resolveType(sub)
+				};
+				return result;
+			}
+			case require_types.TypeDefInfo.Struct: {
+				(0, assert.default)(hasSubs(type));
+				const result = {
+					type: "struct",
+					$name: type.lookupName ?? this.genericNamespace(type.namespace),
+					fields: {}
+				};
+				for (const sub of type.sub) result.fields[sub.name] = this.resolveType(sub);
+				return result;
+			}
+			case require_types.TypeDefInfo.Si:
+				(0, assert.default)(isSi(type));
+				return this.resolveType(metadata.registry.lookup.getTypeDef(type.type));
+			case require_types.TypeDefInfo.Compact:
+				(0, assert.default)(hasSub(type));
+				return this.resolveType(type.sub);
+			case require_types.TypeDefInfo.Null: return {
+				type: "primitive",
+				value: "null"
+			};
+			case require_types.TypeDefInfo.Plain: return {
+				type: "primitive",
+				value: type.type
+			};
+			case require_types.TypeDefInfo.BTreeSet:
+			case require_types.TypeDefInfo.Vec:
+			case require_types.TypeDefInfo.VecFixed:
+				(0, assert.default)(hasSub(type));
+				return {
+					type: "array",
+					value: this.resolveType(type.sub),
+					length: type.length
+				};
+			case require_types.TypeDefInfo.Tuple:
+				(0, assert.default)(hasSubs(type));
+				return {
+					type: "tuple",
+					values: type.sub.map((t) => this.resolveType(t))
+				};
+			case require_types.TypeDefInfo.Option:
+				(0, assert.default)(hasSub(type));
+				return {
+					type: "option",
+					value: this.resolveType(type.sub)
+				};
+			case require_types.TypeDefInfo.Result:
+				(0, assert.default)(hasSubs(type));
+				return {
+					type: "enum",
+					$name: (0, _chainflip_utils_string.uncapitalize)(type.typeName),
+					values: [{
+						name: "Ok",
+						value: this.resolveType(type.sub[0])
+					}, {
+						name: "Err",
+						value: this.resolveType(type.sub[1])
+					}]
+				};
+			case require_types.TypeDefInfo.Range:
+				(0, assert.default)(hasSub(type));
+				return {
+					type: "range",
+					value: this.resolveType(type.sub)
+				};
+			case require_types.TypeDefInfo.BTreeMap:
+				(0, assert.default)(hasSubs(type, 2));
+				return {
+					type: "map",
+					key: this.resolveType(type.sub[0]),
+					value: this.resolveType(type.sub[1])
+				};
+			default: throw new Error(`Unhandled type: ${type.info}`);
+		}
+	}
+	getPalletName() {
+		(0, assert.default)(this.currentPallet, "Pallet not set");
+		return this.currentPallet;
+	}
+	genericNamespace(namespace) {
+		if (!namespace) return namespace;
+		if (namespace.startsWith("pallet_cf_ingress_egress")) {
+			const chain = /^(.+)IngressEgress$/.exec(this.getPalletName())[1];
+			return namespace.replace("pallet_cf_ingress_egress", `pallet_cf_${chain.toLowerCase()}_ingress_egress`);
+		}
+		if (namespace.startsWith("cf_chains")) {
+			const chain = /^(.+)IngressEgress$/.exec(this.getPalletName())?.[1];
+			if (chain) return namespace.replace("cf_chains", `cf_${chain.toLowerCase()}_chain`);
+		}
+		return namespace;
+	}
+	tryResolveType(type) {
+		try {
+			return this.resolveType(type);
+		} catch (error) {
+			console.error("failed to parse type:");
+			console.error(type);
+			console.error(error);
+			throw error;
+		}
+	}
+	parseMetadata() {
+		const metadata = this.getMetadataSync();
+		return Object.fromEntries(metadata.asV14.pallets.map((pallet) => {
+			const palletMetadata = this.getItems(pallet);
+			if (!palletMetadata) return null;
+			const items = metadata.registry.lookup.getTypeDef(palletMetadata.type);
+			const palletName = pallet.name.toString();
+			if (!this.shouldParsePallet(palletName)) return null;
+			(0, assert.default)(hasSubs(items));
+			return [palletName, items];
+		}).filter(_chainflip_utils_guard.isNotNullish).map(([palletName, items]) => {
+			const itemsAndTypes = items.sub.filter(hasName).filter((item) => this.shouldParseItem(palletName, item.name)).map((item) => {
+				this.currentPallet = palletName;
+				return [item.name, this.tryResolveType(item)];
+			});
+			if (!itemsAndTypes.length) return null;
+			return [palletName, Object.fromEntries(itemsAndTypes)];
+		}).filter(_chainflip_utils_guard.isNotNullish));
+	}
+	async fetchMetadataAndSpecVersion() {
+		if (this.metadata && this.specVersion) return {
+			metadata: this.metadata,
+			specVersion: this.specVersion
+		};
+		const { specVersion, metadata } = await this.specVersionCache.getMetadataAndVersion(this.network, this.hash);
+		this.specVersion = specVersion;
+		this.metadata = metadata;
+		return {
+			specVersion,
+			metadata
+		};
+	}
+	getMetadataSync() {
+		(0, assert.default)(this.metadata, "Metadata not available");
+		return this.metadata;
+	}
+	async getSpecVersion() {
+		let { specVersion } = this;
+		if (!specVersion) specVersion = (await this.fetchMetadataAndSpecVersion()).specVersion;
+		return specVersion;
+	}
+	async fetchAndParseSpec() {
+		const specVersion = new require_SpecVersion.default(await this.getSpecVersion());
+		const outfile = path.join(this.generatedDir, `types-${specVersion.toString()}.json`);
+		let parsedMetadata = await fs_promises.readFile(outfile, "utf8").then((data) => JSON.parse(data)).catch(() => null);
+		if (!parsedMetadata) {
+			parsedMetadata = this.parseMetadata();
+			await fs_promises.mkdir(path.dirname(outfile), { recursive: true });
+			await fs_promises.writeFile(outfile, JSON.stringify(parsedMetadata, null, 2));
+		}
+		return {
+			metadata: parsedMetadata,
+			specVersion
+		};
+	}
+};
+
+//#endregion
+exports.default = BaseParser;

package/dist/packages/chainspec/src/Compiler.cjs

@@ -0,0 +1,56 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_cache = require('./cache.cjs');
+const require_utils = require('./utils.cjs');
+let fs_promises = require("fs/promises");
+fs_promises = require_rolldown_runtime.__toESM(fs_promises);
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path);
+
+//#region ../chainspec/src/Compiler.ts
+var Compiler = class {
+	constructor(Parser, CodeGenerator, generatedDir, specVersionCache$1 = require_cache.specVersionCache) {
+		this.Parser = Parser;
+		this.CodeGenerator = CodeGenerator;
+		this.generatedDir = generatedDir;
+		this.specVersionCache = specVersionCache$1;
+	}
+	async retrieveMetadata() {
+		const info = await this.specVersionCache.read();
+		const opts = Object.values(info).map((i) => ({
+			...i,
+			generatedDir: this.generatedDir
+		}));
+		return (await Promise.all(opts.map((o) => new this.Parser(o, this.specVersionCache).fetchAndParseSpec()))).sort((a, b) => a.specVersion.compare(b.specVersion));
+	}
+	async compile(cb) {
+		let previousMetadata = {};
+		let acc;
+		let previousSpecVersion;
+		for (const { metadata, specVersion } of await this.retrieveMetadata()) {
+			const specDir = path.join(this.generatedDir, specVersion.toString());
+			await fs_promises.rm(specDir, {
+				recursive: true,
+				force: true
+			});
+			const { changedOrAddedEvents, changelog } = require_utils.diffSpecs(previousMetadata, metadata);
+			const generator = new this.CodeGenerator({ trackedItems: changedOrAddedEvents });
+			for (const module of generator.generate(metadata)) await module.writeFile(specDir, module.isCommon() ? changelog : void 0);
+			acc = await cb?.(acc, {
+				new: {
+					metadata,
+					specVersion
+				},
+				old: {
+					metadata: previousMetadata,
+					specVersion: previousSpecVersion
+				}
+			});
+			previousMetadata = metadata;
+			previousSpecVersion = specVersion;
+		}
+		return acc;
+	}
+};
+
+//#endregion
+exports.default = Compiler;

package/dist/packages/chainspec/src/SpecVersion.cjs

@@ -0,0 +1,35 @@
+
+//#region ../chainspec/src/SpecVersion.ts
+var SpecVersion = class {
+	major;
+	minor;
+	patch;
+	constructor(integerVersion) {
+		this.integerVersion = integerVersion;
+		const stringVersion = integerVersion.toString();
+		const versionLength = stringVersion.length;
+		const partLength = Math.ceil(versionLength / 3);
+		const paddedVersion = stringVersion.padStart(partLength * 3, "0");
+		this.major = parseInt(paddedVersion.slice(0, partLength), 10);
+		this.minor = parseInt(paddedVersion.slice(partLength, partLength * 2), 10);
+		this.patch = parseInt(paddedVersion.slice(partLength * 2), 10);
+	}
+	compare(other) {
+		if (this.major < other.major) return -1;
+		if (this.major > other.major) return 1;
+		if (this.minor < other.minor) return -1;
+		if (this.minor > other.minor) return 1;
+		if (this.patch < other.patch) return -1;
+		if (this.patch > other.patch) return 1;
+		return 0;
+	}
+	toString() {
+		return this.integerVersion.toString();
+	}
+	toFormatted() {
+		return `${this.major}.${this.minor}.${this.patch}`;
+	}
+};
+
+//#endregion
+exports.default = SpecVersion;

package/dist/packages/chainspec/src/cache.cjs

@@ -0,0 +1,102 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_HttpClient = require('../../../node_modules/.pnpm/@chainflip_rpc@1.9.3/node_modules/@chainflip/rpc/dist/HttpClient.cjs');
+require('../../../node_modules/.pnpm/@chainflip_rpc@1.9.3/node_modules/@chainflip/rpc/dist/index.cjs');
+const require_Metadata = require('../../../node_modules/.pnpm/@polkadot_types@16.5.4/node_modules/@polkadot/types/metadata/Metadata.cjs');
+const require_registry = require('../../../node_modules/.pnpm/@polkadot_types@16.5.4/node_modules/@polkadot/types/create/registry.cjs');
+let fs_promises = require("fs/promises");
+fs_promises = require_rolldown_runtime.__toESM(fs_promises);
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path);
+let _chainflip_utils_async = require("@chainflip/utils/async");
+let zod = require("zod");
+
+//#region ../chainspec/src/cache.ts
+const cacheSchema = zod.z.record(zod.z.object({
+	hash: zod.z.string(),
+	network: zod.z.enum([
+		"mainnet",
+		"perseverance",
+		"sisyphos",
+		"backspin",
+		"localnet"
+	])
+}));
+const networkToRpcUrl = {
+	mainnet: "https://archive.mainnet.chainflip.io",
+	perseverance: "https://archive.perseverance.chainflip.io",
+	sisyphos: "https://archive.sisyphos.chainflip.io",
+	backspin: "https://rpc.backspin.chainflip.io",
+	localnet: "http://127.0.0.1:9944"
+};
+var SpecVersionCache = class {
+	contents;
+	queue = new _chainflip_utils_async.Queue();
+	constructor(filePath) {
+		this.filePath = filePath;
+	}
+	async read() {
+		const contents = JSON.parse(await fs_promises.readFile(this.filePath, "utf8").catch(() => "{}"));
+		this.contents ??= cacheSchema.parse(contents);
+		return this.contents;
+	}
+	async write(id, hash, network) {
+		return this.queue.enqueue(async () => {
+			const data = await this.read();
+			data[id] = {
+				hash,
+				network
+			};
+			await fs_promises.mkdir(path.dirname(this.filePath), { recursive: true });
+			await fs_promises.writeFile(this.filePath, JSON.stringify(data, null, 2));
+		});
+	}
+	async persistMetadata(specVersion, filePath, bytes) {
+		await fs_promises.mkdir(path.dirname(filePath), { recursive: true });
+		await fs_promises.writeFile(filePath, bytes);
+		for (const file of await fs_promises.readdir(this.getDir())) if (file.startsWith(`${specVersion}-`) && file !== path.basename(filePath)) await fs_promises.rm(path.join(this.getDir(), file)).catch(() => null);
+	}
+	async fetchSpecVersion(hash, network) {
+		const { specVersion } = await new require_HttpClient.HttpClient(networkToRpcUrl[network]).sendRequest("state_getRuntimeVersion", hash);
+		return specVersion;
+	}
+	async getVersion(hash, network) {
+		const data = await this.read();
+		const [version] = Object.entries(data).find(([, d]) => d.hash === hash && d.network === network) ?? [];
+		return version !== void 0 ? Number(version) : void 0;
+	}
+	async getMetadataAndVersion(network, maybeHash) {
+		let specVersion;
+		let hash;
+		const client = new require_HttpClient.HttpClient(networkToRpcUrl[network]);
+		if (maybeHash) {
+			hash = maybeHash;
+			specVersion = await this.getVersion(maybeHash, network);
+		} else hash = await client.sendRequest("chain_getBlockHash");
+		if (!specVersion) {
+			specVersion = await this.fetchSpecVersion(hash, network);
+			await this.write(specVersion, hash, network);
+		}
+		const filePath = path.join(this.getDir(), `${specVersion}-${hash.slice(2, 8)}.scale`);
+		let bytes = await fs_promises.readFile(filePath).catch(() => null);
+		if (!bytes) {
+			const metadata = await client.sendRequest("state_getMetadata", hash);
+			bytes = Buffer.from(metadata.slice(2), "hex");
+			await this.persistMetadata(specVersion, filePath, bytes);
+		}
+		const registry = new require_registry.TypeRegistry();
+		const metadata = new require_Metadata.Metadata(registry, bytes);
+		registry.setMetadata(metadata);
+		return {
+			specVersion,
+			metadata
+		};
+	}
+	getDir() {
+		return path.dirname(this.filePath);
+	}
+};
+const specVersionCache = new SpecVersionCache(path.join(typeof __dirname !== "undefined" ? __dirname : __dirname, "..", "metadata", "specVersion.json"));
+
+//#endregion
+exports.SpecVersionCache = SpecVersionCache;
+exports.specVersionCache = specVersionCache;

package/dist/packages/chainspec/src/utils.cjs

@@ -0,0 +1,104 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../node_modules/.pnpm/prettier@3.8.1/node_modules/prettier/index.cjs');
+let assert = require("assert");
+assert = require_rolldown_runtime.__toESM(assert);
+
+//#region ../chainspec/src/utils.ts
+function* diff(a, b, path = []) {
+	const addedKeys = new Set(Object.keys(b).filter((key) => b[key] !== void 0).filter((key) => !a[key]));
+	const removedKeys = new Set(Object.keys(a).filter((key) => a[key] !== void 0).filter((key) => !b[key]));
+	const commonKeys = new Set(Object.keys(a).filter((key) => a[key] !== void 0).filter((key) => b[key]));
+	addedKeys.delete("$name");
+	removedKeys.delete("$name");
+	commonKeys.delete("$name");
+	for (const key of addedKeys) yield {
+		path: [...path, key],
+		type: "added"
+	};
+	for (const key of removedKeys) yield {
+		path: [...path, key],
+		type: "removed"
+	};
+	for (const key of commonKeys) if (typeof a[key] === "object" && typeof b[key] === "object") yield* diff(a[key], b[key], [...path, key]);
+	else if (a[key] !== b[key]) yield {
+		path: [...path, key],
+		type: "changed"
+	};
+}
+var ChangelogGenerator = class {
+	addedOrRemovedPallets = {};
+	changedEvents = {};
+	addedOrRemovedEvents = {};
+	trackedFieldChanges = /* @__PURE__ */ new Set();
+	add({ path, type }) {
+		if (path.length === 1) {
+			(0, assert.default)(type === "added" || type === "removed");
+			this.addedOrRemovedPallets[path[0]] = type;
+		} else if (path.length === 2) {
+			const name = `${path[0]}.${path[1]}`;
+			(0, assert.default)(type === "added" || type === "removed");
+			this.addedOrRemovedEvents[name] = type;
+		} else {
+			const [pallet, event, , field] = path;
+			const id = `${pallet}.${event}.${field}`;
+			if (this.trackedFieldChanges.has(id)) return;
+			this.trackedFieldChanges.add(id);
+			(this.changedEvents[`${pallet}.${event}`] ??= []).push({
+				field,
+				type,
+				path
+			});
+		}
+	}
+	toString() {
+		const lines = [];
+		const pallets = Object.keys(this.addedOrRemovedPallets).sort();
+		if (pallets.length) {
+			lines.push("New or removed pallets:");
+			for (const pallet of pallets) lines.push(`  ${pallet}: ${this.addedOrRemovedPallets[pallet]}`);
+			lines.push("");
+		}
+		const events = Object.keys(this.addedOrRemovedEvents).concat(Object.keys(this.changedEvents)).sort();
+		let currentPallet = "";
+		for (const event of events) {
+			const [pallet, name] = event.split(".");
+			if (pallet !== currentPallet) {
+				if (currentPallet) lines.push("");
+				currentPallet = pallet;
+				lines.push(`${pallet}:`);
+			}
+			if (event in this.addedOrRemovedEvents) lines.push(`  - ${name}: ${this.addedOrRemovedEvents[event]}`);
+			else {
+				lines.push(`  - ${name}:`);
+				const fields = this.changedEvents[event].map(({ field, type, path }) => `    - ${field}: ${type} (${path.filter((v) => v !== "value" && v !== "values" && v !== "fields").join(".")})`);
+				lines.push(...fields);
+			}
+		}
+		lines.push("");
+		return lines.join("\n");
+	}
+};
+const diffSpecs = (a, b) => {
+	const changedOrAddedEvents = /* @__PURE__ */ new Set();
+	const changelog = new ChangelogGenerator();
+	for (const change of diff(a, b)) {
+		changelog.add(change);
+		const [pallet, event, field] = change.path;
+		if (event && (field || change.type === "added")) changedOrAddedEvents.add(`${pallet}.${event}`);
+		else if (change.type === "added") Object.keys(b[pallet]).map((e) => `${pallet}.${e}`).forEach((ev) => changedOrAddedEvents.add(ev));
+	}
+	return {
+		changedOrAddedEvents,
+		changelog: changelog.toString()
+	};
+};
+const formatCode = (code) => require_index.format2(code, {
+	parser: "typescript",
+	singleQuote: true,
+	trailingComma: "all",
+	printWidth: 100
+});
+
+//#endregion
+exports.diffSpecs = diffSpecs;
+exports.formatCode = formatCode;