@askdkc/dsh-cli 0.11.3

package/node_modules/@dsh-std/manifest/lib/index.js

@@ -0,0 +1,625 @@
+import { assertVersionRange, parseSemanticVersion, protocolKey, validateApiReference } from "@dsh-std/core";
+//#region src/index.ts
+const COMMUNITY_V015_MANIFEST_VERSION = "0.15";
+const COMPONENT_API_VERSION = "manifest.dsh/internal/v1alpha1";
+const COMMUNITY_PERMISSION_API_VERSION = "community.dsh/v1alpha1";
+const COMMUNITY_PERMISSION_KIND = "Permission";
+const COMPONENT_ID = /^[a-z][a-z0-9]*(?:[.-][a-z0-9][a-z0-9-]*)+$/u;
+const LOCAL_NAME = /^[a-z][a-z0-9]*(?:[.-][a-z0-9][a-z0-9-]*)*$/u;
+var ManifestDefinitionCatalog = class {
+	validator;
+	activations = /* @__PURE__ */ new Map();
+	extensions = /* @__PURE__ */ new Map();
+	constructor(validator = Object.freeze({
+		name: "@dsh-std/manifest",
+		version: "0.1.0"
+	})) {
+		this.validator = validator;
+		nonEmpty(validator.name, "validator.name");
+		nonEmpty(validator.version, "validator.version");
+	}
+	registerActivation(definition) {
+		return registerDefinition(this.activations, definition, "activation");
+	}
+	registerExtension(definition) {
+		return registerDefinition(this.extensions, definition, "extension");
+	}
+	activation(reference) {
+		return this.activations.get(protocolKey(reference));
+	}
+	extension(reference) {
+		return this.extensions.get(protocolKey(reference));
+	}
+	validate(manifestValue, protocols, options = {}) {
+		const manifest = defineComponentManifest(manifestValue);
+		const issues = [];
+		for (const [facetIndex, facet] of manifest.spec.facets.entries()) {
+			const base = `/spec/facets/${facetIndex}`;
+			if (facet.activation !== void 0) {
+				const definition = this.activation(facet.activation);
+				if (definition === void 0) issues.push(issue("unknown-activation", "warning", `${base}/activation`, "activation definition is not installed"));
+				else try {
+					definition.validateSpec(facet.activation.spec);
+				} catch (error) {
+					issues.push(issue("invalid-activation", "error", `${base}/activation/spec`, errorMessage(error)));
+				}
+			}
+			for (const direction of ["requires", "supports"]) for (const [index, row] of (facet.protocols?.[direction] ?? []).entries()) if (protocols !== void 0 && !protocols.understands(row)) issues.push(issue("unknown-protocol", "warning", `${base}/protocols/${direction}/${index}`, `protocol ${row.apiVersion} ${row.kind} is unknown`));
+			for (const [index, extension] of (facet.extensions ?? []).entries()) {
+				const definition = this.extension(extension);
+				if (definition === void 0) issues.push(issue("unknown-extension", "warning", `${base}/extensions/${index}`, "extension definition is not installed"));
+				else try {
+					definition.validateMetadata?.(extension.metadata);
+					definition.validateSpec(extension.spec);
+				} catch (error) {
+					issues.push(issue("invalid-extension", "error", `${base}/extensions/${index}`, errorMessage(error)));
+				}
+			}
+		}
+		return Object.freeze({
+			apiVersion: "manifest.dsh/report/v1alpha1",
+			validator: Object.freeze({ ...this.validator }),
+			source: options.source ?? "memory:",
+			digest: options.digest ?? manifestDigest(manifest),
+			manifest: Object.freeze({
+				name: manifest.metadata.name,
+				version: manifest.metadata.version
+			}),
+			compatible: !issues.some((row) => row.severity === "error"),
+			issues: Object.freeze(issues)
+		});
+	}
+};
+/** Parse the package-root dsh-plugin.json without executing plugin code or fetching a schema. */
+function parseManifest(source, options = {}) {
+	if (typeof source !== "string") throw new TypeError("manifest source must be a string");
+	let value;
+	try {
+		value = JSON.parse(source);
+	} catch (error) {
+		throw new SyntaxError(`${options.source ?? "dsh-plugin.json"}: ${errorMessage(error)}`, { cause: error });
+	}
+	try {
+		return defineManifest(value);
+	} catch (error) {
+		throw new TypeError(`${options.source ?? "dsh-plugin.json"}: ${errorMessage(error)}`, { cause: error });
+	}
+}
+function defineManifest(manifest) {
+	validateManifest(manifest);
+	return deepFreeze(structuredClone(manifest));
+}
+function validateManifest(value) {
+	if (!record(value)) throw new TypeError("plugin manifest must be an object");
+	if (value.manifestVersion === "0.15") {
+		validateCommunityManifest(value);
+		return;
+	}
+	throw new TypeError(`unsupported plugin manifest $schema ${JSON.stringify(value.$schema)} and manifestVersion ${JSON.stringify(value.manifestVersion)}`);
+}
+function validateCommunityManifest(value) {
+	exact(value, [
+		"$schema",
+		"manifestVersion",
+		"id",
+		"name",
+		"version",
+		"facets",
+		"requires",
+		"permissions",
+		"contributes",
+		"subscriptions",
+		"license",
+		"source",
+		"artifact",
+		"compat",
+		"overrides"
+	], "community v0.15 plugin manifest");
+	validateSchemaIdentifier(value.$schema, "community v0.15 manifest.$schema");
+	if (value.manifestVersion !== "0.15") throw new TypeError(`unsupported Community v0.15 manifestVersion ${JSON.stringify(value.manifestVersion)}`);
+	namespaced(value.id, "community v0.15 manifest.id");
+	nonEmpty(value.name, "community v0.15 manifest.name");
+	nonEmpty(value.version, "community v0.15 manifest.version");
+	parseSemanticVersion(value.version);
+	validateCommunityFacets(value.facets);
+	validateCommunityRequirements(value.requires);
+	validateCommunityPermissions(value.permissions);
+	validateCommunityContributions(value.contributes);
+	validateCommunitySubscriptions(value.subscriptions);
+	if (value.license !== void 0) nonEmpty(value.license, "community v0.15 manifest.license");
+	if (value.source !== void 0) validateCommunitySource(value.source);
+	if (value.artifact !== void 0) validateCommunityArtifact(value.artifact);
+	if (value.compat !== void 0) validateCommunityCompat(value.compat);
+	if (value.overrides !== void 0) validateCommunityOverrides(value.overrides);
+}
+/** Validate a host-internal Component/Facet projection. */
+function defineComponentManifest(manifest) {
+	validateComponentManifest(manifest);
+	return deepFreeze(structuredClone(manifest));
+}
+function validateComponentManifest(value) {
+	if (!record(value)) throw new TypeError("component manifest must be an object");
+	exact(value, [
+		"apiVersion",
+		"kind",
+		"metadata",
+		"spec"
+	], "component manifest");
+	if (value.apiVersion !== "manifest.dsh/internal/v1alpha1") throw new TypeError(`unsupported component manifest apiVersion ${JSON.stringify(value.apiVersion)}`);
+	if (value.kind !== "Component") throw new TypeError("component manifest kind must be \"Component\"");
+	if (!record(value.metadata)) throw new TypeError("component metadata must be an object");
+	exact(value.metadata, [
+		"name",
+		"version",
+		"displayName"
+	], "component metadata");
+	namespaced(value.metadata.name, "component metadata.name");
+	nonEmpty(value.metadata.version, "component metadata.version");
+	parseSemanticVersion(value.metadata.version);
+	if (value.metadata.displayName !== void 0) nonEmpty(value.metadata.displayName, "component metadata.displayName");
+	if (!record(value.spec)) throw new TypeError("component spec must be an object");
+	exact(value.spec, ["facets", "relationships"], "component spec");
+	if (!Array.isArray(value.spec.facets) || value.spec.facets.length === 0) throw new TypeError("component spec.facets must be a non-empty array");
+	const names = /* @__PURE__ */ new Set();
+	for (const [index, facet] of value.spec.facets.entries()) {
+		validateFacet(facet, index);
+		const name = facet.name;
+		if (names.has(name)) throw new TypeError(`duplicate facet name ${JSON.stringify(name)}`);
+		names.add(name);
+	}
+	if (value.spec.relationships !== void 0) validateRelationships(value.spec.relationships, value.metadata.name);
+}
+/** Project a supported package manifest version into the common host composition model. */
+function projectManifest(manifestValue) {
+	return projectCommunityManifest(defineManifest(manifestValue));
+}
+function projectCommunityManifest(manifest) {
+	const extensions = manifest.contributes.commands.map((row) => Object.freeze({
+		apiVersion: "commands.dsh/v1alpha1",
+		kind: "Command",
+		metadata: Object.freeze({
+			name: localContributionName(row.id),
+			labels: Object.freeze({ "dsh.std/contribution-id": row.id })
+		}),
+		spec: Object.freeze({
+			title: row.title,
+			...row.description === void 0 ? {} : { description: row.description }
+		})
+	}));
+	for (const [point, contributions] of Object.entries(manifest.contributes)) {
+		if (!point.startsWith("x-")) continue;
+		for (const contribution of contributions) {
+			if (!record(contribution) || typeof contribution.apiVersion !== "string" || typeof contribution.kind !== "string" || typeof contribution.id !== "string" || typeof contribution.name !== "string" || !Object.hasOwn(contribution, "spec")) continue;
+			extensions.push(Object.freeze({
+				apiVersion: contribution.apiVersion,
+				kind: contribution.kind,
+				metadata: Object.freeze({
+					name: contribution.name,
+					labels: Object.freeze({ "dsh.std/contribution-id": contribution.id })
+				}),
+				spec: contribution.spec
+			}));
+		}
+	}
+	const requirements = manifest.requires.contracts.map(communityRequirement);
+	const permissions = manifest.permissions.map((permission) => Object.freeze({
+		apiVersion: COMMUNITY_PERMISSION_API_VERSION,
+		kind: COMMUNITY_PERMISSION_KIND,
+		action: permission.name,
+		...permission.reason === void 0 ? {} : { reason: permission.reason },
+		spec: Object.freeze({ scope: permission.scope })
+	}));
+	return defineComponentManifest({
+		apiVersion: COMPONENT_API_VERSION,
+		kind: "Component",
+		metadata: {
+			name: manifest.id,
+			displayName: manifest.name,
+			version: manifest.version
+		},
+		spec: { facets: [{
+			name: "host",
+			activation: {
+				apiVersion: "lifecycle.dsh/v1alpha1",
+				kind: "FacetModule",
+				spec: { module: manifest.facets.host.entry }
+			},
+			...requirements.length === 0 ? {} : { protocols: { requires: requirements } },
+			...extensions.length === 0 ? {} : { extensions },
+			...permissions.length === 0 ? {} : { permissions }
+		}] }
+	});
+}
+function communityRequirement(reference) {
+	return Object.freeze({
+		apiVersion: reference.apiVersion,
+		kind: reference.kind,
+		...reference.optional === void 0 ? {} : { optional: reference.optional },
+		...reference.fallback === void 0 ? {} : { "x-community-fallback": reference.fallback }
+	});
+}
+function facetIdentity(manifest, facet) {
+	if (!manifest.spec.facets.includes(facet)) {
+		if (manifest.spec.facets.find((candidate) => candidate.name === facet.name) === void 0) throw new TypeError(`facet ${JSON.stringify(facet.name)} does not belong to component`);
+	}
+	return Object.freeze({
+		component: manifest.metadata.name,
+		version: manifest.metadata.version,
+		facet: facet.name
+	});
+}
+function facetKey(identity) {
+	return `${identity.component}@${identity.version}#${identity.facet}`;
+}
+function findFacet(manifest, name) {
+	return manifest.spec.facets.find((facet) => facet.name === name);
+}
+function validateCommunityFacets(value) {
+	const label = "community v0.15 manifest.facets";
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	exact(value, ["host"], label, false);
+	if (!record(value.host)) throw new TypeError(`${label}.host must be an object`);
+	exact(value.host, ["entry", "apiVersion"], `${label}.host`, false);
+	validatePackageRelative(value.host.entry, `${label}.host.entry`);
+	if (typeof value.host.apiVersion !== "string" || !/^v[1-9][0-9]*(?:(?:alpha|beta)[1-9][0-9]*)?$/u.test(value.host.apiVersion)) throw new TypeError(`${label}.host.apiVersion is invalid`);
+}
+function validateCommunityRequirements(value) {
+	const label = "community v0.15 manifest.requires";
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	exact(value, ["contracts", "services"], label, false);
+	if (!Array.isArray(value.contracts)) throw new TypeError(`${label}.contracts must be an array`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, referenceValue] of value.contracts.entries()) {
+		const rowLabel = `${label}.contracts[${index}]`;
+		validateApiReference(referenceValue, rowLabel);
+		const reference = referenceValue;
+		exact(reference, [
+			"apiVersion",
+			"kind",
+			"optional",
+			"fallback"
+		], rowLabel, false);
+		if (reference.optional !== void 0 && typeof reference.optional !== "boolean") throw new TypeError(`${rowLabel}.optional must be boolean`);
+		if (reference.fallback !== void 0) nonEmpty(reference.fallback, `${rowLabel}.fallback`);
+		const key = protocolKey(reference);
+		if (seen.has(key)) throw new TypeError(`${label}.contracts contains duplicate contract ${JSON.stringify(key)}`);
+		seen.add(key);
+	}
+	if (value.services !== void 0 && (!Array.isArray(value.services) || value.services.length !== 0)) throw new TypeError(`${label}.services must be an empty array in v0.15`);
+}
+function validateCommunityPermissions(value) {
+	const label = "community v0.15 manifest.permissions";
+	if (!Array.isArray(value)) throw new TypeError(`${label} must be an array`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, permissionValue] of value.entries()) {
+		const rowLabel = `${label}[${index}]`;
+		if (!record(permissionValue)) throw new TypeError(`${rowLabel} must be an object`);
+		exact(permissionValue, [
+			"name",
+			"scope",
+			"reason"
+		], rowLabel, false);
+		capabilityId(permissionValue.name, `${rowLabel}.name`);
+		nonEmpty(permissionValue.scope, `${rowLabel}.scope`);
+		if (permissionValue.reason !== void 0) nonEmpty(permissionValue.reason, `${rowLabel}.reason`);
+		const key = `${String(permissionValue.name)}\0${String(permissionValue.scope)}`;
+		if (seen.has(key)) throw new TypeError(`${label} contains duplicate permission ${JSON.stringify(key)}`);
+		seen.add(key);
+	}
+}
+function validateCommunityContributions(value) {
+	const label = "community v0.15 manifest.contributes";
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	const unknown = Object.keys(value).filter((point) => point !== "commands" && point !== "panels" && !point.startsWith("x-"));
+	if (unknown.length > 0) throw new TypeError(`${label} contains unknown contribution point ${JSON.stringify(unknown[0])}`);
+	if (!Array.isArray(value.commands)) throw new TypeError(`${label}.commands must be an array`);
+	const ids = /* @__PURE__ */ new Set();
+	for (const [index, commandValue] of value.commands.entries()) {
+		const rowLabel = `${label}.commands[${index}]`;
+		if (!record(commandValue)) throw new TypeError(`${rowLabel} must be an object`);
+		exact(commandValue, [
+			"id",
+			"title",
+			"description"
+		], rowLabel, false);
+		namespaced(commandValue.id, `${rowLabel}.id`);
+		nonEmpty(commandValue.title, `${rowLabel}.title`);
+		if (commandValue.description !== void 0) nonEmpty(commandValue.description, `${rowLabel}.description`);
+		if (ids.has(commandValue.id)) throw new TypeError(`${label}.commands contains duplicate id ${JSON.stringify(commandValue.id)}`);
+		ids.add(commandValue.id);
+	}
+	if (value.panels !== void 0 && (!Array.isArray(value.panels) || value.panels.length !== 0)) throw new TypeError(`${label}.panels must be an empty array in v0.15`);
+	for (const [point, contributions] of Object.entries(value)) {
+		if (!point.startsWith("x-")) continue;
+		if (!Array.isArray(contributions)) throw new TypeError(`${label}.${point} must be an array`);
+	}
+}
+function validateCommunitySubscriptions(value) {
+	const label = "community v0.15 manifest.subscriptions";
+	if (!Array.isArray(value)) throw new TypeError(`${label} must be an array`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, subscriptionValue] of value.entries()) {
+		const rowLabel = `${label}[${index}]`;
+		let key;
+		if (typeof subscriptionValue === "string") {
+			nonEmpty(subscriptionValue, rowLabel);
+			key = `legacy\0${subscriptionValue}`;
+		} else {
+			validateApiReference(subscriptionValue, rowLabel);
+			const subscription = subscriptionValue;
+			exact(subscription, [
+				"apiVersion",
+				"kind",
+				"scope"
+			], rowLabel, false);
+			if (subscription.scope !== void 0) nonEmpty(subscription.scope, `${rowLabel}.scope`);
+			key = `${protocolKey(subscription)}\0${String(subscription.scope ?? "")}`;
+		}
+		if (seen.has(key)) throw new TypeError(`${label} contains duplicate subscription ${JSON.stringify(key)}`);
+		seen.add(key);
+	}
+}
+function validateCommunitySource(value) {
+	const label = "community v0.15 manifest.source";
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	exact(value, ["repository", "revision"], label, false);
+	validateSchemaIdentifier(value.repository, `${label}.repository`);
+	if (value.revision !== void 0) nonEmpty(value.revision, `${label}.revision`);
+}
+function validateCommunityArtifact(value) {
+	const label = "community v0.15 manifest.artifact";
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	exact(value, [
+		"digest",
+		"algorithm",
+		"path"
+	], label, false);
+	if (value.algorithm !== "sha256") throw new TypeError(`${label}.algorithm must be "sha256"`);
+	if (typeof value.digest !== "string" || !/^sha256:[a-f0-9]{64}$/u.test(value.digest)) throw new TypeError(`${label}.digest must be a SHA-256 digest`);
+	validatePackageRelative(value.path, `${label}.path`);
+}
+function validateCommunityCompat(value) {
+	const label = "community v0.15 manifest.compat";
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	exact(value, ["hosts"], label, false);
+	if (value.hosts === void 0) return;
+	if (!Array.isArray(value.hosts)) throw new TypeError(`${label}.hosts must be an array`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, host] of value.hosts.entries()) {
+		nonEmpty(host, `${label}.hosts[${index}]`);
+		if (seen.has(host)) throw new TypeError(`${label}.hosts contains duplicate ${JSON.stringify(host)}`);
+		seen.add(host);
+	}
+}
+function validateCommunityOverrides(value) {
+	const label = "community v0.15 manifest.overrides";
+	if (!Array.isArray(value)) throw new TypeError(`${label} must be an array`);
+	for (const [index, overrideValue] of value.entries()) {
+		const rowLabel = `${label}[${index}]`;
+		if (!record(overrideValue)) throw new TypeError(`${rowLabel} must be an object`);
+		exact(overrideValue, [
+			"target",
+			"kind",
+			"description"
+		], rowLabel, false);
+		nonEmpty(overrideValue.target, `${rowLabel}.target`);
+		if (overrideValue.kind !== "patch" && overrideValue.kind !== "native" && overrideValue.kind !== "build") throw new TypeError(`${rowLabel}.kind is invalid`);
+		if (overrideValue.description !== void 0) nonEmpty(overrideValue.description, `${rowLabel}.description`);
+	}
+}
+function validatePackageRelative(value, label) {
+	nonEmpty(value, label);
+	if (value.startsWith("/") || value.startsWith("\\") || /^[a-zA-Z]:[\\/]/u.test(value)) throw new TypeError(`${label} must be package-relative`);
+	if (value.replaceAll("\\", "/").split("/").includes("..")) throw new TypeError(`${label} must remain inside the package`);
+}
+function capabilityId(value, label) {
+	if (value === "commands" || value === "storage.local" || value === "messages.observe") return;
+	if (typeof value !== "string" || !/^(?:x-[a-z0-9][a-z0-9.-]*\.)?[a-z][a-z0-9]*(?:[.-][a-z0-9][a-z0-9-]*)+$/u.test(value)) throw new TypeError(`${label} must be a namespaced capability identifier`);
+}
+function localContributionName(id) {
+	const name = id.split(".").at(-1) ?? id;
+	localName(name, "contribution local name");
+	return name;
+}
+function validateFacet(value, index) {
+	const label = `component spec.facets[${index}]`;
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	exact(value, [
+		"name",
+		"activation",
+		"protocols",
+		"extensions",
+		"permissions"
+	], label);
+	localName(value.name, `${label}.name`);
+	if (value.activation !== void 0) validateActivation(value.activation, `${label}.activation`);
+	if (value.protocols !== void 0) validateProtocols(value.protocols, `${label}.protocols`);
+	if (value.extensions !== void 0) validateExtensions(value.extensions, `${label}.extensions`);
+	if (value.permissions !== void 0) validatePermissions(value.permissions, `${label}.permissions`);
+	if (value.activation === void 0 && value.protocols === void 0 && value.extensions === void 0 && value.permissions === void 0) throw new TypeError(`${label} must declare activation, protocols, extensions, or permissions`);
+}
+function validateActivation(value, label) {
+	validateApiReference(value, label);
+	const row = value;
+	exact(row, [
+		"apiVersion",
+		"kind",
+		"spec"
+	], label);
+	if (!Object.hasOwn(row, "spec")) throw new TypeError(`${label}.spec is required`);
+}
+function validateProtocols(value, label) {
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	exact(value, ["requires", "supports"], label);
+	validateProtocolRows(value.requires, true, `${label}.requires`);
+	validateProtocolRows(value.supports, false, `${label}.supports`);
+}
+function validateProtocolRows(value, requirement, label) {
+	if (value === void 0) return;
+	if (!Array.isArray(value)) throw new TypeError(`${label} must be an array`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, rowValue] of value.entries()) {
+		const rowLabel = `${label}[${index}]`;
+		validateApiReference(rowValue, rowLabel);
+		const row = rowValue;
+		exact(row, requirement ? [
+			"apiVersion",
+			"kind",
+			"optional",
+			"spec"
+		] : [
+			"apiVersion",
+			"kind",
+			"spec"
+		], rowLabel);
+		if (requirement && row.optional !== void 0 && typeof row.optional !== "boolean") throw new TypeError(`${rowLabel}.optional must be boolean`);
+		const key = protocolKey(row);
+		if (seen.has(key)) throw new TypeError(`${label} contains duplicate protocol ${JSON.stringify(key)}`);
+		seen.add(key);
+	}
+}
+function validateExtensions(value, label) {
+	if (!Array.isArray(value)) throw new TypeError(`${label} must be an array`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, extensionValue] of value.entries()) {
+		const rowLabel = `${label}[${index}]`;
+		validateApiReference(extensionValue, rowLabel);
+		const extension = extensionValue;
+		exact(extension, [
+			"apiVersion",
+			"kind",
+			"metadata",
+			"spec"
+		], rowLabel);
+		if (!record(extension.metadata)) throw new TypeError(`${rowLabel}.metadata must be an object`);
+		exact(extension.metadata, ["name", "labels"], `${rowLabel}.metadata`);
+		nonEmpty(extension.metadata.name, `${rowLabel}.metadata.name`);
+		if (extension.metadata.labels !== void 0) validateLabels(extension.metadata.labels, `${rowLabel}.metadata.labels`);
+		if (!Object.hasOwn(extension, "spec")) throw new TypeError(`${rowLabel}.spec is required`);
+		if (Object.hasOwn(extension, "status")) throw new TypeError(`${rowLabel}.status is runtime-owned`);
+		const key = `${protocolKey(extension)}\0${String(extension.metadata.name)}`;
+		if (seen.has(key)) throw new TypeError(`${label} contains duplicate extension ${JSON.stringify(key)}`);
+		seen.add(key);
+	}
+}
+function validatePermissions(value, label) {
+	if (!Array.isArray(value)) throw new TypeError(`${label} must be an array`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, permissionValue] of value.entries()) {
+		const rowLabel = `${label}[${index}]`;
+		validateApiReference(permissionValue, rowLabel);
+		const permission = permissionValue;
+		exact(permission, [
+			"apiVersion",
+			"kind",
+			"action",
+			"optional",
+			"reason",
+			"spec"
+		], rowLabel);
+		localName(permission.action, `${rowLabel}.action`);
+		if (permission.optional !== void 0 && typeof permission.optional !== "boolean") throw new TypeError(`${rowLabel}.optional must be boolean`);
+		if (permission.reason !== void 0) nonEmpty(permission.reason, `${rowLabel}.reason`);
+		const key = `${protocolKey(permission)}\0${String(permission.action)}`;
+		if (seen.has(key)) throw new TypeError(`${label} contains duplicate permission ${JSON.stringify(key)}`);
+		seen.add(key);
+	}
+}
+function validateRelationships(value, component) {
+	if (!record(value)) throw new TypeError("component relationships must be an object");
+	exact(value, [
+		"depends",
+		"recommends",
+		"conflicts",
+		"breaks"
+	], "component relationships", false);
+	for (const kind of [
+		"depends",
+		"recommends",
+		"conflicts",
+		"breaks"
+	]) {
+		const rows = value[kind];
+		if (rows === void 0) continue;
+		if (!record(rows)) throw new TypeError(`component relationships.${kind} must be an object`);
+		for (const [target, range] of Object.entries(rows)) {
+			namespaced(target, `component relationships.${kind} target`);
+			if (target === component) throw new TypeError(`component cannot declare ${kind} on itself`);
+			assertVersionRange(range);
+		}
+	}
+}
+function registerDefinition(target, definition, label) {
+	validateApiReference(definition, `${label} definition`);
+	if (typeof definition.validateSpec !== "function") throw new TypeError(`${label} definition.validateSpec must be a function`);
+	const key = protocolKey(definition);
+	if (target.has(key)) throw new Error(`${label} definition ${definition.apiVersion} ${definition.kind} is already registered`);
+	const stored = Object.freeze({ ...definition });
+	target.set(key, stored);
+	return () => {
+		if (target.get(key) === stored) target.delete(key);
+	};
+}
+function issue(code, severity, path, message) {
+	return Object.freeze({
+		code,
+		severity,
+		path,
+		message
+	});
+}
+function validateLabels(value, label) {
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	for (const [key, item] of Object.entries(value)) {
+		nonEmpty(key, `${label} key`);
+		if (typeof item !== "string") throw new TypeError(`${label}.${key} must be a string`);
+	}
+}
+function namespaced(value, label) {
+	if (typeof value !== "string" || !COMPONENT_ID.test(value)) throw new TypeError(`${label} must be namespaced`);
+}
+function localName(value, label) {
+	if (typeof value !== "string" || !LOCAL_NAME.test(value)) throw new TypeError(`${label} is invalid`);
+}
+function nonEmpty(value, label) {
+	if (typeof value !== "string" || value.trim() === "") throw new TypeError(`${label} must be a non-empty string`);
+}
+function validateSchemaIdentifier(value, label) {
+	nonEmpty(value, label);
+	try {
+		new URL(value);
+	} catch (error) {
+		throw new TypeError(`${label} must be an absolute URI`, { cause: error });
+	}
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function exact(value, allowed, label, extensions = true) {
+	const unknown = Object.keys(value).filter((key) => !allowed.includes(key) && !(extensions && key.startsWith("x-")));
+	if (unknown.length > 0) throw new TypeError(`${label} contains unknown field ${JSON.stringify(unknown[0])}`);
+}
+function deepFreeze(value) {
+	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+	Object.freeze(value);
+	for (const child of Object.values(value)) deepFreeze(child);
+	return value;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function manifestDigest(manifest) {
+	const input = canonical(manifest);
+	let hash = 2166136261;
+	for (let index = 0; index < input.length; index += 1) hash = Math.imul(hash ^ input.charCodeAt(index), 16777619);
+	return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function canonical(value) {
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	if (record(value)) return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+	return JSON.stringify(value) ?? "null";
+}
+//#endregion
+export { COMMUNITY_PERMISSION_API_VERSION, COMMUNITY_PERMISSION_KIND, COMMUNITY_V015_MANIFEST_VERSION, COMPONENT_API_VERSION, ManifestDefinitionCatalog, defineComponentManifest, defineManifest, facetIdentity, facetKey, findFacet, parseManifest, projectManifest, validateComponentManifest, validateManifest };
+
+//# sourceMappingURL=index.js.map