@usefragments/core 1.0.0 → 1.3.0

package/src/conform-prove.ts

@@ -15,8 +15,7 @@
  *
  * Determinism (architecture §6.3): the sampler receives `(seq, codeHashAtRequest)`
  * so a durable-replay layer can key recorded sampler output on the exact code it
- * was asked to repair, and hard-invalidate on a hash mismatch — instead of the
- * pass-index-only key the standalone MCP tool uses.
+ * was asked to repair and hard-invalidate on a hash mismatch.
  *
  * Browser-safe: depends only on the conform contract types + the pure SHA-256
  * in this package. No Node APIs.
@@ -248,14 +247,11 @@ export async function proveCompliant(
     // and we are under the attempt cap (kept strictly below maxPasses so a
     // revalidation pass always remains in budget).
     //
-    // Sampling semantics (intentional, and DIFFERENT from the standalone MCP
-    // tool): the loop re-samples only while the sampler keeps producing *new*
-    // code (each fresh snippet is re-validated on the next pass); a sample that
+    // The loop re-samples only while the sampler keeps producing *new* code
+    // (each fresh snippet is re-validated on the next pass). A sample that
     // returns nothing new — null, no `code`, or byte-identical code — ends the
     // loop. Re-asking the model with the identical residual rarely helps and
-    // burns tokens. The MCP tool instead retries up to its cap on each stall
-    // (its suspend/resume transport makes per-stall retry the natural shape);
-    // both are bounded by maxPasses. See docs/contract-mode/01-architecture.md.
+    // burns tokens.
     const residual: ProveResidual = {
       suggestions: result.suggestions,
       unresolved: result.unresolved,

package/src/contract/index.ts

@@ -8,11 +8,13 @@
 export { canonicalPreimage, contractHash, sha256Hex } from "./hash.js";
 export {
   CONTRACT_DOMAINS,
+  CONTRACT_PREIMAGE_CAPABILITY_HEADER,
   CONTRACT_PREIMAGE_SCHEMA,
   contractComponentsFromFragments,
   contractPolicyFromGovernanceConfig,
   diffContractDomains,
   projectContractPreimage,
+  verifiedContractPreimageFromPin,
 } from "./preimage.js";
 export type {
   CanonicalMappingStatus,
@@ -20,6 +22,7 @@ export type {
   ContractCatalogInput,
   ContractComponentInput,
   ContractDomain,
+  ContractIdentityPin,
   ContractPolicyInput,
   ContractPreimage,
   ContractPropMappingInput,

package/src/contract/preimage.test.ts

@@ -18,6 +18,7 @@ import {
   contractComponentsFromFragments,
   diffContractDomains,
   projectContractPreimage,
+  verifiedContractPreimageFromPin,
 } from "./preimage.js";
 import { formatStampPin } from "./stamp.js";
 
@@ -61,6 +62,55 @@ describe("§1 byte parity — one fixture, one hash, every runtime", () => {
   });
 });
 
+describe("published identity pin verification", () => {
+  it("reconstructs the exact canonical preimage behind a matching FCID", () => {
+    const preimage = projectContractPreimage(catalogFixtureA);
+
+    expect(
+      verifiedContractPreimageFromPin({
+        contractHash: contractHash(preimage),
+        preimageSchema: preimage.schema,
+        domainHashes: preimage.domains,
+      })
+    ).toEqual(preimage);
+  });
+
+  it("rejects tampered, incomplete, pre-identity, and future-domain pins", () => {
+    const preimage = projectContractPreimage(catalogFixtureA);
+    const valid = {
+      contractHash: contractHash(preimage),
+      preimageSchema: preimage.schema,
+      domainHashes: preimage.domains,
+    };
+
+    expect(
+      verifiedContractPreimageFromPin({
+        ...valid,
+        contractHash: "f".repeat(64),
+      })
+    ).toBeNull();
+    expect(
+      verifiedContractPreimageFromPin({
+        ...valid,
+        domainHashes: { components: preimage.domains.components },
+      })
+    ).toBeNull();
+    expect(
+      verifiedContractPreimageFromPin({
+        ...valid,
+        preimageSchema: undefined,
+        domainHashes: null,
+      })
+    ).toBeNull();
+    expect(
+      verifiedContractPreimageFromPin({
+        ...valid,
+        domainHashes: { ...preimage.domains, future: "a".repeat(64) },
+      })
+    ).toBeNull();
+  });
+});
+
 describe("§2 enforced-only — prose doesn't move the hash, enforcement does", () => {
   it("(a) display-data edits leave the identity unchanged", () => {
     // Adapters may pass wider objects (enrichment descriptions, docs URLs…);

package/src/contract/preimage.ts

@@ -139,6 +139,8 @@ export interface ContractCatalogInput {
 // ---------------------------------------------------------------------------
 
 export const CONTRACT_PREIMAGE_SCHEMA = "fcid-preimage:v1" as const;
+/** Request header used by clients that can verify and consume this preimage. */
+export const CONTRACT_PREIMAGE_CAPABILITY_HEADER = "X-Fragments-Contract-Preimage" as const;
 
 /**
  * The hashed identity record: four domain sub-hashes plus the projection schema
@@ -150,6 +152,60 @@ export interface ContractPreimage {
   domains: Record<ContractDomain, string>;
 }
 
+/**
+ * Wire-compatible identity pin carried by Cloud policy responses. Older
+ * contract rows may omit the schema/domains, so every field except the FCID is
+ * intentionally nullable at this boundary.
+ */
+export interface ContractIdentityPin {
+  contractHash: string;
+  preimageSchema?: string | null;
+  domainHashes?: Readonly<Record<string, string>> | null;
+}
+
+const SHA256_HEX_PATTERN = /^[0-9a-f]{64}$/u;
+
+/**
+ * Reconstruct and verify the canonical preimage behind a published FCID.
+ *
+ * This is the only supported bridge from the additive ledger/wire shape
+ * (`preimageSchema` + `domainHashes`) back to the hash input. Consumers must
+ * not trust `enforcedIdentityComparable` on its own: a malformed, partial, or
+ * internally inconsistent pin returns `null` and therefore fails closed.
+ */
+export function verifiedContractPreimageFromPin(pin: ContractIdentityPin): ContractPreimage | null {
+  if (
+    pin.preimageSchema !== CONTRACT_PREIMAGE_SCHEMA ||
+    !SHA256_HEX_PATTERN.test(pin.contractHash) ||
+    !pin.domainHashes ||
+    typeof pin.domainHashes !== "object"
+  ) {
+    return null;
+  }
+
+  const keys = Object.keys(pin.domainHashes).sort();
+  const expectedKeys = [...CONTRACT_DOMAINS].sort();
+  if (
+    keys.length !== expectedKeys.length ||
+    keys.some((key, index) => key !== expectedKeys[index])
+  ) {
+    return null;
+  }
+
+  const domains = Object.fromEntries(
+    CONTRACT_DOMAINS.map((domain) => [domain, pin.domainHashes?.[domain]])
+  ) as Record<ContractDomain, string | undefined>;
+  if (CONTRACT_DOMAINS.some((domain) => !SHA256_HEX_PATTERN.test(domains[domain] ?? ""))) {
+    return null;
+  }
+
+  const preimage: ContractPreimage = {
+    schema: CONTRACT_PREIMAGE_SCHEMA,
+    domains: domains as Record<ContractDomain, string>,
+  };
+  return contractHash(preimage) === pin.contractHash ? preimage : null;
+}
+
 /**
  * Sort projected elements by their canonical serialization: total, deterministic,
  * and independent of adapter iteration order, without per-type comparators.

package/src/evidence.ts

@@ -0,0 +1,27 @@
+/** Stable evidence grades shared by scanners, renderers, Inspect, and Cloud. */
+export type EvidenceGrade =
+  | "none"
+  | "runtime_advisory"
+  | "provenance_bound"
+  | "source_backed"
+  | "receipt_backed";
+
+export const EVIDENCE_ORDER = [
+  "none",
+  "runtime_advisory",
+  "provenance_bound",
+  "source_backed",
+  "receipt_backed",
+] as const satisfies readonly EvidenceGrade[];
+
+/** Only source-backed or receipt-backed claims may block a write or CI gate. */
+export function canBlock(grade: EvidenceGrade): boolean {
+  return EVIDENCE_ORDER.indexOf(grade) >= EVIDENCE_ORDER.indexOf("source_backed");
+}
+
+export type InspectClaimTier = "advisory" | "local_only" | "team_ci" | "receipt";
+
+export interface InspectClaim {
+  tier: InspectClaimTier;
+  text: string;
+}

package/src/facts/builders.ts

@@ -461,16 +461,20 @@ export function makeJsxComponentPreferredFact(input: {
 export function makeTokenDefinitionFact(input: {
   name: string;
   value: string;
+  location?: TokenDefinitionFact["location"];
   category?: TokenDefinitionFact["category"];
   referenceFormat?: TokenDefinitionFact["referenceFormat"];
+  sourceNames?: TokenDefinitionFact["sourceNames"];
 }): TokenDefinitionFact {
   return {
     id: factId("token_definition", { name: input.name }),
     kind: "token_definition",
     name: input.name,
     value: input.value,
+    ...(input.location ? { location: input.location } : {}),
     category: input.category,
     referenceFormat: input.referenceFormat,
+    ...(input.sourceNames?.length ? { sourceNames: [...input.sourceNames] } : {}),
   };
 }
 

package/src/facts/fact-index.ts

@@ -58,6 +58,10 @@ function logicalComponentId(componentId: ComponentId): ComponentId {
 }
 
 function logicalFactForComparison(fact: Fact): Record<string, unknown> {
+  if (fact.kind === "token_definition") {
+    const { location: _location, sourceNames: _sourceNames, ...logicalFact } = fact;
+    return logicalFact;
+  }
   if (fact.kind === "jsx_import_path_preferred") {
     return {
       ...fact,
@@ -109,8 +113,12 @@ export class FactIndex {
   private readonly facts = new Map<FactId, Fact>();
   private readonly idsByKind = new Map<FactKind, Set<FactId>>();
   private readonly idsByComponent = new Map<ComponentId, Set<FactId>>();
+  private readonly tokenBySymbol = new Map<string, TokenDefinitionFact>();
 
   add(fact: Fact): void {
+    if (fact.kind === "token_definition") {
+      this.indexTokenSymbols(fact);
+    }
     const existing = this.facts.get(fact.id);
     if (existing) {
       if (
@@ -118,7 +126,7 @@ export class FactIndex {
         canonicalJson(logicalFactForComparison(fact))
       ) {
         console.warn(
-          `FactIndex: conflicting facts for id ${fact.id} — keeping first fact, skipping ${describeFactForConflict(fact)}`
+          `FactIndex: conflicting facts for id ${fact.id} — keeping ${describeFactForConflict(existing)}, skipping ${describeFactForConflict(fact)}`
         );
       }
       return;
@@ -342,12 +350,28 @@ export class FactIndex {
     list: (): TokenDefinitionFact[] => this.byKind("token_definition"),
     byCategory: (category: TokenDefinitionFact["category"]): TokenDefinitionFact[] =>
       this.byKind("token_definition").filter((t) => t.category === category),
+    symbolExists: (name: string): boolean => this.tokenBySymbol.has(name),
+    definitionForSymbol: (name: string): TokenDefinitionFact | undefined =>
+      this.tokenBySymbol.get(name),
   };
 
   // ---------------------------------------------------------------------
   // Internals
   // ---------------------------------------------------------------------
 
+  private indexTokenSymbols(fact: TokenDefinitionFact): void {
+    const legacyScssAlias =
+      fact.referenceFormat === "scss-var" && fact.name.startsWith("--")
+        ? `$${fact.name.slice(2)}`
+        : fact.referenceFormat === "scss-var" && fact.name.startsWith("$")
+          ? `--${fact.name.slice(1)}`
+          : undefined;
+    for (const symbol of [fact.name, ...(fact.sourceNames ?? []), legacyScssAlias]) {
+      if (!symbol) continue;
+      if (!this.tokenBySymbol.has(symbol)) this.tokenBySymbol.set(symbol, fact);
+    }
+  }
+
   private byComponentOfKind<F extends Fact>(componentId: ComponentId, kind: FactKind): F[] {
     const ids = this.idsByComponent.get(logicalComponentId(componentId));
     if (!ids) return [];

package/src/facts/facts.test.ts

@@ -9,6 +9,7 @@ import {
   compileComponentFacts,
   compileGlobalGovernanceFacts,
   g,
+  makeTokenDefinitionFact,
   makeUsageNodeFact,
 } from "../index.js";
 import type { ComponentId, FactId, PropValueForbiddenFact } from "../index.js";
@@ -443,6 +444,54 @@ describe("FactIndex — query layer", () => {
     warn.mockRestore();
   });
 
+  it("does not treat token-definition provenance as a logical conflict", () => {
+    const ix = new FactIndex();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const first = makeTokenDefinitionFact({
+      name: "--fui-color-accent",
+      value: "#2563eb",
+      location: { file: "tokens/base.css", line: 2, column: 1 },
+    });
+    const second = makeTokenDefinitionFact({
+      name: "--fui-color-accent",
+      value: "#2563eb",
+      location: { file: "tokens/theme.css", line: 4, column: 1 },
+    });
+
+    ix.add(first);
+    ix.add(second);
+
+    expect(warn).not.toHaveBeenCalled();
+    expect(ix.get(first.id)).toEqual(first);
+    warn.mockRestore();
+  });
+
+  it("includes token-definition provenance in logical conflict warnings", () => {
+    const ix = new FactIndex();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const first = makeTokenDefinitionFact({
+      name: "--fui-color-accent",
+      value: "#2563eb",
+      location: { file: "tokens/base.css", line: 2, column: 1 },
+    });
+    const second = makeTokenDefinitionFact({
+      name: "--fui-color-accent",
+      value: "#1d4ed8",
+      location: { file: "tokens/theme.css", line: 4, column: 1 },
+    });
+
+    ix.add(first);
+    ix.add(second);
+
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringMatching(
+        /conflicting facts.*keeping kind=token_definition location=tokens\/base\.css:2:1, skipping kind=token_definition location=tokens\/theme\.css:4:1/
+      )
+    );
+    expect(ix.get(first.id)).toEqual(first);
+    warn.mockRestore();
+  });
+
   it("treats old and current owned component spellings as the same indexed facts", () => {
     const legacyId = asComponentId("@fragments-sdk/ui#Button");
     const currentId = asComponentId("@usefragments/ui#Button");

package/src/facts/types.ts

@@ -200,6 +200,7 @@ export interface JsxComponentPreferredFact extends BaseFact {
  */
 export interface TokenDefinitionFact extends BaseFact {
   kind: "token_definition";
+  location?: FactLocation;
   /** Token identifier, e.g., "fui-color-accent" or "--fui-color-accent". */
   name: string;
   /** Resolved value, e.g., "#2563eb". */
@@ -216,6 +217,8 @@ export interface TokenDefinitionFact extends BaseFact {
    * Absent on legacy/hand-built facts, which are treated as safe.
    */
   referenceFormat?: "css-var" | "scss-var" | "scss-map" | "dtcg";
+  /** Original authored spellings retained before parser normalization. */
+  sourceNames?: string[];
 }
 
 export interface TailwindPaletteAllowFact extends BaseFact {

package/src/governance-integrity.test.ts

@@ -177,8 +177,10 @@ describe("evaluateGovernanceIntegrity", () => {
     };
     const verdict = evaluate({ policy, policySource: "config", declared: true });
     const hygiene = verdict.families.find((f) => f.id === "hygiene");
+    const components = verdict.families.find((f) => f.id === "components");
     expect(hygiene?.armed).toBe(true);
     expect(hygiene?.rules).toContain("styles/no-raw-color");
+    expect(components?.remediation).toContain("govern.canonicalSources");
     expect(verdict.status).toBe("degraded");
     // degraded is enforceable, so not CI-fatal
     expect(verdict.fatalForCi).toBe(false);

package/src/governance-integrity.ts

@@ -25,7 +25,11 @@ import { BLOCKING_RULE_ALLOWLIST } from "./rules/emit-gate.js";
 export type GovernanceIntegrityStatus = "healthy" | "degraded" | "inert";
 
 export type GovernanceIntegrityFamilyId =
-  "policy" | "components" | "tokens" | "hygiene" | "blocking-deny";
+  | "policy"
+  | "components"
+  | "tokens"
+  | "hygiene"
+  | "blocking-deny";
 
 export interface GovernanceIntegrityFamily {
   id: GovernanceIntegrityFamilyId;
@@ -177,6 +181,8 @@ export function evaluateGovernanceIntegrity(
         "add govern.canonicalSources (a directory source, or npm/registry with a non-empty include) or designSystem.path/packageName";
     } else {
       componentsFamily.reason = "components/prefer-library not enabled";
+      componentsFamily.remediation =
+        "add govern.canonicalSources (a directory source, or npm/registry with a non-empty include) or designSystem.path/packageName";
     }
   }
 

package/src/index.ts

@@ -7,6 +7,10 @@
 export { BRAND, DEFAULTS } from "./constants.js";
 export type { Brand, Defaults } from "./constants.js";
 
+// Evidence vocabulary (wire-stable, browser-safe, shared with Inspect).
+export { EVIDENCE_ORDER, canBlock } from "./evidence.js";
+export type { EvidenceGrade, InspectClaim, InspectClaimTier } from "./evidence.js";
+
 // Conform engine contract (shared across extract engine, mcp tool, surfaces)
 export type {
   ConformChange,
@@ -62,7 +66,11 @@ export type { Severity, SeverityLevel } from "./severity.js";
 
 // Canonical TypeStyle schemas
 export {
+  AGENT_FORMAT_SCHEMA_VERSION,
+  agentErrorEnvelopeSchema,
   agentFormatSchema,
+  agentIntegritySchema,
+  agentOutputSchema,
   factEvidenceSchema,
   factLocationSchema,
   findingFixSchema,
@@ -83,7 +91,9 @@ export {
   violationSchema,
 } from "./schemas/index.js";
 export type {
+  AgentErrorEnvelope,
   AgentFormat,
+  AgentOutput,
   Fix,
   Finding as CanonicalFinding,
   GovernanceVerdict as CanonicalGovernanceVerdict,
@@ -763,6 +773,7 @@ export {
   catalogFixtureAContractPayload,
   catalogFixtureATokensDtcg,
   CONTRACT_DOMAINS,
+  CONTRACT_PREIMAGE_CAPABILITY_HEADER,
   CONTRACT_PREIMAGE_SCHEMA,
   contractComponentsFromFragments,
   contractHash,
@@ -775,6 +786,7 @@ export {
   projectContractPreimage,
   serializeContractStamp,
   sha256Hex,
+  verifiedContractPreimageFromPin,
 } from "./contract/index.js";
 export {
   OWNED_PACKAGE_IDENTITY_EPOCH,
@@ -794,6 +806,7 @@ export type {
   ContractCatalogInput,
   ContractComponentInput,
   ContractDomain,
+  ContractIdentityPin,
   ContractPolicyInput,
   ContractPreimage,
   ContractPropMappingInput,

package/src/rules/__tests__/fix-emission-invariant.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it } from "vitest";
+
+import { FactIndex } from "../../facts/fact-index.js";
+import {
+  makeGovernanceRuleConfigFact,
+  makeScaleFact,
+  makeScaleValueFact,
+  makeStyleDeclarationFact,
+  makeStyleFontSizeScaleFact,
+  makeStylePropertyScaleFact,
+  makeStyleRawColorForbiddenFact,
+  makeStyleRawDimensionForbiddenFact,
+  makeTokenDefinitionFact,
+} from "../../facts/builders.js";
+import type { Finding, FindingFix } from "../types.js";
+import { RULES } from "../index.js";
+import { tokenSymbolsInText } from "../utils.js";
+
+describe("proof-carrying fix invariant", () => {
+  it("runs every rule and downgrades every token fix when its registry is poisoned", () => {
+    const ix = buildFixtureCorpus();
+    const fullRegistryFindings = runEveryRule(ix);
+    const fullRegistryFixes = tokenFixes(fullRegistryFindings);
+
+    expect(fullRegistryFindings.every((finding) => finding.evidenceGrade === "source_backed")).toBe(
+      true
+    );
+    expect(fullRegistryFixes).toHaveLength(5);
+    expect(fullRegistryFixes.every(({ fix }) => fix.deterministic === true)).toBe(true);
+
+    ix.tokens.symbolExists = () => false;
+    const poisonedFindings = runEveryRule(ix);
+    const poisonedFixes = tokenFixes(poisonedFindings);
+
+    expect(poisonedFixes).toHaveLength(fullRegistryFixes.length);
+    expect(
+      poisonedFixes.map(({ finding, fix }) => ({
+        ruleId: finding.ruleId,
+        fix: withoutDeterminism(fix),
+      }))
+    ).toEqual(
+      fullRegistryFixes.map(({ finding, fix }) => ({
+        ruleId: finding.ruleId,
+        fix: withoutDeterminism(fix),
+      }))
+    );
+    expect(poisonedFixes.filter(({ fix }) => fix.deterministic === true)).toEqual([]);
+    expect(
+      poisonedFixes.every(
+        ({ finding }) =>
+          typeof finding.attributes?.downgradeReason === "string" &&
+          finding.attributes.downgradeReason.includes("absent token symbol")
+      )
+    ).toBe(true);
+  });
+
+  it("downgrades an exact dimension match whose token has no directly applicable form", () => {
+    const ix = buildFixtureCorpus("dtcg");
+    const dimension = RULES.find((rule) => rule.id === "styles/no-raw-dimensions")
+      ?.run(ix)
+      .find((finding) => finding.fix);
+
+    expect(dimension?.fix?.deterministic).toBe(false);
+    expect(dimension?.attributes?.downgradeReason).toContain(
+      "token reference is not directly applicable"
+    );
+  });
+});
+
+function runEveryRule(ix: FactIndex): Finding[] {
+  const visited: string[] = [];
+  const findings = RULES.flatMap((rule) => {
+    visited.push(rule.id);
+    return rule.run(ix);
+  });
+  expect(visited).toEqual(RULES.map((rule) => rule.id));
+  return findings;
+}
+
+function tokenFixes(findings: readonly Finding[]) {
+  return findings.flatMap((finding) => {
+    const fix = finding.fix;
+    if (!fix) return [];
+    const symbols = tokenSymbolsInText(replacementText(fix));
+    return symbols.length > 0 ? [{ finding, fix, symbols }] : [];
+  });
+}
+
+function replacementText(fix: FindingFix): string {
+  if (fix.kind === "replaceStyleValue") return fix.value;
+  if (fix.kind === "replaceImport" || fix.kind === "replaceComponent") return fix.to;
+  if (fix.kind === "replaceClassToken") return fix.to ?? "";
+  return typeof fix.value === "string" ? fix.value : "";
+}
+
+function withoutDeterminism(fix: FindingFix): Omit<FindingFix, "deterministic"> {
+  const { deterministic: _deterministic, ...rest } = fix;
+  return rest;
+}
+
+function buildFixtureCorpus(radiusReferenceFormat: "css-var" | "dtcg" = "css-var"): FactIndex {
+  const ix = new FactIndex();
+  ix.addMany([
+    makeTokenDefinitionFact({
+      name: "--proof-color",
+      value: "#123456",
+      category: "color",
+      referenceFormat: "css-var",
+      sourceNames: ["--proof-color"],
+    }),
+    makeTokenDefinitionFact({
+      name: "--proof-space",
+      value: "8px",
+      category: "spacing",
+      referenceFormat: "css-var",
+      sourceNames: ["--proof-space"],
+    }),
+    makeTokenDefinitionFact({
+      name: "--proof-radius",
+      value: "4px",
+      category: "radius",
+      referenceFormat: radiusReferenceFormat,
+      sourceNames: ["--proof-radius"],
+    }),
+    makeTokenDefinitionFact({
+      name: "--proof-font",
+      value: "16px",
+      category: "typography",
+      referenceFormat: "css-var",
+      sourceNames: ["--proof-font"],
+    }),
+    makeTokenDefinitionFact({
+      name: "--proof-dual",
+      value: "8px",
+      category: "spacing",
+      referenceFormat: "scss-var",
+      sourceNames: ["--proof-dual", "$proof-dual"],
+    }),
+    makeStyleRawColorForbiddenFact({ except: [], prefer: "token", severity: "error" }),
+    makeStyleRawDimensionForbiddenFact({
+      appliesTo: ["border-radius"],
+      prefer: "token",
+      severity: "error",
+    }),
+    makeScaleFact({ name: "space", unit: "px" }),
+    makeScaleValueFact({ scale: "space", value: 8 }),
+    makeStylePropertyScaleFact({ property: "margin", scale: "space", severity: "error" }),
+    makeScaleFact({ name: "type", unit: "px" }),
+    makeScaleValueFact({ scale: "type", value: 16 }),
+    makeStyleFontSizeScaleFact({ scale: "type", severity: "error" }),
+    makeGovernanceRuleConfigFact({
+      ruleId: "tokens/require-dual-fallback",
+      enabled: true,
+      severity: "error",
+    }),
+    declaration("color", "#123456", 1),
+    declaration("border-radius", "4px", 2),
+    declaration("margin", "8px", 3),
+    declaration("font-size", "16px", 4),
+    declaration("gap", "var(--proof-dual)", 5),
+  ]);
+  return ix;
+}
+
+function declaration(property: string, value: string, line: number) {
+  return makeStyleDeclarationFact({
+    file: "fixture.scss",
+    selector: ".fixture",
+    declarationPath: `.fixture/${property}`,
+    property,
+    value,
+    location: { file: "fixture.scss", line, column: 1 },
+  });
+}