halfcode-compiler.xnl 0.1.1

package/dist/src-COEMEqZw.js

@@ -0,0 +1,431 @@
+import { n as wordToString, t as parseXnl } from "./dist-Bkv7YeVi.js";
+import { readFile, readdir, realpath, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+//#region ../resource-core/src/xnl-loader.ts
+async function buildXnlResourceTree(options) {
+	const context = {
+		rootDir: resolve(options.rootDir),
+		diagnostics: [],
+		kindDefinitions: /* @__PURE__ */ new Map(),
+		resources: [],
+		seenIdentities: /* @__PURE__ */ new Map()
+	};
+	const manifest = await loadManifest(resolve(context.rootDir, options.manifestPath), "manifest", context, true);
+	if (!manifest || context.diagnostics.length > 0) return { diagnostics: context.diagnostics };
+	const byKind = /* @__PURE__ */ new Map();
+	for (const resource of context.resources) {
+		const records = byKind.get(resource.kind) ?? [];
+		records.push(resource);
+		byKind.set(resource.kind, records);
+	}
+	return {
+		diagnostics: [],
+		tree: {
+			manifest,
+			registry: { byKind },
+			diagnostics: []
+		}
+	};
+}
+async function loadManifest(filePath, sourceShape, context, isRoot) {
+	const record = await loadXnlRecord(filePath, sourceShape, context);
+	if (!record) return void 0;
+	if (isRoot && record.kind !== "ResourcePackage") {
+		context.diagnostics.push({
+			code: "RESOURCE_XNL_ROOT_INVALID",
+			location: record.documentUri,
+			message: "The root manifest.xnl must contain one ResourcePackage root."
+		});
+		return;
+	}
+	const catalogs = readCatalogs(record, context.diagnostics);
+	for (const catalog of catalogs.filter((item) => item.kind === "KindDefinition")) await loadKindDefinitions(catalog, dirname(filePath), context);
+	for (const catalog of catalogs.filter((item) => item.kind !== "KindDefinition")) await loadCatalog(catalog, dirname(filePath), context);
+	if (!isRoot) {
+		validateIdentity(record, context);
+		context.resources.push(record);
+	}
+	return record;
+}
+async function loadKindDefinitions(catalog, manifestDir, context) {
+	const files = await catalogFiles(catalog, manifestDir, context);
+	for (const file of files) {
+		const record = await loadXnlRecord(file, catalog.shape, context);
+		if (!record) continue;
+		if (record.kind !== "KindDefinition") {
+			context.diagnostics.push(kindMismatch(record.kind, "KindDefinition", record.documentUri));
+			continue;
+		}
+		const definition = normalizeKindDefinition(record, context.diagnostics);
+		if (!definition) continue;
+		context.kindDefinitions.set(definition.resourceKind, definition);
+	}
+}
+async function loadCatalog(catalog, manifestDir, context) {
+	const definition = context.kindDefinitions.get(catalog.kind);
+	if (!definition) {
+		context.diagnostics.push({
+			code: "KIND_DEFINITION_MISSING",
+			location: catalog.location,
+			message: `No KindDefinition is registered for catalog kind '${catalog.kind}'.`
+		});
+		return;
+	}
+	if (!definition.sourceShapes.includes(catalog.shape)) {
+		context.diagnostics.push({
+			code: "RESOURCE_SOURCE_SHAPE_NOT_ALLOWED",
+			location: catalog.location,
+			message: `Kind '${catalog.kind}' does not allow source shape '${catalog.shape}'.`
+		});
+		return;
+	}
+	const files = await catalogFiles(catalog, manifestDir, context);
+	for (const file of files) {
+		if (catalog.shape === "manifest") {
+			const record = await loadXnlRecord(file, "manifest", context);
+			if (!record) continue;
+			if (record.kind !== catalog.kind) {
+				context.diagnostics.push(kindMismatch(record.kind, catalog.kind, record.documentUri));
+				continue;
+			}
+			await validateRequiredFiles(dirname(file), record, definition, context.diagnostics);
+			validateIdentity(record, context);
+			context.resources.push(record);
+			const catalogs = readCatalogs(record, context.diagnostics);
+			for (const nested of catalogs.filter((item) => item.kind !== "KindDefinition")) await loadCatalog(nested, dirname(file), context);
+			continue;
+		}
+		const record = await loadXnlRecord(file, catalog.shape, context);
+		if (!record) continue;
+		if (record.kind !== catalog.kind) {
+			context.diagnostics.push(kindMismatch(record.kind, catalog.kind, record.documentUri));
+			continue;
+		}
+		await validateRequiredFiles(dirname(file), record, definition, context.diagnostics);
+		validateIdentity(record, context);
+		context.resources.push(record);
+	}
+}
+async function catalogFiles(catalog, manifestDir, context) {
+	const root = await resolveCatalogDirectory(catalog.root, manifestDir, catalog.location, context);
+	if (!root) return [];
+	const entries = await readdir(root, { withFileTypes: true }).catch(() => void 0);
+	if (!entries) {
+		context.diagnostics.push({
+			code: "RESOURCE_CATALOG_ROOT_MISSING",
+			location: catalog.location,
+			message: "Catalog root does not exist or is not readable."
+		});
+		return [];
+	}
+	if (catalog.shape === "single-file") return entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".xnl")).sort((left, right) => left.name.localeCompare(right.name)).map((entry) => join(root, entry.name));
+	if (!catalog.entry || !isPlainEntry(catalog.entry)) {
+		context.diagnostics.push({
+			code: "RESOURCE_CATALOG_ENTRY_INVALID",
+			location: catalog.location,
+			message: "Directory and manifest catalogs require a plain XNL entry filename."
+		});
+		return [];
+	}
+	return entries.filter((entry) => entry.isDirectory()).sort((left, right) => left.name.localeCompare(right.name)).map((entry) => join(root, entry.name, catalog.entry));
+}
+async function loadXnlRecord(filePath, sourceShape, context) {
+	const documentUri = documentUriFor(context.rootDir, filePath);
+	const source = await readFile(filePath, "utf8").catch(() => void 0);
+	if (source === void 0) {
+		context.diagnostics.push({
+			code: "RESOURCE_FILE_MISSING",
+			location: documentUri,
+			message: "Resource file does not exist."
+		});
+		return;
+	}
+	let root;
+	try {
+		const parsed = parseXnl(source, { textBlockStyle: true });
+		if (parsed.warnings?.length) {
+			context.diagnostics.push({
+				code: "RESOURCE_XNL_WARNING",
+				location: documentUri,
+				message: parsed.warnings.map((warning) => warning.message).join("; ")
+			});
+			return;
+		}
+		if (parsed.nodes.length !== 1 || !isDataElement(parsed.nodes[0])) {
+			context.diagnostics.push({
+				code: "RESOURCE_XNL_ROOT_INVALID",
+				location: documentUri,
+				message: "XNL resource documents must contain exactly one data-element root."
+			});
+			return;
+		}
+		root = parsed.nodes[0];
+	} catch (error) {
+		context.diagnostics.push({
+			code: "RESOURCE_XNL_SYNTAX",
+			location: documentUri,
+			message: `Invalid XNL resource document: ${error instanceof Error ? error.message : String(error)}`
+		});
+		return;
+	}
+	const node = normalizeNode(root);
+	const resourceId = node.resourceId;
+	const apiVersion = asString(node.metadata.apiVersion);
+	const lifecycle = asString(node.properties.lifecycle);
+	const description = asString(node.properties.description) ?? node.subdomains.Description?.text;
+	if (!resourceId) context.diagnostics.push({
+		code: "RESOURCE_IDENTITY_MISSING",
+		location: documentUri,
+		message: "XNL resource roots must declare a #id."
+	});
+	if (!apiVersion) context.diagnostics.push({
+		code: "RESOURCE_METADATA_FIELD_MISSING",
+		location: documentUri,
+		message: "XNL resources require metadata apiVersion."
+	});
+	if (!resourceId || !apiVersion) return void 0;
+	const metadata = {
+		apiVersion,
+		...lifecycle ? { lifecycle } : {},
+		version: asString(node.metadata.version)
+	};
+	const logicalPath = relative(context.rootDir, filePath).split(sep).join("/");
+	return {
+		kind: node.tag,
+		resourceId,
+		fqn: resourceId,
+		...description ? { description } : {},
+		metadata,
+		sourceShape,
+		logicalPath,
+		documentUri,
+		format: "xnl",
+		node
+	};
+}
+function normalizeNode(node) {
+	const subdomains = {};
+	if (node.kind === "DataElement" && node.extend) for (const name of node.extend.order) {
+		const child = node.extend.children[name];
+		if (child) subdomains[name] = normalizeNode(child);
+	}
+	return Object.freeze({
+		tag: node.tag,
+		resourceId: wordToString(node.id),
+		metadata: Object.freeze(normalizeMap(node.metadata)),
+		properties: Object.freeze(normalizeMap(node.attributes)),
+		body: Object.freeze(node.kind === "DataElement" ? (node.body ?? []).map(normalizeValue) : []),
+		subdomains: Object.freeze(subdomains),
+		...node.kind === "TextElement" ? { text: node.text ?? "" } : {}
+	});
+}
+function normalizeMap(map) {
+	return Object.fromEntries(Object.entries(map ?? {}).map(([key, value]) => [key, normalizeValue(value)]));
+}
+function normalizeValue(value) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) return Object.freeze(value.map(normalizeValue));
+	if (isElement(value)) return normalizeNode(value);
+	if (isWord(value)) return wordToString(value) ?? "";
+	if (isComment(value)) return value.value;
+	return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, child]) => [key, normalizeValue(child)])));
+}
+function readCatalogs(record, diagnostics) {
+	const catalogs = record.node.subdomains.Catalogs;
+	if (!catalogs) return [];
+	const out = [];
+	for (const value of catalogs.body) {
+		if (!isResourceNode(value) || value.tag !== "Catalog") continue;
+		const id = value.resourceId;
+		const kind = asString(value.properties.kind);
+		const root = asString(value.properties.root);
+		const entry = asString(value.properties.entry);
+		const shapeValue = asString(value.properties.shape) ?? (entry ? "directory" : "single-file");
+		const location = `${record.documentUri}#Catalog:${id ?? "unknown"}`;
+		if (!id || !kind || !root || !isXnlShape(shapeValue)) {
+			diagnostics.push({
+				code: "RESOURCE_CATALOG_INVALID",
+				location,
+				message: "Catalog requires #id, kind, root and a valid shape."
+			});
+			continue;
+		}
+		out.push({
+			id,
+			kind,
+			root,
+			entry,
+			shape: shapeValue,
+			location
+		});
+	}
+	return out;
+}
+function normalizeKindDefinition(record, diagnostics) {
+	const resourceKind = asString(record.node.properties.resourceKind) ?? record.resourceId.split(".").at(-1);
+	const shapes = record.node.properties.sourceShapes;
+	const sourceShapes = Array.isArray(shapes) ? shapes.filter(isXnlShape) : [];
+	if (!resourceKind || sourceShapes.length === 0) {
+		diagnostics.push({
+			code: "KIND_DEFINITION_INVALID",
+			location: record.documentUri,
+			message: "KindDefinition requires resourceKind (or an id suffix) and sourceShapes."
+		});
+		return;
+	}
+	return {
+		resourceKind,
+		sourceShapes,
+		requiredFiles: ((record.node.subdomains.DescriptorContract?.subdomains.RequiredFiles)?.body ?? []).filter(isResourceNode).filter((node) => node.tag === "File").map((node) => asString(node.properties.name)).filter((value) => Boolean(value))
+	};
+}
+async function validateRequiredFiles(resourceDir, record, definition, diagnostics) {
+	for (const name of definition.requiredFiles) {
+		if (!isPlainEntry(name)) {
+			diagnostics.push({
+				code: "KIND_DEFINITION_REQUIRED_FILE_INVALID",
+				location: record.documentUri,
+				message: `Invalid required file '${name}'.`
+			});
+			continue;
+		}
+		if (!await stat(join(resourceDir, name)).then((info) => info.isFile()).catch(() => false)) diagnostics.push({
+			code: "RESOURCE_REQUIRED_FILE_MISSING",
+			location: `${record.documentUri}#${name}`,
+			message: `Resource is missing required material '${name}'.`
+		});
+	}
+}
+async function resolveCatalogDirectory(uri, manifestDir, location, context) {
+	const relativeMatch = /^vfs:\/\/(\.\/|@\/)(.*)$/.exec(uri);
+	if (!relativeMatch || !uri.endsWith("/")) {
+		context.diagnostics.push({
+			code: "RESOURCE_REF_UNSUPPORTED",
+			location,
+			message: "Catalog roots must be directory vfs://./ or vfs://@/ references."
+		});
+		return;
+	}
+	const rawPath = relativeMatch[2];
+	let decoded;
+	try {
+		decoded = decodeURIComponent(rawPath);
+	} catch {
+		context.diagnostics.push({
+			code: "RESOURCE_REF_CONTAINMENT",
+			location,
+			message: "VFS reference contains invalid encoding."
+		});
+		return;
+	}
+	if (isAbsolute(decoded) || decoded.split(/[\\/]+/).includes("..") || /%2f|%5c/i.test(rawPath)) {
+		context.diagnostics.push({
+			code: "RESOURCE_REF_CONTAINMENT",
+			location,
+			message: "VFS reference escapes the owning package boundary."
+		});
+		return;
+	}
+	const base = relativeMatch[1] === "@/" ? context.rootDir : manifestDir;
+	const boundary = await realpath(context.rootDir);
+	const candidate = resolve(base, decoded);
+	const resolved = await realpath(candidate).catch(() => candidate);
+	if (resolved !== boundary && !resolved.startsWith(`${boundary}${sep}`)) {
+		context.diagnostics.push({
+			code: "RESOURCE_REF_CONTAINMENT",
+			location,
+			message: "VFS reference resolves outside the owning package boundary."
+		});
+		return;
+	}
+	return resolved;
+}
+function validateIdentity(record, context) {
+	const prior = context.seenIdentities.get(record.resourceId);
+	if (prior) {
+		context.diagnostics.push({
+			code: "RESOURCE_IDENTITY_DUPLICATE",
+			location: record.documentUri,
+			message: `Duplicate resource identity '${record.resourceId}'.`,
+			hint: `First seen at ${prior}.`
+		});
+		return;
+	}
+	context.seenIdentities.set(record.resourceId, record.documentUri);
+}
+function documentUriFor(rootDir, filePath) {
+	return `vfs://@/${relative(rootDir, filePath).split(sep).join("/")}`;
+}
+function kindMismatch(actual, expected, location) {
+	return {
+		code: "RESOURCE_KIND_MISMATCH",
+		location,
+		message: `Resource kind '${actual}' does not match catalog kind '${expected}'.`
+	};
+}
+function isXnlShape(value) {
+	return value === "single-file" || value === "directory" || value === "manifest";
+}
+function isPlainEntry(value) {
+	return Boolean(value) && !value.includes("/") && !value.includes("\\") && !value.includes("..");
+}
+function asString(value) {
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+function isResourceNode(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "tag" in value;
+}
+function isDataElement(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "kind" in value && value.kind === "DataElement";
+}
+function isElement(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "kind" in value && (value.kind === "DataElement" || value.kind === "TextElement");
+}
+function isWord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "kind" in value && value.kind === "Word";
+}
+function isComment(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "kind" in value && value.kind === "Comment";
+}
+//#endregion
+//#region ../resource-core/src/index.ts
+var ResourceValidationError = class extends Error {
+	diagnostics;
+	constructor(diagnostics) {
+		super(`Resource validation failed with ${diagnostics.length} diagnostic(s)`);
+		this.name = "ResourceValidationError";
+		this.diagnostics = diagnostics;
+	}
+};
+async function loadResourceTree(options) {
+	const unsupported = unsupportedAuthorityDiagnostic(options);
+	if (unsupported) throw new ResourceValidationError([unsupported]);
+	const manifestPath = options.manifestPath ?? "manifest.xnl";
+	const result = await buildXnlResourceTree({
+		...options,
+		rootDir: resolve(options.rootDir),
+		manifestPath
+	});
+	if (result.diagnostics.length > 0 || !result.tree) throw new ResourceValidationError(result.diagnostics);
+	return result.tree;
+}
+async function validateResourceTree(options) {
+	const unsupported = unsupportedAuthorityDiagnostic(options);
+	if (unsupported) return [unsupported];
+	const manifestPath = options.manifestPath ?? "manifest.xnl";
+	return (await buildXnlResourceTree({
+		...options,
+		rootDir: resolve(options.rootDir),
+		manifestPath
+	})).diagnostics;
+}
+function unsupportedAuthorityDiagnostic(options) {
+	const manifestPath = options.manifestPath ?? "manifest.xnl";
+	if (!manifestPath.toLowerCase().endsWith(".xnl")) return {
+		code: "RESOURCE_AUTHORITY_FORMAT_UNSUPPORTED",
+		location: `vfs://@/${manifestPath}`,
+		message: "Resource package manifests must use XNL authority."
+	};
+}
+//#endregion
+export { loadResourceTree as n, validateResourceTree as r, ResourceValidationError as t };