@jsprismarine/mcfunction 0.0.0-stage → 0.16.0-unstable-20261029132853

package/dist/registry.cjs.cjs

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_identifiers = require("./identifiers.cjs.cjs");
+const require_tags = require("./tags.cjs.cjs");
+const require_compile = require("./compile.cjs.cjs");
+const require_diagnostics = require("./diagnostics.cjs.cjs");
+// src/registry.ts
+/** The functions a pack stack loaded, keyed by namespaced id. */
+var FunctionRegistry = class {
+	functions = /* @__PURE__ */ new Map();
+	/** Registers a function, replacing whatever an earlier pack registered under the same id. */
+	add(compiled, pack) {
+		this.functions.set(compiled.id, {
+			compiled,
+			pack
+		});
+	}
+	/** Returns the winning function for an id. */
+	get(id) {
+		return this.functions.get(id)?.compiled;
+	}
+	/** Whether any pack registered the id. */
+	has(id) {
+		return this.functions.has(id);
+	}
+	/** The name of the pack whose file won the id. */
+	packOf(id) {
+		return this.functions.get(id)?.pack;
+	}
+	/** Every registered id, in registration order. */
+	ids() {
+		return [...this.functions.keys()];
+	}
+	/** How many functions are registered. */
+	get size() {
+		return this.functions.size;
+	}
+};
+var decoder = new TextDecoder("utf-8", { fatal: true });
+/** Decodes a file, or reports that it is not text. */
+var decode = (file, pack, path, collector) => {
+	if (typeof file === "string") return file;
+	try {
+		return decoder.decode(file);
+	} catch {
+		collector.add({
+			severity: "error",
+			code: "load.invalid-file",
+			pack,
+			message: `${path} is not valid UTF-8`
+		});
+		return;
+	}
+};
+/** Reads a function tag file, which is a JSON object with `values` and an optional `replace`. */
+var readTagFile = (text, pack, path, collector) => {
+	const report = (message) => {
+		collector.add({
+			severity: "error",
+			code: "load.invalid-file",
+			pack,
+			message: `${path}: ${message}`
+		});
+	};
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (error) {
+		return report(error instanceof Error ? error.message : String(error));
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return report("a tag file must be a JSON object");
+	if (!("values" in parsed) || !Array.isArray(parsed.values)) return report("the tag file has no values array");
+	const values = [];
+	for (const entry of parsed.values) {
+		if (typeof entry === "string") {
+			values.push(entry);
+			continue;
+		}
+		if (typeof entry === "object" && entry !== null && "id" in entry && typeof entry.id === "string") {
+			const required = "required" in entry && typeof entry.required === "boolean" ? entry.required : void 0;
+			values.push(required === void 0 ? { id: entry.id } : {
+				id: entry.id,
+				required
+			});
+			continue;
+		}
+		return report("a tag entry must be an id or an object with an id");
+	}
+	return {
+		values,
+		replace: "replace" in parsed && parsed.replace === true
+	};
+};
+/**
+* Loads every function and function tag a pack stack declares.
+*
+* Packs apply in order. A function id a later pack also declares is replaced
+* whole; a tag a later pack also declares is merged, unless that pack sets
+* `replace`. A file that does not compile is reported and left out, so one
+* broken function does not stop the rest of the stack from loading.
+*/
+var loadFunctions = (packs) => {
+	const functions = new FunctionRegistry();
+	const tags = new require_tags.FunctionTagRegistry();
+	const collector = new require_diagnostics.DiagnosticCollector();
+	for (const pack of packs) for (const [path, file] of pack.files) {
+		const functionId = require_identifiers.functionIdForPath(path);
+		if (functionId !== void 0) {
+			const text = decode(file, pack.name, path, collector);
+			if (text === void 0) continue;
+			const compiled = require_compile.compileFunction(functionId, text);
+			for (const diagnostic of compiled.diagnostics) collector.add({
+				...diagnostic,
+				pack: pack.name
+			});
+			if (compiled.function) functions.add(compiled.function, pack.name);
+			continue;
+		}
+		const tagId = require_identifiers.functionTagIdForPath(path);
+		if (tagId === void 0) continue;
+		const text = decode(file, pack.name, path, collector);
+		if (text === void 0) continue;
+		const tag = readTagFile(text, pack.name, path, collector);
+		if (tag) tags.add(tagId, tag);
+	}
+	return {
+		functions,
+		tags,
+		diagnostics: collector.diagnostics
+	};
+};
+exports.FunctionRegistry = FunctionRegistry;
+exports.loadFunctions = loadFunctions;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"registry.cjs.cjs","names":["FunctionTagRegistry","DiagnosticCollector","functionIdForPath","compileFunction","functionTagIdForPath"],"sources":["../src/registry.ts"],"sourcesContent":["/**\n * Loading functions and function tags from a stack of packs. The stack\n * composes the way the rest of this repository composes packs: a later pack\n * replaces an earlier one by identifier. Tags are the exception, because a tag\n * merges across packs unless it says `replace`, which is what lets two packs\n * both add to `minecraft:tick`.\n */\n\nimport type { CompiledFunction } from './compile';\nimport { compileFunction } from './compile';\nimport type { Diagnostic } from './diagnostics';\nimport { DiagnosticCollector } from './diagnostics';\nimport type { FunctionLookup } from './executor';\nimport { functionIdForPath, functionTagIdForPath } from './identifiers';\nimport type { FunctionTag, FunctionTagEntry } from './tags';\nimport { FunctionTagRegistry } from './tags';\n\n/**\n * One pack's files, keyed by pack-relative path. Any pack reader can supply\n * this: `@jsprismarine/packs` routes the JSON half of a datapack, and the\n * `.mcfunction` files it does not consume come through here unchanged.\n */\nexport interface FunctionPack {\n    /** The pack's name, used to attribute diagnostics and to say which pack won. */\n    name: string;\n    files: ReadonlyMap<string, string | Uint8Array>;\n}\n\n/** The functions a pack stack loaded, keyed by namespaced id. */\nexport class FunctionRegistry implements FunctionLookup {\n    private readonly functions = new Map<string, { compiled: CompiledFunction; pack: string }>();\n\n    /** Registers a function, replacing whatever an earlier pack registered under the same id. */\n    public add(compiled: CompiledFunction, pack: string): void {\n        this.functions.set(compiled.id, { compiled, pack });\n    }\n\n    /** Returns the winning function for an id. */\n    public get(id: string): CompiledFunction | undefined {\n        return this.functions.get(id)?.compiled;\n    }\n\n    /** Whether any pack registered the id. */\n    public has(id: string): boolean {\n        return this.functions.has(id);\n    }\n\n    /** The name of the pack whose file won the id. */\n    public packOf(id: string): string | undefined {\n        return this.functions.get(id)?.pack;\n    }\n\n    /** Every registered id, in registration order. */\n    public ids(): readonly string[] {\n        return [...this.functions.keys()];\n    }\n\n    /** How many functions are registered. */\n    public get size(): number {\n        return this.functions.size;\n    }\n}\n\n/** What {@link loadFunctions} produces. */\nexport interface FunctionLoadResult {\n    functions: FunctionRegistry;\n    tags: FunctionTagRegistry;\n    diagnostics: readonly Diagnostic[];\n}\n\nconst decoder = new TextDecoder('utf-8', { fatal: true });\n\n/** Decodes a file, or reports that it is not text. */\nconst decode = (\n    file: string | Uint8Array,\n    pack: string,\n    path: string,\n    collector: DiagnosticCollector\n): string | undefined => {\n    if (typeof file === 'string') return file;\n    try {\n        return decoder.decode(file);\n    } catch {\n        collector.add({\n            severity: 'error',\n            code: 'load.invalid-file',\n            pack,\n            message: `${path} is not valid UTF-8`\n        });\n        return undefined;\n    }\n};\n\n/** Reads a function tag file, which is a JSON object with `values` and an optional `replace`. */\nconst readTagFile = (\n    text: string,\n    pack: string,\n    path: string,\n    collector: DiagnosticCollector\n): FunctionTag | undefined => {\n    const report = (message: string): undefined => {\n        collector.add({ severity: 'error', code: 'load.invalid-file', pack, message: `${path}: ${message}` });\n        return undefined;\n    };\n\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(text);\n    } catch (error) {\n        return report(error instanceof Error ? error.message : String(error));\n    }\n\n    // Pack data is a parsed-input boundary, so every field is narrowed rather than asserted.\n    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {\n        return report('a tag file must be a JSON object');\n    }\n    if (!('values' in parsed) || !Array.isArray(parsed.values)) return report('the tag file has no values array');\n\n    const values: FunctionTagEntry[] = [];\n    for (const entry of parsed.values) {\n        if (typeof entry === 'string') {\n            values.push(entry);\n            continue;\n        }\n        if (typeof entry === 'object' && entry !== null && 'id' in entry && typeof entry.id === 'string') {\n            const required = 'required' in entry && typeof entry.required === 'boolean' ? entry.required : undefined;\n            values.push(required === undefined ? { id: entry.id } : { id: entry.id, required });\n            continue;\n        }\n        return report('a tag entry must be an id or an object with an id');\n    }\n\n    const replace = 'replace' in parsed && parsed.replace === true;\n    return { values, replace };\n};\n\n/**\n * Loads every function and function tag a pack stack declares.\n *\n * Packs apply in order. A function id a later pack also declares is replaced\n * whole; a tag a later pack also declares is merged, unless that pack sets\n * `replace`. A file that does not compile is reported and left out, so one\n * broken function does not stop the rest of the stack from loading.\n */\nexport const loadFunctions = (packs: readonly FunctionPack[]): FunctionLoadResult => {\n    const functions = new FunctionRegistry();\n    const tags = new FunctionTagRegistry();\n    const collector = new DiagnosticCollector();\n\n    for (const pack of packs) {\n        for (const [path, file] of pack.files) {\n            const functionId = functionIdForPath(path);\n            if (functionId !== undefined) {\n                const text = decode(file, pack.name, path, collector);\n                if (text === undefined) continue;\n\n                const compiled = compileFunction(functionId, text);\n                for (const diagnostic of compiled.diagnostics) collector.add({ ...diagnostic, pack: pack.name });\n                if (compiled.function) functions.add(compiled.function, pack.name);\n                continue;\n            }\n\n            const tagId = functionTagIdForPath(path);\n            if (tagId === undefined) continue;\n\n            const text = decode(file, pack.name, path, collector);\n            if (text === undefined) continue;\n\n            const tag = readTagFile(text, pack.name, path, collector);\n            if (tag) tags.add(tagId, tag);\n        }\n    }\n\n    return { functions, tags, diagnostics: collector.diagnostics };\n};\n"],"mappings":"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"}

package/dist/registry.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Loading functions and function tags from a stack of packs. The stack
+ * composes the way the rest of this repository composes packs: a later pack
+ * replaces an earlier one by identifier. Tags are the exception, because a tag
+ * merges across packs unless it says `replace`, which is what lets two packs
+ * both add to `minecraft:tick`.
+ */
+import type { CompiledFunction } from './compile';
+import type { Diagnostic } from './diagnostics';
+import type { FunctionLookup } from './executor';
+import { FunctionTagRegistry } from './tags';
+/**
+ * One pack's files, keyed by pack-relative path. Any pack reader can supply
+ * this: `@jsprismarine/packs` routes the JSON half of a datapack, and the
+ * `.mcfunction` files it does not consume come through here unchanged.
+ */
+export interface FunctionPack {
+    /** The pack's name, used to attribute diagnostics and to say which pack won. */
+    name: string;
+    files: ReadonlyMap<string, string | Uint8Array>;
+}
+/** The functions a pack stack loaded, keyed by namespaced id. */
+export declare class FunctionRegistry implements FunctionLookup {
+    private readonly functions;
+    /** Registers a function, replacing whatever an earlier pack registered under the same id. */
+    add(compiled: CompiledFunction, pack: string): void;
+    /** Returns the winning function for an id. */
+    get(id: string): CompiledFunction | undefined;
+    /** Whether any pack registered the id. */
+    has(id: string): boolean;
+    /** The name of the pack whose file won the id. */
+    packOf(id: string): string | undefined;
+    /** Every registered id, in registration order. */
+    ids(): readonly string[];
+    /** How many functions are registered. */
+    get size(): number;
+}
+/** What {@link loadFunctions} produces. */
+export interface FunctionLoadResult {
+    functions: FunctionRegistry;
+    tags: FunctionTagRegistry;
+    diagnostics: readonly Diagnostic[];
+}
+/**
+ * Loads every function and function tag a pack stack declares.
+ *
+ * Packs apply in order. A function id a later pack also declares is replaced
+ * whole; a tag a later pack also declares is merged, unless that pack sets
+ * `replace`. A file that does not compile is reported and left out, so one
+ * broken function does not stop the rest of the stack from loading.
+ */
+export declare const loadFunctions: (packs: readonly FunctionPack[]) => FunctionLoadResult;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAElD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAE7C;;;;GAIG;AACH,MAAM,WAAW,YAAY;IACzB,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC;CACnD;AAED,iEAAiE;AACjE,qBAAa,gBAAiB,YAAW,cAAc;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmE;IAE7F,6FAA6F;IACtF,GAAG,CAAC,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEzD;IAED,8CAA8C;IACvC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAEnD;IAED,0CAA0C;IACnC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE9B;IAED,kDAAkD;IAC3C,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE5C;IAED,kDAAkD;IAC3C,GAAG,IAAI,SAAS,MAAM,EAAE,CAE9B;IAED,yCAAyC;IACzC,IAAW,IAAI,IAAI,MAAM,CAExB;CACJ;AAED,2CAA2C;AAC3C,MAAM,WAAW,kBAAkB;IAC/B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CACtC;AAoED;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,UAAW,SAAS,YAAY,EAAE,KAAG,kBA8B9D,CAAC"}

package/dist/registry.es.js

@@ -0,0 +1,132 @@
+import { functionIdForPath, functionTagIdForPath } from "./identifiers.es.js";
+import { FunctionTagRegistry } from "./tags.es.js";
+import { compileFunction } from "./compile.es.js";
+import { DiagnosticCollector } from "./diagnostics.es.js";
+// src/registry.ts
+/** The functions a pack stack loaded, keyed by namespaced id. */
+var FunctionRegistry = class {
+	functions = /* @__PURE__ */ new Map();
+	/** Registers a function, replacing whatever an earlier pack registered under the same id. */
+	add(compiled, pack) {
+		this.functions.set(compiled.id, {
+			compiled,
+			pack
+		});
+	}
+	/** Returns the winning function for an id. */
+	get(id) {
+		return this.functions.get(id)?.compiled;
+	}
+	/** Whether any pack registered the id. */
+	has(id) {
+		return this.functions.has(id);
+	}
+	/** The name of the pack whose file won the id. */
+	packOf(id) {
+		return this.functions.get(id)?.pack;
+	}
+	/** Every registered id, in registration order. */
+	ids() {
+		return [...this.functions.keys()];
+	}
+	/** How many functions are registered. */
+	get size() {
+		return this.functions.size;
+	}
+};
+var decoder = new TextDecoder("utf-8", { fatal: true });
+/** Decodes a file, or reports that it is not text. */
+var decode = (file, pack, path, collector) => {
+	if (typeof file === "string") return file;
+	try {
+		return decoder.decode(file);
+	} catch {
+		collector.add({
+			severity: "error",
+			code: "load.invalid-file",
+			pack,
+			message: `${path} is not valid UTF-8`
+		});
+		return;
+	}
+};
+/** Reads a function tag file, which is a JSON object with `values` and an optional `replace`. */
+var readTagFile = (text, pack, path, collector) => {
+	const report = (message) => {
+		collector.add({
+			severity: "error",
+			code: "load.invalid-file",
+			pack,
+			message: `${path}: ${message}`
+		});
+	};
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (error) {
+		return report(error instanceof Error ? error.message : String(error));
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return report("a tag file must be a JSON object");
+	if (!("values" in parsed) || !Array.isArray(parsed.values)) return report("the tag file has no values array");
+	const values = [];
+	for (const entry of parsed.values) {
+		if (typeof entry === "string") {
+			values.push(entry);
+			continue;
+		}
+		if (typeof entry === "object" && entry !== null && "id" in entry && typeof entry.id === "string") {
+			const required = "required" in entry && typeof entry.required === "boolean" ? entry.required : void 0;
+			values.push(required === void 0 ? { id: entry.id } : {
+				id: entry.id,
+				required
+			});
+			continue;
+		}
+		return report("a tag entry must be an id or an object with an id");
+	}
+	return {
+		values,
+		replace: "replace" in parsed && parsed.replace === true
+	};
+};
+/**
+* Loads every function and function tag a pack stack declares.
+*
+* Packs apply in order. A function id a later pack also declares is replaced
+* whole; a tag a later pack also declares is merged, unless that pack sets
+* `replace`. A file that does not compile is reported and left out, so one
+* broken function does not stop the rest of the stack from loading.
+*/
+var loadFunctions = (packs) => {
+	const functions = new FunctionRegistry();
+	const tags = new FunctionTagRegistry();
+	const collector = new DiagnosticCollector();
+	for (const pack of packs) for (const [path, file] of pack.files) {
+		const functionId = functionIdForPath(path);
+		if (functionId !== void 0) {
+			const text = decode(file, pack.name, path, collector);
+			if (text === void 0) continue;
+			const compiled = compileFunction(functionId, text);
+			for (const diagnostic of compiled.diagnostics) collector.add({
+				...diagnostic,
+				pack: pack.name
+			});
+			if (compiled.function) functions.add(compiled.function, pack.name);
+			continue;
+		}
+		const tagId = functionTagIdForPath(path);
+		if (tagId === void 0) continue;
+		const text = decode(file, pack.name, path, collector);
+		if (text === void 0) continue;
+		const tag = readTagFile(text, pack.name, path, collector);
+		if (tag) tags.add(tagId, tag);
+	}
+	return {
+		functions,
+		tags,
+		diagnostics: collector.diagnostics
+	};
+};
+export { FunctionRegistry, loadFunctions };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"registry.es.js","names":[],"sources":["../src/registry.ts"],"sourcesContent":["/**\n * Loading functions and function tags from a stack of packs. The stack\n * composes the way the rest of this repository composes packs: a later pack\n * replaces an earlier one by identifier. Tags are the exception, because a tag\n * merges across packs unless it says `replace`, which is what lets two packs\n * both add to `minecraft:tick`.\n */\n\nimport type { CompiledFunction } from './compile';\nimport { compileFunction } from './compile';\nimport type { Diagnostic } from './diagnostics';\nimport { DiagnosticCollector } from './diagnostics';\nimport type { FunctionLookup } from './executor';\nimport { functionIdForPath, functionTagIdForPath } from './identifiers';\nimport type { FunctionTag, FunctionTagEntry } from './tags';\nimport { FunctionTagRegistry } from './tags';\n\n/**\n * One pack's files, keyed by pack-relative path. Any pack reader can supply\n * this: `@jsprismarine/packs` routes the JSON half of a datapack, and the\n * `.mcfunction` files it does not consume come through here unchanged.\n */\nexport interface FunctionPack {\n    /** The pack's name, used to attribute diagnostics and to say which pack won. */\n    name: string;\n    files: ReadonlyMap<string, string | Uint8Array>;\n}\n\n/** The functions a pack stack loaded, keyed by namespaced id. */\nexport class FunctionRegistry implements FunctionLookup {\n    private readonly functions = new Map<string, { compiled: CompiledFunction; pack: string }>();\n\n    /** Registers a function, replacing whatever an earlier pack registered under the same id. */\n    public add(compiled: CompiledFunction, pack: string): void {\n        this.functions.set(compiled.id, { compiled, pack });\n    }\n\n    /** Returns the winning function for an id. */\n    public get(id: string): CompiledFunction | undefined {\n        return this.functions.get(id)?.compiled;\n    }\n\n    /** Whether any pack registered the id. */\n    public has(id: string): boolean {\n        return this.functions.has(id);\n    }\n\n    /** The name of the pack whose file won the id. */\n    public packOf(id: string): string | undefined {\n        return this.functions.get(id)?.pack;\n    }\n\n    /** Every registered id, in registration order. */\n    public ids(): readonly string[] {\n        return [...this.functions.keys()];\n    }\n\n    /** How many functions are registered. */\n    public get size(): number {\n        return this.functions.size;\n    }\n}\n\n/** What {@link loadFunctions} produces. */\nexport interface FunctionLoadResult {\n    functions: FunctionRegistry;\n    tags: FunctionTagRegistry;\n    diagnostics: readonly Diagnostic[];\n}\n\nconst decoder = new TextDecoder('utf-8', { fatal: true });\n\n/** Decodes a file, or reports that it is not text. */\nconst decode = (\n    file: string | Uint8Array,\n    pack: string,\n    path: string,\n    collector: DiagnosticCollector\n): string | undefined => {\n    if (typeof file === 'string') return file;\n    try {\n        return decoder.decode(file);\n    } catch {\n        collector.add({\n            severity: 'error',\n            code: 'load.invalid-file',\n            pack,\n            message: `${path} is not valid UTF-8`\n        });\n        return undefined;\n    }\n};\n\n/** Reads a function tag file, which is a JSON object with `values` and an optional `replace`. */\nconst readTagFile = (\n    text: string,\n    pack: string,\n    path: string,\n    collector: DiagnosticCollector\n): FunctionTag | undefined => {\n    const report = (message: string): undefined => {\n        collector.add({ severity: 'error', code: 'load.invalid-file', pack, message: `${path}: ${message}` });\n        return undefined;\n    };\n\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(text);\n    } catch (error) {\n        return report(error instanceof Error ? error.message : String(error));\n    }\n\n    // Pack data is a parsed-input boundary, so every field is narrowed rather than asserted.\n    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {\n        return report('a tag file must be a JSON object');\n    }\n    if (!('values' in parsed) || !Array.isArray(parsed.values)) return report('the tag file has no values array');\n\n    const values: FunctionTagEntry[] = [];\n    for (const entry of parsed.values) {\n        if (typeof entry === 'string') {\n            values.push(entry);\n            continue;\n        }\n        if (typeof entry === 'object' && entry !== null && 'id' in entry && typeof entry.id === 'string') {\n            const required = 'required' in entry && typeof entry.required === 'boolean' ? entry.required : undefined;\n            values.push(required === undefined ? { id: entry.id } : { id: entry.id, required });\n            continue;\n        }\n        return report('a tag entry must be an id or an object with an id');\n    }\n\n    const replace = 'replace' in parsed && parsed.replace === true;\n    return { values, replace };\n};\n\n/**\n * Loads every function and function tag a pack stack declares.\n *\n * Packs apply in order. A function id a later pack also declares is replaced\n * whole; a tag a later pack also declares is merged, unless that pack sets\n * `replace`. A file that does not compile is reported and left out, so one\n * broken function does not stop the rest of the stack from loading.\n */\nexport const loadFunctions = (packs: readonly FunctionPack[]): FunctionLoadResult => {\n    const functions = new FunctionRegistry();\n    const tags = new FunctionTagRegistry();\n    const collector = new DiagnosticCollector();\n\n    for (const pack of packs) {\n        for (const [path, file] of pack.files) {\n            const functionId = functionIdForPath(path);\n            if (functionId !== undefined) {\n                const text = decode(file, pack.name, path, collector);\n                if (text === undefined) continue;\n\n                const compiled = compileFunction(functionId, text);\n                for (const diagnostic of compiled.diagnostics) collector.add({ ...diagnostic, pack: pack.name });\n                if (compiled.function) functions.add(compiled.function, pack.name);\n                continue;\n            }\n\n            const tagId = functionTagIdForPath(path);\n            if (tagId === undefined) continue;\n\n            const text = decode(file, pack.name, path, collector);\n            if (text === undefined) continue;\n\n            const tag = readTagFile(text, pack.name, path, collector);\n            if (tag) tags.add(tagId, tag);\n        }\n    }\n\n    return { functions, tags, diagnostics: collector.diagnostics };\n};\n"],"mappings":"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"}

package/dist/runner.cjs.cjs

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/runner.ts
+/**
+* A runner that records what it was asked to run instead of running it. It is
+* the second adapter at the command seam: tests and pack authors use it to
+* check what a function would execute without a world to execute it against.
+*
+* @example
+* ```ts
+* const runner = new RecordingCommandRunner();
+* new FunctionExecutor({ functions, runner }).run('pack:greet', { source: console });
+* expect(runner.commandLines).toEqual(['say hello']);
+* ```
+*/
+var RecordingCommandRunner = class {
+	respond;
+	/** Every command handed to the runner, in execution order. */
+	recorded = [];
+	constructor(respond = () => ({})) {
+		this.respond = respond;
+	}
+	/** Records the command and returns whatever the configured response says. */
+	run(commandLine, context) {
+		this.recorded.push({
+			commandLine,
+			context
+		});
+		return this.respond(commandLine, context);
+	}
+	/** The recorded command text, in execution order. */
+	get commandLines() {
+		return this.recorded.map((entry) => entry.commandLine);
+	}
+	/** Forgets everything recorded so far. */
+	clear() {
+		this.recorded.length = 0;
+	}
+};
+exports.RecordingCommandRunner = RecordingCommandRunner;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVubmVyLmNqcy5janMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vc3JjL3J1bm5lci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFRoZSBzZWFtIGJldHdlZW4gdGhpcyBwYWNrYWdlIGFuZCB0aGUgY29tbWFuZHMuIFRoaXMgcGFja2FnZSBydW5zIGZ1bmN0aW9uc1xuICogYW5kIG5ldmVyIGltcGxlbWVudHMgYSBjb21tYW5kOiBldmVyeSBsaW5lIGl0IGRvZXMgbm90IGhhbmRsZSBpdHNlbGYgZ29lcyB0b1xuICogYSB7QGxpbmsgQ29tbWFuZFJ1bm5lcn0sIHdoaWNoIGlzIHdoZXJlIHRoZSBzZXJ2ZXIncyBCcmlnYWRpZXIgZGlzcGF0Y2hlclxuICogcGx1Z3MgaW4uXG4gKi9cblxuLyoqIFdoYXQgYSBjb21tYW5kIGlzIHRvbGQgYWJvdXQgdGhlIGxpbmUgaXQgd2FzIHJlYWNoZWQgZnJvbS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ29tbWFuZENvbnRleHQ8VFNvdXJjZSA9IHVua25vd24+IHtcbiAgICAvKiogV2hhdGV2ZXIgdGhlIHNlcnZlciB1c2VzIGFzIGEgY29tbWFuZCBzb3VyY2UsIHBhc3NlZCB0aHJvdWdoIHVudG91Y2hlZC4gKi9cbiAgICBzb3VyY2U6IFRTb3VyY2U7XG4gICAgLyoqIFRoZSBuYW1lc3BhY2VkIGlkIG9mIHRoZSBmdW5jdGlvbiB0aGUgbGluZSBiZWxvbmdzIHRvLiAqL1xuICAgIGZ1bmN0aW9uSWQ6IHN0cmluZztcbiAgICAvKiogVGhlIDEtYmFzZWQgbGluZSBvZiB0aGF0IGZ1bmN0aW9uJ3MgZmlsZS4gKi9cbiAgICBsaW5lOiBudW1iZXI7XG59XG5cbi8qKiBXaGF0IGEgY29tbWFuZCByZXBvcnRzIGJhY2suICovXG5leHBvcnQgaW50ZXJmYWNlIENvbW1hbmRPdXRjb21lIHtcbiAgICAvKiogVGhlIGNvbW1hbmQncyBpbnRlZ2VyIHJlc3VsdCwgYXMgQnJpZ2FkaWVyIGRlZmluZXMgaXQuIERlZmF1bHRzIHRvIDAuICovXG4gICAgcmVzdWx0PzogbnVtYmVyO1xuICAgIC8qKlxuICAgICAqIEhvdyBtYW55IGNvbnRleHRzIHRoZSBjb21tYW5kIGNyZWF0ZWQsIHdoaWNoIGlzIHdoYXQgYG1heENvbW1hbmRGb3Jrc2BcbiAgICAgKiBjb3VudHMuIGBleGVjdXRlIGFzIEBlYCB3aXRoIGZpdmUgbWF0Y2hpbmcgZW50aXRpZXMgcmVwb3J0cyA1LiBBIGNvbW1hbmRcbiAgICAgKiB0aGF0IHJ1bnMgaW4gb25lIGNvbnRleHQgcmVwb3J0cyBub3RoaW5nLlxuICAgICAqL1xuICAgIGZvcmtzPzogbnVtYmVyO1xuICAgIC8qKlxuICAgICAqIFNldCB3aGVuIHRoZSBsaW5lIGVuZGVkIHRoZSBmdW5jdGlvbiBpdCBiZWxvbmdzIHRvLCB3aGljaCBpcyB3aGF0XG4gICAgICogYC9yZXR1cm5gIGRvZXMuIFRoZSBleGVjdXRvciBkcm9wcyB0aGF0IGZ1bmN0aW9uJ3MgcmVtYWluaW5nIGxpbmVzIGFuZFxuICAgICAqIGNhcnJpZXMgb24gd2l0aCB3aGF0ZXZlciBjYWxsZWQgaXQuXG4gICAgICpcbiAgICAgKiBgdmFsdWVgIGlzIHdoYXQgdGhlIGZ1bmN0aW9uIHJldHVybnMuIGAvcmV0dXJuIGZhaWxgLCBhbmQgYVxuICAgICAqIGAvcmV0dXJuIHJ1bmAgd2hvc2UgY29tbWFuZCBmYWlsZWQsIGVuZCB0aGUgZnVuY3Rpb24gd2l0aG91dCBvbmUsIHdoaWNoXG4gICAgICogaXMgdGhlIGNhc2UgYGV4ZWN1dGUgaWYgZnVuY3Rpb25gIGRvZXMgbm90IG1hdGNoLlxuICAgICAqL1xuICAgIHJldHVybmVkPzogeyByZWFkb25seSB2YWx1ZT86IG51bWJlciB9O1xufVxuXG4vKiogUnVucyBvbmUgY29tbWFuZCBsaW5lLiBUaGUgc2VydmVyJ3MgZGlzcGF0Y2hlciBpcyB0aGUgcmVhbCBhZGFwdGVyIGF0IHRoaXMgc2VhbS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ29tbWFuZFJ1bm5lcjxUU291cmNlID0gdW5rbm93bj4ge1xuICAgIC8qKlxuICAgICAqIFJ1bnMgb25lIGNvbW1hbmQsIHdyaXR0ZW4gd2l0aG91dCBhIGxlYWRpbmcgc2xhc2guXG4gICAgICpcbiAgICAgKiBUaGUgcnVudGltZSBuZXZlciBjYWxscyB0aGlzIHdpdGggYSBjb21tYW5kIHRoZSBsaW5lIGZvcm1hdCBhbHJlYWR5XG4gICAgICogaGFuZGxlcywgc28gYSBgZnVuY3Rpb25gIGxpbmUgbmV2ZXIgcmVhY2hlcyBpdC4gVGhyb3dpbmcgaXMgYWxsb3dlZDogdGhlXG4gICAgICogZXhlY3V0b3IgY2F0Y2hlcyBpdCwgcmVwb3J0cyBpdCwgYW5kIGNhcnJpZXMgb24gd2l0aCB0aGUgbmV4dCBsaW5lLCB0aGVcbiAgICAgKiB3YXkgb25lIGZhaWxpbmcgY29tbWFuZCBkb2VzIG5vdCBhYm9ydCBhIEphdmEgZnVuY3Rpb24uXG4gICAgICovXG4gICAgcnVuKGNvbW1hbmRMaW5lOiBzdHJpbmcsIGNvbnRleHQ6IENvbW1hbmRDb250ZXh0PFRTb3VyY2U+KTogQ29tbWFuZE91dGNvbWU7XG59XG5cbi8qKiBPbmUgY29tbWFuZCBhIHtAbGluayBSZWNvcmRpbmdDb21tYW5kUnVubmVyfSB3YXMgYXNrZWQgdG8gcnVuLiAqL1xuZXhwb3J0IGludGVyZmFjZSBSZWNvcmRlZENvbW1hbmQ8VFNvdXJjZSA9IHVua25vd24+IHtcbiAgICBjb21tYW5kTGluZTogc3RyaW5nO1xuICAgIGNvbnRleHQ6IENvbW1hbmRDb250ZXh0PFRTb3VyY2U+O1xufVxuXG4vKipcbiAqIEEgcnVubmVyIHRoYXQgcmVjb3JkcyB3aGF0IGl0IHdhcyBhc2tlZCB0byBydW4gaW5zdGVhZCBvZiBydW5uaW5nIGl0LiBJdCBpc1xuICogdGhlIHNlY29uZCBhZGFwdGVyIGF0IHRoZSBjb21tYW5kIHNlYW06IHRlc3RzIGFuZCBwYWNrIGF1dGhvcnMgdXNlIGl0IHRvXG4gKiBjaGVjayB3aGF0IGEgZnVuY3Rpb24gd291bGQgZXhlY3V0ZSB3aXRob3V0IGEgd29ybGQgdG8gZXhlY3V0ZSBpdCBhZ2FpbnN0LlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0c1xuICogY29uc3QgcnVubmVyID0gbmV3IFJlY29yZGluZ0NvbW1hbmRSdW5uZXIoKTtcbiAqIG5ldyBGdW5jdGlvbkV4ZWN1dG9yKHsgZnVuY3Rpb25zLCBydW5uZXIgfSkucnVuKCdwYWNrOmdyZWV0JywgeyBzb3VyY2U6IGNvbnNvbGUgfSk7XG4gKiBleHBlY3QocnVubmVyLmNvbW1hbmRMaW5lcykudG9FcXVhbChbJ3NheSBoZWxsbyddKTtcbiAqIGBgYFxuICovXG5leHBvcnQgY2xhc3MgUmVjb3JkaW5nQ29tbWFuZFJ1bm5lcjxUU291cmNlID0gdW5rbm93bj4gaW1wbGVtZW50cyBDb21tYW5kUnVubmVyPFRTb3VyY2U+IHtcbiAgICAvKiogRXZlcnkgY29tbWFuZCBoYW5kZWQgdG8gdGhlIHJ1bm5lciwgaW4gZXhlY3V0aW9uIG9yZGVyLiAqL1xuICAgIHB1YmxpYyByZWFkb25seSByZWNvcmRlZDogUmVjb3JkZWRDb21tYW5kPFRTb3VyY2U+W10gPSBbXTtcblxuICAgIHB1YmxpYyBjb25zdHJ1Y3RvcihcbiAgICAgICAgLyoqIERlY2lkZXMgd2hhdCBlYWNoIGNvbW1hbmQgcmVwb3J0cyBiYWNrLiBFdmVyeXRoaW5nIHN1Y2NlZWRzIHdpdGggbm8gZm9ya3MgYnkgZGVmYXVsdC4gKi9cbiAgICAgICAgcHJpdmF0ZSByZWFkb25seSByZXNwb25kOiAoY29tbWFuZExpbmU6IHN0cmluZywgY29udGV4dDogQ29tbWFuZENvbnRleHQ8VFNvdXJjZT4pID0+IENvbW1hbmRPdXRjb21lID0gKCkgPT4gKHt9KVxuICAgICkge31cblxuICAgIC8qKiBSZWNvcmRzIHRoZSBjb21tYW5kIGFuZCByZXR1cm5zIHdoYXRldmVyIHRoZSBjb25maWd1cmVkIHJlc3BvbnNlIHNheXMuICovXG4gICAgcHVibGljIHJ1bihjb21tYW5kTGluZTogc3RyaW5nLCBjb250ZXh0OiBDb21tYW5kQ29udGV4dDxUU291cmNlPik6IENvbW1hbmRPdXRjb21lIHtcbiAgICAgICAgdGhpcy5yZWNvcmRlZC5wdXNoKHsgY29tbWFuZExpbmUsIGNvbnRleHQgfSk7XG4gICAgICAgIHJldHVybiB0aGlzLnJlc3BvbmQoY29tbWFuZExpbmUsIGNvbnRleHQpO1xuICAgIH1cblxuICAgIC8qKiBUaGUgcmVjb3JkZWQgY29tbWFuZCB0ZXh0LCBpbiBleGVjdXRpb24gb3JkZXIuICovXG4gICAgcHVibGljIGdldCBjb21tYW5kTGluZXMoKTogcmVhZG9ubHkgc3RyaW5nW10ge1xuICAgICAgICByZXR1cm4gdGhpcy5yZWNvcmRlZC5tYXAoKGVudHJ5KSA9PiBlbnRyeS5jb21tYW5kTGluZSk7XG4gICAgfVxuXG4gICAgLyoqIEZvcmdldHMgZXZlcnl0aGluZyByZWNvcmRlZCBzbyBmYXIuICovXG4gICAgcHVibGljIGNsZWFyKCk6IHZvaWQge1xuICAgICAgICB0aGlzLnJlY29yZGVkLmxlbmd0aCA9IDA7XG4gICAgfVxufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7QUFzRUEsSUFBYSx5QkFBYixNQUF5RjtDQU1oRTs7Q0FKckIsV0FBdUQsQ0FBQztDQUV4RCxZQUVJLGlCQUE2RyxDQUFDLElBQ2hIO0VBRG1CLEtBQUEsVUFBQTtDQUNsQjs7Q0FHSCxJQUFXLGFBQXFCLFNBQWtEO0VBQzlFLEtBQUssU0FBUyxLQUFLO0dBQUU7R0FBYTtFQUFRLENBQUM7RUFDM0MsT0FBTyxLQUFLLFFBQVEsYUFBYSxPQUFPO0NBQzVDOztDQUdBLElBQVcsZUFBa0M7RUFDekMsT0FBTyxLQUFLLFNBQVMsS0FBSyxVQUFVLE1BQU0sV0FBVztDQUN6RDs7Q0FHQSxRQUFxQjtFQUNqQixLQUFLLFNBQVMsU0FBUztDQUMzQjtBQUNKIn0=

package/dist/runner.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The seam between this package and the commands. This package runs functions
+ * and never implements a command: every line it does not handle itself goes to
+ * a {@link CommandRunner}, which is where the server's Brigadier dispatcher
+ * plugs in.
+ */
+/** What a command is told about the line it was reached from. */
+export interface CommandContext<TSource = unknown> {
+    /** Whatever the server uses as a command source, passed through untouched. */
+    source: TSource;
+    /** The namespaced id of the function the line belongs to. */
+    functionId: string;
+    /** The 1-based line of that function's file. */
+    line: number;
+}
+/** What a command reports back. */
+export interface CommandOutcome {
+    /** The command's integer result, as Brigadier defines it. Defaults to 0. */
+    result?: number;
+    /**
+     * How many contexts the command created, which is what `maxCommandForks`
+     * counts. `execute as @e` with five matching entities reports 5. A command
+     * that runs in one context reports nothing.
+     */
+    forks?: number;
+    /**
+     * Set when the line ended the function it belongs to, which is what
+     * `/return` does. The executor drops that function's remaining lines and
+     * carries on with whatever called it.
+     *
+     * `value` is what the function returns. `/return fail`, and a
+     * `/return run` whose command failed, end the function without one, which
+     * is the case `execute if function` does not match.
+     */
+    returned?: {
+        readonly value?: number;
+    };
+}
+/** Runs one command line. The server's dispatcher is the real adapter at this seam. */
+export interface CommandRunner<TSource = unknown> {
+    /**
+     * Runs one command, written without a leading slash.
+     *
+     * The runtime never calls this with a command the line format already
+     * handles, so a `function` line never reaches it. Throwing is allowed: the
+     * executor catches it, reports it, and carries on with the next line, the
+     * way one failing command does not abort a Java function.
+     */
+    run(commandLine: string, context: CommandContext<TSource>): CommandOutcome;
+}
+/** One command a {@link RecordingCommandRunner} was asked to run. */
+export interface RecordedCommand<TSource = unknown> {
+    commandLine: string;
+    context: CommandContext<TSource>;
+}
+/**
+ * A runner that records what it was asked to run instead of running it. It is
+ * the second adapter at the command seam: tests and pack authors use it to
+ * check what a function would execute without a world to execute it against.
+ *
+ * @example
+ * ```ts
+ * const runner = new RecordingCommandRunner();
+ * new FunctionExecutor({ functions, runner }).run('pack:greet', { source: console });
+ * expect(runner.commandLines).toEqual(['say hello']);
+ * ```
+ */
+export declare class RecordingCommandRunner<TSource = unknown> implements CommandRunner<TSource> {
+    /** Decides what each command reports back. Everything succeeds with no forks by default. */
+    private readonly respond;
+    /** Every command handed to the runner, in execution order. */
+    readonly recorded: RecordedCommand<TSource>[];
+    constructor(
+    /** Decides what each command reports back. Everything succeeds with no forks by default. */
+    respond?: (commandLine: string, context: CommandContext<TSource>) => CommandOutcome);
+    /** Records the command and returns whatever the configured response says. */
+    run(commandLine: string, context: CommandContext<TSource>): CommandOutcome;
+    /** The recorded command text, in execution order. */
+    get commandLines(): readonly string[];
+    /** Forgets everything recorded so far. */
+    clear(): void;
+}
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,iEAAiE;AACjE,MAAM,WAAW,cAAc,CAAC,OAAO,GAAG,OAAO;IAC7C,8EAA8E;IAC9E,MAAM,EAAE,OAAO,CAAC;IAChB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,mCAAmC;AACnC,MAAM,WAAW,cAAc;IAC3B,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1C;AAED,uFAAuF;AACvF,MAAM,WAAW,aAAa,CAAC,OAAO,GAAG,OAAO;IAC5C;;;;;;;OAOG;IACH,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,cAAc,CAAC;CAC9E;AAED,qEAAqE;AACrE,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,OAAO;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,sBAAsB,CAAC,OAAO,GAAG,OAAO,CAAE,YAAW,aAAa,CAAC,OAAO,CAAC;IAKhF,4FAA4F;IAC5F,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL5B,8DAA8D;IAC9D,SAAgB,QAAQ,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,CAAM;IAE1D;IACI,4FAA4F;IAC3E,OAAO,GAAE,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,KAAK,cAA2B,EAChH;IAEJ,6EAA6E;IACtE,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,cAAc,CAGhF;IAED,qDAAqD;IACrD,IAAW,YAAY,IAAI,SAAS,MAAM,EAAE,CAE3C;IAED,0CAA0C;IACnC,KAAK,IAAI,IAAI,CAEnB;CACJ"}

package/dist/runner.es.js

@@ -0,0 +1,40 @@
+// src/runner.ts
+/**
+* A runner that records what it was asked to run instead of running it. It is
+* the second adapter at the command seam: tests and pack authors use it to
+* check what a function would execute without a world to execute it against.
+*
+* @example
+* ```ts
+* const runner = new RecordingCommandRunner();
+* new FunctionExecutor({ functions, runner }).run('pack:greet', { source: console });
+* expect(runner.commandLines).toEqual(['say hello']);
+* ```
+*/
+var RecordingCommandRunner = class {
+	respond;
+	/** Every command handed to the runner, in execution order. */
+	recorded = [];
+	constructor(respond = () => ({})) {
+		this.respond = respond;
+	}
+	/** Records the command and returns whatever the configured response says. */
+	run(commandLine, context) {
+		this.recorded.push({
+			commandLine,
+			context
+		});
+		return this.respond(commandLine, context);
+	}
+	/** The recorded command text, in execution order. */
+	get commandLines() {
+		return this.recorded.map((entry) => entry.commandLine);
+	}
+	/** Forgets everything recorded so far. */
+	clear() {
+		this.recorded.length = 0;
+	}
+};
+export { RecordingCommandRunner };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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