@shapeshift-labs/frontier-lang-css 0.1.8 → 0.1.10

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.
 
 ## 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.
+- 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 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.
 - 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`, `browserCascadeEquivalenceClaim`, and `browserRenderEquivalenceClaim` remain false.

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 { CssDependencyGraphEvidence } from './dependency-graph.js';
 
 export interface CssProjectionOptions {
   readonly banner?: string;
@@ -216,7 +216,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 +227,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;
@@ -235,9 +235,7 @@ export interface CssSemanticMergeEvidence {
 }
 
 export interface CssSafeMergeConflict {
-  readonly code: string;
-  readonly gateId: 'css-semantic-merge' | string;
-  readonly sourcePath?: string;
+  readonly code: string; readonly gateId: 'css-semantic-merge' | string; readonly sourcePath?: string;
   readonly details: Readonly<Record<string, unknown>> & { readonly reasonCode: string; readonly conflictKey: string };
 }
 
@@ -256,28 +254,26 @@ export interface CssSafeMergeResult {
   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;
 }
 
 export interface CssSafeMergeParserEvidence {
   readonly kind: 'frontier.lang.cssSafeMergeParserEvidence'; readonly version: 1; readonly parserNames: readonly string[];
   readonly sourceCodeLocationInfo: boolean; readonly parserBackedSourceSpans: boolean; readonly parserBackedDeclarationSpans: boolean; readonly parserBackedTriviaHashes: boolean;
-  readonly scopedCascadeGraphHashPresent: boolean; readonly parseErrors: number;
-  readonly sides: Readonly<Record<string, CssSafeMergeParserSideEvidence>>;
+  readonly scopedCascadeGraphHashPresent: boolean; readonly parseErrors: number; readonly sides: Readonly<Record<string, CssSafeMergeParserSideEvidence>>;
 }
 
 export interface CssSafeMergeParserSideEvidence {
-  readonly parserName: string;
-  readonly sourceCodeLocationInfo: boolean; readonly parserBackedSourceSpans: boolean; readonly parserBackedDeclarationSpans: boolean; readonly parserBackedTriviaHashes: boolean;
+  readonly parserName: string; readonly sourceCodeLocationInfo: boolean; readonly parserBackedSourceSpans: boolean; readonly parserBackedDeclarationSpans: boolean; readonly parserBackedTriviaHashes: boolean;
   readonly scopedCascadeGraphHashPresent: boolean; readonly parseErrors: number; readonly recordCount: number; readonly declarationCount: number;
 }
 
 export interface CssSafeMergeSelectorTargetEvidence {
-  readonly kind: 'frontier.lang.cssSafeMergeSelectorTargetEvidence'; readonly version: 1;
-  readonly selectorTargetGraphHashPresent: boolean; readonly parserBackedRuleSpans: boolean;
+  readonly kind: 'frontier.lang.cssSafeMergeSelectorTargetEvidence'; readonly version: 1; readonly selectorTargetGraphHashPresent: boolean; readonly parserBackedRuleSpans: boolean;
   readonly selectorMoveCount: number; readonly workerSelectorMoves: number; readonly headSelectorMoves: number;
   readonly sides: Readonly<Record<string, CssSafeMergeSelectorTargetSideEvidence>>;
   readonly moves: Readonly<Record<'worker' | 'head', readonly CssSafeMergeSelectorMove[]>>;
+  readonly rebasedChangeCount?: number; readonly rebaseProofs?: readonly CssSafeMergeSelectorTargetRebaseProof[];
 }
 
 export interface CssSafeMergeSelectorTargetSideEvidence {
@@ -288,7 +284,15 @@ export interface CssSafeMergeSelectorTargetSideEvidence {
 export interface CssSafeMergeSelectorMove {
   readonly side: string; readonly property: string; readonly beforeRuleKey: string; readonly afterRuleKey: string;
   readonly beforeSelectors?: readonly string[]; readonly afterSelectors?: readonly string[]; readonly beforeScopes?: readonly string[]; readonly afterScopes?: readonly string[];
-  readonly declarationHash: string; readonly selectorTargetGraphHashPresent: boolean;
+  readonly declarationHash: string; readonly beforeSelectorTargetGraphHash?: string; readonly afterSelectorTargetGraphHash?: string; readonly selectorTargetGraphHashPresent: boolean;
+}
+
+export interface CssSafeMergeSelectorTargetRebaseProof {
+  readonly kind: 'css-selector-target-rebase'; readonly side: string; readonly fromRuleKey: string; readonly toRuleKey: string; readonly property: string; readonly cascadeKey: string;
+}
+
+export interface CssSelectorTargetEquivalence {
+  readonly fromRuleKey?: string; readonly toRuleKey?: string; readonly fromSelectors?: readonly string[]; readonly toSelectors?: readonly string[]; readonly graphHash?: string;
 }
 
 export interface CssSafeMergeInput {
@@ -296,7 +300,7 @@ 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 selectorTargetGraphHash?: string;
+  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;
   readonly baseJsTsUseSiteGraphHash?: string; readonly workerJsTsUseSiteGraphHash?: string; readonly headJsTsUseSiteGraphHash?: 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-selector-targets.js

@@ -46,26 +46,64 @@ function selectorTargetMoves(changes, side) {
       beforeScopes: deletion.before.scopes,
       afterScopes: addition.after.scopes,
       declarationHash: addition.after.declarationHash,
+      beforeSelectorTargetGraphHash: deletion.before.selectorTargetGraphHash,
+      afterSelectorTargetGraphHash: addition.after.selectorTargetGraphHash,
       selectorTargetGraphHashPresent: Boolean(deletion.before.selectorTargetGraphHash && addition.after.selectorTargetGraphHash)
     });
   }
   return moves;
 }
 
-function selectorTargetMoveConflicts(id, sourcePath, selectorTargetEvidence, changed) {
-  return [
-    ...selectorTargetMoveSideConflicts(id, sourcePath, selectorTargetEvidence.moves.worker, selectorTargetEvidence.moves.head, changed.head),
-    ...selectorTargetMoveSideConflicts(id, sourcePath, selectorTargetEvidence.moves.head, selectorTargetEvidence.moves.worker, changed.worker)
-  ];
+function planSelectorTargetRebase(id, sourcePath, selectorTargetEvidence, changed, options = {}) {
+  const planned = { worker: [...changed.worker], head: [...changed.head] };
+  const worker = selectorTargetMoveSidePlan(id, sourcePath, selectorTargetEvidence.moves.worker, selectorTargetEvidence.moves.head, planned.head, options);
+  const head = selectorTargetMoveSidePlan(id, sourcePath, selectorTargetEvidence.moves.head, selectorTargetEvidence.moves.worker, planned.worker, options);
+  return {
+    changed: planned,
+    conflicts: [...worker.conflicts, ...head.conflicts],
+    evidence: { ...selectorTargetEvidence, rebasedChangeCount: worker.rebaseProofs.length + head.rebaseProofs.length, rebaseProofs: [...worker.rebaseProofs, ...head.rebaseProofs] }
+  };
+}
+
+function selectorTargetMoveSidePlan(id, sourcePath, moves, oppositeMoves, oppositeChanges, options) {
+  const conflicts = [];
+  const rebaseProofs = [];
+  for (const move of moves) {
+    if (oppositeMoves.some((oppositeMove) => sameSelectorMove(move, oppositeMove))) continue;
+    for (let index = 0; index < oppositeChanges.length; index += 1) {
+      const change = oppositeChanges[index];
+      if (!selectorMoveTouchesChange(move, change)) continue;
+      if (canRebaseChange(move, change, options)) {
+        const rebased = rebaseChangeToSelectorMove(change, move);
+        oppositeChanges[index] = rebased.change;
+        rebaseProofs.push(rebased.proof);
+      } else conflicts.push(conflict(id, sourcePath, change.key, move, change));
+    }
+  }
+  return { conflicts, rebaseProofs };
 }
 
-function selectorTargetMoveSideConflicts(id, sourcePath, moves, oppositeMoves, oppositeChanges) {
-  return moves.flatMap((move) => {
-    if (oppositeMoves.some((oppositeMove) => sameSelectorMove(move, oppositeMove))) return [];
-    return oppositeChanges.filter((change) => selectorMoveTouchesChange(move, change)).map((change) => conflict(id, sourcePath, change.key, move, change));
+function canRebaseChange(move, change, options) {
+  return change.kind === 'add' && change.after && hasSelectorTargetEquivalence(move, options);
+}
+
+function hasSelectorTargetEquivalence(move, options) {
+  return (options.selectorTargetEquivalences ?? []).some((entry) => {
+    const ruleKeysMatch = entry.fromRuleKey === move.beforeRuleKey && entry.toRuleKey === move.afterRuleKey;
+    const selectorsMatch = selectorListKey(entry.fromSelectors) === selectorListKey(move.beforeSelectors) && selectorListKey(entry.toSelectors) === selectorListKey(move.afterSelectors);
+    const graphMatches = !entry.graphHash || entry.graphHash === move.beforeSelectorTargetGraphHash || entry.graphHash === move.afterSelectorTargetGraphHash;
+    return graphMatches && (ruleKeysMatch || selectorsMatch);
   });
 }
 
+function rebaseChangeToSelectorMove(change, move) {
+  const after = { ...change.after, ruleKey: move.afterRuleKey, selectors: move.afterSelectors, scopes: move.afterScopes ?? [], key: cascadeKey(move.afterScopes, move.afterSelectors, change.after.property), rebasedFromRuleKey: move.beforeRuleKey };
+  return {
+    change: { ...change, key: after.key, after },
+    proof: { kind: 'css-selector-target-rebase', side: change.side, fromRuleKey: move.beforeRuleKey, toRuleKey: move.afterRuleKey, property: change.after.property, cascadeKey: after.key }
+  };
+}
+
 function conflict(id, sourcePath, cascadeKey, selectorMove, change) {
   return {
     code: 'css-selector-target-conflict',
@@ -94,6 +132,8 @@ function sameSelectorMove(left, right) {
   return left.property === right.property && left.beforeRuleKey === right.beforeRuleKey && left.afterRuleKey === right.afterRuleKey && left.declarationHash === right.declarationHash;
 }
 
+function cascadeKey(scopes = [], selectors = [], property) { return [...scopes, selectors.join(','), property].join('::'); }
+function selectorListKey(value = []) { return Array.isArray(value) ? value.join(',') : undefined; }
 function changeDetails(change) { return { kind: change.kind, property: (change.after ?? change.before)?.property, value: change.after?.value, important: change.after?.important }; }
 
-export { mergeSelectorTargetEvidence, selectorTargetMoveConflicts };
+export { mergeSelectorTargetEvidence, planSelectorTargetRebase };

package/dist/semantic-merge.js

@@ -1,5 +1,6 @@
 import { cssModuleContractChanges, cssModuleContractConflicts, sheetOptions, unsupportedSourceShapeConflicts } from './semantic-merge-css-modules.js';
-import { mergeSelectorTargetEvidence, selectorTargetMoveConflicts } from './semantic-merge-selector-targets.js';
+import { mergeCssDependencyGraphEvidence } from './dependency-graph.js';
+import { mergeSelectorTargetEvidence, planSelectorTargetRebase } from './semantic-merge-selector-targets.js';
 
 function safeMergeCssSource(input = {}, context = {}) {
   const parseSheet = context.parseCssSemanticSheet;
@@ -31,11 +32,11 @@ function safeMergeCssSource(input = {}, context = {}) {
   const moduleConflicts = cssModuleContractConflicts(id, sourcePath, moduleChanges);
   const sourceShapeConflicts = unsupportedSourceShapeConflicts(id, sourcePath, sheets, changed, hash);
   const parserEvidence = mergeParserEvidence(sheets);
-  const selectorTargetEvidence = mergeSelectorTargetEvidence(sheets, changed);
-  const selectorTargetConflicts = selectorTargetMoveConflicts(id, sourcePath, selectorTargetEvidence, changed);
-  const conflicts = [...parserConflicts, ...proofConflicts, ...overlapConflicts, ...moduleConflicts, ...sourceShapeConflicts, ...selectorTargetConflicts];
-  if (conflicts.length) return blocked(id, sourcePath, 'css-semantic-merge-conflict', conflicts, { parserEvidence, selectorTargetEvidence });
-  const mergedIndex = applyDeclarationChanges(applyDeclarationChanges(indexes.base, changed.head), changed.worker);
+  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, dependencyGraphEvidence, selectorTargetEvidence: selectorTargetPlan.evidence });
+  const mergedIndex = applyDeclarationChanges(applyDeclarationChanges(indexes.base, selectorTargetPlan.changed.head), selectorTargetPlan.changed.worker);
   return merged(id, sourcePath, renderDeclarationIndex(mergedIndex), 'semantic-declaration-merge', hash, {
     baseSheetHash: sheets.base.sheetHash,
     workerSheetHash: sheets.worker.sheetHash,
@@ -45,7 +46,8 @@ function safeMergeCssSource(input = {}, context = {}) {
     workerChangedCssModuleContracts: moduleChanges.worker.length,
     headChangedCssModuleContracts: moduleChanges.head.length,
     parserEvidence,
-    selectorTargetEvidence
+    dependencyGraphEvidence,
+    selectorTargetEvidence: selectorTargetPlan.evidence
   });
 }
 

package/package.json

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