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

package/dist/tags.cjs.cjs

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_identifiers = require("./identifiers.cjs.cjs");
+// src/tags.ts
+/** The tag whose functions run once after the packs load. */
+var LOAD_FUNCTION_TAG = "minecraft:load";
+/** The tag whose functions run on every server tick. */
+var TICK_FUNCTION_TAG = "minecraft:tick";
+/**
+* Expands a function tag into the functions it names.
+*
+* Entries apply in order and a nested `#tag` expands where it appears. A
+* function already named earlier is not repeated. A cycle between tags is
+* reported and cut rather than followed, and a missing entry is reported only
+* when the entry does not say `required: false`.
+*
+* @param tagId - The tag id, with or without the leading `#`.
+*/
+var resolveFunctionTag = (lookup, tagId) => {
+	const functions = [];
+	const diagnostics = [];
+	const seen = /* @__PURE__ */ new Set();
+	const open = /* @__PURE__ */ new Set();
+	const visit = (id, required) => {
+		if (open.has(id)) {
+			diagnostics.push({
+				severity: "error",
+				code: "tag.cycle",
+				message: `the function tag #${id} references itself`
+			});
+			return;
+		}
+		const tag = lookup.get(id);
+		if (!tag) {
+			if (required) diagnostics.push({
+				severity: "error",
+				code: "tag.missing-entry",
+				message: `the function tag #${id} does not exist`
+			});
+			return;
+		}
+		open.add(id);
+		for (const entry of tag.values) {
+			const text = typeof entry === "string" ? entry : entry.id;
+			const entryRequired = typeof entry === "string" ? true : entry.required !== false;
+			const reference = require_identifiers.parseFunctionReference(text);
+			if (!reference) {
+				diagnostics.push({
+					severity: "error",
+					code: "tag.missing-entry",
+					message: `'${text}' in #${id} is not a valid function reference`
+				});
+				continue;
+			}
+			if (reference.kind === "tag") {
+				visit(reference.id, entryRequired);
+				continue;
+			}
+			if (seen.has(reference.id)) continue;
+			seen.add(reference.id);
+			functions.push(reference.id);
+		}
+		open.delete(id);
+	};
+	const start = require_identifiers.normalizeIdentifier(tagId.startsWith("#") ? tagId.slice(1) : tagId);
+	if (start === void 0) return {
+		functions: [],
+		exists: false,
+		diagnostics: [{
+			severity: "error",
+			code: "tag.missing-entry",
+			message: `'${tagId}' is not a valid tag id`
+		}]
+	};
+	const exists = lookup.get(start) !== void 0;
+	visit(start, false);
+	return {
+		functions,
+		exists,
+		diagnostics
+	};
+};
+/**
+* The tags a pack stack declares. Tags merge instead of replacing: every pack
+* that declares the same tag adds its entries, and only `replace: true`
+* discards what came before, which is how one pack adds to `minecraft:tick`
+* without hiding another pack's entry.
+*/
+var FunctionTagRegistry = class {
+	tags = /* @__PURE__ */ new Map();
+	/** Merges one tag file into the registry, honoring its `replace` flag. */
+	add(tagId, tag) {
+		const id = require_identifiers.normalizeIdentifier(tagId.startsWith("#") ? tagId.slice(1) : tagId);
+		if (id === void 0) return;
+		const existing = tag.replace ? void 0 : this.tags.get(id);
+		this.tags.set(id, [...existing ?? [], ...tag.values]);
+	}
+	/** Returns the merged tag, or undefined when no pack declared it. */
+	get(tagId) {
+		const values = this.tags.get(tagId);
+		return values ? { values } : void 0;
+	}
+	/** Every tag id the stack declared. */
+	ids() {
+		return [...this.tags.keys()];
+	}
+};
+exports.FunctionTagRegistry = FunctionTagRegistry;
+exports.LOAD_FUNCTION_TAG = LOAD_FUNCTION_TAG;
+exports.TICK_FUNCTION_TAG = TICK_FUNCTION_TAG;
+exports.resolveFunctionTag = resolveFunctionTag;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tags.cjs.cjs","names":["parseFunctionReference","normalizeIdentifier"],"sources":["../src/tags.ts"],"sourcesContent":["/**\n * Function tags, including the two the server looks up by name. Java's\n * `ServerFunctionManager` declares exactly two tag constants, `minecraft:tick`\n * and `minecraft:load`, and nothing else in the server reads a function tag\n * on its own. Every other tag is reached from a `function #namespace:tag`\n * line.\n *\n * Vanilla ships neither file: the 26.3 server jar has 883 tag files and none\n * of them tags the function registry. A pack supplies both.\n */\n\nimport type { Diagnostic } from './diagnostics';\nimport { normalizeIdentifier, parseFunctionReference } from './identifiers';\n\n/** The tag whose functions run once after the packs load. */\nexport const LOAD_FUNCTION_TAG = 'minecraft:load';\n\n/** The tag whose functions run on every server tick. */\nexport const TICK_FUNCTION_TAG = 'minecraft:tick';\n\n/**\n * One entry of a tag file: a function id, a `#tag` reference, or the object\n * form, whose `required: false` lets a pack reference something that may not\n * be installed.\n */\nexport type FunctionTagEntry = string | { id: string; required?: boolean };\n\n/** One tag file's contents after the packs that declare it are merged. */\nexport interface FunctionTag {\n    values: readonly FunctionTagEntry[];\n    /** Whether the tag discards what earlier packs contributed. */\n    replace?: boolean;\n}\n\n/** Where {@link resolveFunctionTag} reads tags from. */\nexport interface FunctionTagLookup {\n    /** Returns the tag registered under a namespaced id, without the `#`. */\n    get(tagId: string): FunctionTag | undefined;\n}\n\n/** The functions a tag names, in the order they run, plus anything that did not resolve. */\nexport interface TagResolution {\n    /** The function ids, each once, in tag order with nested tags expanded in place. */\n    functions: readonly string[];\n    /** Whether the tag itself exists. An empty tag that exists resolves to no functions. */\n    exists: boolean;\n    diagnostics: readonly Diagnostic[];\n}\n\n/**\n * Expands a function tag into the functions it names.\n *\n * Entries apply in order and a nested `#tag` expands where it appears. A\n * function already named earlier is not repeated. A cycle between tags is\n * reported and cut rather than followed, and a missing entry is reported only\n * when the entry does not say `required: false`.\n *\n * @param tagId - The tag id, with or without the leading `#`.\n */\nexport const resolveFunctionTag = (lookup: FunctionTagLookup, tagId: string): TagResolution => {\n    const functions: string[] = [];\n    const diagnostics: Diagnostic[] = [];\n    const seen = new Set<string>();\n    const open = new Set<string>();\n\n    const visit = (id: string, required: boolean): void => {\n        if (open.has(id)) {\n            diagnostics.push({\n                severity: 'error',\n                code: 'tag.cycle',\n                message: `the function tag #${id} references itself`\n            });\n            return;\n        }\n\n        const tag = lookup.get(id);\n        if (!tag) {\n            if (required) {\n                diagnostics.push({\n                    severity: 'error',\n                    code: 'tag.missing-entry',\n                    message: `the function tag #${id} does not exist`\n                });\n            }\n            return;\n        }\n\n        open.add(id);\n        for (const entry of tag.values) {\n            const text = typeof entry === 'string' ? entry : entry.id;\n            const entryRequired = typeof entry === 'string' ? true : entry.required !== false;\n            const reference = parseFunctionReference(text);\n            if (!reference) {\n                diagnostics.push({\n                    severity: 'error',\n                    code: 'tag.missing-entry',\n                    message: `'${text}' in #${id} is not a valid function reference`\n                });\n                continue;\n            }\n\n            if (reference.kind === 'tag') {\n                visit(reference.id, entryRequired);\n                continue;\n            }\n\n            if (seen.has(reference.id)) continue;\n            seen.add(reference.id);\n            functions.push(reference.id);\n        }\n        open.delete(id);\n    };\n\n    const start = normalizeIdentifier(tagId.startsWith('#') ? tagId.slice(1) : tagId);\n    if (start === undefined) {\n        return {\n            functions: [],\n            exists: false,\n            diagnostics: [{ severity: 'error', code: 'tag.missing-entry', message: `'${tagId}' is not a valid tag id` }]\n        };\n    }\n\n    const exists = lookup.get(start) !== undefined;\n    visit(start, false);\n    return { functions, exists, diagnostics };\n};\n\n/**\n * The tags a pack stack declares. Tags merge instead of replacing: every pack\n * that declares the same tag adds its entries, and only `replace: true`\n * discards what came before, which is how one pack adds to `minecraft:tick`\n * without hiding another pack's entry.\n */\nexport class FunctionTagRegistry implements FunctionTagLookup {\n    private readonly tags = new Map<string, FunctionTagEntry[]>();\n\n    /** Merges one tag file into the registry, honoring its `replace` flag. */\n    public add(tagId: string, tag: FunctionTag): void {\n        const id = normalizeIdentifier(tagId.startsWith('#') ? tagId.slice(1) : tagId);\n        if (id === undefined) return;\n\n        const existing = tag.replace ? undefined : this.tags.get(id);\n        this.tags.set(id, [...(existing ?? []), ...tag.values]);\n    }\n\n    /** Returns the merged tag, or undefined when no pack declared it. */\n    public get(tagId: string): FunctionTag | undefined {\n        const values = this.tags.get(tagId);\n        return values ? { values } : undefined;\n    }\n\n    /** Every tag id the stack declared. */\n    public ids(): readonly string[] {\n        return [...this.tags.keys()];\n    }\n}\n"],"mappings":";;;;;AAeA,IAAa,oBAAoB;;AAGjC,IAAa,oBAAoB;;;;;;;;;;;AAyCjC,IAAa,sBAAsB,QAA2B,UAAiC;CAC3F,MAAM,YAAsB,CAAC;CAC7B,MAAM,cAA4B,CAAC;CACnC,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,uBAAO,IAAI,IAAY;CAE7B,MAAM,SAAS,IAAY,aAA4B;EACnD,IAAI,KAAK,IAAI,EAAE,GAAG;GACd,YAAY,KAAK;IACb,UAAU;IACV,MAAM;IACN,SAAS,qBAAqB,GAAG;GACrC,CAAC;GACD;EACJ;EAEA,MAAM,MAAM,OAAO,IAAI,EAAE;EACzB,IAAI,CAAC,KAAK;GACN,IAAI,UACA,YAAY,KAAK;IACb,UAAU;IACV,MAAM;IACN,SAAS,qBAAqB,GAAG;GACrC,CAAC;GAEL;EACJ;EAEA,KAAK,IAAI,EAAE;EACX,KAAK,MAAM,SAAS,IAAI,QAAQ;GAC5B,MAAM,OAAO,OAAO,UAAU,WAAW,QAAQ,MAAM;GACvD,MAAM,gBAAgB,OAAO,UAAU,WAAW,OAAO,MAAM,aAAa;GAC5E,MAAM,YAAYA,oBAAAA,uBAAuB,IAAI;GAC7C,IAAI,CAAC,WAAW;IACZ,YAAY,KAAK;KACb,UAAU;KACV,MAAM;KACN,SAAS,IAAI,KAAK,QAAQ,GAAG;IACjC,CAAC;IACD;GACJ;GAEA,IAAI,UAAU,SAAS,OAAO;IAC1B,MAAM,UAAU,IAAI,aAAa;IACjC;GACJ;GAEA,IAAI,KAAK,IAAI,UAAU,EAAE,GAAG;GAC5B,KAAK,IAAI,UAAU,EAAE;GACrB,UAAU,KAAK,UAAU,EAAE;EAC/B;EACA,KAAK,OAAO,EAAE;CAClB;CAEA,MAAM,QAAQC,oBAAAA,oBAAoB,MAAM,WAAW,GAAG,IAAI,MAAM,MAAM,CAAC,IAAI,KAAK;CAChF,IAAI,UAAU,KAAA,GACV,OAAO;EACH,WAAW,CAAC;EACZ,QAAQ;EACR,aAAa,CAAC;GAAE,UAAU;GAAS,MAAM;GAAqB,SAAS,IAAI,MAAM;EAAyB,CAAC;CAC/G;CAGJ,MAAM,SAAS,OAAO,IAAI,KAAK,MAAM,KAAA;CACrC,MAAM,OAAO,KAAK;CAClB,OAAO;EAAE;EAAW;EAAQ;CAAY;AAC5C;;;;;;;AAQA,IAAa,sBAAb,MAA8D;CAC1D,uBAAwB,IAAI,IAAgC;;CAG5D,IAAW,OAAe,KAAwB;EAC9C,MAAM,KAAKA,oBAAAA,oBAAoB,MAAM,WAAW,GAAG,IAAI,MAAM,MAAM,CAAC,IAAI,KAAK;EAC7E,IAAI,OAAO,KAAA,GAAW;EAEtB,MAAM,WAAW,IAAI,UAAU,KAAA,IAAY,KAAK,KAAK,IAAI,EAAE;EAC3D,KAAK,KAAK,IAAI,IAAI,CAAC,GAAI,YAAY,CAAC,GAAI,GAAG,IAAI,MAAM,CAAC;CAC1D;;CAGA,IAAW,OAAwC;EAC/C,MAAM,SAAS,KAAK,KAAK,IAAI,KAAK;EAClC,OAAO,SAAS,EAAE,OAAO,IAAI,KAAA;CACjC;;CAGA,MAAgC;EAC5B,OAAO,CAAC,GAAG,KAAK,KAAK,KAAK,CAAC;CAC/B;AACJ"}

package/dist/tags.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Function tags, including the two the server looks up by name. Java's
+ * `ServerFunctionManager` declares exactly two tag constants, `minecraft:tick`
+ * and `minecraft:load`, and nothing else in the server reads a function tag
+ * on its own. Every other tag is reached from a `function #namespace:tag`
+ * line.
+ *
+ * Vanilla ships neither file: the 26.3 server jar has 883 tag files and none
+ * of them tags the function registry. A pack supplies both.
+ */
+import type { Diagnostic } from './diagnostics';
+/** The tag whose functions run once after the packs load. */
+export declare const LOAD_FUNCTION_TAG = "minecraft:load";
+/** The tag whose functions run on every server tick. */
+export declare const TICK_FUNCTION_TAG = "minecraft:tick";
+/**
+ * One entry of a tag file: a function id, a `#tag` reference, or the object
+ * form, whose `required: false` lets a pack reference something that may not
+ * be installed.
+ */
+export type FunctionTagEntry = string | {
+    id: string;
+    required?: boolean;
+};
+/** One tag file's contents after the packs that declare it are merged. */
+export interface FunctionTag {
+    values: readonly FunctionTagEntry[];
+    /** Whether the tag discards what earlier packs contributed. */
+    replace?: boolean;
+}
+/** Where {@link resolveFunctionTag} reads tags from. */
+export interface FunctionTagLookup {
+    /** Returns the tag registered under a namespaced id, without the `#`. */
+    get(tagId: string): FunctionTag | undefined;
+}
+/** The functions a tag names, in the order they run, plus anything that did not resolve. */
+export interface TagResolution {
+    /** The function ids, each once, in tag order with nested tags expanded in place. */
+    functions: readonly string[];
+    /** Whether the tag itself exists. An empty tag that exists resolves to no functions. */
+    exists: boolean;
+    diagnostics: readonly Diagnostic[];
+}
+/**
+ * Expands a function tag into the functions it names.
+ *
+ * Entries apply in order and a nested `#tag` expands where it appears. A
+ * function already named earlier is not repeated. A cycle between tags is
+ * reported and cut rather than followed, and a missing entry is reported only
+ * when the entry does not say `required: false`.
+ *
+ * @param tagId - The tag id, with or without the leading `#`.
+ */
+export declare const resolveFunctionTag: (lookup: FunctionTagLookup, tagId: string) => TagResolution;
+/**
+ * The tags a pack stack declares. Tags merge instead of replacing: every pack
+ * that declares the same tag adds its entries, and only `replace: true`
+ * discards what came before, which is how one pack adds to `minecraft:tick`
+ * without hiding another pack's entry.
+ */
+export declare class FunctionTagRegistry implements FunctionTagLookup {
+    private readonly tags;
+    /** Merges one tag file into the registry, honoring its `replace` flag. */
+    add(tagId: string, tag: FunctionTag): void;
+    /** Returns the merged tag, or undefined when no pack declared it. */
+    get(tagId: string): FunctionTag | undefined;
+    /** Every tag id the stack declared. */
+    ids(): readonly string[];
+}
+//# sourceMappingURL=tags.d.ts.map

package/dist/tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../src/tags.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,6DAA6D;AAC7D,eAAO,MAAM,iBAAiB,mBAAmB,CAAC;AAElD,wDAAwD;AACxD,eAAO,MAAM,iBAAiB,mBAAmB,CAAC;AAElD;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAE3E,0EAA0E;AAC1E,MAAM,WAAW,WAAW;IACxB,MAAM,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACpC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,wDAAwD;AACxD,MAAM,WAAW,iBAAiB;IAC9B,yEAAyE;IACzE,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;CAC/C;AAED,4FAA4F;AAC5F,MAAM,WAAW,aAAa;IAC1B,oFAAoF;IACpF,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,wFAAwF;IACxF,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CACtC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,WAAY,iBAAiB,SAAS,MAAM,KAAG,aAkE7E,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,mBAAoB,YAAW,iBAAiB;IACzD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyC;IAE9D,0EAA0E;IACnE,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,IAAI,CAMhD;IAED,qEAAqE;IAC9D,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAGjD;IAED,uCAAuC;IAChC,GAAG,IAAI,SAAS,MAAM,EAAE,CAE9B;CACJ"}

package/dist/tags.es.js

@@ -0,0 +1,108 @@
+import { normalizeIdentifier, parseFunctionReference } from "./identifiers.es.js";
+// src/tags.ts
+/** The tag whose functions run once after the packs load. */
+var LOAD_FUNCTION_TAG = "minecraft:load";
+/** The tag whose functions run on every server tick. */
+var TICK_FUNCTION_TAG = "minecraft:tick";
+/**
+* Expands a function tag into the functions it names.
+*
+* Entries apply in order and a nested `#tag` expands where it appears. A
+* function already named earlier is not repeated. A cycle between tags is
+* reported and cut rather than followed, and a missing entry is reported only
+* when the entry does not say `required: false`.
+*
+* @param tagId - The tag id, with or without the leading `#`.
+*/
+var resolveFunctionTag = (lookup, tagId) => {
+	const functions = [];
+	const diagnostics = [];
+	const seen = /* @__PURE__ */ new Set();
+	const open = /* @__PURE__ */ new Set();
+	const visit = (id, required) => {
+		if (open.has(id)) {
+			diagnostics.push({
+				severity: "error",
+				code: "tag.cycle",
+				message: `the function tag #${id} references itself`
+			});
+			return;
+		}
+		const tag = lookup.get(id);
+		if (!tag) {
+			if (required) diagnostics.push({
+				severity: "error",
+				code: "tag.missing-entry",
+				message: `the function tag #${id} does not exist`
+			});
+			return;
+		}
+		open.add(id);
+		for (const entry of tag.values) {
+			const text = typeof entry === "string" ? entry : entry.id;
+			const entryRequired = typeof entry === "string" ? true : entry.required !== false;
+			const reference = parseFunctionReference(text);
+			if (!reference) {
+				diagnostics.push({
+					severity: "error",
+					code: "tag.missing-entry",
+					message: `'${text}' in #${id} is not a valid function reference`
+				});
+				continue;
+			}
+			if (reference.kind === "tag") {
+				visit(reference.id, entryRequired);
+				continue;
+			}
+			if (seen.has(reference.id)) continue;
+			seen.add(reference.id);
+			functions.push(reference.id);
+		}
+		open.delete(id);
+	};
+	const start = normalizeIdentifier(tagId.startsWith("#") ? tagId.slice(1) : tagId);
+	if (start === void 0) return {
+		functions: [],
+		exists: false,
+		diagnostics: [{
+			severity: "error",
+			code: "tag.missing-entry",
+			message: `'${tagId}' is not a valid tag id`
+		}]
+	};
+	const exists = lookup.get(start) !== void 0;
+	visit(start, false);
+	return {
+		functions,
+		exists,
+		diagnostics
+	};
+};
+/**
+* The tags a pack stack declares. Tags merge instead of replacing: every pack
+* that declares the same tag adds its entries, and only `replace: true`
+* discards what came before, which is how one pack adds to `minecraft:tick`
+* without hiding another pack's entry.
+*/
+var FunctionTagRegistry = class {
+	tags = /* @__PURE__ */ new Map();
+	/** Merges one tag file into the registry, honoring its `replace` flag. */
+	add(tagId, tag) {
+		const id = normalizeIdentifier(tagId.startsWith("#") ? tagId.slice(1) : tagId);
+		if (id === void 0) return;
+		const existing = tag.replace ? void 0 : this.tags.get(id);
+		this.tags.set(id, [...existing ?? [], ...tag.values]);
+	}
+	/** Returns the merged tag, or undefined when no pack declared it. */
+	get(tagId) {
+		const values = this.tags.get(tagId);
+		return values ? { values } : void 0;
+	}
+	/** Every tag id the stack declared. */
+	ids() {
+		return [...this.tags.keys()];
+	}
+};
+export { FunctionTagRegistry, LOAD_FUNCTION_TAG, TICK_FUNCTION_TAG, resolveFunctionTag };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tags.es.js","names":[],"sources":["../src/tags.ts"],"sourcesContent":["/**\n * Function tags, including the two the server looks up by name. Java's\n * `ServerFunctionManager` declares exactly two tag constants, `minecraft:tick`\n * and `minecraft:load`, and nothing else in the server reads a function tag\n * on its own. Every other tag is reached from a `function #namespace:tag`\n * line.\n *\n * Vanilla ships neither file: the 26.3 server jar has 883 tag files and none\n * of them tags the function registry. A pack supplies both.\n */\n\nimport type { Diagnostic } from './diagnostics';\nimport { normalizeIdentifier, parseFunctionReference } from './identifiers';\n\n/** The tag whose functions run once after the packs load. */\nexport const LOAD_FUNCTION_TAG = 'minecraft:load';\n\n/** The tag whose functions run on every server tick. */\nexport const TICK_FUNCTION_TAG = 'minecraft:tick';\n\n/**\n * One entry of a tag file: a function id, a `#tag` reference, or the object\n * form, whose `required: false` lets a pack reference something that may not\n * be installed.\n */\nexport type FunctionTagEntry = string | { id: string; required?: boolean };\n\n/** One tag file's contents after the packs that declare it are merged. */\nexport interface FunctionTag {\n    values: readonly FunctionTagEntry[];\n    /** Whether the tag discards what earlier packs contributed. */\n    replace?: boolean;\n}\n\n/** Where {@link resolveFunctionTag} reads tags from. */\nexport interface FunctionTagLookup {\n    /** Returns the tag registered under a namespaced id, without the `#`. */\n    get(tagId: string): FunctionTag | undefined;\n}\n\n/** The functions a tag names, in the order they run, plus anything that did not resolve. */\nexport interface TagResolution {\n    /** The function ids, each once, in tag order with nested tags expanded in place. */\n    functions: readonly string[];\n    /** Whether the tag itself exists. An empty tag that exists resolves to no functions. */\n    exists: boolean;\n    diagnostics: readonly Diagnostic[];\n}\n\n/**\n * Expands a function tag into the functions it names.\n *\n * Entries apply in order and a nested `#tag` expands where it appears. A\n * function already named earlier is not repeated. A cycle between tags is\n * reported and cut rather than followed, and a missing entry is reported only\n * when the entry does not say `required: false`.\n *\n * @param tagId - The tag id, with or without the leading `#`.\n */\nexport const resolveFunctionTag = (lookup: FunctionTagLookup, tagId: string): TagResolution => {\n    const functions: string[] = [];\n    const diagnostics: Diagnostic[] = [];\n    const seen = new Set<string>();\n    const open = new Set<string>();\n\n    const visit = (id: string, required: boolean): void => {\n        if (open.has(id)) {\n            diagnostics.push({\n                severity: 'error',\n                code: 'tag.cycle',\n                message: `the function tag #${id} references itself`\n            });\n            return;\n        }\n\n        const tag = lookup.get(id);\n        if (!tag) {\n            if (required) {\n                diagnostics.push({\n                    severity: 'error',\n                    code: 'tag.missing-entry',\n                    message: `the function tag #${id} does not exist`\n                });\n            }\n            return;\n        }\n\n        open.add(id);\n        for (const entry of tag.values) {\n            const text = typeof entry === 'string' ? entry : entry.id;\n            const entryRequired = typeof entry === 'string' ? true : entry.required !== false;\n            const reference = parseFunctionReference(text);\n            if (!reference) {\n                diagnostics.push({\n                    severity: 'error',\n                    code: 'tag.missing-entry',\n                    message: `'${text}' in #${id} is not a valid function reference`\n                });\n                continue;\n            }\n\n            if (reference.kind === 'tag') {\n                visit(reference.id, entryRequired);\n                continue;\n            }\n\n            if (seen.has(reference.id)) continue;\n            seen.add(reference.id);\n            functions.push(reference.id);\n        }\n        open.delete(id);\n    };\n\n    const start = normalizeIdentifier(tagId.startsWith('#') ? tagId.slice(1) : tagId);\n    if (start === undefined) {\n        return {\n            functions: [],\n            exists: false,\n            diagnostics: [{ severity: 'error', code: 'tag.missing-entry', message: `'${tagId}' is not a valid tag id` }]\n        };\n    }\n\n    const exists = lookup.get(start) !== undefined;\n    visit(start, false);\n    return { functions, exists, diagnostics };\n};\n\n/**\n * The tags a pack stack declares. Tags merge instead of replacing: every pack\n * that declares the same tag adds its entries, and only `replace: true`\n * discards what came before, which is how one pack adds to `minecraft:tick`\n * without hiding another pack's entry.\n */\nexport class FunctionTagRegistry implements FunctionTagLookup {\n    private readonly tags = new Map<string, FunctionTagEntry[]>();\n\n    /** Merges one tag file into the registry, honoring its `replace` flag. */\n    public add(tagId: string, tag: FunctionTag): void {\n        const id = normalizeIdentifier(tagId.startsWith('#') ? tagId.slice(1) : tagId);\n        if (id === undefined) return;\n\n        const existing = tag.replace ? undefined : this.tags.get(id);\n        this.tags.set(id, [...(existing ?? []), ...tag.values]);\n    }\n\n    /** Returns the merged tag, or undefined when no pack declared it. */\n    public get(tagId: string): FunctionTag | undefined {\n        const values = this.tags.get(tagId);\n        return values ? { values } : undefined;\n    }\n\n    /** Every tag id the stack declared. */\n    public ids(): readonly string[] {\n        return [...this.tags.keys()];\n    }\n}\n"],"mappings":";;;AAeA,IAAa,oBAAoB;;AAGjC,IAAa,oBAAoB;;;;;;;;;;;AAyCjC,IAAa,sBAAsB,QAA2B,UAAiC;CAC3F,MAAM,YAAsB,CAAC;CAC7B,MAAM,cAA4B,CAAC;CACnC,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,uBAAO,IAAI,IAAY;CAE7B,MAAM,SAAS,IAAY,aAA4B;EACnD,IAAI,KAAK,IAAI,EAAE,GAAG;GACd,YAAY,KAAK;IACb,UAAU;IACV,MAAM;IACN,SAAS,qBAAqB,GAAG;GACrC,CAAC;GACD;EACJ;EAEA,MAAM,MAAM,OAAO,IAAI,EAAE;EACzB,IAAI,CAAC,KAAK;GACN,IAAI,UACA,YAAY,KAAK;IACb,UAAU;IACV,MAAM;IACN,SAAS,qBAAqB,GAAG;GACrC,CAAC;GAEL;EACJ;EAEA,KAAK,IAAI,EAAE;EACX,KAAK,MAAM,SAAS,IAAI,QAAQ;GAC5B,MAAM,OAAO,OAAO,UAAU,WAAW,QAAQ,MAAM;GACvD,MAAM,gBAAgB,OAAO,UAAU,WAAW,OAAO,MAAM,aAAa;GAC5E,MAAM,YAAY,uBAAuB,IAAI;GAC7C,IAAI,CAAC,WAAW;IACZ,YAAY,KAAK;KACb,UAAU;KACV,MAAM;KACN,SAAS,IAAI,KAAK,QAAQ,GAAG;IACjC,CAAC;IACD;GACJ;GAEA,IAAI,UAAU,SAAS,OAAO;IAC1B,MAAM,UAAU,IAAI,aAAa;IACjC;GACJ;GAEA,IAAI,KAAK,IAAI,UAAU,EAAE,GAAG;GAC5B,KAAK,IAAI,UAAU,EAAE;GACrB,UAAU,KAAK,UAAU,EAAE;EAC/B;EACA,KAAK,OAAO,EAAE;CAClB;CAEA,MAAM,QAAQ,oBAAoB,MAAM,WAAW,GAAG,IAAI,MAAM,MAAM,CAAC,IAAI,KAAK;CAChF,IAAI,UAAU,KAAA,GACV,OAAO;EACH,WAAW,CAAC;EACZ,QAAQ;EACR,aAAa,CAAC;GAAE,UAAU;GAAS,MAAM;GAAqB,SAAS,IAAI,MAAM;EAAyB,CAAC;CAC/G;CAGJ,MAAM,SAAS,OAAO,IAAI,KAAK,MAAM,KAAA;CACrC,MAAM,OAAO,KAAK;CAClB,OAAO;EAAE;EAAW;EAAQ;CAAY;AAC5C;;;;;;;AAQA,IAAa,sBAAb,MAA8D;CAC1D,uBAAwB,IAAI,IAAgC;;CAG5D,IAAW,OAAe,KAAwB;EAC9C,MAAM,KAAK,oBAAoB,MAAM,WAAW,GAAG,IAAI,MAAM,MAAM,CAAC,IAAI,KAAK;EAC7E,IAAI,OAAO,KAAA,GAAW;EAEtB,MAAM,WAAW,IAAI,UAAU,KAAA,IAAY,KAAK,KAAK,IAAI,EAAE;EAC3D,KAAK,KAAK,IAAI,IAAI,CAAC,GAAI,YAAY,CAAC,GAAI,GAAG,IAAI,MAAM,CAAC;CAC1D;;CAGA,IAAW,OAAwC;EAC/C,MAAM,SAAS,KAAK,KAAK,IAAI,KAAK;EAClC,OAAO,SAAS,EAAE,OAAO,IAAI,KAAA;CACjC;;CAGA,MAAgC;EAC5B,OAAO,CAAC,GAAG,KAAK,KAAK,KAAK,CAAC;CAC/B;AACJ"}

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@jsprismarine/mcfunction",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.16.0-unstable-20261029132853",
+  "description": "Java Edition mcfunction runtime: parser, macros, function tags and a queue-based executor",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": [
+    "dist",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "main": "./dist/index.cjs.cjs",
+  "module": "./dist/index.es.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.es.js",
+      "module": "./dist/index.es.js",
+      "require": "./dist/index.cjs.cjs"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.es.js",
+      "module": "./dist/*.es.js",
+      "require": "./dist/*.cjs.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JSPrismarine/JSPrismarine.git"
+  },
+  "keywords": [
+    "jsprismarine",
+    "minecraft",
+    "mcfunction",
+    "datapack"
+  ],
+  "author": "JSPrismarine",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/JSPrismarine/JSPrismarine/issues"
+  },
+  "homepage": "https://github.com/JSPrismarine/JSPrismarine/tree/master/packages/mcfunction",
+  "devDependencies": {
+    "@types/node": "24.19.2",
+    "glob": "13.0.6",
+    "rimraf": "6.1.3",
+    "typescript": "7.0.2",
+    "vite": "8.3.5",
+    "vitest": "5.0.5"
+  },
+  "scripts": {
+    "clean": "rimraf dist jsp *.tsbuildinfo vite.config.ts.timestamp-* .tsup .turbo",
+    "build": "vite build && node ../../scripts/emit-dts.mts",
+    "build:watch": "vite build --watch",
+    "test": "vitest run",
+    "typecheck": "tsc-ts --noEmit && tsc-ts --noEmit -p tsconfig.test.json"
+  }
 }