@shapeshift-labs/frontier-lang-css 0.1.13 → 0.1.15

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, `var()` fallback references, animation/keyframe links, font-face links, URL asset references, cascade keys, statement-form at-rules, block-form runtime 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, blocks parallel edits whose CSS shorthand expansions overlap a longhand or sub-shorthand, preserves unchanged statement-form at-rules such as `@layer reset, components;`, preserves unchanged block-form runtime at-rules such as `@keyframes` and `@font-face`, 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.
+`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, block-form runtime 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, blocks dependency-affecting declaration edits unless an exact source-bound dependency graph proof is supplied, blocks selector-target rebases unless the host supplies a source-bound selector target graph hash and the parser proves selector specificity is invariant, blocks parallel edits whose CSS shorthand expansions overlap a longhand or sub-shorthand, preserves unchanged statement-form at-rules such as `@layer reset, components;`, preserves unchanged block-form runtime at-rules such as `@keyframes` and `@font-face`, 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, source-bound dependency graph hashes for custom properties, `var()` fallbacks, animations/keyframes, font faces, and URL assets, statement-form at-rules, block-form runtime 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 and non-overlapping shorthand expansion sets; unchanged statement-form at-rules and unchanged block-form runtime 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, shorthand value expansion/equivalence beyond known affected-property overlap checks, statement-form at-rule order/condition changes, one-sided or structurally changed scoped cascade under `@media` / `@supports` / `@container` / `@layer`, changed runtime blocks such as `@keyframes`, `@font-face`, `@page`, and `@property`, browser layout and render equivalence.
-- 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.
+- Safe merge: independent declarations with non-overlapping cascade keys, non-overlapping shorthand expansion sets, and no changed dependency graph surface; unchanged statement-form at-rules and unchanged block-form runtime at-rules preserved in canonical output; existing scoped declaration edits when scoped cascade graph proof is supplied; dependency-affecting declaration edits only when an exact source-bound dependency graph proof is supplied; selector-target rebases only when a matching selector target graph hash is supplied and before/after selector specificity is identical; 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 dependency graph changes, unproved CSS Modules use-site graphs, unproved composition or ICSS graphs, shorthand value expansion/equivalence beyond known affected-property overlap checks, statement-form at-rule order/condition changes, one-sided or structurally changed scoped cascade under `@media` / `@supports` / `@container` / `@layer`, changed runtime blocks such as `@keyframes`, `@font-face`, `@page`, and `@property`, browser layout and render equivalence.
+- Claims: dependency graph evidence is an admission/review signal only unless an exact source-bound dependency graph proof admits the changed dependency surface; `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/dependency-graph.d.ts

@@ -30,6 +30,15 @@ export interface CssDependencyGraphRecordSets {
   readonly urlAssetReferences?: readonly CssDependencyGraphRecord[];
 }
 
+export interface CssDependencyGraphChange {
+  readonly side: 'worker' | 'head' | string;
+  readonly cascadeKey: string;
+  readonly reasonCode: 'css-dependency-graph-proof-unproved' | string;
+  readonly changeKind?: string;
+  readonly before?: Readonly<Record<string, unknown>>;
+  readonly after?: Readonly<Record<string, unknown>>;
+}
+
 export interface CssDependencyGraphEvidence {
   readonly kind: 'frontier.lang.cssDependencyGraphEvidence' | 'frontier.lang.cssSafeMergeDependencyGraphEvidence' | string;
   readonly version: 1;
@@ -42,6 +51,7 @@ export interface CssDependencyGraphEvidence {
   readonly dependencyGraphHash?: string;
   readonly cssDependencyGraphHash?: string;
   readonly changedDependencySurfaceCount?: number;
+  readonly changedDependencySurfaces?: readonly CssDependencyGraphChange[];
   readonly customPropertyDefinitions?: number;
   readonly customPropertyReferences?: number;
   readonly varReferences?: number;
@@ -58,3 +68,36 @@ export interface CssDependencyGraphEvidence {
   readonly browserRenderEquivalenceClaim?: false;
   readonly semanticEquivalenceClaim: false;
 }
+
+export interface CssDependencyGraphProof {
+  readonly id?: string;
+  readonly kind: 'css-dependency-graph-proof' | 'css-source-bound-dependency-graph-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 cascadeKey?: string; readonly cascadeKeys?: readonly string[];
+  readonly dependencyKey?: string; readonly dependencyKeys?: 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>>;
+  readonly baseDependencyGraphHash?: string; readonly workerDependencyGraphHash?: string; readonly headDependencyGraphHash?: string;
+  readonly baseCssDependencyGraphHash?: string; readonly workerCssDependencyGraphHash?: string; readonly headCssDependencyGraphHash?: string;
+  readonly dependencyGraphHashes?: Readonly<Record<string, string>>;
+  readonly cssDependencyGraphHashes?: Readonly<Record<string, string>>;
+}
+
+export interface CssDependencyGraphProofRecord {
+  readonly id?: string;
+  readonly kind: string;
+  readonly status: 'passed';
+  readonly proofLevel: string;
+  readonly reasonCode: string;
+  readonly side: string;
+  readonly cascadeKey: string;
+  readonly sourcePath?: string;
+  readonly baseSourceHash?: string; readonly workerSourceHash?: string; readonly headSourceHash?: string; readonly outputSourceHash?: string;
+  readonly baseDependencyGraphHash?: string; readonly workerDependencyGraphHash?: string; readonly headDependencyGraphHash?: string;
+}

package/dist/dependency-graph.js

@@ -72,8 +72,7 @@ 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));
+  const changedDependencySurfaces = changedDependencyGraphSurfaces(sides, changed);
   return {
     kind: 'frontier.lang.cssSafeMergeDependencyGraphEvidence',
     version: 1,
@@ -81,7 +80,8 @@ function mergeCssDependencyGraphEvidence(sheets, changed = {}) {
     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,
+    changedDependencySurfaceCount: changedDependencySurfaces.length,
+    changedDependencySurfaces,
     sides,
     browserCascadeEquivalenceClaim: false,
     browserRenderEquivalenceClaim: false,
@@ -89,7 +89,37 @@ function mergeCssDependencyGraphEvidence(sheets, changed = {}) {
   };
 }
 
-function dependencySurfaceKeys(evidence) {
+function admitCssDependencyGraphProofs({ id, sourcePath, input, dependencyGraphEvidence, binding, hash }) {
+  const proofs = dependencyGraphProofCandidates(input, sourcePath);
+  const admitted = [];
+  const conflicts = [];
+  for (const change of dependencyGraphEvidence.changedDependencySurfaces ?? []) {
+    const proof = proofs.find((candidate) => isDependencyGraphProofForChange(candidate, change, sourcePath, dependencyGraphEvidence, binding, hash));
+    if (proof) admitted.push(dependencyGraphProofRecord(proof, change, sourcePath, dependencyGraphEvidence, binding, hash));
+    else conflicts.push(conflict(id, sourcePath, 'css-dependency-graph-proof-blocked', change.reasonCode, change));
+  }
+  return { proofs: admitted, conflicts };
+}
+
+function changedDependencyGraphSurfaces(sides, changed) {
+  return Object.entries(changed).flatMap(([side, changes]) => (changes ?? []).flatMap((change) => {
+    const cascadeKey = change.after?.key ?? change.before?.key;
+    if (!cascadeKey) return [];
+    const before = dependencyRecordsForKey(sides.base, cascadeKey);
+    const after = dependencyRecordsForKey(sides[side], cascadeKey);
+    if (!before.length && !after.length) return [];
+    return [{
+      side,
+      cascadeKey,
+      reasonCode: 'css-dependency-graph-proof-unproved',
+      changeKind: change.kind,
+      before: dependencyRecordSummary(before),
+      after: dependencyRecordSummary(after)
+    }];
+  }));
+}
+
+function dependencySurfaceRecords(evidence) {
   const records = evidence.records ?? {};
   return [
     ...(records.customPropertyDefinitions ?? []),
@@ -97,7 +127,99 @@ function dependencySurfaceKeys(evidence) {
     ...(records.animationNameLinks ?? []),
     ...(records.fontFaceLinks ?? []),
     ...(records.urlAssetReferences ?? [])
-  ].map((entry) => entry.cascadeKey).filter(Boolean);
+  ];
+}
+
+function dependencyRecordsForKey(evidence, cascadeKey) {
+  return dependencySurfaceRecords(evidence).filter((entry) => entry.cascadeKey === cascadeKey);
+}
+
+function dependencyRecordSummary(records) {
+  return {
+    dependencyKinds: unique(records.map((entry) => entry.kind)),
+    names: unique(records.map((entry) => entry.name ?? entry.family ?? entry.url)),
+    properties: unique(records.map((entry) => entry.property)),
+    declarationHashes: unique(records.map((entry) => entry.declarationHash))
+  };
+}
+
+function dependencyGraphProofCandidates(input = {}, sourcePath) {
+  return [
+    input.cssDependencyGraphProof,
+    input.cssDependencyGraphProofs,
+    input.cssDependencyGraphProofsByPath?.[sourcePath],
+    input.cssSourceBoundDependencyGraphProof,
+    input.cssSourceBoundDependencyGraphProofs,
+    input.cssSourceBoundDependencyGraphProofsByPath?.[sourcePath],
+    input.dependencyGraphProof,
+    input.dependencyGraphProofs,
+    input.dependencyGraphProofsByPath?.[sourcePath],
+    input.sourceBoundDependencyGraphProof,
+    input.sourceBoundDependencyGraphProofs,
+    input.sourceBoundDependencyGraphProofsByPath?.[sourcePath]
+  ].flatMap(asArray).filter(Boolean);
+}
+
+function isDependencyGraphProofForChange(proof, change, sourcePath, evidence, binding, hash) {
+  return Boolean(proof && typeof proof === 'object') &&
+    DependencyGraphProofKinds.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.cascadeKey ?? proof.dependencyKey, proof.cascadeKeys ?? proof.dependencyKeys, change.cascadeKey) &&
+    proofSourceMatches(proof, 'base', binding.base, hash) &&
+    proofSourceMatches(proof, 'worker', binding.worker, hash) &&
+    proofSourceMatches(proof, 'head', binding.head, hash) &&
+    proofSourceMatches(proof, 'output', binding.output, hash) &&
+    dependencyGraphHashMatches(proof, 'base', evidence.sides?.base) &&
+    dependencyGraphHashMatches(proof, 'worker', evidence.sides?.worker) &&
+    dependencyGraphHashMatches(proof, 'head', evidence.sides?.head);
+}
+
+function dependencyGraphHashMatches(proof, role, sideEvidence) {
+  const graphHash = sideEvidence?.dependencyGraphHash;
+  if (!graphHash) return true;
+  return proof[`${role}DependencyGraphHash`] === graphHash ||
+    proof[`${role}CssDependencyGraphHash`] === graphHash ||
+    proof.dependencyGraphHashes?.[role] === graphHash ||
+    proof.cssDependencyGraphHashes?.[role] === graphHash;
+}
+
+function proofSourceMatches(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 dependencyGraphProofRecord(proof, change, sourcePath, evidence, binding, hash) {
+  return {
+    id: proof.id,
+    kind: proof.kind,
+    status: 'passed',
+    proofLevel: proof.proofLevel ?? 'css-dependency-graph-source-bound',
+    reasonCode: change.reasonCode,
+    side: change.side,
+    cascadeKey: change.cascadeKey,
+    sourcePath,
+    baseSourceHash: hash?.(binding.base),
+    workerSourceHash: hash?.(binding.worker),
+    headSourceHash: hash?.(binding.head),
+    outputSourceHash: hash?.(binding.output),
+    baseDependencyGraphHash: evidence.sides?.base?.dependencyGraphHash,
+    workerDependencyGraphHash: evidence.sides?.worker?.dependencyGraphHash,
+    headDependencyGraphHash: evidence.sides?.head?.dependencyGraphHash
+  };
+}
+
+function conflict(id, sourcePath, code, reasonCode, details = {}) {
+  return { code, gateId: 'css-semantic-merge', sourcePath, details: { reasonCode, conflictKey: `css#${id}#${reasonCode}#${details.cascadeKey ?? sourcePath ?? 'source'}`, ...details } };
 }
 
 function customPropertyDefinition(record, declaration) {
@@ -184,8 +306,11 @@ function stableTextHash(text) {
 
 function unique(values) { return [...new Set(values.filter(Boolean))]; }
 function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+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 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']);
+const DependencyGraphProofKinds = new Set(['css-dependency-graph-proof', 'css-source-bound-dependency-graph-proof']);
 
-export { createCssDependencyGraphEvidence, mergeCssDependencyGraphEvidence };
+export { admitCssDependencyGraphProofs, createCssDependencyGraphEvidence, mergeCssDependencyGraphEvidence };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-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';
+import type { FrontierLangDocument } from '@shapeshift-labs/frontier-lang-kernel'; import type { CssCascadeRuntimeProof, CssCascadeRuntimeProofRecord } from './cascade-runtime-proof.js'; import type { CssDependencyGraphEvidence, CssDependencyGraphProof, CssDependencyGraphProofRecord } from './dependency-graph.js'; export type { CssCascadeRuntimeProof, CssCascadeRuntimeProofRecord } from './cascade-runtime-proof.js'; export type { CssDependencyGraphChange, CssDependencyGraphEvidence, CssDependencyGraphProof, CssDependencyGraphProofRecord } from './dependency-graph.js';
 
 export interface CssProjectionOptions {
   readonly banner?: string;
@@ -227,6 +227,7 @@ export interface CssSafeMergeAdmission {
   readonly reviewRequired: boolean; readonly reasonCodes: readonly string[];
   readonly browserCascadeEquivalenceClaim?: true;
   readonly cssCascadeRuntimeProofs?: readonly CssCascadeRuntimeProofRecord[];
+  readonly cssDependencyGraphProofs?: readonly CssDependencyGraphProofRecord[];
 }
 
 export interface CssSafeMergeResult {
@@ -242,6 +243,7 @@ export interface CssSafeMergeResult {
   readonly workerChangedCssModuleContracts?: number; readonly headChangedCssModuleContracts?: number;
   readonly parserEvidence?: CssSafeMergeParserEvidence; readonly selectorTargetEvidence?: CssSafeMergeSelectorTargetEvidence; readonly dependencyGraphEvidence?: CssDependencyGraphEvidence;
   readonly cascadeRuntimeProofs?: readonly CssCascadeRuntimeProofRecord[];
+  readonly dependencyGraphProofs?: readonly CssDependencyGraphProofRecord[];
 }
 
 export interface CssSafeMergeParserEvidence {
@@ -271,15 +273,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 beforeSelectorTargetGraphHash?: string; readonly afterSelectorTargetGraphHash?: string; readonly selectorTargetGraphHashPresent: boolean;
+  readonly beforeSpecificity?: readonly (readonly number[])[]; readonly afterSpecificity?: readonly (readonly number[])[]; readonly specificityInvariant: 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;
+  readonly kind: 'css-selector-target-rebase'; readonly side: string; readonly fromRuleKey: string; readonly toRuleKey: string; readonly property: string; readonly cascadeKey: string; readonly selectorTargetGraphHash?: string; readonly specificityInvariant: true; readonly beforeSpecificity?: readonly (readonly number[])[]; readonly afterSpecificity?: readonly (readonly number[])[];
 }
 
 export interface CssSelectorTargetEquivalence {
-  readonly fromRuleKey?: string; readonly toRuleKey?: string; readonly fromSelectors?: readonly string[]; readonly toSelectors?: readonly string[]; readonly graphHash?: string;
+  readonly sourcePath?: string; readonly fromRuleKey?: string; readonly toRuleKey?: string; readonly fromSelectors?: readonly string[]; readonly toSelectors?: readonly string[]; readonly fromSpecificity?: readonly (readonly number[])[]; readonly toSpecificity?: readonly (readonly number[])[]; readonly graphHash?: string;
 }
 
 export interface CssSafeMergeInput {
@@ -295,6 +297,8 @@ export interface CssSafeMergeInput {
   readonly cascadeRuntimeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;
   readonly sourceBoundCascadeProof?: CssCascadeRuntimeProof; readonly sourceBoundCascadeProofs?: readonly CssCascadeRuntimeProof[];
   readonly sourceBoundCascadeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;
+  readonly cssDependencyGraphProof?: CssDependencyGraphProof; readonly cssDependencyGraphProofs?: readonly CssDependencyGraphProof[]; readonly cssSourceBoundDependencyGraphProof?: CssDependencyGraphProof; readonly cssSourceBoundDependencyGraphProofs?: readonly CssDependencyGraphProof[];
+  readonly cssDependencyGraphProofsByPath?: Readonly<Record<string, CssDependencyGraphProof | readonly CssDependencyGraphProof[]>>; readonly cssSourceBoundDependencyGraphProofsByPath?: Readonly<Record<string, CssDependencyGraphProof | readonly CssDependencyGraphProof[]>>;
   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/semantic-merge-selector-targets.js

@@ -45,6 +45,9 @@ function selectorTargetMoves(changes, side) {
       afterSelectors: addition.after.selectors,
       beforeScopes: deletion.before.scopes,
       afterScopes: addition.after.scopes,
+      beforeSpecificity: deletion.before.specificity,
+      afterSpecificity: addition.after.specificity,
+      specificityInvariant: specificityListKey(deletion.before.specificity) === specificityListKey(addition.after.specificity),
       declarationHash: addition.after.declarationHash,
       beforeSelectorTargetGraphHash: deletion.before.selectorTargetGraphHash,
       afterSelectorTargetGraphHash: addition.after.selectorTargetGraphHash,
@@ -73,7 +76,7 @@ function selectorTargetMoveSidePlan(id, sourcePath, moves, oppositeMoves, opposi
     for (let index = 0; index < oppositeChanges.length; index += 1) {
       const change = oppositeChanges[index];
       if (!selectorMoveTouchesChange(move, change)) continue;
-      if (canRebaseChange(move, change, options)) {
+      if (canRebaseChange(move, change, options, sourcePath)) {
         const rebased = rebaseChangeToSelectorMove(change, move);
         oppositeChanges[index] = rebased.change;
         rebaseProofs.push(rebased.proof);
@@ -83,16 +86,19 @@ function selectorTargetMoveSidePlan(id, sourcePath, moves, oppositeMoves, opposi
   return { conflicts, rebaseProofs };
 }
 
-function canRebaseChange(move, change, options) {
-  return change.kind === 'add' && change.after && hasSelectorTargetEquivalence(move, options);
+function canRebaseChange(move, change, options, sourcePath) {
+  return change.kind === 'add' && change.after && hasSelectorTargetEquivalence(move, options, sourcePath);
 }
 
-function hasSelectorTargetEquivalence(move, options) {
+function hasSelectorTargetEquivalence(move, options, sourcePath) {
+  if (!move.specificityInvariant) return false;
   return (options.selectorTargetEquivalences ?? []).some((entry) => {
+    const sourceMatches = !entry.sourcePath || entry.sourcePath === sourcePath;
     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);
+    const graphMatches = Boolean(entry.graphHash && entry.graphHash === move.beforeSelectorTargetGraphHash && entry.graphHash === move.afterSelectorTargetGraphHash);
+    const specificityMatches = (!entry.fromSpecificity || specificityListKey(entry.fromSpecificity) === specificityListKey(move.beforeSpecificity)) && (!entry.toSpecificity || specificityListKey(entry.toSpecificity) === specificityListKey(move.afterSpecificity));
+    return sourceMatches && graphMatches && specificityMatches && (ruleKeysMatch || selectorsMatch);
   });
 }
 
@@ -100,7 +106,7 @@ 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 }
+    proof: { kind: 'css-selector-target-rebase', side: change.side, fromRuleKey: move.beforeRuleKey, toRuleKey: move.afterRuleKey, property: change.after.property, cascadeKey: after.key, selectorTargetGraphHash: move.afterSelectorTargetGraphHash, specificityInvariant: true, beforeSpecificity: move.beforeSpecificity, afterSpecificity: move.afterSpecificity }
   };
 }
 
@@ -134,6 +140,7 @@ function sameSelectorMove(left, right) {
 
 function cascadeKey(scopes = [], selectors = [], property) { return [...scopes, selectors.join(','), property].join('::'); }
 function selectorListKey(value = []) { return Array.isArray(value) ? value.join(',') : undefined; }
+function specificityListKey(value = []) { return Array.isArray(value) ? value.map((item) => Array.isArray(item) ? item.join(',') : '').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, planSelectorTargetRebase };

package/dist/semantic-merge.js

@@ -1,6 +1,6 @@
 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 { admitCssDependencyGraphProofs, mergeCssDependencyGraphEvidence } from './dependency-graph.js';
 import { mergeSelectorTargetEvidence, planSelectorTargetRebase } from './semantic-merge-selector-targets.js';
 import { applyAtRuleBlockChanges, atRuleBlockEntry, atRuleBlockOverlapConflicts, atRuleOccurrenceKey, changedAtRuleBlocks, renderAtRuleBlock, renderAtRuleStatement } from './semantic-merge-at-rules.js';
 import { declarationsOverlapByCssProperty, shorthandGroupForProperty } from './semantic-merge-shorthand.js';
@@ -52,8 +52,9 @@ function safeMergeCssSource(input = {}, context = {}) {
     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 });
+  const dependencyGraphAdmission = admitCssDependencyGraphProofs({ id, sourcePath, input, dependencyGraphEvidence, binding: { base, worker, head, output: mergedSourceText }, hash });
+  const conflicts = [...parserConflicts, ...proofConflicts, ...overlapConflicts, ...moduleConflicts, ...cascadeRuntimeAdmission.conflicts, ...dependencyGraphAdmission.conflicts, ...selectorTargetPlan.conflicts];
+  if (conflicts.length) return blocked(id, sourcePath, 'css-semantic-merge-conflict', conflicts, { parserEvidence, dependencyGraphEvidence, selectorTargetEvidence: selectorTargetPlan.evidence, cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs, dependencyGraphProofs: dependencyGraphAdmission.proofs });
   return merged(id, sourcePath, mergedSourceText, 'semantic-declaration-merge', hash, {
     baseSheetHash: sheets.base.sheetHash,
     workerSheetHash: sheets.worker.sheetHash,
@@ -66,6 +67,7 @@ function safeMergeCssSource(input = {}, context = {}) {
     dependencyGraphEvidence,
     selectorTargetEvidence: selectorTargetPlan.evidence,
     cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs,
+    dependencyGraphProofs: dependencyGraphAdmission.proofs,
     browserCascadeEquivalenceClaim: cascadeRuntimeAdmission.proofs.length > 0
   });
 }
@@ -99,7 +101,7 @@ function declarationIndex(sheet) {
         key: declaration.cascadeKey,
         ruleKey,
         selectors: record.selectors,
-        scopes: record.scopes ?? [],
+        scopes: record.scopes ?? [], specificity: record.specificity,
         property: declaration.property,
         value: declaration.value,
         important: declaration.important,
@@ -297,7 +299,7 @@ function result(id, sourcePath, status, body) {
       reviewRequired: status !== 'merged',
       reasonCodes: unique((body.conflicts ?? []).map((item) => item.details.reasonCode)),
       browserCascadeEquivalenceClaim: browserCascadeEquivalenceClaim || undefined,
-      cssCascadeRuntimeProofs: body.cascadeRuntimeProofs?.length ? body.cascadeRuntimeProofs : undefined
+      cssCascadeRuntimeProofs: body.cascadeRuntimeProofs?.length ? body.cascadeRuntimeProofs : undefined, cssDependencyGraphProofs: body.dependencyGraphProofs?.length ? body.dependencyGraphProofs : undefined
     }
   };
 }

package/package.json

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