halfcode-compiler.xnl 0.2.8 → 0.3.0

package/dist/kind-definition.js

@@ -1,34 +1,845 @@
+import { C as digestCanonical, S as compareCodeUnits, s as CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS } from "./src-jggOQtq3.js";
+//#region ../kind-definition/src/versioned-contracts.ts
+var KindContractRegistry = class {
+	ownersByKind = /* @__PURE__ */ new Map();
+	ownersBySubject = /* @__PURE__ */ new Map();
+	revisionsBySubject = /* @__PURE__ */ new Map();
+	registerOwner(input) {
+		const owner = freezeOwner(input);
+		const byKind = this.ownersByKind.get(owner.kind);
+		const bySubject = this.ownersBySubject.get(owner.subjectFqn);
+		if (byKind && !sameOwner(byKind, owner) || bySubject && !sameOwner(bySubject, owner)) fail$1("KIND_SUBJECT_OWNER_CONFLICT", `Kind '${owner.kind}' or subject '${owner.subjectFqn}' already has a different owner.`);
+		this.ownersByKind.set(owner.kind, owner);
+		this.ownersBySubject.set(owner.subjectFqn, owner);
+		return this;
+	}
+	registerRevision(input) {
+		const revision = freezeRevision(input);
+		const owner = this.ownersBySubject.get(revision.subjectFqn);
+		if (!owner || owner.kind !== revision.kind) fail$1("KIND_SPEC_OWNER_NOT_ADMITTED", `Subject '${revision.subjectFqn}' has no admitted owner for Kind '${revision.kind}'.`);
+		if (revision.sourceContractFingerprint !== owner.sourceContract.sourceContractFingerprint) fail$1("KIND_SPEC_SOURCE_CONTRACT_MISMATCH", `Revision '${revision.subjectFqn}@${revision.specVersion}' does not bind its admitted owner source contract.`);
+		const revisions = this.revisionsBySubject.get(revision.subjectFqn) ?? /* @__PURE__ */ new Map();
+		const previous = revisions.get(revision.specVersion);
+		if (previous) {
+			if (previous.contractFingerprint !== revision.contractFingerprint || previous.schemaFingerprint !== revision.schemaFingerprint || digestCanonical(previous.specSchema) !== digestCanonical(revision.specSchema)) fail$1("KIND_SPEC_CONTRACT_CONFLICT", `Revision '${revision.subjectFqn}@${revision.specVersion}' is immutable.`);
+			return this;
+		}
+		revisions.set(revision.specVersion, revision);
+		this.revisionsBySubject.set(revision.subjectFqn, revisions);
+		return this;
+	}
+	subject(kind) {
+		const value = this.ownersByKind.get(nonEmpty(kind, "kind"));
+		if (!value) fail$1("KIND_SUBJECT_MISSING", `No admitted subject owns Kind '${kind}'.`);
+		return value;
+	}
+	owner(subjectFqn) {
+		const value = this.ownersBySubject.get(nonEmpty(subjectFqn, "subjectFqn"));
+		if (!value) fail$1("KIND_SUBJECT_MISSING", `No admitted owner exists for subject '${subjectFqn}'.`);
+		return value;
+	}
+	revision(subjectFqn, specVersion) {
+		const version = exactSpecVersion(specVersion);
+		const value = this.revisionsBySubject.get(nonEmpty(subjectFqn, "subjectFqn"))?.get(version);
+		if (!value) fail$1("KIND_SPEC_REVISION_MISSING", `Revision '${subjectFqn}@${version}' is not registered.`);
+		return value;
+	}
+	owners() {
+		return Object.freeze([...this.ownersBySubject.values()].sort((left, right) => compare(left.subjectFqn, right.subjectFqn)));
+	}
+	revisions(subjectFqn) {
+		const values = subjectFqn ? [...this.revisionsBySubject.get(subjectFqn)?.values() ?? []] : [...this.revisionsBySubject.values()].flatMap((revisions) => [...revisions.values()]);
+		return Object.freeze(values.sort((left, right) => compare(left.subjectFqn, right.subjectFqn) || left.specVersion - right.specVersion));
+	}
+};
+var KindWriterRegistry = class {
+	contracts;
+	registrations = /* @__PURE__ */ new Map();
+	constructor(contracts) {
+		this.contracts = contracts;
+	}
+	register(input) {
+		const subjectFqn = nonEmpty(input.subjectFqn, "writer.subjectFqn");
+		const writerSpecVersion = exactSpecVersion(input.writerSpecVersion);
+		const contractFingerprint = validateFingerprint(input.contractFingerprint, "writer.contractFingerprint");
+		if (typeof input.write !== "function") fail$1("KIND_WRITER_INVALID", "Writer registration requires a write function.");
+		if (this.contracts.revision(subjectFqn, writerSpecVersion).contractFingerprint !== contractFingerprint) fail$1("KIND_WRITER_CONTRACT_MISMATCH", `Writer '${subjectFqn}@${writerSpecVersion}' contract fingerprint does not match its revision.`);
+		const key = revisionKey(subjectFqn, writerSpecVersion);
+		const previous = this.registrations.get(key);
+		if (previous && (previous.contractFingerprint !== contractFingerprint || previous.write !== input.write)) fail$1("KIND_WRITER_REGISTRATION_CONFLICT", `Writer '${key}' is already registered with a different implementation.`);
+		this.registrations.set(key, Object.freeze({
+			subjectFqn,
+			writerSpecVersion,
+			contractFingerprint,
+			write: input.write
+		}));
+		return this;
+	}
+	require(subjectFqn, writerSpecVersion) {
+		const key = revisionKey(nonEmpty(subjectFqn, "subjectFqn"), exactSpecVersion(writerSpecVersion));
+		const writer = this.registrations.get(key);
+		if (!writer) fail$1("KIND_WRITER_MISSING", `Writer '${key}' is not registered.`);
+		return writer;
+	}
+};
+var KindReaderRegistry = class {
+	registrations = /* @__PURE__ */ new Map();
+	register(input) {
+		const registration = freezeReader(input);
+		const previous = this.registrations.get(registration.readerId);
+		if (previous && !sameReader(previous, registration)) fail$1("KIND_READER_REGISTRATION_CONFLICT", `Reader '${registration.readerId}' is already registered with a different contract.`);
+		this.registrations.set(registration.readerId, registration);
+		return this;
+	}
+	require(target) {
+		const exactTarget = freezeTarget(target);
+		const reader = this.registrations.get(exactTarget.readerId);
+		if (!reader) fail$1("KIND_READER_MISSING", `Reader '${exactTarget.readerId}' is not registered.`);
+		if (reader.subjectFqn !== exactTarget.subjectFqn || reader.readerSpecVersion !== exactTarget.readerSpecVersion) fail$1("KIND_READER_TARGET_MISMATCH", `Reader '${exactTarget.readerId}' does not implement the requested subject/version.`);
+		if (reader.contractFingerprint !== exactTarget.contractFingerprint || reader.readerImplementationFingerprint !== exactTarget.readerImplementationFingerprint) fail$1("KIND_READER_FINGERPRINT_MISMATCH", `Reader '${exactTarget.readerId}' fingerprint does not match its target.`);
+		return reader;
+	}
+	all() {
+		return Object.freeze([...this.registrations.values()].sort((left, right) => compare(left.readerId, right.readerId)));
+	}
+};
+var ExactReaderProfile = class {
+	profileId;
+	readers;
+	constructor(profileId, targets) {
+		this.profileId = profileId;
+		nonEmpty(profileId, "profileId");
+		const readers = /* @__PURE__ */ new Map();
+		for (const input of targets) {
+			const target = freezeTarget(input);
+			if (readers.has(target.subjectFqn)) fail$1("KIND_READER_TARGET_CONFLICT", `Profile '${profileId}' declares subject '${target.subjectFqn}' more than once.`);
+			readers.set(target.subjectFqn, target);
+		}
+		this.readers = readonlyMap$1(readers);
+		Object.freeze(this);
+	}
+	readerFor(subjectFqn) {
+		const target = this.readers.get(subjectFqn);
+		if (!target) fail$1("KIND_READER_TARGET_MISSING", `Profile '${this.profileId}' has no reader for '${subjectFqn}'.`);
+		return target;
+	}
+};
+function createReaderProfile(profileId, targets) {
+	return new ExactReaderProfile(profileId, targets);
+}
+var SpecResolutionRegistry = class {
+	contracts;
+	definitions = [];
+	ids = /* @__PURE__ */ new Set();
+	constructor(contracts) {
+		this.contracts = contracts;
+	}
+	register(input) {
+		const definition = freezeResolution(input);
+		if (this.ids.has(definition.id)) fail$1("SPEC_RESOLUTION_ID_CONFLICT", `Resolution '${definition.id}' is already registered.`);
+		const owner = this.contracts.owner(definition.subjectFqn);
+		if (owner.ownerPackageId !== definition.ownerPackageId || owner.ownerPackageFingerprint !== definition.ownerPackageFingerprint) fail$1("SPEC_RESOLUTION_OWNER_NOT_ADMITTED", `Resolution '${definition.id}' is not provided by admitted owner '${owner.ownerPackageId}'.`);
+		const writer = this.contracts.revision(definition.subjectFqn, definition.writerSpecVersion);
+		const reader = this.contracts.revision(definition.subjectFqn, definition.readerSpecVersion);
+		if (writer.contractFingerprint !== definition.writerContractFingerprint || reader.contractFingerprint !== definition.readerContractFingerprint) fail$1("SPEC_RESOLUTION_ENDPOINT_MISMATCH", `Resolution '${definition.id}' endpoint fingerprint does not match its revisions.`);
+		if (definition.writerSpecVersion === definition.readerSpecVersion) fail$1("SPEC_RESOLUTION_IDENTITY_EXPLICIT", "Same-version resolution is implicit and must not register executable code.");
+		const sameEndpoints = this.definitions.find((candidate) => candidate.subjectFqn === definition.subjectFqn && candidate.writerSpecVersion === definition.writerSpecVersion && candidate.readerSpecVersion === definition.readerSpecVersion);
+		if (sameEndpoints) fail$1("SPEC_RESOLUTION_EDGE_CONFLICT", `Resolution edge '${definition.subjectFqn}' ${definition.writerSpecVersion}→${definition.readerSpecVersion} is already owned by '${sameEndpoints.id}'.`);
+		this.ids.add(definition.id);
+		this.definitions.push(definition);
+		return this;
+	}
+	plan(subjectFqn, writerSpecVersion, readerSpecVersion) {
+		const from = exactSpecVersion(writerSpecVersion);
+		const to = exactSpecVersion(readerSpecVersion);
+		this.contracts.revision(subjectFqn, from);
+		this.contracts.revision(subjectFqn, to);
+		if (from === to) return Object.freeze([]);
+		this.validateGraph(subjectFqn);
+		const paths = [];
+		const visit = (version, path, seen) => {
+			if (paths.length > 1) return;
+			if (version === to) {
+				paths.push(path);
+				return;
+			}
+			for (const edge of this.outgoing(subjectFqn, version)) {
+				if (seen.has(edge.readerSpecVersion)) continue;
+				visit(edge.readerSpecVersion, [...path, edge], /* @__PURE__ */ new Set([...seen, edge.readerSpecVersion]));
+			}
+		};
+		visit(from, [], /* @__PURE__ */ new Set([from]));
+		if (paths.length === 0) fail$1("SPEC_RESOLUTION_PATH_MISSING", `No resolution path exists for '${subjectFqn}' ${from}→${to}.`);
+		if (paths.length > 1) fail$1("SPEC_RESOLUTION_PATH_AMBIGUOUS", `More than one resolution path exists for '${subjectFqn}' ${from}→${to}.`);
+		return Object.freeze([...paths[0]]);
+	}
+	validateGraph(subjectFqn) {
+		const subjects = subjectFqn ? [subjectFqn] : [...new Set(this.definitions.map((definition) => definition.subjectFqn))];
+		for (const subject of subjects) {
+			const visiting = /* @__PURE__ */ new Set();
+			const visited = /* @__PURE__ */ new Set();
+			const walk = (version) => {
+				if (visiting.has(version)) fail$1("SPEC_RESOLUTION_GRAPH_CYCLIC", `Resolution graph for '${subject}' contains a cycle at version ${version}.`);
+				if (visited.has(version)) return;
+				visiting.add(version);
+				for (const edge of this.outgoing(subject, version)) walk(edge.readerSpecVersion);
+				visiting.delete(version);
+				visited.add(version);
+			};
+			for (const revision of this.contracts.revisions(subject)) walk(revision.specVersion);
+		}
+	}
+	validateReaderCompatibility(registration) {
+		const target = registration.readerSpecVersion;
+		if (registration.compatibilityPolicy === "exact") return;
+		const older = this.contracts.revisions(registration.subjectFqn).filter((revision) => revision.specVersion < target);
+		if (registration.compatibilityPolicy === "backward") {
+			const previous = older.at(-1);
+			if (previous && this.plan(registration.subjectFqn, previous.specVersion, target).length !== 1) fail$1("KIND_READER_BACKWARD_COVERAGE_INVALID", `Reader '${registration.readerId}' requires one direct previous-version resolution.`);
+			return;
+		}
+		for (const revision of older) this.plan(registration.subjectFqn, revision.specVersion, target);
+	}
+	all() {
+		return Object.freeze([...this.definitions].sort((left, right) => compare(left.subjectFqn, right.subjectFqn) || left.writerSpecVersion - right.writerSpecVersion || left.readerSpecVersion - right.readerSpecVersion || compare(left.id, right.id)));
+	}
+	outgoing(subjectFqn, writerSpecVersion) {
+		return this.definitions.filter((definition) => definition.subjectFqn === subjectFqn && definition.writerSpecVersion === writerSpecVersion).sort((left, right) => left.readerSpecVersion - right.readerSpecVersion || compare(left.id, right.id));
+	}
+};
+function resolveSpec(input) {
+	const resourceId = nonEmpty(input.resourceId, "resourceId");
+	const owner = input.contracts.subject(input.kind);
+	const writer = input.contracts.revision(owner.subjectFqn, input.writerSpecVersion);
+	validateFingerprint(input.sourceContentDigest, "sourceContentDigest");
+	let resolvedSpec = clonePortableSpec(input.authoredSpec);
+	validateSchema(input.validator, writer, resolvedSpec, "WRITER_SCHEMA_INVALID");
+	const target = input.readerProfile.readerFor(owner.subjectFqn);
+	const reader = input.readers.require(target);
+	const readerRevision = input.contracts.revision(owner.subjectFqn, reader.readerSpecVersion);
+	if (readerRevision.contractFingerprint !== reader.contractFingerprint) fail$1("KIND_READER_CONTRACT_MISMATCH", `Reader '${reader.readerId}' contract fingerprint does not match revision ${reader.readerSpecVersion}.`);
+	input.resolutions.validateReaderCompatibility(reader);
+	if (reader.compatibilityPolicy === "exact" && writer.specVersion !== reader.readerSpecVersion) fail$1("KIND_READER_EXACT_VERSION_REQUIRED", `Reader '${reader.readerId}' only accepts writer version ${reader.readerSpecVersion}.`);
+	if (reader.compatibilityPolicy !== "exact" && writer.specVersion > reader.readerSpecVersion) fail$1("KIND_READER_FORWARD_VERSION_UNSUPPORTED", `Reader '${reader.readerId}' uses '${reader.compatibilityPolicy}' compatibility and cannot read newer writer version ${writer.specVersion}.`);
+	const path = input.resolutions.plan(owner.subjectFqn, writer.specVersion, reader.readerSpecVersion);
+	if (reader.compatibilityPolicy === "backward" && path.length > 1) fail$1("KIND_READER_BACKWARD_PATH_NOT_DIRECT", `Reader '${reader.readerId}' requires a direct resolution.`);
+	for (const edge of path) {
+		const next = clonePortableSpec(edge.resolve(resolvedSpec));
+		const targetRevision = input.contracts.revision(owner.subjectFqn, edge.readerSpecVersion);
+		validateSchema(input.validator, targetRevision, next, "SPEC_RESOLUTION_TARGET_SCHEMA_INVALID");
+		resolvedSpec = next;
+	}
+	validateSchema(input.validator, readerRevision, resolvedSpec, "READER_SCHEMA_INVALID");
+	const readerValue = reader.read(resolvedSpec);
+	const resolvedSpecDigest = digestCanonical(resolvedSpec);
+	const pathReceipt = Object.freeze(path.map((edge) => Object.freeze({
+		resolutionId: edge.id,
+		resolutionFingerprint: edge.resolutionFingerprint
+	})));
+	const receipt = Object.freeze({
+		resourceId,
+		subjectFqn: owner.subjectFqn,
+		sourceContentDigest: input.sourceContentDigest,
+		writer: Object.freeze({
+			specVersion: writer.specVersion,
+			schemaFingerprint: writer.schemaFingerprint,
+			contractFingerprint: writer.contractFingerprint,
+			sourceContractFingerprint: writer.sourceContractFingerprint
+		}),
+		reader: Object.freeze({
+			readerId: reader.readerId,
+			specVersion: reader.readerSpecVersion,
+			schemaFingerprint: readerRevision.schemaFingerprint,
+			contractFingerprint: reader.contractFingerprint,
+			implementationFingerprint: reader.readerImplementationFingerprint,
+			sourceContractFingerprint: readerRevision.sourceContractFingerprint
+		}),
+		path: pathReceipt,
+		resolvedSpecDigest
+	});
+	return Object.freeze({
+		resolvedSpec,
+		readerValue,
+		receipt,
+		effectiveContentDigest: digestCanonical({
+			sourceContentDigest: input.sourceContentDigest,
+			writer: receipt.writer,
+			reader: receipt.reader,
+			path: pathReceipt,
+			resolvedSpecDigest
+		})
+	});
+}
+function createKindContractLock(input) {
+	const envelopeVersion = nonEmpty(input.envelopeVersion, "envelopeVersion");
+	const envelopeFingerprint = validateFingerprint(input.envelopeFingerprint, "envelopeFingerprint");
+	const owners = Object.freeze(input.contracts.owners().map(freezeOwner));
+	const readers = Object.freeze([...input.readerProfile.readers.values()].map((target) => {
+		const reader = input.readers.require(target);
+		if (input.contracts.revision(target.subjectFqn, target.readerSpecVersion).contractFingerprint !== target.contractFingerprint) fail$1("KIND_READER_CONTRACT_MISMATCH", `Reader target '${target.readerId}' does not match revision '${target.subjectFqn}@${target.readerSpecVersion}'.`);
+		input.resolutions.validateReaderCompatibility(reader);
+		return Object.freeze({
+			...freezeTarget(target),
+			compatibilityPolicy: reader.compatibilityPolicy
+		});
+	}).sort((left, right) => compare(left.subjectFqn, right.subjectFqn)));
+	const revisions = Object.freeze(input.contracts.revisions().map((revision) => {
+		const owner = input.contracts.owner(revision.subjectFqn);
+		return Object.freeze({
+			subjectFqn: revision.subjectFqn,
+			specVersion: revision.specVersion,
+			schemaFingerprint: revision.schemaFingerprint,
+			contractFingerprint: revision.contractFingerprint,
+			ownerPackageId: owner.ownerPackageId,
+			ownerPackageFingerprint: owner.ownerPackageFingerprint,
+			sourceContractFingerprint: revision.sourceContractFingerprint
+		});
+	}));
+	input.resolutions.validateGraph();
+	const facts = {
+		envelopeVersion,
+		envelopeFingerprint,
+		owners,
+		readers,
+		revisions,
+		resolutions: Object.freeze(input.resolutions.all().map((resolution) => Object.freeze({
+			resolutionId: resolution.id,
+			subjectFqn: resolution.subjectFqn,
+			writerSpecVersion: resolution.writerSpecVersion,
+			readerSpecVersion: resolution.readerSpecVersion,
+			resolutionFingerprint: resolution.resolutionFingerprint
+		})))
+	};
+	return Object.freeze({
+		...facts,
+		lockDigest: digestCanonical(facts)
+	});
+}
+function exactSpecVersion(value) {
+	if (!Number.isSafeInteger(value) || value <= 0) fail$1("SPEC_VERSION_INVALID", "specVersion must be a positive safe integer.");
+	return value;
+}
+function createKindSubjectOwner(input) {
+	const kind = nonEmpty(input.kind, "owner.kind");
+	const subjectFqn = nonEmpty(input.subjectFqn, "owner.subjectFqn");
+	const ownerPackageId = nonEmpty(input.ownerPackageId, "owner.ownerPackageId");
+	const ownerPackageFingerprint = validateFingerprint(input.ownerPackageFingerprint, "owner.ownerPackageFingerprint");
+	const sourceShapes = Object.freeze([...new Set(input.sourceShapes.map((shape) => validateSourceShape(shape)))].sort(compare));
+	if (sourceShapes.length === 0) fail$1("KIND_SOURCE_CONTRACT_INVALID", "Kind source contract requires at least one source shape.");
+	const documentCardinality = input.documentCardinality ?? "one";
+	if (documentCardinality !== "one" && documentCardinality !== "many") fail$1("KIND_SOURCE_CONTRACT_INVALID", `Unknown document cardinality '${documentCardinality}'.`);
+	if (documentCardinality === "many" && (sourceShapes.length !== 1 || sourceShapes[0] !== "single-file")) fail$1("KIND_SOURCE_CONTRACT_INVALID", "documentCardinality 'many' requires exactly the single-file source shape.");
+	const requiredFiles = Object.freeze([...new Set((input.requiredFiles ?? []).map((name) => nonEmpty(name, "owner.requiredFile")))].sort(compare));
+	const sourceFacts = Object.freeze({
+		sourceShapes,
+		documentCardinality,
+		requiredFiles
+	});
+	const sourceContract = Object.freeze({
+		...sourceFacts,
+		sourceContractFingerprint: digestCanonical(sourceFacts)
+	});
+	return Object.freeze({
+		kind,
+		subjectFqn,
+		ownerPackageId,
+		ownerPackageFingerprint,
+		sourceContract
+	});
+}
+function createKindSpecRevision(input) {
+	const kind = nonEmpty(input.kind, "revision.kind");
+	const subjectFqn = nonEmpty(input.subjectFqn, "revision.subjectFqn");
+	const specVersion = exactSpecVersion(input.specVersion);
+	const specSchema = cloneJson(input.specSchema);
+	const semanticContract = freezeSemanticContract(input.semanticContract);
+	const sourceContractFingerprint = validateFingerprint(input.sourceContractFingerprint, "revision.sourceContractFingerprint");
+	const schemaFingerprint = digestCanonical(specSchema);
+	return Object.freeze({
+		kind,
+		subjectFqn,
+		specVersion,
+		specSchema,
+		semanticContract,
+		sourceContractFingerprint,
+		schemaFingerprint,
+		contractFingerprint: digestCanonical({
+			kind,
+			subjectFqn,
+			specVersion,
+			schemaFingerprint,
+			semanticContract,
+			sourceContractFingerprint
+		}),
+		stability: input.stability
+	});
+}
+function validateSchema(validator, revision, value, code) {
+	const issues = validator.validate(revision, value);
+	if (issues.length > 0) fail$1(code, `${revision.subjectFqn}@${revision.specVersion}: ${issues.join("; ")}`);
+}
+function freezeOwner(input) {
+	const owner = createKindSubjectOwner({
+		kind: input.kind,
+		subjectFqn: input.subjectFqn,
+		ownerPackageId: input.ownerPackageId,
+		ownerPackageFingerprint: input.ownerPackageFingerprint,
+		sourceShapes: input.sourceContract.sourceShapes,
+		documentCardinality: input.sourceContract.documentCardinality,
+		requiredFiles: input.sourceContract.requiredFiles
+	});
+	if (owner.sourceContract.sourceContractFingerprint !== validateFingerprint(input.sourceContract.sourceContractFingerprint, "owner.sourceContract.sourceContractFingerprint")) fail$1("KIND_SOURCE_CONTRACT_FINGERPRINT_MISMATCH", `Kind '${owner.kind}' source contract fingerprint is not canonical.`);
+	return owner;
+}
+function freezeRevision(input) {
+	const revision = createKindSpecRevision({
+		kind: nonEmpty(input.kind, "revision.kind"),
+		subjectFqn: nonEmpty(input.subjectFqn, "revision.subjectFqn"),
+		specVersion: exactSpecVersion(input.specVersion),
+		specSchema: cloneJson(input.specSchema),
+		semanticContract: input.semanticContract,
+		sourceContractFingerprint: input.sourceContractFingerprint,
+		stability: input.stability
+	});
+	if (revision.schemaFingerprint !== validateFingerprint(input.schemaFingerprint, "revision.schemaFingerprint") || revision.contractFingerprint !== validateFingerprint(input.contractFingerprint, "revision.contractFingerprint")) fail$1("KIND_SPEC_FINGERPRINT_MISMATCH", `Revision '${revision.subjectFqn}@${revision.specVersion}' fingerprints do not match canonical contract content.`);
+	return revision;
+}
+function freezeReader(input) {
+	if (typeof input.read !== "function") fail$1("KIND_READER_INVALID", "Reader registration requires a read function.");
+	if (![
+		"exact",
+		"backward",
+		"backward-transitive"
+	].includes(input.compatibilityPolicy)) fail$1("KIND_READER_POLICY_INVALID", `Unknown compatibility policy '${input.compatibilityPolicy}'.`);
+	return Object.freeze({
+		readerId: nonEmpty(input.readerId, "reader.readerId"),
+		subjectFqn: nonEmpty(input.subjectFqn, "reader.subjectFqn"),
+		readerSpecVersion: exactSpecVersion(input.readerSpecVersion),
+		contractFingerprint: validateFingerprint(input.contractFingerprint, "reader.contractFingerprint"),
+		readerImplementationFingerprint: validateFingerprint(input.readerImplementationFingerprint, "reader.readerImplementationFingerprint"),
+		compatibilityPolicy: input.compatibilityPolicy,
+		read: input.read
+	});
+}
+function freezeTarget(input) {
+	return Object.freeze({
+		readerId: nonEmpty(input.readerId, "target.readerId"),
+		subjectFqn: nonEmpty(input.subjectFqn, "target.subjectFqn"),
+		readerSpecVersion: exactSpecVersion(input.readerSpecVersion),
+		contractFingerprint: validateFingerprint(input.contractFingerprint, "target.contractFingerprint"),
+		readerImplementationFingerprint: validateFingerprint(input.readerImplementationFingerprint, "target.readerImplementationFingerprint")
+	});
+}
+function freezeResolution(input) {
+	if (typeof input.resolve !== "function") fail$1("SPEC_RESOLUTION_INVALID", "Resolution registration requires a resolve function.");
+	return Object.freeze({
+		id: nonEmpty(input.id, "resolution.id"),
+		subjectFqn: nonEmpty(input.subjectFqn, "resolution.subjectFqn"),
+		ownerPackageId: nonEmpty(input.ownerPackageId, "resolution.ownerPackageId"),
+		ownerPackageFingerprint: validateFingerprint(input.ownerPackageFingerprint, "resolution.ownerPackageFingerprint"),
+		writerSpecVersion: exactSpecVersion(input.writerSpecVersion),
+		readerSpecVersion: exactSpecVersion(input.readerSpecVersion),
+		writerContractFingerprint: validateFingerprint(input.writerContractFingerprint, "resolution.writerContractFingerprint"),
+		readerContractFingerprint: validateFingerprint(input.readerContractFingerprint, "resolution.readerContractFingerprint"),
+		resolutionFingerprint: validateFingerprint(input.resolutionFingerprint, "resolution.resolutionFingerprint"),
+		resolve: input.resolve
+	});
+}
+function freezeSemanticContract(input) {
+	return Object.freeze({
+		semanticValidatorFingerprint: validateFingerprint(input.semanticValidatorFingerprint, "semanticContract.semanticValidatorFingerprint"),
+		referenceProjectionFingerprint: validateFingerprint(input.referenceProjectionFingerprint, "semanticContract.referenceProjectionFingerprint"),
+		compilerInputFingerprint: validateFingerprint(input.compilerInputFingerprint, "semanticContract.compilerInputFingerprint")
+	});
+}
+function sameOwner(left, right) {
+	return left.kind === right.kind && left.subjectFqn === right.subjectFqn && left.ownerPackageId === right.ownerPackageId && left.ownerPackageFingerprint === right.ownerPackageFingerprint && left.sourceContract.sourceContractFingerprint === right.sourceContract.sourceContractFingerprint;
+}
+function validateSourceShape(value) {
+	if (value === "single-file" || value === "directory" || value === "manifest") return value;
+	fail$1("KIND_SOURCE_CONTRACT_INVALID", `Unknown source shape '${value}'.`);
+}
+function sameReader(left, right) {
+	return left.readerId === right.readerId && left.subjectFqn === right.subjectFqn && left.readerSpecVersion === right.readerSpecVersion && left.contractFingerprint === right.contractFingerprint && left.readerImplementationFingerprint === right.readerImplementationFingerprint && left.compatibilityPolicy === right.compatibilityPolicy && left.read === right.read;
+}
+function validateFingerprint(value, label) {
+	if (!/^sha256:[0-9a-f]{64}$/u.test(value)) fail$1("CONTRACT_FINGERPRINT_INVALID", `${label} must be a lowercase SHA-256 digest.`);
+	return value;
+}
+function nonEmpty(value, label) {
+	if (typeof value !== "string" || value.trim().length === 0) fail$1("CONTRACT_FIELD_INVALID", `${label} must be a non-empty string.`);
+	return value.trim();
+}
+function compare(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function revisionKey(subjectFqn, specVersion) {
+	return `${subjectFqn}@${specVersion}`;
+}
+function readonlyMap$1(source) {
+	const target = new Map(source);
+	return Object.freeze({
+		get size() {
+			return target.size;
+		},
+		has: (key) => target.has(key),
+		get: (key) => target.get(key),
+		forEach: (callback, thisArg) => {
+			target.forEach((value, key) => callback.call(thisArg, value, key, target));
+		},
+		entries: () => target.entries(),
+		keys: () => target.keys(),
+		values: () => target.values(),
+		[Symbol.iterator]: () => target[Symbol.iterator]()
+	});
+}
+function clonePortableSpec(value) {
+	const cloned = cloneJson(value);
+	if (!cloned || Array.isArray(cloned) || typeof cloned !== "object") fail$1("PORTABLE_SPEC_INVALID", "Spec must be a JSON-compatible object.");
+	return cloned;
+}
+function cloneJson(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) fail$1("PORTABLE_VALUE_INVALID", "Portable values require finite numbers.");
+		return value;
+	}
+	if (Array.isArray(value)) return Object.freeze(value.map(cloneJson));
+	if (typeof value === "object") {
+		const output = {};
+		for (const key of Object.keys(value).sort(compare)) {
+			const item = value[key];
+			if (item !== void 0) output[key] = cloneJson(item);
+		}
+		return Object.freeze(output);
+	}
+	fail$1("PORTABLE_VALUE_INVALID", `Unsupported portable value type '${typeof value}'.`);
+}
+function fail$1(code, message) {
+	throw new Error(`${code}: ${message}`);
+}
+//#endregion
+//#region ../kind-definition/src/resource-tree-resolution.ts
+function resolveResourceTree(input) {
+	admitKindDefinitionDescriptions(input);
+	const authored = uniqueAuthoredRecords(input.tree);
+	const resolvedById = /* @__PURE__ */ new Map();
+	for (const source of authored) {
+		const owner = input.contracts.subject(source.kind);
+		if (source.subjectFqn !== owner.subjectFqn) fail("AUTHORED_RESOURCE_SUBJECT_MISMATCH", `Resource '${source.resourceId}' was decoded as '${source.subjectFqn}' but admitted Kind '${source.kind}' owns '${owner.subjectFqn}'.`);
+		const result = resolveSpec({
+			resourceId: source.resourceId,
+			kind: source.kind,
+			writerSpecVersion: source.metadata.specVersion,
+			authoredSpec: source.authoredSpec,
+			sourceContentDigest: source.sourceContentDigest,
+			readerProfile: input.readerProfile,
+			contracts: input.contracts,
+			readers: input.readers,
+			resolutions: input.resolutions,
+			validator: input.validator
+		});
+		const record = Object.freeze({
+			stage: "resolved",
+			kind: source.kind,
+			subjectFqn: owner.subjectFqn,
+			resourceId: source.resourceId,
+			fqn: source.fqn,
+			...source.name ? { name: source.name } : {},
+			...source.description ? { description: source.description } : {},
+			metadata: source.metadata,
+			sourceShape: source.sourceShape,
+			logicalPath: source.logicalPath,
+			documentUri: source.documentUri,
+			format: source.format,
+			node: resolvedNode(source.node, result.resolvedSpec),
+			source,
+			readerId: result.receipt.reader.readerId,
+			readerSpecVersion: result.receipt.reader.specVersion,
+			resolvedSpec: result.resolvedSpec,
+			readerValue: result.readerValue,
+			resolution: result.receipt,
+			effectiveContentDigest: result.effectiveContentDigest
+		});
+		resolvedById.set(record.resourceId, record);
+	}
+	const manifest = resolvedById.get(input.tree.manifest.resourceId);
+	if (!manifest) fail("RESOLVED_MANIFEST_MISSING", `Manifest '${input.tree.manifest.resourceId}' was not resolved.`);
+	const byKind = /* @__PURE__ */ new Map();
+	for (const [kind, records] of input.tree.registry.byKind) byKind.set(kind, Object.freeze(records.map((record) => {
+		const resolved = resolvedById.get(record.resourceId);
+		if (!resolved) fail("RESOLVED_RESOURCE_MISSING", `Resource '${record.resourceId}' was not resolved.`);
+		return resolved;
+	})));
+	const receipts = Object.freeze([...resolvedById.values()].sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId)).map((record) => record.resolution));
+	const effectiveContentIdentities = readonlyMap([...resolvedById.values()].sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId)).map((record) => [record.resourceId, record.effectiveContentDigest]));
+	return Object.freeze({
+		stage: "resolved",
+		source: input.tree,
+		manifest,
+		registry: Object.freeze({
+			byKind: readonlyMap([...byKind.entries()].sort(([left], [right]) => compareCodeUnits(left, right))),
+			kindDefinitions: input.tree.registry.kindDefinitions
+		}),
+		diagnostics: Object.freeze([]),
+		readerProfileId: input.readerProfile.profileId,
+		receipts,
+		effectiveContentIdentities
+	});
+}
+function admitKindDefinitionDescriptions(input) {
+	for (const definition of input.tree.registry.kindDefinitions.values()) {
+		const owner = input.contracts.subject(definition.resourceKind);
+		if (owner.subjectFqn !== definition.subjectFqn) fail("KIND_DEFINITION_SUBJECT_MISMATCH", `KindDefinition '${definition.resourceId}' describes '${definition.subjectFqn}', admitted owner describes '${owner.subjectFqn}'.`);
+		const expectedSource = owner.sourceContract;
+		const actualSourceShapes = Object.freeze([...new Set(definition.sourceShapes)].sort(compareCodeUnits));
+		const actualRequiredFiles = Object.freeze([...new Set(definition.requiredFiles)].sort(compareCodeUnits));
+		if (actualSourceShapes.length !== expectedSource.sourceShapes.length || actualSourceShapes.some((shape, index) => shape !== expectedSource.sourceShapes[index]) || definition.documentCardinality !== expectedSource.documentCardinality || actualRequiredFiles.length !== expectedSource.requiredFiles.length || actualRequiredFiles.some((name, index) => name !== expectedSource.requiredFiles[index])) fail("KIND_DEFINITION_SOURCE_CONTRACT_MISMATCH", `KindDefinition '${definition.resourceId}' source shapes, cardinality, or required files differ from admitted owner '${owner.subjectFqn}'.`);
+		if (input.contracts.revisions(definition.subjectFqn).length !== definition.specRevisions.length) fail("KIND_DEFINITION_REVISION_SET_MISMATCH", `KindDefinition '${definition.resourceId}' revision set does not match admitted registrations.`);
+		for (const descriptor of definition.specRevisions) {
+			const revision = input.contracts.revision(definition.subjectFqn, descriptor.specVersion);
+			if (revision.schemaFingerprint !== descriptor.schemaFingerprint || revision.contractFingerprint !== descriptor.contractFingerprint || revision.stability !== descriptor.stability || revision.semanticContract.semanticValidatorFingerprint !== descriptor.semanticContract.semanticValidatorFingerprint || revision.semanticContract.referenceProjectionFingerprint !== descriptor.semanticContract.referenceProjectionFingerprint || revision.semanticContract.compilerInputFingerprint !== descriptor.semanticContract.compilerInputFingerprint) fail("KIND_DEFINITION_REVISION_MISMATCH", `KindDefinition '${definition.resourceId}' revision ${descriptor.specVersion} differs from admitted contract content.`);
+		}
+	}
+}
+function uniqueAuthoredRecords(tree) {
+	const byId = /* @__PURE__ */ new Map([[tree.manifest.resourceId, tree.manifest]]);
+	for (const records of tree.registry.byKind.values()) for (const record of records) byId.set(record.resourceId, record);
+	return Object.freeze([...byId.values()].sort((left, right) => compareCodeUnits(left.resourceId, right.resourceId)));
+}
+function resolvedNode(source, spec) {
+	return Object.freeze({
+		...source,
+		properties: asResourceMap(spec.properties, source.properties),
+		body: asResourceList(spec.body, source.body),
+		subdomains: asResourceNodeMap(spec.subdomains, source.subdomains),
+		...typeof spec.text === "string" ? { text: spec.text } : source.text === void 0 ? {} : { text: source.text }
+	});
+}
+function asResourceMap(value, fallback) {
+	return isRecord(value) ? value : fallback;
+}
+function asResourceList(value, fallback) {
+	return Array.isArray(value) ? value : fallback;
+}
+function asResourceNodeMap(value, fallback) {
+	return isRecord(value) ? value : fallback;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readonlyMap(entries) {
+	const target = new Map(entries);
+	return Object.freeze({
+		get size() {
+			return target.size;
+		},
+		has: (key) => target.has(key),
+		get: (key) => target.get(key),
+		forEach: (callback, thisArg) => {
+			target.forEach((value, key) => callback.call(thisArg, value, key, target));
+		},
+		entries: () => target.entries(),
+		keys: () => target.keys(),
+		values: () => target.values(),
+		[Symbol.iterator]: () => target[Symbol.iterator]()
+	});
+}
+function fail(code, message) {
+	throw new Error(`${code}: ${message}`);
+}
+//#endregion
+//#region ../kind-definition/src/core-kind-contracts.ts
+const CORE_KIND_OWNER_PACKAGE_ID = "halfcode-compiler.xnl";
+const CORE_KIND_OWNER_PACKAGE_FINGERPRINT = digestCanonical(Object.freeze({
+	authority: "halfcode-compiler.xnl/core-kind-contracts/v1",
+	ownerPackageId: CORE_KIND_OWNER_PACKAGE_ID,
+	subjects: Object.freeze(["Halfcode.ResourceKind.KindDefinition", "Halfcode.ResourceKind.ResourcePackage"])
+}));
+const RESOURCE_PACKAGE_KIND_OWNER = createKindSubjectOwner({
+	kind: "ResourcePackage",
+	subjectFqn: "Halfcode.ResourceKind.ResourcePackage",
+	ownerPackageId: CORE_KIND_OWNER_PACKAGE_ID,
+	ownerPackageFingerprint: CORE_KIND_OWNER_PACKAGE_FINGERPRINT,
+	sourceShapes: Object.freeze(["manifest"]),
+	documentCardinality: "one"
+});
+const KIND_DEFINITION_KIND_OWNER = createKindSubjectOwner({
+	kind: "KindDefinition",
+	subjectFqn: "Halfcode.ResourceKind.KindDefinition",
+	ownerPackageId: CORE_KIND_OWNER_PACKAGE_ID,
+	ownerPackageFingerprint: CORE_KIND_OWNER_PACKAGE_FINGERPRINT,
+	sourceShapes: Object.freeze(["single-file", "directory"]),
+	documentCardinality: "one"
+});
+const AUTHORED_SPEC_PROPERTIES = Object.freeze({
+	properties: Object.freeze({ type: "object" }),
+	body: Object.freeze({ type: "array" }),
+	subdomains: Object.freeze({ type: "object" }),
+	text: Object.freeze({ type: "string" })
+});
+const RESOURCE_PACKAGE_SPEC_SCHEMA_V1 = Object.freeze({
+	type: "object",
+	required: Object.freeze([
+		"properties",
+		"body",
+		"subdomains"
+	]),
+	properties: Object.freeze({
+		...AUTHORED_SPEC_PROPERTIES,
+		subdomains: Object.freeze({
+			type: "object",
+			required: Object.freeze(["Catalogs"])
+		})
+	}),
+	additionalProperties: false
+});
+const KIND_DEFINITION_SPEC_SCHEMA_V1 = Object.freeze({
+	type: "object",
+	required: Object.freeze([
+		"properties",
+		"body",
+		"subdomains"
+	]),
+	properties: Object.freeze({
+		...AUTHORED_SPEC_PROPERTIES,
+		properties: Object.freeze({
+			type: "object",
+			required: Object.freeze([
+				"resourceKind",
+				"subjectFqn",
+				"sourceShapes"
+			]),
+			properties: Object.freeze({
+				resourceKind: Object.freeze({
+					type: "string",
+					minLength: 1
+				}),
+				subjectFqn: Object.freeze({
+					type: "string",
+					minLength: 1
+				}),
+				sourceShapes: Object.freeze({
+					type: "array",
+					minItems: 1,
+					items: Object.freeze({ enum: Object.freeze([
+						"single-file",
+						"directory",
+						"manifest"
+					]) })
+				}),
+				documentCardinality: Object.freeze({ enum: Object.freeze(["one", "many"]) })
+			})
+		}),
+		subdomains: Object.freeze({
+			type: "object",
+			required: Object.freeze(["SpecRevisions"])
+		})
+	}),
+	additionalProperties: false
+});
+function coreSemanticContract(kind) {
+	return Object.freeze({
+		semanticValidatorFingerprint: digestCanonical(Object.freeze({
+			authority: "halfcode-compiler.xnl/core-kind-contracts/v1",
+			kind,
+			role: "bootstrap-structural-admission"
+		})),
+		referenceProjectionFingerprint: digestCanonical(Object.freeze({
+			authority: "halfcode-compiler.xnl/core-kind-contracts/v1",
+			kind,
+			role: kind === "ResourcePackage" ? "catalog-reference-projection" : "spec-revision-reference-projection"
+		})),
+		compilerInputFingerprint: digestCanonical(Object.freeze({
+			authority: "halfcode-compiler.xnl/core-kind-contracts/v1",
+			kind,
+			role: "authored-spec-envelope-projection",
+			fields: Object.freeze([
+				"properties",
+				"body",
+				"subdomains",
+				"text"
+			])
+		}))
+	});
+}
+const RESOURCE_PACKAGE_KIND_SPEC_REVISION_V1 = createKindSpecRevision({
+	kind: RESOURCE_PACKAGE_KIND_OWNER.kind,
+	subjectFqn: RESOURCE_PACKAGE_KIND_OWNER.subjectFqn,
+	specVersion: CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS.ResourcePackage,
+	specSchema: RESOURCE_PACKAGE_SPEC_SCHEMA_V1,
+	semanticContract: coreSemanticContract("ResourcePackage"),
+	sourceContractFingerprint: RESOURCE_PACKAGE_KIND_OWNER.sourceContract.sourceContractFingerprint,
+	stability: "stable"
+});
+const KIND_DEFINITION_KIND_SPEC_REVISION_V1 = createKindSpecRevision({
+	kind: KIND_DEFINITION_KIND_OWNER.kind,
+	subjectFqn: KIND_DEFINITION_KIND_OWNER.subjectFqn,
+	specVersion: CORE_BOOTSTRAP_WRITER_SPEC_VERSIONS.KindDefinition,
+	specSchema: KIND_DEFINITION_SPEC_SCHEMA_V1,
+	semanticContract: coreSemanticContract("KindDefinition"),
+	sourceContractFingerprint: KIND_DEFINITION_KIND_OWNER.sourceContract.sourceContractFingerprint,
+	stability: "stable"
+});
+const CORE_KIND_SUBJECT_OWNERS = Object.freeze([KIND_DEFINITION_KIND_OWNER, RESOURCE_PACKAGE_KIND_OWNER]);
+const CORE_KIND_SPEC_REVISIONS = Object.freeze([KIND_DEFINITION_KIND_SPEC_REVISION_V1, RESOURCE_PACKAGE_KIND_SPEC_REVISION_V1]);
+function coreReaderRegistration(readerId, revision) {
+	return Object.freeze({
+		readerId,
+		subjectFqn: revision.subjectFqn,
+		readerSpecVersion: revision.specVersion,
+		contractFingerprint: revision.contractFingerprint,
+		readerImplementationFingerprint: digestCanonical(Object.freeze({
+			authority: "halfcode-compiler.xnl/core-kind-contracts/v1",
+			readerId,
+			subjectFqn: revision.subjectFqn,
+			readerSpecVersion: revision.specVersion,
+			operation: "identity-read-of-validated-authored-spec"
+		})),
+		compatibilityPolicy: "exact",
+		read: (spec) => spec
+	});
+}
+const KIND_DEFINITION_KIND_READER_REGISTRATION_V1 = coreReaderRegistration("halfcode.compiler.kind-definition.reader.v1", KIND_DEFINITION_KIND_SPEC_REVISION_V1);
+const RESOURCE_PACKAGE_KIND_READER_REGISTRATION_V1 = coreReaderRegistration("halfcode.compiler.resource-package.reader.v1", RESOURCE_PACKAGE_KIND_SPEC_REVISION_V1);
+const CORE_KIND_READER_REGISTRATIONS = Object.freeze([KIND_DEFINITION_KIND_READER_REGISTRATION_V1, RESOURCE_PACKAGE_KIND_READER_REGISTRATION_V1]);
+const CORE_RESOURCE_CONTRACT_REGISTRATIONS = Object.freeze({
+	owners: CORE_KIND_SUBJECT_OWNERS,
+	revisions: CORE_KIND_SPEC_REVISIONS,
+	readers: CORE_KIND_READER_REGISTRATIONS
+});
+//#endregion
 //#region ../kind-definition/src/index.ts
-var ResourceMigrationRegistry = class {
+var ResourceSourceMigrationRegistry = class {
 	definitions = [];
 	ids = /* @__PURE__ */ new Set();
 	register(definition) {
 		if (this.ids.has(definition.id)) throw new Error(`Duplicate migration id '${definition.id}'`);
-		if (!definition.id || !definition.resourceKind || !definition.fromApiVersion || !definition.toApiVersion) throw new Error("Migration definitions require id, resourceKind, fromApiVersion, and toApiVersion");
-		if (definition.fromApiVersion === definition.toApiVersion) throw new Error(`Migration '${definition.id}' must change apiVersion`);
+		if (!definition.id || !definition.subjectFqn || !Number.isSafeInteger(definition.fromWriterSpecVersion) || definition.fromWriterSpecVersion <= 0 || !Number.isSafeInteger(definition.toWriterSpecVersion) || definition.toWriterSpecVersion <= 0) throw new Error("Source migration definitions require id, subjectFqn and positive writer spec versions");
+		if (definition.fromWriterSpecVersion === definition.toWriterSpecVersion) throw new Error(`Migration '${definition.id}' must change writer specVersion`);
 		this.ids.add(definition.id);
 		this.definitions.push(Object.freeze({ ...definition }));
 		return this;
 	}
-	plan(resourceKind, fromApiVersion, toApiVersion) {
-		if (fromApiVersion === toApiVersion) return [];
+	plan(subjectFqn, fromWriterSpecVersion, toWriterSpecVersion) {
+		if (fromWriterSpecVersion === toWriterSpecVersion) return [];
 		const steps = [];
 		const visited = /* @__PURE__ */ new Set();
-		let current = fromApiVersion;
-		while (current !== toApiVersion) {
-			if (visited.has(current)) throw new Error(`Migration cycle detected for Kind '${resourceKind}' at '${current}'`);
+		let current = fromWriterSpecVersion;
+		while (current !== toWriterSpecVersion) {
+			if (visited.has(current)) throw new Error(`Source migration cycle detected for '${subjectFqn}' at writer specVersion ${current}`);
 			visited.add(current);
-			const candidates = this.definitions.filter((definition) => definition.resourceKind === resourceKind && definition.fromApiVersion === current);
-			if (candidates.length === 0) throw new Error(`No migration for Kind '${resourceKind}' from '${current}' to '${toApiVersion}'`);
-			if (candidates.length > 1) throw new Error(`Ambiguous migration for Kind '${resourceKind}' from '${current}': ${candidates.map((candidate) => candidate.id).join(", ")}`);
+			const candidates = this.definitions.filter((definition) => definition.subjectFqn === subjectFqn && definition.fromWriterSpecVersion === current);
+			if (candidates.length === 0) throw new Error(`No source migration for '${subjectFqn}' from writer specVersion ${current} to ${toWriterSpecVersion}`);
+			if (candidates.length > 1) throw new Error(`Ambiguous source migration for '${subjectFqn}' from writer specVersion ${current}: ${candidates.map((candidate) => candidate.id).join(", ")}`);
 			const step = candidates[0];
 			steps.push(step);
-			current = step.toApiVersion;
+			current = step.toWriterSpecVersion;
 		}
 		return Object.freeze(steps);
 	}
-	migrate(resourceKind, fromApiVersion, toApiVersion, resource) {
-		return this.plan(resourceKind, fromApiVersion, toApiVersion).reduce((value, step) => step.migrate(value), resource);
+	migrate(subjectFqn, fromWriterSpecVersion, toWriterSpecVersion, resource) {
+		return this.plan(subjectFqn, fromWriterSpecVersion, toWriterSpecVersion).reduce((value, step) => step.migrate(value), resource);
 	}
 };
 const kindDefinitionPackage = {
@@ -37,4 +848,4 @@ const kindDefinitionPackage = {
 	owns: "resource kind validation authority"
 };
 //#endregion
-export { ResourceMigrationRegistry, kindDefinitionPackage };
+export { CORE_KIND_READER_REGISTRATIONS, CORE_KIND_SPEC_REVISIONS, CORE_KIND_SUBJECT_OWNERS, CORE_RESOURCE_CONTRACT_REGISTRATIONS, KIND_DEFINITION_KIND_OWNER, KIND_DEFINITION_KIND_READER_REGISTRATION_V1, KIND_DEFINITION_KIND_SPEC_REVISION_V1, KIND_DEFINITION_SPEC_SCHEMA_V1, KindContractRegistry, KindReaderRegistry, KindWriterRegistry, RESOURCE_PACKAGE_KIND_OWNER, RESOURCE_PACKAGE_KIND_READER_REGISTRATION_V1, RESOURCE_PACKAGE_KIND_SPEC_REVISION_V1, RESOURCE_PACKAGE_SPEC_SCHEMA_V1, ResourceSourceMigrationRegistry, SpecResolutionRegistry, createKindContractLock, createKindSpecRevision, createKindSubjectOwner, createReaderProfile, exactSpecVersion, kindDefinitionPackage, resolveResourceTree, resolveSpec };