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

package/dist/executor.es.js

@@ -0,0 +1,298 @@
+import { parseFunctionReference } from "./identifiers.es.js";
+import { LOAD_FUNCTION_TAG, TICK_FUNCTION_TAG, resolveFunctionTag } from "./tags.es.js";
+// src/executor.ts
+/**
+* The limits a run uses when the caller sets none.
+*
+* Both default to 65536. Mojang has never published either default: the
+* figure has two independent secondary confirmations (minecraft.wiki's
+* gamerule page and Pumpkin's extraction from the 26.3 server jar) and the
+* `GameRules` class holds 65536 in its constant pool, but no Mojang document
+* attributes the value to either rule. Treat it as a well-corroborated
+* default rather than a confirmed one, and configure it when a world says
+* otherwise.
+*/
+var DEFAULT_EXECUTION_LIMITS = {
+	maxCommandSequenceLength: 65536,
+	maxCommandForks: 65536
+};
+/**
+* What Bedrock caps a single `/function` call at, from Mojang's creator
+* documentation. This runtime runs Java functions and does not apply it; a
+* server that wants Bedrock's ceiling passes it as `maxCommandSequenceLength`.
+*/
+var BEDROCK_MAX_COMMANDS_PER_FUNCTION = 1e4;
+var CALL_PATTERN = /^function[ \t]+(\S+)[ \t]*([\s\S]*)$/;
+/** Reads a JSON object as an argument compound; anything else is rejected. */
+var parseJsonArguments = (text) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	return { ...parsed };
+};
+/**
+* Runs functions against a command runner.
+*
+* One executor is reusable: it holds no run state, so a server builds it once
+* at load and calls {@link FunctionExecutor.runTick} every tick.
+*
+* `function <id>` and `function #tag` are the only lines the executor reads
+* itself, because a call is control flow rather than a command: handling it
+* here is what keeps nesting on the queue instead of on the JavaScript stack.
+* Every other line goes to the runner untouched.
+*
+* `/return` is the other half of that split. It is a command, so the runner
+* implements it, but only the executor can act on it: a runner that reports
+* {@link CommandOutcome.returned} ends the function the line came from and
+* the loop carries on with its caller.
+*/
+var FunctionExecutor = class {
+	options;
+	limits;
+	parseArguments;
+	constructor(options) {
+		this.options = options;
+		this.limits = {
+			...DEFAULT_EXECUTION_LIMITS,
+			...options.limits
+		};
+		this.parseArguments = options.parseArguments ?? parseJsonArguments;
+	}
+	/** Runs `minecraft:load`, which a server does once after its packs load. */
+	runLoad(options) {
+		return this.run(`#${LOAD_FUNCTION_TAG}`, options);
+	}
+	/** Runs `minecraft:tick`, which a server does once per server tick. */
+	runTick(options) {
+		return this.run(`#${TICK_FUNCTION_TAG}`, options);
+	}
+	/**
+	* Runs one function or every function in one tag.
+	*
+	* Everything a call reaches shares one budget, so the report covers the
+	* whole tree below the entry point. A limit stops the run and is reported
+	* as a diagnostic; nothing here throws, and a command that throws is
+	* reported and skipped.
+	*
+	* @param reference - A function id, or a tag id written `#namespace:tag`.
+	*/
+	run(reference, options) {
+		const diagnostics = [];
+		const state = {
+			operations: 0,
+			forks: 0,
+			commands: 0,
+			invocations: 0,
+			maxDepth: 0
+		};
+		const stack = [];
+		const returnValues = [];
+		const parsed = parseFunctionReference(reference);
+		if (!parsed) {
+			diagnostics.push({
+				severity: "error",
+				code: "call.unknown-function",
+				message: `'${reference}' is not a valid function reference`
+			});
+			return {
+				...state,
+				returnValues,
+				diagnostics
+			};
+		}
+		let stopped;
+		/** Charges one operation, reporting and stopping the run at the limit. */
+		const charge = (functionId, line) => {
+			state.operations += 1;
+			if (state.operations <= this.limits.maxCommandSequenceLength) return true;
+			stopped = "max-command-sequence-length";
+			diagnostics.push({
+				severity: "error",
+				code: "limit.command-sequence-length",
+				functionId,
+				line,
+				message: `the run reached maxCommandSequenceLength (${this.limits.maxCommandSequenceLength}) and stopped`
+			});
+			return false;
+		};
+		/** Instantiates one call and pushes its frame, or reports why it could not. */
+		const invoke = (id, args, from, root = false) => {
+			const compiled = this.options.functions.get(id);
+			if (!compiled) {
+				diagnostics.push({
+					severity: "error",
+					code: "call.unknown-function",
+					functionId: from.functionId,
+					line: from.line,
+					message: `the function ${id} does not exist`
+				});
+				return true;
+			}
+			if (!charge(from.functionId, from.line)) return false;
+			state.invocations += 1;
+			const instantiated = compiled.instantiate(args);
+			if (!instantiated.ok) {
+				diagnostics.push({
+					severity: "error",
+					code: "macro.missing-arguments",
+					functionId: id,
+					line: instantiated.line,
+					message: instantiated.message
+				});
+				return true;
+			}
+			const top = stack.at(-1);
+			const replaced = top && top.index >= top.commands.length ? stack.pop() : void 0;
+			stack.push({
+				functionId: id,
+				commands: instantiated.commands,
+				index: 0,
+				root: replaced?.root ?? root
+			});
+			state.maxDepth = Math.max(state.maxDepth, stack.length);
+			return true;
+		};
+		const entries = parsed.kind === "function" ? [parsed.id] : this.resolveTag(parsed.id, reference, diagnostics);
+		for (const id of [...entries].reverse()) if (!invoke(id, options.arguments, { functionId: reference }, true)) break;
+		while (stopped === void 0 && stack.length > 0) {
+			const frame = stack.at(-1);
+			if (!frame) break;
+			if (frame.index >= frame.commands.length) {
+				stack.pop();
+				continue;
+			}
+			const entry = frame.commands[frame.index];
+			frame.index += 1;
+			if (!entry) continue;
+			if (!charge(frame.functionId, entry.line)) break;
+			const call = CALL_PATTERN.exec(entry.command);
+			if (call) {
+				this.handleCall(call, frame, entry, invoke, diagnostics);
+				continue;
+			}
+			state.commands += 1;
+			let forks = 0;
+			let returned;
+			try {
+				const outcome = this.options.runner.run(entry.command, {
+					source: options.source,
+					functionId: frame.functionId,
+					line: entry.line
+				});
+				forks = outcome.forks ?? 0;
+				returned = outcome.returned;
+			} catch (error) {
+				diagnostics.push({
+					severity: "error",
+					code: "command.failed",
+					functionId: frame.functionId,
+					line: entry.line,
+					message: error instanceof Error ? error.message : String(error)
+				});
+			}
+			if (returned !== void 0) {
+				if (frame.root && returned.value !== void 0) returnValues.push(returned.value);
+				if (stack.at(-1) === frame) stack.pop();
+			}
+			state.forks += forks;
+			if (state.forks > this.limits.maxCommandForks) {
+				stopped = "max-command-forks";
+				diagnostics.push({
+					severity: "error",
+					code: "limit.command-forks",
+					functionId: frame.functionId,
+					line: entry.line,
+					message: `the run reached maxCommandForks (${this.limits.maxCommandForks}) and stopped`
+				});
+				break;
+			}
+		}
+		return {
+			...state,
+			returnValues,
+			...stopped ? { stopped } : {},
+			diagnostics
+		};
+	}
+	/** Expands a tag reference, reporting a tag no pack declared. */
+	resolveTag(id, reference, diagnostics) {
+		if (!this.options.tags) {
+			diagnostics.push({
+				severity: "error",
+				code: "call.unknown-tag",
+				message: `${reference} is a tag reference, and this executor has no tag lookup`
+			});
+			return [];
+		}
+		const resolved = resolveFunctionTag(this.options.tags, id);
+		diagnostics.push(...resolved.diagnostics);
+		return resolved.functions;
+	}
+	/** Runs one `function` line: resolves what it names and pushes the frames it invokes. */
+	handleCall(call, frame, entry, invoke, diagnostics) {
+		const from = {
+			functionId: frame.functionId,
+			line: entry.line
+		};
+		const target = parseFunctionReference(call[1] ?? "");
+		if (!target) {
+			diagnostics.push({
+				severity: "error",
+				code: "call.unknown-function",
+				...from,
+				message: `'${call[1] ?? ""}' is not a valid function reference`
+			});
+			return;
+		}
+		const argumentText = (call[2] ?? "").trim();
+		let args;
+		if (argumentText.length > 0) {
+			args = this.parseArguments(argumentText);
+			if (args === void 0) {
+				diagnostics.push({
+					severity: "error",
+					code: "call.invalid-arguments",
+					...from,
+					message: `the arguments of '${entry.command}' are not a compound this runtime can read`
+				});
+				return;
+			}
+		}
+		if (target.kind === "function") {
+			invoke(target.id, args, from);
+			return;
+		}
+		const tags = this.options.tags;
+		if (!tags) {
+			diagnostics.push({
+				severity: "error",
+				code: "call.unknown-tag",
+				...from,
+				message: `#${target.id} cannot be resolved, because this executor has no tag lookup`
+			});
+			return;
+		}
+		const resolved = resolveFunctionTag(tags, target.id);
+		diagnostics.push(...resolved.diagnostics.map((diagnostic) => ({
+			...diagnostic,
+			...from
+		})));
+		if (!resolved.exists) {
+			diagnostics.push({
+				severity: "error",
+				code: "call.unknown-tag",
+				...from,
+				message: `the function tag #${target.id} does not exist`
+			});
+			return;
+		}
+		for (const id of [...resolved.functions].reverse()) if (!invoke(id, args, from)) break;
+	}
+};
+export { BEDROCK_MAX_COMMANDS_PER_FUNCTION, DEFAULT_EXECUTION_LIMITS, FunctionExecutor };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"executor.es.js","names":[],"sources":["../src/executor.ts"],"sourcesContent":["/**\n * The executor. Java rewrote function execution in 23w41a from a recursive\n * call path into an explicit queue of frames on the heap, which is what lets\n * it bound work with a counter and stops a tail-recursive pack from\n * exhausting the host stack. This is the same shape: a stack of frames in an\n * array, one loop, and a counter charged per operation.\n */\n\nimport type { CompiledFunction, InstantiatedCommand } from './compile';\nimport type { Diagnostic } from './diagnostics';\nimport type { FunctionReference } from './identifiers';\nimport { parseFunctionReference } from './identifiers';\nimport type { MacroArguments } from './macro';\nimport type { CommandOutcome, CommandRunner } from './runner';\nimport type { FunctionTagLookup } from './tags';\nimport { LOAD_FUNCTION_TAG, TICK_FUNCTION_TAG, resolveFunctionTag } from './tags';\n\n/**\n * The two gamerules that bound a run. They were renamed in 1.21.11 from\n * `maxCommandChainLength` and `maxCommandForkCount`; anything written against\n * the camelCase names is stale.\n */\nexport interface ExecutionLimits {\n    /** `minecraft:max_command_sequence_length`: how many operations one entry point may run. */\n    maxCommandSequenceLength: number;\n    /** `minecraft:max_command_forks`: how many contexts one entry point may create. */\n    maxCommandForks: number;\n}\n\n/**\n * The limits a run uses when the caller sets none.\n *\n * Both default to 65536. Mojang has never published either default: the\n * figure has two independent secondary confirmations (minecraft.wiki's\n * gamerule page and Pumpkin's extraction from the 26.3 server jar) and the\n * `GameRules` class holds 65536 in its constant pool, but no Mojang document\n * attributes the value to either rule. Treat it as a well-corroborated\n * default rather than a confirmed one, and configure it when a world says\n * otherwise.\n */\nexport const DEFAULT_EXECUTION_LIMITS: ExecutionLimits = {\n    maxCommandSequenceLength: 65_536,\n    maxCommandForks: 65_536\n};\n\n/**\n * What Bedrock caps a single `/function` call at, from Mojang's creator\n * documentation. This runtime runs Java functions and does not apply it; a\n * server that wants Bedrock's ceiling passes it as `maxCommandSequenceLength`.\n */\nexport const BEDROCK_MAX_COMMANDS_PER_FUNCTION = 10_000;\n\n/** Where the executor reads compiled functions from. */\nexport interface FunctionLookup {\n    /** Returns the function registered under a namespaced id. */\n    get(id: string): CompiledFunction | undefined;\n}\n\n/** How to build a {@link FunctionExecutor}. */\nexport interface FunctionExecutorOptions<TSource = unknown> {\n    functions: FunctionLookup;\n    runner: CommandRunner<TSource>;\n    /** Resolves `#namespace:tag` references. Without it, a tag reference is reported as unknown. */\n    tags?: FunctionTagLookup;\n    /** Overrides either limit; anything left out keeps its {@link DEFAULT_EXECUTION_LIMITS} value. */\n    limits?: Partial<ExecutionLimits>;\n    /**\n     * Reads the argument compound of a `function <id> <arguments>` line. The\n     * default accepts JSON, because SNBT needs a parser this package does not\n     * own; a server with one passes it here.\n     */\n    parseArguments?: (text: string) => MacroArguments | undefined;\n}\n\n/** What one call needs beyond the function to run. */\nexport interface ExecutionOptions<TSource = unknown> {\n    /** The command source every command in the run is given. */\n    source: TSource;\n    /** The compound a macro function substitutes from. Ignored by a plain function. */\n    arguments?: MacroArguments;\n}\n\n/** Why a run stopped before it finished. */\nexport type ExecutionStop = 'max-command-sequence-length' | 'max-command-forks';\n\n/** What one run did. */\nexport interface ExecutionReport {\n    /** Operations charged against `maxCommandSequenceLength`. */\n    operations: number;\n    /** Contexts charged against `maxCommandForks`. */\n    forks: number;\n    /** How many command lines reached the runner. */\n    commands: number;\n    /** How many functions the run invoked, including the entry point. */\n    invocations: number;\n    /** The deepest the frame stack got. A tail call does not deepen it. */\n    maxDepth: number;\n    /**\n     * The values `/return` produced, one per function the entry point\n     * invoked directly that reached one.\n     *\n     * Empty when every function ran to its last line, which is the case Java\n     * calls \"returned no value\". A tag contributes one entry per member that\n     * returned, because `execute if function #tag` matches when any member\n     * did. A `/return` deeper in the call tree ends its own function and\n     * leaves nothing here, the way Java returns from one function rather\n     * than from its caller.\n     */\n    returnValues: readonly number[];\n    /** Set when a limit stopped the run; the matching diagnostic carries the detail. */\n    stopped?: ExecutionStop;\n    diagnostics: readonly Diagnostic[];\n}\n\n/** One function in progress: its remaining commands and where it is in them. */\ninterface Frame {\n    functionId: string;\n    commands: readonly InstantiatedCommand[];\n    index: number;\n    /**\n     * Whether the entry point invoked this function itself, which is what\n     * decides whose `/return` the run reports. A tail call inherits it: the\n     * replacement runs in the frame it replaced, so its return is that\n     * function's last act.\n     */\n    root: boolean;\n}\n\nconst CALL_PATTERN = /^function[ \\t]+(\\S+)[ \\t]*([\\s\\S]*)$/;\n\n/** Reads a JSON object as an argument compound; anything else is rejected. */\nconst parseJsonArguments = (text: string): MacroArguments | undefined => {\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(text);\n    } catch {\n        return undefined;\n    }\n    // JSON.parse is a parsed-input boundary, so narrow rather than assert.\n    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return undefined;\n    return { ...parsed };\n};\n\n/**\n * Runs functions against a command runner.\n *\n * One executor is reusable: it holds no run state, so a server builds it once\n * at load and calls {@link FunctionExecutor.runTick} every tick.\n *\n * `function <id>` and `function #tag` are the only lines the executor reads\n * itself, because a call is control flow rather than a command: handling it\n * here is what keeps nesting on the queue instead of on the JavaScript stack.\n * Every other line goes to the runner untouched.\n *\n * `/return` is the other half of that split. It is a command, so the runner\n * implements it, but only the executor can act on it: a runner that reports\n * {@link CommandOutcome.returned} ends the function the line came from and\n * the loop carries on with its caller.\n */\nexport class FunctionExecutor<TSource = unknown> {\n    private readonly limits: ExecutionLimits;\n\n    private readonly parseArguments: (text: string) => MacroArguments | undefined;\n\n    public constructor(private readonly options: FunctionExecutorOptions<TSource>) {\n        this.limits = { ...DEFAULT_EXECUTION_LIMITS, ...options.limits };\n        this.parseArguments = options.parseArguments ?? parseJsonArguments;\n    }\n\n    /** Runs `minecraft:load`, which a server does once after its packs load. */\n    public runLoad(options: ExecutionOptions<TSource>): ExecutionReport {\n        return this.run(`#${LOAD_FUNCTION_TAG}`, options);\n    }\n\n    /** Runs `minecraft:tick`, which a server does once per server tick. */\n    public runTick(options: ExecutionOptions<TSource>): ExecutionReport {\n        return this.run(`#${TICK_FUNCTION_TAG}`, options);\n    }\n\n    /**\n     * Runs one function or every function in one tag.\n     *\n     * Everything a call reaches shares one budget, so the report covers the\n     * whole tree below the entry point. A limit stops the run and is reported\n     * as a diagnostic; nothing here throws, and a command that throws is\n     * reported and skipped.\n     *\n     * @param reference - A function id, or a tag id written `#namespace:tag`.\n     */\n    public run(reference: string, options: ExecutionOptions<TSource>): ExecutionReport {\n        const diagnostics: Diagnostic[] = [];\n        const state = { operations: 0, forks: 0, commands: 0, invocations: 0, maxDepth: 0 };\n        const stack: Frame[] = [];\n        const returnValues: number[] = [];\n\n        const parsed = parseFunctionReference(reference);\n        if (!parsed) {\n            diagnostics.push({\n                severity: 'error',\n                code: 'call.unknown-function',\n                message: `'${reference}' is not a valid function reference`\n            });\n            return { ...state, returnValues, diagnostics };\n        }\n\n        let stopped: ExecutionStop | undefined;\n\n        /** Charges one operation, reporting and stopping the run at the limit. */\n        const charge = (functionId: string, line?: number): boolean => {\n            state.operations += 1;\n            if (state.operations <= this.limits.maxCommandSequenceLength) return true;\n            stopped = 'max-command-sequence-length';\n            diagnostics.push({\n                severity: 'error',\n                code: 'limit.command-sequence-length',\n                functionId,\n                line,\n                message: `the run reached maxCommandSequenceLength (${this.limits.maxCommandSequenceLength}) and stopped`\n            });\n            return false;\n        };\n\n        /** Instantiates one call and pushes its frame, or reports why it could not. */\n        const invoke = (\n            id: string,\n            args: MacroArguments | undefined,\n            from: { functionId: string; line?: number },\n            root = false\n        ): boolean => {\n            const compiled = this.options.functions.get(id);\n            if (!compiled) {\n                diagnostics.push({\n                    severity: 'error',\n                    code: 'call.unknown-function',\n                    functionId: from.functionId,\n                    line: from.line,\n                    message: `the function ${id} does not exist`\n                });\n                return true;\n            }\n\n            if (!charge(from.functionId, from.line)) return false;\n            state.invocations += 1;\n\n            const instantiated = compiled.instantiate(args);\n            if (!instantiated.ok) {\n                diagnostics.push({\n                    severity: 'error',\n                    code: 'macro.missing-arguments',\n                    functionId: id,\n                    line: instantiated.line,\n                    message: instantiated.message\n                });\n                return true;\n            }\n\n            // A call made from the last line of a frame replaces that frame\n            // instead of stacking on it, so a tail-recursive function runs in\n            // constant depth, as Java's rewrite made it in 23w44a.\n            const top = stack.at(-1);\n            const replaced = top && top.index >= top.commands.length ? stack.pop() : undefined;\n\n            stack.push({\n                functionId: id,\n                commands: instantiated.commands,\n                index: 0,\n                root: replaced?.root ?? root\n            });\n            state.maxDepth = Math.max(state.maxDepth, stack.length);\n            return true;\n        };\n\n        const entries = parsed.kind === 'function' ? [parsed.id] : this.resolveTag(parsed.id, reference, diagnostics);\n\n        // Frames run from the top of the stack, so the first function of a tag\n        // is pushed last.\n        for (const id of [...entries].reverse()) {\n            if (!invoke(id, options.arguments, { functionId: reference }, true)) break;\n        }\n\n        while (stopped === undefined && stack.length > 0) {\n            const frame = stack.at(-1);\n            if (!frame) break;\n            if (frame.index >= frame.commands.length) {\n                stack.pop();\n                continue;\n            }\n\n            const entry = frame.commands[frame.index];\n            frame.index += 1;\n            if (!entry) continue;\n            if (!charge(frame.functionId, entry.line)) break;\n\n            const call = CALL_PATTERN.exec(entry.command);\n            if (call) {\n                this.handleCall(call, frame, entry, invoke, diagnostics);\n                continue;\n            }\n\n            state.commands += 1;\n            let forks = 0;\n            let returned: CommandOutcome['returned'];\n            try {\n                const outcome = this.options.runner.run(entry.command, {\n                    source: options.source,\n                    functionId: frame.functionId,\n                    line: entry.line\n                });\n                forks = outcome.forks ?? 0;\n                returned = outcome.returned;\n            } catch (error) {\n                diagnostics.push({\n                    severity: 'error',\n                    code: 'command.failed',\n                    functionId: frame.functionId,\n                    line: entry.line,\n                    message: error instanceof Error ? error.message : String(error)\n                });\n            }\n\n            if (returned !== undefined) {\n                // `/return` ends this function and no other: its caller's\n                // frame is still below and runs on from where it called.\n                if (frame.root && returned.value !== undefined) returnValues.push(returned.value);\n                if (stack.at(-1) === frame) stack.pop();\n            }\n\n            state.forks += forks;\n            if (state.forks > this.limits.maxCommandForks) {\n                stopped = 'max-command-forks';\n                diagnostics.push({\n                    severity: 'error',\n                    code: 'limit.command-forks',\n                    functionId: frame.functionId,\n                    line: entry.line,\n                    message: `the run reached maxCommandForks (${this.limits.maxCommandForks}) and stopped`\n                });\n                break;\n            }\n        }\n\n        return { ...state, returnValues, ...(stopped ? { stopped } : {}), diagnostics };\n    }\n\n    /** Expands a tag reference, reporting a tag no pack declared. */\n    private resolveTag(id: string, reference: string, diagnostics: Diagnostic[]): readonly string[] {\n        if (!this.options.tags) {\n            diagnostics.push({\n                severity: 'error',\n                code: 'call.unknown-tag',\n                message: `${reference} is a tag reference, and this executor has no tag lookup`\n            });\n            return [];\n        }\n\n        const resolved = resolveFunctionTag(this.options.tags, id);\n        diagnostics.push(...resolved.diagnostics);\n        return resolved.functions;\n    }\n\n    /** Runs one `function` line: resolves what it names and pushes the frames it invokes. */\n    private handleCall(\n        call: RegExpExecArray,\n        frame: Frame,\n        entry: InstantiatedCommand,\n        invoke: (id: string, args: MacroArguments | undefined, from: { functionId: string; line?: number }) => boolean,\n        diagnostics: Diagnostic[]\n    ): void {\n        const from = { functionId: frame.functionId, line: entry.line };\n        const target: FunctionReference | undefined = parseFunctionReference(call[1] ?? '');\n        if (!target) {\n            diagnostics.push({\n                severity: 'error',\n                code: 'call.unknown-function',\n                ...from,\n                message: `'${call[1] ?? ''}' is not a valid function reference`\n            });\n            return;\n        }\n\n        const argumentText = (call[2] ?? '').trim();\n        let args: MacroArguments | undefined;\n        if (argumentText.length > 0) {\n            args = this.parseArguments(argumentText);\n            if (args === undefined) {\n                diagnostics.push({\n                    severity: 'error',\n                    code: 'call.invalid-arguments',\n                    ...from,\n                    message: `the arguments of '${entry.command}' are not a compound this runtime can read`\n                });\n                return;\n            }\n        }\n\n        if (target.kind === 'function') {\n            invoke(target.id, args, from);\n            return;\n        }\n\n        const tags = this.options.tags;\n        if (!tags) {\n            diagnostics.push({\n                severity: 'error',\n                code: 'call.unknown-tag',\n                ...from,\n                message: `#${target.id} cannot be resolved, because this executor has no tag lookup`\n            });\n            return;\n        }\n\n        const resolved = resolveFunctionTag(tags, target.id);\n        diagnostics.push(...resolved.diagnostics.map((diagnostic) => ({ ...diagnostic, ...from })));\n        if (!resolved.exists) {\n            diagnostics.push({\n                severity: 'error',\n                code: 'call.unknown-tag',\n                ...from,\n                message: `the function tag #${target.id} does not exist`\n            });\n            return;\n        }\n\n        for (const id of [...resolved.functions].reverse()) {\n            if (!invoke(id, args, from)) break;\n        }\n    }\n}\n"],"mappings":"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"}

package/dist/identifiers.cjs.cjs

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/identifiers.ts
+/**
+* Namespaced ids as `/function` and the function tag files use them. A
+* reference is either a function id (`minecraft:foo/bar`) or a tag id written
+* with a leading `#` (`#minecraft:tick`); both default to the `minecraft`
+* namespace when the colon is left out.
+*/
+var NAMESPACE_PATTERN = /^[a-z0-9_.-]+$/;
+var PATH_PATTERN = /^[a-z0-9_./-]+$/;
+/** The namespace an id without a colon belongs to. */
+var DEFAULT_NAMESPACE = "minecraft";
+/**
+* Normalizes a namespaced id, filling in the default namespace.
+*
+* @returns The `namespace:path` form, or undefined when either half is not a legal id.
+*/
+var normalizeIdentifier = (text) => {
+	const colon = text.indexOf(":");
+	const namespace = colon === -1 ? DEFAULT_NAMESPACE : text.slice(0, colon);
+	const path = colon === -1 ? text : text.slice(colon + 1);
+	if (!NAMESPACE_PATTERN.test(namespace) || !PATH_PATTERN.test(path)) return void 0;
+	return `${namespace}:${path}`;
+};
+/**
+* Parses the argument of a `/function` call or a function tag entry.
+*
+* @returns The reference, or undefined when the text is not a legal id.
+*/
+var parseFunctionReference = (text) => {
+	const tag = text.startsWith("#");
+	const id = normalizeIdentifier(tag ? text.slice(1) : text);
+	if (id === void 0) return void 0;
+	return {
+		kind: tag ? "tag" : "function",
+		id
+	};
+};
+/** The file extension of a function file. */
+var FUNCTION_EXTENSION = ".mcfunction";
+/**
+* Derives a function id from a pack-relative path, following the 26.3 layout
+* `data/<namespace>/function/<path>.mcfunction`.
+*
+* @returns The namespaced id, or undefined when the path is not a function file.
+*/
+var functionIdForPath = (path) => {
+	if (!path.startsWith("data/") || !path.endsWith(".mcfunction")) return void 0;
+	const [namespace, folder, ...rest] = path.slice(5, -11).split("/");
+	if (!namespace || folder !== "function" || rest.length === 0) return void 0;
+	if (!NAMESPACE_PATTERN.test(namespace)) return void 0;
+	const idPath = rest.join("/");
+	if (!PATH_PATTERN.test(idPath)) return void 0;
+	return `${namespace}:${idPath}`;
+};
+/**
+* Derives a function tag id from a pack-relative path, following
+* `data/<namespace>/tags/function/<path>.json`.
+*
+* @returns The namespaced tag id without a `#`, or undefined when the path is not a function tag.
+*/
+var functionTagIdForPath = (path) => {
+	if (!path.startsWith("data/") || !path.endsWith(".json")) return void 0;
+	const [namespace, folder, registry, ...rest] = path.slice(5, -5).split("/");
+	if (!namespace || folder !== "tags" || registry !== "function" || rest.length === 0) return void 0;
+	if (!NAMESPACE_PATTERN.test(namespace)) return void 0;
+	const idPath = rest.join("/");
+	if (!PATH_PATTERN.test(idPath)) return void 0;
+	return `${namespace}:${idPath}`;
+};
+exports.DEFAULT_NAMESPACE = DEFAULT_NAMESPACE;
+exports.FUNCTION_EXTENSION = FUNCTION_EXTENSION;
+exports.functionIdForPath = functionIdForPath;
+exports.functionTagIdForPath = functionTagIdForPath;
+exports.normalizeIdentifier = normalizeIdentifier;
+exports.parseFunctionReference = parseFunctionReference;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/identifiers.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Namespaced ids as `/function` and the function tag files use them. A
+ * reference is either a function id (`minecraft:foo/bar`) or a tag id written
+ * with a leading `#` (`#minecraft:tick`); both default to the `minecraft`
+ * namespace when the colon is left out.
+ */
+/** The namespace an id without a colon belongs to. */
+export declare const DEFAULT_NAMESPACE = "minecraft";
+/** A parsed reference to either one function or a function tag. */
+export interface FunctionReference {
+    /** Whether the reference named a tag (`#namespace:path`) or a single function. */
+    kind: 'function' | 'tag';
+    /** The namespaced id, always with an explicit namespace and without the `#`. */
+    id: string;
+}
+/**
+ * Normalizes a namespaced id, filling in the default namespace.
+ *
+ * @returns The `namespace:path` form, or undefined when either half is not a legal id.
+ */
+export declare const normalizeIdentifier: (text: string) => string | undefined;
+/**
+ * Parses the argument of a `/function` call or a function tag entry.
+ *
+ * @returns The reference, or undefined when the text is not a legal id.
+ */
+export declare const parseFunctionReference: (text: string) => FunctionReference | undefined;
+/** The file extension of a function file. */
+export declare const FUNCTION_EXTENSION = ".mcfunction";
+/**
+ * Derives a function id from a pack-relative path, following the 26.3 layout
+ * `data/<namespace>/function/<path>.mcfunction`.
+ *
+ * @returns The namespaced id, or undefined when the path is not a function file.
+ */
+export declare const functionIdForPath: (path: string) => string | undefined;
+/**
+ * Derives a function tag id from a pack-relative path, following
+ * `data/<namespace>/tags/function/<path>.json`.
+ *
+ * @returns The namespaced tag id without a `#`, or undefined when the path is not a function tag.
+ */
+export declare const functionTagIdForPath: (path: string) => string | undefined;
+//# sourceMappingURL=identifiers.d.ts.map

package/dist/identifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifiers.d.ts","sourceRoot":"","sources":["../src/identifiers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,sDAAsD;AACtD,eAAO,MAAM,iBAAiB,cAAc,CAAC;AAE7C,mEAAmE;AACnE,MAAM,WAAW,iBAAiB;IAC9B,kFAAkF;IAClF,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC;IACzB,gFAAgF;IAChF,EAAE,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,SAAU,MAAM,KAAG,MAAM,GAAG,SAM3D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,SAAU,MAAM,KAAG,iBAAiB,GAAG,SAKzE,CAAC;AAEF,6CAA6C;AAC7C,eAAO,MAAM,kBAAkB,gBAAgB,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,SAAU,MAAM,KAAG,MAAM,GAAG,SAWzD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,SAAU,MAAM,KAAG,MAAM,GAAG,SAW5D,CAAC"}

package/dist/identifiers.es.js

@@ -0,0 +1,72 @@
+// src/identifiers.ts
+/**
+* Namespaced ids as `/function` and the function tag files use them. A
+* reference is either a function id (`minecraft:foo/bar`) or a tag id written
+* with a leading `#` (`#minecraft:tick`); both default to the `minecraft`
+* namespace when the colon is left out.
+*/
+var NAMESPACE_PATTERN = /^[a-z0-9_.-]+$/;
+var PATH_PATTERN = /^[a-z0-9_./-]+$/;
+/** The namespace an id without a colon belongs to. */
+var DEFAULT_NAMESPACE = "minecraft";
+/**
+* Normalizes a namespaced id, filling in the default namespace.
+*
+* @returns The `namespace:path` form, or undefined when either half is not a legal id.
+*/
+var normalizeIdentifier = (text) => {
+	const colon = text.indexOf(":");
+	const namespace = colon === -1 ? DEFAULT_NAMESPACE : text.slice(0, colon);
+	const path = colon === -1 ? text : text.slice(colon + 1);
+	if (!NAMESPACE_PATTERN.test(namespace) || !PATH_PATTERN.test(path)) return void 0;
+	return `${namespace}:${path}`;
+};
+/**
+* Parses the argument of a `/function` call or a function tag entry.
+*
+* @returns The reference, or undefined when the text is not a legal id.
+*/
+var parseFunctionReference = (text) => {
+	const tag = text.startsWith("#");
+	const id = normalizeIdentifier(tag ? text.slice(1) : text);
+	if (id === void 0) return void 0;
+	return {
+		kind: tag ? "tag" : "function",
+		id
+	};
+};
+/** The file extension of a function file. */
+var FUNCTION_EXTENSION = ".mcfunction";
+/**
+* Derives a function id from a pack-relative path, following the 26.3 layout
+* `data/<namespace>/function/<path>.mcfunction`.
+*
+* @returns The namespaced id, or undefined when the path is not a function file.
+*/
+var functionIdForPath = (path) => {
+	if (!path.startsWith("data/") || !path.endsWith(".mcfunction")) return void 0;
+	const [namespace, folder, ...rest] = path.slice(5, -11).split("/");
+	if (!namespace || folder !== "function" || rest.length === 0) return void 0;
+	if (!NAMESPACE_PATTERN.test(namespace)) return void 0;
+	const idPath = rest.join("/");
+	if (!PATH_PATTERN.test(idPath)) return void 0;
+	return `${namespace}:${idPath}`;
+};
+/**
+* Derives a function tag id from a pack-relative path, following
+* `data/<namespace>/tags/function/<path>.json`.
+*
+* @returns The namespaced tag id without a `#`, or undefined when the path is not a function tag.
+*/
+var functionTagIdForPath = (path) => {
+	if (!path.startsWith("data/") || !path.endsWith(".json")) return void 0;
+	const [namespace, folder, registry, ...rest] = path.slice(5, -5).split("/");
+	if (!namespace || folder !== "tags" || registry !== "function" || rest.length === 0) return void 0;
+	if (!NAMESPACE_PATTERN.test(namespace)) return void 0;
+	const idPath = rest.join("/");
+	if (!PATH_PATTERN.test(idPath)) return void 0;
+	return `${namespace}:${idPath}`;
+};
+export { DEFAULT_NAMESPACE, FUNCTION_EXTENSION, functionIdForPath, functionTagIdForPath, normalizeIdentifier, parseFunctionReference };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/index.cjs.cjs

@@ -0,0 +1,36 @@
+"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_runner = require("./runner.cjs.cjs");
+const require_macro = require("./macro.cjs.cjs");
+const require_parse = require("./parse.cjs.cjs");
+const require_compile = require("./compile.cjs.cjs");
+const require_diagnostics = require("./diagnostics.cjs.cjs");
+const require_registry = require("./registry.cjs.cjs");
+const require_executor = require("./executor.cjs.cjs");
+exports.BEDROCK_MAX_COMMANDS_PER_FUNCTION = require_executor.BEDROCK_MAX_COMMANDS_PER_FUNCTION;
+exports.CompiledFunction = require_compile.CompiledFunction;
+exports.DEFAULT_EXECUTION_LIMITS = require_executor.DEFAULT_EXECUTION_LIMITS;
+exports.DEFAULT_NAMESPACE = require_identifiers.DEFAULT_NAMESPACE;
+exports.DiagnosticCollector = require_diagnostics.DiagnosticCollector;
+exports.FUNCTION_EXTENSION = require_identifiers.FUNCTION_EXTENSION;
+exports.FunctionExecutor = require_executor.FunctionExecutor;
+exports.FunctionRegistry = require_registry.FunctionRegistry;
+exports.FunctionTagRegistry = require_tags.FunctionTagRegistry;
+exports.LOAD_FUNCTION_TAG = require_tags.LOAD_FUNCTION_TAG;
+exports.MACRO_CACHE_ENTRIES = require_compile.MACRO_CACHE_ENTRIES;
+exports.MAX_COMMAND_LENGTH = require_parse.MAX_COMMAND_LENGTH;
+exports.RecordingCommandRunner = require_runner.RecordingCommandRunner;
+exports.TICK_FUNCTION_TAG = require_tags.TICK_FUNCTION_TAG;
+exports.compileFunction = require_compile.compileFunction;
+exports.compileMacroLine = require_macro.compileMacroLine;
+exports.functionIdForPath = require_identifiers.functionIdForPath;
+exports.functionTagIdForPath = require_identifiers.functionTagIdForPath;
+exports.loadFunctions = require_registry.loadFunctions;
+exports.normalizeIdentifier = require_identifiers.normalizeIdentifier;
+exports.parseFunctionReference = require_identifiers.parseFunctionReference;
+exports.parseFunctionSource = require_parse.parseFunctionSource;
+exports.renderMacroValue = require_macro.renderMacroValue;
+exports.resolveFunctionTag = require_tags.resolveFunctionTag;
+exports.substituteMacro = require_macro.substituteMacro;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './compile';
+export * from './diagnostics';
+export * from './executor';
+export * from './identifiers';
+export * from './macro';
+export * from './parse';
+export * from './registry';
+export * from './runner';
+export * from './tags';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC"}

package/dist/index.es.js

@@ -0,0 +1,10 @@
+import { DEFAULT_NAMESPACE, FUNCTION_EXTENSION, functionIdForPath, functionTagIdForPath, normalizeIdentifier, parseFunctionReference } from "./identifiers.es.js";
+import { FunctionTagRegistry, LOAD_FUNCTION_TAG, TICK_FUNCTION_TAG, resolveFunctionTag } from "./tags.es.js";
+import { RecordingCommandRunner } from "./runner.es.js";
+import { compileMacroLine, renderMacroValue, substituteMacro } from "./macro.es.js";
+import { MAX_COMMAND_LENGTH, parseFunctionSource } from "./parse.es.js";
+import { CompiledFunction, MACRO_CACHE_ENTRIES, compileFunction } from "./compile.es.js";
+import { DiagnosticCollector } from "./diagnostics.es.js";
+import { FunctionRegistry, loadFunctions } from "./registry.es.js";
+import { BEDROCK_MAX_COMMANDS_PER_FUNCTION, DEFAULT_EXECUTION_LIMITS, FunctionExecutor } from "./executor.es.js";
+export { BEDROCK_MAX_COMMANDS_PER_FUNCTION, CompiledFunction, DEFAULT_EXECUTION_LIMITS, DEFAULT_NAMESPACE, DiagnosticCollector, FUNCTION_EXTENSION, FunctionExecutor, FunctionRegistry, FunctionTagRegistry, LOAD_FUNCTION_TAG, MACRO_CACHE_ENTRIES, MAX_COMMAND_LENGTH, RecordingCommandRunner, TICK_FUNCTION_TAG, compileFunction, compileMacroLine, functionIdForPath, functionTagIdForPath, loadFunctions, normalizeIdentifier, parseFunctionReference, parseFunctionSource, renderMacroValue, resolveFunctionTag, substituteMacro };