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

package/dist/compile.cjs.cjs

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_macro = require("./macro.cjs.cjs");
+const require_parse = require("./parse.cjs.cjs");
+// src/compile.ts
+/**
+* How many argument sets one macro function remembers. Java's
+* `MacroFunction` carries 8 as its only integer constant, and caches only the
+* values the macro actually references, so extra entries in the compound do
+* not split the cache.
+*/
+var MACRO_CACHE_ENTRIES = 8;
+/**
+* A function file ready to run. Instances come from {@link compileFunction}
+* and are shared by every call, including the macro cache.
+*/
+var CompiledFunction = class {
+	id;
+	lines;
+	/** Whether any line of the function is a macro line, so calls need arguments. */
+	macro;
+	/** Every variable the function substitutes, once each, in first-use order. */
+	variables;
+	cache = /* @__PURE__ */ new Map();
+	plain;
+	constructor(id, lines) {
+		this.id = id;
+		this.lines = lines;
+		this.macro = lines.some((line) => "template" in line);
+		const variables = [];
+		for (const line of lines) {
+			if (!("template" in line)) continue;
+			for (const variable of line.template.variables) if (!variables.includes(variable)) variables.push(variable);
+		}
+		this.variables = variables;
+		this.plain = this.macro ? void 0 : lines.flatMap((line) => "command" in line ? [{
+			command: line.command,
+			line: line.line
+		}] : []);
+	}
+	/** How many commands the function declares. */
+	get length() {
+		return this.lines.length;
+	}
+	/**
+	* Produces the commands one call runs.
+	*
+	* A plain function ignores the arguments, the way the Java server
+	* silently ignores a compound passed to a non-macro function. A macro
+	* function needs one entry per variable it substitutes and reports the
+	* first entry it is missing; the Java server skips the whole call in that
+	* case, and so does {@link FunctionExecutor}.
+	*/
+	instantiate(args) {
+		if (this.plain) return {
+			ok: true,
+			commands: this.plain
+		};
+		if (args === void 0) return {
+			ok: false,
+			message: `${this.id} is a macro function and was called without arguments`
+		};
+		for (const variable of this.variables) {
+			const value = args[variable];
+			if (value === void 0 || value === null) return {
+				ok: false,
+				message: `the macro arguments have no entry for '${variable}'`
+			};
+		}
+		const key = JSON.stringify(this.variables.map((variable) => args[variable] ?? null));
+		const cached = this.cache.get(key);
+		if (cached) {
+			this.cache.delete(key);
+			this.cache.set(key, cached);
+			return {
+				ok: true,
+				commands: cached
+			};
+		}
+		const commands = [];
+		for (const line of this.lines) {
+			if ("command" in line) {
+				commands.push({
+					command: line.command,
+					line: line.line
+				});
+				continue;
+			}
+			const substituted = require_macro.substituteMacro(line.template, args);
+			if (!substituted.ok) return {
+				ok: false,
+				message: substituted.message,
+				line: line.line
+			};
+			commands.push({
+				command: substituted.command,
+				line: line.line
+			});
+		}
+		this.cache.set(key, commands);
+		if (this.cache.size > 8) {
+			const oldest = this.cache.keys().next();
+			if (!oldest.done) this.cache.delete(oldest.value);
+		}
+		return {
+			ok: true,
+			commands
+		};
+	}
+	/** How many argument sets the macro cache currently holds. */
+	get cachedArgumentSets() {
+		return this.cache.size;
+	}
+};
+/**
+* Compiles one function file.
+*
+* A file with any error does not produce a function, matching the Java
+* server, where a file that fails `CommandFunction.fromLines` is logged and
+* left out of the function library rather than partly loaded.
+*
+* @param id - The namespaced id the file loads under.
+* @param source - The text of the `.mcfunction` file.
+*/
+var compileFunction = (id, source) => {
+	const parsed = require_parse.parseFunctionSource(source);
+	const diagnostics = parsed.diagnostics.map((diagnostic) => ({
+		...diagnostic,
+		functionId: id
+	}));
+	const lines = [];
+	for (const line of parsed.lines) {
+		if (!line.macro) {
+			lines.push({
+				line: line.line,
+				command: line.command
+			});
+			continue;
+		}
+		const compiled = require_macro.compileMacroLine(line.command);
+		if (!compiled.ok) {
+			diagnostics.push({
+				severity: "error",
+				code: "macro.invalid",
+				functionId: id,
+				line: line.line,
+				message: compiled.message
+			});
+			continue;
+		}
+		lines.push({
+			line: line.line,
+			template: compiled.template
+		});
+	}
+	if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) return { diagnostics };
+	return {
+		function: new CompiledFunction(id, lines),
+		diagnostics
+	};
+};
+exports.CompiledFunction = CompiledFunction;
+exports.MACRO_CACHE_ENTRIES = MACRO_CACHE_ENTRIES;
+exports.compileFunction = compileFunction;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"compile.cjs.cjs","names":["substituteMacro","parseFunctionSource","compileMacroLine"],"sources":["../src/compile.ts"],"sourcesContent":["/**\n * A function file compiled once into the commands a call runs. A plain\n * function is instantiated for free, every call sharing the same lines. A\n * macro function re-instantiates per argument set, so it keeps a small cache\n * of recent sets, which is what makes repeated calls with the same arguments\n * cheaper than new ones.\n */\n\nimport type { Diagnostic } from './diagnostics';\nimport type { MacroArguments, MacroTemplate } from './macro';\nimport { compileMacroLine, substituteMacro } from './macro';\nimport { parseFunctionSource } from './parse';\n\n/**\n * How many argument sets one macro function remembers. Java's\n * `MacroFunction` carries 8 as its only integer constant, and caches only the\n * values the macro actually references, so extra entries in the compound do\n * not split the cache.\n */\nexport const MACRO_CACHE_ENTRIES = 8;\n\n/** One command a call is about to run. */\nexport interface InstantiatedCommand {\n    /** The command text, with every macro substitution already filled in. */\n    command: string;\n    /** The 1-based line of the function file the command came from. */\n    line: number;\n}\n\n/** The outcome of instantiating a function for one call. */\nexport type InstantiationResult =\n    { ok: true; commands: readonly InstantiatedCommand[] } | { ok: false; message: string; line?: number };\n\n/** One compiled line: fixed text, or a template waiting for arguments. */\ntype CompiledLine = { line: number; command: string } | { line: number; template: MacroTemplate };\n\n/**\n * A function file ready to run. Instances come from {@link compileFunction}\n * and are shared by every call, including the macro cache.\n */\nexport class CompiledFunction {\n    /** Whether any line of the function is a macro line, so calls need arguments. */\n    public readonly macro: boolean;\n\n    /** Every variable the function substitutes, once each, in first-use order. */\n    public readonly variables: readonly string[];\n\n    private readonly cache = new Map<string, readonly InstantiatedCommand[]>();\n\n    private readonly plain: readonly InstantiatedCommand[] | undefined;\n\n    public constructor(\n        /** The namespaced id the function is registered under. */\n        public readonly id: string,\n        private readonly lines: readonly CompiledLine[]\n    ) {\n        this.macro = lines.some((line) => 'template' in line);\n        const variables: string[] = [];\n        for (const line of lines) {\n            if (!('template' in line)) continue;\n            for (const variable of line.template.variables) {\n                if (!variables.includes(variable)) variables.push(variable);\n            }\n        }\n        this.variables = variables;\n        this.plain = this.macro\n            ? undefined\n            : lines.flatMap((line) => ('command' in line ? [{ command: line.command, line: line.line }] : []));\n    }\n\n    /** How many commands the function declares. */\n    public get length(): number {\n        return this.lines.length;\n    }\n\n    /**\n     * Produces the commands one call runs.\n     *\n     * A plain function ignores the arguments, the way the Java server\n     * silently ignores a compound passed to a non-macro function. A macro\n     * function needs one entry per variable it substitutes and reports the\n     * first entry it is missing; the Java server skips the whole call in that\n     * case, and so does {@link FunctionExecutor}.\n     */\n    public instantiate(args?: MacroArguments): InstantiationResult {\n        if (this.plain) return { ok: true, commands: this.plain };\n\n        if (args === undefined) {\n            return {\n                ok: false,\n                message: `${this.id} is a macro function and was called without arguments`\n            };\n        }\n\n        for (const variable of this.variables) {\n            const value = args[variable];\n            if (value === undefined || value === null) {\n                return { ok: false, message: `the macro arguments have no entry for '${variable}'` };\n            }\n        }\n\n        const key = JSON.stringify(this.variables.map((variable) => args[variable] ?? null));\n        const cached = this.cache.get(key);\n        if (cached) {\n            // Re-insert to make this the most recent set, so the eviction below\n            // drops the set that has gone unused the longest.\n            this.cache.delete(key);\n            this.cache.set(key, cached);\n            return { ok: true, commands: cached };\n        }\n\n        const commands: InstantiatedCommand[] = [];\n        for (const line of this.lines) {\n            if ('command' in line) {\n                commands.push({ command: line.command, line: line.line });\n                continue;\n            }\n\n            const substituted = substituteMacro(line.template, args);\n            if (!substituted.ok) return { ok: false, message: substituted.message, line: line.line };\n            commands.push({ command: substituted.command, line: line.line });\n        }\n\n        this.cache.set(key, commands);\n        if (this.cache.size > MACRO_CACHE_ENTRIES) {\n            const oldest = this.cache.keys().next();\n            if (!oldest.done) this.cache.delete(oldest.value);\n        }\n\n        return { ok: true, commands };\n    }\n\n    /** How many argument sets the macro cache currently holds. */\n    public get cachedArgumentSets(): number {\n        return this.cache.size;\n    }\n}\n\n/** What {@link compileFunction} produces. */\nexport interface CompileResult {\n    /** The compiled function, or undefined when the file did not compile. */\n    function?: CompiledFunction;\n    diagnostics: readonly Diagnostic[];\n}\n\n/**\n * Compiles one function file.\n *\n * A file with any error does not produce a function, matching the Java\n * server, where a file that fails `CommandFunction.fromLines` is logged and\n * left out of the function library rather than partly loaded.\n *\n * @param id - The namespaced id the file loads under.\n * @param source - The text of the `.mcfunction` file.\n */\nexport const compileFunction = (id: string, source: string): CompileResult => {\n    const parsed = parseFunctionSource(source);\n    const diagnostics: Diagnostic[] = parsed.diagnostics.map((diagnostic) => ({ ...diagnostic, functionId: id }));\n    const lines: CompiledLine[] = [];\n\n    for (const line of parsed.lines) {\n        if (!line.macro) {\n            lines.push({ line: line.line, command: line.command });\n            continue;\n        }\n\n        const compiled = compileMacroLine(line.command);\n        if (!compiled.ok) {\n            diagnostics.push({\n                severity: 'error',\n                code: 'macro.invalid',\n                functionId: id,\n                line: line.line,\n                message: compiled.message\n            });\n            continue;\n        }\n\n        lines.push({ line: line.line, template: compiled.template });\n    }\n\n    if (diagnostics.some((diagnostic) => diagnostic.severity === 'error')) return { diagnostics };\n    return { function: new CompiledFunction(id, lines), diagnostics };\n};\n"],"mappings":"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"}

package/dist/compile.d.ts

@@ -0,0 +1,91 @@
+/**
+ * A function file compiled once into the commands a call runs. A plain
+ * function is instantiated for free, every call sharing the same lines. A
+ * macro function re-instantiates per argument set, so it keeps a small cache
+ * of recent sets, which is what makes repeated calls with the same arguments
+ * cheaper than new ones.
+ */
+import type { Diagnostic } from './diagnostics';
+import type { MacroArguments, MacroTemplate } from './macro';
+/**
+ * How many argument sets one macro function remembers. Java's
+ * `MacroFunction` carries 8 as its only integer constant, and caches only the
+ * values the macro actually references, so extra entries in the compound do
+ * not split the cache.
+ */
+export declare const MACRO_CACHE_ENTRIES = 8;
+/** One command a call is about to run. */
+export interface InstantiatedCommand {
+    /** The command text, with every macro substitution already filled in. */
+    command: string;
+    /** The 1-based line of the function file the command came from. */
+    line: number;
+}
+/** The outcome of instantiating a function for one call. */
+export type InstantiationResult = {
+    ok: true;
+    commands: readonly InstantiatedCommand[];
+} | {
+    ok: false;
+    message: string;
+    line?: number;
+};
+/** One compiled line: fixed text, or a template waiting for arguments. */
+type CompiledLine = {
+    line: number;
+    command: string;
+} | {
+    line: number;
+    template: MacroTemplate;
+};
+/**
+ * A function file ready to run. Instances come from {@link compileFunction}
+ * and are shared by every call, including the macro cache.
+ */
+export declare class CompiledFunction {
+    /** The namespaced id the function is registered under. */
+    readonly id: string;
+    private readonly lines;
+    /** Whether any line of the function is a macro line, so calls need arguments. */
+    readonly macro: boolean;
+    /** Every variable the function substitutes, once each, in first-use order. */
+    readonly variables: readonly string[];
+    private readonly cache;
+    private readonly plain;
+    constructor(
+    /** The namespaced id the function is registered under. */
+    id: string, lines: readonly CompiledLine[]);
+    /** How many commands the function declares. */
+    get length(): number;
+    /**
+     * Produces the commands one call runs.
+     *
+     * A plain function ignores the arguments, the way the Java server
+     * silently ignores a compound passed to a non-macro function. A macro
+     * function needs one entry per variable it substitutes and reports the
+     * first entry it is missing; the Java server skips the whole call in that
+     * case, and so does {@link FunctionExecutor}.
+     */
+    instantiate(args?: MacroArguments): InstantiationResult;
+    /** How many argument sets the macro cache currently holds. */
+    get cachedArgumentSets(): number;
+}
+/** What {@link compileFunction} produces. */
+export interface CompileResult {
+    /** The compiled function, or undefined when the file did not compile. */
+    function?: CompiledFunction;
+    diagnostics: readonly Diagnostic[];
+}
+/**
+ * Compiles one function file.
+ *
+ * A file with any error does not produce a function, matching the Java
+ * server, where a file that fails `CommandFunction.fromLines` is logged and
+ * left out of the function library rather than partly loaded.
+ *
+ * @param id - The namespaced id the file loads under.
+ * @param source - The text of the `.mcfunction` file.
+ */
+export declare const compileFunction: (id: string, source: string) => CompileResult;
+export {};
+//# sourceMappingURL=compile.d.ts.map

package/dist/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAI7D;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,0CAA0C;AAC1C,MAAM,WAAW,mBAAmB;IAChC,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,4DAA4D;AAC5D,MAAM,MAAM,mBAAmB,GAC3B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,SAAS,mBAAmB,EAAE,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3G,0EAA0E;AAC1E,KAAK,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,aAAa,CAAA;CAAE,CAAC;AAElG;;;GAGG;AACH,qBAAa,gBAAgB;IAYrB,0DAA0D;aAC1C,EAAE,EAAE,MAAM;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK;IAb1B,iFAAiF;IACjF,SAAgB,KAAK,EAAE,OAAO,CAAC;IAE/B,8EAA8E;IAC9E,SAAgB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAE7C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqD;IAE3E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6C;IAEnE;IACI,0DAA0D;IAC1C,EAAE,EAAE,MAAM,EACT,KAAK,EAAE,SAAS,YAAY,EAAE,EAclD;IAED,+CAA+C;IAC/C,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED;;;;;;;;OAQG;IACI,WAAW,CAAC,IAAI,CAAC,EAAE,cAAc,GAAG,mBAAmB,CA8C7D;IAED,8DAA8D;IAC9D,IAAW,kBAAkB,IAAI,MAAM,CAEtC;CACJ;AAED,6CAA6C;AAC7C,MAAM,WAAW,aAAa;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CACtC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,OAAQ,MAAM,UAAU,MAAM,KAAG,aA4B5D,CAAC"}

package/dist/compile.es.js

@@ -0,0 +1,162 @@
+import { compileMacroLine, substituteMacro } from "./macro.es.js";
+import { parseFunctionSource } from "./parse.es.js";
+// src/compile.ts
+/**
+* How many argument sets one macro function remembers. Java's
+* `MacroFunction` carries 8 as its only integer constant, and caches only the
+* values the macro actually references, so extra entries in the compound do
+* not split the cache.
+*/
+var MACRO_CACHE_ENTRIES = 8;
+/**
+* A function file ready to run. Instances come from {@link compileFunction}
+* and are shared by every call, including the macro cache.
+*/
+var CompiledFunction = class {
+	id;
+	lines;
+	/** Whether any line of the function is a macro line, so calls need arguments. */
+	macro;
+	/** Every variable the function substitutes, once each, in first-use order. */
+	variables;
+	cache = /* @__PURE__ */ new Map();
+	plain;
+	constructor(id, lines) {
+		this.id = id;
+		this.lines = lines;
+		this.macro = lines.some((line) => "template" in line);
+		const variables = [];
+		for (const line of lines) {
+			if (!("template" in line)) continue;
+			for (const variable of line.template.variables) if (!variables.includes(variable)) variables.push(variable);
+		}
+		this.variables = variables;
+		this.plain = this.macro ? void 0 : lines.flatMap((line) => "command" in line ? [{
+			command: line.command,
+			line: line.line
+		}] : []);
+	}
+	/** How many commands the function declares. */
+	get length() {
+		return this.lines.length;
+	}
+	/**
+	* Produces the commands one call runs.
+	*
+	* A plain function ignores the arguments, the way the Java server
+	* silently ignores a compound passed to a non-macro function. A macro
+	* function needs one entry per variable it substitutes and reports the
+	* first entry it is missing; the Java server skips the whole call in that
+	* case, and so does {@link FunctionExecutor}.
+	*/
+	instantiate(args) {
+		if (this.plain) return {
+			ok: true,
+			commands: this.plain
+		};
+		if (args === void 0) return {
+			ok: false,
+			message: `${this.id} is a macro function and was called without arguments`
+		};
+		for (const variable of this.variables) {
+			const value = args[variable];
+			if (value === void 0 || value === null) return {
+				ok: false,
+				message: `the macro arguments have no entry for '${variable}'`
+			};
+		}
+		const key = JSON.stringify(this.variables.map((variable) => args[variable] ?? null));
+		const cached = this.cache.get(key);
+		if (cached) {
+			this.cache.delete(key);
+			this.cache.set(key, cached);
+			return {
+				ok: true,
+				commands: cached
+			};
+		}
+		const commands = [];
+		for (const line of this.lines) {
+			if ("command" in line) {
+				commands.push({
+					command: line.command,
+					line: line.line
+				});
+				continue;
+			}
+			const substituted = substituteMacro(line.template, args);
+			if (!substituted.ok) return {
+				ok: false,
+				message: substituted.message,
+				line: line.line
+			};
+			commands.push({
+				command: substituted.command,
+				line: line.line
+			});
+		}
+		this.cache.set(key, commands);
+		if (this.cache.size > 8) {
+			const oldest = this.cache.keys().next();
+			if (!oldest.done) this.cache.delete(oldest.value);
+		}
+		return {
+			ok: true,
+			commands
+		};
+	}
+	/** How many argument sets the macro cache currently holds. */
+	get cachedArgumentSets() {
+		return this.cache.size;
+	}
+};
+/**
+* Compiles one function file.
+*
+* A file with any error does not produce a function, matching the Java
+* server, where a file that fails `CommandFunction.fromLines` is logged and
+* left out of the function library rather than partly loaded.
+*
+* @param id - The namespaced id the file loads under.
+* @param source - The text of the `.mcfunction` file.
+*/
+var compileFunction = (id, source) => {
+	const parsed = parseFunctionSource(source);
+	const diagnostics = parsed.diagnostics.map((diagnostic) => ({
+		...diagnostic,
+		functionId: id
+	}));
+	const lines = [];
+	for (const line of parsed.lines) {
+		if (!line.macro) {
+			lines.push({
+				line: line.line,
+				command: line.command
+			});
+			continue;
+		}
+		const compiled = compileMacroLine(line.command);
+		if (!compiled.ok) {
+			diagnostics.push({
+				severity: "error",
+				code: "macro.invalid",
+				functionId: id,
+				line: line.line,
+				message: compiled.message
+			});
+			continue;
+		}
+		lines.push({
+			line: line.line,
+			template: compiled.template
+		});
+	}
+	if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) return { diagnostics };
+	return {
+		function: new CompiledFunction(id, lines),
+		diagnostics
+	};
+};
+export { CompiledFunction, MACRO_CACHE_ENTRIES, compileFunction };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"compile.es.js","names":[],"sources":["../src/compile.ts"],"sourcesContent":["/**\n * A function file compiled once into the commands a call runs. A plain\n * function is instantiated for free, every call sharing the same lines. A\n * macro function re-instantiates per argument set, so it keeps a small cache\n * of recent sets, which is what makes repeated calls with the same arguments\n * cheaper than new ones.\n */\n\nimport type { Diagnostic } from './diagnostics';\nimport type { MacroArguments, MacroTemplate } from './macro';\nimport { compileMacroLine, substituteMacro } from './macro';\nimport { parseFunctionSource } from './parse';\n\n/**\n * How many argument sets one macro function remembers. Java's\n * `MacroFunction` carries 8 as its only integer constant, and caches only the\n * values the macro actually references, so extra entries in the compound do\n * not split the cache.\n */\nexport const MACRO_CACHE_ENTRIES = 8;\n\n/** One command a call is about to run. */\nexport interface InstantiatedCommand {\n    /** The command text, with every macro substitution already filled in. */\n    command: string;\n    /** The 1-based line of the function file the command came from. */\n    line: number;\n}\n\n/** The outcome of instantiating a function for one call. */\nexport type InstantiationResult =\n    { ok: true; commands: readonly InstantiatedCommand[] } | { ok: false; message: string; line?: number };\n\n/** One compiled line: fixed text, or a template waiting for arguments. */\ntype CompiledLine = { line: number; command: string } | { line: number; template: MacroTemplate };\n\n/**\n * A function file ready to run. Instances come from {@link compileFunction}\n * and are shared by every call, including the macro cache.\n */\nexport class CompiledFunction {\n    /** Whether any line of the function is a macro line, so calls need arguments. */\n    public readonly macro: boolean;\n\n    /** Every variable the function substitutes, once each, in first-use order. */\n    public readonly variables: readonly string[];\n\n    private readonly cache = new Map<string, readonly InstantiatedCommand[]>();\n\n    private readonly plain: readonly InstantiatedCommand[] | undefined;\n\n    public constructor(\n        /** The namespaced id the function is registered under. */\n        public readonly id: string,\n        private readonly lines: readonly CompiledLine[]\n    ) {\n        this.macro = lines.some((line) => 'template' in line);\n        const variables: string[] = [];\n        for (const line of lines) {\n            if (!('template' in line)) continue;\n            for (const variable of line.template.variables) {\n                if (!variables.includes(variable)) variables.push(variable);\n            }\n        }\n        this.variables = variables;\n        this.plain = this.macro\n            ? undefined\n            : lines.flatMap((line) => ('command' in line ? [{ command: line.command, line: line.line }] : []));\n    }\n\n    /** How many commands the function declares. */\n    public get length(): number {\n        return this.lines.length;\n    }\n\n    /**\n     * Produces the commands one call runs.\n     *\n     * A plain function ignores the arguments, the way the Java server\n     * silently ignores a compound passed to a non-macro function. A macro\n     * function needs one entry per variable it substitutes and reports the\n     * first entry it is missing; the Java server skips the whole call in that\n     * case, and so does {@link FunctionExecutor}.\n     */\n    public instantiate(args?: MacroArguments): InstantiationResult {\n        if (this.plain) return { ok: true, commands: this.plain };\n\n        if (args === undefined) {\n            return {\n                ok: false,\n                message: `${this.id} is a macro function and was called without arguments`\n            };\n        }\n\n        for (const variable of this.variables) {\n            const value = args[variable];\n            if (value === undefined || value === null) {\n                return { ok: false, message: `the macro arguments have no entry for '${variable}'` };\n            }\n        }\n\n        const key = JSON.stringify(this.variables.map((variable) => args[variable] ?? null));\n        const cached = this.cache.get(key);\n        if (cached) {\n            // Re-insert to make this the most recent set, so the eviction below\n            // drops the set that has gone unused the longest.\n            this.cache.delete(key);\n            this.cache.set(key, cached);\n            return { ok: true, commands: cached };\n        }\n\n        const commands: InstantiatedCommand[] = [];\n        for (const line of this.lines) {\n            if ('command' in line) {\n                commands.push({ command: line.command, line: line.line });\n                continue;\n            }\n\n            const substituted = substituteMacro(line.template, args);\n            if (!substituted.ok) return { ok: false, message: substituted.message, line: line.line };\n            commands.push({ command: substituted.command, line: line.line });\n        }\n\n        this.cache.set(key, commands);\n        if (this.cache.size > MACRO_CACHE_ENTRIES) {\n            const oldest = this.cache.keys().next();\n            if (!oldest.done) this.cache.delete(oldest.value);\n        }\n\n        return { ok: true, commands };\n    }\n\n    /** How many argument sets the macro cache currently holds. */\n    public get cachedArgumentSets(): number {\n        return this.cache.size;\n    }\n}\n\n/** What {@link compileFunction} produces. */\nexport interface CompileResult {\n    /** The compiled function, or undefined when the file did not compile. */\n    function?: CompiledFunction;\n    diagnostics: readonly Diagnostic[];\n}\n\n/**\n * Compiles one function file.\n *\n * A file with any error does not produce a function, matching the Java\n * server, where a file that fails `CommandFunction.fromLines` is logged and\n * left out of the function library rather than partly loaded.\n *\n * @param id - The namespaced id the file loads under.\n * @param source - The text of the `.mcfunction` file.\n */\nexport const compileFunction = (id: string, source: string): CompileResult => {\n    const parsed = parseFunctionSource(source);\n    const diagnostics: Diagnostic[] = parsed.diagnostics.map((diagnostic) => ({ ...diagnostic, functionId: id }));\n    const lines: CompiledLine[] = [];\n\n    for (const line of parsed.lines) {\n        if (!line.macro) {\n            lines.push({ line: line.line, command: line.command });\n            continue;\n        }\n\n        const compiled = compileMacroLine(line.command);\n        if (!compiled.ok) {\n            diagnostics.push({\n                severity: 'error',\n                code: 'macro.invalid',\n                functionId: id,\n                line: line.line,\n                message: compiled.message\n            });\n            continue;\n        }\n\n        lines.push({ line: line.line, template: compiled.template });\n    }\n\n    if (diagnostics.some((diagnostic) => diagnostic.severity === 'error')) return { diagnostics };\n    return { function: new CompiledFunction(id, lines), diagnostics };\n};\n"],"mappings":"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"}

package/dist/diagnostics.cjs.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/diagnostics.ts
+/** Collects diagnostics in report order. */
+var DiagnosticCollector = class {
+	/** Everything reported so far, in the order it was reported. */
+	diagnostics = [];
+	/** Records one diagnostic. */
+	add(diagnostic) {
+		this.diagnostics.push(diagnostic);
+	}
+	/** Whether any recorded diagnostic is an error. */
+	get hasErrors() {
+		return this.diagnostics.some((diagnostic) => diagnostic.severity === "error");
+	}
+};
+exports.DiagnosticCollector = DiagnosticCollector;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/diagnostics.d.ts

@@ -0,0 +1,62 @@
+/**
+ * What this runtime reports instead of throwing. Loading a pack, compiling a
+ * function and running one are all best-effort: a broken file or a tripped
+ * limit produces a diagnostic and the rest of the work continues, the way the
+ * Java server logs a function it could not load and keeps the server running.
+ */
+/** How serious a diagnostic is. An error means the affected function did not load or did not run. */
+export type DiagnosticSeverity = 'error' | 'warning';
+/** The problems this package reports. */
+export type DiagnosticCode = 
+/** A line started with `//`, which is not a comment marker in mcfunction. */
+'line.double-slash-comment'
+/** A line started with `/`, which mcfunction does not use. */
+ | 'line.leading-slash'
+/** A line was longer than {@link MAX_COMMAND_LENGTH}. */
+ | 'line.too-long'
+/** The file ended with a line continuation that had nothing to continue into. */
+ | 'line.dangling-continuation'
+/** A macro line was malformed: a bad variable name, an unterminated `$(`, or no substitution at all. */
+ | 'macro.invalid'
+/** A macro function was called without the arguments its substitutions need. */
+ | 'macro.missing-arguments'
+/** A `function` line named a function that is not registered. */
+ | 'call.unknown-function'
+/** A `function` line named a tag that the tag lookup does not know. */
+ | 'call.unknown-tag'
+/** A `function` line carried an argument compound that could not be parsed. */
+ | 'call.invalid-arguments'
+/** The command runner threw while running a line. */
+ | 'command.failed'
+/** A function tag referenced itself through a chain of tags. */
+ | 'tag.cycle'
+/** A tag entry named a required function or tag that does not exist. */
+ | 'tag.missing-entry'
+/** Execution stopped because it reached `maxCommandSequenceLength`. */
+ | 'limit.command-sequence-length'
+/** Execution stopped because it reached `maxCommandForks`. */
+ | 'limit.command-forks'
+/** A file under `function/` could not be decoded or routed to an identifier. */
+ | 'load.invalid-file';
+/** One reported problem, carrying enough location to find it in a pack. */
+export interface Diagnostic {
+    severity: DiagnosticSeverity;
+    code: DiagnosticCode;
+    message: string;
+    /** The namespaced id of the function the problem is in, when there is one. */
+    functionId?: string;
+    /** The 1-based line number inside that function, when the problem has one. */
+    line?: number;
+    /** The name of the pack the file came from, for problems found while loading. */
+    pack?: string;
+}
+/** Collects diagnostics in report order. */
+export declare class DiagnosticCollector {
+    /** Everything reported so far, in the order it was reported. */
+    readonly diagnostics: Diagnostic[];
+    /** Records one diagnostic. */
+    add(diagnostic: Diagnostic): void;
+    /** Whether any recorded diagnostic is an error. */
+    get hasErrors(): boolean;
+}
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../src/diagnostics.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,qGAAqG;AACrG,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAC;AAErD,yCAAyC;AACzC,MAAM,MAAM,cAAc;AACtB,6EAA6E;AAC3E,2BAA2B;AAC7B,8DAA8D;GAC5D,oBAAoB;AACtB,yDAAyD;GACvD,eAAe;AACjB,iFAAiF;GAC/E,4BAA4B;AAC9B,wGAAwG;GACtG,eAAe;AACjB,gFAAgF;GAC9E,yBAAyB;AAC3B,iEAAiE;GAC/D,uBAAuB;AACzB,uEAAuE;GACrE,kBAAkB;AACpB,+EAA+E;GAC7E,wBAAwB;AAC1B,qDAAqD;GACnD,gBAAgB;AAClB,gEAAgE;GAC9D,WAAW;AACb,wEAAwE;GACtE,mBAAmB;AACrB,uEAAuE;GACrE,+BAA+B;AACjC,8DAA8D;GAC5D,qBAAqB;AACvB,gFAAgF;GAC9E,mBAAmB,CAAC;AAE1B,2EAA2E;AAC3E,MAAM,WAAW,UAAU;IACvB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,4CAA4C;AAC5C,qBAAa,mBAAmB;IAC5B,gEAAgE;IAChE,SAAgB,WAAW,EAAE,UAAU,EAAE,CAAM;IAE/C,8BAA8B;IACvB,GAAG,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAEvC;IAED,mDAAmD;IACnD,IAAW,SAAS,IAAI,OAAO,CAE9B;CACJ"}

package/dist/diagnostics.es.js

@@ -0,0 +1,17 @@
+// src/diagnostics.ts
+/** Collects diagnostics in report order. */
+var DiagnosticCollector = class {
+	/** Everything reported so far, in the order it was reported. */
+	diagnostics = [];
+	/** Records one diagnostic. */
+	add(diagnostic) {
+		this.diagnostics.push(diagnostic);
+	}
+	/** Whether any recorded diagnostic is an error. */
+	get hasErrors() {
+		return this.diagnostics.some((diagnostic) => diagnostic.severity === "error");
+	}
+};
+export { DiagnosticCollector };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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