halfcode-compiler.xnl 0.2.7 → 0.2.9

package/dist/{src-88_zDKZE.js → src-D3qSzGFn.js}

@@ -1,10 +1,8 @@
 import { n as wordToString, t as parseXnl } from "./dist-Bkv7YeVi.js";
-import { lstat, mkdtemp, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
-import { dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import { lstat, readFile, readdir, realpath, stat } from "node:fs/promises";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { parse } from "yaml";
 import { createHash } from "node:crypto";
-import { tmpdir } from "node:os";
-import { pathToFileURL } from "node:url";
 //#region ../resource-core/src/canonical.ts
 function compareCodeUnits(left, right) {
 	if (left < right) return -1;
@@ -75,17 +73,17 @@ function createResourceContentIdentity(input) {
 		strictCanonicalInput: false,
 		validateClaimedDigest: false
 	});
-	if (diagnostics.length > 0 || !identity) throw new ResourceCompositionError(stableDiagnostics$1(diagnostics));
+	if (diagnostics.length > 0 || !identity) throw new ResourceCompositionError(stableDiagnostics(diagnostics));
 	return identity;
 }
 function buildResourceDependencySnapshot(input) {
 	const diagnostics = [];
-	if (!isEffectiveRegistryAuthentic(input.registry) || input.registry.revision !== input.registry.compositionRevision) throw new ResourceCompositionError(Object.freeze([diagnostic$1("RESOURCE_EFFECTIVE_REGISTRY_UNTRUSTED", "effective-registry:revision", "Dependency snapshots require an authentic immutable registry returned by composeLayeredResourceRegistry().")]));
+	if (!isEffectiveRegistryAuthentic(input.registry) || input.registry.revision !== input.registry.compositionRevision) throw new ResourceCompositionError(Object.freeze([diagnostic("RESOURCE_EFFECTIVE_REGISTRY_UNTRUSTED", "effective-registry:revision", "Dependency snapshots require an authentic immutable registry returned by composeLayeredResourceRegistry().")]));
 	const roots = validateRoots(input.roots, input.registry, diagnostics);
 	const edges = validateEdges(input.edges, input.registry, diagnostics);
 	validateContentIdentityIndex(input.contentIdentities, diagnostics);
 	const validatedIdentities = validateEffectiveContentIdentities(input.registry, input.contentIdentities, diagnostics);
-	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics$1(diagnostics));
+	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics(diagnostics));
 	const registryRevision = digestCanonical({
 		compositionRevision: input.registry.compositionRevision,
 		resources: [...validatedIdentities.values()].sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId)).map((identity) => ({
@@ -109,7 +107,7 @@ function buildResourceDependencySnapshot(input) {
 		if (visiting.has(resourceId)) {
 			const cycleStart = path.indexOf(resourceId);
 			const cycle = [...path.slice(cycleStart), resourceId];
-			diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_CYCLE", dependencyLocation(resourceId), `Resource dependency cycle detected: ${cycle.join(" -> ")}.`));
+			diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_CYCLE", dependencyLocation(resourceId), `Resource dependency cycle detected: ${cycle.join(" -> ")}.`));
 			return;
 		}
 		if (visited.has(resourceId)) return;
@@ -125,7 +123,7 @@ function buildResourceDependencySnapshot(input) {
 		visited.add(resourceId);
 	};
 	for (const root of roots) visit(root);
-	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics$1(diagnostics));
+	if (diagnostics.length > 0) throw new ResourceCompositionError(stableDiagnostics(diagnostics));
 	const closure = Object.freeze([...reachable].sort(compareCodeUnits).map((resourceId) => {
 		const entry = input.registry.byId.get(resourceId);
 		const identity = validatedIdentities.get(resourceId);
@@ -163,19 +161,19 @@ function validateRoots(inputRoots, registry, diagnostics) {
 	for (const value of inputRoots) {
 		const resourceId = value.trim();
 		if (resourceId.length === 0) {
-			diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_ROOT_EMPTY", "dependency-root:unnamed", "Dependency snapshot roots must be non-empty resource ids."));
+			diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_ROOT_EMPTY", "dependency-root:unnamed", "Dependency snapshot roots must be non-empty resource ids."));
 			continue;
 		}
 		if (seen.has(resourceId)) {
-			diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_ROOT_DUPLICATE", dependencyLocation(resourceId), `Dependency snapshot root '${resourceId}' is declared more than once.`));
+			diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_ROOT_DUPLICATE", dependencyLocation(resourceId), `Dependency snapshot root '${resourceId}' is declared more than once.`));
 			continue;
 		}
 		seen.add(resourceId);
 		roots.push(resourceId);
 		const entry = registry.byId.get(resourceId);
-		if (!entry || !entry.resource) diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_ROOT_MISSING", dependencyLocation(resourceId), `Dependency snapshot root '${resourceId}' is not an effective resource.`));
+		if (!entry || !entry.resource) diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_ROOT_MISSING", dependencyLocation(resourceId), `Dependency snapshot root '${resourceId}' is not an effective resource.`));
 	}
-	if (roots.length === 0 && diagnostics.length === 0) diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_ROOTS_EMPTY", "dependency-root:none", "Dependency snapshot requires at least one explicit root."));
+	if (roots.length === 0 && diagnostics.length === 0) diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_ROOTS_EMPTY", "dependency-root:none", "Dependency snapshot requires at least one explicit root."));
 	return roots;
 }
 function validateEdges(inputEdges, registry, diagnostics) {
@@ -188,13 +186,13 @@ function validateEdges(inputEdges, registry, diagnostics) {
 			declaredBy: inputEdge.declaredBy.trim()
 		});
 		if (!edge.fromResourceId || !edge.toResourceId || !edge.relation || !edge.declaredBy) {
-			diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_EDGE_INVALID", `dependency-edge:${index}`, "Dependency edges require non-empty fromResourceId, toResourceId, relation, and declaredBy fields."));
+			diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_EDGE_INVALID", `dependency-edge:${index}`, "Dependency edges require non-empty fromResourceId, toResourceId, relation, and declaredBy fields."));
 			return;
 		}
 		const source = registry.byId.get(edge.fromResourceId);
 		const target = registry.byId.get(edge.toResourceId);
-		if (!source?.resource) diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_SOURCE_MISSING", dependencyLocation(edge.fromResourceId), `Dependency edge source '${edge.fromResourceId}' is not an effective resource.`));
-		if (!target?.resource) diagnostics.push(diagnostic$1("RESOURCE_DEPENDENCY_TARGET_MISSING", dependencyLocation(edge.toResourceId), `Dependency edge target '${edge.toResourceId}' is not an effective resource.`));
+		if (!source?.resource) diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_SOURCE_MISSING", dependencyLocation(edge.fromResourceId), `Dependency edge source '${edge.fromResourceId}' is not an effective resource.`));
+		if (!target?.resource) diagnostics.push(diagnostic("RESOURCE_DEPENDENCY_TARGET_MISSING", dependencyLocation(edge.toResourceId), `Dependency edge target '${edge.toResourceId}' is not an effective resource.`));
 		values.set(edgeKey(edge), edge);
 	});
 	return [...values.values()].sort(compareEdges);
@@ -202,41 +200,41 @@ function validateEdges(inputEdges, registry, diagnostics) {
 function normalizeContentIdentity(input, diagnostics, options) {
 	const initialDiagnosticCount = diagnostics.length;
 	if (!isRecord(input)) {
-		diagnostics.push(diagnostic$1("RESOURCE_CONTENT_IDENTITY_INVALID", contentLocation(""), "Resource content identity must be an object fact."));
+		diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_INVALID", contentLocation(""), "Resource content identity must be an object fact."));
 		return;
 	}
 	const rawResourceId = input.resourceId;
 	const resourceId = typeof rawResourceId === "string" ? rawResourceId.trim() : "";
-	if (resourceId.length === 0) diagnostics.push(diagnostic$1("RESOURCE_CONTENT_IDENTITY_ID_EMPTY", contentLocation(""), "Resource content identity requires a non-empty resource id."));
-	else if (options.strictCanonicalInput && rawResourceId !== resourceId) diagnostics.push(diagnostic$1("RESOURCE_CONTENT_IDENTITY_NON_CANONICAL", contentLocation(resourceId), `Resource content identity '${resourceId}' must use its canonical id without surrounding whitespace.`));
+	if (resourceId.length === 0) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_ID_EMPTY", contentLocation(""), "Resource content identity requires a non-empty resource id."));
+	else if (options.strictCanonicalInput && rawResourceId !== resourceId) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_NON_CANONICAL", contentLocation(resourceId), `Resource content identity '${resourceId}' must use its canonical id without surrounding whitespace.`));
 	const authorityDigest = typeof input.authorityDigest === "string" ? input.authorityDigest : "";
-	if (!isSha256Digest(authorityDigest)) diagnostics.push(diagnostic$1("RESOURCE_CONTENT_AUTHORITY_DIGEST_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has an invalid authority digest.`));
+	if (!isSha256Digest(authorityDigest)) diagnostics.push(diagnostic("RESOURCE_CONTENT_AUTHORITY_DIGEST_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has an invalid authority digest.`));
 	const rawContributions = input.contributions;
 	let contributionFacts = [];
 	if (rawContributions === void 0 && !options.requireContributions) contributionFacts = [];
-	else if (!Array.isArray(rawContributions)) diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTIONS_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' must provide an explicit digest contribution array.`));
+	else if (!Array.isArray(rawContributions)) diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTIONS_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' must provide an explicit digest contribution array.`));
 	else contributionFacts = rawContributions;
 	const contributions = /* @__PURE__ */ new Map();
 	for (const fact of contributionFacts) {
 		if (!isRecord(fact)) {
-			diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTION_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has a non-object digest contribution.`));
+			diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_INVALID", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has a non-object digest contribution.`));
 			continue;
 		}
 		const rawKey = fact.key;
 		const key = typeof rawKey === "string" ? rawKey.trim() : "";
 		if (key.length === 0) {
-			diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTION_KEY_EMPTY", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has a digest contribution with an empty key.`));
+			diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_KEY_EMPTY", contentLocation(resourceId), `Resource '${resourceId || "unnamed"}' has a digest contribution with an empty key.`));
 			continue;
 		}
-		if (options.strictCanonicalInput && rawKey !== key) diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTION_NON_CANONICAL", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId}' must use its canonical key.`));
+		if (options.strictCanonicalInput && rawKey !== key) diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_NON_CANONICAL", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId}' must use its canonical key.`));
 		const digest = typeof fact.digest === "string" ? fact.digest : "";
 		if (!isSha256Digest(digest)) {
-			diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTION_INVALID", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' is invalid.`));
+			diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_INVALID", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' is invalid.`));
 			continue;
 		}
 		const sourceUri = fact.sourceUri;
 		if (sourceUri !== void 0 && typeof sourceUri !== "string") {
-			diagnostics.push(diagnostic$1("RESOURCE_DIGEST_CONTRIBUTION_SOURCE_INVALID", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId}' has an invalid source URI.`));
+			diagnostics.push(diagnostic("RESOURCE_DIGEST_CONTRIBUTION_SOURCE_INVALID", contentLocation(resourceId, key), `Digest contribution '${key}' for resource '${resourceId}' has an invalid source URI.`));
 			continue;
 		}
 		const contribution = Object.freeze({
@@ -247,7 +245,7 @@ function normalizeContentIdentity(input, diagnostics, options) {
 		const current = contributions.get(key);
 		if (current) {
 			const conflicting = current.digest !== digest;
-			diagnostics.push(diagnostic$1(conflicting ? "RESOURCE_DIGEST_CONTRIBUTION_CONFLICT" : "RESOURCE_DIGEST_CONTRIBUTION_DUPLICATE", contentLocation(resourceId, key), conflicting ? `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' has conflicting digests.` : `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' is declared more than once.`));
+			diagnostics.push(diagnostic(conflicting ? "RESOURCE_DIGEST_CONTRIBUTION_CONFLICT" : "RESOURCE_DIGEST_CONTRIBUTION_DUPLICATE", contentLocation(resourceId, key), conflicting ? `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' has conflicting digests.` : `Digest contribution '${key}' for resource '${resourceId || "unnamed"}' is declared more than once.`));
 			continue;
 		}
 		contributions.set(key, contribution);
@@ -265,11 +263,11 @@ function normalizeContentIdentity(input, diagnostics, options) {
 	if (options.validateClaimedDigest) {
 		const claimedDigest = input.contentDigest;
 		if (typeof claimedDigest !== "string" || !isSha256Digest(claimedDigest)) {
-			diagnostics.push(diagnostic$1("RESOURCE_CONTENT_DIGEST_INVALID", contentLocation(resourceId), `Resource '${resourceId}' has an invalid claimed content digest.`));
+			diagnostics.push(diagnostic("RESOURCE_CONTENT_DIGEST_INVALID", contentLocation(resourceId), `Resource '${resourceId}' has an invalid claimed content digest.`));
 			return;
 		}
 		if (claimedDigest !== contentDigest) {
-			diagnostics.push(diagnostic$1("RESOURCE_CONTENT_DIGEST_MISMATCH", contentLocation(resourceId), `Resource '${resourceId}' claimed a content digest that does not match its explicit authority and contributions.`));
+			diagnostics.push(diagnostic("RESOURCE_CONTENT_DIGEST_MISMATCH", contentLocation(resourceId), `Resource '${resourceId}' claimed a content digest that does not match its explicit authority and contributions.`));
 			return;
 		}
 	}
@@ -286,7 +284,7 @@ function validateEffectiveContentIdentities(registry, identities, diagnostics) {
 	for (const entry of effectiveEntries) {
 		const input = identities.get(entry.resourceId);
 		if (input === void 0) {
-			diagnostics.push(diagnostic$1("RESOURCE_CONTENT_IDENTITY_MISSING", dependencyLocation(entry.resourceId), `Effective resource '${entry.resourceId}' has no explicit content identity.`));
+			diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_MISSING", dependencyLocation(entry.resourceId), `Effective resource '${entry.resourceId}' has no explicit content identity.`));
 			continue;
 		}
 		const identity = normalizeContentIdentity(input, diagnostics, {
@@ -301,7 +299,7 @@ function validateEffectiveContentIdentities(registry, identities, diagnostics) {
 function validateContentIdentityIndex(identities, diagnostics) {
 	for (const [key, identity] of [...identities.entries()].sort(([left], [right]) => compareCodeUnits(left, right))) {
 		const identityResourceId = isRecord(identity) && typeof identity.resourceId === "string" ? identity.resourceId : void 0;
-		if (key !== identityResourceId) diagnostics.push(diagnostic$1("RESOURCE_CONTENT_IDENTITY_KEY_MISMATCH", dependencyLocation(key), `Content identity index key '${key}' does not match identity '${identityResourceId ?? "invalid"}'.`));
+		if (key !== identityResourceId) diagnostics.push(diagnostic("RESOURCE_CONTENT_IDENTITY_KEY_MISMATCH", dependencyLocation(key), `Content identity index key '${key}' does not match identity '${identityResourceId ?? "invalid"}'.`));
 	}
 }
 function isSha256Digest(value) {
@@ -347,10 +345,10 @@ function cloneOrigin(origin) {
 		...origin.logicalPath === void 0 ? {} : { logicalPath: origin.logicalPath }
 	});
 }
-function stableDiagnostics$1(diagnostics) {
+function stableDiagnostics(diagnostics) {
 	return Object.freeze([...diagnostics].sort((left, right) => compareCodeUnits(left.location, right.location) || compareCodeUnits(left.code, right.code)));
 }
-function diagnostic$1(code, location, message) {
+function diagnostic(code, location, message) {
 	return Object.freeze({
 		code,
 		location,
@@ -374,224 +372,6 @@ function isLoadedResourceTreeAuthentic(tree) {
 	return authenticLoadedResourceTrees.has(tree);
 }
 //#endregion
-//#region ../resource-core/src/code-package.ts
-const CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY = "code-binding:module";
-/** @internal Node effect implementation bound by the public facade. */
-const nodeCodePackageRuntime = Object.freeze({
-	realpath,
-	readFile,
-	stat,
-	prepareModuleSource: async ({ bytes }) => {
-		const directory = await mkdtemp(join(tmpdir(), "halfcode-code-package-module-"));
-		const sourcePath = join(directory, "entry.mjs");
-		try {
-			await writeFile(sourcePath, bytes, { flag: "wx" });
-		} catch (error) {
-			await rm(directory, {
-				recursive: true,
-				force: true
-			}).catch(() => void 0);
-			throw error;
-		}
-		return Object.freeze({
-			url: pathToFileURL(sourcePath).href,
-			dispose: async () => rm(directory, {
-				recursive: true,
-				force: true
-			})
-		});
-	},
-	importModule: async (url) => import(url)
-});
-var CodePackageLoadError = class extends Error {
-	diagnostics;
-	constructor(diagnostics) {
-		super(`CodePackage loading failed with ${diagnostics.length} diagnostic(s)`);
-		this.name = "CodePackageLoadError";
-		this.diagnostics = Object.freeze([...diagnostics]);
-	}
-};
-/** @internal Used by the canonical XNL loader before it brands the completed tree. */
-function normalizeCodePackageBinding(record) {
-	const diagnostics = [];
-	if (record.sourceShape !== "code-package") {
-		diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_SHAPE_INVALID", record.documentUri, `Resource '${record.resourceId}' does not use the code-package source shape.`));
-		return { diagnostics };
-	}
-	const declaredEntry = stringValue(record.node.properties.entry);
-	const declaredRuntime = stringValue(record.node.properties.runtime);
-	const declaredModuleUri = declaredEntry ? normalizeModuleUri(`vfs://./${declaredEntry}`) : void 0;
-	if (!declaredEntry) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_DECLARATION_MISSING", record.documentUri, `CodePackage resource '${record.resourceId}' requires a manifest entry.`));
-	else if (!declaredModuleUri) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_DECLARATION_INVALID", record.documentUri, `CodePackage resource '${record.resourceId}' has an invalid manifest entry.`));
-	if (!declaredRuntime) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_RUNTIME_MISSING", record.documentUri, `CodePackage resource '${record.resourceId}' requires a manifest runtime.`));
-	const node = record.node.subdomains.CodeBinding;
-	if (!node || node.tag !== "CodeBinding") {
-		diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_BINDING_MISSING", record.documentUri, `CodePackage resource '${record.resourceId}' requires one CodeBinding.`));
-		return { diagnostics };
-	}
-	if (node.properties.package !== void 0) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_BINDING_INVALID", record.documentUri, `CodePackage resource '${record.resourceId}' must bind a package-local module, not an external package.`));
-	const rawModule = stringValue(node.properties.module);
-	const moduleUri = rawModule === void 0 ? void 0 : normalizeModuleUri(rawModule);
-	if (!moduleUri) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_MODULE_INVALID", record.documentUri, `CodePackage resource '${record.resourceId}' requires a canonical package-local .js or .mjs module URI.`));
-	const rawExport = node.properties.export;
-	const exportName = stringValue(rawExport);
-	if (rawExport !== void 0 && (!exportName || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName))) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_EXPORT_INVALID", record.documentUri, `CodePackage resource '${record.resourceId}' has an invalid named export binding.`));
-	if (moduleUri && declaredModuleUri && moduleUri !== declaredModuleUri) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_BINDING_MISMATCH", record.documentUri, `CodePackage resource '${record.resourceId}' manifest entry and CodeBinding.module must identify the same package-local module.`));
-	if (diagnostics.length > 0 || !moduleUri) return { diagnostics: stableDiagnostics(diagnostics) };
-	return {
-		binding: Object.freeze({
-			resourceId: record.resourceId,
-			moduleUri,
-			...exportName ? { exportName } : {}
-		}),
-		diagnostics: Object.freeze([])
-	};
-}
-/** @internal Resolves and reads the exact entry bytes under the descriptor directory. */
-async function readCodePackageEntry(runtime, rootDir, record, binding) {
-	const diagnostics = [];
-	const realRoot = await runtime.realpath(resolve(rootDir)).catch(() => void 0);
-	if (!realRoot) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_ROOT_MISSING", record.documentUri, `The resource root for '${record.resourceId}' is missing or unreadable.`)] };
-	if (!isSafeLogicalPath(record.logicalPath)) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_PROVENANCE_INVALID", record.documentUri, `CodePackage resource '${record.resourceId}' has unsafe logical provenance.`)] };
-	const descriptorPath = resolve(realRoot, record.logicalPath);
-	const descriptorDirectory = await runtime.realpath(dirname(descriptorPath)).catch(() => void 0);
-	if (!descriptorDirectory || !isWithin(realRoot, descriptorDirectory)) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_CONTAINMENT", record.documentUri, `CodePackage resource '${record.resourceId}' resolves outside the resource root.`)] };
-	const localPath = moduleLocalPath(binding.moduleUri);
-	if (!localPath) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_MODULE_INVALID", record.documentUri, `CodePackage resource '${record.resourceId}' has an invalid module URI.`)] };
-	const entryPath = await runtime.realpath(resolve(descriptorDirectory, ...localPath.split("/"))).catch(() => void 0);
-	if (!entryPath) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_MISSING", `${record.documentUri}#CodeBinding`, `CodePackage entry is missing for '${record.resourceId}'.`)] };
-	if (!isWithin(descriptorDirectory, entryPath) || entryPath === descriptorDirectory) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_CONTAINMENT", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' resolves outside its package directory.`));
-	if (!(await runtime.stat(entryPath).catch(() => void 0))?.isFile()) diagnostics.push(diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_INVALID", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' must be a regular file.`));
-	if (diagnostics.length > 0) return { diagnostics: stableDiagnostics(diagnostics) };
-	const bytes = await runtime.readFile(entryPath).catch(() => void 0);
-	if (!bytes) return { diagnostics: [diagnostic("RESOURCE_CODE_PACKAGE_ENTRY_MISSING", `${record.documentUri}#CodeBinding`, `CodePackage entry is unreadable for '${record.resourceId}'.`)] };
-	const resourceDirectory = posix.dirname(record.logicalPath);
-	return {
-		entryPath,
-		bytes,
-		sourceUri: `vfs://@/${resourceDirectory === "." ? localPath : `${resourceDirectory}/${localPath}`}`,
-		diagnostics: Object.freeze([])
-	};
-}
-async function loadCodePackageModule(input) {
-	return loadCodePackageModuleWithRuntime(nodeCodePackageRuntime, input);
-}
-/** @internal Pure orchestration over an injected effect runtime; hidden by the package facade. */
-async function loadCodePackageModuleWithRuntime(runtime, input) {
-	if (!isLoadedResourceTreeAuthentic(input.tree)) throw loadError("RESOURCE_CODE_PACKAGE_TREE_UNTRUSTED", `code-package:${input.resourceId}`, "CodePackage modules require an authentic LoadedResourceTree.");
-	const record = findResource(input.tree, input.resourceId);
-	const binding = input.tree.codePackageBindings.get(input.resourceId);
-	const identity = input.tree.contentIdentities.get(input.resourceId);
-	if (!record || record.sourceShape !== "code-package" || !binding || !identity) throw loadError("RESOURCE_CODE_PACKAGE_RESOURCE_INVALID", `code-package:${input.resourceId}`, `Resource '${input.resourceId}' is not a loaded CodePackage.`);
-	const entry = await readCodePackageEntry(runtime, input.rootDir, record, binding);
-	if (entry.diagnostics.length > 0 || !entry.entryPath || !entry.bytes) throw new CodePackageLoadError(entry.diagnostics);
-	const contribution = identity.contributions.find((item) => item.key === CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY);
-	if (!contribution || contribution.digest !== sha256Digest(entry.bytes) || contribution.sourceUri !== entry.sourceUri) throw loadError("RESOURCE_CODE_PACKAGE_REVISION_STALE", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' changed after its ResourceTree was loaded.`);
-	let preparedSource;
-	try {
-		preparedSource = await runtime.prepareModuleSource({
-			bytes: entry.bytes,
-			revision: identity.contentDigest
-		});
-	} catch {
-		throw loadError("RESOURCE_CODE_PACKAGE_IMPORT_PREPARE_FAILED", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' could not be prepared for import.`);
-	}
-	let moduleNamespace;
-	let importFailed = false;
-	try {
-		moduleNamespace = await runtime.importModule(preparedSource.url);
-	} catch {
-		importFailed = true;
-		moduleNamespace = Object.freeze({});
-	}
-	const cleanupFailed = await preparedSource.dispose().then(() => false, () => true);
-	if (importFailed) throw loadError("RESOURCE_CODE_PACKAGE_IMPORT_FAILED", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' could not be imported.`);
-	if (cleanupFailed) throw loadError("RESOURCE_CODE_PACKAGE_IMPORT_CLEANUP_FAILED", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' could not be cleaned up after import.`);
-	if (binding.exportName && !(binding.exportName in moduleNamespace)) throw loadError("RESOURCE_CODE_PACKAGE_EXPORT_MISSING", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' does not export '${binding.exportName}'.`);
-	const currentBytes = await runtime.readFile(entry.entryPath).catch(() => void 0);
-	if (!currentBytes || sha256Digest(currentBytes) !== contribution.digest) throw loadError("RESOURCE_CODE_PACKAGE_REVISION_STALE", `${record.documentUri}#CodeBinding`, `CodePackage entry for '${record.resourceId}' changed while it was being imported.`);
-	const frozenNamespace = Object.freeze(Object.fromEntries(Object.keys(moduleNamespace).sort(compareCodeUnits).map((name) => [name, moduleNamespace[name]])));
-	return Object.freeze({
-		resourceId: record.resourceId,
-		binding,
-		revision: identity.contentDigest,
-		moduleNamespace: frozenNamespace
-	});
-}
-function admitCodePackageExports(loaded, contract) {
-	return admitCandidates([{
-		loaded,
-		contract
-	}]);
-}
-function admitCodePackages(loaded, contract) {
-	return admitCandidates(loaded.map((item) => ({
-		loaded: item,
-		contract
-	})));
-}
-function admitCandidates(packages) {
-	const definitions = /* @__PURE__ */ new Map();
-	for (const { loaded, contract } of packages) {
-		const names = loaded.binding.exportName ? [loaded.binding.exportName] : Object.keys(loaded.moduleNamespace).sort(compareCodeUnits);
-		for (const name of names) {
-			const exported = loaded.moduleNamespace[name];
-			const candidates = Array.isArray(exported) ? exported : [exported];
-			for (const candidate of candidates) {
-				if (!contract.isDefinition(candidate)) continue;
-				const identity = contract.identityOf(candidate).trim();
-				if (!identity) throw new TypeError(`CodePackage definition from '${loaded.resourceId}' has an empty identity`);
-				if (definitions.has(identity)) throw new TypeError(`Duplicate CodePackage definition identity '${identity}'`);
-				definitions.set(identity, candidate);
-			}
-		}
-	}
-	return Object.freeze([...definitions.entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([, definition]) => definition));
-}
-function normalizeModuleUri(value) {
-	const prefix = "vfs://./";
-	if (!value.startsWith(prefix) || value !== value.trim() || value.includes("%") || value.includes("\\") || value.includes("?") || value.includes("#")) return void 0;
-	const localPath = value.slice(8);
-	if (!localPath || isAbsolute(localPath) || posix.isAbsolute(localPath)) return void 0;
-	const parts = localPath.split("/");
-	if (parts.some((part) => !part || part === "." || part === "..")) return void 0;
-	const extension = extname(localPath).toLowerCase();
-	if (extension !== ".js" && extension !== ".mjs") return void 0;
-	return `${prefix}${parts.join("/")}`;
-}
-function moduleLocalPath(moduleUri) {
-	return normalizeModuleUri(moduleUri)?.slice(8);
-}
-function findResource(tree, resourceId) {
-	for (const records of tree.registry.byKind.values()) {
-		const record = records.find((item) => item.resourceId === resourceId);
-		if (record) return record;
-	}
-}
-function isSafeLogicalPath(value) {
-	return Boolean(value) && !isAbsolute(value) && !value.includes("\\") && !value.split("/").some((part) => !part || part === "." || part === "..");
-}
-function isWithin(boundary, candidate) {
-	const path = relative(boundary, candidate);
-	return path === "" || !path.startsWith(`..${sep}`) && path !== ".." && !isAbsolute(path);
-}
-function stringValue(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function loadError(code, location, message) {
-	return new CodePackageLoadError([diagnostic(code, location, message)]);
-}
-function stableDiagnostics(diagnostics) {
-	return Object.freeze([...diagnostics].sort((left, right) => compareCodeUnits(left.location, right.location) || compareCodeUnits(left.code, right.code)));
-}
-function diagnostic(code, location, message) {
-	return Object.freeze({
-		code,
-		location,
-		message
-	});
-}
-//#endregion
 //#region ../resource-core/src/readonly-map.ts
 function readonlyMap(entries) {
 	const values = new Map(entries);
@@ -635,8 +415,7 @@ async function buildXnlResourceTree(options) {
 		seenIdentities: /* @__PURE__ */ new Map(),
 		authorityFiles: /* @__PURE__ */ new Map(),
 		recordAuthorityDigests: /* @__PURE__ */ new WeakMap(),
-		recordContributions: /* @__PURE__ */ new WeakMap(),
-		codePackageBindings: /* @__PURE__ */ new Map()
+		recordContributions: /* @__PURE__ */ new WeakMap()
 	};
 	const manifest = await loadManifest(resolve(context.rootDir, options.manifestPath), "manifest", context, true);
 	if (!manifest || context.diagnostics.length > 0) return { diagnostics: context.diagnostics };
@@ -649,7 +428,6 @@ async function buildXnlResourceTree(options) {
 	const frozenByKind = readonlyMap([...byKind.entries()].sort(([left], [right]) => compareCodeUnits(left, right)).map(([kind, records]) => [kind, Object.freeze([...records].sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId)))]));
 	const frozenKindDefinitions = readonlyMap([...context.kindDefinitions.entries()].sort(([left], [right]) => compareCodeUnits(left, right)));
 	const contentIdentities = readonlyMap(context.resources.map((resource) => [resource.resourceId, loadedContentIdentity(resource, context)]).sort(([left], [right]) => compareCodeUnits(left, right)));
-	const codePackageBindings = readonlyMap([...context.codePackageBindings.entries()].sort(([left], [right]) => compareCodeUnits(left, right)));
 	return {
 		diagnostics: [],
 		tree: markLoadedResourceTreeAuthentic(Object.freeze({
@@ -659,24 +437,38 @@ async function buildXnlResourceTree(options) {
 				kindDefinitions: frozenKindDefinitions
 			}),
 			diagnostics: Object.freeze([]),
-			contentIdentities,
-			codePackageBindings
+			contentIdentities
 		}))
 	};
 }
 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);
+	if (isRoot && record.kind !== "ResourcePackage") {
+		const definition = context.kindDefinitions.get(record.kind);
+		if (!definition) {
+			context.diagnostics.push({
+				code: "KIND_DEFINITION_MISSING",
+				location: record.documentUri,
+				message: `No KindDefinition is registered for semantic root kind '${record.kind}'.`
+			});
+			return;
+		}
+		if (!definition.sourceShapes.includes("manifest")) {
+			context.diagnostics.push({
+				code: "RESOURCE_SOURCE_SHAPE_NOT_ALLOWED",
+				location: record.documentUri,
+				message: `Semantic root kind '${record.kind}' does not allow source shape 'manifest'.`
+			});
+			return;
+		}
+		validateResourceApiVersion(record, definition, context.diagnostics);
+		await validateRequiredFiles(dirname(filePath), record, definition, context.diagnostics);
+		validateIdentity(record, context);
+		context.resources.push(record);
+	}
 	for (const catalog of catalogs.filter((item) => item.kind !== "KindDefinition")) await loadCatalog(catalog, dirname(filePath), context);
 	if (!isRoot) {
 		validateIdentity(record, context);
@@ -749,7 +541,6 @@ async function loadCatalog(catalog, manifestDir, context) {
 			}
 			validateResourceApiVersion(record, definition, context.diagnostics);
 			await validateRequiredFiles(dirname(file), record, definition, context.diagnostics);
-			if (catalog.shape === "code-package" && !await prepareCodePackageRecord(record, context)) continue;
 			validateIdentity(record, context);
 			context.resources.push(record);
 		}
@@ -785,27 +576,26 @@ async function catalogFiles(catalog, manifestDir, context) {
 		context.diagnostics.push({
 			code: "RESOURCE_CATALOG_ENTRY_INVALID",
 			location: catalog.location,
-			message: "Directory, manifest and code-package catalogs require a plain XNL entry filename."
+			message: "Directory and manifest catalogs require a plain XNL entry filename."
 		});
 		return [];
 	}
-	if (catalog.shape === "code-package") {
+	if (catalog.shape === "directory" && catalog.scope === "root") {
 		const directEntry = join(root, catalog.entry);
 		const directStat = await lstat(directEntry).catch((error) => {
 			if (error.code === "ENOENT") return void 0;
 			throw error;
 		});
-		if (directStat) {
-			if (directStat.isSymbolicLink() || !directStat.isFile()) {
-				context.diagnostics.push({
-					code: "RESOURCE_CODE_PACKAGE_CATALOG_ENTRY_INVALID",
-					location: documentUriFor(context.rootDir, directEntry),
-					message: "A direct CodePackage catalog entry must be a regular non-symbolic-link XNL file."
-				});
-				return [];
-			}
-			return [directEntry];
+		if (!directStat) return [directEntry];
+		if (directStat.isSymbolicLink() || !directStat.isFile()) {
+			context.diagnostics.push({
+				code: "RESOURCE_CATALOG_ENTRY_INVALID",
+				location: documentUriFor(context.rootDir, directEntry),
+				message: "A root-scoped directory catalog entry must be a regular non-symbolic-link XNL file."
+			});
+			return [];
 		}
+		return [directEntry];
 	}
 	return entries.filter((entry) => entry.isDirectory()).sort((left, right) => compareCodeUnits(left.name, right.name)).map((entry) => join(root, entry.name, catalog.entry));
 }
@@ -993,22 +783,6 @@ function loadedContentIdentity(resource, context) {
 		contributions: context.recordContributions.get(resource) ?? []
 	});
 }
-async function prepareCodePackageRecord(record, context) {
-	const normalized = normalizeCodePackageBinding(record);
-	context.diagnostics.push(...normalized.diagnostics);
-	if (!normalized.binding) return false;
-	const entry = await readCodePackageEntry(nodeCodePackageRuntime, context.rootDir, record, normalized.binding);
-	context.diagnostics.push(...entry.diagnostics);
-	if (!entry.bytes || !entry.sourceUri) return false;
-	const contribution = Object.freeze({
-		key: CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY,
-		digest: sha256Digest(entry.bytes),
-		sourceUri: entry.sourceUri
-	});
-	context.recordContributions.set(record, Object.freeze([contribution]));
-	context.codePackageBindings.set(record.resourceId, normalized.binding);
-	return true;
-}
 function resourceRecordFromRoot(root, filePath, sourceShape, context) {
 	const documentUri = documentUriFor(context.rootDir, filePath);
 	const node = normalizeNode(root);
@@ -1079,18 +853,26 @@ function readCatalogs(record, diagnostics) {
 	if (!catalogs) return [];
 	const out = [];
 	for (const value of catalogs.body) {
-		if (!isResourceNode(value) || value.tag !== "Catalog") continue;
+		if (!isResourceNode(value)) continue;
+		const fixedShape = catalogShapeForTag(value.tag);
+		if (value.tag !== "Catalog" && !fixedShape) continue;
 		const id = value.resourceId;
-		const kind = asString(value.properties.kind);
+		const kind = asString(value.properties.resourceKind) ?? 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)) {
+		const declaredShape = asString(value.properties.shape);
+		const shapeValue = fixedShape ?? declaredShape ?? (entry ? "directory" : "single-file");
+		const declaredScope = asString(value.properties.scope);
+		const scope = declaredScope ?? "children";
+		const location = `${record.documentUri}#${value.tag}:${id ?? "unknown"}`;
+		const shapeConflict = Boolean(fixedShape && declaredShape && declaredShape !== fixedShape);
+		const invalidScope = scope !== "root" && scope !== "children";
+		const scopeNotAllowed = Boolean(declaredScope && shapeValue !== "directory");
+		if (!id || !kind || !root || !isXnlShape(shapeValue) || shapeConflict || invalidScope || scopeNotAllowed) {
 			diagnostics.push({
 				code: "RESOURCE_CATALOG_INVALID",
 				location,
-				message: "Catalog requires #id, kind, root and a valid shape."
+				message: "Resource catalog requires #id, resourceKind (or legacy kind), root, a tag-consistent shape and a valid directory scope."
 			});
 			continue;
 		}
@@ -1100,11 +882,17 @@ function readCatalogs(record, diagnostics) {
 			root,
 			entry,
 			shape: shapeValue,
+			scope,
 			location
 		});
 	}
 	return out;
 }
+function catalogShapeForTag(tag) {
+	if (tag === "FileResourceCatalog") return "single-file";
+	if (tag === "DirectoryResourceCatalog") return "directory";
+	if (tag === "ManifestResourceCatalog") return "manifest";
+}
 function normalizeKindDefinition(record, diagnostics) {
 	const resourceKind = asString(record.node.properties.resourceKind) ?? record.resourceId.split(".").at(-1);
 	const shapes = record.node.properties.sourceShapes;
@@ -1243,7 +1031,7 @@ function kindMismatch(actual, expected, location) {
 	};
 }
 function isXnlShape(value) {
-	return value === "single-file" || value === "directory" || value === "manifest" || value === "code-package";
+	return value === "single-file" || value === "directory" || value === "manifest";
 }
 function isDocumentCardinality(value) {
 	return value === "one" || value === "many";
@@ -1332,4 +1120,4 @@ function unsupportedAuthorityDiagnostic(options) {
 	};
 }
 //#endregion
-export { ResourceCompositionError as _, CODE_PACKAGE_ENTRY_CONTRIBUTION_KEY as a, admitCodePackages as c, buildResourceDependencySnapshot as d, createResourceContentIdentity as f, markEffectiveRegistryAuthentic as g, isEffectiveRegistryAuthentic as h, readonlyMap as i, loadCodePackageModule as l, effectiveRegistryLayerBindings as m, loadResourceTree as n, CodePackageLoadError as o, sha256Digest as p, validateResourceTree as r, admitCodePackageExports as s, ResourceValidationError as t, isLoadedResourceTreeAuthentic as u, compareCodeUnits as v, digestCanonical as y };
+export { isLoadedResourceTreeAuthentic as a, sha256Digest as c, markEffectiveRegistryAuthentic as d, ResourceCompositionError as f, readonlyMap as i, effectiveRegistryLayerBindings as l, digestCanonical as m, loadResourceTree as n, buildResourceDependencySnapshot as o, compareCodeUnits as p, validateResourceTree as r, createResourceContentIdentity as s, ResourceValidationError as t, isEffectiveRegistryAuthentic as u };