stylegallery 0.1.0

package/scripts/test-validate-promotion-rfc.mjs

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { copyTreeNoSymlinks, testPromotionBoundaries } from "./promotion-boundary-test-contract.mjs";
+
+const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const fixtureRoot = path.join(repositoryRoot, "consumer-reference/fixtures/promotion");
+const validator = path.join(repositoryRoot, "scripts/validate-promotion-rfc.mjs");
+
+function readJson(relative) {
+  return JSON.parse(fs.readFileSync(path.join(fixtureRoot, relative), "utf8"));
+}
+
+function runArguments(args) {
+  const child = spawnSync(process.execPath, [validator, ...args], { cwd: repositoryRoot, encoding: "utf8" });
+  let report = { failures: [], ok: false, parse_error: true };
+  try {
+    report = JSON.parse(child.stdout);
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    report = { failures: [], ok: false, parse_error: true };
+  }
+  return { report, status: child.status };
+}
+
+function run(file, profileRepositoryRoot) {
+  const args = ["--file", file, "--json"];
+  if (profileRepositoryRoot) args.push("--profile-repository-root", profileRepositoryRoot);
+  return runArguments(args);
+}
+
+function runPolicy(file) {
+  return runArguments(["--policy", file, "--json"]);
+}
+
+function writeMutation(name, source, mutate) {
+  const value = structuredClone(readJson(source));
+  mutate(value);
+  const file = path.join(tempRoot, `${name}.json`);
+  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+  return file;
+}
+
+function writePolicyMutation(root, name, mutate) {
+  const value = JSON.parse(fs.readFileSync(path.join(repositoryRoot, "consumer-reference/policies/shared-experimental.json"), "utf8"));
+  mutate(value);
+  const file = path.join(root, `${name}.json`);
+  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+  return file;
+}
+
+function copyProfileRepository(name) {
+  const root = path.join(tempRoot, name);
+  const source = path.join(repositoryRoot, "design-engineering/reference-profiles/governed-local");
+  const target = path.join(root, "design-engineering/reference-profiles/governed-local");
+  copyTreeNoSymlinks(source, target);
+  return root;
+}
+
+function editProfileJson(root, relative, mutate) {
+  const file = path.join(root, relative);
+  const value = JSON.parse(fs.readFileSync(file, "utf8"));
+  mutate(value);
+  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+const fixtureManifest = JSON.parse(fs.readFileSync(path.join(fixtureRoot, "manifest.json"), "utf8"));
+const invalidCases = fixtureManifest.invalid_records.map((entry) => [entry.file.replace(/\.json$/, ""), entry.file, entry.expected_code]);
+
+const tempRoot = fs.mkdtempSync(path.join(repositoryRoot, ".tmp-pr6-promotion-"));
+const repositoryTempRoot = fs.mkdtempSync(path.join(repositoryRoot, ".tmp-pr6-profile-"));
+const results = [];
+try {
+  for (const [name, relative, expected] of invalidCases) {
+    const child = run(path.join(fixtureRoot, relative));
+    const codes = child.report.failures.map((failure) => failure.code);
+    results.push({ actual: { codes, scaffold: child.report.scaffold === true, status: child.status }, expected, name, ok: child.status > 0 && codes.includes(expected) && child.report.scaffold !== true });
+  }
+
+  const editorial = writeMutation("editorial_counted", "valid-deferred-example.json", (value) => {
+    value.attestations = [{ attested_by: "Synthetic owner", context_id: "editorial", consumer_id: "editorial-reference-profile", count_toward_gate: true, organization_id: "stylegallery", profile_record: "design-engineering/reference-profiles/governed-local/editorial/profile.json", relationship: "independent" }];
+  });
+  const terminal = writeMutation("terminal_counted", "valid-deferred-example.json", (value) => {
+    value.attestations = [{ attested_by: "Synthetic owner", context_id: "terminal", consumer_id: "terminal-reference-profile", count_toward_gate: true, organization_id: "stylegallery", profile_record: "design-engineering/reference-profiles/governed-local/terminal/profile.json", relationship: "independent" }];
+  });
+  const booleanReview = writeMutation("boolean_review", "valid-deferred-example.json", (value) => { value.review_independence = false; });
+  const fakeIndependence = writeMutation("fake_independence", "valid-deferred-example.json", (value) => {
+    value.attestations = [
+      { attested_by: "Synthetic owner", context_id: "one", consumer_id: "consumer-one", count_toward_gate: true, organization_id: "same-org", relationship: "independent" },
+      { attested_by: "Synthetic owner", context_id: "two", consumer_id: "consumer-two", count_toward_gate: true, organization_id: "same-org", relationship: "independent" }
+    ];
+  });
+  const duplicateIdentity = writeMutation("duplicate_identity", "valid-deferred-example.json", (value) => {
+    const attestation = { attested_by: "Synthetic owner", context_id: "same", consumer_id: "same-consumer", count_toward_gate: true, organization_id: "same-org", relationship: "independent" };
+    value.attestations = [attestation, structuredClone(attestation)];
+  });
+  const duplicateConsumer = writeMutation("duplicate_consumer", "valid-deferred-example.json", (value) => {
+    value.attestations = [
+      { attested_by: "Synthetic owner A", context_id: "one", consumer_id: "same-consumer", count_toward_gate: true, organization_id: "organization-a", relationship: "independent" },
+      { attested_by: "Synthetic owner B", context_id: "two", consumer_id: "same-consumer", count_toward_gate: true, organization_id: "organization-b", relationship: "independent" }
+    ];
+  });
+  const unknownConsumers = writeMutation("unknown_consumers", "valid-deferred-example.json", (value) => {
+    value.attestations = [
+      { attested_by: "Synthetic owner A", context_id: "one", consumer_id: "unknown-one", count_toward_gate: true, organization_id: "organization-a", relationship: "independent" },
+      { attested_by: "Synthetic owner B", context_id: "two", consumer_id: "unknown-two", count_toward_gate: true, organization_id: "organization-b", relationship: "independent" }
+    ];
+  });
+  const forgedOne = path.join(repositoryTempRoot, "forged-one.json");
+  const forgedTwo = path.join(repositoryTempRoot, "forged-two.json");
+  fs.writeFileSync(forgedOne, '{"fixture_independence":"independent","id":"forged-one"}\n');
+  fs.writeFileSync(forgedTwo, '{"fixture_independence":"independent","id":"forged-two"}\n');
+  const forgedProfiles = writeMutation("forged_profiles", "valid-deferred-example.json", (value) => {
+    value.attestations = [
+      { attested_by: "Synthetic owner A", context_id: "one", consumer_id: "forged-one", count_toward_gate: true, organization_id: "organization-a", profile_record: path.relative(repositoryRoot, forgedOne), relationship: "independent" },
+      { attested_by: "Synthetic owner B", context_id: "two", consumer_id: "forged-two", count_toward_gate: true, organization_id: "organization-b", profile_record: path.relative(repositoryRoot, forgedTwo), relationship: "independent" }
+    ];
+  });
+  const copiedProfileRoot = path.join(repositoryTempRoot, "copied");
+  copyTreeNoSymlinks(path.join(repositoryRoot, "design-engineering/reference-profiles/governed-local/editorial"), copiedProfileRoot);
+  const copiedUnregistered = writeMutation("copied_unregistered", "valid-deferred-example.json", (value) => {
+    value.attestations = [{ attested_by: "Synthetic owner", context_id: "copied", consumer_id: "editorial-reference-profile", count_toward_gate: true, organization_id: "copied-org", profile_record: path.relative(repositoryRoot, path.join(copiedProfileRoot, "profile.json")), relationship: "independent" }];
+  });
+  const invalidRegisteredRoot = copyProfileRepository("invalid-registered-root");
+  editProfileJson(invalidRegisteredRoot, "design-engineering/reference-profiles/governed-local/editorial/profile.json", (value) => { delete value.owner; });
+  const invalidRegistered = writeMutation("invalid_registered", "valid-deferred-example.json", (value) => {
+    value.attestations = [{ attested_by: "Synthetic owner", context_id: "invalid", consumer_id: "editorial-reference-profile", count_toward_gate: true, organization_id: "invalid-org", profile_record: "design-engineering/reference-profiles/governed-local/editorial/profile.json", relationship: "independent" }];
+  });
+  const duplicateRegistryRoot = copyProfileRepository("duplicate-registry-root");
+  editProfileJson(duplicateRegistryRoot, "design-engineering/reference-profiles/governed-local/terminal/profile.json", (value) => { value.id = "editorial-reference-profile"; });
+  const duplicateRegistryIdentity = writeMutation("duplicate_registry_identity", "valid-deferred-example.json", (value) => {
+    value.attestations = [{ attested_by: "Synthetic owner", context_id: "duplicate", consumer_id: "editorial-reference-profile", count_toward_gate: true, organization_id: "duplicate-org", profile_record: "design-engineering/reference-profiles/governed-local/editorial/profile.json", relationship: "independent" }];
+  });
+  const silentRelabel = writeMutation("silent_relabel", "valid-deferred-example.json", (value) => {
+    value.transition = { from: "stable", to: "shared_experimental" };
+  });
+  const pathEscape = writeMutation("path_escape", "valid-deferred-example.json", (value) => {
+    value.attestations = [{ attested_by: "Synthetic owner", context_id: "escape", consumer_id: "escape", count_toward_gate: true, organization_id: "escape", profile_record: "../outside.json", relationship: "independent" }];
+  });
+  const profileMismatch = writeMutation("profile_mismatch", "valid-deferred-example.json", (value) => {
+    value.attestations = [{ attested_by: "Synthetic owner", context_id: "editorial", consumer_id: "different-profile", count_toward_gate: true, organization_id: "stylegallery", profile_record: "design-engineering/reference-profiles/governed-local/editorial/profile.json", relationship: "independent" }];
+  });
+  const profileLink = path.join(repositoryTempRoot, "profile.json");
+  fs.symlinkSync(path.join(repositoryRoot, "design-engineering/reference-profiles/governed-local/editorial/profile.json"), profileLink);
+  const profileSymlink = writeMutation("profile_symlink", "valid-deferred-example.json", (value) => {
+    value.attestations = [{ attested_by: "Synthetic owner", context_id: "editorial", consumer_id: "editorial-reference-profile", count_toward_gate: true, organization_id: "stylegallery", profile_record: path.relative(repositoryRoot, profileLink), relationship: "independent" }];
+  });
+  const schemaExtra = writeMutation("schema_extra", "valid-deferred-example.json", (value) => { value.unexpected_promotion = true; });
+  const acceptedDecision = writeMutation("accepted_decision", "valid-deferred-example.json", (value) => { value.decision = "accepted"; });
+  const aestheticPromotion = writeMutation("aesthetic_promotion", "valid-deferred-example.json", (value) => { value.scope.aesthetic = true; });
+  const breakingWithoutMigration = writeMutation("breaking_without_migration", "valid-deferred-example.json", (value) => { value.compatibility.breaking = true; value.migration.required = false; });
+  const normativeWithoutRollback = writeMutation("normative_without_rollback", "valid-normative-bypass.json", (value) => { delete value.rollback; });
+  const normativeEndedSupport = writeMutation("normative_ended_support", "valid-normative-bypass.json", (value) => {
+    value.support = { capacity: "No active support capacity", status: "ended" };
+  });
+  const normativeMissingSupport = writeMutation("normative_missing_support", "valid-normative-bypass.json", (value) => { delete value.support; });
+  const normativeMissingCapacity = writeMutation("normative_missing_capacity", "valid-normative-bypass.json", (value) => { delete value.support.capacity; });
+  const weakCapacityCases = ["0", "Not available", "Absent", "Lapsed", "Negative capacity"].map((capacity, index) => [
+    `weak_capacity_${index + 1}`,
+    writeMutation(`weak_capacity_${index + 1}`, "valid-deferred-example.json", (value) => { value.support.capacity = capacity; }),
+    "promotion_support_required",
+  ]);
+  const stableWithoutCount = writeMutation("stable_without_count", "valid-deferred-example.json", (value) => {
+    value.transition = { from: "shared_experimental", to: "stable" };
+    value.stable_scope_decision = true;
+    value.provenance.debt_resolved = true;
+  });
+  const stableWithoutEvidence = writeMutation("stable_without_evidence", "valid-deferred-example.json", (value) => {
+    value.transition = { from: "shared_experimental", to: "stable" };
+    value.stable_scope_decision = true;
+    value.provenance.debt_resolved = true;
+    value.evidence = [{ id: "regression", kind: "regression", reference: "synthetic-fixture:regression", status: "failed" }];
+  });
+  const duplicateKey = path.join(tempRoot, "duplicate_key.json");
+  fs.writeFileSync(duplicateKey, fs.readFileSync(path.join(fixtureRoot, "valid-deferred-example.json"), "utf8").replace('"decision": "deferred",', '"decision": "deferred",\n  "decision": "rejected",'));
+  for (const [name, file, expected, profileRepositoryRoot] of [
+    ["editorial_counted", editorial, "promotion_related_consumer_counted"],
+    ["terminal_counted", terminal, "promotion_related_consumer_counted"],
+    ["boolean_review", booleanReview, "review_independence_boolean"],
+    ["fake_independence", fakeIndependence, "promotion_independence_unproven"],
+    ["duplicate_identity", duplicateIdentity, "promotion_attestation_duplicate"],
+    ["duplicate_consumer", duplicateConsumer, "promotion_attestation_duplicate"],
+    ["unknown_consumers", unknownConsumers, "promotion_independence_unproven"],
+    ["forged_profiles", forgedProfiles, "promotion_independence_unproven"],
+    ["copied_unregistered", copiedUnregistered, "promotion_independence_unproven"],
+    ["invalid_registered", invalidRegistered, "promotion_independence_unproven", invalidRegisteredRoot],
+    ["duplicate_registry_identity", duplicateRegistryIdentity, "promotion_independence_unproven", duplicateRegistryRoot],
+    ["silent_relabel", silentRelabel, "promotion_stable_relabel_forbidden"],
+    ["path_escape", pathEscape, "promotion_profile_path_invalid"],
+    ["profile_mismatch", profileMismatch, "promotion_profile_identity_mismatch"],
+    ["profile_symlink", profileSymlink, "promotion_profile_path_symlink"],
+    ["schema_extra", schemaExtra, "promotion_schema_invalid"],
+    ["accepted_decision", acceptedDecision, "promotion_schema_invalid"],
+    ["aesthetic_promotion", aestheticPromotion, "promotion_schema_invalid"],
+    ["breaking_without_migration", breakingWithoutMigration, "promotion_migration_required"],
+    ["normative_without_rollback", normativeWithoutRollback, "promotion_schema_invalid"],
+    ["normative_ended_support", normativeEndedSupport, "promotion_support_required"],
+    ["normative_missing_support", normativeMissingSupport, "promotion_support_required"],
+    ["normative_missing_capacity", normativeMissingCapacity, "promotion_support_required"],
+    ["duplicate_key", duplicateKey, "promotion_json_invalid"],
+    ["stable_without_evidence", stableWithoutEvidence, "promotion_stable_evidence_required"],
+    ...weakCapacityCases,
+  ]) {
+    const child = run(file, profileRepositoryRoot);
+    const codes = child.report.failures.map((failure) => failure.code);
+    results.push({ actual: { codes, scaffold: child.report.scaffold === true, status: child.status }, expected, name, ok: child.status > 0 && codes.includes(expected) && child.report.scaffold !== true });
+  }
+
+  for (const relative of ["valid-deferred-example.json", "valid-normative-bypass.json"]) {
+    const child = run(path.join(fixtureRoot, relative));
+    results.push({ actual: { scaffold: child.report.scaffold === true, status: child.status }, expected: "ok:true", name: relative, ok: child.status === 0 && child.report.ok === true && child.report.scaffold !== true });
+  }
+  const stable = run(stableWithoutCount);
+  results.push({ actual: { scaffold: stable.report.scaffold === true, status: stable.status }, expected: "stable_without_numeric_threshold", name: "stable_without_count", ok: stable.status === 0 && stable.report.ok === true && stable.report.scaffold !== true });
+  const canonicalPolicy = runPolicy(path.join(repositoryRoot, "consumer-reference/policies/shared-experimental.json"));
+  results.push({ actual: { status: canonicalPolicy.status }, expected: "canonical_policy_valid", name: "canonical_policy", ok: canonicalPolicy.status === 0 && canonicalPolicy.report.ok === true });
+  results.push(...testPromotionBoundaries({ fixtureRoot, repositoryRoot, runArguments, tempRoot }));
+  for (const [name, file, expected] of [
+    ["stable_numeric_count", writePolicyMutation(tempRoot, "stable_numeric_count", (value) => { value.gateway.stable_numeric_threshold = 2; }), "promotion_stable_numeric_threshold_forbidden"],
+    ["bypass_overreach", writePolicyMutation(tempRoot, "bypass_overreach", (value) => { value.normative_bypass.waives.push("regression_proof"); }), "promotion_normative_bypass_overreach"],
+    ["fake_promotion_claim", writePolicyMutation(tempRoot, "fake_promotion_claim", (value) => { value.claims.promotion_occurred = true; }), "promotion_claim_forbidden"],
+    ["policy_unknown_field", writePolicyMutation(tempRoot, "policy_unknown_field", (value) => { value.accepted = true; }), "promotion_policy_shape_invalid"],
+    ["policy_nested_unknown", writePolicyMutation(tempRoot, "policy_nested_unknown", (value) => { value.gateway.stable_by_count = true; }), "promotion_policy_shape_invalid"],
+    ["policy_promotes_palette", writePolicyMutation(tempRoot, "policy_promotes_palette", (value) => { value.boundaries.promoted_content.push("palette"); }), "promotion_aesthetic_boundary_required"],
+    ["policy_promotes_alias", writePolicyMutation(tempRoot, "policy_promotes_alias", (value) => { value.boundaries.promoted_content.push("brand_identity"); }), "promotion_aesthetic_boundary_required"],
+    ["policy_promoted_non_string", writePolicyMutation(tempRoot, "policy_promoted_non_string", (value) => { value.boundaries.promoted_content = [42]; }), "promotion_aesthetic_boundary_required"],
+    ["policy_normative_aesthetic", writePolicyMutation(tempRoot, "policy_normative_aesthetic", (value) => { value.normative_bypass.categories = ["aesthetic"]; }), "promotion_normative_bypass_overreach"],
+    ["policy_lifecycle_incomplete", writePolicyMutation(tempRoot, "policy_lifecycle_incomplete", (value) => { value.lifecycle.failure_actions = ["deprecate_with_migration"]; }), "promotion_lifecycle_invalid"],
+    ["policy_excluded_non_string", writePolicyMutation(tempRoot, "policy_excluded_non_string", (value) => { value.boundaries.excluded_content.push(42); }), "promotion_aesthetic_boundary_required"],
+    ["policy_retains_non_string", writePolicyMutation(tempRoot, "policy_retains_non_string", (value) => { value.normative_bypass.retains.push(42); }), "promotion_normative_bypass_overreach"],
+    ["policy_verified_owner", writePolicyMutation(tempRoot, "policy_verified_owner", (value) => { value.owner.enforcement = "verified"; }), "promotion_policy_owner_invalid"],
+    ["policy_promoted_status", writePolicyMutation(tempRoot, "policy_promoted_status", (value) => { value.status = "promoted"; }), "promotion_claim_forbidden"],
+    ["policy_generated_mode", writePolicyMutation(tempRoot, "policy_generated_mode", (value) => { value.artifact_mode = "generated"; }), "promotion_policy_identity_invalid"],
+  ]) {
+    const child = runPolicy(file);
+    const codes = child.report.failures.map((failure) => failure.code);
+    results.push({ actual: { codes, status: child.status }, expected, name, ok: child.status > 0 && codes.includes(expected) });
+  }
+} finally {
+  fs.rmSync(tempRoot, { force: true, recursive: true });
+  fs.rmSync(repositoryTempRoot, { force: true, recursive: true });
+}
+
+const failures = results.filter((result) => !result.ok).map((result) => `missing_semantic:${result.name}:${result.expected}`);
+const report = { failures, ok: failures.length === 0, results };
+process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+if (!report.ok) process.exitCode = 1;

package/scripts/test-validate-reference-profiles.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const validator = path.join(repositoryRoot, "scripts", "validate-consumer-reference.mjs");
+const profilePath = "design-engineering/reference-profiles/governed-local/editorial/profile.json";
+const terminalProfilePath = "design-engineering/reference-profiles/governed-local/terminal/profile.json";
+const aliasProfilePath = "design-engineering/reference-profiles/governed-local/alias/profile.json";
+const layoutSha = "775430bbaf4ee208a642220f440f6926d79c90a3";
+
+const baseProfile = {
+  artifact_mode: "governed_local",
+  component_records: ["components/button.component.json"],
+  default: false,
+  environment_assumptions: {
+    reset: { body_margin: "0", box_sizing: "border-box", figure_margin: "0" },
+    user_agent_styles: "Preserve browser defaults except for the declared reset.",
+  },
+  example_only: true,
+  evidence_records: ["evidence/button.evidence.json"],
+  fixture_records: ["fixtures/button.fixture.json"],
+  fixture_independence: "related",
+  handoff: { record: profilePath, status: "declared" },
+  generated_records: ["generated/evidence-coverage.md", "generated/keyboard-matrix.md", "generated/state-matrix.md"],
+  id: "editorial-reference-profile",
+  layout_source_sha: layoutSha,
+  local_foundations: "local-foundations.json",
+  maturity: "experimental",
+  owner: { enforcement: "placeholder", name: "Design Engineering owner" },
+  profile_kind: "governed_local",
+  related_fixture_set_id: "layout-identity-adversarial-pair",
+  review_independence: "single_account",
+  schema_version: "1.0",
+  selection: { method: "profile_path", required: true },
+  state_records: ["states/button.states.json"],
+  support: { status: "active" },
+  tokens: "tokens.dtcg.json",
+};
+
+const tokens = {
+  color: {
+    $type: "color",
+    accent: { $value: { alpha: 1, colorSpace: "srgb", components: [0.55, 0.18, 0.1] } },
+  },
+  space: { $type: "dimension", page: { $value: { unit: "rem", value: 1.5 } } },
+};
+const terminalTokens = {
+  color: {
+    $type: "color",
+    accent: { $value: { alpha: 1, colorSpace: "srgb", components: [0.1, 0.9, 0.5] } },
+  },
+  space: { $type: "dimension", page: { $value: { unit: "rem", value: 1 } } },
+};
+const editorialFoundations = { bindings: { accent: "{color.accent}" }, identity: "Warm editorial", profile_id: "editorial-reference-profile" };
+const terminalFoundations = { bindings: { accent: "{color.accent}" }, identity: "Dark terminal", profile_id: "terminal-reference-profile" };
+
+const cases = [
+  { name: "valid_governed_local_profile" },
+  { expect: "profile_artifact_mode_governed_local", name: "local_as_external", mutate: (item) => { item.artifact_mode = "external_consumer"; } },
+  { expect: "profile_default_forbidden", name: "implicit_default", mutate: (item) => { item.default = true; } },
+  { expect: "profile_layout_source_sha_required", name: "missing_layout_sha", mutate: (item) => { delete item.layout_source_sha; } },
+  { expect: "profile_ua_assumption_required", name: "missing_ua_assumption", mutate: (item) => { delete item.environment_assumptions.user_agent_styles; } },
+  { expect: "profile_reset_assumptions_required", name: "missing_reset_assumptions", mutate: (item) => { delete item.environment_assumptions.reset; } },
+  { expect: "profile_explicit_selection_required", name: "implicit_selection", mutate: (item) => { item.selection.required = false; } },
+  { expect: "fixture_independence_related", name: "independence_independent", mutate: (item) => { item.fixture_independence = "independent"; } },
+  { expect: "reverse_import", name: "reverse_profile_import", patternData: "export const related_fixture_set_id = 'layout-identity-adversarial-pair';\n" },
+  { expect: "external_adaptation_record_forbidden", externalRecord: true, name: "durable_external_adopter" },
+  { equalTokens: true, expect: "profile_tokens_not_distinct", name: "single_profile_equal_pair_tokens" },
+  { equalFoundations: true, expect: "profile_foundations_not_distinct", name: "single_profile_equal_pair_foundations" },
+  { equalIdentity: true, expect: "profile_identity_not_distinct", name: "single_profile_equal_pair_identity" },
+  { expect: "profile_related_set_mismatch", name: "single_profile_related_set_mismatch", mutateTerminal: (item) => { item.related_fixture_set_id = "unrelated-terminal-set"; } },
+  { expect: "profile_tokens_symlink_escape", linkedArtifact: "tokens", name: "linked_outside_tokens" },
+  { expect: "profile_foundations_symlink_escape", linkedArtifact: "foundations", name: "linked_outside_foundations" },
+  { expect: "profile_environment_property_unknown", name: "unknown_environment_field", mutate: (item) => { item.environment_assumptions.viewport = "wide"; } },
+  { expect: "profile_reset_property_unknown", name: "unknown_reset_field", mutate: (item) => { item.environment_assumptions.reset.list_margin = "0"; } },
+  { expect: "profile_selection_property_unknown", name: "unknown_selection_field", mutate: (item) => { item.selection.fallback = "editorial"; } },
+  { expect: "item_property_unknown", name: "unknown_profile_top_level", mutate: (item) => { item.profile_fallback = true; } },
+  {
+    equalTokens: true,
+    expect: "profile_tokens_not_distinct",
+    name: "normalized_equivalent_selector_loads_pair",
+    selector: "design-engineering/reference-profiles/governed-local/editorial/../editorial/profile.json",
+  },
+  { absoluteSelector: true, expect: "item_unresolved", name: "absolute_profile_selector_rejected" },
+  { expect: "item_unresolved", name: "scheme_profile_selector_rejected", selector: "https://example.com/editorial/profile.json" },
+  { expect: "item_unresolved", name: "network_profile_selector_rejected", selector: "//server/editorial/profile.json" },
+  { expect: "item_unresolved", name: "escaping_profile_selector_rejected", selector: "../editorial/profile.json" },
+  { aliasSelector: true, expect: "item_redirect", name: "symlink_alias_profile_selector_rejected" },
+];
+
+function writeFixture(testCase) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), `stylegallery-reference-profile-${testCase.name}-`));
+  const profile = structuredClone(baseProfile);
+  const terminalProfile = structuredClone(baseProfile);
+  terminalProfile.handoff.record = terminalProfilePath;
+  terminalProfile.id = "terminal-reference-profile";
+  testCase.mutate?.(profile);
+  testCase.mutateTerminal?.(terminalProfile);
+  const terminalFoundation = structuredClone(terminalFoundations);
+  if (testCase.equalIdentity) terminalFoundation.identity = editorialFoundations.identity;
+  const files = {
+    "CATALOG.md": "# Catalog\n",
+    [profilePath]: `${JSON.stringify(profile, null, 2)}\n`,
+    "design-engineering/reference-profiles/governed-local/editorial/local-foundations.json": `${JSON.stringify(editorialFoundations)}\n`,
+    "design-engineering/reference-profiles/governed-local/editorial/tokens.dtcg.json": `${JSON.stringify(tokens, null, 2)}\n`,
+    [terminalProfilePath]: `${JSON.stringify(terminalProfile, null, 2)}\n`,
+    "design-engineering/reference-profiles/governed-local/terminal/local-foundations.json": `${JSON.stringify(testCase.equalFoundations ? editorialFoundations : terminalFoundation)}\n`,
+    "design-engineering/reference-profiles/governed-local/terminal/tokens.dtcg.json": `${JSON.stringify(testCase.equalTokens ? tokens : terminalTokens, null, 2)}\n`,
+    "layout/index.md": "# Layout\n",
+    "patterns/index.md": "# Patterns\n",
+    "quality/handoff.md": "Implementation handoff:\nConsumer reference: not_applicable\nConsumer reference reason: This fixture has no consumer-specific reference record.\n",
+    "scripts/pattern-data.mjs": testCase.patternData ?? "export const patterns = [];\n",
+  };
+  if (testCase.externalRecord) files["design-engineering/reference-profiles/external-adaptation/adopter.json"] = "{}\n";
+  for (const [relative, content] of Object.entries(files)) {
+    const target = path.join(root, relative);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, content);
+  }
+  let externalRoot;
+  if (testCase.linkedArtifact) {
+    externalRoot = fs.mkdtempSync(path.join(os.tmpdir(), "stylegallery-reference-profile-outside-"));
+    const filename = testCase.linkedArtifact === "tokens" ? "tokens.dtcg.json" : "local-foundations.json";
+    const target = path.join(root, path.posix.dirname(profilePath), filename);
+    const external = path.join(externalRoot, filename);
+    fs.writeFileSync(external, files[path.posix.join(path.posix.dirname(profilePath), filename)]);
+    fs.rmSync(target);
+    fs.symlinkSync(external, target);
+  }
+  let selector = testCase.selector ?? profilePath;
+  if (testCase.absoluteSelector) selector = path.join(root, profilePath);
+  if (testCase.aliasSelector) {
+    const alias = path.join(root, aliasProfilePath);
+    fs.mkdirSync(path.dirname(alias), { recursive: true });
+    fs.symlinkSync(path.join(root, profilePath), alias);
+    selector = aliasProfilePath;
+  }
+  return { externalRoot, root, selector };
+}
+
+function runCase(testCase) {
+  const fixture = writeFixture(testCase);
+  try {
+    const child = spawnSync(process.execPath, [validator, "--profile", fixture.selector, "--json"], { cwd: fixture.root, encoding: "utf8" });
+    const output = JSON.parse(child.stdout);
+    const codes = Array.isArray(output.failures) ? output.failures.map((failure) => failure.code) : [];
+    const accepted = child.status === 0 && output.ok === true && output.scaffold !== true;
+    const rejected = child.status !== 0 && output.ok === false && codes.includes(testCase.expect);
+    return {
+      actual: { codes, ok: output.ok, status: child.status },
+      expected: testCase.expect ?? "ok:true and exit:0",
+      name: testCase.name,
+      ok: testCase.expect ? rejected : accepted,
+    };
+  } finally {
+    fs.rmSync(fixture.root, { force: true, recursive: true });
+    if (fixture.externalRoot) fs.rmSync(fixture.externalRoot, { force: true, recursive: true });
+  }
+}
+
+const results = cases.map(runCase);
+const failures = results.filter((result) => !result.ok).map((result) => `missing_semantic:${result.name}:${result.expected}`);
+const report = { failures, ok: failures.length === 0, results };
+console.log(JSON.stringify(report, null, 2));
+process.exitCode = report.ok ? 0 : 1;

package/scripts/test-validate-unity-org-wiki.mjs

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const root = path.resolve(import.meta.dirname, "..");
+const validator = path.join(root, "scripts", "validate-unity-org-wiki.mjs");
+
+function run(cwd) {
+  return spawnSync(process.execPath, [validator, "--json"], { cwd, encoding: "utf8" });
+}
+
+async function main() {
+  const inventoryPath = path.join(root, "game-ui", "unity", "data", "unity-technologies-public-repositories.json");
+  const mapPath = path.join(root, "game-ui", "unity", "repository-map.md");
+  const wikiPath = path.join(root, "game-ui", "unity", "org-wiki.md");
+  const inventoryText = await readFile(inventoryPath, "utf8");
+  const inventory = JSON.parse(inventoryText);
+  const map = await readFile(mapPath, "utf8");
+  const wiki = await readFile(wikiPath, "utf8");
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "unity-org-wiki-validator-"));
+
+  try {
+    await writeFile(path.join(tempRoot, "inventory.json"), inventoryText);
+    await writeFile(path.join(tempRoot, "map.md"), map);
+    await writeFile(path.join(tempRoot, "wiki.md"), wiki);
+    const fixtures = [
+      ["wrong count", inventory.slice(1), map, wiki, "expected 804 repositories"],
+      ["duplicate repository", [...inventory.slice(0, -1), inventory[0]], map, wiki, "duplicate repository identity"],
+      ["NGUI inside org", [...inventory.slice(0, -1), { ...inventory.at(-1), id: 999999999, full_name: "tasharen/ngui", html_url: "https://github.com/tasharen/ngui" }], map, wiki, "NGUI must remain external"],
+      ["invalid cluster", [{ ...inventory[0], primary_cluster: "unverified" }, ...inventory.slice(1)], map, wiki, "invalid primary_cluster"],
+      ["absolute path", inventory, map, `${wiki}\n/Users/example/private\n`, "absolute home path"],
+      ["wiki data drift", inventory, map, wiki.replaceAll("**804**", "**803**"), "wiki must state the 804-row boundary"],
+      ["repository map count drift", inventory, map.replace("804 classified rows", "803 classified rows"), wiki, "repository map must state the 804-row boundary"],
+      ["repository map hash drift", inventory, map.replaceAll("b1438e6e8d438bab3eff2ff02f5a10e9374fdfb89b0581ffb936a42920fa2e05", "0000000000000000000000000000000000000000000000000000000000000000"), wiki, "repository map tracked inventory hash drift"],
+      ["tracked inventory hash drift", [{ ...inventory[0], stargazers_count: inventory[0].stargazers_count + 1 }, ...inventory.slice(1)], map, wiki, "tracked inventory SHA-256 mismatch"],
+    ];
+
+    for (const [name, candidateInventory, candidateMap, candidateWiki, expected] of fixtures) {
+      await writeFile(path.join(tempRoot, "inventory.json"), candidateInventory === inventory ? inventoryText : JSON.stringify(candidateInventory));
+      await writeFile(path.join(tempRoot, "map.md"), candidateMap);
+      await writeFile(path.join(tempRoot, "wiki.md"), candidateWiki);
+      const result = spawnSync(process.execPath, [validator, "--json", "--inventory", path.join(tempRoot, "inventory.json"), "--map", path.join(tempRoot, "map.md"), "--wiki", path.join(tempRoot, "wiki.md")], { cwd: root, encoding: "utf8" });
+      assert.notEqual(result.status, 0, `${name} fixture unexpectedly passed`);
+      assert.match(`${result.stdout}${result.stderr}`, new RegExp(expected.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")), `${name} fixture failed for the wrong reason`);
+    }
+
+    const result = run(root);
+    assert.equal(result.status, 0, result.stderr || result.stdout);
+    console.log("Unity org wiki validator fixtures passed: 9 negative, 1 positive.");
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+await main();

package/scripts/test-validate-unity-source-contracts.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const root = path.resolve(import.meta.dirname, "..");
+const validator = path.join(root, "scripts", "validate-unity-source-contracts.mjs");
+const documents = [
+  "game-ui/unity/architecture.md",
+  "game-ui/unity/cli-loop.md",
+  "game-ui/unity/org-wiki.md",
+  "game-ui/unity/repository-map.md",
+  "game-ui/unity/ui-systems.md",
+];
+const originals = Object.fromEntries(documents.map((relative) => [relative, fs.readFileSync(path.join(root, relative), "utf8")]));
+const fixtures = [
+  {
+    name: "missing CLI license attribution",
+    relative: "game-ui/unity/cli-loop.md",
+    mutate: (content) => content.replace(/- Source license:.*\n/, ""),
+    expected: "game-ui/unity/cli-loop.md: missing pinned source license",
+  },
+  {
+    name: "mutable CLI body citation",
+    relative: "game-ui/unity/cli-loop.md",
+    mutate: (content) => content.replace("https://github.com/hatayama/unity-cli-loop/blob/61a0fe6d7da0aa9d0bcbc6d95944dd069c483ff0/README.md", "https://github.com/hatayama/unity-cli-loop/blob/main/README.md"),
+    expected: "game-ui/unity/cli-loop.md: GitHub body citation must use a non-zero 40-character revision: hatayama/unity-cli-loop",
+  },
+  {
+    name: "zeroed uGUI body revisions",
+    relative: "game-ui/unity/ui-systems.md",
+    mutate: (content) => content.replaceAll("9edb4420267b6652090ece4c28c38bd98746a68e", "0000000000000000000000000000000000000000"),
+    expected: "game-ui/unity/ui-systems.md: GitHub body citation must use a non-zero 40-character revision: Unity-Technologies/uGUI",
+  },
+  {
+    name: "invalid reviewed date",
+    relative: "game-ui/unity/architecture.md",
+    mutate: (content) => content.replace("reviewed_on: 2026-07-14", "reviewed_on: never"),
+    expected: "game-ui/unity/architecture.md: reviewed_on must be an ISO calendar date",
+  },
+];
+
+function writeFixture(fixture) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "unity-source-contracts-"));
+  for (const [relative, content] of Object.entries(originals)) {
+    const target = path.join(directory, relative);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, relative === fixture.relative ? fixture.mutate(content) : content);
+  }
+  return directory;
+}
+
+for (const fixture of fixtures) {
+  const directory = writeFixture(fixture);
+  const result = spawnSync(process.execPath, [validator, "--json", "--root", directory], { encoding: "utf8" });
+  fs.rmSync(directory, { force: true, recursive: true });
+  assert.notEqual(result.status, 0, `${fixture.name} unexpectedly passed`);
+  const output = JSON.parse(result.stdout);
+  assert(output.failures.includes(fixture.expected), `${fixture.name} failed for the wrong reason: ${result.stdout}`);
+}
+
+const positive = spawnSync(process.execPath, [validator, "--json"], { cwd: root, encoding: "utf8" });
+assert.equal(positive.status, 0, positive.stderr || positive.stdout);
+console.log("Unity source contract fixtures passed: 4 negative, 1 positive.");