@shapeshift-labs/frontier-lang-css 0.1.21 → 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

@@ -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, CssDependencyGraphProof, CssDependencyGraphProofRecord } from './dependency-graph.js'; import type { CssModuleContractProof, CssModuleContractProofRecord } from './css-module-contract-proof.js'; import type { CssSafeMergeShorthandExpansionEvidence, CssShorthandExpansionEvidence } from './shorthand-expansion.js'; import type { CssSafeMergeSelectorTargetEvidence, CssSelectorTargetEquivalence, CssSelectorTargetProof } from './selector-target-proof.js'; export type { CssCascadeRuntimeProof, CssCascadeRuntimeProofRecord } from './cascade-runtime-proof.js'; export type { CssDependencyGraphChange, CssDependencyGraphEvidence, CssDependencyGraphProof, CssDependencyGraphProofRecord } from './dependency-graph.js'; export type { CssModuleContractProof, CssModuleContractProofRecord } from './css-module-contract-proof.js'; export type { CssSafeMergeChangedShorthandExpansion, CssSafeMergeShorthandExpansionEvidence, CssSafeMergeShorthandExpansionSideEvidence, CssShorthandExpansionEvidence, CssShorthandLonghandExpansion } from './shorthand-expansion.js'; export type { CssSafeMergeSelectorMove, CssSafeMergeSelectorTargetEvidence, CssSafeMergeSelectorTargetRebaseProof, CssSafeMergeSelectorTargetSideEvidence, CssSelectorTargetEquivalence, CssSelectorTargetProof } from './selector-target-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'; import type { CssModuleContractProof, CssModuleContractProofRecord } from './css-module-contract-proof.js'; import type { CssScopedCascadeProof, CssScopedCascadeProofRecord } from './scoped-cascade-proof.js'; import type { CssSafeMergeShorthandExpansionEvidence, CssShorthandExpansionEvidence } from './shorthand-expansion.js'; import type { CssSafeMergeSelectorTargetEvidence, CssSelectorTargetEquivalence, CssSelectorTargetProof } from './selector-target-proof.js'; export type { CssCascadeRuntimeProof, CssCascadeRuntimeProofRecord } from './cascade-runtime-proof.js'; export type { CssDependencyGraphChange, CssDependencyGraphEvidence, CssDependencyGraphProof, CssDependencyGraphProofRecord } from './dependency-graph.js'; export type { CssModuleContractProof, CssModuleContractProofRecord } from './css-module-contract-proof.js'; export type { CssScopedCascadeProof, CssScopedCascadeProofRecord } from './scoped-cascade-proof.js'; export type { CssSafeMergeChangedShorthandExpansion, CssSafeMergeShorthandExpansionEvidence, CssSafeMergeShorthandExpansionSideEvidence, CssShorthandExpansionEvidence, CssShorthandLonghandExpansion } from './shorthand-expansion.js'; export type { CssSafeMergeSelectorMove, CssSafeMergeSelectorTargetEvidence, CssSafeMergeSelectorTargetRebaseProof, CssSafeMergeSelectorTargetSideEvidence, CssSelectorTargetEquivalence, CssSelectorTargetProof } from './selector-target-proof.js';
 
 export interface CssProjectionOptions {
   readonly banner?: string;
@@ -13,6 +13,16 @@ 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[];
   readonly cssSourceBoundCascadeProof?: CssCascadeRuntimeProof; readonly cssSourceBoundCascadeProofs?: readonly CssCascadeRuntimeProof[];
   readonly selectorTargetGraphHash?: string;
@@ -127,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;
@@ -228,6 +239,7 @@ export interface CssSafeMergeAdmission {
   readonly reviewRequired: boolean; readonly reasonCodes: readonly string[];
   readonly browserCascadeEquivalenceClaim?: true;
   readonly cssCascadeRuntimeProofs?: readonly CssCascadeRuntimeProofRecord[];
+  readonly cssScopedCascadeProofs?: readonly CssScopedCascadeProofRecord[];
   readonly cssDependencyGraphProofs?: readonly CssDependencyGraphProofRecord[];
   readonly cssModuleContractProofs?: readonly CssModuleContractProofRecord[];
 }
@@ -245,6 +257,7 @@ export interface CssSafeMergeResult {
   readonly workerChangedCssModuleContracts?: number; readonly headChangedCssModuleContracts?: number;
   readonly parserEvidence?: CssSafeMergeParserEvidence; readonly shorthandExpansionEvidence?: CssSafeMergeShorthandExpansionEvidence; readonly selectorTargetEvidence?: CssSafeMergeSelectorTargetEvidence; readonly dependencyGraphEvidence?: CssDependencyGraphEvidence;
   readonly cssModuleContractProofs?: readonly CssModuleContractProofRecord[];
+  readonly scopedCascadeProofs?: readonly CssScopedCascadeProofRecord[];
   readonly cascadeRuntimeProofs?: readonly CssCascadeRuntimeProofRecord[];
   readonly dependencyGraphProofs?: readonly CssDependencyGraphProofRecord[];
 }
@@ -252,18 +265,22 @@ 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 {
   readonly id?: string; readonly sourcePath?: string; readonly baseSourceText?: string; readonly workerSourceText?: string; readonly headSourceText?: string;
   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 cssScopedCascadeProof?: CssScopedCascadeProof; readonly cssScopedCascadeProofs?: readonly CssScopedCascadeProof[]; readonly cssScopedCascadeProofsByPath?: Readonly<Record<string, CssScopedCascadeProof | readonly CssScopedCascadeProof[]>>;
+  readonly cssSourceBoundScopedCascadeProof?: CssScopedCascadeProof; readonly cssSourceBoundScopedCascadeProofs?: readonly CssScopedCascadeProof[]; readonly cssSourceBoundScopedCascadeProofsByPath?: Readonly<Record<string, CssScopedCascadeProof | readonly CssScopedCascadeProof[]>>;
+  readonly scopedCascadeProof?: CssScopedCascadeProof; readonly scopedCascadeProofs?: readonly CssScopedCascadeProof[]; readonly scopedCascadeProofsByPath?: Readonly<Record<string, CssScopedCascadeProof | readonly CssScopedCascadeProof[]>>;
+  readonly sourceBoundScopedCascadeProof?: CssScopedCascadeProof; readonly sourceBoundScopedCascadeProofs?: readonly CssScopedCascadeProof[]; readonly sourceBoundScopedCascadeProofsByPath?: Readonly<Record<string, CssScopedCascadeProof | readonly CssScopedCascadeProof[]>>;
   readonly cssCascadeRuntimeProof?: CssCascadeRuntimeProof; readonly cssCascadeRuntimeProofs?: readonly CssCascadeRuntimeProof[]; readonly cssCascadeRuntimeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;
   readonly cssSourceBoundCascadeProof?: CssCascadeRuntimeProof; readonly cssSourceBoundCascadeProofs?: readonly CssCascadeRuntimeProof[];
   readonly cssSourceBoundCascadeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;

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

@@ -0,0 +1,61 @@
+export interface CssScopedCascadeProof {
+  readonly id?: string;
+  readonly kind: 'css-scoped-cascade-proof' | 'css-source-bound-scoped-cascade-proof' | 'css-scoped-cascade-runtime-proof' | 'css-source-bound-scoped-cascade-runtime-proof' | string;
+  readonly status: 'passed' | string;
+  readonly proofLevel?: string;
+  readonly sourcePath?: string;
+  readonly reasonCode?: string;
+  readonly reasonCodes?: readonly string[];
+  readonly side?: 'worker' | 'head' | string;
+  readonly sides?: readonly string[];
+  readonly cascadeKey?: string;
+  readonly cascadeKeys?: readonly string[];
+  readonly ruleKey?: string;
+  readonly ruleKeys?: readonly string[];
+  readonly selectors?: readonly string[];
+  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;
+  readonly workerScopedCascadeGraphHash?: string;
+  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>>;
+  readonly sources?: Readonly<Record<string, string>>;
+  readonly sourceHashes?: Readonly<Record<string, string>>;
+  readonly hashes?: Readonly<Record<string, string>>;
+}
+
+export interface CssScopedCascadeProofRecord {
+  readonly id?: string;
+  readonly kind: string;
+  readonly status: 'passed';
+  readonly proofLevel: string;
+  readonly reasonCode: string;
+  readonly side: string;
+  readonly cascadeKey: string;
+  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;
+  readonly outputSourceHash?: 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

@@ -0,0 +1,182 @@
+function scopedCascadeChanges(changed, indexes) {
+  return [
+    ...scopedCascadeChangesForSide(changed.worker, 'worker', indexes.base),
+    ...scopedCascadeChangesForSide(changed.head, 'head', indexes.base)
+  ];
+}
+
+function scopedCascadeChangesForSide(changes, side, baseIndex) {
+  const baseScopeKeys = new Set([...baseIndex.declarations.values()]
+    .filter((entry) => entry.scopes?.length)
+    .map((entry) => scopeListKey(entry.scopes)));
+  return changes.flatMap((change) => {
+    const entries = [change.before, change.after].filter((entry) => entry?.scopes?.length);
+    if (!entries.length || !entries.some((entry) => baseScopeKeys.has(scopeListKey(entry.scopes)))) return [];
+    const entry = change.after ?? change.before;
+    const graphRoles = scopedCascadeGraphRoles(change, side);
+    return [{
+      side,
+      changeKind: change.kind,
+      reasonCode: 'css-scoped-cascade-equivalence-unproved',
+      reasonCodes: unique(['css-scoped-cascade-equivalence-unproved', ...entries.flatMap((item) => scopedCascadeReasonCodes(item.scopes))]),
+      cascadeKey: change.key,
+      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)
+    }];
+  });
+}
+
+function admitScopedCascadeProofs({ id, sourcePath, input, changes, binding, hash }) {
+  const proofs = scopedCascadeProofCandidates(input, sourcePath);
+  const admitted = [];
+  const conflicts = [];
+  for (const change of changes) {
+    const proof = proofs.find((candidate) => isScopedCascadeProofForChange(candidate, change, sourcePath, binding, hash));
+    if (proof) admitted.push(scopedCascadeProofRecord(proof, change, sourcePath, binding, hash));
+    else conflicts.push(conflict(id, sourcePath, 'css-scoped-cascade-proof-blocked', change.reasonCode, change));
+  }
+  return { proofs: admitted, conflicts };
+}
+
+function scopedCascadeProofCandidates(input = {}, sourcePath) {
+  return [
+    input.cssScopedCascadeProof,
+    input.cssScopedCascadeProofs,
+    input.cssScopedCascadeProofsByPath?.[sourcePath],
+    input.cssSourceBoundScopedCascadeProof,
+    input.cssSourceBoundScopedCascadeProofs,
+    input.cssSourceBoundScopedCascadeProofsByPath?.[sourcePath],
+    input.scopedCascadeProof,
+    input.scopedCascadeProofs,
+    input.scopedCascadeProofsByPath?.[sourcePath],
+    input.sourceBoundScopedCascadeProof,
+    input.sourceBoundScopedCascadeProofs,
+    input.sourceBoundScopedCascadeProofsByPath?.[sourcePath]
+  ].flatMap(asArray).filter(Boolean);
+}
+
+function isScopedCascadeProofForChange(proof, change, sourcePath, binding, hash) {
+  return Boolean(proof && typeof proof === 'object') &&
+    ScopedCascadeProofKinds.has(proof.kind) &&
+    proof.status === 'passed' &&
+    proof.sourcePath === sourcePath &&
+    change.scopedCascadeGraphReady === true &&
+    proofCoversAny(proof.reasonCode, proof.reasonCodes, change.reasonCodes) &&
+    proofCoversValue(proof.side, proof.sides, change.side) &&
+    proofCoversValue(proof.cascadeKey, proof.cascadeKeys, change.cascadeKey) &&
+    proofCoversValue(proof.property, proof.properties, change.property) &&
+    scopedCascadeRuleMatches(proof, change) &&
+    scopedCascadeGraphHashMatches(proof, change) &&
+    proofSourceMatches(proof, 'base', binding.base, hash) &&
+    proofSourceMatches(proof, 'worker', binding.worker, hash) &&
+    proofSourceMatches(proof, 'head', binding.head, hash) &&
+    proofSourceMatches(proof, 'output', binding.output, hash);
+}
+
+function scopedCascadeRuleMatches(proof, change) {
+  const ruleKeyMatches = proof.ruleKey === change.ruleKey || proof.ruleKeys?.includes(change.ruleKey);
+  const selectorsMatch = selectorListKey(proof.selectors) === selectorListKey(change.selectors);
+  const scopesMatch = scopeListKey(proof.scopes) === scopeListKey(change.scopes);
+  return ruleKeyMatches || (selectorsMatch && scopesMatch);
+}
+
+function scopedCascadeGraphHashMatches(proof, change) {
+  const hashes = Object.entries(change.scopedCascadeGraphHashes ?? {});
+  if (!hashes.length) return false;
+  return hashes.every(([role, expected]) => {
+    const sharedHash = firstString(proof.scopedCascadeGraphHash, proof.graphHash);
+    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,
+    kind: proof.kind,
+    status: 'passed',
+    proofLevel: proof.proofLevel ?? 'css-scoped-cascade-source-bound',
+    reasonCode: change.reasonCode,
+    side: change.side,
+    cascadeKey: change.cascadeKey,
+    ruleKey: change.ruleKey,
+    property: change.property,
+    scopes: change.scopes,
+    scopedCascadeGraphShapeKey: change.scopedCascadeGraphShapeKey,
+    sourcePath,
+    scopedCascadeGraphHash: change.scopedCascadeGraphHash,
+    scopedCascadeGraphHashes: change.scopedCascadeGraphHashes,
+    baseSourceHash: hash?.(binding.base),
+    workerSourceHash: hash?.(binding.worker),
+    headSourceHash: hash?.(binding.head),
+    outputSourceHash: hash?.(binding.output)
+  };
+}
+
+function scopedCascadeGraphRoles(change, side) {
+  return [
+    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, scopedCascadeGraphShapeKey: entry.scopedCascadeGraphShapeKey, scopedCascadeGraphHash: entry.scopedCascadeGraphHash } : undefined;
+}
+
+function scopedCascadeReasonCodes(scopes = []) {
+  return scopes.map((scope) => /^@([-\w]+)/.exec(scope)?.[1]).filter(Boolean).map((name) => `css-${name}-cascade-scope-unproved`);
+}
+
+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 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 proofCoversAny(value, values, expectedValues = []) { return expectedValues.some((expected) => proofCoversValue(value, values, expected)); }
+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]; }
+function selectorListKey(value = []) { return Array.isArray(value) ? value.join(',') : undefined; }
+function scopeListKey(value = []) { return Array.isArray(value) ? value.join('::') : undefined; }
+function firstString(...values) { return values.find((value) => typeof value === 'string' && value.length > 0); }
+function unique(values) { return [...new Set(values.filter(Boolean))]; }
+
+const ScopedCascadeProofKinds = new Set(['css-scoped-cascade-proof', 'css-source-bound-scoped-cascade-proof', 'css-scoped-cascade-runtime-proof', 'css-source-bound-scoped-cascade-runtime-proof']);
+const ScopedCascadeProofGapCodes = new Set(['css-scoped-cascade-equivalence-unproved', 'css-media-cascade-scope-unproved', 'css-supports-cascade-scope-unproved', 'css-container-cascade-scope-unproved', 'css-layer-cascade-scope-unproved', 'css-scope-cascade-scope-unproved']);
+
+export { ScopedCascadeProofGapCodes, admitScopedCascadeProofs, scopedCascadeChanges };

package/dist/semantic-merge.js

@@ -1,6 +1,7 @@
 import { cssModuleContractChanges, sheetOptions, unsupportedSourceShapeChanges } from './semantic-merge-css-modules.js';
 import { admitCssModuleContractProofs } from './semantic-merge-css-module-proofs.js';
 import { admitCascadeRuntimeProofs } from './semantic-merge-cascade-runtime.js';
+import { ScopedCascadeProofGapCodes, admitScopedCascadeProofs, scopedCascadeChanges } from './semantic-merge-scoped-cascade.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';
@@ -47,20 +48,15 @@ function safeMergeCssSource(input = {}, context = {}) {
   const dependencyGraphEvidence = mergeCssDependencyGraphEvidence(sheets, changed);
   const selectorTargetPlan = planSelectorTargetRebase(id, sourcePath, mergeSelectorTargetEvidence(sheets, changed), changed, { ...input, sourceBinding: { base, worker, head }, hashSemanticValue: hash });
   const shapeChanges = unsupportedSourceShapeChanges(sheets, changed, hash);
+  const scopedChanges = scopedCascadeChanges(selectorTargetPlan.changed, indexes);
   const mergedIndex = applyAtRuleBlockChanges(applyAtRuleBlockChanges(applyDeclarationChanges(applyDeclarationChanges(indexes.base, selectorTargetPlan.changed.head), selectorTargetPlan.changed.worker), blockChanges.head), blockChanges.worker);
   const mergedSourceText = renderDeclarationIndex(mergedIndex);
-  const cascadeRuntimeAdmission = admitCascadeRuntimeProofs({
-    id,
-    sourcePath,
-    input,
-    sourceShapeChanges: shapeChanges,
-    binding: { base, worker, head, output: mergedSourceText },
-    hash
-  });
+  const scopedCascadeAdmission = admitScopedCascadeProofs({ id, sourcePath, input, changes: scopedChanges, binding: { base, worker, head, output: mergedSourceText }, hash });
+  const cascadeRuntimeAdmission = admitCascadeRuntimeProofs({ id, sourcePath, input, sourceShapeChanges: shapeChanges, binding: { base, worker, head, output: mergedSourceText }, hash });
   const dependencyGraphAdmission = admitCssDependencyGraphProofs({ id, sourcePath, input, dependencyGraphEvidence, binding: { base, worker, head, output: mergedSourceText }, hash });
   const cssModuleAdmission = admitCssModuleContractProofs({ id, sourcePath, input, moduleChanges, binding: { base, worker, head, output: mergedSourceText }, hash });
-  const conflicts = [...parserConflicts, ...duplicateCascadeKeyConflicts, ...proofConflicts, ...overlapConflicts, ...cssModuleAdmission.conflicts, ...cascadeRuntimeAdmission.conflicts, ...dependencyGraphAdmission.conflicts, ...selectorTargetPlan.conflicts];
-  if (conflicts.length) return blocked(id, sourcePath, 'css-semantic-merge-conflict', conflicts, { parserEvidence, shorthandExpansionEvidence, dependencyGraphEvidence, selectorTargetEvidence: selectorTargetPlan.evidence, cssModuleContractProofs: cssModuleAdmission.proofs, cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs, dependencyGraphProofs: dependencyGraphAdmission.proofs, ...blockedMergeCandidate(input, mergedSourceText, hash) });
+  const conflicts = [...parserConflicts, ...duplicateCascadeKeyConflicts, ...proofConflicts, ...overlapConflicts, ...cssModuleAdmission.conflicts, ...scopedCascadeAdmission.conflicts, ...cascadeRuntimeAdmission.conflicts, ...dependencyGraphAdmission.conflicts, ...selectorTargetPlan.conflicts];
+  if (conflicts.length) return blocked(id, sourcePath, 'css-semantic-merge-conflict', conflicts, { parserEvidence, shorthandExpansionEvidence, dependencyGraphEvidence, selectorTargetEvidence: selectorTargetPlan.evidence, cssModuleContractProofs: cssModuleAdmission.proofs, scopedCascadeProofs: scopedCascadeAdmission.proofs, cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs, dependencyGraphProofs: dependencyGraphAdmission.proofs, ...blockedMergeCandidate(input, mergedSourceText, hash) });
   return merged(id, sourcePath, mergedSourceText, 'semantic-declaration-merge', hash, {
     baseSheetHash: sheets.base.sheetHash,
     workerSheetHash: sheets.worker.sheetHash,
@@ -74,6 +70,7 @@ function safeMergeCssSource(input = {}, context = {}) {
     dependencyGraphEvidence,
     selectorTargetEvidence: selectorTargetPlan.evidence,
     cssModuleContractProofs: cssModuleAdmission.proofs,
+    scopedCascadeProofs: scopedCascadeAdmission.proofs,
     cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs,
     dependencyGraphProofs: dependencyGraphAdmission.proofs,
     browserCascadeEquivalenceClaim: cascadeRuntimeAdmission.proofs.length > 0
@@ -109,6 +106,8 @@ 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)
       };
@@ -165,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)
   };
@@ -180,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
@@ -209,6 +211,7 @@ function shorthandOverlapConflicts(id, sourcePath, workerChanges, headChanges) {
 }
 
 function canAdmitProofGap(gap, entry, changed, indexes) {
+  if (ScopedCascadeProofGapCodes.has(gap.code)) return true;
   if (gap.code !== 'css-shorthand-expansion-unproved' || !entry) return false;
   const group = shorthandGroupForProperty(entry.property);
   if (!group || entry.shorthandExpansion?.status !== 'expanded' || hasRelatedExistingDeclaration(entry, indexes)) return false;
@@ -296,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, cssDependencyGraphProofs: body.dependencyGraphProofs?.length ? body.dependencyGraphProofs : undefined, cssModuleContractProofs: body.cssModuleContractProofs?.length ? body.cssModuleContractProofs : undefined
+      cssCascadeRuntimeProofs: body.cascadeRuntimeProofs?.length ? body.cascadeRuntimeProofs : undefined, cssScopedCascadeProofs: body.scopedCascadeProofs?.length ? body.scopedCascadeProofs : undefined, cssDependencyGraphProofs: body.dependencyGraphProofs?.length ? body.dependencyGraphProofs : undefined, cssModuleContractProofs: body.cssModuleContractProofs?.length ? body.cssModuleContractProofs : undefined
     }
   };
 }

package/package.json

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