halfcode-compiler.xnl 0.2.0 → 0.2.2

package/dist/src-BlKlpg0J.js

@@ -1,180 +0,0 @@
-import { n as wordToString, t as parseXnl } from "./dist-Bkv7YeVi.js";
-import { copyFile, lstat, mkdir, readdir } from "node:fs/promises";
-import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
-//#region ../resource-mapping/src/index.ts
-function parseResourceMappings(source, uri = "vfs://./resource-mappings.xnl") {
-	let root;
-	try {
-		const document = parseXnl(source);
-		if (document.warnings?.length || document.nodes.length !== 1 || !isDataElement(document.nodes[0])) throw new Error("expected exactly one ResourceMappings data root without warnings");
-		root = document.nodes[0];
-	} catch (error) {
-		throw new Error(`Invalid ResourceMappings at ${uri}: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (root.tag !== "ResourceMappings") throw new Error(`Invalid ResourceMappings at ${uri}: root must be ResourceMappings`);
-	const referenceTargets = /* @__PURE__ */ new Map();
-	for (const entry of bodyElements(extension(root, "ReferenceTargets"), "ReferenceTarget")) {
-		const kind = requiredXnlProperty(entry, "kind", uri);
-		if (referenceTargets.has(kind)) throw new Error(`Invalid ResourceMappings at ${uri}: duplicate ReferenceTarget kind ${kind}`);
-		referenceTargets.set(kind, normalizeOutputDirectory(requiredXnlProperty(entry, "target", uri), uri));
-	}
-	const callable = extension(root, "CallableArtifacts");
-	const callableArtifactsTarget = normalizeOutputDirectory(callable ? requiredXnlProperty(callable, "target", uri) : "functions/", uri);
-	const sources = bodyElements(extension(root, "SourceRoots"), "SourceRoot").map((entry) => {
-		const id = wordToString(entry.id);
-		if (!id || !/^[A-Z][A-Za-z0-9]*$/.test(id)) throw new Error(`Invalid ResourceMappings at ${uri}: SourceRoot #id must be a PascalCase segment`);
-		const operations = (entry.body ?? []).filter(isDataElement).filter((operation) => operation.tag === "CopyDirectory" || operation.tag === "CopyFile").map((operation) => ({
-			kind: operation.tag,
-			from: normalizeRelativePath(requiredXnlProperty(operation, "from", uri), uri, "from"),
-			to: normalizeRelativePath(requiredXnlProperty(operation, "to", uri), uri, "to")
-		}));
-		return {
-			id,
-			sourceRoot: requiredXnlProperty(entry, "sourceRoot", uri),
-			operations
-		};
-	});
-	if (new Set(sources.map((item) => item.id)).size !== sources.length) throw new Error(`Invalid ResourceMappings at ${uri}: SourceRoot ids must be unique`);
-	return {
-		referenceTargets,
-		callableArtifactsTarget,
-		sources,
-		source: { uri }
-	};
-}
-function extension(node, name) {
-	const child = node.extend?.children[name];
-	return child?.kind === "DataElement" ? child : void 0;
-}
-function bodyElements(node, tag) {
-	return (node?.body ?? []).filter(isDataElement).filter((entry) => entry.tag === tag);
-}
-function requiredXnlProperty(node, name, uri) {
-	const value = node.attributes?.[name];
-	if (typeof value !== "string" || !value.trim()) throw new Error(`Invalid ResourceMappings at ${uri}: <${node.tag}> requires ${name}`);
-	return value;
-}
-function isDataElement(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && "kind" in value && value.kind === "DataElement";
-}
-async function planResourceMappings(mappings, options) {
-	const roots = asRootMap(options.moduleRoots);
-	const claims = [];
-	const entries = [];
-	const reserved = (options.reservedTargetPaths ?? []).map((path) => normalizeRelativePath(path, mappings.source.uri, "to"));
-	for (const mapping of mappings.sources) {
-		const sourceRootPath = resolveSourceRoot(mapping.sourceRoot, roots, options.defaultSourceRoot, mappings.source.uri);
-		await assertDirectory(sourceRootPath, mappings.source.uri, mapping.sourceRoot);
-		for (const operation of mapping.operations) {
-			for (const prior of claims) if (pathsOverlap(prior.target, operation.to)) throw new Error(`ResourceMappings target collision between ${prior.mappingId}:${prior.from} -> ${prior.target} and ${mapping.id}:${operation.from} -> ${operation.to}`);
-			claims.push({
-				target: operation.to,
-				mappingId: mapping.id,
-				from: operation.from
-			});
-			const sourcePath = safeResolve(sourceRootPath, operation.from, mappings.source.uri);
-			if (operation.kind === "CopyFile") {
-				await assertFile(sourcePath, mappings.source.uri, operation.from);
-				assertNotReserved(operation.to, reserved, mappings.source.uri);
-				entries.push({
-					sourcePath,
-					targetRelativePath: operation.to,
-					mappingId: mapping.id
-				});
-				continue;
-			}
-			await assertDirectory(sourcePath, mappings.source.uri, operation.from);
-			for (const filePath of await listFiles(sourcePath, mappings.source.uri)) {
-				const child = relative(sourcePath, filePath).split(sep).join("/");
-				const targetRelativePath = posix.join(operation.to, child);
-				assertNotReserved(targetRelativePath, reserved, mappings.source.uri);
-				entries.push({
-					sourcePath: filePath,
-					targetRelativePath,
-					mappingId: mapping.id
-				});
-			}
-		}
-	}
-	const seenTargets = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const prior = seenTargets.get(entry.targetRelativePath);
-		if (prior) throw new Error(`ResourceMappings duplicate target ${entry.targetRelativePath} from ${prior.sourcePath} and ${entry.sourcePath}`);
-		seenTargets.set(entry.targetRelativePath, entry);
-	}
-	return { entries: entries.sort((a, b) => a.targetRelativePath.localeCompare(b.targetRelativePath)) };
-}
-async function applyResourceMappingPlan(plan, outputRoot) {
-	const files = [];
-	for (const entry of plan.entries) {
-		const target = resolve(outputRoot, entry.targetRelativePath);
-		if (!isWithinRoot(resolve(outputRoot), target)) throw new Error(`ResourceMappings output escapes target root: ${entry.targetRelativePath}`);
-		await mkdir(dirname(target), { recursive: true });
-		await copyFile(entry.sourcePath, target);
-		files.push(entry.targetRelativePath);
-	}
-	return files;
-}
-function resolveSourceRoot(uri, roots, defaultSourceRoot, mappingUri) {
-	const moduleMatch = /^vfs:\/\/module\/([A-Z][A-Za-z0-9]*)\/(.*)$/.exec(uri);
-	if (moduleMatch) {
-		const base = roots.get(moduleMatch[1]);
-		if (!base) throw new Error(`Invalid ResourceMappings at ${mappingUri}: unknown module root ${moduleMatch[1]}`);
-		return safeResolve(resolve(base), moduleMatch[2], mappingUri);
-	}
-	const localMatch = /^vfs:\/\/@\/(.*)$/.exec(uri);
-	if (localMatch && defaultSourceRoot) return safeResolve(resolve(defaultSourceRoot), localMatch[1], mappingUri);
-	throw new Error(`Invalid ResourceMappings at ${mappingUri}: unsupported sourceRoot ${uri}`);
-}
-async function listFiles(root, uri) {
-	const files = [];
-	for (const entry of (await readdir(root, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
-		const path = join(root, entry.name);
-		if (entry.isSymbolicLink()) throw new Error(`Invalid ResourceMappings at ${uri}: symbolic links are not supported: ${path}`);
-		if (entry.isDirectory()) files.push(...await listFiles(path, uri));
-		else if (entry.isFile()) files.push(path);
-		else throw new Error(`Invalid ResourceMappings at ${uri}: unsupported source entry ${path}`);
-	}
-	return files;
-}
-async function assertDirectory(path, uri, label) {
-	const info = await lstat(path).catch(() => void 0);
-	if (!info || info.isSymbolicLink() || !info.isDirectory()) throw new Error(`Invalid ResourceMappings at ${uri}: directory source does not exist: ${label}`);
-}
-async function assertFile(path, uri, label) {
-	const info = await lstat(path).catch(() => void 0);
-	if (!info || info.isSymbolicLink() || !info.isFile()) throw new Error(`Invalid ResourceMappings at ${uri}: file source does not exist: ${label}`);
-}
-function safeResolve(root, path, uri) {
-	const target = resolve(root, path);
-	if (!isWithinRoot(root, target)) throw new Error(`Invalid ResourceMappings at ${uri}: path escapes source root: ${path}`);
-	return target;
-}
-function isWithinRoot(root, target) {
-	return target === root || target.startsWith(`${root}${sep}`);
-}
-function assertNotReserved(path, reserved, uri) {
-	for (const item of reserved) if (pathsOverlap(path, item)) throw new Error(`Invalid ResourceMappings at ${uri}: target ${path} conflicts with generated target ${item}`);
-}
-function pathsOverlap(left, right) {
-	return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
-}
-function normalizeRelativePath(value, uri, attribute) {
-	if (!value.trim() || value.includes("\\") || value.startsWith("/") || isAbsolute(value) || value.split("/").includes("..")) throw new Error(`Invalid ResourceMappings at ${uri}: ${attribute} must be a safe relative path: ${value}`);
-	const normalized = posix.normalize(value).replace(/^\.\//, "").replace(/\/$/, "");
-	if (!normalized || normalized === "." || normalized.startsWith("../")) throw new Error(`Invalid ResourceMappings at ${uri}: ${attribute} must identify a non-root path: ${value}`);
-	return normalized;
-}
-function normalizeOutputDirectory(value, uri) {
-	return `${normalizeRelativePath(value, uri, "to")}/`;
-}
-function asRootMap(value) {
-	return typeof value.get === "function" ? value : new Map(Object.entries(value));
-}
-const resourceMappingPackage = {
-	role: "framework",
-	area: "resource-mapping",
-	owns: "declarative multi-root resource copy planning and collision preflight"
-};
-//#endregion
-export { resourceMappingPackage as i, parseResourceMappings as n, planResourceMappings as r, applyResourceMappingPlan as t };

package/dist/src-xibObw5e.js

@@ -1,494 +0,0 @@
-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 requestedRoot = resolve(options.rootDir);
-	const context = {
-		rootDir: await realpath(requestedRoot).catch(() => requestedRoot),
-		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,
-				kindDefinitions: context.kindDefinitions
-			},
-			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;
-			}
-			validateResourceApiVersion(record, definition, context.diagnostics);
-			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;
-		}
-		if (definition.documentCardinality === "many" && catalog.shape !== "single-file") {
-			context.diagnostics.push({
-				code: "RESOURCE_DOCUMENT_CARDINALITY_UNSUPPORTED",
-				location: catalog.location,
-				message: `Kind '${catalog.kind}' allows multiple document roots only in a single-file catalog.`
-			});
-			continue;
-		}
-		const records = await loadXnlRecords(file, catalog.shape, context, definition.documentCardinality);
-		for (const record of records) {
-			if (record.kind !== catalog.kind) {
-				context.diagnostics.push(kindMismatch(record.kind, catalog.kind, record.documentUri));
-				continue;
-			}
-			validateResourceApiVersion(record, definition, context.diagnostics);
-			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) {
-	return (await loadXnlRecords(filePath, sourceShape, context, "one"))[0];
-}
-async function loadXnlRecords(filePath, sourceShape, context, documentCardinality) {
-	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 roots;
-	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 === 0 || parsed.nodes.some((node) => !isDataElement(node)) || documentCardinality === "one" && parsed.nodes.length !== 1) {
-			context.diagnostics.push({
-				code: "RESOURCE_XNL_ROOT_INVALID",
-				location: documentUri,
-				message: documentCardinality === "one" ? "XNL resource documents must contain exactly one data-element root." : "XNL resource forests must contain one or more data-element roots."
-			});
-			return [];
-		}
-		roots = parsed.nodes;
-	} catch (error) {
-		context.diagnostics.push({
-			code: "RESOURCE_XNL_SYNTAX",
-			location: documentUri,
-			message: `Invalid XNL resource document: ${error instanceof Error ? error.message : String(error)}`
-		});
-		return [];
-	}
-	return roots.flatMap((root) => {
-		const record = resourceRecordFromRoot(root, filePath, sourceShape, context);
-		return record ? [record] : [];
-	});
-}
-function resourceRecordFromRoot(root, filePath, sourceShape, context) {
-	const documentUri = documentUriFor(context.rootDir, filePath);
-	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) : [];
-	const currentApiVersion = asString(record.node.properties.currentApiVersion);
-	const versions = record.node.properties.supportedApiVersions;
-	const supportedApiVersions = Array.isArray(versions) ? versions.filter((value) => typeof value === "string" && Boolean(value.trim())) : [];
-	const cardinalityValue = asString(record.node.properties.documentCardinality) ?? "one";
-	if (!resourceKind || sourceShapes.length === 0 || !currentApiVersion || supportedApiVersions.length === 0 || !isDocumentCardinality(cardinalityValue)) {
-		diagnostics.push({
-			code: "KIND_DEFINITION_INVALID",
-			location: record.documentUri,
-			message: "KindDefinition requires resourceKind (or an id suffix), sourceShapes, currentApiVersion, and supportedApiVersions."
-		});
-		return;
-	}
-	if (!supportedApiVersions.includes(currentApiVersion)) {
-		diagnostics.push({
-			code: "KIND_DEFINITION_VERSION_INVALID",
-			location: record.documentUri,
-			message: `Kind '${resourceKind}' currentApiVersion '${currentApiVersion}' must be included in supportedApiVersions.`
-		});
-		return;
-	}
-	if (cardinalityValue === "many" && sourceShapes.some((shape) => shape !== "single-file")) {
-		diagnostics.push({
-			code: "KIND_DEFINITION_CARDINALITY_INVALID",
-			location: record.documentUri,
-			message: `Kind '${resourceKind}' documentCardinality 'many' requires only the single-file source shape.`
-		});
-		return;
-	}
-	const 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));
-	return {
-		resourceId: record.resourceId,
-		resourceKind,
-		sourceShapes: Object.freeze([...sourceShapes]),
-		requiredFiles: Object.freeze([...requiredFiles]),
-		currentApiVersion,
-		supportedApiVersions: Object.freeze([...new Set(supportedApiVersions)]),
-		documentCardinality: cardinalityValue,
-		documentUri: record.documentUri
-	};
-}
-function validateResourceApiVersion(record, definition, diagnostics) {
-	if (definition.supportedApiVersions.includes(record.metadata.apiVersion)) return;
-	diagnostics.push({
-		code: "RESOURCE_API_VERSION_UNSUPPORTED",
-		location: record.documentUri,
-		message: `Kind '${record.kind}' does not support apiVersion '${record.metadata.apiVersion}'.`,
-		hint: `Current apiVersion is '${definition.currentApiVersion}'.`
-	});
-}
-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 isDocumentCardinality(value) {
-	return value === "one" || value === "many";
-}
-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 };