@shapeshift-labs/frontier-lang-css 0.1.22 → 0.1.23

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 deterministic box-shorthand expansion evidence for supported margin/padding/inset/gap/scroll/border-edge families, carries source-bound dependency graph evidence into the merge result, blocks duplicate ordered occurrences of the same cascade key until ordered cascade evidence exists, 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.
+`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 keyed by scope shape, source spans, stable hashes, and fail-closed proof gaps for cascade/render-sensitive CSS surfaces. `safeMergeCssSource` admits independent declaration edits by cascade key, carries deterministic box-shorthand expansion evidence for supported margin/padding/inset/gap/scroll/border-edge families, carries source-bound dependency graph evidence into the merge result, blocks duplicate ordered occurrences of the same cascade key until ordered cascade evidence exists, 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 changed scoped declarations under `@media` / `@supports` / `@container` / `@layer` / `@scope` unless an exact source-bound scoped cascade proof matches the scope shape key, scoped graph hash, and base/worker/head/output source hashes, 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, no duplicate ordered occurrences for any changed cascade key, deterministic box-shorthand expansion evidence for supported shorthand families, 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: duplicate ordered occurrences of the same cascade key, incomplete generated class-name maps, unproved dependency graph changes, unproved CSS Modules use-site graphs, unproved composition or ICSS graphs, ambiguous shorthand value expansion/equivalence such as `font`, layered `background`, and runtime-substituted `var()` / `env()` shorthand values, 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.
+- 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 by scope shape key, source-bound scoped cascade proofs, source-bound cascade runtime proofs, source spans, stable hashes.
+- Safe merge: independent declarations with non-overlapping cascade keys, no duplicate ordered occurrences for any changed cascade key, deterministic box-shorthand expansion evidence for supported shorthand families, 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; changed scoped declaration edits only when an exact source-bound scoped cascade proof matches the scope shape key, scoped graph hash, and base/worker/head/output source hashes; 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: duplicate ordered occurrences of the same cascade key, incomplete generated class-name maps, unproved dependency graph changes, unproved CSS Modules use-site graphs, unproved composition or ICSS graphs, ambiguous shorthand value expansion/equivalence such as `font`, layered `background`, and runtime-substituted `var()` / `env()` shorthand values, statement-form at-rule order/condition changes, one-sided or structurally changed scoped cascade under `@media` / `@supports` / `@container` / `@layer` / `@scope`, 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/index.d.ts

@@ -13,6 +13,14 @@ export interface CssProjectionOptions {
   readonly cssModuleCompositionGraphHash?: string;
   readonly icssGraphHash?: string;
   readonly scopedCascadeGraphHash?: string;
+  readonly scopedCascadeGraphHashesByShapeKey?: Readonly<Record<string, string>>;
+  readonly cssScopedCascadeGraphHashesByShapeKey?: Readonly<Record<string, string>>;
+  readonly baseScopedCascadeGraphHashesByShapeKey?: Readonly<Record<string, string>>;
+  readonly workerScopedCascadeGraphHashesByShapeKey?: Readonly<Record<string, string>>;
+  readonly headScopedCascadeGraphHashesByShapeKey?: Readonly<Record<string, string>>;
+  readonly baseCssScopedCascadeGraphHashesByShapeKey?: Readonly<Record<string, string>>;
+  readonly workerCssScopedCascadeGraphHashesByShapeKey?: Readonly<Record<string, string>>;
+  readonly headCssScopedCascadeGraphHashesByShapeKey?: Readonly<Record<string, string>>;
   readonly cssScopedCascadeProof?: CssScopedCascadeProof; readonly cssScopedCascadeProofs?: readonly CssScopedCascadeProof[];
   readonly cssSourceBoundScopedCascadeProof?: CssScopedCascadeProof; readonly cssSourceBoundScopedCascadeProofs?: readonly CssScopedCascadeProof[];
   readonly cssCascadeRuntimeProof?: CssCascadeRuntimeProof; readonly cssCascadeRuntimeProofs?: readonly CssCascadeRuntimeProof[];
@@ -129,6 +137,7 @@ export interface CssSemanticRecord {
   readonly scopeKey?: string;
   readonly statementText?: string;
   readonly blockText?: string;
+  readonly scopedCascadeGraphShapeKey?: string;
   readonly scopedCascadeGraphHash?: string;
   readonly selectorTargetGraphHash?: string;
   readonly sourceSpan: CssSourceSpan;
@@ -256,12 +265,12 @@ export interface CssSafeMergeResult {
 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 scopedCascadeGraphShapeHashPresent?: 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 scopedCascadeGraphHashPresent: boolean; readonly parseErrors: number; readonly recordCount: number; readonly declarationCount: number;
+  readonly scopedCascadeGraphHashPresent: boolean; readonly scopedCascadeGraphShapeHashPresent?: boolean; readonly scopedCascadeGraphShapeKeys?: number; readonly parseErrors: number; readonly recordCount: number; readonly declarationCount: number;
 }
 
 export interface CssSafeMergeInput {

package/dist/postcss-parser-evidence.js

@@ -42,9 +42,11 @@ function postcssRuleRecord(node, scopes, sourceHash, options) {
   const selectors = String(node.selector ?? '').split(',').map((selector) => selector.trim()).filter(Boolean);
   const declarations = (node.nodes ?? []).filter((child) => child.type === 'decl').map(postcssDeclaration);
   const nestedChildren = (node.nodes ?? []).filter((child) => child.type !== 'decl' && child.type !== 'comment');
+  const scopedCascadeGraphShapeKey = scopedCascadeGraphShapeKeyForScopes(scopes);
+  const scopedCascadeGraphHash = scopedCascadeGraphHashForShape(scopedCascadeGraphShapeKey, options);
   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.')] : [],
+    ...scopes.length && !scopedCascadeGraphHash ? [proofGap('css-scoped-cascade-equivalence-unproved', 'Scoped cascade equivalence requires browser/style evidence.')] : [],
     ...nestedChildren.length ? [proofGap('css-nesting-semantic-unproved', 'CSS nested rule semantics require nesting expansion evidence.')] : []
   ];
   return compactRecord({
@@ -60,7 +62,8 @@ function postcssRuleRecord(node, scopes, sourceHash, options) {
       declarationHash: hashSemanticValue({ kind: 'frontier.lang.css.declaration.v2.postcss', scopes, selectors, property: declaration.property, rawProperty: declaration.rawProperty, value: declaration.value, important: declaration.important })
     })),
     customProperties: declarations.filter((declaration) => declaration.property.startsWith('--')).map((declaration) => declaration.property),
-    scopedCascadeGraphHash: scopes.length ? options.scopedCascadeGraphHash : undefined,
+    scopedCascadeGraphShapeKey,
+    scopedCascadeGraphHash,
     selectorTargetGraphHash: options.selectorTargetGraphHash,
     sourceSpan: sourceSpanFromPostcss(node.source, options.sourcePath),
     sourceHash,
@@ -89,9 +92,12 @@ function postcssAtRuleRecord(node, scopes, sourceHash, options) {
   const atRuleName = String(node.name ?? 'unknown').toLowerCase();
   const conditionText = String(node.params ?? '').trim();
   const rawText = rawPostcssText(node);
+  const scopeKey = postcssAtRuleScopeKey(node);
+  const scopedCascadeGraphShapeKey = ScopeAtRules.has(atRuleName) ? scopedCascadeGraphShapeKeyForScopes([...scopes, scopeKey]) : undefined;
+  const scopedCascadeGraphHash = scopedCascadeGraphHashForShape(scopedCascadeGraphShapeKey, options);
   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.`));
+  if (ScopeAtRules.has(atRuleName) && !scopedCascadeGraphHash) proofGaps.push(proofGap(`css-${atRuleName}-cascade-scope-unproved`, `CSS @${atRuleName} scoped cascade requires condition evaluation evidence.`));
   if (!node.nodes?.length && atRuleName === 'layer') proofGaps.push(proofGap('css-layer-order-statement-unsupported', 'CSS @layer statement order requires cascade order evidence.'));
   else if (!node.nodes?.length) proofGaps.push(proofGap(`css-${atRuleName}-statement-equivalence-unproved`, `CSS @${atRuleName} statement semantics require host evidence.`));
   const kind = node.nodes?.length ? 'at-rule' : 'at-rule-statement';
@@ -101,10 +107,11 @@ function postcssAtRuleRecord(node, scopes, sourceHash, options) {
     conditionText,
     statementText: kind === 'at-rule-statement' ? rawText : undefined,
     blockText: kind === 'at-rule' ? rawText : undefined,
-    scopeKey: postcssAtRuleScopeKey(node),
+    scopeKey,
     scopes,
     dependencyTokens: atRuleDependencyTokens(node, atRuleName),
-    scopedCascadeGraphHash: ScopeAtRules.has(atRuleName) ? options.scopedCascadeGraphHash : undefined,
+    scopedCascadeGraphShapeKey,
+    scopedCascadeGraphHash,
     sourceSpan: sourceSpanFromPostcss(node.source, options.sourcePath),
     sourceHash,
     rawTextHash: hashSemanticValue({ kind: 'frontier.lang.css.rawAtRuleText.v1', text: rawText }),
@@ -118,6 +125,19 @@ function postcssAtRuleScopeKey(node) {
   return `@${String(node.name ?? 'unknown').toLowerCase()} ${String(node.params ?? '').trim()}`.trim();
 }
 
+function scopedCascadeGraphShapeKeyForScopes(scopes = []) {
+  return scopes.length ? scopes.join('::') : undefined;
+}
+
+function scopedCascadeGraphHashForShape(shapeKey, options) {
+  if (!shapeKey) return undefined;
+  return scopedCascadeGraphHashesByShapeKey(options)?.[shapeKey] ?? options.scopedCascadeGraphHash;
+}
+
+function scopedCascadeGraphHashesByShapeKey(options) {
+  return options.scopedCascadeGraphHashesByShapeKey ?? options.cssScopedCascadeGraphHashesByShapeKey ?? options.scopedCascadeGraphHashes;
+}
+
 function atRuleDependencyTokens(node, atRuleName) {
   if (atRuleName !== 'font-face') return undefined;
   const declarations = (node.nodes ?? []).filter((child) => child.type === 'decl');

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

@@ -16,6 +16,10 @@ export interface CssScopedCascadeProof {
   readonly scopes?: readonly string[];
   readonly property?: string;
   readonly properties?: readonly string[];
+  readonly scopedCascadeGraphShapeKey?: string;
+  readonly scopedCascadeGraphShapeKeys?: readonly string[];
+  readonly shapeKey?: string;
+  readonly shapeKeys?: readonly string[];
   readonly scopedCascadeGraphHash?: string;
   readonly graphHash?: string;
   readonly baseScopedCascadeGraphHash?: string;
@@ -23,6 +27,9 @@ export interface CssScopedCascadeProof {
   readonly headScopedCascadeGraphHash?: string;
   readonly scopedCascadeGraphHashes?: Readonly<Record<string, string>>;
   readonly graphHashes?: Readonly<Record<string, string>>;
+  readonly scopedCascadeGraphHashesByShapeKey?: Readonly<Record<string, string>>;
+  readonly graphHashesByShapeKey?: Readonly<Record<string, string>>;
+  readonly scopedCascadeGraphHashesByRoleAndShape?: Readonly<Record<string, Readonly<Record<string, 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>>;
@@ -42,9 +49,11 @@ export interface CssScopedCascadeProofRecord {
   readonly ruleKey?: string;
   readonly property?: string;
   readonly scopes?: readonly string[];
+  readonly scopedCascadeGraphShapeKey?: string;
   readonly sourcePath?: string;
   readonly scopedCascadeGraphHash?: string;
   readonly scopedCascadeGraphHashes?: Readonly<Record<string, string>>;
+  readonly scopedCascadeGraphShapeKeys?: Readonly<Record<string, string>>;
   readonly baseSourceHash?: string;
   readonly workerSourceHash?: string;
   readonly headSourceHash?: string;

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

@@ -12,6 +12,7 @@ function sheetOptions(input, side, sourcePath) {
     cssModuleCompositionGraphHash: input[`${prefix}CssModuleCompositionGraphHash`] ?? input.cssModuleCompositionGraphHash,
     icssGraphHash: input[`${prefix}IcssGraphHash`] ?? input.icssGraphHash,
     scopedCascadeGraphHash: input[`${prefix}ScopedCascadeGraphHash`] ?? input.scopedCascadeGraphHash,
+    scopedCascadeGraphHashesByShapeKey: input[`${prefix}ScopedCascadeGraphHashesByShapeKey`] ?? input[`${prefix}CssScopedCascadeGraphHashesByShapeKey`] ?? input.scopedCascadeGraphHashesByShapeKey ?? input.cssScopedCascadeGraphHashesByShapeKey,
     selectorTargetGraphHash: input[`${prefix}SelectorTargetGraphHash`] ?? input.selectorTargetGraphHash
   };
 }

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

@@ -23,11 +23,13 @@ function scopedCascadeChangesForSide(changes, side, baseIndex) {
       ruleKey: entry.ruleKey,
       selectors: entry.selectors,
       scopes: entry.scopes,
+      scopedCascadeGraphShapeKey: entry.scopedCascadeGraphShapeKey,
       property: entry.property,
       specificity: entry.specificity,
       scopedCascadeGraphReady: graphRoles.every((item) => typeof item.hash === 'string'),
       scopedCascadeGraphHash: graphRoles.find((item) => typeof item.hash === 'string')?.hash,
       scopedCascadeGraphHashes: Object.fromEntries(graphRoles.map((item) => [item.role, item.hash]).filter(([, value]) => typeof value === 'string')),
+      scopedCascadeGraphShapeKeys: Object.fromEntries(graphRoles.map((item) => [item.role, item.shapeKey]).filter(([, value]) => typeof value === 'string')),
       before: scopedCascadeDeclarationDetails(change.before),
       after: scopedCascadeDeclarationDetails(change.after)
     }];
@@ -93,13 +95,25 @@ function scopedCascadeGraphHashMatches(proof, change) {
   if (!hashes.length) return false;
   return hashes.every(([role, expected]) => {
     const sharedHash = firstString(proof.scopedCascadeGraphHash, proof.graphHash);
-    return sharedHash === expected ||
-      proof[`${role}ScopedCascadeGraphHash`] === expected ||
-      proof.scopedCascadeGraphHashes?.[role] === expected ||
-      proof.graphHashes?.[role] === expected;
+    const shapeKey = change.scopedCascadeGraphShapeKeys?.[role] ?? change.scopedCascadeGraphShapeKey;
+    return proof.scopedCascadeGraphHashesByShapeKey?.[shapeKey] === expected ||
+      proof.graphHashesByShapeKey?.[shapeKey] === expected ||
+      proof.scopedCascadeGraphHashesByRoleAndShape?.[role]?.[shapeKey] === expected ||
+      ((sharedHash === expected || proof[`${role}ScopedCascadeGraphHash`] === expected || proof.scopedCascadeGraphHashes?.[role] === expected || proof.graphHashes?.[role] === expected) && proofShapeMatches(proof, shapeKey));
   });
 }
 
+function proofShapeMatches(proof, shapeKey) {
+  if (!shapeKey) return true;
+  if (proof.scopedCascadeGraphShapeKey === shapeKey || proof.shapeKey === shapeKey) return true;
+  if (proof.scopedCascadeGraphShapeKeys?.includes?.(shapeKey) || proof.shapeKeys?.includes?.(shapeKey)) return true;
+  return !hasProofShapeBinding(proof);
+}
+
+function hasProofShapeBinding(proof) {
+  return Boolean(proof.scopedCascadeGraphShapeKey || proof.shapeKey || proof.scopedCascadeGraphShapeKeys || proof.shapeKeys || proof.scopedCascadeGraphHashesByShapeKey || proof.graphHashesByShapeKey || proof.scopedCascadeGraphHashesByRoleAndShape);
+}
+
 function scopedCascadeProofRecord(proof, change, sourcePath, binding, hash) {
   return {
     id: proof.id,
@@ -112,6 +126,7 @@ function scopedCascadeProofRecord(proof, change, sourcePath, binding, hash) {
     ruleKey: change.ruleKey,
     property: change.property,
     scopes: change.scopes,
+    scopedCascadeGraphShapeKey: change.scopedCascadeGraphShapeKey,
     sourcePath,
     scopedCascadeGraphHash: change.scopedCascadeGraphHash,
     scopedCascadeGraphHashes: change.scopedCascadeGraphHashes,
@@ -124,13 +139,13 @@ function scopedCascadeProofRecord(proof, change, sourcePath, binding, hash) {
 
 function scopedCascadeGraphRoles(change, side) {
   return [
-    change.before?.scopedCascadeGraphHash ? { role: 'base', hash: change.before.scopedCascadeGraphHash } : undefined,
-    change.after?.scopedCascadeGraphHash ? { role: side, hash: change.after.scopedCascadeGraphHash } : undefined
+    change.before?.scopedCascadeGraphHash ? { role: 'base', hash: change.before.scopedCascadeGraphHash, shapeKey: change.before.scopedCascadeGraphShapeKey } : undefined,
+    change.after?.scopedCascadeGraphHash ? { role: side, hash: change.after.scopedCascadeGraphHash, shapeKey: change.after.scopedCascadeGraphShapeKey } : undefined
   ].filter(Boolean);
 }
 
 function scopedCascadeDeclarationDetails(entry) {
-  return entry ? { property: entry.property, value: entry.value, ruleKey: entry.ruleKey, cascadeKey: entry.key, scopes: entry.scopes, scopedCascadeGraphHash: entry.scopedCascadeGraphHash } : undefined;
+  return entry ? { property: entry.property, value: entry.value, ruleKey: entry.ruleKey, cascadeKey: entry.key, scopes: entry.scopes, scopedCascadeGraphShapeKey: entry.scopedCascadeGraphShapeKey, scopedCascadeGraphHash: entry.scopedCascadeGraphHash } : undefined;
 }
 
 function scopedCascadeReasonCodes(scopes = []) {

package/dist/semantic-merge.js

@@ -106,6 +106,7 @@ function declarationIndex(sheet, hash) {
         declarationOrdinal: declaration.ordinal,
         declarationHash: declaration.declarationHash,
         shorthandExpansion: deterministicShorthandExpansion(declaration.property, declaration.value, hash),
+        scopedCascadeGraphShapeKey: record.scopedCascadeGraphShapeKey,
         scopedCascadeGraphHash: record.scopedCascadeGraphHash,
         selectorTargetGraphHash: record.selectorTargetGraphHash,
         proofGaps: proofGapsForDeclaration(record, declaration)
@@ -163,6 +164,7 @@ function mergeParserEvidence(sheets) {
     parserBackedDeclarationSpans: entries.every(([, evidence]) => evidence.parserBackedDeclarationSpans === true),
     parserBackedTriviaHashes: entries.every(([, evidence]) => evidence.parserBackedTriviaHashes === true),
     scopedCascadeGraphHashPresent: entries.every(([, evidence]) => evidence.scopedCascadeGraphHashPresent === true),
+    scopedCascadeGraphShapeHashPresent: entries.every(([, evidence]) => evidence.scopedCascadeGraphShapeHashPresent === true),
     parseErrors: entries.reduce((sum, [, evidence]) => sum + evidence.parseErrors, 0),
     sides: Object.fromEntries(entries)
   };
@@ -178,6 +180,8 @@ function sheetParserEvidence(sheet) {
     parserBackedDeclarationSpans: declarations.some((declaration) => declaration.sourceSpan?.startOffset !== undefined),
     parserBackedTriviaHashes: records.some((record) => record.parser === 'postcss' && typeof record.rawTextHash === 'string'),
     scopedCascadeGraphHashPresent: records.every((record) => !(record.scopes?.length) || Boolean(record.scopedCascadeGraphHash)),
+    scopedCascadeGraphShapeHashPresent: records.every((record) => !(record.scopes?.length) || Boolean(record.scopedCascadeGraphHash && record.scopedCascadeGraphShapeKey)),
+    scopedCascadeGraphShapeKeys: unique(records.filter((record) => record.scopes?.length).map((record) => record.scopedCascadeGraphShapeKey)).length,
     parseErrors: sheet.parser?.parseErrors?.length ?? 0,
     recordCount: records.length,
     declarationCount: declarations.length

package/package.json

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