@shapeshift-labs/frontier-lang-css 0.1.9 → 0.1.11

package/README.md

@@ -232,11 +232,11 @@ const merge = safeMergeCssSource({
 });
 ```
 
-`sourceMap.mappings` links emitted rule blocks back to Frontier Lang semantic node ids. `createCssSemanticMergeEvidence` records selectors, specificity, declarations, custom properties, cascade keys, statement-form at-rules, CSS Modules exports, ICSS edges, scoped cascade graph proof hashes, source spans, stable hashes, and fail-closed proof gaps for cascade/render-sensitive CSS surfaces. `safeMergeCssSource` admits independent declaration edits by cascade key, including existing scoped `@media` / `@supports` / `@container` / `@layer` declarations when a scoped cascade graph proof hash is supplied, preserves unchanged statement-form at-rules such as `@layer reset, components;`, and for `.module.css` files it classifies exported local classes, `composes`, and ICSS import/export records as explicit merge contracts.
+`sourceMap.mappings` links emitted rule blocks back to Frontier Lang semantic node ids. `createCssSemanticMergeEvidence` records selectors, specificity, declarations, custom properties, `var()` fallback references, animation/keyframe links, font-face links, URL asset references, cascade keys, statement-form at-rules, CSS Modules exports, ICSS edges, scoped cascade graph proof hashes, source spans, stable hashes, and fail-closed proof gaps for cascade/render-sensitive CSS surfaces. `safeMergeCssSource` admits independent declaration edits by cascade key, including existing scoped `@media` / `@supports` / `@container` / `@layer` declarations when a scoped cascade graph proof hash is supplied, carries source-bound dependency graph evidence into the merge result, preserves unchanged statement-form at-rules such as `@layer reset, components;`, and for `.module.css` files it classifies exported local classes, `composes`, and ICSS import/export records as explicit merge contracts. Cascade-sensitive source-shape changes still block by default, but a host can attach a `css-source-bound-cascade-runtime-proof` / `css-cascade-runtime-proof` that is bound to the exact source path, reason, side, shape key, and base/worker/head/output source hashes to admit that specific change.
 
 ## Support Boundary
 
-- Ready evidence: style rules, selectors, specificity, declarations, custom properties, statement-form at-rules, CSS Modules local exports, generated class-name map coverage, JS/TS use-site graph hashes, composition graph hashes, ICSS graph hashes, scoped cascade graph hashes, source spans, stable hashes.
-- Safe merge: independent declarations with non-overlapping cascade keys; unchanged statement-form at-rules preserved in canonical output; existing scoped declaration edits when scoped cascade graph proof is supplied; explicit CSS Modules export additions/deletions when generated class-name and JS/TS use-site graph proof is supplied; composition edits when composition graph proof is supplied; ICSS edits when ICSS graph proof is supplied. Output is a canonical CSS render and not a byte/trivia-preserving claim.
+- Ready evidence: style rules, selectors, specificity, declarations, source-bound dependency graph hashes for custom properties, `var()` fallbacks, animations/keyframes, font faces, and URL assets, statement-form at-rules, CSS Modules local exports, generated class-name map coverage, JS/TS use-site graph hashes, composition graph hashes, ICSS graph hashes, scoped cascade graph hashes, source-bound cascade runtime proofs, source spans, stable hashes.
+- Safe merge: independent declarations with non-overlapping cascade keys; unchanged statement-form at-rules preserved in canonical output; existing scoped declaration edits when scoped cascade graph proof is supplied; source-shape/cascade-sensitive edits only when an exact source-bound cascade runtime proof is supplied; explicit CSS Modules export additions/deletions when generated class-name and JS/TS use-site graph proof is supplied; composition edits when composition graph proof is supplied; ICSS edits when ICSS graph proof is supplied. Output is a canonical CSS render and not a byte/trivia-preserving claim.
 - Review-only gaps: incomplete generated class-name maps, unproved CSS Modules use-site graphs, unproved composition or ICSS graphs, shorthands without longhand expansion, statement-form at-rule order/condition changes, one-sided or structurally changed scoped cascade under `@media` / `@supports` / `@container` / `@layer`, `@keyframes`, `@font-face`, `@page`, browser layout and render equivalence.
-- Claims: `autoMergeClaim`, `semanticEquivalenceClaim`, `browserCascadeEquivalenceClaim`, and `browserRenderEquivalenceClaim` remain false.
+- Claims: dependency graph evidence is an admission/review signal only; `autoMergeClaim`, `semanticEquivalenceClaim`, and `browserRenderEquivalenceClaim` remain false. `browserCascadeEquivalenceClaim` is only true on a safe-merge result when a source-bound cascade runtime proof admits the specific cascade-sensitive source-shape change.

package/dist/cascade-runtime-proof.d.ts

@@ -0,0 +1,34 @@
+export interface CssCascadeRuntimeProof {
+  readonly id?: string;
+  readonly kind: 'css-cascade-runtime-proof' | 'css-source-bound-cascade-runtime-proof' | string;
+  readonly status: 'passed' | string;
+  readonly proofLevel?: string;
+  readonly sourcePath?: string;
+  readonly reasonCode?: string;
+  readonly reasonCodes?: readonly string[];
+  readonly side?: 'worker' | 'head' | string;
+  readonly sides?: readonly string[];
+  readonly shapeKey?: string;
+  readonly shapeKeys?: readonly string[];
+  readonly baseSourceText?: string; readonly workerSourceText?: string; readonly headSourceText?: string; readonly outputSourceText?: string; readonly mergedSourceText?: string;
+  readonly baseSourceHash?: string; readonly workerSourceHash?: string; readonly headSourceHash?: string; readonly outputSourceHash?: string; readonly mergedSourceHash?: string;
+  readonly sourceTexts?: Readonly<Record<string, string>>;
+  readonly sources?: Readonly<Record<string, string>>;
+  readonly sourceHashes?: Readonly<Record<string, string>>;
+  readonly hashes?: Readonly<Record<string, string>>;
+}
+
+export interface CssCascadeRuntimeProofRecord {
+  readonly id?: string;
+  readonly kind: string;
+  readonly status: 'passed';
+  readonly proofLevel: string;
+  readonly reasonCode: string;
+  readonly side: string;
+  readonly shapeKey: string;
+  readonly sourcePath?: string;
+  readonly baseSourceHash?: string;
+  readonly workerSourceHash?: string;
+  readonly headSourceHash?: string;
+  readonly outputSourceHash?: string;
+}

package/dist/dependency-graph.d.ts

@@ -0,0 +1,60 @@
+import type { CssSourceSpan } from './index.js';
+
+export interface CssDependencyGraphRecord {
+  readonly kind: string;
+  readonly cascadeKey?: string;
+  readonly property?: string;
+  readonly name?: string;
+  readonly family?: string;
+  readonly url?: string;
+  readonly sourceKind?: string;
+  readonly hasFallback?: boolean;
+  readonly fallbackHash?: string;
+  readonly targetDefined?: boolean;
+  readonly declarationHash?: string;
+  readonly ruleHash?: string;
+  readonly atRuleHash?: string;
+  readonly selectors?: readonly string[];
+  readonly scopes?: readonly string[];
+  readonly sourceSpan?: CssSourceSpan;
+  readonly sourceHash?: string;
+}
+
+export interface CssDependencyGraphRecordSets {
+  readonly customPropertyDefinitions?: readonly CssDependencyGraphRecord[];
+  readonly customPropertyReferences?: readonly CssDependencyGraphRecord[];
+  readonly keyframes?: readonly CssDependencyGraphRecord[];
+  readonly animationNameLinks?: readonly CssDependencyGraphRecord[];
+  readonly fontFaces?: readonly CssDependencyGraphRecord[];
+  readonly fontFaceLinks?: readonly CssDependencyGraphRecord[];
+  readonly urlAssetReferences?: readonly CssDependencyGraphRecord[];
+}
+
+export interface CssDependencyGraphEvidence {
+  readonly kind: 'frontier.lang.cssDependencyGraphEvidence' | 'frontier.lang.cssSafeMergeDependencyGraphEvidence' | string;
+  readonly version: 1;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly hasDependencySurface: boolean;
+  readonly dependencySurfaceCount: number;
+  readonly dependencyGraphHashPresent: boolean;
+  readonly cssDependencyGraphHashPresent?: boolean;
+  readonly dependencyGraphHash?: string;
+  readonly cssDependencyGraphHash?: string;
+  readonly changedDependencySurfaceCount?: number;
+  readonly customPropertyDefinitions?: number;
+  readonly customPropertyReferences?: number;
+  readonly varReferences?: number;
+  readonly varFallbackReferences?: number;
+  readonly keyframeDefinitions?: number;
+  readonly animationNameLinks?: number;
+  readonly keyframeLinks?: number;
+  readonly fontFaceDefinitions?: number;
+  readonly fontFaceLinks?: number;
+  readonly urlAssetReferences?: number;
+  readonly records?: CssDependencyGraphRecordSets;
+  readonly sides?: Readonly<Record<string, CssDependencyGraphEvidence>>;
+  readonly browserCascadeEquivalenceClaim?: false;
+  readonly browserRenderEquivalenceClaim?: false;
+  readonly semanticEquivalenceClaim: false;
+}

package/dist/dependency-graph.js

@@ -0,0 +1,191 @@
+function createCssDependencyGraphEvidence(records = [], options = {}) {
+  const hash = options.hashSemanticValue;
+  const definitions = [];
+  const references = [];
+  const animations = [];
+  const keyframes = [];
+  const fontFaces = [];
+  const fonts = [];
+  const assets = [];
+  for (const record of records) {
+    if (record.kind === 'at-rule' && record.atRuleName === 'keyframes') keyframes.push(keyframeDefinition(record));
+    if (record.kind === 'at-rule' && record.atRuleName === 'font-face') {
+      for (const family of record.dependencyTokens?.fontFamilies ?? []) fontFaces.push(fontFaceDefinition(record, family));
+      for (const url of record.dependencyTokens?.urls ?? []) assets.push(assetReference(record, undefined, url, 'font-face-src'));
+    }
+    for (const declaration of record.declarations ?? []) {
+      if (declaration.property?.startsWith('--')) definitions.push(customPropertyDefinition(record, declaration));
+      for (const item of cssVarReferences(declaration.value)) references.push(customPropertyReference(record, declaration, item));
+      if (declaration.property === 'animation' || declaration.property === 'animation-name') {
+        for (const name of animationNames(declaration.value)) animations.push(animationReference(record, declaration, name));
+      }
+      if (declaration.property === 'font' || declaration.property === 'font-family') {
+        for (const family of fontFamilyNames(declaration.value)) fonts.push(fontReference(record, declaration, family));
+      }
+      for (const url of cssUrlReferences(declaration.value)) assets.push(assetReference(record, declaration, url, 'declaration-url'));
+    }
+  }
+  const keyframeNames = new Set(keyframes.map((entry) => entry.name));
+  const fontNames = new Set(fontFaces.map((entry) => entry.family));
+  const linkedAnimations = animations.map((entry) => ({ ...entry, targetDefined: keyframeNames.has(entry.name) }));
+  const linkedFonts = fonts.map((entry) => ({ ...entry, targetDefined: fontNames.has(entry.family) }));
+  const dependencySurfaceCount = definitions.length + references.length + linkedAnimations.length + keyframes.length + fontFaces.length + linkedFonts.length + assets.length;
+  const graphHash = dependencySurfaceCount ? hash?.({
+    kind: 'frontier.lang.css.dependencyGraph.v1',
+    definitions,
+    references,
+    animations: linkedAnimations,
+    keyframes,
+    fontFaces,
+    fonts: linkedFonts,
+    assets
+  }) : undefined;
+  return compactRecord({
+    kind: 'frontier.lang.cssDependencyGraphEvidence',
+    version: 1,
+    sourcePath: options.sourcePath,
+    sourceHash: options.sourceHash,
+    hasDependencySurface: dependencySurfaceCount > 0,
+    dependencySurfaceCount,
+    dependencyGraphHashPresent: Boolean(graphHash),
+    cssDependencyGraphHashPresent: Boolean(graphHash),
+    dependencyGraphHash: graphHash,
+    cssDependencyGraphHash: graphHash,
+    customPropertyDefinitions: definitions.length,
+    customPropertyReferences: references.length,
+    varReferences: references.length,
+    varFallbackReferences: references.filter((entry) => entry.hasFallback).length,
+    keyframeDefinitions: keyframes.length,
+    animationNameLinks: linkedAnimations.length,
+    keyframeLinks: linkedAnimations.filter((entry) => entry.targetDefined).length,
+    fontFaceDefinitions: fontFaces.length,
+    fontFaceLinks: linkedFonts.length,
+    urlAssetReferences: assets.length,
+    records: { customPropertyDefinitions: definitions, customPropertyReferences: references, keyframes, animationNameLinks: linkedAnimations, fontFaces, fontFaceLinks: linkedFonts, urlAssetReferences: assets },
+    browserCascadeEquivalenceClaim: false,
+    browserRenderEquivalenceClaim: false,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function mergeCssDependencyGraphEvidence(sheets, changed = {}) {
+  const sides = Object.fromEntries(Object.entries(sheets).map(([side, sheet]) => [side, sheet.dependencyGraphEvidence ?? emptyGraphEvidence(sheet)]));
+  const sideValues = Object.values(sides);
+  const hasDependencySurface = sideValues.some((side) => side.hasDependencySurface === true);
+  const changedKeys = new Set([...(changed.worker ?? []), ...(changed.head ?? [])].flatMap((change) => [change.before?.key, change.after?.key].filter(Boolean)));
+  const dependencyKeys = new Set(sideValues.flatMap(dependencySurfaceKeys));
+  return {
+    kind: 'frontier.lang.cssSafeMergeDependencyGraphEvidence',
+    version: 1,
+    hasDependencySurface,
+    dependencySurfaceCount: Math.max(0, ...sideValues.map((side) => side.dependencySurfaceCount ?? 0)),
+    dependencyGraphHashPresent: hasDependencySurface && sideValues.every((side) => side.hasDependencySurface !== true || side.dependencyGraphHashPresent === true),
+    cssDependencyGraphHashPresent: hasDependencySurface && sideValues.every((side) => side.hasDependencySurface !== true || side.cssDependencyGraphHashPresent === true),
+    changedDependencySurfaceCount: [...changedKeys].filter((key) => dependencyKeys.has(key)).length,
+    sides,
+    browserCascadeEquivalenceClaim: false,
+    browserRenderEquivalenceClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+function dependencySurfaceKeys(evidence) {
+  const records = evidence.records ?? {};
+  return [
+    ...(records.customPropertyDefinitions ?? []),
+    ...(records.customPropertyReferences ?? []),
+    ...(records.animationNameLinks ?? []),
+    ...(records.fontFaceLinks ?? []),
+    ...(records.urlAssetReferences ?? [])
+  ].map((entry) => entry.cascadeKey).filter(Boolean);
+}
+
+function customPropertyDefinition(record, declaration) {
+  return baseDependencyRecord(record, declaration, { kind: 'custom-property-definition', name: declaration.property, valueHash: declaration.valueHash });
+}
+
+function customPropertyReference(record, declaration, item) {
+  return baseDependencyRecord(record, declaration, { kind: 'custom-property-reference', name: item.name, fallbackHash: item.fallbackHash, hasFallback: item.hasFallback });
+}
+
+function animationReference(record, declaration, name) {
+  return baseDependencyRecord(record, declaration, { kind: 'animation-name-link', name });
+}
+
+function fontReference(record, declaration, family) {
+  return baseDependencyRecord(record, declaration, { kind: 'font-face-link', family });
+}
+
+function assetReference(record, declaration, url, sourceKind) {
+  return baseDependencyRecord(record, declaration, { kind: 'url-asset-reference', url, sourceKind });
+}
+
+function keyframeDefinition(record) {
+  return { kind: 'keyframes-definition', name: firstCssIdent(record.conditionText), atRuleHash: record.atRuleHash, sourceSpan: record.sourceSpan, sourceHash: record.sourceHash };
+}
+
+function fontFaceDefinition(record, family) {
+  return { kind: 'font-face-definition', family, atRuleHash: record.atRuleHash, sourceSpan: record.sourceSpan, sourceHash: record.sourceHash };
+}
+
+function baseDependencyRecord(record, declaration, extra) {
+  return compactRecord({
+    ...extra,
+    cascadeKey: declaration?.cascadeKey,
+    property: declaration?.property,
+    declarationHash: declaration?.declarationHash,
+    ruleHash: record.ruleHash,
+    selectors: record.selectors,
+    scopes: record.scopes ?? [],
+    sourceSpan: declaration?.sourceSpan ?? record.sourceSpan,
+    sourceHash: record.sourceHash
+  });
+}
+
+function cssVarReferences(value) {
+  return [...String(value ?? '').matchAll(/\bvar\(\s*(--[-_A-Za-z][\w-]*)(?:\s*,\s*([^)]*))?\)/g)].map((match) => ({
+    name: match[1],
+    hasFallback: match[2] !== undefined,
+    fallbackHash: match[2] === undefined ? undefined : stableTextHash(match[2].trim())
+  }));
+}
+
+function cssUrlReferences(value) {
+  return [...String(value ?? '').matchAll(/\burl\(\s*(?:"([^"]*)"|'([^']*)'|([^)]*?))\s*\)/g)]
+    .map((match) => (match[1] ?? match[2] ?? match[3] ?? '').trim())
+    .filter(Boolean);
+}
+
+function animationNames(value) {
+  const normalized = String(value ?? '').replace(/\bvar\(\s*--[-_A-Za-z][\w-]*(?:\s*,\s*([^)]*))?\)/g, (_, fallback) => fallback ?? '');
+  return unique(normalized.split(/[\s,]+/).map((part) => part.trim().replace(/[()]+$/g, '')).filter((part) => part && !AnimationKeywords.has(part) && !/^[\d.]+m?s$/.test(part)));
+}
+
+function fontFamilyNames(value) {
+  return unique(String(value ?? '').split(',').map((part) => part.trim().replace(/^['"]|['"]$/g, '')).filter((part) => part && !FontKeywords.has(part) && !/^[\d.]+/.test(part)));
+}
+
+function firstCssIdent(value) {
+  return /^[-_A-Za-z][\w-]*/.exec(String(value ?? '').trim())?.[0];
+}
+
+function emptyGraphEvidence(sheet) {
+  return { kind: 'frontier.lang.cssDependencyGraphEvidence', version: 1, sourceHash: sheet.sourceHash, hasDependencySurface: false, dependencySurfaceCount: 0, dependencyGraphHashPresent: false, cssDependencyGraphHashPresent: false, semanticEquivalenceClaim: false };
+}
+
+function stableTextHash(text) {
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, '0')}`;
+}
+
+function unique(values) { return [...new Set(values.filter(Boolean))]; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+const AnimationKeywords = new Set(['none', 'initial', 'inherit', 'unset', 'revert', 'linear', 'ease', 'ease-in', 'ease-out', 'ease-in-out', 'infinite', 'alternate', 'forwards', 'backwards', 'both', 'normal', 'reverse', 'running', 'paused']);
+const FontKeywords = new Set(['serif', 'sans-serif', 'monospace', 'cursive', 'fantasy', 'system-ui', 'inherit', 'initial', 'unset', 'revert']);
+
+export { createCssDependencyGraphEvidence, mergeCssDependencyGraphEvidence };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { FrontierLangDocument } from '@shapeshift-labs/frontier-lang-kernel';
+import type { FrontierLangDocument } from '@shapeshift-labs/frontier-lang-kernel'; import type { CssCascadeRuntimeProof, CssCascadeRuntimeProofRecord } from './cascade-runtime-proof.js'; import type { CssDependencyGraphEvidence } from './dependency-graph.js'; export type { CssCascadeRuntimeProof, CssCascadeRuntimeProofRecord } from './cascade-runtime-proof.js';
 
 export interface CssProjectionOptions {
   readonly banner?: string;
@@ -13,6 +13,8 @@ export interface CssProjectionOptions {
   readonly cssModuleCompositionGraphHash?: string;
   readonly icssGraphHash?: string;
   readonly scopedCascadeGraphHash?: string;
+  readonly cssCascadeRuntimeProof?: CssCascadeRuntimeProof; readonly cssCascadeRuntimeProofs?: readonly CssCascadeRuntimeProof[];
+  readonly cssSourceBoundCascadeProof?: CssCascadeRuntimeProof; readonly cssSourceBoundCascadeProofs?: readonly CssCascadeRuntimeProof[];
   readonly selectorTargetGraphHash?: string;
   readonly targetPath?: string;
   readonly semanticIndexId?: string;
@@ -20,36 +22,16 @@ export interface CssProjectionOptions {
   readonly evidence?: readonly CssProjectionEvidenceRecord[];
 }
 
-export interface CssProjectionEvidenceRecord {
-  readonly id: string;
-  readonly kind?: string;
-  readonly summary?: string;
-  readonly [key: string]: unknown;
-}
+export interface CssProjectionEvidenceRecord { readonly id: string; readonly kind?: string; readonly summary?: string; readonly [key: string]: unknown; }
 
 export interface CssSourceSpan {
-  readonly path?: string;
-  readonly startOffset?: number;
-  readonly endOffset?: number;
-  readonly startLine: number;
-  readonly startColumn: number;
-  readonly endLine: number;
-  readonly endColumn: number;
+  readonly path?: string; readonly startOffset?: number; readonly endOffset?: number;
+  readonly startLine: number; readonly startColumn: number; readonly endLine: number; readonly endColumn: number;
 }
 
-export interface CssParserDiagnostic {
-  readonly reason?: string;
-  readonly line?: number;
-  readonly column?: number;
-  readonly input?: string;
-  readonly [key: string]: unknown;
-}
+export interface CssParserDiagnostic { readonly reason?: string; readonly line?: number; readonly column?: number; readonly input?: string; readonly [key: string]: unknown; }
 
-export interface CssParserEvidence {
-  readonly name: 'postcss' | string;
-  readonly sourceCodeLocationInfo: boolean;
-  readonly parseErrors: readonly CssParserDiagnostic[];
-}
+export interface CssParserEvidence { readonly name: 'postcss' | string; readonly sourceCodeLocationInfo: boolean; readonly parseErrors: readonly CssParserDiagnostic[]; }
 
 export interface CssSourceRef {
   readonly semanticNodeId: string;
@@ -216,7 +198,7 @@ export interface CssSemanticSheet {
   readonly sourcePath?: string;
   readonly sourceHash: string;
   readonly records: readonly CssSemanticRecord[];
-  readonly cssModules?: CssModuleEvidence;
+  readonly cssModules?: CssModuleEvidence; readonly dependencyGraphEvidence: CssDependencyGraphEvidence;
   readonly sheetHash: string;
   readonly summary: Readonly<Record<string, number>>;
   readonly proofGaps: readonly CssSemanticProofGap[];
@@ -227,7 +209,7 @@ export interface CssSemanticMergeEvidence {
   readonly kind: 'frontier.lang.cssSemanticMergeEvidence'; readonly version: 1;
   readonly status: 'ready' | 'needs-review' | string; readonly sourcePath?: string; readonly sourceHash: string; readonly sheetHash: string;
   readonly records: readonly CssSemanticRecord[];
-  readonly cssModules?: CssModuleEvidence;
+  readonly cssModules?: CssModuleEvidence; readonly dependencyGraphEvidence: CssDependencyGraphEvidence;
   readonly proofGaps: readonly CssSemanticProofGap[];
   readonly autoMergeClaim: false; readonly semanticEquivalenceClaim: false;
   readonly cssModuleGeneratedNameEquivalenceClaim: false; readonly cssModuleUseSiteEquivalenceClaim: false;
@@ -242,6 +224,8 @@ export interface CssSafeMergeConflict {
 export interface CssSafeMergeAdmission {
   readonly status: 'auto-merge-candidate' | 'blocked' | string; readonly action: 'apply-css' | 'human-review' | string;
   readonly reviewRequired: boolean; readonly reasonCodes: readonly string[];
+  readonly browserCascadeEquivalenceClaim?: true;
+  readonly cssCascadeRuntimeProofs?: readonly CssCascadeRuntimeProofRecord[];
 }
 
 export interface CssSafeMergeResult {
@@ -251,10 +235,12 @@ export interface CssSafeMergeResult {
   readonly conflicts: readonly CssSafeMergeConflict[];
   readonly admission: CssSafeMergeAdmission;
   readonly autoMergeClaim: false; readonly semanticEquivalenceClaim: false;
+  readonly browserCascadeEquivalenceClaim: boolean; readonly browserRenderEquivalenceClaim: false;
   readonly baseSheetHash?: string; readonly workerSheetHash?: string; readonly headSheetHash?: string;
   readonly workerChangedDeclarations?: number; readonly headChangedDeclarations?: number;
   readonly workerChangedCssModuleContracts?: number; readonly headChangedCssModuleContracts?: number;
-  readonly parserEvidence?: CssSafeMergeParserEvidence; readonly selectorTargetEvidence?: CssSafeMergeSelectorTargetEvidence;
+  readonly parserEvidence?: CssSafeMergeParserEvidence; readonly selectorTargetEvidence?: CssSafeMergeSelectorTargetEvidence; readonly dependencyGraphEvidence?: CssDependencyGraphEvidence;
+  readonly cascadeRuntimeProofs?: readonly CssCascadeRuntimeProofRecord[];
 }
 
 export interface CssSafeMergeParserEvidence {
@@ -300,6 +286,14 @@ export interface CssSafeMergeInput {
   readonly cssModule?: boolean; readonly cssModules?: boolean;
   readonly generatedClassNameMap?: Readonly<Record<string, string>>;
   readonly generatedClassNameMapHash?: string; readonly jsTsUseSiteGraphHash?: string; readonly cssModuleCompositionGraphHash?: string; readonly icssGraphHash?: string; readonly scopedCascadeGraphHash?: string;
+  readonly cssCascadeRuntimeProof?: CssCascadeRuntimeProof; readonly cssCascadeRuntimeProofs?: readonly CssCascadeRuntimeProof[];
+  readonly cssCascadeRuntimeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;
+  readonly cssSourceBoundCascadeProof?: CssCascadeRuntimeProof; readonly cssSourceBoundCascadeProofs?: readonly CssCascadeRuntimeProof[];
+  readonly cssSourceBoundCascadeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;
+  readonly cascadeRuntimeProof?: CssCascadeRuntimeProof; readonly cascadeRuntimeProofs?: readonly CssCascadeRuntimeProof[];
+  readonly cascadeRuntimeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;
+  readonly sourceBoundCascadeProof?: CssCascadeRuntimeProof; readonly sourceBoundCascadeProofs?: readonly CssCascadeRuntimeProof[];
+  readonly sourceBoundCascadeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;
   readonly selectorTargetGraphHash?: string; readonly selectorTargetEquivalences?: readonly CssSelectorTargetEquivalence[];
   readonly baseGeneratedClassNameMap?: Readonly<Record<string, string>>; readonly workerGeneratedClassNameMap?: Readonly<Record<string, string>>; readonly headGeneratedClassNameMap?: Readonly<Record<string, string>>;
   readonly baseGeneratedClassNameMapHash?: string; readonly workerGeneratedClassNameMapHash?: string; readonly headGeneratedClassNameMapHash?: string;

package/dist/index.js

@@ -1,12 +1,9 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { createCssModuleEvidence } from './css-modules.js';
+import { createCssDependencyGraphEvidence } from './dependency-graph.js';
 import { parsePostcssSemanticRecords } from './postcss-parser-evidence.js';
 import { safeMergeCssSource as safeMergeCssSourceImpl } from './semantic-merge.js';
 
-const ShorthandProperties = new Set(['all', 'animation', 'background', 'border', 'border-block', 'border-color', 'border-image', 'border-inline', 'border-radius', 'border-style', 'border-width', 'columns', 'flex', 'font', 'gap', 'grid', 'grid-area', 'grid-column', 'grid-row', 'inset', 'list-style', 'margin', 'offset', 'outline', 'overflow', 'padding', 'place-content', 'place-items', 'place-self', 'text-decoration', 'transition']);
-const RuntimeAtRules = new Set(['keyframes', 'font-face', 'page', 'property']);
-const ScopeAtRules = new Set(['media', 'supports', 'container', 'layer', 'scope']);
-
 export function toCssAst(document, options = {}) {
   const banner = options.banner ?? 'Generated by @shapeshift-labs/frontier-lang-css.';
   const rules = [];
@@ -62,6 +59,7 @@ export function parseCssSemanticSheet(sourceText, options = {}) {
   const parsed = parsePostcssSemanticRecords(sourceText, sourceHash, options);
   const records = parsed.records;
   const cssModules = createCssModuleEvidence(records, options, sourceHash);
+  const dependencyGraphEvidence = createCssDependencyGraphEvidence(records, { ...options, sourceHash, hashSemanticValue });
   const proofGaps = [
     ...parsed.proofGaps,
     ...records.flatMap((record) => record.proofGaps ?? []),
@@ -74,7 +72,8 @@ export function parseCssSemanticSheet(sourceText, options = {}) {
     sourceHash,
     records,
     cssModules,
-    sheetHash: hashSemanticValue({ kind: 'frontier.lang.cssSemanticSheet.records.v1', records: records.map(hashableCssRecord), cssModuleHash: cssModules?.moduleHash }),
+    dependencyGraphEvidence,
+    sheetHash: hashSemanticValue({ kind: 'frontier.lang.cssSemanticSheet.records.v1', records: records.map(hashableCssRecord), cssModuleHash: cssModules?.moduleHash, dependencyGraphHash: dependencyGraphEvidence.dependencyGraphHash }),
     summary: {
       rules: records.filter((record) => record.kind === 'rule').length,
       declarations: records.reduce((sum, record) => sum + (record.declarations?.length ?? 0), 0),
@@ -83,6 +82,13 @@ export function parseCssSemanticSheet(sourceText, options = {}) {
       cssModuleCompositions: cssModules?.compositions.length ?? 0,
       icssImports: cssModules?.icssImports.length ?? 0,
       icssExports: cssModules?.icssExports.length ?? 0,
+      dependencySurfaceCount: dependencyGraphEvidence.dependencySurfaceCount,
+      customPropertyDefinitions: dependencyGraphEvidence.customPropertyDefinitions,
+      customPropertyReferences: dependencyGraphEvidence.customPropertyReferences,
+      animationNameLinks: dependencyGraphEvidence.animationNameLinks,
+      keyframeDefinitions: dependencyGraphEvidence.keyframeDefinitions,
+      fontFaceLinks: dependencyGraphEvidence.fontFaceLinks,
+      urlAssetReferences: dependencyGraphEvidence.urlAssetReferences,
       proofGaps: proofGaps.length,
       parseErrors: parsed.parser.parseErrors.length
     },
@@ -102,6 +108,7 @@ export function createCssSemanticMergeEvidence(sourceText, options = {}) {
     sheetHash: sheet.sheetHash,
     records: sheet.records,
     cssModules: sheet.cssModules,
+    dependencyGraphEvidence: sheet.dependencyGraphEvidence,
     proofGaps: sheet.proofGaps,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false,
@@ -116,163 +123,6 @@ export function safeMergeCssSource(input = {}) {
   return safeMergeCssSourceImpl(input, { parseCssSemanticSheet, hashSemanticValue });
 }
 
-function parseCssBlocks(sourceText, start, end, scopes, lineStarts, sourceHash, options) {
-  const records = [];
-  const blockRanges = [];
-  let index = start;
-  while (index < end) {
-    const open = sourceText.indexOf('{', index);
-    if (open < 0 || open >= end) break;
-    const close = matchingBrace(sourceText, open, end);
-    if (close < 0) break;
-    const preludeStart = previousBoundary(sourceText, index, open);
-    blockRanges.push([preludeStart, close + 1]);
-    const prelude = sourceText.slice(preludeStart, open).replace(/\/\*[\s\S]*?\*\//g, '').trim();
-    const body = sourceText.slice(open + 1, close);
-    if (prelude.startsWith('@')) {
-      const at = parseAtRule(prelude, preludeStart, close + 1, lineStarts, sourceHash, scopes, options);
-      records.push(at);
-      if (ScopeAtRules.has(at.atRuleName)) records.push(...parseCssBlocks(sourceText, open + 1, close, [...scopes, at.scopeKey], lineStarts, sourceHash, options));
-    } else if (prelude) {
-      records.push(cssRuleRecord(prelude, body, preludeStart, close + 1, lineStarts, sourceHash, scopes, options));
-    }
-    index = close + 1;
-  }
-  records.push(...parseAtRuleStatements(sourceText, start, end, scopes, lineStarts, sourceHash, options, blockRanges));
-  return records.sort((left, right) => left.sourceSpan.startOffset - right.sourceSpan.startOffset);
-}
-
-function cssRuleRecord(prelude, body, start, end, lineStarts, sourceHash, scopes, options) {
-  const selectors = prelude.split(',').map((selector) => selector.trim()).filter(Boolean);
-  const declarations = parseDeclarations(body);
-  const proofGaps = [
-    ...declarations.filter((declaration) => ShorthandProperties.has(declaration.property)).map((declaration) => proofGap('css-shorthand-expansion-unproved', `CSS shorthand ${declaration.property} needs longhand expansion evidence.`)),
-    ...scopes.length && !options.scopedCascadeGraphHash ? [proofGap('css-scoped-cascade-equivalence-unproved', 'Scoped cascade equivalence requires browser/style evidence.')] : []
-  ];
-  return compactRecord({
-    kind: 'rule',
-    selectors,
-    selectorHash: hashSemanticValue({ kind: 'frontier.lang.css.selectors.v1', selectors }),
-    specificity: selectors.map(selectorSpecificity),
-    scopes,
-    declarations: declarations.map((declaration, ordinal) => ({
-      ...declaration,
-      ordinal,
-      cascadeKey: [...scopes, selectors.join(','), declaration.property].join('::'),
-      declarationHash: hashSemanticValue({ kind: 'frontier.lang.css.declaration.v1', scopes, selectors, declaration })
-    })),
-    customProperties: declarations.filter((declaration) => declaration.property.startsWith('--')).map((declaration) => declaration.property),
-    scopedCascadeGraphHash: scopes.length ? options.scopedCascadeGraphHash : undefined,
-    sourceSpan: sourceSpan(start, end, lineStarts),
-    sourceHash,
-    ruleHash: hashSemanticValue({ kind: 'frontier.lang.css.rule.v1', selectors, scopes, declarations }),
-    proofGaps: proofGaps.length ? proofGaps : undefined
-  });
-}
-
-function parseAtRule(prelude, start, end, lineStarts, sourceHash, scopes, options) {
-  const match = /^@([A-Za-z-]+)\s*([\s\S]*)$/.exec(prelude);
-  const atRuleName = match?.[1]?.toLowerCase() ?? 'unknown';
-  const conditionText = match?.[2]?.trim() ?? '';
-  const proofGaps = [];
-  if (RuntimeAtRules.has(atRuleName)) proofGaps.push(proofGap(`css-${atRuleName}-runtime-equivalence-unproved`, `CSS @${atRuleName} semantics require browser evidence.`));
-  if (ScopeAtRules.has(atRuleName) && !options.scopedCascadeGraphHash) proofGaps.push(proofGap(`css-${atRuleName}-cascade-scope-unproved`, `CSS @${atRuleName} scoped cascade requires condition evaluation evidence.`));
-  return compactRecord({
-    kind: 'at-rule',
-    atRuleName,
-    conditionText,
-    scopeKey: `@${atRuleName} ${conditionText}`.trim(),
-    scopes,
-    scopedCascadeGraphHash: ScopeAtRules.has(atRuleName) ? options.scopedCascadeGraphHash : undefined,
-    sourceSpan: sourceSpan(start, end, lineStarts),
-    sourceHash,
-    atRuleHash: hashSemanticValue({ kind: 'frontier.lang.css.atRule.v1', atRuleName, conditionText, scopes }),
-    proofGaps: proofGaps.length ? proofGaps : undefined
-  });
-}
-
-function parseAtRuleStatements(sourceText, start, end, scopes, lineStarts, sourceHash, options, blockRanges) {
-  const records = [];
-  let index = start;
-  while (index < end) {
-    const semicolon = sourceText.indexOf(';', index);
-    if (semicolon < 0 || semicolon >= end) break;
-    const range = blockRanges.find(([rangeStart, rangeEnd]) => semicolon >= rangeStart && semicolon < rangeEnd);
-    if (range) {
-      index = range[1];
-      continue;
-    }
-    const statementStart = previousBoundary(sourceText, index, semicolon);
-    const statementText = sourceText.slice(statementStart, semicolon + 1).replace(/\/\*[\s\S]*?\*\//g, '').trim();
-    if (statementText.startsWith('@') && !statementText.includes('{')) records.push(parseAtRuleStatement(statementText, statementStart, semicolon + 1, lineStarts, sourceHash, scopes, options));
-    index = semicolon + 1;
-  }
-  return records;
-}
-
-function parseAtRuleStatement(statementText, start, end, lineStarts, sourceHash, scopes, options) {
-  const body = statementText.replace(/;$/, '').trim();
-  const match = /^@([A-Za-z-]+)\s*([\s\S]*)$/.exec(body);
-  const atRuleName = match?.[1]?.toLowerCase() ?? 'unknown';
-  const conditionText = match?.[2]?.trim() ?? '';
-  const proofGaps = [];
-  if (atRuleName === 'layer') proofGaps.push(proofGap('css-layer-order-statement-unsupported', 'CSS @layer statement order requires cascade order evidence.'));
-  else proofGaps.push(proofGap(`css-${atRuleName}-statement-equivalence-unproved`, `CSS @${atRuleName} statement semantics require host evidence.`));
-  return compactRecord({
-    kind: 'at-rule-statement',
-    atRuleName,
-    conditionText,
-    statementText,
-    scopes,
-    scopedCascadeGraphHash: ScopeAtRules.has(atRuleName) ? options.scopedCascadeGraphHash : undefined,
-    sourceSpan: sourceSpan(start, end, lineStarts),
-    sourceHash,
-    atRuleHash: hashSemanticValue({ kind: 'frontier.lang.css.atRuleStatement.v1', atRuleName, conditionText, scopes, statementText }),
-    proofGaps
-  });
-}
-
-function parseDeclarations(body) {
-  return body
-    .replace(/\/\*[\s\S]*?\*\//g, '')
-    .split(';')
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .flatMap((part) => {
-      const separator = part.indexOf(':');
-      if (separator <= 0) return [];
-      const rawProperty = part.slice(0, separator).trim();
-      const property = rawProperty.toLowerCase();
-      const value = part.slice(separator + 1).trim();
-      return [{ property, rawProperty, value, important: /!important\s*$/i.test(value), valueHash: hashSemanticValue({ kind: 'frontier.lang.css.value.v1', value }) }];
-    });
-}
-
-function selectorSpecificity(selector) {
-  const withoutStrings = selector.replace(/"[^"]*"|'[^']*'/g, '');
-  const ids = (withoutStrings.match(/#[\w-]+/g) ?? []).length;
-  const classes = (withoutStrings.match(/\.[\w-]+|\[[^\]]+\]|:(?!:)[\w-]+(?:\([^)]*\))?/g) ?? []).length;
-  const elements = (withoutStrings.replace(/#[\w-]+|\.[\w-]+|\[[^\]]+\]|:{1,2}[\w-]+(?:\([^)]*\))?/g, ' ').match(/\b[A-Za-z][\w-]*\b/g) ?? []).length;
-  return [ids, classes, elements];
-}
-
-function matchingBrace(text, open, end) {
-  let depth = 0;
-  for (let index = open; index < end; index += 1) {
-    if (text[index] === '{') depth += 1;
-    if (text[index] === '}') {
-      depth -= 1;
-      if (depth === 0) return index;
-    }
-  }
-  return -1;
-}
-
-function previousBoundary(text, start, open) {
-  const candidates = [text.lastIndexOf('}', open - 1), text.lastIndexOf(';', open - 1)].filter((value) => value >= start);
-  return (candidates.length ? Math.max(...candidates) + 1 : start);
-}
-
 function sourceMapMapping(rule, index, startLine, endLine, options) {
   return compactRecord({
     id: `map_${idFragment(rule.sourceRef.semanticNodeId)}_${index}`,
@@ -290,22 +140,8 @@ function sourceMapEnvelope(ast, mappings, options) {
   return compactRecord({ kind: 'frontier.lang.sourceMap', version: 1, id: options.sourceMapId ?? `sourcemap_${idFragment(ast.kind)}_css`, sourcePath: options.sourcePath, sourceHash: options.sourceHash, target: { language: 'css' }, targetPath: options.targetPath, semanticIndexId: options.semanticIndexId, mappings, evidence: options.evidence ?? [], metadata: { precision: 'rule-block', generatedSpanStrategy: 'css-renderer-rule-block' } });
 }
 
-function sourceSpan(start, end, lineStarts) {
-  const from = positionAt(start, lineStarts);
-  const to = positionAt(end, lineStarts);
-  return { startOffset: start, endOffset: end, startLine: from.line, startColumn: from.column, endLine: to.line, endColumn: to.column };
-}
-
-function positionAt(offset, lineStarts) {
-  let line = 0;
-  while (line + 1 < lineStarts.length && lineStarts[line + 1] <= offset) line += 1;
-  return { line: line + 1, column: offset - lineStarts[line] + 1 };
-}
-
 function sourceRef(node, extra = {}) { return { semanticNodeId: node.id, semanticNodeKind: node.kind, semanticNodeName: node.name, ...extra }; }
-function proofGap(code, summary) { return { code, status: 'not-claimed', summary, failClosed: true, semanticEquivalenceClaim: false }; }
 function hashableCssRecord(record) { return { kind: record.kind, selectors: record.selectors, specificity: record.specificity, scopes: record.scopes, atRuleName: record.atRuleName, conditionText: record.conditionText, statementText: record.statementText, declarations: record.declarations?.map((item) => ({ property: item.property, value: item.value, important: item.important })), proofGaps: record.proofGaps?.map((gap) => gap.code) }; }
-function computeLineStarts(text) { const starts = [0]; for (let index = 0; index < text.length; index += 1) if (text[index] === '\n') starts.push(index + 1); return starts; }
 function cssIdentifier(value) { return String(value ?? 'unknown').replace(/[^A-Za-z0-9_-]/g, '-').replace(/^-+/, '') || 'unknown'; }
 function cssString(value) { return String(value ?? '').replace(/\\/g, '\\\\').replace(/"/g, '\\"'); }
 function typeName(type) { return typeof type === 'string' ? type : type?.name ?? type?.kind ?? 'unknown'; }

package/dist/postcss-parser-evidence.js

@@ -102,6 +102,7 @@ function postcssAtRuleRecord(node, scopes, sourceHash, options) {
     statementText: kind === 'at-rule-statement' ? rawText : undefined,
     scopeKey: postcssAtRuleScopeKey(node),
     scopes,
+    dependencyTokens: atRuleDependencyTokens(node, atRuleName),
     scopedCascadeGraphHash: ScopeAtRules.has(atRuleName) ? options.scopedCascadeGraphHash : undefined,
     sourceSpan: sourceSpanFromPostcss(node.source, options.sourcePath),
     sourceHash,
@@ -116,6 +117,26 @@ function postcssAtRuleScopeKey(node) {
   return `@${String(node.name ?? 'unknown').toLowerCase()} ${String(node.params ?? '').trim()}`.trim();
 }
 
+function atRuleDependencyTokens(node, atRuleName) {
+  if (atRuleName !== 'font-face') return undefined;
+  const declarations = (node.nodes ?? []).filter((child) => child.type === 'decl');
+  const fontFamilies = declarations
+    .filter((declaration) => String(declaration.prop ?? '').toLowerCase() === 'font-family')
+    .flatMap((declaration) => fontFamilyNames(declaration.value));
+  const urls = declarations.flatMap((declaration) => cssUrlReferences(declaration.value));
+  return compactRecord({ fontFamilies: unique(fontFamilies), urls: unique(urls) });
+}
+
+function fontFamilyNames(value) {
+  return String(value ?? '').split(',').map((part) => part.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean);
+}
+
+function cssUrlReferences(value) {
+  return [...String(value ?? '').matchAll(/\burl\(\s*(?:"([^"]*)"|'([^']*)'|([^)]*?))\s*\)/g)]
+    .map((match) => (match[1] ?? match[2] ?? match[3] ?? '').trim())
+    .filter(Boolean);
+}
+
 function sourceSpanFromPostcss(source, fallbackPath) {
   const start = source?.start;
   const end = source?.end;
@@ -147,6 +168,7 @@ function selectorSpecificity(selector) {
 }
 
 function proofGap(code, summary) { return { code, status: 'not-claimed', summary, failClosed: true, semanticEquivalenceClaim: false }; }
+function unique(values) { return [...new Set(values.filter(Boolean))]; }
 function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
 
 export { parsePostcssSemanticRecords };

package/dist/semantic-merge-cascade-runtime.js

@@ -0,0 +1,82 @@
+function admitCascadeRuntimeProofs({ id, sourcePath, input, sourceShapeChanges, binding, hash }) {
+  const proofs = cascadeRuntimeProofCandidates(input, sourcePath);
+  const admitted = [];
+  const conflicts = [];
+  for (const change of sourceShapeChanges) {
+    const proof = proofs.find((candidate) => isCascadeRuntimeProofForChange(candidate, change, sourcePath, binding, hash));
+    if (proof) admitted.push(cascadeRuntimeProofRecord(proof, change, sourcePath, binding, hash));
+    else conflicts.push(conflict(id, sourcePath, 'css-source-shape-unsupported', change.reasonCode, change));
+  }
+  return { proofs: admitted, conflicts };
+}
+
+function cascadeRuntimeProofCandidates(input = {}, sourcePath) {
+  return [
+    input.cssCascadeRuntimeProof,
+    input.cssCascadeRuntimeProofs,
+    input.cssCascadeRuntimeProofsByPath?.[sourcePath],
+    input.cssSourceBoundCascadeProof,
+    input.cssSourceBoundCascadeProofs,
+    input.cssSourceBoundCascadeProofsByPath?.[sourcePath],
+    input.cascadeRuntimeProof,
+    input.cascadeRuntimeProofs,
+    input.cascadeRuntimeProofsByPath?.[sourcePath],
+    input.sourceBoundCascadeProof,
+    input.sourceBoundCascadeProofs,
+    input.sourceBoundCascadeProofsByPath?.[sourcePath]
+  ].flatMap(asArray).filter(Boolean);
+}
+
+function isCascadeRuntimeProofForChange(proof, change, sourcePath, binding, hash) {
+  return Boolean(proof && typeof proof === 'object') &&
+    CascadeRuntimeProofKinds.has(proof.kind) &&
+    proof.status === 'passed' &&
+    proof.sourcePath === sourcePath &&
+    proofCoversValue(proof.reasonCode, proof.reasonCodes, change.reasonCode) &&
+    proofCoversValue(proof.side, proof.sides, change.side) &&
+    proofCoversValue(proof.shapeKey, proof.shapeKeys, change.shapeKey) &&
+    cascadeProofSourceMatches(proof, 'base', binding.base, hash) &&
+    cascadeProofSourceMatches(proof, 'worker', binding.worker, hash) &&
+    cascadeProofSourceMatches(proof, 'head', binding.head, hash) &&
+    cascadeProofSourceMatches(proof, 'output', binding.output, hash);
+}
+
+function cascadeProofSourceMatches(proof, role, sourceText, hash) {
+  if (typeof sourceText !== 'string') return false;
+  const sourceHash = hash?.(sourceText);
+  const textFields = role === 'output' ? ['outputSourceText', 'mergedSourceText'] : [`${role}SourceText`];
+  const hashFields = role === 'output' ? ['outputSourceHash', 'mergedSourceHash'] : [`${role}SourceHash`];
+  const aliases = role === 'output' ? ['output', 'merged'] : [role];
+  return textFields.some((field) => proof[field] === sourceText) ||
+    aliases.some((alias) => proof.sourceTexts?.[alias] === sourceText || proof.sources?.[alias] === sourceText) ||
+    hashFields.some((field) => sourceHash !== undefined && proof[field] === sourceHash) ||
+    aliases.some((alias) => sourceHash !== undefined && (proof.sourceHashes?.[alias] === sourceHash || proof.hashes?.[alias] === sourceHash));
+}
+
+function cascadeRuntimeProofRecord(proof, change, sourcePath, binding, hash) {
+  return {
+    id: proof.id,
+    kind: proof.kind,
+    status: 'passed',
+    proofLevel: proof.proofLevel ?? 'css-cascade-runtime-source-bound',
+    reasonCode: change.reasonCode,
+    side: change.side,
+    shapeKey: change.shapeKey,
+    sourcePath,
+    baseSourceHash: hash?.(binding.base),
+    workerSourceHash: hash?.(binding.worker),
+    headSourceHash: hash?.(binding.head),
+    outputSourceHash: hash?.(binding.output)
+  };
+}
+
+function conflict(id, sourcePath, code, reasonCode, details = {}) {
+  return { code, gateId: 'css-semantic-merge', sourcePath, details: { reasonCode, conflictKey: `css#${id}#${reasonCode}#${details.cascadeKey ?? details.shapeKey ?? sourcePath ?? 'source'}`, ...details } };
+}
+
+function proofCoversValue(value, values, expected) { return value === expected || (Array.isArray(values) && values.includes(expected)); }
+function asArray(value) { return Array.isArray(value) ? value : value === undefined ? [] : [value]; }
+
+const CascadeRuntimeProofKinds = new Set(['css-cascade-runtime-proof', 'css-source-bound-cascade-runtime-proof']);
+
+export { admitCascadeRuntimeProofs };

package/dist/semantic-merge-css-modules.js

@@ -131,14 +131,18 @@ function cssModuleOverlapConflicts(id, sourcePath, workerChanges, headChanges) {
 }
 
 function unsupportedSourceShapeConflicts(id, sourcePath, sheets, declarationChanges, hash) {
-  const sourceShapeChanges = {
-    worker: unsupportedSourceShapeChanges(sheets.base, sheets.worker, declarationChanges.worker, 'worker', hash),
-    head: unsupportedSourceShapeChanges(sheets.base, sheets.head, declarationChanges.head, 'head', hash)
-  };
-  return [...sourceShapeChanges.worker, ...sourceShapeChanges.head].map((change) => conflict(id, sourcePath, 'css-source-shape-unsupported', change.reasonCode, change));
+  return unsupportedSourceShapeChanges(sheets, declarationChanges, hash)
+    .map((change) => conflict(id, sourcePath, 'css-source-shape-unsupported', change.reasonCode, change));
+}
+
+function unsupportedSourceShapeChanges(sheets, declarationChanges, hash) {
+  return [
+    ...unsupportedSourceShapeChangesForSide(sheets.base, sheets.worker, declarationChanges.worker, 'worker', hash),
+    ...unsupportedSourceShapeChangesForSide(sheets.base, sheets.head, declarationChanges.head, 'head', hash)
+  ];
 }
 
-function unsupportedSourceShapeChanges(baseSheet, currentSheet, declarationChanges, side, hash) {
+function unsupportedSourceShapeChangesForSide(baseSheet, currentSheet, declarationChanges, side, hash) {
   const baseShape = sourceShapeIndex(baseSheet, hash);
   const currentShape = sourceShapeIndex(currentSheet, hash);
   const keys = unique([...baseShape.keys(), ...currentShape.keys()]);
@@ -226,4 +230,4 @@ function uniqueProofGaps(values) {
   return [...byCode.values()];
 }
 
-export { cssModuleContractChanges, cssModuleContractConflicts, sheetOptions, unsupportedSourceShapeConflicts };
+export { cssModuleContractChanges, cssModuleContractConflicts, sheetOptions, unsupportedSourceShapeChanges, unsupportedSourceShapeConflicts };

package/dist/semantic-merge-shorthand.js

@@ -0,0 +1,16 @@
+function shorthandGroupForProperty(property) {
+  if (ShorthandGroups.has(property)) return property;
+  for (const [group, longhands] of ShorthandGroups) if (longhands.includes(property)) return group;
+  return undefined;
+}
+
+const ShorthandGroups = new Map([
+  ['background', ['background-attachment', 'background-clip', 'background-color', 'background-image', 'background-origin', 'background-position', 'background-repeat', 'background-size']],
+  ['border', ['border-color', 'border-style', 'border-width', 'border-top', 'border-right', 'border-bottom', 'border-left']],
+  ['font', ['font-family', 'font-size', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'line-height']],
+  ['list-style', ['list-style-image', 'list-style-position', 'list-style-type']],
+  ['margin', ['margin-top', 'margin-right', 'margin-bottom', 'margin-left']],
+  ['padding', ['padding-top', 'padding-right', 'padding-bottom', 'padding-left']]
+]);
+
+export { shorthandGroupForProperty };

package/dist/semantic-merge.js

@@ -1,5 +1,8 @@
-import { cssModuleContractChanges, cssModuleContractConflicts, sheetOptions, unsupportedSourceShapeConflicts } from './semantic-merge-css-modules.js';
+import { cssModuleContractChanges, cssModuleContractConflicts, sheetOptions, unsupportedSourceShapeChanges } from './semantic-merge-css-modules.js';
+import { admitCascadeRuntimeProofs } from './semantic-merge-cascade-runtime.js';
+import { mergeCssDependencyGraphEvidence } from './dependency-graph.js';
 import { mergeSelectorTargetEvidence, planSelectorTargetRebase } from './semantic-merge-selector-targets.js';
+import { shorthandGroupForProperty } from './semantic-merge-shorthand.js';
 
 function safeMergeCssSource(input = {}, context = {}) {
   const parseSheet = context.parseCssSemanticSheet;
@@ -29,13 +32,23 @@ function safeMergeCssSource(input = {}, context = {}) {
     ...shorthandOverlapConflicts(id, sourcePath, changed.worker, changed.head)
   ];
   const moduleConflicts = cssModuleContractConflicts(id, sourcePath, moduleChanges);
-  const sourceShapeConflicts = unsupportedSourceShapeConflicts(id, sourcePath, sheets, changed, hash);
   const parserEvidence = mergeParserEvidence(sheets);
+  const dependencyGraphEvidence = mergeCssDependencyGraphEvidence(sheets, changed);
   const selectorTargetPlan = planSelectorTargetRebase(id, sourcePath, mergeSelectorTargetEvidence(sheets, changed), changed, input);
-  const conflicts = [...parserConflicts, ...proofConflicts, ...overlapConflicts, ...moduleConflicts, ...sourceShapeConflicts, ...selectorTargetPlan.conflicts];
-  if (conflicts.length) return blocked(id, sourcePath, 'css-semantic-merge-conflict', conflicts, { parserEvidence, selectorTargetEvidence: selectorTargetPlan.evidence });
+  const shapeChanges = unsupportedSourceShapeChanges(sheets, changed, hash);
   const mergedIndex = applyDeclarationChanges(applyDeclarationChanges(indexes.base, selectorTargetPlan.changed.head), selectorTargetPlan.changed.worker);
-  return merged(id, sourcePath, renderDeclarationIndex(mergedIndex), 'semantic-declaration-merge', hash, {
+  const mergedSourceText = renderDeclarationIndex(mergedIndex);
+  const cascadeRuntimeAdmission = admitCascadeRuntimeProofs({
+    id,
+    sourcePath,
+    input,
+    sourceShapeChanges: shapeChanges,
+    binding: { base, worker, head, output: mergedSourceText },
+    hash
+  });
+  const conflicts = [...parserConflicts, ...proofConflicts, ...overlapConflicts, ...moduleConflicts, ...cascadeRuntimeAdmission.conflicts, ...selectorTargetPlan.conflicts];
+  if (conflicts.length) return blocked(id, sourcePath, 'css-semantic-merge-conflict', conflicts, { parserEvidence, dependencyGraphEvidence, selectorTargetEvidence: selectorTargetPlan.evidence, cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs });
+  return merged(id, sourcePath, mergedSourceText, 'semantic-declaration-merge', hash, {
     baseSheetHash: sheets.base.sheetHash,
     workerSheetHash: sheets.worker.sheetHash,
     headSheetHash: sheets.head.sheetHash,
@@ -44,7 +57,10 @@ function safeMergeCssSource(input = {}, context = {}) {
     workerChangedCssModuleContracts: moduleChanges.worker.length,
     headChangedCssModuleContracts: moduleChanges.head.length,
     parserEvidence,
-    selectorTargetEvidence: selectorTargetPlan.evidence
+    dependencyGraphEvidence,
+    selectorTargetEvidence: selectorTargetPlan.evidence,
+    cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs,
+    browserCascadeEquivalenceClaim: cascadeRuntimeAdmission.proofs.length > 0
   });
 }
 
@@ -264,20 +280,25 @@ function blocked(id, sourcePath, reasonCode, conflicts = [], extra = {}) {
 }
 
 function result(id, sourcePath, status, body) {
+  const browserCascadeEquivalenceClaim = status === 'merged' && body.browserCascadeEquivalenceClaim === true;
   return {
     kind: 'frontier.lang.cssSafeMerge',
     version: 1,
     id,
     sourcePath,
     status,
+    ...body,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false,
-    ...body,
+    browserCascadeEquivalenceClaim,
+    browserRenderEquivalenceClaim: false,
     admission: {
       status: status === 'merged' ? 'auto-merge-candidate' : 'blocked',
       action: status === 'merged' ? 'apply-css' : 'human-review',
       reviewRequired: status !== 'merged',
-      reasonCodes: unique((body.conflicts ?? []).map((item) => item.details.reasonCode))
+      reasonCodes: unique((body.conflicts ?? []).map((item) => item.details.reasonCode)),
+      browserCascadeEquivalenceClaim: browserCascadeEquivalenceClaim || undefined,
+      cssCascadeRuntimeProofs: body.cascadeRuntimeProofs?.length ? body.cascadeRuntimeProofs : undefined
     }
   };
 }
@@ -295,19 +316,4 @@ function proofGapsForDeclaration(record, declaration) {
 function unique(values) { return [...new Set(values.filter(Boolean))]; }
 function spaces(count) { return ' '.repeat(Math.max(0, count)); }
 
-function shorthandGroupForProperty(property) {
-  if (ShorthandGroups.has(property)) return property;
-  for (const [group, longhands] of ShorthandGroups) if (longhands.includes(property)) return group;
-  return undefined;
-}
-
-const ShorthandGroups = new Map([
-  ['background', ['background-attachment', 'background-clip', 'background-color', 'background-image', 'background-origin', 'background-position', 'background-repeat', 'background-size']],
-  ['border', ['border-color', 'border-style', 'border-width', 'border-top', 'border-right', 'border-bottom', 'border-left']],
-  ['font', ['font-family', 'font-size', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'line-height']],
-  ['list-style', ['list-style-image', 'list-style-position', 'list-style-type']],
-  ['margin', ['margin-top', 'margin-right', 'margin-bottom', 'margin-left']],
-  ['padding', ['padding-top', 'padding-right', 'padding-bottom', 'padding-left']]
-]);
-
 export { safeMergeCssSource };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-css",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "CSS semantic merge evidence and projection adapter for Frontier Lang semantic source documents.",
   "type": "module",
   "main": "./dist/index.js",