@verndale/accessibility-standards 1.0.0 → 2.0.0

package/lib/validate.mjs

@@ -1,31 +1,262 @@
-import { compileApplicability } from './compile-applicability.mjs';
+import { compileApplicability, referencedFacts, validateExpression } from './compile-applicability.mjs';
+
+const SEMVER = /^\d+\.\d+\.\d+$/;
+const RECORD_ID = /^[a-z][a-z0-9.-]+$/;
+const FACT_ID = /^[a-z][a-z0-9_-]*(?:\.[a-z][a-z0-9_-]*)+$/;
+const RECORD_PREFIX = {
+  foundation: 'foundation.',
+  semantic: 'semantics.',
+  pattern: 'pattern.',
+  policy: 'policy.'
+};
+
+function isRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function validateStringArray(label, value, errors, { required = true } = {}) {
+  if (!Array.isArray(value) || (required && value.length === 0) || value.some((item) => !isNonEmptyString(item))) {
+    errors.push(`${label} must be ${required ? 'a non-empty' : 'an'} array of non-empty strings`);
+    return false;
+  }
+  if (new Set(value).size !== value.length) errors.push(`${label} must not contain duplicates`);
+  return true;
+}
+
+function validateAuthorityRecord(record, expectedKind, errors) {
+  const label = isRecord(record) && isNonEmptyString(record.id) ? record.id : `<malformed ${expectedKind}>`;
+  if (!isRecord(record)) {
+    errors.push(`Malformed ${expectedKind} record`);
+    return;
+  }
+  if (!isNonEmptyString(record.id) || !RECORD_ID.test(record.id) || !record.id.startsWith(RECORD_PREFIX[expectedKind])) errors.push(`${label} has invalid ${expectedKind} ID`);
+  if (!SEMVER.test(record.version ?? '')) errors.push(`${label} has invalid record version`);
+  if (!isNonEmptyString(record.title)) errors.push(`${label} has no title`);
+  if (record.kind !== expectedKind) errors.push(`${label} must declare kind ${expectedKind}`);
+  if (expectedKind !== 'pattern' && !isNonEmptyString(record.requirement)) errors.push(`${label} has no requirement`);
+}
+
+function validateFacts(catalog, errors) {
+  if (!isRecord(catalog) || catalog.version !== 1 || !isRecord(catalog.facts) || Object.keys(catalog.facts).length === 0) {
+    errors.push('Malformed applicability fact catalog');
+    return {};
+  }
+  for (const [id, definition] of Object.entries(catalog.facts)) {
+    if (!FACT_ID.test(id)) errors.push(`Invalid applicability fact ID: ${id}`);
+    if (!isRecord(definition) || !['boolean', 'string', 'array'].includes(definition.type)) {
+      errors.push(`Fact ${id} has unsupported type ${definition?.type ?? '<missing>'}`);
+      continue;
+    }
+    const extraKeys = Object.keys(definition).filter((key) => !['type', 'items', 'source', 'derived'].includes(key));
+    if (extraKeys.length) errors.push(`Fact ${id} has unsupported fields: ${extraKeys.join(', ')}`);
+    if (definition.type === 'array' && definition.items !== 'string') errors.push(`Fact ${id} must declare string array items`);
+    if (definition.type !== 'array' && Object.hasOwn(definition, 'items')) errors.push(`Fact ${id} cannot declare array items`);
+    if (Object.hasOwn(definition, 'source') && !isNonEmptyString(definition.source)) errors.push(`Fact ${id} has invalid source`);
+    if (Object.hasOwn(definition, 'derived') && definition.derived !== true) errors.push(`Fact ${id} has invalid derived marker`);
+    if (Object.hasOwn(definition, 'source') && Object.hasOwn(definition, 'derived')) errors.push(`Fact ${id} cannot be both sourced and derived`);
+  }
+  if (catalog.facts['component.ui_pattern_ids']?.source !== 'ui-design-brain') errors.push('component.ui_pattern_ids must be sourced from ui-design-brain');
+  if (catalog.facts['component.accessibility_pattern_ids']?.derived !== true) errors.push('component.accessibility_pattern_ids must be derived');
+  return catalog.facts;
+}
 
 export function validateStandards(data) {
   const errors = [];
-  const records = [...data.foundations, ...data.semantics, ...data.patterns, ...data.policies];
+  if (data.contract?.schema_version !== 2 || data.contract?.package_version !== '2.0.0') errors.push('Expected accessibility contract schema 2 targeting package 2.0.0');
+  if (data.package?.version !== data.contract?.package_version) errors.push(`Installed package version ${data.package?.version ?? '<missing>'} does not match contract target ${data.contract?.package_version ?? '<missing>'}`);
+  validateSources(data.sources, errors);
+  validateProfiles(data.profiles, data.contract?.package_version, errors);
+  validateProfileTemplates(data.profileTemplates, errors);
+  const foundations = Array.isArray(data.foundations) ? data.foundations : [];
+  const semantics = Array.isArray(data.semantics) ? data.semantics : [];
+  const patterns = Array.isArray(data.patterns) ? data.patterns : [];
+  const policies = Array.isArray(data.policies) ? data.policies : [];
+  if (!Array.isArray(data.foundations) || !foundations.length) errors.push('Foundations must be a non-empty array');
+  if (!Array.isArray(data.semantics) || !semantics.length) errors.push('Semantics must be a non-empty array');
+  if (!Array.isArray(data.patterns) || !patterns.length) errors.push('Patterns must be a non-empty array');
+  if (!Array.isArray(data.policies) || !policies.length) errors.push('Policies must be a non-empty array');
+  const records = [...foundations, ...semantics, ...patterns, ...policies];
   const ids = new Set();
-  for (const record of records) {
-    if (!record.id || !record.version || !record.title) errors.push(`Malformed record: ${JSON.stringify(record)}`);
-    if (ids.has(record.id)) errors.push(`Duplicate authority: ${record.id}`);
-    ids.add(record.id);
-  }
-  const semanticIds = new Set(data.semantics.map(({ id }) => id));
-  for (const pattern of data.patterns) {
-    if (!pattern.requires?.length) errors.push(`Orphan pattern: ${pattern.id}`);
-    for (const dependency of pattern.requires ?? []) if (!semanticIds.has(dependency)) errors.push(`${pattern.id} has missing semantic dependency ${dependency}`);
-    if (!pattern.activation || !pattern.scope || !pattern.behavior?.length || !pattern.functional_spec_bindings?.length || !pattern.implementation_outcomes?.length || !pattern.evidence_routes?.length) errors.push(`Incomplete pattern contract: ${pattern.id}`);
-  }
-  const proofKinds = new Set(Object.keys(data.evidence.proof_kinds));
-  for (const semantic of data.semantics) for (const route of semantic.proof ?? []) if (!proofKinds.has(route)) errors.push(`${semantic.id} uses unsupported proof route ${route}`);
-  for (const pattern of data.patterns) for (const route of pattern.evidence_routes ?? []) if (!proofKinds.has(route)) errors.push(`${pattern.id} uses unsupported proof route ${route}`);
-  for (const row of data.matrix.rows) {
-    try { compileApplicability({ rows: [row] }, data.facts); } catch (error) { errors.push(`${row.id}: ${error.message}`); }
-    for (const outcome of row.outcomes) if (!ids.has(outcome)) errors.push(`${row.id} references unknown outcome ${outcome}`);
-    for (const route of row.evidence) if (!proofKinds.has(route)) errors.push(`${row.id} uses unsupported proof route ${route}`);
-  }
-  const lanes = new Set([...data.semantics.flatMap((item) => item.proof), ...data.patterns.flatMap((item) => item.evidence_routes), ...data.matrix.rows.flatMap((item) => item.evidence)]);
+  for (const [kind, group] of [['foundation', foundations], ['semantic', semantics], ['pattern', patterns], ['policy', policies]]) {
+    for (const record of group) {
+      validateAuthorityRecord(record, kind, errors);
+      if (!isRecord(record) || !isNonEmptyString(record.id)) continue;
+      if (ids.has(record.id)) errors.push(`Duplicate authority: ${record.id}`);
+      ids.add(record.id);
+    }
+  }
+  const facts = validateFacts(data.facts, errors);
+  const semanticIds = new Set(semantics.map(({ id }) => id));
+  const patternIds = new Set(patterns.map(({ id }) => id));
+  for (const semantic of semantics) validateStringArray(`${semantic.id ?? '<malformed semantic>'} proof`, semantic.proof, errors);
+  for (const pattern of patterns) {
+    const id = pattern.id ?? '<malformed pattern>';
+    if (!validateStringArray(`${id} semantic dependencies`, pattern.requires, errors)) errors.push(`Orphan pattern: ${id}`);
+    for (const dependency of Array.isArray(pattern.requires) ? pattern.requires : []) if (!semanticIds.has(dependency)) errors.push(`${id} has missing semantic dependency ${dependency}`);
+    if (!isNonEmptyString(pattern.scope)) errors.push(`${id} has no scope`);
+    validateStringArray(`${id} behavior`, pattern.behavior, errors);
+    validateStringArray(`${id} product decisions`, pattern.product_decisions, errors);
+    validateStringArray(`${id} Functional Spec bindings`, pattern.functional_spec_bindings, errors);
+    validateStringArray(`${id} implementation outcomes`, pattern.implementation_outcomes, errors);
+    validateStringArray(`${id} evidence routes`, pattern.evidence_routes, errors);
+    try { validateExpression(pattern.activation, facts); } catch (error) { errors.push(`${id} activation: ${error.message}`); }
+  }
+  const proofKindObject = isRecord(data.evidence?.proof_kinds) ? data.evidence.proof_kinds : {};
+  if (data.evidence?.version !== 1 || !Object.keys(proofKindObject).length || !isNonEmptyString(data.evidence?.rule)) errors.push('Malformed evidence routing contract');
+  const expectedProofKinds = ['axe', 'e2e', 'human', 'unit'];
+  if (JSON.stringify(Object.keys(proofKindObject).sort()) !== JSON.stringify(expectedProofKinds)) errors.push('Evidence routes must be exactly unit, axe, e2e, and human');
+  const proofKinds = new Set(Object.keys(proofKindObject));
+  for (const [kind, route] of Object.entries(proofKindObject)) {
+    if (!isRecord(route) || !isNonEmptyString(route.purpose) || route.required_capability !== kind) errors.push(`Malformed evidence route ${kind}`);
+  }
+  for (const semantic of semantics) for (const route of Array.isArray(semantic.proof) ? semantic.proof : []) if (!proofKinds.has(route)) errors.push(`${semantic.id} uses unsupported proof route ${route}`);
+  for (const pattern of patterns) for (const route of Array.isArray(pattern.evidence_routes) ? pattern.evidence_routes : []) if (!proofKinds.has(route)) errors.push(`${pattern.id} uses unsupported proof route ${route}`);
+  const rows = Array.isArray(data.matrix?.rows) ? data.matrix.rows : [];
+  if (data.matrix?.version !== 1 || !rows.length) errors.push('Malformed applicability matrix');
+  const rowIds = new Set();
+  for (const row of rows) {
+    const id = row?.id ?? '<malformed applicability row>';
+    if (!isRecord(row) || !/^applicability\.[a-z0-9]+(?:[.-][a-z0-9]+)*$/.test(id)) errors.push(`Invalid applicability row ID: ${id}`);
+    if (rowIds.has(id)) errors.push(`Duplicate applicability row: ${id}`);
+    rowIds.add(id);
+    validateStringArray(`${id} outcomes`, row?.outcomes, errors);
+    validateStringArray(`${id} evidence`, row?.evidence, errors);
+    try { compileApplicability({ rows: [row] }, data.facts); } catch (error) { errors.push(`${id}: ${error.message}`); }
+    for (const outcome of Array.isArray(row?.outcomes) ? row.outcomes : []) if (!ids.has(outcome)) errors.push(`${id} references unknown outcome ${outcome}`);
+    for (const route of Array.isArray(row?.evidence) ? row.evidence : []) if (!proofKinds.has(route)) errors.push(`${id} uses unsupported proof route ${route}`);
+  }
+  const lanes = new Set([...semantics.flatMap((item) => Array.isArray(item.proof) ? item.proof : []), ...patterns.flatMap((item) => Array.isArray(item.evidence_routes) ? item.evidence_routes : []), ...rows.flatMap((item) => Array.isArray(item.evidence) ? item.evidence : [])]);
   for (const lane of proofKinds) if (!lanes.has(lane)) errors.push(`Dead evidence lane: ${lane}`);
-  if (data.matrix.rows.length !== 18) errors.push(`Expected 18 applicability rows, found ${data.matrix.rows.length}`);
+  validateUiDesignBrainBindings(data.uiDesignBrainBindings, { facts }, semanticIds, patternIds, errors);
+  if (rows.length !== 19) errors.push(`Expected 19 applicability rows, found ${rows.length}`);
   if (errors.length) throw new Error(errors.join('\n'));
-  return { records: records.length, semantics: data.semantics.length, patterns: data.patterns.length, applicability: data.matrix.rows.length };
+  return { records: records.length, semantics: semantics.length, patterns: patterns.length, applicability: rows.length, uiPatternBindings: data.uiDesignBrainBindings.bindings.length };
+}
+
+function validateProfileTemplates(profileTemplates, errors) {
+  const expected = {
+    conductor: ['applicability/README.md', 'evidence/README.md', 'patterns/README.md', 'semantics/README.md'],
+    'ai-orchestration': ['implementation/README.md', 'patterns/README.md', 'review/README.md', 'semantics/README.md', 'testing/README.md']
+  };
+  if (!isRecord(profileTemplates) || JSON.stringify(Object.keys(profileTemplates).sort()) !== JSON.stringify(Object.keys(expected).sort())) {
+    errors.push('Profile templates must be exactly conductor and ai-orchestration');
+    return;
+  }
+  for (const [profile, paths] of Object.entries(expected)) {
+    const templates = profileTemplates[profile];
+    if (!isRecord(templates) || JSON.stringify(Object.keys(templates).sort()) !== JSON.stringify(paths)) {
+      errors.push(`Invalid profile template set: ${profile}`);
+      continue;
+    }
+    for (const [path, content] of Object.entries(templates)) {
+      if (!isNonEmptyString(content)) errors.push(`Empty profile template: ${profile}/${path}`);
+    }
+  }
+}
+
+function validateSources(sources, errors) {
+  if (!isRecord(sources) || sources.version !== 1 || !Array.isArray(sources.authorities) || !sources.authorities.length) {
+    errors.push('Malformed standards source hierarchy');
+    return;
+  }
+  const authorityIds = new Set();
+  for (const authority of sources.authorities) {
+    if (!isRecord(authority) || !isNonEmptyString(authority.id) || !/^https:\/\//.test(authority.url ?? '') || typeof authority.normative !== 'boolean') {
+      errors.push(`Malformed standards authority ${authority?.id ?? '<missing>'}`);
+      continue;
+    }
+    if (authorityIds.has(authority.id)) errors.push(`Duplicate standards authority ${authority.id}`);
+    authorityIds.add(authority.id);
+  }
+  if (!validateStringArray('Standards precedence', sources.precedence, errors)) return;
+  for (const id of authorityIds) if (!sources.precedence.includes(id)) errors.push(`Standards precedence omits authority ${id}`);
+}
+
+function validateProfiles(profiles, packageVersion, errors) {
+  const expected = {
+    conductor: ['ui-pattern-bindings', 'semantics', 'patterns', 'applicability', 'evidence'],
+    'ai-orchestration': ['ui-pattern-bindings', 'semantics', 'patterns', 'implementation', 'testing', 'review']
+  };
+  if (!isRecord(profiles) || JSON.stringify(Object.keys(profiles).sort()) !== JSON.stringify(Object.keys(expected).sort())) {
+    errors.push('Profile contracts must be exactly conductor and ai-orchestration');
+    return;
+  }
+  for (const [name, channels] of Object.entries(expected)) {
+    const profile = profiles[name];
+    if (!isRecord(profile) || profile.name !== name || profile.version !== packageVersion || JSON.stringify(profile.channels) !== JSON.stringify(channels)) {
+      errors.push(`Invalid or incorrectly ordered profile contract: ${name}`);
+    }
+  }
+}
+
+function validateUiDesignBrainBindings(contract, facts, semanticIds, patternIds, errors) {
+  if (contract?.version !== 1 || !contract.source || !Array.isArray(contract.bindings)) {
+    errors.push('Malformed UI Design Brain binding contract');
+    return;
+  }
+  if (contract.source.package !== '@verndale/ui-design-brain') errors.push('UI Design Brain binding source package is invalid');
+  if (contract.source.repository !== 'https://github.com/verndale/ui-design-brain') errors.push('UI Design Brain binding repository is invalid');
+  if (contract.source.tracking_issue !== 'https://github.com/verndale/ui-design-brain/issues/47') errors.push('UI Design Brain binding tracking issue is invalid');
+  if (contract.source.package_version !== '1.16.0') errors.push('UI Design Brain projector package version is invalid');
+  if (contract.source.catalog_authority_version !== '1.15.1') errors.push('UI Design Brain catalog authority version is invalid');
+  if (!/^sha256:[a-f0-9]{64}$/.test(contract.source.source_digest ?? '')) errors.push('UI Design Brain source digest is invalid');
+  if (!/^sha256:[a-f0-9]{64}$/.test(contract.source.manifest_digest ?? '')) errors.push('UI Design Brain manifest digest is invalid');
+  if (contract.source.pattern_count !== contract.bindings.length) errors.push(`UI Design Brain binding count ${contract.bindings.length} does not match source count ${contract.source.pattern_count}`);
+
+  const expectedOrder = contract.bindings.map(({ ui_pattern_id }) => ui_pattern_id).sort();
+  const actualOrder = contract.bindings.map(({ ui_pattern_id }) => ui_pattern_id);
+  if (JSON.stringify(actualOrder) !== JSON.stringify(expectedOrder)) errors.push('UI Design Brain bindings must be sorted by canonical ui_pattern_id');
+  const seen = new Set();
+  for (const binding of contract.bindings) {
+    const prefix = `UI Design Brain binding ${binding.ui_pattern_id ?? '<missing>'}`;
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(binding.ui_pattern_id ?? '')) errors.push(`${prefix} has invalid canonical ID`);
+    if (seen.has(binding.ui_pattern_id)) errors.push(`${prefix} is duplicated`);
+    seen.add(binding.ui_pattern_id);
+    if (!['direct', 'candidate', 'baseline-only'].includes(binding.classification)) errors.push(`${prefix} has invalid classification ${binding.classification}`);
+    validateSortedUnique(`${prefix} pattern_ids`, binding.pattern_ids ?? [], errors);
+    for (const patternId of binding.pattern_ids ?? []) if (!patternIds.has(patternId)) errors.push(`${prefix} references unknown pattern ${patternId}`);
+    validateSortedUnique(`${prefix} baseline_semantic_ids`, binding.baseline_semantic_ids ?? [], errors);
+    for (const semanticId of binding.baseline_semantic_ids ?? []) if (!semanticIds.has(semanticId)) errors.push(`${prefix} references unknown baseline semantic ${semanticId}`);
+
+    if (binding.classification === 'direct') {
+      if (!binding.pattern_ids?.length) errors.push(`${prefix} must declare at least one direct pattern`);
+      if (binding.candidates || binding.discriminator_facts) errors.push(`${prefix} direct mapping cannot declare candidates`);
+    } else if (binding.classification === 'baseline-only') {
+      if (binding.pattern_ids || binding.candidates || binding.discriminator_facts) errors.push(`${prefix} baseline-only mapping cannot declare specialized patterns`);
+      if (!binding.baseline_semantic_ids?.length) errors.push(`${prefix} baseline-only mapping must declare at least one baseline semantic`);
+    } else if (binding.classification === 'candidate') {
+      if (!binding.candidates?.length || !binding.discriminator_facts?.length) errors.push(`${prefix} candidate mapping requires candidates and discriminator facts`);
+      validateSortedUnique(`${prefix} discriminator_facts`, binding.discriminator_facts ?? [], errors);
+      for (const fact of binding.discriminator_facts ?? []) if (!facts.facts[fact]) errors.push(`${prefix} references unknown discriminator fact ${fact}`);
+      const candidatePatternIds = [];
+      const usedFacts = new Set();
+      for (const candidate of binding.candidates ?? []) {
+        candidatePatternIds.push(candidate.pattern_id);
+        if (!patternIds.has(candidate.pattern_id)) errors.push(`${prefix} references unknown candidate pattern ${candidate.pattern_id}`);
+        try {
+          validateExpression(candidate.when, facts.facts);
+          for (const fact of referencedFacts(candidate.when)) usedFacts.add(fact);
+        } catch (error) {
+          errors.push(`${prefix} ${candidate.pattern_id}: ${error.message}`);
+        }
+      }
+      validateSortedUnique(`${prefix} candidate pattern IDs`, candidatePatternIds, errors);
+      const declaredFacts = [...(binding.discriminator_facts ?? [])].sort();
+      const referenced = [...usedFacts].sort();
+      if (JSON.stringify(declaredFacts) !== JSON.stringify(referenced)) errors.push(`${prefix} discriminator facts do not exactly match candidate expressions`);
+    }
+  }
+}
+
+function validateSortedUnique(label, values, errors) {
+  if (!Array.isArray(values) || values.some((value) => !isNonEmptyString(value))) {
+    errors.push(`${label} must be an array of non-empty strings`);
+    return;
+  }
+  const sorted = [...new Set(values)].sort();
+  if (JSON.stringify(values) !== JSON.stringify(sorted)) errors.push(`${label} must be sorted and unique`);
 }

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@verndale/accessibility-standards",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Deterministic accessibility semantics, patterns, applicability, and consumer projections",
   "type": "module",
   "private": false,
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/verndale/accessibility-standards.git"
+  },
+  "packageManager": "pnpm@11.1.1",
   "engines": {
     "node": ">=24.14.0"
   },
@@ -21,26 +26,34 @@
     "README.md",
     "OPERATING.md"
   ],
+  "scripts": {
+    "build": "node bin/accessibility-standards.mjs build",
+    "check": "node bin/accessibility-standards.mjs validate",
+    "test": "node --test tests/unit/*.test.mjs && pnpm release:preflight:selftest",
+    "contract:version:check": "node scripts/check-package-contract.cjs",
+    "verify:ci": "pnpm contract:version:check && pnpm check && pnpm test && pnpm build && git diff --exit-code -- . ':!dist'",
+    "release:preflight": "node scripts/check-release-commit.cjs",
+    "release:preflight:selftest": "node scripts/check-release-commit.selftest.cjs",
+    "prepack": "node scripts/check-package-contract.cjs",
+    "graph:build": "node scripts/wiki/build-graph.cjs",
+    "graph:check": "node scripts/wiki/build-graph.cjs --check",
+    "wiki:check": "node scripts/wiki/check.cjs",
+    "prepare": "node scripts/install-hooks.mjs"
+  },
   "devDependencies": {
     "@semantic-release/changelog": "6.0.3",
+    "@semantic-release/commit-analyzer": "13.0.1",
     "@semantic-release/git": "10.0.1",
     "@semantic-release/github": "12.0.8",
     "@semantic-release/npm": "13.1.5",
     "@verndale/ai-commit": "2.7.0",
     "@verndale/ai-pr": "1.3.5",
+    "ajv": "8.20.0",
+    "conventional-changelog-conventionalcommits": "9.3.1",
     "semantic-release": "25.0.3"
   },
   "publishConfig": {
     "access": "public",
     "provenance": true
-  },
-  "scripts": {
-    "build": "node bin/accessibility-standards.mjs build",
-    "check": "node bin/accessibility-standards.mjs validate",
-    "test": "node --test tests/unit/*.test.mjs",
-    "verify:ci": "pnpm check && pnpm test && pnpm build && git diff --exit-code -- . ':!dist'",
-    "graph:build": "node scripts/wiki/build-graph.cjs",
-    "graph:check": "node scripts/wiki/build-graph.cjs --check",
-    "wiki:check": "node scripts/wiki/check.cjs"
   }
-}
+}

package/profiles/ai-orchestration/profile.json

@@ -1 +1 @@
-{"name":"ai-orchestration","version":"1.0.0","channels":["semantics","patterns","implementation","testing","review"]}
+{"name":"ai-orchestration","version":"2.0.0","channels":["ui-pattern-bindings","semantics","patterns","implementation","testing","review"]}

package/profiles/conductor/profile.json

@@ -1 +1 @@
-{"name":"conductor","version":"1.0.0","channels":["semantics","patterns","applicability","evidence"]}
+{"name":"conductor","version":"2.0.0","channels":["ui-pattern-bindings","semantics","patterns","applicability","evidence"]}

package/schemas/consumer-config.schema.json

@@ -1 +1 @@
-{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"consumer-config.schema.json","type":"object","required":["package","profile","routes"],"properties":{"package":{"const":"@verndale/accessibility-standards@1.0.0"},"profile":{"enum":["conductor","ai-orchestration"]},"routes":{"type":"string"},"outputRoot":{"type":"string"}},"additionalProperties":false}
+{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"consumer-config.schema.json","type":"object","required":["package","profile","routes"],"properties":{"package":{"const":"@verndale/accessibility-standards@2.0.0"},"profile":{"enum":["conductor","ai-orchestration"]},"routes":{"type":"string"},"outputRoot":{"type":"string"}},"additionalProperties":false}

package/schemas/contract.schema.json

@@ -0,0 +1 @@
+{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"contract.schema.json","type":"object","required":["schema_version","package_version"],"additionalProperties":false,"properties":{"schema_version":{"type":"integer","const":2},"package_version":{"type":"string","const":"2.0.0"}}}

package/schemas/manifest.schema.json

@@ -1 +1 @@
-{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"manifest.schema.json","type":"object","required":["package","schema_version","records"],"properties":{"package":{"type":"string"},"schema_version":{"type":"integer"},"records":{"type":"array","items":{"type":"object","required":["id","digest"]}}}}
+{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"manifest.schema.json","type":"object","required":["_generated","package","schema_version","source_digest","profile_digests","ui_design_brain","records"],"properties":{"_generated":{"type":"string"},"package":{"type":"string"},"schema_version":{"type":"integer"},"source_digest":{"type":"string","pattern":"^[a-f0-9]{64}$"},"profile_digests":{"type":"object"},"ui_design_brain":{"type":"object","required":["package","package_version","catalog_authority_version","source_digest","manifest_digest","binding_digest"]},"records":{"type":"array","items":{"type":"object","required":["id","digest"]}}}}

package/schemas/projection-manifest.schema.json

@@ -1 +1,84 @@
-{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"projection-manifest.schema.json","type":"object","required":["package","profile","digests","projected_ids","lane_coverage"],"properties":{"package":{"type":"string"},"profile":{"type":"string"},"digests":{"type":"object"},"projected_ids":{"type":"array","items":{"type":"string"}},"lane_coverage":{"type":"object"}}}
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "projection-manifest.schema.json",
+  "$defs": {
+    "digest": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "uiDesignBrain": {
+      "type": "object",
+      "required": ["package", "package_version", "catalog_authority_version", "source_digest", "manifest_digest", "binding_digest"]
+    },
+    "consumer": {
+      "type": "object",
+      "required": [
+        "_generated",
+        "package",
+        "profile",
+        "profile_version",
+        "schema_version",
+        "digests",
+        "ui_design_brain",
+        "ui_pattern_ids",
+        "projected_ids",
+        "lane_coverage",
+        "output_paths",
+        "output_digests",
+        "manifest_digest"
+      ],
+      "properties": {
+        "_generated": { "type": "string" },
+        "package": { "type": "string" },
+        "profile": { "enum": ["conductor", "ai-orchestration"] },
+        "profile_version": { "type": "string" },
+        "schema_version": { "type": "integer" },
+        "digests": {
+          "type": "object",
+          "required": ["source", "profile", "ui_design_brain_bindings", "config", "routes"],
+          "additionalProperties": { "$ref": "#/$defs/digest" }
+        },
+        "ui_design_brain": { "$ref": "#/$defs/uiDesignBrain" },
+        "ui_pattern_ids": { "type": "array", "items": { "type": "string" }, "uniqueItems": true },
+        "projected_ids": { "type": "array", "items": { "type": "string" }, "uniqueItems": true },
+        "lane_coverage": { "type": "object" },
+        "output_paths": { "type": "object", "additionalProperties": { "type": "string" } },
+        "output_digests": { "type": "object", "additionalProperties": { "$ref": "#/$defs/digest" } },
+        "manifest_digest": { "$ref": "#/$defs/digest" }
+      },
+      "additionalProperties": true
+    },
+    "distribution": {
+      "type": "object",
+      "required": ["_generated", "package", "schema_version", "source_digest", "profile_digests", "ui_design_brain", "profiles"],
+      "properties": {
+        "_generated": { "type": "string" },
+        "package": { "type": "string" },
+        "schema_version": { "type": "integer" },
+        "source_digest": { "$ref": "#/$defs/digest" },
+        "profile_digests": {
+          "type": "object",
+          "required": ["conductor", "ai-orchestration"],
+          "additionalProperties": { "$ref": "#/$defs/digest" }
+        },
+        "ui_design_brain": { "$ref": "#/$defs/uiDesignBrain" },
+        "profiles": {
+          "type": "object",
+          "required": ["conductor", "ai-orchestration"],
+          "additionalProperties": {
+            "type": "object",
+            "required": ["version", "profile_digest", "source_digest", "outputs"],
+            "properties": {
+              "version": { "type": "string" },
+              "profile_digest": { "$ref": "#/$defs/digest" },
+              "source_digest": { "$ref": "#/$defs/digest" },
+              "outputs": { "type": "object", "additionalProperties": { "$ref": "#/$defs/digest" } }
+            }
+          }
+        }
+      },
+      "additionalProperties": true
+    }
+  },
+  "oneOf": [
+    { "$ref": "#/$defs/consumer" },
+    { "$ref": "#/$defs/distribution" }
+  ]
+}

package/schemas/ui-design-brain-bindings.schema.json

@@ -0,0 +1,86 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "ui-design-brain-bindings.schema.json",
+  "type": "object",
+  "required": ["version", "source", "bindings"],
+  "additionalProperties": false,
+  "properties": {
+    "version": { "type": "integer", "const": 1 },
+    "source": {
+      "type": "object",
+      "required": ["package", "package_version", "catalog_authority_version", "repository", "manifest_path", "source_digest", "manifest_digest", "pattern_count", "tracking_issue"],
+      "additionalProperties": false,
+      "properties": {
+        "package": { "const": "@verndale/ui-design-brain" },
+        "package_version": { "const": "1.16.0" },
+        "catalog_authority_version": { "const": "1.15.1" },
+        "repository": { "const": "https://github.com/verndale/ui-design-brain" },
+        "manifest_path": { "const": "skills/ui-design-brain/catalog-manifest.json" },
+        "source_digest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
+        "manifest_digest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
+        "pattern_count": { "type": "integer", "minimum": 1 },
+        "tracking_issue": { "const": "https://github.com/verndale/ui-design-brain/issues/47" }
+      }
+    },
+    "bindings": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["ui_pattern_id", "classification"],
+        "additionalProperties": false,
+        "properties": {
+          "ui_pattern_id": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+          "classification": { "enum": ["direct", "candidate", "baseline-only"] },
+          "pattern_ids": {
+            "type": "array",
+            "items": { "type": "string", "pattern": "^pattern\\." },
+            "uniqueItems": true
+          },
+          "baseline_semantic_ids": {
+            "type": "array",
+            "items": { "type": "string", "pattern": "^semantics\\." },
+            "minItems": 1,
+            "uniqueItems": true
+          },
+          "discriminator_facts": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+          },
+          "candidates": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "required": ["pattern_id", "when"],
+              "additionalProperties": false,
+              "properties": {
+                "pattern_id": { "type": "string", "pattern": "^pattern\\." },
+                "when": { "type": "object", "minProperties": 1, "maxProperties": 1 }
+              }
+            }
+          }
+        },
+        "allOf": [
+          {
+            "if": { "properties": { "classification": { "const": "direct" } } },
+            "then": { "required": ["pattern_ids"], "not": { "anyOf": [{ "required": ["candidates"] }, { "required": ["discriminator_facts"] }] } }
+          },
+          {
+            "if": { "properties": { "classification": { "const": "candidate" } } },
+            "then": { "required": ["discriminator_facts", "candidates"] }
+          },
+          {
+            "if": { "properties": { "classification": { "const": "baseline-only" } } },
+            "then": {
+              "required": ["baseline_semantic_ids"],
+              "not": { "anyOf": [{ "required": ["pattern_ids"] }, { "required": ["candidates"] }, { "required": ["discriminator_facts"] }] }
+            }
+          }
+        ]
+      }
+    }
+  }
+}

package/src/applicability/facts.yml

@@ -1 +1,29 @@
-{"version":1,"facts":{"artifact.page_context":{"type":"boolean"},"content.has_non_text":{"type":"boolean"},"content.has_media":{"type":"boolean"},"component.has_form_fields":{"type":"boolean"},"component.submission_consequence":{"type":"array","items":"string"},"component.has_dynamic_status":{"type":"boolean"},"component.pattern":{"type":"string"},"interaction.has_motion_or_timing":{"type":"boolean"},"interaction.has_complex_pointer":{"type":"boolean"},"interaction.has_character_shortcuts":{"type":"boolean"},"content.uses_orientation_or_sensory_cues":{"type":"boolean"},"interaction.has_pointer_targets":{"type":"boolean"},"interaction.can_obscure_focus":{"type":"boolean"},"flow.has_authentication":{"type":"boolean"},"flow.repeats_entry":{"type":"boolean"},"artifact.has_help":{"type":"boolean"},"content.has_locale_or_bidi":{"type":"boolean"},"component.has_data_table_or_grid":{"type":"boolean"}}}
+{
+  "version": 1,
+  "facts": {
+    "artifact.page_context": { "type": "boolean" },
+    "content.has_non_text": { "type": "boolean" },
+    "content.has_media": { "type": "boolean" },
+    "component.ui_pattern_ids": { "type": "array", "items": "string", "source": "ui-design-brain" },
+    "component.accessibility_pattern_ids": { "type": "array", "items": "string", "derived": true },
+    "component.command_menu_trigger": { "type": "boolean" },
+    "component.has_form_fields": { "type": "boolean" },
+    "component.has_validation": { "type": "boolean" },
+    "component.submission_consequence": { "type": "array", "items": "string" },
+    "component.has_dynamic_status": { "type": "boolean" },
+    "component.message_urgency": { "type": "string" },
+    "component.overlay_model": { "type": "string" },
+    "component.selection_model": { "type": "string" },
+    "interaction.has_motion_or_timing": { "type": "boolean" },
+    "interaction.has_complex_pointer": { "type": "boolean" },
+    "interaction.has_character_shortcuts": { "type": "boolean" },
+    "content.uses_orientation_or_sensory_cues": { "type": "boolean" },
+    "interaction.has_pointer_targets": { "type": "boolean" },
+    "interaction.can_obscure_focus": { "type": "boolean" },
+    "flow.has_authentication": { "type": "boolean" },
+    "flow.repeats_entry": { "type": "boolean" },
+    "artifact.has_help": { "type": "boolean" },
+    "content.has_locale_or_bidi": { "type": "boolean" },
+    "component.has_data_table_or_grid": { "type": "boolean" }
+  }
+}

package/src/applicability/matrix.yml

@@ -2,10 +2,11 @@
 {"id":"applicability.page-context","when":{"equals":{"fact":"artifact.page_context","value":true}},"outcomes":["semantics.headings","semantics.landmarks"],"evidence":["axe","human"]},
 {"id":"applicability.non-text-content","when":{"equals":{"fact":"content.has_non_text","value":true}},"outcomes":["pattern.image"],"evidence":["axe","human"]},
 {"id":"applicability.media","when":{"equals":{"fact":"content.has_media","value":true}},"outcomes":["pattern.media-player"],"evidence":["e2e","human"]},
-{"id":"applicability.forms","when":{"equals":{"fact":"component.has_form_fields","value":true}},"outcomes":["pattern.field","pattern.validation"],"evidence":["unit","axe","e2e"]},
+{"id":"applicability.forms","when":{"equals":{"fact":"component.has_form_fields","value":true}},"outcomes":["pattern.field"],"evidence":["unit","axe"]},
+{"id":"applicability.validation","when":{"equals":{"fact":"component.has_validation","value":true}},"outcomes":["pattern.validation"],"evidence":["unit","axe","e2e","human"]},
 {"id":"applicability.consequential-submission","when":{"contains":{"fact":"component.submission_consequence","value":"consequential"}},"outcomes":["pattern.consequential-submission"],"evidence":["e2e","human"]},
 {"id":"applicability.dynamic-status","when":{"equals":{"fact":"component.has_dynamic_status","value":true}},"outcomes":["pattern.dynamic-status"],"evidence":["unit","e2e","human"]},
-{"id":"applicability.overlays","when":{"contains":{"fact":"component.pattern","value":["dialog","popover","tooltip"]}},"outcomes":["semantics.keyboard.escape","semantics.focus.return"],"evidence":["e2e"]},
+{"id":"applicability.overlays","when":{"any":[{"contains":{"fact":"component.ui_pattern_ids","value":"modal"}},{"contains":{"fact":"component.ui_pattern_ids","value":"popover"}},{"contains":{"fact":"component.ui_pattern_ids","value":"tooltip"}}]},"outcomes":["semantics.keyboard.escape","semantics.focus.return"],"evidence":["e2e"]},
 {"id":"applicability.motion-timing","when":{"equals":{"fact":"interaction.has_motion_or_timing","value":true}},"outcomes":["semantics.motion-control"],"evidence":["e2e","human"]},
 {"id":"applicability.complex-pointer","when":{"equals":{"fact":"interaction.has_complex_pointer","value":true}},"outcomes":["semantics.keyboard"],"evidence":["e2e","human"]},
 {"id":"applicability.character-shortcuts","when":{"equals":{"fact":"interaction.has_character_shortcuts","value":true}},"outcomes":["semantics.keyboard"],"evidence":["unit","e2e"]},