@jsprismarine/mcfunction 0.0.0 → 0.16.0-unstable-20261029132853

package/dist/executor.cjs.cjs

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_identifiers = require("./identifiers.cjs.cjs");
+const require_tags = require("./tags.cjs.cjs");
+// 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(`#${require_tags.LOAD_FUNCTION_TAG}`, options);
+	}
+	/** Runs `minecraft:tick`, which a server does once per server tick. */
+	runTick(options) {
+		return this.run(`#${require_tags.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 = require_identifiers.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 = require_tags.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 = require_identifiers.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 = require_tags.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;
+	}
+};
+exports.BEDROCK_MAX_COMMANDS_PER_FUNCTION = BEDROCK_MAX_COMMANDS_PER_FUNCTION;
+exports.DEFAULT_EXECUTION_LIMITS = DEFAULT_EXECUTION_LIMITS;
+exports.FunctionExecutor = FunctionExecutor;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"executor.cjs.cjs","names":["LOAD_FUNCTION_TAG","TICK_FUNCTION_TAG","parseFunctionReference","resolveFunctionTag"],"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/executor.d.ts

@@ -0,0 +1,140 @@
+/**
+ * The executor. Java rewrote function execution in 23w41a from a recursive
+ * call path into an explicit queue of frames on the heap, which is what lets
+ * it bound work with a counter and stops a tail-recursive pack from
+ * exhausting the host stack. This is the same shape: a stack of frames in an
+ * array, one loop, and a counter charged per operation.
+ */
+import type { CompiledFunction } from './compile';
+import type { Diagnostic } from './diagnostics';
+import type { MacroArguments } from './macro';
+import type { CommandRunner } from './runner';
+import type { FunctionTagLookup } from './tags';
+/**
+ * The two gamerules that bound a run. They were renamed in 1.21.11 from
+ * `maxCommandChainLength` and `maxCommandForkCount`; anything written against
+ * the camelCase names is stale.
+ */
+export interface ExecutionLimits {
+    /** `minecraft:max_command_sequence_length`: how many operations one entry point may run. */
+    maxCommandSequenceLength: number;
+    /** `minecraft:max_command_forks`: how many contexts one entry point may create. */
+    maxCommandForks: number;
+}
+/**
+ * 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.
+ */
+export declare const DEFAULT_EXECUTION_LIMITS: ExecutionLimits;
+/**
+ * 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`.
+ */
+export declare const BEDROCK_MAX_COMMANDS_PER_FUNCTION = 10000;
+/** Where the executor reads compiled functions from. */
+export interface FunctionLookup {
+    /** Returns the function registered under a namespaced id. */
+    get(id: string): CompiledFunction | undefined;
+}
+/** How to build a {@link FunctionExecutor}. */
+export interface FunctionExecutorOptions<TSource = unknown> {
+    functions: FunctionLookup;
+    runner: CommandRunner<TSource>;
+    /** Resolves `#namespace:tag` references. Without it, a tag reference is reported as unknown. */
+    tags?: FunctionTagLookup;
+    /** Overrides either limit; anything left out keeps its {@link DEFAULT_EXECUTION_LIMITS} value. */
+    limits?: Partial<ExecutionLimits>;
+    /**
+     * Reads the argument compound of a `function <id> <arguments>` line. The
+     * default accepts JSON, because SNBT needs a parser this package does not
+     * own; a server with one passes it here.
+     */
+    parseArguments?: (text: string) => MacroArguments | undefined;
+}
+/** What one call needs beyond the function to run. */
+export interface ExecutionOptions<TSource = unknown> {
+    /** The command source every command in the run is given. */
+    source: TSource;
+    /** The compound a macro function substitutes from. Ignored by a plain function. */
+    arguments?: MacroArguments;
+}
+/** Why a run stopped before it finished. */
+export type ExecutionStop = 'max-command-sequence-length' | 'max-command-forks';
+/** What one run did. */
+export interface ExecutionReport {
+    /** Operations charged against `maxCommandSequenceLength`. */
+    operations: number;
+    /** Contexts charged against `maxCommandForks`. */
+    forks: number;
+    /** How many command lines reached the runner. */
+    commands: number;
+    /** How many functions the run invoked, including the entry point. */
+    invocations: number;
+    /** The deepest the frame stack got. A tail call does not deepen it. */
+    maxDepth: number;
+    /**
+     * The values `/return` produced, one per function the entry point
+     * invoked directly that reached one.
+     *
+     * Empty when every function ran to its last line, which is the case Java
+     * calls "returned no value". A tag contributes one entry per member that
+     * returned, because `execute if function #tag` matches when any member
+     * did. A `/return` deeper in the call tree ends its own function and
+     * leaves nothing here, the way Java returns from one function rather
+     * than from its caller.
+     */
+    returnValues: readonly number[];
+    /** Set when a limit stopped the run; the matching diagnostic carries the detail. */
+    stopped?: ExecutionStop;
+    diagnostics: readonly Diagnostic[];
+}
+/**
+ * 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.
+ */
+export declare class FunctionExecutor<TSource = unknown> {
+    private readonly options;
+    private readonly limits;
+    private readonly parseArguments;
+    constructor(options: FunctionExecutorOptions<TSource>);
+    /** Runs `minecraft:load`, which a server does once after its packs load. */
+    runLoad(options: ExecutionOptions<TSource>): ExecutionReport;
+    /** Runs `minecraft:tick`, which a server does once per server tick. */
+    runTick(options: ExecutionOptions<TSource>): ExecutionReport;
+    /**
+     * 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: string, options: ExecutionOptions<TSource>): ExecutionReport;
+    /** Expands a tag reference, reporting a tag no pack declared. */
+    private resolveTag;
+    /** Runs one `function` line: resolves what it names and pushes the frames it invokes. */
+    private handleCall;
+}
+//# sourceMappingURL=executor.d.ts.map

package/dist/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../src/executor.ts"],"names":[],"mappings":"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"}