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

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'; 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';
+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,8 @@ export interface CssProjectionOptions {
   readonly cssModuleCompositionGraphHash?: string;
   readonly icssGraphHash?: string;
   readonly scopedCascadeGraphHash?: 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;
@@ -228,6 +230,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 +248,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[];
 }
@@ -260,37 +264,14 @@ export interface CssSafeMergeParserSideEvidence {
   readonly scopedCascadeGraphHashPresent: boolean; readonly parseErrors: number; readonly recordCount: number; readonly declarationCount: number;
 }
 
-export interface CssSafeMergeSelectorTargetEvidence {
-  readonly kind: 'frontier.lang.cssSafeMergeSelectorTargetEvidence'; readonly version: 1; readonly selectorTargetGraphHashPresent: boolean; readonly parserBackedRuleSpans: boolean;
-  readonly selectorMoveCount: number; readonly workerSelectorMoves: number; readonly headSelectorMoves: number;
-  readonly sides: Readonly<Record<string, CssSafeMergeSelectorTargetSideEvidence>>;
-  readonly moves: Readonly<Record<'worker' | 'head', readonly CssSafeMergeSelectorMove[]>>;
-  readonly rebasedChangeCount?: number; readonly rebaseProofs?: readonly CssSafeMergeSelectorTargetRebaseProof[];
-}
-
-export interface CssSafeMergeSelectorTargetSideEvidence {
-  readonly ruleCount: number; readonly selectorCount: number; readonly declarationCount: number; readonly scopedRuleCount: number;
-  readonly selectorTargetGraphHashPresent: boolean; readonly parserBackedRuleSpans: boolean; readonly selectorSpecificityRecords: number;
-}
-
-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 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 selectorTargetGraphHash?: string; readonly specificityInvariant: true; readonly beforeSpecificity?: readonly (readonly number[])[]; readonly afterSpecificity?: readonly (readonly number[])[];
-}
-
-export interface CssSelectorTargetEquivalence {
-  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 {
   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[]>>;
@@ -301,6 +282,11 @@ export interface CssSafeMergeInput {
   readonly cssDependencyGraphProofsByPath?: Readonly<Record<string, CssDependencyGraphProof | readonly CssDependencyGraphProof[]>>; readonly cssSourceBoundDependencyGraphProofsByPath?: Readonly<Record<string, CssDependencyGraphProof | readonly CssDependencyGraphProof[]>>;
   readonly cssModuleContractProof?: CssModuleContractProof; readonly cssModuleContractProofs?: readonly CssModuleContractProof[]; readonly cssModuleContractProofsByPath?: Readonly<Record<string, CssModuleContractProof | readonly CssModuleContractProof[]>>; readonly cssSourceBoundModuleContractProof?: CssModuleContractProof; readonly cssSourceBoundModuleContractProofs?: readonly CssModuleContractProof[]; readonly cssSourceBoundModuleContractProofsByPath?: Readonly<Record<string, CssModuleContractProof | readonly CssModuleContractProof[]>>;
   readonly selectorTargetGraphHash?: string; readonly selectorTargetEquivalences?: readonly CssSelectorTargetEquivalence[];
+  readonly cssSelectorTargetProof?: CssSelectorTargetProof; readonly cssSelectorTargetProofs?: readonly CssSelectorTargetProof[]; readonly cssSelectorTargetProofsByPath?: Readonly<Record<string, CssSelectorTargetProof | readonly CssSelectorTargetProof[]>>;
+  readonly cssSourceBoundSelectorTargetProof?: CssSelectorTargetProof; readonly cssSourceBoundSelectorTargetProofs?: readonly CssSelectorTargetProof[]; readonly cssSourceBoundSelectorTargetProofsByPath?: Readonly<Record<string, CssSelectorTargetProof | readonly CssSelectorTargetProof[]>>;
+  readonly selectorTargetProof?: CssSelectorTargetProof; readonly selectorTargetProofs?: readonly CssSelectorTargetProof[]; readonly selectorTargetProofsByPath?: Readonly<Record<string, CssSelectorTargetProof | readonly CssSelectorTargetProof[]>>;
+  readonly selectorTargetRebaseProof?: CssSelectorTargetProof; readonly selectorTargetRebaseProofs?: readonly CssSelectorTargetProof[]; readonly selectorTargetRebaseProofsByPath?: Readonly<Record<string, CssSelectorTargetProof | readonly CssSelectorTargetProof[]>>;
+  readonly sourceBoundSelectorTargetProof?: CssSelectorTargetProof; readonly sourceBoundSelectorTargetProofs?: readonly CssSelectorTargetProof[]; readonly sourceBoundSelectorTargetProofsByPath?: Readonly<Record<string, CssSelectorTargetProof | readonly CssSelectorTargetProof[]>>;
   readonly baseGeneratedClassNameMap?: Readonly<Record<string, string>>; readonly workerGeneratedClassNameMap?: Readonly<Record<string, string>>; readonly headGeneratedClassNameMap?: Readonly<Record<string, string>>;
   readonly baseGeneratedClassNameMapHash?: string; readonly workerGeneratedClassNameMapHash?: string; readonly headGeneratedClassNameMapHash?: string;
   readonly baseJsTsUseSiteGraphHash?: string; readonly workerJsTsUseSiteGraphHash?: string; readonly headJsTsUseSiteGraphHash?: string;

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

@@ -0,0 +1,52 @@
+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 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 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 sourcePath?: string;
+  readonly scopedCascadeGraphHash?: string;
+  readonly scopedCascadeGraphHashes?: Readonly<Record<string, string>>;
+  readonly baseSourceHash?: string;
+  readonly workerSourceHash?: string;
+  readonly headSourceHash?: string;
+  readonly outputSourceHash?: string;
+}

package/dist/selector-target-proof.d.ts

@@ -0,0 +1,46 @@
+export interface CssSelectorTargetProof {
+  readonly id?: string; readonly kind: 'css-selector-target-proof' | 'css-source-bound-selector-target-proof' | 'css-selector-target-rebase-proof' | 'css-source-bound-selector-target-rebase-proof' | string;
+  readonly status: 'passed' | string; readonly proofLevel?: string; readonly sourcePath?: string; readonly reasonCode?: string; readonly reasonCodes?: readonly string[];
+  readonly side?: string; readonly sides?: readonly string[]; readonly moveSide?: string; readonly moveSides?: readonly string[]; readonly selectorMoveSide?: string; readonly selectorMoveSides?: readonly string[];
+  readonly rebasedSide?: string; readonly rebasedSides?: readonly 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 selectorTargetGraphHash?: string; readonly graphHash?: string; readonly beforeSelectorTargetGraphHash?: string; readonly afterSelectorTargetGraphHash?: string;
+  readonly selectorTargetGraphHashes?: Readonly<Record<string, string>>; readonly graphHashes?: Readonly<Record<string, string>>;
+  readonly baseSelectorTargetGraphHash?: string; readonly workerSelectorTargetGraphHash?: string; readonly headSelectorTargetGraphHash?: string;
+  readonly baseSourceText?: string; readonly workerSourceText?: string; readonly headSourceText?: string;
+  readonly baseSourceHash?: string; readonly workerSourceHash?: string; readonly headSourceHash?: string;
+  readonly sourceTexts?: Readonly<Record<string, string>>; readonly sourceHashes?: Readonly<Record<string, string>>;
+  readonly sources?: Readonly<Record<string, string>>; readonly hashes?: Readonly<Record<string, string>>;
+}
+
+export interface CssSafeMergeSelectorTargetEvidence {
+  readonly kind: 'frontier.lang.cssSafeMergeSelectorTargetEvidence'; readonly version: 1; readonly selectorTargetGraphHashPresent: boolean; readonly parserBackedRuleSpans: boolean;
+  readonly selectorMoveCount: number; readonly workerSelectorMoves: number; readonly headSelectorMoves: number;
+  readonly sides: Readonly<Record<string, CssSafeMergeSelectorTargetSideEvidence>>;
+  readonly moves: Readonly<Record<'worker' | 'head', readonly CssSafeMergeSelectorMove[]>>;
+  readonly rebasedChangeCount?: number; readonly rebaseProofs?: readonly CssSafeMergeSelectorTargetRebaseProof[];
+}
+
+export interface CssSafeMergeSelectorTargetSideEvidence {
+  readonly ruleCount: number; readonly selectorCount: number; readonly declarationCount: number; readonly scopedRuleCount: number;
+  readonly selectorTargetGraphHashPresent: boolean; readonly parserBackedRuleSpans: boolean; readonly selectorSpecificityRecords: number;
+}
+
+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 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 id?: string; readonly kind: 'css-selector-target-rebase'; readonly proofKind?: string; readonly status?: 'passed' | string; readonly proofLevel?: string;
+  readonly side: string; readonly moveSide?: string; readonly fromRuleKey: string; readonly toRuleKey: string; readonly fromSelectors?: readonly string[]; readonly toSelectors?: readonly string[];
+  readonly property: string; readonly cascadeKey: string; readonly selectorTargetGraphHash?: string; readonly beforeSelectorTargetGraphHash?: string; readonly afterSelectorTargetGraphHash?: string;
+  readonly specificityInvariant: true; readonly beforeSpecificity?: readonly (readonly number[])[]; readonly afterSpecificity?: readonly (readonly number[])[];
+  readonly baseSourceHash?: string; readonly workerSourceHash?: string; readonly headSourceHash?: string;
+}
+
+export interface CssSelectorTargetEquivalence {
+  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;
+}

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

@@ -0,0 +1,167 @@
+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,
+      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')),
+      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);
+    return sharedHash === expected ||
+      proof[`${role}ScopedCascadeGraphHash`] === expected ||
+      proof.scopedCascadeGraphHashes?.[role] === expected ||
+      proof.graphHashes?.[role] === expected;
+  });
+}
+
+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,
+    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 } : undefined,
+    change.after?.scopedCascadeGraphHash ? { role: side, hash: change.after.scopedCascadeGraphHash } : 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;
+}
+
+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-selector-targets.js

@@ -76,8 +76,9 @@ 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, sourcePath)) {
-        const rebased = rebaseChangeToSelectorMove(change, move);
+      const proof = selectorTargetRebaseProofForChange(move, change, options, sourcePath);
+      if (proof) {
+        const rebased = rebaseChangeToSelectorMove(change, move, proof, options);
         oppositeChanges[index] = rebased.change;
         rebaseProofs.push(rebased.proof);
       } else conflicts.push(conflict(id, sourcePath, change.key, move, change));
@@ -86,27 +87,113 @@ function selectorTargetMoveSidePlan(id, sourcePath, moves, oppositeMoves, opposi
   return { conflicts, rebaseProofs };
 }
 
-function canRebaseChange(move, change, options, sourcePath) {
-  return change.kind === 'add' && change.after && hasSelectorTargetEquivalence(move, options, sourcePath);
+function selectorTargetRebaseProofForChange(move, change, options, sourcePath) {
+  if (change.kind !== 'add' || !change.after || !move.specificityInvariant) return undefined;
+  return selectorTargetProofCandidates(options, sourcePath)
+    .find((proof) => isSelectorTargetProofForChange(proof, move, change, sourcePath, 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 = 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);
-  });
+function selectorTargetProofCandidates(input = {}, sourcePath) {
+  return [
+    input.cssSelectorTargetProof,
+    input.cssSelectorTargetProofs,
+    input.cssSelectorTargetProofsByPath?.[sourcePath],
+    input.cssSourceBoundSelectorTargetProof,
+    input.cssSourceBoundSelectorTargetProofs,
+    input.cssSourceBoundSelectorTargetProofsByPath?.[sourcePath],
+    input.selectorTargetProof,
+    input.selectorTargetProofs,
+    input.selectorTargetProofsByPath?.[sourcePath],
+    input.selectorTargetRebaseProof,
+    input.selectorTargetRebaseProofs,
+    input.selectorTargetRebaseProofsByPath?.[sourcePath],
+    input.sourceBoundSelectorTargetProof,
+    input.sourceBoundSelectorTargetProofs,
+    input.sourceBoundSelectorTargetProofsByPath?.[sourcePath]
+  ].flatMap(asArray).filter(Boolean);
 }
 
-function rebaseChangeToSelectorMove(change, move) {
+function isSelectorTargetProofForChange(proof, move, change, sourcePath, options) {
+  const hash = options.hashSemanticValue;
+  const binding = options.sourceBinding ?? {};
+  return Boolean(proof && typeof proof === 'object') &&
+    SelectorTargetProofKinds.has(proof.kind) &&
+    proof.status === 'passed' &&
+    proof.sourcePath === sourcePath &&
+    proofCoversValue(proof.reasonCode, proof.reasonCodes, 'css-selector-target-rebase-unproved') &&
+    proofCoversValue(proof.moveSide ?? proof.selectorMoveSide, proof.moveSides ?? proof.selectorMoveSides ?? proof.sides, move.side) &&
+    proofCoversValue(proof.rebasedSide ?? proof.side, proof.rebasedSides, change.side) &&
+    selectorTargetRuleOrSelectorMatches(proof, move) &&
+    selectorTargetSpecificityMatches(proof, move) &&
+    selectorTargetGraphHashMatches(proof, move) &&
+    proofSourceMatches(proof, 'base', binding.base, hash) &&
+    proofSourceMatches(proof, 'worker', binding.worker, hash) &&
+    proofSourceMatches(proof, 'head', binding.head, hash);
+}
+
+function selectorTargetRuleOrSelectorMatches(proof, move) {
+  const ruleKeysMatch = proof.fromRuleKey === move.beforeRuleKey && proof.toRuleKey === move.afterRuleKey;
+  const selectorsMatch = selectorListKey(proof.fromSelectors) === selectorListKey(move.beforeSelectors) && selectorListKey(proof.toSelectors) === selectorListKey(move.afterSelectors);
+  return ruleKeysMatch || selectorsMatch;
+}
+
+function selectorTargetSpecificityMatches(proof, move) {
+  return move.specificityInvariant === true &&
+    specificityListKey(proof.fromSpecificity) === specificityListKey(move.beforeSpecificity) &&
+    specificityListKey(proof.toSpecificity) === specificityListKey(move.afterSpecificity);
+}
+
+function selectorTargetGraphHashMatches(proof, move) {
+  const beforeHash = move.beforeSelectorTargetGraphHash;
+  const afterHash = move.afterSelectorTargetGraphHash;
+  if (!beforeHash || !afterHash) return false;
+  const sharedHash = firstString(proof.selectorTargetGraphHash, proof.graphHash);
+  if (sharedHash && sharedHash === beforeHash && sharedHash === afterHash) return true;
+  return (proof.beforeSelectorTargetGraphHash === beforeHash && proof.afterSelectorTargetGraphHash === afterHash) ||
+    (proof.selectorTargetGraphHashes?.before === beforeHash && proof.selectorTargetGraphHashes?.after === afterHash) ||
+    (proof.graphHashes?.before === beforeHash && proof.graphHashes?.after === afterHash) ||
+    (proof.baseSelectorTargetGraphHash === beforeHash && proof[`${move.side}SelectorTargetGraphHash`] === afterHash);
+}
+
+function proofSourceMatches(proof, role, sourceText, hash) {
+  if (typeof sourceText !== 'string') return false;
+  const sourceHash = hash?.(sourceText);
+  return proof[`${role}SourceText`] === sourceText ||
+    proof.sourceTexts?.[role] === sourceText ||
+    proof.sources?.[role] === sourceText ||
+    (sourceHash !== undefined && proof[`${role}SourceHash`] === sourceHash) ||
+    (sourceHash !== undefined && proof.sourceHashes?.[role] === sourceHash) ||
+    (sourceHash !== undefined && proof.hashes?.[role] === sourceHash);
+}
+
+function rebaseChangeToSelectorMove(change, move, proof, options) {
   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, selectorTargetGraphHash: move.afterSelectorTargetGraphHash, specificityInvariant: true, beforeSpecificity: move.beforeSpecificity, afterSpecificity: move.afterSpecificity }
+    proof: {
+      id: proof.id,
+      kind: 'css-selector-target-rebase',
+      proofKind: proof.kind,
+      status: 'passed',
+      proofLevel: proof.proofLevel ?? 'css-selector-target-source-bound',
+      side: change.side,
+      moveSide: move.side,
+      fromRuleKey: move.beforeRuleKey,
+      toRuleKey: move.afterRuleKey,
+      fromSelectors: move.beforeSelectors,
+      toSelectors: move.afterSelectors,
+      property: change.after.property,
+      cascadeKey: after.key,
+      selectorTargetGraphHash: move.afterSelectorTargetGraphHash,
+      beforeSelectorTargetGraphHash: move.beforeSelectorTargetGraphHash,
+      afterSelectorTargetGraphHash: move.afterSelectorTargetGraphHash,
+      specificityInvariant: true,
+      beforeSpecificity: move.beforeSpecificity,
+      afterSpecificity: move.afterSpecificity,
+      baseSourceHash: options.hashSemanticValue?.(options.sourceBinding?.base),
+      workerSourceHash: options.hashSemanticValue?.(options.sourceBinding?.worker),
+      headSourceHash: options.hashSemanticValue?.(options.sourceBinding?.head)
+    }
   };
 }
 
@@ -142,5 +229,10 @@ function cascadeKey(scopes = [], selectors = [], property) { return [...scopes,
 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 }; }
+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 firstString(...values) { return values.find((value) => typeof value === 'string' && value.length > 0); }
+
+const SelectorTargetProofKinds = new Set(['css-selector-target-proof', 'css-source-bound-selector-target-proof', 'css-selector-target-rebase-proof', 'css-source-bound-selector-target-rebase-proof']);
 
 export { mergeSelectorTargetEvidence, planSelectorTargetRebase };

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';
@@ -45,22 +46,17 @@ function safeMergeCssSource(input = {}, context = {}) {
   const parserEvidence = mergeParserEvidence(sheets);
   const shorthandExpansionEvidence = mergeShorthandExpansionEvidence(indexes, changed);
   const dependencyGraphEvidence = mergeCssDependencyGraphEvidence(sheets, changed);
-  const selectorTargetPlan = planSelectorTargetRebase(id, sourcePath, mergeSelectorTargetEvidence(sheets, changed), changed, input);
+  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,7 @@ function declarationIndex(sheet, hash) {
         declarationOrdinal: declaration.ordinal,
         declarationHash: declaration.declarationHash,
         shorthandExpansion: deterministicShorthandExpansion(declaration.property, declaration.value, hash),
+        scopedCascadeGraphHash: record.scopedCascadeGraphHash,
         selectorTargetGraphHash: record.selectorTargetGraphHash,
         proofGaps: proofGapsForDeclaration(record, declaration)
       };
@@ -209,6 +207,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 +295,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.20",
+  "version": "0.1.22",
   "description": "CSS semantic merge evidence and projection adapter for Frontier Lang semantic source documents.",
   "type": "module",
   "main": "./dist/index.js",