@vizejs/marquette 0.321.0 → 0.323.0

package/README.md

@@ -90,6 +90,45 @@ stable codes shared with the native contract implementation. Keeping it in a
 separate entry means authoring-only applications do not include validation
 code.
 
+## Adapter capability negotiation
+
+Adapters publish inclusive capability-version ranges independently from the
+application marquette. Application capability definitions are the authority
+for requirements; an undeclared requirement fails closed even when an adapter
+offers a capability with the same identifier. Adapter-only capabilities are
+allowed and remain additive until an application requires them.
+
+```ts
+import {
+  negotiateAdapterCapabilities,
+  type AdapterCapabilityManifest,
+} from "@vizejs/marquette/adapter";
+
+const adapter = {
+  adapter: "terminal.fresco",
+  capabilities: [{ id: "terminal.color", minVersion: 1, maxVersion: 3 }],
+} satisfies AdapterCapabilityManifest;
+
+const result = negotiateAdapterCapabilities(
+  marquette,
+  marquette.environments?.[0]?.capabilities ?? [],
+  adapter,
+);
+if (!result.compatible) {
+  console.error(result.diagnostics, result.mismatches);
+}
+```
+
+Exact and inclusive-bound matches are compatible. Missing support,
+requirements below an adapter's minimum, and requirements above its maximum
+use the stable `missing-capability`, `version-below-minimum`, and
+`version-above-maximum` codes. Adding a support range or widening either bound
+is additive; removing support or narrowing either bound is breaking. Both
+negotiation and compatibility reports are sorted deterministically and do not
+mutate their inputs. Compatibility reports expose validation diagnostics for
+both manifests and omit changes when either input is invalid. The published manifest schema is available from
+`@vizejs/marquette/adapter/schema`.
+
 ## Test-run evidence
 
 Release-bound test-run evidence records live in their own lazy entries so
@@ -141,6 +180,8 @@ available from `@vizejs/marquette/test-run/schema`, the decision contract from
   normalization.
 - The published application-contract schema is available from
   `@vizejs/marquette/schema`.
+- The published adapter manifest schema is available from
+  `@vizejs/marquette/adapter/schema`.
 - Every optional contract field documents its default in JSDoc.
 - Package builds enforce a 1 KiB gzip budget for authoring entries and 3 KiB
   or 4 KiB budgets for the validation entries.

package/dist/adapter-capability-manifest.schema.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://vizejs.dev/schemas/marquette/adapter-capability-manifest.schema.json",
+  "title": "Vize Adapter Capability Manifest",
+  "description": "Versioned language-neutral capability ranges offered by one Vize adapter.",
+  "$ref": "#/$defs/manifest",
+  "$defs": {
+    "identifier": {
+      "type": "string",
+      "pattern": "^[a-z0-9][a-z0-9._-]*$"
+    },
+    "support": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "minVersion", "maxVersion"],
+      "properties": {
+        "id": { "$ref": "#/$defs/identifier" },
+        "minVersion": { "type": "integer", "minimum": 1 },
+        "maxVersion": { "type": "integer", "minimum": 1 }
+      }
+    },
+    "manifest": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["adapter"],
+      "properties": {
+        "formatVersion": { "const": 1, "default": 1 },
+        "adapter": { "$ref": "#/$defs/identifier" },
+        "capabilities": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/support" },
+          "default": []
+        }
+      }
+    }
+  }
+}

package/dist/adapter.d.mts

@@ -0,0 +1,122 @@
+import { t as ApplicationMarquette } from "./model-DWcxWbC1.mjs";
+
+//#region src/adapter-model.d.ts
+/** Current serialized adapter-capability manifest format. */
+declare const ADAPTER_CAPABILITY_FORMAT_VERSION: 1;
+/** Inclusive version range supported for one capability contract. */
+interface AdapterCapabilitySupport {
+  /** Stable capability identifier from an application marquette. */
+  readonly id: string;
+  /** Oldest supported capability contract version, inclusive. */
+  readonly minVersion: number;
+  /** Newest supported capability contract version, inclusive. */
+  readonly maxVersion: number;
+}
+/** Versioned, language-neutral capabilities offered by one adapter. */
+interface AdapterCapabilityManifest {
+  /**
+   * Serialized manifest format.
+   *
+   * @default 1
+   */
+  readonly formatVersion?: typeof ADAPTER_CAPABILITY_FORMAT_VERSION;
+  /** Stable adapter identifier shown in diagnostics and reports. */
+  readonly adapter: string;
+  /**
+   * Supported capability ranges.
+   *
+   * @default []
+   */
+  readonly capabilities?: readonly AdapterCapabilitySupport[];
+}
+/** Stable validation code for an adapter capability manifest. */
+type AdapterCapabilityDiagnosticCode = "invalid-format-version" | "invalid-adapter-id" | "invalid-capability-id" | "invalid-version" | "invalid-version-range" | "duplicate-capability";
+/** Deterministic validation diagnostic for an adapter capability manifest. */
+interface AdapterCapabilityDiagnostic {
+  /** Stable machine-readable diagnostic code. */
+  readonly code: AdapterCapabilityDiagnosticCode;
+  /** JSON-style path of the invalid value. */
+  readonly path: string;
+  /** Human-readable explanation. */
+  readonly message: string;
+}
+/** Stable incompatibility code emitted during capability negotiation. */
+type AdapterCapabilityMismatchCode = "unknown-requirement" | "missing-capability" | "version-below-minimum" | "version-above-maximum";
+/** One failed adapter capability requirement. */
+interface AdapterCapabilityMismatch {
+  /** Stable machine-readable mismatch code. */
+  readonly code: AdapterCapabilityMismatchCode;
+  /** Required capability identifier. */
+  readonly capability: string;
+  /** Required contract version when the capability is declared. */
+  readonly requiredVersion?: number;
+  /** Adapter minimum when support exists. */
+  readonly minVersion?: number;
+  /** Adapter maximum when support exists. */
+  readonly maxVersion?: number;
+}
+/** Deterministic result of negotiating requirements with one adapter. */
+interface AdapterCapabilityNegotiation {
+  /** Adapter whose support was inspected. */
+  readonly adapter: string;
+  /** Whether the manifest is valid and every requirement is supported. */
+  readonly compatible: boolean;
+  /** Manifest validation failures, in stable path order. */
+  readonly diagnostics: readonly AdapterCapabilityDiagnostic[];
+  /** Unsupported or unknown requirements, in stable capability order. */
+  readonly mismatches: readonly AdapterCapabilityMismatch[];
+}
+/** Compatibility classification for one adapter capability change. */
+type CompatibilityChangeKind = "additive" | "breaking";
+/** One stable adapter capability compatibility change. */
+interface AdapterCapabilityCompatibilityChange {
+  /** Compatibility classification. */
+  readonly kind: CompatibilityChangeKind;
+  /** JSON-style path of the changed capability support. */
+  readonly path: string;
+  /** Human-readable summary. */
+  readonly message: string;
+}
+/** Deterministic compatibility report between two adapter manifests. */
+interface AdapterCapabilityCompatibilityReport {
+  /** Validation failures in the previous manifest. */
+  readonly previousDiagnostics: readonly AdapterCapabilityDiagnostic[];
+  /** Validation failures in the next manifest. */
+  readonly nextDiagnostics: readonly AdapterCapabilityDiagnostic[];
+  /** All changes in stable path order. */
+  readonly changes: readonly AdapterCapabilityCompatibilityChange[];
+}
+//#endregion
+//#region src/adapter-compatibility.d.ts
+/**
+ * Compares adapter capability support from older to newer.
+ *
+ * Adding support or widening an inclusive version range is additive.
+ * Removing support or narrowing either bound is breaking.
+ */
+declare function compareAdapterCapabilities(previous: AdapterCapabilityManifest, next: AdapterCapabilityManifest): AdapterCapabilityCompatibilityReport;
+//#endregion
+//#region src/adapter-negotiate.d.ts
+/**
+ * Negotiates application capability requirements against one adapter.
+ *
+ * Requirement identifiers are deduplicated and sorted. Unknown application
+ * capability identifiers fail closed instead of being treated as adapter
+ * omissions. An invalid manifest never produces a compatible result.
+ */
+declare function negotiateAdapterCapabilities(marquette: ApplicationMarquette, requiredCapabilities: readonly string[], manifest: AdapterCapabilityManifest): AdapterCapabilityNegotiation;
+//#endregion
+//#region src/adapter-validate.d.ts
+/** Validates an adapter capability manifest without mutating it. */
+declare function validateAdapterCapabilityManifest(manifest: AdapterCapabilityManifest): AdapterCapabilityDiagnostic[];
+/**
+ * Parses an untrusted manifest with strict field and primitive checks.
+ *
+ * Unknown fields, missing required fields, and mismatched primitive types
+ * throw before negotiation. Semantic range errors remain available from
+ * {@link validateAdapterCapabilityManifest}.
+ */
+declare function parseAdapterCapabilityManifest(value: unknown): AdapterCapabilityManifest;
+//#endregion
+export { ADAPTER_CAPABILITY_FORMAT_VERSION, type AdapterCapabilityCompatibilityChange, type AdapterCapabilityCompatibilityReport, type AdapterCapabilityDiagnostic, type AdapterCapabilityDiagnosticCode, type AdapterCapabilityManifest, type AdapterCapabilityMismatch, type AdapterCapabilityMismatchCode, type AdapterCapabilityNegotiation, type AdapterCapabilitySupport, type CompatibilityChangeKind, compareAdapterCapabilities, negotiateAdapterCapabilities, parseAdapterCapabilityManifest, validateAdapterCapabilityManifest };
+//# sourceMappingURL=adapter.d.mts.map

package/dist/adapter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/adapter-model.ts","../src/adapter-compatibility.ts","../src/adapter-negotiate.ts","../src/adapter-validate.ts"],"mappings":";;;;cACa,iCAAA;;UAGI,wBAAA;EAH0C;EAAA,SAKhD,EAAA;EALgD;EAAA,SAOhD,UAAA;EAJM;EAAA,SAMN,UAAA;AAAA;;UAIM,yBAAA;EANN;;;;AAMX;EANW,SAYA,aAAA,UAAuB,iCAAA;;WAEvB,OAAA;EAFA;;;;;EAAA,SAQA,YAAA,YAAwB,wBAAA;AAAA;AAInC;AAAA,KAAY,+BAAA;;UASK,2BAAA;EAT0B;EAAA,SAWhC,IAAA,EAAM,+BAAA;EAF2B;EAAA,SAIjC,IAAA;EAFqC;EAAA,SAIrC,OAAA;AAAA;;KAIC,6BAAA;;UAOK,yBAAA;EAPL;EAAA,SASD,IAAA,EAAM,6BAAA;;WAEN,UAAA;EAX8B;EAAA,SAa9B,eAAA;EAN+B;EAAA,SAQ/B,UAAA;EANmC;EAAA,SAQnC,UAAA;AAAA;;UAIM,4BAAA;EANN;EAAA,SAQA,OAAA;EANU;EAAA,SAQV,UAAA;EAJM;EAAA,SAMN,WAAA,WAAsB,2BAAA;;WAEtB,UAAA,WAAqB,yBAAA;AAAA;;KAIpB,uBAAA;;UAGK,oCAAA;EAPe;EAAA,SASrB,IAAA,EAAM,uBAAA;EATwC;EAAA,SAW9C,IAAA;EAPwB;EAAA,SASxB,OAAA;AAAA;;UAIM,oCAAA;EAVoC;EAAA,SAY1C,mBAAA,WAA8B,2BAAA;EAVD;EAAA,SAY7B,eAAA,WAA0B,2BAAA;EAZpB;EAAA,SAcN,OAAA,WAAkB,oCAAA;AAAA;;;;;AAtG7B;;;;iBCcgB,0BAAA,CACd,QAAA,EAAU,yBAAA,EACV,IAAA,EAAM,yBAAA,GACL,oCAAA;;;;ADjBH;;;;;AAGA;iBEagB,4BAAA,CACd,SAAA,EAAW,oBAAA,EACX,oBAAA,qBACA,QAAA,EAAU,yBAAA,GACT,4BAAA;;;;iBCHa,iCAAA,CACd,QAAA,EAAU,yBAAA,GACT,2BAAA;AHnBH;;;;;AAGA;;AAHA,iBG0GgB,8BAAA,CAA+B,KAAA,YAAiB,yBAAA"}

package/dist/adapter.mjs

@@ -0,0 +1,175 @@
+//#region src/adapter-model.ts
+/** Current serialized adapter-capability manifest format. */
+const ADAPTER_CAPABILITY_FORMAT_VERSION = 1;
+//#endregion
+//#region src/adapter-validate.ts
+const IDENTIFIER = /^[a-z0-9][a-z0-9._-]*$/;
+const DIAGNOSTIC_ORDER = {
+	"invalid-format-version": 0,
+	"invalid-adapter-id": 1,
+	"invalid-capability-id": 2,
+	"invalid-version": 3,
+	"invalid-version-range": 4,
+	"duplicate-capability": 5
+};
+/** Validates an adapter capability manifest without mutating it. */
+function validateAdapterCapabilityManifest(manifest) {
+	const diagnostics = [];
+	if ((manifest.formatVersion ?? 1) !== 1) diagnostics.push(diagnostic("invalid-format-version", "formatVersion", "unsupported adapter capability manifest format version"));
+	if (!IDENTIFIER.test(manifest.adapter)) diagnostics.push(diagnostic("invalid-adapter-id", "adapter", "adapter must be a lowercase portable identifier"));
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, capability] of (manifest.capabilities ?? []).entries()) {
+		const path = `capabilities.${index}`;
+		if (!IDENTIFIER.test(capability.id)) diagnostics.push(diagnostic("invalid-capability-id", `${path}.id`, "capability id must be a lowercase portable identifier"));
+		if (seen.has(capability.id)) diagnostics.push(diagnostic("duplicate-capability", `${path}.id`, "capability id must be unique within the adapter manifest"));
+		seen.add(capability.id);
+		if (capability.minVersion <= 0) diagnostics.push(diagnostic("invalid-version", `${path}.minVersion`, "minimum supported version must be greater than zero"));
+		if (capability.maxVersion <= 0) diagnostics.push(diagnostic("invalid-version", `${path}.maxVersion`, "maximum supported version must be greater than zero"));
+		if (capability.minVersion > capability.maxVersion) diagnostics.push(diagnostic("invalid-version-range", path, "minimum supported version must not exceed maximum supported version"));
+	}
+	return diagnostics.sort((left, right) => compareText$1(left.path, right.path) || DIAGNOSTIC_ORDER[left.code] - DIAGNOSTIC_ORDER[right.code] || compareText$1(left.message, right.message));
+}
+/**
+* Parses an untrusted manifest with strict field and primitive checks.
+*
+* Unknown fields, missing required fields, and mismatched primitive types
+* throw before negotiation. Semantic range errors remain available from
+* {@link validateAdapterCapabilityManifest}.
+*/
+function parseAdapterCapabilityManifest(value) {
+	assertRecord(value, "manifest");
+	assertKnownFields(value, [
+		"formatVersion",
+		"adapter",
+		"capabilities"
+	], "manifest");
+	if (value.formatVersion !== void 0 && typeof value.formatVersion !== "number") throw new TypeError("formatVersion must be a number");
+	if (typeof value.adapter !== "string") throw new TypeError("adapter must be a string");
+	if (value.capabilities !== void 0) {
+		if (!Array.isArray(value.capabilities)) throw new TypeError("capabilities must be an array");
+		for (const [index, capability] of value.capabilities.entries()) {
+			const path = `capabilities.${index}`;
+			assertRecord(capability, path);
+			assertKnownFields(capability, [
+				"id",
+				"minVersion",
+				"maxVersion"
+			], path);
+			if (typeof capability.id !== "string") throw new TypeError(`${path}.id must be a string`);
+			if (typeof capability.minVersion !== "number" || !Number.isSafeInteger(capability.minVersion) || capability.minVersion < 0) throw new TypeError(`${path}.minVersion must be a safe integer`);
+			if (typeof capability.maxVersion !== "number" || !Number.isSafeInteger(capability.maxVersion) || capability.maxVersion < 0) throw new TypeError(`${path}.maxVersion must be a safe integer`);
+		}
+	}
+	return value;
+}
+function diagnostic(code, path, message) {
+	return {
+		code,
+		path,
+		message
+	};
+}
+function assertRecord(value, path) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${path} must be an object`);
+}
+function assertKnownFields(value, expected, path) {
+	const known = new Set(expected);
+	const unknown = Object.keys(value).find((field) => !known.has(field));
+	if (unknown !== void 0) throw new TypeError(`${path} has unknown field ${unknown}`);
+}
+function compareText$1(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
+//#region src/adapter-compatibility.ts
+/**
+* Compares adapter capability support from older to newer.
+*
+* Adding support or widening an inclusive version range is additive.
+* Removing support or narrowing either bound is breaking.
+*/
+function compareAdapterCapabilities(previous, next) {
+	const previousDiagnostics = validateAdapterCapabilityManifest(previous);
+	const nextDiagnostics = validateAdapterCapabilityManifest(next);
+	if (previousDiagnostics.length > 0 || nextDiagnostics.length > 0) return {
+		previousDiagnostics,
+		nextDiagnostics,
+		changes: []
+	};
+	const changes = [];
+	if (previous.adapter !== next.adapter) changes.push(change("breaking", "adapter", "adapter identity changed"));
+	const oldSupport = byId(previous);
+	const newSupport = byId(next);
+	for (const id of [...oldSupport.keys()].filter((id) => !newSupport.has(id)).sort()) changes.push(change("breaking", `capabilities.${id}`, "capability support was removed"));
+	for (const id of [...newSupport.keys()].filter((id) => !oldSupport.has(id)).sort()) changes.push(change("additive", `capabilities.${id}`, "capability support was added"));
+	for (const [id, old] of oldSupport) {
+		const current = newSupport.get(id);
+		if (current === void 0) continue;
+		if (old.minVersion !== current.minVersion) changes.push(change(current.minVersion < old.minVersion ? "additive" : "breaking", `capabilities.${id}.minVersion`, current.minVersion < old.minVersion ? "minimum supported version decreased" : "minimum supported version increased"));
+		if (old.maxVersion !== current.maxVersion) changes.push(change(current.maxVersion > old.maxVersion ? "additive" : "breaking", `capabilities.${id}.maxVersion`, current.maxVersion > old.maxVersion ? "maximum supported version increased" : "maximum supported version decreased"));
+	}
+	changes.sort((left, right) => compareText(left.path, right.path) || compareText(left.kind, right.kind));
+	return {
+		previousDiagnostics,
+		nextDiagnostics,
+		changes
+	};
+}
+function byId(manifest) {
+	return new Map((manifest.capabilities ?? []).map((value) => [value.id, value]));
+}
+function change(kind, path, message) {
+	return {
+		kind,
+		path,
+		message
+	};
+}
+function compareText(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
+//#region src/adapter-negotiate.ts
+/**
+* Negotiates application capability requirements against one adapter.
+*
+* Requirement identifiers are deduplicated and sorted. Unknown application
+* capability identifiers fail closed instead of being treated as adapter
+* omissions. An invalid manifest never produces a compatible result.
+*/
+function negotiateAdapterCapabilities(marquette, requiredCapabilities, manifest) {
+	const diagnostics = validateAdapterCapabilityManifest(manifest);
+	const support = new Map((manifest.capabilities ?? []).map((capability) => [capability.id, capability]));
+	const mismatches = [...new Set(requiredCapabilities)].sort().flatMap((id) => mismatch(marquette, id, support.get(id), diagnostics.length === 0));
+	return {
+		adapter: manifest.adapter,
+		compatible: diagnostics.length === 0 && mismatches.length === 0,
+		diagnostics,
+		mismatches
+	};
+}
+function mismatch(marquette, id, support, manifestIsValid) {
+	const requirement = marquette.capabilities?.[id];
+	if (requirement === void 0) return [problem("unknown-requirement", id)];
+	if (!manifestIsValid) return [];
+	const requiredVersion = requirement.version ?? 1;
+	if (support === void 0) return [problem("missing-capability", id, requiredVersion)];
+	if (requiredVersion < support.minVersion) return [problem("version-below-minimum", id, requiredVersion, support)];
+	if (requiredVersion > support.maxVersion) return [problem("version-above-maximum", id, requiredVersion, support)];
+	return [];
+}
+function problem(code, capability, requiredVersion, support) {
+	return {
+		code,
+		capability,
+		...requiredVersion === void 0 ? {} : { requiredVersion },
+		...support === void 0 ? {} : {
+			minVersion: support.minVersion,
+			maxVersion: support.maxVersion
+		}
+	};
+}
+//#endregion
+export { ADAPTER_CAPABILITY_FORMAT_VERSION, compareAdapterCapabilities, negotiateAdapterCapabilities, parseAdapterCapabilityManifest, validateAdapterCapabilityManifest };
+
+//# sourceMappingURL=adapter.mjs.map

package/dist/adapter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.mjs","names":["compareText"],"sources":["../src/adapter-model.ts","../src/adapter-validate.ts","../src/adapter-compatibility.ts","../src/adapter-negotiate.ts"],"sourcesContent":["/** Current serialized adapter-capability manifest format. */\nexport const ADAPTER_CAPABILITY_FORMAT_VERSION = 1 as const;\n\n/** Inclusive version range supported for one capability contract. */\nexport interface AdapterCapabilitySupport {\n  /** Stable capability identifier from an application marquette. */\n  readonly id: string;\n  /** Oldest supported capability contract version, inclusive. */\n  readonly minVersion: number;\n  /** Newest supported capability contract version, inclusive. */\n  readonly maxVersion: number;\n}\n\n/** Versioned, language-neutral capabilities offered by one adapter. */\nexport interface AdapterCapabilityManifest {\n  /**\n   * Serialized manifest format.\n   *\n   * @default 1\n   */\n  readonly formatVersion?: typeof ADAPTER_CAPABILITY_FORMAT_VERSION;\n  /** Stable adapter identifier shown in diagnostics and reports. */\n  readonly adapter: string;\n  /**\n   * Supported capability ranges.\n   *\n   * @default []\n   */\n  readonly capabilities?: readonly AdapterCapabilitySupport[];\n}\n\n/** Stable validation code for an adapter capability manifest. */\nexport type AdapterCapabilityDiagnosticCode =\n  | \"invalid-format-version\"\n  | \"invalid-adapter-id\"\n  | \"invalid-capability-id\"\n  | \"invalid-version\"\n  | \"invalid-version-range\"\n  | \"duplicate-capability\";\n\n/** Deterministic validation diagnostic for an adapter capability manifest. */\nexport interface AdapterCapabilityDiagnostic {\n  /** Stable machine-readable diagnostic code. */\n  readonly code: AdapterCapabilityDiagnosticCode;\n  /** JSON-style path of the invalid value. */\n  readonly path: string;\n  /** Human-readable explanation. */\n  readonly message: string;\n}\n\n/** Stable incompatibility code emitted during capability negotiation. */\nexport type AdapterCapabilityMismatchCode =\n  | \"unknown-requirement\"\n  | \"missing-capability\"\n  | \"version-below-minimum\"\n  | \"version-above-maximum\";\n\n/** One failed adapter capability requirement. */\nexport interface AdapterCapabilityMismatch {\n  /** Stable machine-readable mismatch code. */\n  readonly code: AdapterCapabilityMismatchCode;\n  /** Required capability identifier. */\n  readonly capability: string;\n  /** Required contract version when the capability is declared. */\n  readonly requiredVersion?: number;\n  /** Adapter minimum when support exists. */\n  readonly minVersion?: number;\n  /** Adapter maximum when support exists. */\n  readonly maxVersion?: number;\n}\n\n/** Deterministic result of negotiating requirements with one adapter. */\nexport interface AdapterCapabilityNegotiation {\n  /** Adapter whose support was inspected. */\n  readonly adapter: string;\n  /** Whether the manifest is valid and every requirement is supported. */\n  readonly compatible: boolean;\n  /** Manifest validation failures, in stable path order. */\n  readonly diagnostics: readonly AdapterCapabilityDiagnostic[];\n  /** Unsupported or unknown requirements, in stable capability order. */\n  readonly mismatches: readonly AdapterCapabilityMismatch[];\n}\n\n/** Compatibility classification for one adapter capability change. */\nexport type CompatibilityChangeKind = \"additive\" | \"breaking\";\n\n/** One stable adapter capability compatibility change. */\nexport interface AdapterCapabilityCompatibilityChange {\n  /** Compatibility classification. */\n  readonly kind: CompatibilityChangeKind;\n  /** JSON-style path of the changed capability support. */\n  readonly path: string;\n  /** Human-readable summary. */\n  readonly message: string;\n}\n\n/** Deterministic compatibility report between two adapter manifests. */\nexport interface AdapterCapabilityCompatibilityReport {\n  /** Validation failures in the previous manifest. */\n  readonly previousDiagnostics: readonly AdapterCapabilityDiagnostic[];\n  /** Validation failures in the next manifest. */\n  readonly nextDiagnostics: readonly AdapterCapabilityDiagnostic[];\n  /** All changes in stable path order. */\n  readonly changes: readonly AdapterCapabilityCompatibilityChange[];\n}\n","import {\n  ADAPTER_CAPABILITY_FORMAT_VERSION,\n  type AdapterCapabilityDiagnostic,\n  type AdapterCapabilityDiagnosticCode,\n  type AdapterCapabilityManifest,\n} from \"./adapter-model.js\";\n\nconst IDENTIFIER = /^[a-z0-9][a-z0-9._-]*$/;\nconst DIAGNOSTIC_ORDER: Record<AdapterCapabilityDiagnosticCode, number> = {\n  \"invalid-format-version\": 0,\n  \"invalid-adapter-id\": 1,\n  \"invalid-capability-id\": 2,\n  \"invalid-version\": 3,\n  \"invalid-version-range\": 4,\n  \"duplicate-capability\": 5,\n};\n\n/** Validates an adapter capability manifest without mutating it. */\nexport function validateAdapterCapabilityManifest(\n  manifest: AdapterCapabilityManifest,\n): AdapterCapabilityDiagnostic[] {\n  const diagnostics: AdapterCapabilityDiagnostic[] = [];\n  if ((manifest.formatVersion ?? 1) !== ADAPTER_CAPABILITY_FORMAT_VERSION) {\n    diagnostics.push(\n      diagnostic(\n        \"invalid-format-version\",\n        \"formatVersion\",\n        \"unsupported adapter capability manifest format version\",\n      ),\n    );\n  }\n  if (!IDENTIFIER.test(manifest.adapter)) {\n    diagnostics.push(\n      diagnostic(\n        \"invalid-adapter-id\",\n        \"adapter\",\n        \"adapter must be a lowercase portable identifier\",\n      ),\n    );\n  }\n\n  const seen = new Set<string>();\n  for (const [index, capability] of (manifest.capabilities ?? []).entries()) {\n    const path = `capabilities.${index}`;\n    if (!IDENTIFIER.test(capability.id)) {\n      diagnostics.push(\n        diagnostic(\n          \"invalid-capability-id\",\n          `${path}.id`,\n          \"capability id must be a lowercase portable identifier\",\n        ),\n      );\n    }\n    if (seen.has(capability.id)) {\n      diagnostics.push(\n        diagnostic(\n          \"duplicate-capability\",\n          `${path}.id`,\n          \"capability id must be unique within the adapter manifest\",\n        ),\n      );\n    }\n    seen.add(capability.id);\n    if (capability.minVersion <= 0) {\n      diagnostics.push(\n        diagnostic(\n          \"invalid-version\",\n          `${path}.minVersion`,\n          \"minimum supported version must be greater than zero\",\n        ),\n      );\n    }\n    if (capability.maxVersion <= 0) {\n      diagnostics.push(\n        diagnostic(\n          \"invalid-version\",\n          `${path}.maxVersion`,\n          \"maximum supported version must be greater than zero\",\n        ),\n      );\n    }\n    if (capability.minVersion > capability.maxVersion) {\n      diagnostics.push(\n        diagnostic(\n          \"invalid-version-range\",\n          path,\n          \"minimum supported version must not exceed maximum supported version\",\n        ),\n      );\n    }\n  }\n\n  return diagnostics.sort(\n    (left, right) =>\n      compareText(left.path, right.path) ||\n      DIAGNOSTIC_ORDER[left.code] - DIAGNOSTIC_ORDER[right.code] ||\n      compareText(left.message, right.message),\n  );\n}\n\n/**\n * Parses an untrusted manifest with strict field and primitive checks.\n *\n * Unknown fields, missing required fields, and mismatched primitive types\n * throw before negotiation. Semantic range errors remain available from\n * {@link validateAdapterCapabilityManifest}.\n */\nexport function parseAdapterCapabilityManifest(value: unknown): AdapterCapabilityManifest {\n  assertRecord(value, \"manifest\");\n  assertKnownFields(value, [\"formatVersion\", \"adapter\", \"capabilities\"], \"manifest\");\n  if (value.formatVersion !== undefined && typeof value.formatVersion !== \"number\") {\n    throw new TypeError(\"formatVersion must be a number\");\n  }\n  if (typeof value.adapter !== \"string\") {\n    throw new TypeError(\"adapter must be a string\");\n  }\n  if (value.capabilities !== undefined) {\n    if (!Array.isArray(value.capabilities)) {\n      throw new TypeError(\"capabilities must be an array\");\n    }\n    for (const [index, capability] of value.capabilities.entries()) {\n      const path = `capabilities.${index}`;\n      assertRecord(capability, path);\n      assertKnownFields(capability, [\"id\", \"minVersion\", \"maxVersion\"], path);\n      if (typeof capability.id !== \"string\") throw new TypeError(`${path}.id must be a string`);\n      if (\n        typeof capability.minVersion !== \"number\" ||\n        !Number.isSafeInteger(capability.minVersion) ||\n        capability.minVersion < 0\n      ) {\n        throw new TypeError(`${path}.minVersion must be a safe integer`);\n      }\n      if (\n        typeof capability.maxVersion !== \"number\" ||\n        !Number.isSafeInteger(capability.maxVersion) ||\n        capability.maxVersion < 0\n      ) {\n        throw new TypeError(`${path}.maxVersion must be a safe integer`);\n      }\n    }\n  }\n  return value as unknown as AdapterCapabilityManifest;\n}\n\nfunction diagnostic(\n  code: AdapterCapabilityDiagnosticCode,\n  path: string,\n  message: string,\n): AdapterCapabilityDiagnostic {\n  return { code, path, message };\n}\n\nfunction assertRecord(value: unknown, path: string): asserts value is Record<string, unknown> {\n  if (value == null || typeof value !== \"object\" || Array.isArray(value)) {\n    throw new TypeError(`${path} must be an object`);\n  }\n}\n\nfunction assertKnownFields(\n  value: Record<string, unknown>,\n  expected: readonly string[],\n  path: string,\n): void {\n  const known = new Set(expected);\n  const unknown = Object.keys(value).find((field) => !known.has(field));\n  if (unknown !== undefined) throw new TypeError(`${path} has unknown field ${unknown}`);\n}\n\nfunction compareText(left: string, right: string): number {\n  return left < right ? -1 : left > right ? 1 : 0;\n}\n","import type {\n  AdapterCapabilityCompatibilityChange,\n  AdapterCapabilityCompatibilityReport,\n  AdapterCapabilityManifest,\n  AdapterCapabilitySupport,\n  CompatibilityChangeKind,\n} from \"./adapter-model.js\";\nimport { validateAdapterCapabilityManifest } from \"./adapter-validate.js\";\n\n/**\n * Compares adapter capability support from older to newer.\n *\n * Adding support or widening an inclusive version range is additive.\n * Removing support or narrowing either bound is breaking.\n */\nexport function compareAdapterCapabilities(\n  previous: AdapterCapabilityManifest,\n  next: AdapterCapabilityManifest,\n): AdapterCapabilityCompatibilityReport {\n  const previousDiagnostics = validateAdapterCapabilityManifest(previous);\n  const nextDiagnostics = validateAdapterCapabilityManifest(next);\n  if (previousDiagnostics.length > 0 || nextDiagnostics.length > 0) {\n    return { previousDiagnostics, nextDiagnostics, changes: [] };\n  }\n\n  const changes: AdapterCapabilityCompatibilityChange[] = [];\n  if (previous.adapter !== next.adapter) {\n    changes.push(change(\"breaking\", \"adapter\", \"adapter identity changed\"));\n  }\n\n  const oldSupport = byId(previous);\n  const newSupport = byId(next);\n  for (const id of [...oldSupport.keys()].filter((id) => !newSupport.has(id)).sort()) {\n    changes.push(change(\"breaking\", `capabilities.${id}`, \"capability support was removed\"));\n  }\n  for (const id of [...newSupport.keys()].filter((id) => !oldSupport.has(id)).sort()) {\n    changes.push(change(\"additive\", `capabilities.${id}`, \"capability support was added\"));\n  }\n  for (const [id, old] of oldSupport) {\n    const current = newSupport.get(id);\n    if (current === undefined) continue;\n    if (old.minVersion !== current.minVersion) {\n      changes.push(\n        change(\n          current.minVersion < old.minVersion ? \"additive\" : \"breaking\",\n          `capabilities.${id}.minVersion`,\n          current.minVersion < old.minVersion\n            ? \"minimum supported version decreased\"\n            : \"minimum supported version increased\",\n        ),\n      );\n    }\n    if (old.maxVersion !== current.maxVersion) {\n      changes.push(\n        change(\n          current.maxVersion > old.maxVersion ? \"additive\" : \"breaking\",\n          `capabilities.${id}.maxVersion`,\n          current.maxVersion > old.maxVersion\n            ? \"maximum supported version increased\"\n            : \"maximum supported version decreased\",\n        ),\n      );\n    }\n  }\n\n  changes.sort(\n    (left, right) => compareText(left.path, right.path) || compareText(left.kind, right.kind),\n  );\n  return { previousDiagnostics, nextDiagnostics, changes };\n}\n\nfunction byId(manifest: AdapterCapabilityManifest): Map<string, AdapterCapabilitySupport> {\n  return new Map((manifest.capabilities ?? []).map((value) => [value.id, value] as const));\n}\n\nfunction change(\n  kind: CompatibilityChangeKind,\n  path: string,\n  message: string,\n): AdapterCapabilityCompatibilityChange {\n  return { kind, path, message };\n}\n\nfunction compareText(left: string, right: string): number {\n  return left < right ? -1 : left > right ? 1 : 0;\n}\n","import type { ApplicationMarquette } from \"./model.js\";\nimport type {\n  AdapterCapabilityManifest,\n  AdapterCapabilityMismatch,\n  AdapterCapabilityMismatchCode,\n  AdapterCapabilityNegotiation,\n  AdapterCapabilitySupport,\n} from \"./adapter-model.js\";\nimport { validateAdapterCapabilityManifest } from \"./adapter-validate.js\";\n\n/**\n * Negotiates application capability requirements against one adapter.\n *\n * Requirement identifiers are deduplicated and sorted. Unknown application\n * capability identifiers fail closed instead of being treated as adapter\n * omissions. An invalid manifest never produces a compatible result.\n */\nexport function negotiateAdapterCapabilities(\n  marquette: ApplicationMarquette,\n  requiredCapabilities: readonly string[],\n  manifest: AdapterCapabilityManifest,\n): AdapterCapabilityNegotiation {\n  const diagnostics = validateAdapterCapabilityManifest(manifest);\n  const support = new Map(\n    (manifest.capabilities ?? []).map((capability) => [capability.id, capability] as const),\n  );\n  const mismatches = [...new Set(requiredCapabilities)]\n    .sort()\n    .flatMap((id) => mismatch(marquette, id, support.get(id), diagnostics.length === 0));\n\n  return {\n    adapter: manifest.adapter,\n    compatible: diagnostics.length === 0 && mismatches.length === 0,\n    diagnostics,\n    mismatches,\n  };\n}\n\nfunction mismatch(\n  marquette: ApplicationMarquette,\n  id: string,\n  support: AdapterCapabilitySupport | undefined,\n  manifestIsValid: boolean,\n): AdapterCapabilityMismatch[] {\n  const requirement = marquette.capabilities?.[id];\n  if (requirement === undefined) return [problem(\"unknown-requirement\", id)];\n  if (!manifestIsValid) return [];\n\n  const requiredVersion = requirement.version ?? 1;\n  if (support === undefined) return [problem(\"missing-capability\", id, requiredVersion)];\n  if (requiredVersion < support.minVersion) {\n    return [problem(\"version-below-minimum\", id, requiredVersion, support)];\n  }\n  if (requiredVersion > support.maxVersion) {\n    return [problem(\"version-above-maximum\", id, requiredVersion, support)];\n  }\n  return [];\n}\n\nfunction problem(\n  code: AdapterCapabilityMismatchCode,\n  capability: string,\n  requiredVersion?: number,\n  support?: AdapterCapabilitySupport,\n): AdapterCapabilityMismatch {\n  return {\n    code,\n    capability,\n    ...(requiredVersion === undefined ? {} : { requiredVersion }),\n    ...(support === undefined\n      ? {}\n      : { minVersion: support.minVersion, maxVersion: support.maxVersion }),\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/marquette",
-  "version": "0.321.0",
+  "version": "0.323.0",
   "description": "Typed application marquettes for every Vize target",
   "keywords": [
     "application-contract",
@@ -36,6 +36,11 @@
       "import": "./dist/validate.mjs",
       "default": "./dist/validate.mjs"
     },
+    "./adapter": {
+      "types": "./dist/adapter.d.mts",
+      "import": "./dist/adapter.mjs",
+      "default": "./dist/adapter.mjs"
+    },
     "./test-run": {
       "types": "./dist/test-run.d.mts",
       "import": "./dist/test-run.mjs",
@@ -67,6 +72,7 @@
       "default": "./dist/test-run-transition.mjs"
     },
     "./schema": "./dist/application-contract.schema.json",
+    "./adapter/schema": "./dist/adapter-capability-manifest.schema.json",
     "./test-run/schema": "./dist/test-run-evidence.schema.json",
     "./test-run/admission/schema": "./dist/test-run-admission.schema.json",
     "./test-run/check/schema": "./dist/test-run-check.schema.json",