@aigne/afs-world-mapping 1.11.0-beta.10

package/dist/index.mjs

@@ -0,0 +1,992 @@
+//#region src/capability.ts
+const REQUIRED_METHODS = [
+	"loadWorld",
+	"reloadWorld",
+	"getWorldStatus",
+	"resolve",
+	"project",
+	"mutate"
+];
+function isWorldMappingCapable(module) {
+	if (!module || typeof module !== "object") return false;
+	const obj = module;
+	return REQUIRED_METHODS.every((method) => typeof obj[method] === "function");
+}
+
+//#endregion
+//#region src/compiler.ts
+var WorldCompiler = class {
+	compile(schema, binding) {
+		if (!schema.world) throw new Error("WorldCompiler: schema missing world name");
+		if (!schema.version) throw new Error("WorldCompiler: schema missing version");
+		for (const [kindName, kindDef] of Object.entries(schema.kinds)) {
+			this.validateIdentifier(kindName, `kind name "${kindName}"`);
+			if (kindDef.fields) for (const fieldName of Object.keys(kindDef.fields)) this.validateIdentifier(fieldName, `field name "${fieldName}" in kind "${kindName}"`);
+		}
+		for (const [kindName, kindDef] of Object.entries(schema.kinds)) {
+			if (kindDef.fields) for (const [fieldName, fieldType] of Object.entries(kindDef.fields)) this.validateFieldType(fieldType, kindName, fieldName);
+			if (kindDef.relations) for (const [relationName, relationType] of Object.entries(kindDef.relations)) {
+				const match = relationType.match(/^list:(.+)$/);
+				if (match?.[1] && !schema.kinds[match[1]]) throw new Error(`WorldCompiler: relation "${relationName}" in kind "${kindName}" references unknown kind "${match[1]}"`);
+			}
+		}
+		const trie = this.buildPathTrie(schema);
+		const kinds = {};
+		for (const [kindName, kindDef] of Object.entries(schema.kinds)) {
+			const kindMapping = binding.mappings?.[kindName];
+			kinds[kindName] = {
+				key: kindDef.key,
+				source: kindMapping?.source ?? binding.source,
+				fieldMap: kindMapping?.fieldMap ?? {}
+			};
+		}
+		return {
+			world: schema.world,
+			version: schema.version,
+			resolve: (path) => this.resolvePath(trie, path),
+			kinds
+		};
+	}
+	validateIdentifier(value, context) {
+		if (!/^[A-Za-z0-9_]+$/.test(value)) throw new Error(`WorldCompiler: invalid identifier for ${context}. Must only contain [A-Za-z0-9_]`);
+	}
+	validateFieldType(fieldType, kindName, fieldName) {
+		if ([
+			"int",
+			"string",
+			"text",
+			"bool",
+			"datetime"
+		].includes(fieldType)) return;
+		if (fieldType.startsWith("enum(") && fieldType.endsWith(")")) return;
+		if (fieldType.startsWith("list:")) return;
+		if (fieldType.startsWith("ref:")) return;
+		throw new Error(`WorldCompiler: field "${fieldName}" in kind "${kindName}" has invalid type "${fieldType}"`);
+	}
+	buildPathTrie(schema) {
+		const root = { children: /* @__PURE__ */ new Map() };
+		for (const [kindName, kindDef] of Object.entries(schema.kinds)) {
+			const segments = kindDef.path.split("/").filter((s) => s.length > 0);
+			const keyParamName = `{${kindDef.key}}`;
+			let node = root;
+			for (let i = 0; i < segments.length; i++) {
+				const segment = segments[i];
+				const isLastSegment = i === segments.length - 1;
+				if (segment.startsWith("{") && segment.endsWith("}")) {
+					const paramName = segment.slice(1, -1);
+					if (!node.param) node.param = {
+						paramName,
+						children: /* @__PURE__ */ new Map()
+					};
+					node = node.param;
+					if (isLastSegment) {
+						node.kind = kindName;
+						node.isCollection = false;
+					}
+				} else {
+					if (!node.children.has(segment)) node.children.set(segment, { children: /* @__PURE__ */ new Map() });
+					node = node.children.get(segment);
+					const nextSegment = segments[i + 1];
+					if (i + 1 < segments.length && nextSegment === keyParamName) {
+						node.kind = kindName;
+						node.isCollection = true;
+					}
+					if (isLastSegment) {
+						node.kind = kindName;
+						node.isCollection = false;
+					}
+				}
+			}
+		}
+		return root;
+	}
+	resolvePath(trie, path) {
+		const segments = path.split("/").filter((s) => s.length > 0);
+		const params = {};
+		let node = trie;
+		let lastMatch = null;
+		for (const segment of segments) {
+			if (node.children.has(segment)) node = node.children.get(segment);
+			else if (node.param) {
+				params[node.param.paramName] = segment;
+				node = node.param;
+			} else return lastMatch;
+			if (node.kind) lastMatch = {
+				kind: node.kind,
+				params: { ...params },
+				isCollection: node.isCollection ?? false
+			};
+		}
+		return lastMatch;
+	}
+};
+
+//#endregion
+//#region src/compute/types.ts
+var ParseError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ParseError";
+	}
+};
+var ExprEvalError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ExprEvalError";
+	}
+};
+
+//#endregion
+//#region src/compute/evaluator.ts
+const MAX_DEPTH = 64;
+const BUILTINS = {
+	concat: (args) => args.map((a) => a == null ? "" : String(a)).join(""),
+	len: ([val]) => {
+		if (typeof val === "string") return val.length;
+		if (Array.isArray(val)) return val.length;
+		throw new ExprEvalError("len() requires a string or array");
+	},
+	upper: ([val]) => {
+		if (typeof val !== "string") throw new ExprEvalError("upper() requires a string");
+		return val.toUpperCase();
+	},
+	lower: ([val]) => {
+		if (typeof val !== "string") throw new ExprEvalError("lower() requires a string");
+		return val.toLowerCase();
+	},
+	trim: ([val]) => {
+		if (typeof val !== "string") throw new ExprEvalError("trim() requires a string");
+		return val.trim();
+	},
+	round: ([val]) => {
+		if (typeof val !== "number") throw new ExprEvalError("round() requires a number");
+		return Math.round(val);
+	},
+	floor: ([val]) => {
+		if (typeof val !== "number") throw new ExprEvalError("floor() requires a number");
+		return Math.floor(val);
+	},
+	ceil: ([val]) => {
+		if (typeof val !== "number") throw new ExprEvalError("ceil() requires a number");
+		return Math.ceil(val);
+	},
+	abs: ([val]) => {
+		if (typeof val !== "number") throw new ExprEvalError("abs() requires a number");
+		return Math.abs(val);
+	},
+	min: (args) => {
+		const nums = args.filter((a) => typeof a === "number");
+		if (nums.length === 0) throw new ExprEvalError("min() requires at least one number");
+		return Math.min(...nums);
+	},
+	max: (args) => {
+		const nums = args.filter((a) => typeof a === "number");
+		if (nums.length === 0) throw new ExprEvalError("max() requires at least one number");
+		return Math.max(...nums);
+	},
+	matches: ([val, pattern]) => {
+		if (typeof val !== "string" || typeof pattern !== "string") throw new ExprEvalError("matches() requires two strings");
+		return new RegExp(pattern).test(val);
+	},
+	hours_between: ([start, end]) => {
+		const s = start instanceof Date ? start.getTime() : typeof start === "string" ? new Date(start).getTime() : NaN;
+		const e = end instanceof Date ? end.getTime() : typeof end === "string" ? new Date(end).getTime() : NaN;
+		if (Number.isNaN(s) || Number.isNaN(e)) throw new ExprEvalError("hours_between() requires valid dates");
+		return Math.floor((e - s) / (1e3 * 60 * 60));
+	},
+	merge: (args) => {
+		const result = {};
+		for (const arg of args) {
+			if (arg == null || typeof arg !== "object" || Array.isArray(arg)) throw new ExprEvalError("merge() requires plain objects");
+			Object.assign(result, arg);
+		}
+		return result;
+	},
+	pick: (args) => {
+		const [obj, ...fields] = args;
+		if (obj == null || typeof obj !== "object" || Array.isArray(obj)) throw new ExprEvalError("pick() requires a plain object as first argument");
+		const result = {};
+		for (const f of fields) {
+			const key = String(f);
+			if (key in obj) result[key] = obj[key];
+		}
+		return result;
+	},
+	omit: (args) => {
+		const [obj, ...fields] = args;
+		if (obj == null || typeof obj !== "object" || Array.isArray(obj)) throw new ExprEvalError("omit() requires a plain object as first argument");
+		const omitSet = new Set(fields.map(String));
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) if (!omitSet.has(key)) result[key] = value;
+		return result;
+	},
+	flatten: ([obj]) => {
+		if (obj == null || typeof obj !== "object" || Array.isArray(obj)) throw new ExprEvalError("flatten() requires a plain object");
+		const result = {};
+		for (const value of Object.values(obj)) if (value != null && typeof value === "object" && !Array.isArray(value)) Object.assign(result, value);
+		return result;
+	}
+};
+function resolveField$1(data, path) {
+	if (path.length === 1 && path[0] === "*") return data;
+	let current = data;
+	for (const key of path) {
+		if (current == null || typeof current !== "object") return null;
+		current = current[key];
+	}
+	return current ?? null;
+}
+/**
+* Evaluate an AST node against a context.
+* Pure synchronous — no async, no IO.
+*/
+function evaluateExpression(node, ctx, depth = 0) {
+	if (depth > MAX_DEPTH) throw new ExprEvalError(`Maximum expression depth (${MAX_DEPTH}) exceeded`);
+	switch (node.type) {
+		case "NumberLiteral": return node.value;
+		case "StringLiteral": return node.value;
+		case "BooleanLiteral": return node.value;
+		case "NullLiteral": return null;
+		case "FieldRef": return resolveField$1(ctx.data, node.path);
+		case "ParamRef": return ctx.params?.[node.name] ?? null;
+		case "UnaryOp": {
+			const operand = evaluateExpression(node.operand, ctx, depth + 1);
+			if (node.operator === "-") {
+				if (typeof operand !== "number") throw new ExprEvalError("Unary minus requires a number");
+				return -operand;
+			}
+			if (node.operator === "!") return !operand;
+			throw new ExprEvalError(`Unknown unary operator: ${node.operator}`);
+		}
+		case "BinaryOp": return evaluateBinaryOp(node.operator, node.left, node.right, ctx, depth);
+		case "FunctionCall": return evaluateFunctionCall(node.name, node.args, ctx, depth);
+	}
+}
+function evaluateBinaryOp(op, leftNode, rightNode, ctx, depth) {
+	if (op === "&&") {
+		const left$1 = evaluateExpression(leftNode, ctx, depth + 1);
+		if (!left$1) return left$1;
+		return evaluateExpression(rightNode, ctx, depth + 1);
+	}
+	if (op === "||") {
+		const left$1 = evaluateExpression(leftNode, ctx, depth + 1);
+		if (left$1) return left$1;
+		return evaluateExpression(rightNode, ctx, depth + 1);
+	}
+	const left = evaluateExpression(leftNode, ctx, depth + 1);
+	const right = evaluateExpression(rightNode, ctx, depth + 1);
+	if (op === "+") {
+		if (typeof left === "string" || typeof right === "string") return String(left ?? "") + String(right ?? "");
+		if (typeof left === "number" && typeof right === "number") return left + right;
+		throw new ExprEvalError(`Cannot apply '+' to ${typeof left} and ${typeof right}`);
+	}
+	if (op === "-") {
+		if (typeof left !== "number" || typeof right !== "number") throw new ExprEvalError(`Cannot apply '-' to ${typeof left} and ${typeof right}`);
+		return left - right;
+	}
+	if (op === "*") {
+		if (typeof left !== "number" || typeof right !== "number") throw new ExprEvalError(`Cannot apply '*' to ${typeof left} and ${typeof right}`);
+		return left * right;
+	}
+	if (op === "/") {
+		if (typeof left !== "number" || typeof right !== "number") throw new ExprEvalError(`Cannot apply '/' to ${typeof left} and ${typeof right}`);
+		if (right === 0) throw new ExprEvalError("Division by zero");
+		return left / right;
+	}
+	if (op === "==") return left === right;
+	if (op === "!=") return left !== right;
+	if (op === "<") return left < right;
+	if (op === ">") return left > right;
+	if (op === "<=") return left <= right;
+	if (op === ">=") return left >= right;
+	throw new ExprEvalError(`Unknown operator: ${op}`);
+}
+function evaluateFunctionCall(name, argNodes, ctx, depth) {
+	if (name === "if") {
+		if (argNodes.length !== 3) throw new ExprEvalError("if() requires exactly 3 arguments");
+		return evaluateExpression(argNodes[0], ctx, depth + 1) ? evaluateExpression(argNodes[1], ctx, depth + 1) : evaluateExpression(argNodes[2], ctx, depth + 1);
+	}
+	const fn = BUILTINS[name];
+	if (!fn) throw new ExprEvalError(`Unknown function: ${name}`);
+	return fn(argNodes.map((a) => evaluateExpression(a, ctx, depth + 1)));
+}
+
+//#endregion
+//#region src/compute/parser.ts
+const MAX_EXPRESSION_LENGTH = 4096;
+const FORBIDDEN_FIELDS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function charAt(s, i) {
+	return s.charAt(i);
+}
+function tokenize(expr) {
+	const tokens = [];
+	let i = 0;
+	while (i < expr.length) {
+		const ch = charAt(expr, i);
+		if (/\s/.test(ch)) {
+			i++;
+			continue;
+		}
+		const pos = i;
+		if (ch === "\"") {
+			i++;
+			let s = "";
+			while (i < expr.length && charAt(expr, i) !== "\"") {
+				if (charAt(expr, i) === "\\" && i + 1 < expr.length) {
+					const next = charAt(expr, i + 1);
+					if (next === "\"") {
+						s += "\"";
+						i += 2;
+						continue;
+					}
+					if (next === "\\") {
+						s += "\\";
+						i += 2;
+						continue;
+					}
+					if (next === "n") {
+						s += "\n";
+						i += 2;
+						continue;
+					}
+					if (next === "t") {
+						s += "	";
+						i += 2;
+						continue;
+					}
+				}
+				s += charAt(expr, i);
+				i++;
+			}
+			if (i >= expr.length) throw new ParseError(`Unterminated string at position ${pos}`);
+			i++;
+			tokens.push({
+				type: "string",
+				value: s,
+				pos
+			});
+			continue;
+		}
+		if (ch === "$") {
+			if (i + 1 < expr.length && charAt(expr, i + 1) === ".") {
+				i += 2;
+				const parts = [];
+				if (i < expr.length && charAt(expr, i) === "*") {
+					parts.push("*");
+					i++;
+				} else {
+					let part = "";
+					while (i < expr.length && /[a-zA-Z0-9_]/.test(charAt(expr, i))) {
+						part += charAt(expr, i);
+						i++;
+					}
+					if (part.length === 0) throw new ParseError(`Expected field name after $. at position ${pos}`);
+					if (FORBIDDEN_FIELDS.has(part)) throw new ParseError(`Forbidden field name: ${part}`);
+					parts.push(part);
+				}
+				while (i < expr.length && charAt(expr, i) === "." && i + 1 < expr.length && /[a-zA-Z0-9_*]/.test(charAt(expr, i + 1))) {
+					i++;
+					if (charAt(expr, i) === "*") {
+						parts.push("*");
+						i++;
+					} else {
+						let part = "";
+						while (i < expr.length && /[a-zA-Z0-9_]/.test(charAt(expr, i))) {
+							part += charAt(expr, i);
+							i++;
+						}
+						if (FORBIDDEN_FIELDS.has(part)) throw new ParseError(`Forbidden field name: ${part}`);
+						parts.push(part);
+					}
+				}
+				tokens.push({
+					type: "field_ref",
+					value: parts.join("."),
+					pos
+				});
+				continue;
+			}
+			throw new ParseError(`Expected '.' after '$' at position ${pos}`);
+		}
+		if (ch === "@") {
+			i++;
+			let name = "";
+			while (i < expr.length && /[a-zA-Z0-9_]/.test(charAt(expr, i))) {
+				name += charAt(expr, i);
+				i++;
+			}
+			if (name.length === 0) throw new ParseError(`Expected parameter name after '@' at position ${pos}`);
+			tokens.push({
+				type: "param_ref",
+				value: name,
+				pos
+			});
+			continue;
+		}
+		if (/[0-9]/.test(ch)) {
+			let num = "";
+			while (i < expr.length && /[0-9.]/.test(charAt(expr, i))) {
+				num += charAt(expr, i);
+				i++;
+			}
+			tokens.push({
+				type: "number",
+				value: num,
+				pos
+			});
+			continue;
+		}
+		if (/[a-zA-Z_]/.test(ch)) {
+			let id = "";
+			while (i < expr.length && /[a-zA-Z0-9_]/.test(charAt(expr, i))) {
+				id += charAt(expr, i);
+				i++;
+			}
+			tokens.push({
+				type: "ident",
+				value: id,
+				pos
+			});
+			continue;
+		}
+		if (i + 1 < expr.length) {
+			const two = charAt(expr, i) + charAt(expr, i + 1);
+			if ([
+				"==",
+				"!=",
+				"<=",
+				">=",
+				"&&",
+				"||"
+			].includes(two)) {
+				tokens.push({
+					type: "op",
+					value: two,
+					pos
+				});
+				i += 2;
+				continue;
+			}
+		}
+		if ("+-*/<>".includes(ch)) {
+			tokens.push({
+				type: "op",
+				value: ch,
+				pos
+			});
+			i++;
+			continue;
+		}
+		if (ch === "(") {
+			tokens.push({
+				type: "lparen",
+				value: "(",
+				pos
+			});
+			i++;
+			continue;
+		}
+		if (ch === ")") {
+			tokens.push({
+				type: "rparen",
+				value: ")",
+				pos
+			});
+			i++;
+			continue;
+		}
+		if (ch === ",") {
+			tokens.push({
+				type: "comma",
+				value: ",",
+				pos
+			});
+			i++;
+			continue;
+		}
+		if (ch === "!") {
+			tokens.push({
+				type: "bang",
+				value: "!",
+				pos
+			});
+			i++;
+			continue;
+		}
+		throw new ParseError(`Unexpected character '${ch}' at position ${i}`);
+	}
+	tokens.push({
+		type: "eof",
+		value: "",
+		pos: i
+	});
+	return tokens;
+}
+const EOF_TOKEN = {
+	type: "eof",
+	value: "",
+	pos: -1
+};
+var Parser = class {
+	tokens;
+	pos;
+	constructor(tokens) {
+		this.tokens = tokens;
+		this.pos = 0;
+	}
+	peek() {
+		return this.tokens[this.pos] ?? EOF_TOKEN;
+	}
+	advance() {
+		const t = this.tokens[this.pos] ?? EOF_TOKEN;
+		this.pos++;
+		return t;
+	}
+	expect(type, value) {
+		const t = this.peek();
+		if (t.type !== type || value !== void 0 && t.value !== value) throw new ParseError(`Expected ${type}${value ? ` '${value}'` : ""} but got ${t.type} '${t.value}' at position ${t.pos}`);
+		return this.advance();
+	}
+	parse() {
+		const node = this.parseOr();
+		if (this.peek().type !== "eof") throw new ParseError(`Unexpected token '${this.peek().value}' at position ${this.peek().pos}`);
+		return node;
+	}
+	parseOr() {
+		let left = this.parseAnd();
+		while (this.peek().type === "op" && this.peek().value === "||") {
+			const op = this.advance().value;
+			const right = this.parseAnd();
+			left = {
+				type: "BinaryOp",
+				operator: op,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseAnd() {
+		let left = this.parseComparison();
+		while (this.peek().type === "op" && this.peek().value === "&&") {
+			const op = this.advance().value;
+			const right = this.parseComparison();
+			left = {
+				type: "BinaryOp",
+				operator: op,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseComparison() {
+		let left = this.parseAddSub();
+		while (this.peek().type === "op" && [
+			"==",
+			"!=",
+			"<",
+			">",
+			"<=",
+			">="
+		].includes(this.peek().value)) {
+			const op = this.advance().value;
+			const right = this.parseAddSub();
+			left = {
+				type: "BinaryOp",
+				operator: op,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseAddSub() {
+		let left = this.parseMulDiv();
+		while (this.peek().type === "op" && ["+", "-"].includes(this.peek().value)) {
+			const op = this.advance().value;
+			const right = this.parseMulDiv();
+			left = {
+				type: "BinaryOp",
+				operator: op,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseMulDiv() {
+		let left = this.parseUnary();
+		while (this.peek().type === "op" && ["*", "/"].includes(this.peek().value)) {
+			const op = this.advance().value;
+			const right = this.parseUnary();
+			left = {
+				type: "BinaryOp",
+				operator: op,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseUnary() {
+		if (this.peek().type === "op" && this.peek().value === "-") {
+			this.advance();
+			return {
+				type: "UnaryOp",
+				operator: "-",
+				operand: this.parseUnary()
+			};
+		}
+		if (this.peek().type === "bang") {
+			this.advance();
+			return {
+				type: "UnaryOp",
+				operator: "!",
+				operand: this.parseUnary()
+			};
+		}
+		return this.parsePrimary();
+	}
+	parsePrimary() {
+		const t = this.peek();
+		if (t.type === "number") {
+			this.advance();
+			return {
+				type: "NumberLiteral",
+				value: Number(t.value)
+			};
+		}
+		if (t.type === "string") {
+			this.advance();
+			return {
+				type: "StringLiteral",
+				value: t.value
+			};
+		}
+		if (t.type === "field_ref") {
+			this.advance();
+			return {
+				type: "FieldRef",
+				path: t.value.split(".")
+			};
+		}
+		if (t.type === "param_ref") {
+			this.advance();
+			return {
+				type: "ParamRef",
+				name: t.value
+			};
+		}
+		if (t.type === "ident") {
+			this.advance();
+			if (t.value === "true") return {
+				type: "BooleanLiteral",
+				value: true
+			};
+			if (t.value === "false") return {
+				type: "BooleanLiteral",
+				value: false
+			};
+			if (t.value === "null") return { type: "NullLiteral" };
+			if (this.peek().type === "lparen") {
+				this.advance();
+				const args = [];
+				if (this.peek().type !== "rparen") {
+					args.push(this.parseOr());
+					while (this.peek().type === "comma") {
+						this.advance();
+						args.push(this.parseOr());
+					}
+				}
+				this.expect("rparen");
+				return {
+					type: "FunctionCall",
+					name: t.value,
+					args
+				};
+			}
+			throw new ParseError(`Unexpected identifier '${t.value}' at position ${t.pos}`);
+		}
+		if (t.type === "lparen") {
+			this.advance();
+			const node = this.parseOr();
+			this.expect("rparen");
+			return node;
+		}
+		throw new ParseError(`Unexpected token '${t.value}' at position ${t.pos}`);
+	}
+};
+/**
+* Parse an expression string into an AST.
+*/
+function parseExpression(expr) {
+	if (!expr || expr.trim().length === 0) throw new ParseError("Empty expression");
+	if (expr.length > MAX_EXPRESSION_LENGTH) throw new ParseError(`Expression length ${expr.length} exceeds maximum ${MAX_EXPRESSION_LENGTH}`);
+	return new Parser(tokenize(expr.trim())).parse();
+}
+
+//#endregion
+//#region src/compute/template.ts
+/**
+* World Compute — Template Engine
+*
+* Simple {{ $.field }} interpolation for representation transforms.
+* Pure synchronous, no code execution.
+*/
+var TemplateError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "TemplateError";
+	}
+};
+function resolveField(data, path) {
+	let current = data;
+	for (const key of path) {
+		if (current == null || typeof current !== "object") return null;
+		current = current[key];
+	}
+	return current ?? null;
+}
+/**
+* Render a template string with {{ $.field }} interpolation.
+*
+* @param template - Template string with {{ $.field }} placeholders
+* @param data - Data object for field resolution
+* @returns Rendered string
+*/
+function renderTemplate(template, data) {
+	let result = "";
+	let i = 0;
+	while (i < template.length) if (template.charAt(i) === "{" && i + 1 < template.length && template.charAt(i + 1) === "{") {
+		const closeIdx = template.indexOf("}}", i + 2);
+		if (closeIdx === -1) throw new TemplateError("Template error: unclosed {{ interpolation");
+		const expr = template.substring(i + 2, closeIdx).trim();
+		if (expr.startsWith("$.")) {
+			const value = resolveField(data, expr.substring(2).split("."));
+			result += value == null ? "" : String(value);
+		} else result += expr;
+		i = closeIdx + 2;
+	} else {
+		result += template.charAt(i);
+		i++;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/core.ts
+var WorldMappingCore = class {
+	schema;
+	binding;
+	compiled;
+	constructor(schema, binding) {
+		this.schema = schema;
+		this.binding = binding;
+		this.compiled = new WorldCompiler().compile(schema, binding);
+	}
+	/** Resolve a target world path to kind + params + isCollection */
+	resolve(path) {
+		return this.compiled.resolve(path);
+	}
+	/** Translate a TrieMatch to a source AFS path */
+	translatePath(match) {
+		const source = this.compiled.kinds[match.kind]?.source ?? this.binding.source;
+		const kindMapping = this.binding.mappings?.[match.kind];
+		let pathTemplate;
+		if (kindMapping?.path) pathTemplate = kindMapping.path;
+		else pathTemplate = this.schema.kinds[match.kind]?.path ?? "";
+		let resolved = pathTemplate;
+		for (const [key, value] of Object.entries(match.params)) resolved = resolved.replace(`{${key}}`, value);
+		if (match.isCollection) resolved = resolved.replace(/\/\{[^}]+\}$/, "");
+		return (source + resolved).replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+	}
+	/** Project source fields → world fields (read direction) */
+	projectFields(data, kindName, params) {
+		const fieldMap = this.compiled.kinds[kindName]?.fieldMap;
+		let result;
+		if (!fieldMap || Object.keys(fieldMap).length === 0) result = { ...data };
+		else {
+			const reverseMap = {};
+			for (const [worldField, sourceField] of Object.entries(fieldMap)) reverseMap[sourceField] = worldField;
+			result = {};
+			for (const [key, value] of Object.entries(data)) if (reverseMap[key]) result[reverseMap[key]] = value;
+			else result[key] = value;
+		}
+		const kindDef = this.schema.kinds[kindName];
+		if (kindDef?.computed) for (const [fieldName, def] of Object.entries(kindDef.computed)) try {
+			const ast = this.getCompiledExpr(kindName, fieldName, def.expr);
+			result[fieldName] = evaluateExpression(ast, {
+				data: result,
+				params
+			});
+		} catch {
+			result[fieldName] = null;
+		}
+		return result;
+	}
+	/** Cache for parsed expressions */
+	exprCache = /* @__PURE__ */ new Map();
+	getCompiledExpr(kindName, fieldName, expr) {
+		const key = `${kindName}.${fieldName}`;
+		let ast = this.exprCache.get(key);
+		if (!ast) {
+			ast = parseExpression(expr);
+			this.exprCache.set(key, ast);
+		}
+		return ast;
+	}
+	/** Reverse project world fields → source fields (write direction) */
+	reverseProjectFields(data, kindName) {
+		const fieldMap = this.compiled.kinds[kindName]?.fieldMap;
+		const computedFields = this.schema.kinds[kindName]?.computed;
+		const result = {};
+		for (const [key, value] of Object.entries(data)) {
+			if (computedFields && key in computedFields) continue;
+			if (fieldMap?.[key]) result[fieldMap[key]] = value;
+			else result[key] = value;
+		}
+		return result;
+	}
+	/** Get kind metadata */
+	getKind(name) {
+		return this.compiled.kinds[name];
+	}
+	/** List all kind names */
+	getKindNames() {
+		return Object.keys(this.compiled.kinds);
+	}
+	/** Validate data against kind's validation rules */
+	validate(data, kindName) {
+		const kindDef = this.schema.kinds[kindName];
+		if (!kindDef?.validate || kindDef.validate.length === 0) return {
+			valid: true,
+			errors: []
+		};
+		const errors = [];
+		for (const rule of kindDef.validate) try {
+			if (!evaluateExpression(this.getCompiledExpr(kindName, `__validate_${rule.expr}`, rule.expr), { data })) errors.push({
+				expr: rule.expr,
+				error: rule.error
+			});
+		} catch {
+			errors.push({
+				expr: rule.expr,
+				error: rule.error
+			});
+		}
+		return {
+			valid: errors.length === 0,
+			errors
+		};
+	}
+	/** Render a representation of data for a kind in the given format */
+	getRepresentation(data, kindName, format) {
+		const kindDef = this.schema.kinds[kindName];
+		if (!kindDef?.represent) return null;
+		const repr = kindDef.represent[format];
+		if (!repr) return null;
+		return renderTemplate(repr.template, data);
+	}
+};
+
+//#endregion
+//#region src/module.ts
+var WorldMappingModule = class {
+	name;
+	description;
+	core;
+	source;
+	constructor(options) {
+		this.core = new WorldMappingCore(options.schema, options.binding);
+		this.source = options.source;
+		this.name = `world-${options.schema.world}`;
+		this.description = `World mapping for ${options.schema.world}`;
+	}
+	/** List entries at a world path */
+	async list(path) {
+		const match = this.core.resolve(path);
+		if (!match) return { list: [] };
+		const sourcePath = this.core.translatePath(match);
+		const result = await this.source.list(sourcePath);
+		if (result.list && match.kind) result.list = result.list.map((entry) => {
+			if (entry && typeof entry === "object" && "content" in entry) return {
+				...entry,
+				content: this.core.projectFields(entry.content, match.kind)
+			};
+			return entry;
+		});
+		return result;
+	}
+	/** Read a single entry at a world path */
+	async read(path) {
+		const match = this.core.resolve(path);
+		if (!match) return;
+		const sourcePath = this.core.translatePath(match);
+		const result = await this.source.read(sourcePath);
+		if (result && typeof result === "object" && "content" in result) {
+			const entry = result;
+			return {
+				...entry,
+				content: this.core.projectFields(entry.content, match.kind)
+			};
+		}
+		return result;
+	}
+	/** Write an entry at a world path */
+	async write(path, content) {
+		if (!this.source.write) throw new Error("Source AFS does not support write operations");
+		const match = this.core.resolve(path);
+		if (!match) throw new Error(`Cannot resolve world path: ${path}`);
+		const sourcePath = this.core.translatePath(match);
+		const sourceContent = this.core.reverseProjectFields(content, match.kind);
+		return this.source.write(sourcePath, sourceContent);
+	}
+	/** Delete an entry at a world path */
+	async delete(path) {
+		if (!this.source.delete) throw new Error("Source AFS does not support delete operations");
+		const match = this.core.resolve(path);
+		if (!match) throw new Error(`Cannot resolve world path: ${path}`);
+		const sourcePath = this.core.translatePath(match);
+		return this.source.delete(sourcePath);
+	}
+	/** Get kind names */
+	getKindNames() {
+		return this.core.getKindNames();
+	}
+};
+
+//#endregion
+//#region src/with-world-mapping.ts
+/** Type guard: check if an object supports world mapping injection */
+function isWithWorldMapping(obj) {
+	if (!obj || typeof obj !== "object") return false;
+	const o = obj;
+	return typeof o.applyWorldMapping === "function" && typeof o.getWorldMapping === "function";
+}
+/**
+* Helper for providers implementing WithWorldMapping.
+* Validates config, creates WorldMappingCore, returns the mapping state.
+* Throws if already applied or config is invalid.
+*/
+function applyWorldMappingHelper(config, existing) {
+	if (existing) throw new Error("World mapping already applied. Each provider supports single injection only.");
+	const core = new WorldMappingCore(config.schema, config.binding);
+	return {
+		core,
+		status: {
+			schema: config.schema,
+			binding: config.binding,
+			kinds: core.getKindNames(),
+			appliedAt: /* @__PURE__ */ new Date()
+		}
+	};
+}
+
+//#endregion
+export { WorldCompiler, WorldMappingCore, WorldMappingModule, applyWorldMappingHelper, isWithWorldMapping, isWorldMappingCapable };
+//# sourceMappingURL=index.mjs.map