halfcode-compiler.xnl 0.2.8 → 0.2.9

package/dist/src-3MZLm339.js

@@ -0,0 +1,588 @@
+import "./src-D3qSzGFn.js";
+import { t as resolveEffectiveResourceContentIdentities } from "./effective-content-identities-DV5fTr5Q.js";
+import { createHash } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region ../runtime-authoring/src/resource-authoring.ts
+const RESOURCE_AUTHORING_SCHEMA_VERSION = "halfcode.resource-authoring/v1";
+var ResourceAuthoringError = class extends Error {
+	code;
+	cause;
+	constructor(code, message, cause) {
+		super(message);
+		this.code = code;
+		this.cause = cause;
+		this.name = "ResourceAuthoringError";
+	}
+};
+/** Derives the content-sensitive revision used by planning and CAS from canonical projections. */
+function deriveResourceAuthoringRegistryRevision(input) {
+	let identities;
+	try {
+		identities = resolveEffectiveResourceContentIdentities(input);
+	} catch (cause) {
+		throw new ResourceAuthoringError("RESOURCE_AUTHORING_REFRESH_INVALID", "Registry revision requires authentic canonical registry and layer projections.", cause);
+	}
+	return digestValue({
+		compositionRevision: input.registry.compositionRevision,
+		resources: [...identities.entries()].map(([resourceId, value]) => ({
+			resourceId,
+			contentDigest: value.contentDigest
+		})).sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId))
+	});
+}
+function planResourceAuthoring(runtime, input, _config) {
+	const proposal = normalizeProposal(input);
+	const planning = normalizePlanningAuthority(runtime.planningAuthority);
+	if (proposal.expected.registryRevision !== planning.registryRevision) fail("RESOURCE_AUTHORING_EXPECTED_STATE_INVALID", "Proposal registry revision does not match the planning authority.");
+	if (proposal.operation === "create" !== (proposal.expected.state === "absent")) fail("RESOURCE_AUTHORING_EXPECTED_STATE_INVALID", "Create requires absent state and update requires present state.");
+	const kindDefinition = planning.kindDefinitions.find((item) => item.kind === proposal.kind);
+	if (!kindDefinition) fail("RESOURCE_AUTHORING_KIND_UNKNOWN", `Kind '${proposal.kind}' is not registered.`);
+	if (!kindDefinition.supportedApiVersions.includes(proposal.apiVersion)) fail("RESOURCE_AUTHORING_API_VERSION_UNSUPPORTED", `Kind '${proposal.kind}' does not support '${proposal.apiVersion}'.`);
+	if (!kindDefinition.sourceShapes.includes(proposal.sourceShape)) fail("RESOURCE_AUTHORING_SOURCE_SHAPE_UNSUPPORTED", `Kind '${proposal.kind}' does not support '${proposal.sourceShape}'.`);
+	const catalog = planning.catalogs.find((item) => item.catalogId === proposal.catalogId);
+	if (!catalog) fail("RESOURCE_AUTHORING_CATALOG_UNKNOWN", `Catalog '${proposal.catalogId}' is not registered.`);
+	if (catalog.resourceKind !== proposal.kind || catalog.sourceShape !== proposal.sourceShape) fail("RESOURCE_AUTHORING_CATALOG_MISMATCH", `Catalog '${catalog.catalogId}' does not admit the proposal Kind and source shape.`);
+	assertCatalogTarget(catalog, proposal.documentUri);
+	let inspection;
+	try {
+		inspection = normalizeInspection(runtime.inspectAuthority({
+			documentUri: proposal.documentUri,
+			sourceShape: proposal.sourceShape,
+			authorityText: proposal.authorityText
+		}));
+	} catch (cause) {
+		if (cause instanceof ResourceAuthoringError) throw cause;
+		throw new ResourceAuthoringError("RESOURCE_AUTHORING_AUTHORITY_INVALID", "Authority inspection failed.", cause);
+	}
+	if (inspection.documentUri !== proposal.documentUri) fail("RESOURCE_AUTHORING_AUTHORITY_INVALID", "Authority inspection changed the logical document URI.");
+	if (kindDefinition.documentCardinality === "one" && inspection.resources.length !== 1) fail("RESOURCE_AUTHORING_AUTHORITY_INVALID", `Kind '${proposal.kind}' requires one resource root per authority document.`);
+	if (inspection.resources.length === 0) fail("RESOURCE_AUTHORING_AUTHORITY_INVALID", "Authority document contains no resource roots.");
+	const resourceIds = /* @__PURE__ */ new Set();
+	for (const resource of inspection.resources) {
+		if (resourceIds.has(resource.resourceId)) fail("RESOURCE_AUTHORING_AUTHORITY_INVALID", "Authority document repeats a resource identity.");
+		resourceIds.add(resource.resourceId);
+		if (resource.kind !== proposal.kind || resource.apiVersion !== proposal.apiVersion) fail("RESOURCE_AUTHORING_AUTHORITY_INVALID", "Every authority root must match the proposed Kind and apiVersion.");
+	}
+	if (!resourceIds.has(proposal.resourceId)) fail("RESOURCE_AUTHORING_AUTHORITY_INVALID", `Authority document does not contain target '${proposal.resourceId}'.`);
+	const authorityDigest = digestText(proposal.authorityText);
+	if (proposal.expected.state === "present" && proposal.expected.authorityDigest === authorityDigest) fail("RESOURCE_AUTHORING_EXPECTED_STATE_INVALID", "Update authority must differ from the expected current authority.");
+	const unsigned = {
+		schemaVersion: RESOURCE_AUTHORING_SCHEMA_VERSION,
+		proposal,
+		kindDefinition,
+		catalog,
+		resources: inspection.resources,
+		authorityDigest
+	};
+	return deepFreeze({
+		...unsigned,
+		planDigest: digestValue(unsigned)
+	});
+}
+async function applyResourceAuthoring(runtime, input, config) {
+	const plan = normalizePlan(input);
+	let replanned;
+	try {
+		replanned = planResourceAuthoring(runtime, plan.proposal, config);
+	} catch (cause) {
+		throw new ResourceAuthoringError("RESOURCE_AUTHORING_PLAN_FORGED", "Resource authoring plan is not admitted by the trusted planning authority.", cause);
+	}
+	if (canonicalJson(plan) !== canonicalJson(replanned)) fail("RESOURCE_AUTHORING_PLAN_FORGED", "Resource authoring plan does not match trusted planning inputs.");
+	let replay;
+	try {
+		replay = await runtime.transaction.loadReceipt(plan.planDigest);
+	} catch (cause) {
+		throw new ResourceAuthoringError("RESOURCE_AUTHORING_COMMIT_INVALID", "Durable receipt lookup failed.", cause);
+	}
+	if (replay) return verifyReceipt(replay, plan);
+	let prepared;
+	let phase = "prepare";
+	try {
+		prepared = normalizePrepared(await runtime.transaction.prepare({
+			planDigest: plan.planDigest,
+			operation: plan.proposal.operation,
+			documentUri: plan.proposal.documentUri,
+			expected: plan.proposal.expected,
+			authorityDigest: plan.authorityDigest,
+			authorityText: plan.proposal.authorityText
+		}));
+		verifyPrepared(prepared, plan);
+		phase = "refresh";
+		const candidate = await runtime.transaction.refreshCandidate({
+			transactionId: prepared.transactionId,
+			planDigest: plan.planDigest
+		});
+		const receipt = verifyCandidate(candidate, prepared, plan);
+		phase = "commit";
+		return verifyReceipt(await runtime.transaction.commit({
+			transactionId: prepared.transactionId,
+			candidateId: candidate.candidateId,
+			receipt
+		}), plan, receipt);
+	} catch (cause) {
+		const recovered = await runtime.transaction.loadReceipt(plan.planDigest).catch(() => void 0);
+		if (recovered) return verifyReceipt(recovered, plan);
+		if (prepared) try {
+			await runtime.transaction.rollback({
+				transactionId: prepared.transactionId,
+				planDigest: plan.planDigest
+			});
+		} catch (rollbackCause) {
+			throw new ResourceAuthoringError("RESOURCE_AUTHORING_ROLLBACK_FAILED", "Resource authoring rollback failed before a durable receipt was found.", {
+				cause,
+				rollbackCause
+			});
+		}
+		if (cause instanceof ResourceAuthoringError) throw cause;
+		throw new ResourceAuthoringError(phase === "prepare" ? "RESOURCE_AUTHORING_PREPARE_INVALID" : phase === "refresh" ? "RESOURCE_AUTHORING_REFRESH_INVALID" : "RESOURCE_AUTHORING_COMMIT_INVALID", `Resource authoring ${phase} failed.`, cause);
+	}
+}
+function verifyPrepared(prepared, plan) {
+	const before = plan.proposal.expected.state === "present" ? plan.proposal.expected.authorityDigest : null;
+	if (prepared.planDigest !== plan.planDigest || prepared.authorityDigestBefore !== before || prepared.registryRevisionBefore !== plan.proposal.expected.registryRevision) fail("RESOURCE_AUTHORING_PREPARE_INVALID", "Prepared write does not match the exact CAS expectation.");
+}
+function verifyCandidate(candidate, prepared, plan) {
+	if (!candidate || typeof candidate !== "object" || candidate.transactionId !== prepared.transactionId || !nonEmptyString(candidate.candidateId) || !nonEmptyString(candidate.targetLayerId) || candidate.tree !== candidate.layers.find((layer) => layer.id === candidate.targetLayerId)?.tree) fail("RESOURCE_AUTHORING_REFRESH_INVALID", "Candidate refresh does not bind the prepared transaction and target layer.");
+	let identities;
+	try {
+		identities = resolveEffectiveResourceContentIdentities({
+			registry: candidate.registry,
+			layers: candidate.layers
+		});
+	} catch (cause) {
+		throw new ResourceAuthoringError("RESOURCE_AUTHORING_REFRESH_INVALID", "Candidate refresh is not an authentic canonical projection.", cause);
+	}
+	const target = candidate.registry.byId.get(plan.proposal.resourceId);
+	const identity = identities.get(plan.proposal.resourceId);
+	const resource = target?.resource;
+	const origin = target?.effectiveOrigin;
+	if (!resource || !identity || !origin || target.kind !== plan.proposal.kind || resource.metadata.apiVersion !== plan.proposal.apiVersion || resource.sourceShape !== plan.proposal.sourceShape || resource.documentUri !== plan.proposal.documentUri || identity.authorityDigest !== plan.authorityDigest || origin.layerId !== candidate.targetLayerId || origin.documentUri !== plan.proposal.documentUri) fail("RESOURCE_AUTHORING_REFRESH_INVALID", "Candidate refresh does not project the planned effective resource and authority.");
+	const actualRoots = recordsAtDocument(candidate.tree, plan.proposal.documentUri).map((record) => ({
+		resourceId: record.resourceId,
+		kind: record.kind,
+		apiVersion: record.metadata.apiVersion
+	})).sort(compareInspectedRoots);
+	const plannedRoots = [...plan.resources].sort(compareInspectedRoots);
+	if (canonicalJson(actualRoots) !== canonicalJson(plannedRoots)) fail("RESOURCE_AUTHORING_REFRESH_INVALID", "Candidate refresh changed the whole authority-document resource set.");
+	for (const root of plannedRoots) {
+		const rootIdentity = candidate.tree.contentIdentities.get(root.resourceId);
+		if (!rootIdentity || rootIdentity.authorityDigest !== plan.authorityDigest) fail("RESOURCE_AUTHORING_REFRESH_INVALID", "Candidate refresh does not bind every authority root to the planned bytes.");
+	}
+	const registryRevisionAfter = deriveResourceAuthoringRegistryRevision({
+		registry: candidate.registry,
+		layers: candidate.layers
+	});
+	if (registryRevisionAfter === prepared.registryRevisionBefore) fail("RESOURCE_AUTHORING_REFRESH_INVALID", "Candidate refresh did not change the content-sensitive registry revision.");
+	const unsignedReceipt = {
+		schemaVersion: RESOURCE_AUTHORING_SCHEMA_VERSION,
+		planDigest: plan.planDigest,
+		transactionId: prepared.transactionId,
+		operation: plan.proposal.operation,
+		catalogId: plan.proposal.catalogId,
+		resourceId: plan.proposal.resourceId,
+		kind: plan.proposal.kind,
+		apiVersion: plan.proposal.apiVersion,
+		sourceShape: plan.proposal.sourceShape,
+		documentUri: plan.proposal.documentUri,
+		authorityDigestBefore: prepared.authorityDigestBefore,
+		authorityDigestAfter: plan.authorityDigest,
+		registryRevisionBefore: prepared.registryRevisionBefore,
+		registryRevisionAfter,
+		contentDigest: identity.contentDigest,
+		effectiveOrigin: {
+			layerId: origin.layerId,
+			layerIndex: origin.layerIndex,
+			packageId: origin.packageId,
+			documentUri: origin.documentUri,
+			...origin.logicalPath === void 0 ? {} : { logicalPath: origin.logicalPath }
+		},
+		authorityResourceIds: plannedRoots.map((item) => item.resourceId)
+	};
+	return deepFreeze({
+		...unsignedReceipt,
+		receiptDigest: digestValue(unsignedReceipt)
+	});
+}
+function verifyReceipt(value, plan, expected) {
+	const receipt = normalizeReceipt(value);
+	const authorityDigestBefore = plan.proposal.expected.state === "present" ? plan.proposal.expected.authorityDigest : null;
+	if (receipt.planDigest !== plan.planDigest || receipt.operation !== plan.proposal.operation || receipt.catalogId !== plan.proposal.catalogId || receipt.resourceId !== plan.proposal.resourceId || receipt.kind !== plan.proposal.kind || receipt.apiVersion !== plan.proposal.apiVersion || receipt.sourceShape !== plan.proposal.sourceShape || receipt.documentUri !== plan.proposal.documentUri || receipt.authorityDigestBefore !== authorityDigestBefore || receipt.authorityDigestAfter !== plan.authorityDigest || receipt.registryRevisionBefore !== plan.proposal.expected.registryRevision || receipt.registryRevisionAfter === receipt.registryRevisionBefore || receipt.effectiveOrigin.documentUri !== plan.proposal.documentUri || canonicalJson(receipt.authorityResourceIds) !== canonicalJson(plan.resources.map((item) => item.resourceId).sort(compareCodeUnits)) || expected && canonicalJson(receipt) !== canonicalJson(expected)) fail("RESOURCE_AUTHORING_COMMIT_INVALID", "Durable receipt does not match the exact accepted plan and refresh projection.");
+	return receipt;
+}
+function normalizeProposal(value) {
+	const input = ownRecord(value, [
+		"schemaVersion",
+		"operation",
+		"catalogId",
+		"resourceId",
+		"kind",
+		"apiVersion",
+		"sourceShape",
+		"documentUri",
+		"authorityText",
+		"expected"
+	], "proposal");
+	if (input.schemaVersion !== "halfcode.resource-authoring/v1") invalid("proposal.schemaVersion");
+	if (input.operation !== "create" && input.operation !== "update") invalid("proposal.operation");
+	if (input.sourceShape !== "single-file") fail("RESOURCE_AUTHORING_SOURCE_SHAPE_UNSUPPORTED", "The initial authoring transaction supports only single-file authority.");
+	const documentUri = normalizeDocumentUri(input.documentUri, "proposal.documentUri");
+	const authorityText = requiredString(input.authorityText, "proposal.authorityText", true);
+	const expectedInput = ownRecord(input.expected, input.operation === "create" ? ["state", "registryRevision"] : [
+		"state",
+		"authorityDigest",
+		"registryRevision"
+	], "proposal.expected");
+	const registryRevision = digestString(expectedInput.registryRevision, "proposal.expected.registryRevision");
+	const expected = input.operation === "create" ? (() => {
+		if (expectedInput.state !== "absent") invalid("proposal.expected.state");
+		return {
+			state: "absent",
+			registryRevision
+		};
+	})() : (() => {
+		if (expectedInput.state !== "present") invalid("proposal.expected.state");
+		return {
+			state: "present",
+			authorityDigest: digestString(expectedInput.authorityDigest, "proposal.expected.authorityDigest"),
+			registryRevision
+		};
+	})();
+	return deepFreeze({
+		schemaVersion: RESOURCE_AUTHORING_SCHEMA_VERSION,
+		operation: input.operation,
+		catalogId: requiredString(input.catalogId, "proposal.catalogId"),
+		resourceId: requiredString(input.resourceId, "proposal.resourceId"),
+		kind: requiredString(input.kind, "proposal.kind"),
+		apiVersion: requiredString(input.apiVersion, "proposal.apiVersion"),
+		sourceShape: "single-file",
+		documentUri,
+		authorityText,
+		expected
+	});
+}
+function normalizePlanningAuthority(value) {
+	const input = ownRecord(value, [
+		"registryRevision",
+		"kindDefinitions",
+		"catalogs"
+	], "planning");
+	const registryRevision = digestString(input.registryRevision, "planning.registryRevision");
+	const kindDefinitions = ownArray(input.kindDefinitions, "planning.kindDefinitions").map((item, index) => {
+		const record = ownRecord(item, [
+			"kind",
+			"supportedApiVersions",
+			"sourceShapes",
+			"documentCardinality"
+		], `planning.kindDefinitions[${index}]`);
+		const sourceShapes = ownArray(record.sourceShapes, `planning.kindDefinitions[${index}].sourceShapes`).map((shape) => {
+			if (shape !== "single-file") fail("RESOURCE_AUTHORING_SOURCE_SHAPE_UNSUPPORTED", "Planning authority contains an unsupported source shape.");
+			return shape;
+		});
+		if (record.documentCardinality !== "one" && record.documentCardinality !== "many") invalid(`planning.kindDefinitions[${index}].documentCardinality`);
+		return deepFreeze({
+			kind: requiredString(record.kind, `planning.kindDefinitions[${index}].kind`),
+			supportedApiVersions: [...uniqueStrings(record.supportedApiVersions, `planning.kindDefinitions[${index}].supportedApiVersions`)].sort(compareCodeUnits),
+			sourceShapes: sourceShapes.sort(compareCodeUnits),
+			documentCardinality: record.documentCardinality
+		});
+	});
+	const catalogs = ownArray(input.catalogs, "planning.catalogs").map((item, index) => {
+		const record = ownRecordOptional(item, [
+			"catalogId",
+			"resourceKind",
+			"sourceShape",
+			"rootUri"
+		], ["entry"], `planning.catalogs[${index}]`);
+		if (record.sourceShape !== "single-file") fail("RESOURCE_AUTHORING_SOURCE_SHAPE_UNSUPPORTED", "Planning catalog contains an unsupported source shape.");
+		const entry = record.entry === void 0 ? void 0 : plainEntry(record.entry, `planning.catalogs[${index}].entry`);
+		return deepFreeze({
+			catalogId: requiredString(record.catalogId, `planning.catalogs[${index}].catalogId`),
+			resourceKind: requiredString(record.resourceKind, `planning.catalogs[${index}].resourceKind`),
+			sourceShape: "single-file",
+			rootUri: normalizeDirectoryUri(record.rootUri, `planning.catalogs[${index}].rootUri`),
+			...entry === void 0 ? {} : { entry }
+		});
+	});
+	requireUnique(kindDefinitions.map((item) => item.kind), "planning Kind");
+	requireUnique(catalogs.map((item) => item.catalogId), "planning catalog");
+	return deepFreeze({
+		registryRevision,
+		kindDefinitions,
+		catalogs
+	});
+}
+function normalizeInspection(value) {
+	const input = ownRecord(value, ["documentUri", "resources"], "authorityInspection");
+	const resources = ownArray(input.resources, "authorityInspection.resources").map((item, index) => {
+		const record = ownRecord(item, [
+			"resourceId",
+			"kind",
+			"apiVersion"
+		], `authorityInspection.resources[${index}]`);
+		return deepFreeze({
+			resourceId: requiredString(record.resourceId, `authorityInspection.resources[${index}].resourceId`),
+			kind: requiredString(record.kind, `authorityInspection.resources[${index}].kind`),
+			apiVersion: requiredString(record.apiVersion, `authorityInspection.resources[${index}].apiVersion`)
+		});
+	}).sort(compareInspectedRoots);
+	return deepFreeze({
+		documentUri: normalizeDocumentUri(input.documentUri, "authorityInspection.documentUri"),
+		resources
+	});
+}
+function normalizePlan(value) {
+	const input = ownRecord(value, [
+		"schemaVersion",
+		"proposal",
+		"kindDefinition",
+		"catalog",
+		"resources",
+		"authorityDigest",
+		"planDigest"
+	], "plan");
+	if (input.schemaVersion !== "halfcode.resource-authoring/v1") invalid("plan.schemaVersion");
+	const proposal = normalizeProposal(input.proposal);
+	const authority = normalizePlanningAuthority({
+		registryRevision: proposal.expected.registryRevision,
+		kindDefinitions: [input.kindDefinition],
+		catalogs: [input.catalog]
+	});
+	const unsigned = {
+		schemaVersion: RESOURCE_AUTHORING_SCHEMA_VERSION,
+		proposal,
+		kindDefinition: authority.kindDefinitions[0],
+		catalog: authority.catalogs[0],
+		resources: normalizeInspection({
+			documentUri: proposal.documentUri,
+			resources: input.resources
+		}).resources,
+		authorityDigest: digestString(input.authorityDigest, "plan.authorityDigest")
+	};
+	const planDigest = digestString(input.planDigest, "plan.planDigest");
+	if (digestValue(unsigned) !== planDigest) fail("RESOURCE_AUTHORING_PLAN_FORGED", "Resource authoring plan digest is invalid.");
+	return deepFreeze({
+		...unsigned,
+		planDigest
+	});
+}
+function normalizePrepared(value) {
+	const input = ownRecord(value, [
+		"transactionId",
+		"planDigest",
+		"authorityDigestBefore",
+		"registryRevisionBefore"
+	], "prepared");
+	return deepFreeze({
+		transactionId: requiredString(input.transactionId, "prepared.transactionId"),
+		planDigest: digestString(input.planDigest, "prepared.planDigest"),
+		authorityDigestBefore: input.authorityDigestBefore === null ? null : digestString(input.authorityDigestBefore, "prepared.authorityDigestBefore"),
+		registryRevisionBefore: digestString(input.registryRevisionBefore, "prepared.registryRevisionBefore")
+	});
+}
+function normalizeReceipt(value) {
+	const input = ownRecord(value, [
+		"schemaVersion",
+		"planDigest",
+		"transactionId",
+		"operation",
+		"catalogId",
+		"resourceId",
+		"kind",
+		"apiVersion",
+		"sourceShape",
+		"documentUri",
+		"authorityDigestBefore",
+		"authorityDigestAfter",
+		"registryRevisionBefore",
+		"registryRevisionAfter",
+		"contentDigest",
+		"effectiveOrigin",
+		"authorityResourceIds",
+		"receiptDigest"
+	], "receipt");
+	if (input.schemaVersion !== "halfcode.resource-authoring/v1") invalid("receipt.schemaVersion");
+	if (input.operation !== "create" && input.operation !== "update") invalid("receipt.operation");
+	if (input.sourceShape !== "single-file") invalid("receipt.sourceShape");
+	const origin = ownRecordOptional(input.effectiveOrigin, [
+		"layerId",
+		"layerIndex",
+		"packageId",
+		"documentUri"
+	], ["logicalPath"], "receipt.effectiveOrigin");
+	if (!Number.isSafeInteger(origin.layerIndex) || Number(origin.layerIndex) < 0) invalid("receipt.effectiveOrigin.layerIndex");
+	const unsignedReceipt = {
+		schemaVersion: RESOURCE_AUTHORING_SCHEMA_VERSION,
+		planDigest: digestString(input.planDigest, "receipt.planDigest"),
+		transactionId: requiredString(input.transactionId, "receipt.transactionId"),
+		operation: input.operation,
+		catalogId: requiredString(input.catalogId, "receipt.catalogId"),
+		resourceId: requiredString(input.resourceId, "receipt.resourceId"),
+		kind: requiredString(input.kind, "receipt.kind"),
+		apiVersion: requiredString(input.apiVersion, "receipt.apiVersion"),
+		sourceShape: "single-file",
+		documentUri: normalizeDocumentUri(input.documentUri, "receipt.documentUri"),
+		authorityDigestBefore: input.authorityDigestBefore === null ? null : digestString(input.authorityDigestBefore, "receipt.authorityDigestBefore"),
+		authorityDigestAfter: digestString(input.authorityDigestAfter, "receipt.authorityDigestAfter"),
+		registryRevisionBefore: digestString(input.registryRevisionBefore, "receipt.registryRevisionBefore"),
+		registryRevisionAfter: digestString(input.registryRevisionAfter, "receipt.registryRevisionAfter"),
+		contentDigest: digestString(input.contentDigest, "receipt.contentDigest"),
+		effectiveOrigin: {
+			layerId: requiredString(origin.layerId, "receipt.effectiveOrigin.layerId"),
+			layerIndex: Number(origin.layerIndex),
+			packageId: requiredString(origin.packageId, "receipt.effectiveOrigin.packageId"),
+			documentUri: normalizeDocumentUri(origin.documentUri, "receipt.effectiveOrigin.documentUri"),
+			...origin.logicalPath === void 0 ? {} : { logicalPath: safeLogicalPath(origin.logicalPath, "receipt.effectiveOrigin.logicalPath") }
+		},
+		authorityResourceIds: [...uniqueStrings(input.authorityResourceIds, "receipt.authorityResourceIds")].sort(compareCodeUnits)
+	};
+	const receiptDigest = digestString(input.receiptDigest, "receipt.receiptDigest");
+	if (digestValue(unsignedReceipt) !== receiptDigest) fail("RESOURCE_AUTHORING_COMMIT_INVALID", "Durable receipt content digest is invalid.");
+	return deepFreeze({
+		...unsignedReceipt,
+		receiptDigest
+	});
+}
+function assertCatalogTarget(catalog, documentUri) {
+	const relative = documentUri.slice(catalog.rootUri.length);
+	if (!documentUri.startsWith(catalog.rootUri) || relative.length === 0 || relative.includes("/")) fail("RESOURCE_AUTHORING_CATALOG_MISMATCH", `Target '${documentUri}' is not a direct member of catalog '${catalog.catalogId}'.`);
+	if (catalog.entry !== void 0 && relative !== catalog.entry) fail("RESOURCE_AUTHORING_CATALOG_MISMATCH", `Catalog '${catalog.catalogId}' admits only '${catalog.entry}'.`);
+}
+function recordsAtDocument(tree, documentUri) {
+	return [...tree.registry.byKind.values()].flatMap((records) => [...records]).filter((record) => record.documentUri === documentUri);
+}
+function compareInspectedRoots(left, right) {
+	return compareCodeUnits(left.resourceId, right.resourceId) || compareCodeUnits(left.kind, right.kind) || compareCodeUnits(left.apiVersion, right.apiVersion);
+}
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function digestText(value) {
+	return `sha256:${createHash("sha256").update(value, "utf8").digest("hex")}`;
+}
+function digestValue(value) {
+	return digestText(canonicalJson(value));
+}
+function canonicalJson(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+	if (typeof value === "number" && Number.isFinite(value)) return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => compareCodeUnits(left, right)).map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
+	invalid("canonical value");
+}
+function deepFreeze(value) {
+	if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+	for (const item of Object.values(value)) deepFreeze(item);
+	return Object.freeze(value);
+}
+function ownRecord(value, keys, location) {
+	return ownRecordOptional(value, keys, [], location);
+}
+function ownRecordOptional(value, required, optional, location) {
+	if (!value || typeof value !== "object" || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null || Object.getOwnPropertySymbols(value).length > 0) invalid(location);
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	const actual = Object.keys(descriptors).filter((key) => descriptors[key].enumerable).sort(compareCodeUnits);
+	const allowed = [...required, ...optional];
+	if (required.some((key) => !actual.includes(key)) || actual.some((key) => !allowed.includes(key))) invalid(location);
+	const output = {};
+	for (const key of actual) {
+		const descriptor = descriptors[key];
+		if (!("value" in descriptor)) invalid(`${location}.${key}`);
+		output[key] = descriptor.value;
+	}
+	return output;
+}
+function ownArray(value, location) {
+	if (!Array.isArray(value) || Object.getOwnPropertySymbols(value).length > 0) invalid(location);
+	for (let index = 0; index < value.length; index += 1) if (!Object.prototype.hasOwnProperty.call(value, index)) invalid(location);
+	return value;
+}
+function requiredString(value, location, allowWhitespace = false) {
+	if (typeof value !== "string" || value.length === 0 || !allowWhitespace && value.trim() !== value) invalid(location);
+	return value;
+}
+function nonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function digestString(value, location) {
+	const text = requiredString(value, location);
+	if (!/^sha256:[0-9a-f]{64}$/u.test(text)) invalid(location);
+	return text;
+}
+function normalizeDocumentUri(value, location) {
+	const text = requiredString(value, location);
+	const logicalPath = text.startsWith("vfs://@/") ? text.slice(8) : "";
+	if (!isSafeAuthoringPath(logicalPath) || !/\.(?:xnl|md)$/u.test(logicalPath)) fail("RESOURCE_AUTHORING_TARGET_UNSAFE", `${location} must be a containment-safe XNL or Markdown VFS document URI.`);
+	return text;
+}
+function normalizeDirectoryUri(value, location) {
+	const text = requiredString(value, location);
+	if (!isSafeAuthoringPath(text.startsWith("vfs://@/") && text.endsWith("/") ? text.slice(8, -1) : "")) fail("RESOURCE_AUTHORING_TARGET_UNSAFE", `${location} must be a containment-safe VFS directory URI ending in '/'.`);
+	return text;
+}
+function plainEntry(value, location) {
+	const text = requiredString(value, location);
+	if (!isSafeAuthoringPath(text) || text.includes("/") || !/\.(?:xnl|md)$/u.test(text)) invalid(location);
+	return text;
+}
+function safeLogicalPath(value, location) {
+	const text = requiredString(value, location);
+	if (!isSafeAuthoringPath(text)) invalid(location);
+	return text;
+}
+function isSafeAuthoringPath(value) {
+	if (value.length === 0 || value.startsWith("/") || value.includes("\\") || value.includes("%") || /[\u0000-\u001f\u007f-\u009f]/u.test(value) || /[\ud800-\udfff]/u.test(value)) return false;
+	return value.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+function uniqueStrings(value, location) {
+	const items = ownArray(value, location).map((item, index) => requiredString(item, `${location}[${index}]`));
+	requireUnique(items, location);
+	return Object.freeze([...items]);
+}
+function requireUnique(values, location) {
+	if (new Set(values).size !== values.length) invalid(`${location} identities`);
+}
+function invalid(location) {
+	throw new ResourceAuthoringError("RESOURCE_AUTHORING_INPUT_INVALID", `${location} is invalid or not closed own-data.`);
+}
+function fail(code, message) {
+	throw new ResourceAuthoringError(code, message);
+}
+//#endregion
+//#region ../runtime-authoring/src/index.ts
+const runtimeScope = new AsyncLocalStorage();
+function runWithRuntime(runtime, callback) {
+	return runtimeScope.run(runtime, callback);
+}
+function currentRuntime() {
+	const runtime = runtimeScope.getStore();
+	if (!runtime) throw new Error("No authoring runtime is active in the current async scope");
+	return runtime;
+}
+function createAuthoringBindings(runtime = currentRuntime()) {
+	return {
+		runtime,
+		logger: runtime.effects.logger,
+		invokeEffect: (effectFqn, input) => runtime.effects.invoke(effectFqn, input)
+	};
+}
+const logger = {
+	info(message, fields) {
+		currentRuntime().effects.logger.info(message, fields);
+	},
+	warn(message, fields) {
+		currentRuntime().effects.logger.warn(message, fields);
+	},
+	error(message, fields) {
+		currentRuntime().effects.logger.error(message, fields);
+	}
+};
+function invokeEffect(effectFqn, input) {
+	return currentRuntime().effects.invoke(effectFqn, input);
+}
+const runtimeAuthoringPackage = {
+	role: "framework",
+	area: "runtime-authoring",
+	owns: "target-neutral deterministic-code runtime and effect boundary"
+};
+//#endregion
+export { runWithRuntime as a, ResourceAuthoringError as c, planResourceAuthoring as d, logger as i, applyResourceAuthoring as l, currentRuntime as n, runtimeAuthoringPackage as o, invokeEffect as r, RESOURCE_AUTHORING_SCHEMA_VERSION as s, createAuthoringBindings as t, deriveResourceAuthoringRegistryRevision as u };

package/dist/testing.js

@@ -1,4 +1,4 @@
-import { a as runWithRuntime } from "./src-B87eJQat.js";
+import { a as runWithRuntime } from "./src-3MZLm339.js";
 //#region ../runtime-mock/src/index.ts
 function createMockRuntime(options = {}) {
 	const effectCalls = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halfcode-compiler.xnl",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Compile XNL-described applications into runtime-ready skill capsules.",
   "type": "module",
   "private": false,
@@ -70,5 +70,9 @@
     "halfcode-compiler-runtime-testing": "workspace:*",
     "halfcode-compiler-skill-capsule": "workspace:*",
     "tsdown": "0.22.14"
-  }
+  },
+  "main": "index.js",
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
 }

package/dist/resource-core-C8IonwKw.d.ts

@@ -1,41 +0,0 @@
-import { I as EffectiveResourceRegistry, O as ResourceDigestContribution, T as ResourceContentIdentity, n as LoadedResourceTree, o as ResourceDiagnostic } from "./index-CDIT65pI.js";
-//#region ../resource-core/src/composition-error.d.ts
-declare class ResourceCompositionError extends Error {
-  readonly diagnostics: readonly ResourceDiagnostic[];
-  constructor(diagnostics: readonly ResourceDiagnostic[]);
-}
-//#endregion
-//#region ../resource-core/src/effective-content-identities.d.ts
-interface ResourceLayerContentIdentityInput {
-  readonly id: string;
-  readonly tree: LoadedResourceTree;
-}
-interface ResolveEffectiveResourceContentIdentitiesInput {
-  readonly registry: EffectiveResourceRegistry;
-  readonly layers: readonly ResourceLayerContentIdentityInput[];
-  readonly contributions?: ReadonlyMap<string, readonly ResourceDigestContribution[]>;
-}
-declare function resolveEffectiveResourceContentIdentities(input: ResolveEffectiveResourceContentIdentitiesInput): ReadonlyMap<string, ResourceContentIdentity>;
-//#endregion
-//#region ../resource-core/src/resource-material.d.ts
-interface ReadResourceMaterialInput {
-  readonly tree: LoadedResourceTree;
-  readonly rootDir: string;
-  readonly resourceId: string;
-  readonly uri: string;
-}
-interface ResourceMaterial {
-  readonly resourceId: string;
-  readonly uri: string;
-  readonly sourceUri: string;
-  readonly digest: string;
-  readonly contribution: ResourceDigestContribution;
-  bytes(): Uint8Array;
-}
-declare class ResourceMaterialError extends Error {
-  readonly diagnostics: readonly ResourceDiagnostic[];
-  constructor(diagnostics: readonly ResourceDiagnostic[]);
-}
-declare function readResourceMaterial(input: ReadResourceMaterialInput): Promise<ResourceMaterial>;
-//#endregion
-export { ResolveEffectiveResourceContentIdentitiesInput as a, ResourceCompositionError as c, readResourceMaterial as i, ResourceMaterial as n, ResourceLayerContentIdentityInput as o, ResourceMaterialError as r, resolveEffectiveResourceContentIdentities as s, ReadResourceMaterialInput as t };