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

package/README.md

@@ -232,11 +232,11 @@ const merge = safeMergeCssSource({
 });
 ```
 
-`sourceMap.mappings` links emitted rule blocks back to Frontier Lang semantic node ids. `createCssSemanticMergeEvidence` records selectors, specificity, declarations, custom properties, `var()` fallback references, animation/keyframe links, font-face links, URL asset references, cascade keys, statement-form at-rules, block-form runtime at-rules, CSS Modules exports, ICSS edges, scoped cascade graph proof hashes, source spans, stable hashes, and fail-closed proof gaps for cascade/render-sensitive CSS surfaces. `safeMergeCssSource` admits independent declaration edits by cascade key, including existing scoped `@media` / `@supports` / `@container` / `@layer` declarations when a scoped cascade graph proof hash is supplied, carries source-bound dependency graph evidence into the merge result, blocks 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, 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.
 
 ## 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, non-overlapping shorthand expansion sets, and no changed dependency graph surface; unchanged statement-form at-rules and unchanged block-form runtime at-rules preserved in canonical output; existing scoped declaration edits when scoped cascade graph proof is supplied; dependency-affecting declaration edits only when an exact source-bound dependency graph proof is supplied; selector-target rebases only when a matching selector target graph hash is supplied and before/after selector specificity is identical; source-shape/cascade-sensitive edits only when an exact source-bound cascade runtime proof is supplied; explicit CSS Modules export additions/deletions when generated class-name and JS/TS use-site graph proof is supplied; composition edits when composition graph proof is supplied; ICSS edits when ICSS graph proof is supplied. Output is a canonical CSS render and not a byte/trivia-preserving claim.
-- Review-only gaps: incomplete generated class-name maps, unproved dependency graph changes, unproved CSS Modules use-site graphs, unproved composition or ICSS graphs, shorthand value expansion/equivalence beyond known affected-property overlap checks, statement-form at-rule order/condition changes, one-sided or structurally changed scoped cascade under `@media` / `@supports` / `@container` / `@layer`, changed runtime blocks such as `@keyframes`, `@font-face`, `@page`, and `@property`, browser layout and render equivalence.
+- 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.
 - 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'; export type { CssCascadeRuntimeProof, CssCascadeRuntimeProofRecord } from './cascade-runtime-proof.js'; export type { CssDependencyGraphChange, CssDependencyGraphEvidence, CssDependencyGraphProof, CssDependencyGraphProofRecord } from './dependency-graph.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 { 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 { CssSafeMergeChangedShorthandExpansion, CssSafeMergeShorthandExpansionEvidence, CssSafeMergeShorthandExpansionSideEvidence, CssShorthandExpansionEvidence, CssShorthandLonghandExpansion } from './shorthand-expansion.js';
 
 export interface CssProjectionOptions {
   readonly banner?: string;
@@ -111,6 +111,7 @@ export interface CssSemanticDeclaration {
   readonly ordinal: number;
   readonly cascadeKey: string;
   readonly declarationHash: string;
+  readonly shorthandExpansion?: CssShorthandExpansionEvidence;
 }
 
 export interface CssSemanticRecord {
@@ -241,7 +242,7 @@ export interface CssSafeMergeResult {
   readonly baseSheetHash?: string; readonly workerSheetHash?: string; readonly headSheetHash?: string;
   readonly workerChangedDeclarations?: number; readonly headChangedDeclarations?: number;
   readonly workerChangedCssModuleContracts?: number; readonly headChangedCssModuleContracts?: number;
-  readonly parserEvidence?: CssSafeMergeParserEvidence; readonly selectorTargetEvidence?: CssSafeMergeSelectorTargetEvidence; readonly dependencyGraphEvidence?: CssDependencyGraphEvidence;
+  readonly parserEvidence?: CssSafeMergeParserEvidence; readonly shorthandExpansionEvidence?: CssSafeMergeShorthandExpansionEvidence; readonly selectorTargetEvidence?: CssSafeMergeSelectorTargetEvidence; readonly dependencyGraphEvidence?: CssDependencyGraphEvidence;
   readonly cascadeRuntimeProofs?: readonly CssCascadeRuntimeProofRecord[];
   readonly dependencyGraphProofs?: readonly CssDependencyGraphProofRecord[];
 }

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

@@ -0,0 +1,43 @@
+function duplicateCascadeKeyConflictsForIndexes(id, sourcePath, indexes) {
+  return Object.entries(indexes).flatMap(([side, index]) => (index.duplicateCascadeKeyGroups ?? [])
+    .map((group) => conflict(id, sourcePath, side, group)));
+}
+
+function conflict(id, sourcePath, side, group) {
+  return {
+    code: 'css-duplicate-cascade-key-blocked',
+    gateId: 'css-semantic-merge',
+    sourcePath,
+    details: {
+      reasonCode: 'css-duplicate-cascade-key-order-unproved',
+      conflictKey: `css#${id}#css-duplicate-cascade-key-order-unproved#${side}#${group.cascadeKey}`,
+      side,
+      cascadeKey: group.cascadeKey,
+      count: group.count,
+      declarations: group.entries.map(duplicateCascadeDeclarationDetails),
+      proofGap: {
+        code: 'css-duplicate-cascade-key-order-unproved',
+        status: 'not-claimed',
+        summary: 'Duplicate CSS cascade keys require ordered cascade occurrence evidence before semantic merge admission.',
+        failClosed: true,
+        semanticEquivalenceClaim: false,
+        browserCascadeEquivalenceClaim: false
+      }
+    }
+  };
+}
+
+function duplicateCascadeDeclarationDetails(entry) {
+  return {
+    ruleKey: entry.ruleKey,
+    selectors: entry.selectors,
+    scopes: entry.scopes,
+    property: entry.property,
+    value: entry.value,
+    important: entry.important,
+    declarationOrdinal: entry.declarationOrdinal,
+    declarationHash: entry.declarationHash
+  };
+}
+
+export { duplicateCascadeKeyConflictsForIndexes };

package/dist/semantic-merge-shorthand-evidence.js

@@ -0,0 +1,38 @@
+function mergeShorthandExpansionEvidence(indexes, changed) {
+  const sides = Object.fromEntries(Object.entries(indexes).map(([side, index]) => [side, shorthandExpansionSideEvidence(index)]));
+  const changedEntries = [...changed.worker, ...changed.head].flatMap((change) => [change.before, change.after].filter(Boolean));
+  const changedShorthands = changedEntries.filter((entry, index, entries) => entry.shorthandExpansion && entries.findIndex((candidate) => candidate.key === entry.key && candidate.declarationHash === entry.declarationHash) === index);
+  const expanded = changedShorthands.filter((entry) => entry.shorthandExpansion.status === 'expanded');
+  const unsupported = changedShorthands.filter((entry) => entry.shorthandExpansion.status !== 'expanded');
+  return {
+    kind: 'frontier.lang.cssSafeMergeShorthandExpansionEvidence',
+    version: 1,
+    shorthandDeclarationCount: Object.values(sides).reduce((sum, side) => sum + side.shorthandDeclarationCount, 0),
+    changedShorthandCount: changedShorthands.length,
+    expandedChangedShorthandCount: expanded.length,
+    unsupportedChangedShorthandCount: unsupported.length,
+    deterministicExpansionClaim: changedShorthands.length > 0 && unsupported.length === 0,
+    sides,
+    changedShorthands: changedShorthands.map((entry) => ({
+      cascadeKey: entry.key,
+      property: entry.property,
+      value: entry.value,
+      expansion: entry.shorthandExpansion
+    }))
+  };
+}
+
+function shorthandExpansionSideEvidence(index) {
+  const expansions = [...index.declarations.values()].filter((entry) => entry.shorthandExpansion).map((entry) => entry.shorthandExpansion);
+  return {
+    shorthandDeclarationCount: expansions.length,
+    expandedShorthandDeclarations: expansions.filter((entry) => entry.status === 'expanded').length,
+    unsupportedShorthandDeclarations: expansions.filter((entry) => entry.status !== 'expanded').length,
+    supportedProperties: unique(expansions.filter((entry) => entry.status === 'expanded').map((entry) => entry.property)),
+    unsupportedProperties: unique(expansions.filter((entry) => entry.status !== 'expanded').map((entry) => entry.property))
+  };
+}
+
+function unique(values) { return [...new Set(values.filter(Boolean))]; }
+
+export { mergeShorthandExpansionEvidence };

package/dist/semantic-merge-shorthand.js

@@ -6,6 +6,38 @@ function shorthandGroupForProperty(property) {
   return undefined;
 }
 
+function deterministicShorthandExpansion(property, value, hash) {
+  const normalized = normalizeProperty(property);
+  if (!normalized || !ShorthandExpansionKeys.has(normalized)) return undefined;
+  const definition = DeterministicShorthandExpansions.get(normalized);
+  const unsupported = (reasonCode) => ({
+    kind: 'frontier.lang.cssShorthandExpansionEvidence',
+    version: 1,
+    property: normalized,
+    value: String(value ?? ''),
+    status: 'unsupported',
+    deterministic: false,
+    reasonCode,
+    expansionHash: hash?.({ kind: 'frontier.lang.css.shorthandExpansion.v1', property: normalized, value: String(value ?? ''), status: 'unsupported', reasonCode })
+  });
+  if (!definition) return unsupported('css-shorthand-expansion-unsupported');
+  const tokens = cssValueTokens(value);
+  if (!tokens.length || tokens.length > definition.maxTokens) return unsupported('css-shorthand-expansion-unsupported-value-shape');
+  if (tokens.some(isRuntimeSubstitutionToken)) return unsupported('css-shorthand-expansion-runtime-substitution');
+  const longhands = expandTokens(definition.properties, tokens);
+  return {
+    kind: 'frontier.lang.cssShorthandExpansionEvidence',
+    version: 1,
+    property: normalized,
+    value: String(value ?? ''),
+    group: normalized,
+    status: 'expanded',
+    deterministic: true,
+    longhands,
+    expansionHash: hash?.({ kind: 'frontier.lang.css.shorthandExpansion.v1', property: normalized, value: String(value ?? ''), longhands })
+  };
+}
+
 function declarationsOverlapByCssProperty(leftProperty, rightProperty) {
   const left = normalizeProperty(leftProperty);
   const right = normalizeProperty(rightProperty);
@@ -28,6 +60,80 @@ function normalizeProperty(property) {
   return String(property ?? '').trim().toLowerCase();
 }
 
+function cssValueTokens(value) {
+  const text = String(value ?? '').trim();
+  if (!text) return [];
+  const tokens = [];
+  let token = '';
+  let depth = 0;
+  let quote = '';
+  let escaped = false;
+  for (const char of text) {
+    if (escaped) {
+      token += char;
+      escaped = false;
+      continue;
+    }
+    if (char === '\\') {
+      token += char;
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      token += char;
+      if (char === quote) quote = '';
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      token += char;
+      quote = char;
+      continue;
+    }
+    if (char === '(') {
+      token += char;
+      depth += 1;
+      continue;
+    }
+    if (char === ')') {
+      token += char;
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (/\s/.test(char) && depth === 0) {
+      if (token) tokens.push(token);
+      token = '';
+      continue;
+    }
+    token += char;
+  }
+  if (token) tokens.push(token);
+  return tokens;
+}
+
+function isRuntimeSubstitutionToken(token) {
+  return /\b(?:var|env)\s*\(/i.test(String(token ?? ''));
+}
+
+function expandTokens(properties, tokens) {
+  if (properties.length === 4) {
+    const [top, right = top, bottom = top, left = right] = tokens;
+    return [
+      { property: properties[0], value: top },
+      { property: properties[1], value: right },
+      { property: properties[2], value: bottom },
+      { property: properties[3], value: left }
+    ];
+  }
+  if (properties.length === 2) {
+    const [first, second = first] = tokens;
+    return [
+      { property: properties[0], value: first },
+      { property: properties[1], value: second }
+    ];
+  }
+  return properties.map((longhand, index) => ({ property: longhand, value: tokens[index] ?? tokens[0] }));
+}
+
 function allPropertyExcluded(property) {
   return property.startsWith('--') || property === 'direction' || property === 'unicode-bidi';
 }
@@ -132,6 +238,32 @@ const ShorthandExpansionKeys = new Map(Object.entries({
   transition: ['transition-behavior', 'transition-delay', 'transition-duration', 'transition-property', 'transition-timing-function']
 }).map(([property, keys]) => [property, new Set(keys)]));
 
+const DeterministicShorthandExpansions = new Map(Object.entries({
+  margin: box4('margin', ['top', 'right', 'bottom', 'left']),
+  padding: box4('padding', ['top', 'right', 'bottom', 'left']),
+  inset: { properties: ['top', 'right', 'bottom', 'left'], maxTokens: 4 },
+  'margin-block': { properties: ['margin-block-start', 'margin-block-end'], maxTokens: 2 },
+  'margin-inline': { properties: ['margin-inline-start', 'margin-inline-end'], maxTokens: 2 },
+  'padding-block': { properties: ['padding-block-start', 'padding-block-end'], maxTokens: 2 },
+  'padding-inline': { properties: ['padding-inline-start', 'padding-inline-end'], maxTokens: 2 },
+  'inset-block': { properties: ['inset-block-start', 'inset-block-end'], maxTokens: 2 },
+  'inset-inline': { properties: ['inset-inline-start', 'inset-inline-end'], maxTokens: 2 },
+  gap: { properties: ['row-gap', 'column-gap'], maxTokens: 2 },
+  'scroll-margin': box4('scroll-margin', ['top', 'right', 'bottom', 'left']),
+  'scroll-padding': box4('scroll-padding', ['top', 'right', 'bottom', 'left']),
+  'scroll-margin-block': { properties: ['scroll-margin-block-start', 'scroll-margin-block-end'], maxTokens: 2 },
+  'scroll-margin-inline': { properties: ['scroll-margin-inline-start', 'scroll-margin-inline-end'], maxTokens: 2 },
+  'scroll-padding-block': { properties: ['scroll-padding-block-start', 'scroll-padding-block-end'], maxTokens: 2 },
+  'scroll-padding-inline': { properties: ['scroll-padding-inline-start', 'scroll-padding-inline-end'], maxTokens: 2 },
+  'border-width': box4('border', ['top-width', 'right-width', 'bottom-width', 'left-width']),
+  'border-style': box4('border', ['top-style', 'right-style', 'bottom-style', 'left-style']),
+  'border-color': box4('border', ['top-color', 'right-color', 'bottom-color', 'left-color'])
+}));
+
+function box4(prefix, suffixes) {
+  return { properties: suffixes.map((suffix) => `${prefix}-${suffix}`), maxTokens: 4 };
+}
+
 function edgeKeys(prefix, attributes) {
   return ['top', 'right', 'bottom', 'left'].flatMap((edge) => attributes.map((attribute) => `${prefix}-${edge}-${attribute}`));
 }
@@ -144,4 +276,4 @@ function propertyTuple(prefix, attributes) {
   return attributes.map((attribute) => `${prefix}-${attribute}`);
 }
 
-export { declarationsOverlapByCssProperty, shorthandGroupForProperty };
+export { declarationsOverlapByCssProperty, deterministicShorthandExpansion, shorthandGroupForProperty };

package/dist/semantic-merge.js

@@ -3,7 +3,9 @@ import { admitCascadeRuntimeProofs } from './semantic-merge-cascade-runtime.js';
 import { admitCssDependencyGraphProofs, mergeCssDependencyGraphEvidence } from './dependency-graph.js';
 import { mergeSelectorTargetEvidence, planSelectorTargetRebase } from './semantic-merge-selector-targets.js';
 import { applyAtRuleBlockChanges, atRuleBlockEntry, atRuleBlockOverlapConflicts, atRuleOccurrenceKey, changedAtRuleBlocks, renderAtRuleBlock, renderAtRuleStatement } from './semantic-merge-at-rules.js';
-import { declarationsOverlapByCssProperty, shorthandGroupForProperty } from './semantic-merge-shorthand.js';
+import { declarationsOverlapByCssProperty, deterministicShorthandExpansion, shorthandGroupForProperty } from './semantic-merge-shorthand.js';
+import { mergeShorthandExpansionEvidence } from './semantic-merge-shorthand-evidence.js';
+import { duplicateCascadeKeyConflictsForIndexes } from './semantic-merge-duplicate-cascade.js';
 
 function safeMergeCssSource(input = {}, context = {}) {
   const parseSheet = context.parseCssSemanticSheet;
@@ -20,7 +22,7 @@ function safeMergeCssSource(input = {}, context = {}) {
     worker: parseSheet(worker, sheetOptions(input, 'worker', sourcePath)),
     head: parseSheet(head, sheetOptions(input, 'head', sourcePath))
   };
-  const indexes = Object.fromEntries(Object.entries(sheets).map(([name, sheet]) => [name, declarationIndex(sheet)]));
+  const indexes = Object.fromEntries(Object.entries(sheets).map(([name, sheet]) => [name, declarationIndex(sheet, hash)]));
   const changed = {
     worker: changedDeclarations(indexes.base, indexes.worker, 'worker'),
     head: changedDeclarations(indexes.base, indexes.head, 'head')
@@ -32,6 +34,7 @@ function safeMergeCssSource(input = {}, context = {}) {
   const moduleChanges = cssModuleContractChanges(sheets, hash);
   const proofConflicts = proofGapConflicts(id, sourcePath, changed, indexes);
   const parserConflicts = parserErrorConflicts(id, sourcePath, sheets);
+  const duplicateCascadeKeyConflicts = duplicateCascadeKeyConflictsForIndexes(id, sourcePath, indexes);
   const overlapConflicts = [
     ...overlapDeclarationConflicts(id, sourcePath, changed.worker, changed.head),
     ...shorthandOverlapConflicts(id, sourcePath, changed.worker, changed.head),
@@ -39,6 +42,7 @@ function safeMergeCssSource(input = {}, context = {}) {
   ];
   const moduleConflicts = cssModuleContractConflicts(id, sourcePath, moduleChanges);
   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 shapeChanges = unsupportedSourceShapeChanges(sheets, changed, hash);
@@ -53,8 +57,8 @@ function safeMergeCssSource(input = {}, context = {}) {
     hash
   });
   const dependencyGraphAdmission = admitCssDependencyGraphProofs({ id, sourcePath, input, dependencyGraphEvidence, binding: { base, worker, head, output: mergedSourceText }, hash });
-  const conflicts = [...parserConflicts, ...proofConflicts, ...overlapConflicts, ...moduleConflicts, ...cascadeRuntimeAdmission.conflicts, ...dependencyGraphAdmission.conflicts, ...selectorTargetPlan.conflicts];
-  if (conflicts.length) return blocked(id, sourcePath, 'css-semantic-merge-conflict', conflicts, { parserEvidence, dependencyGraphEvidence, selectorTargetEvidence: selectorTargetPlan.evidence, cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs, dependencyGraphProofs: dependencyGraphAdmission.proofs });
+  const conflicts = [...parserConflicts, ...duplicateCascadeKeyConflicts, ...proofConflicts, ...overlapConflicts, ...moduleConflicts, ...cascadeRuntimeAdmission.conflicts, ...dependencyGraphAdmission.conflicts, ...selectorTargetPlan.conflicts];
+  if (conflicts.length) return blocked(id, sourcePath, 'css-semantic-merge-conflict', conflicts, { parserEvidence, shorthandExpansionEvidence, dependencyGraphEvidence, selectorTargetEvidence: selectorTargetPlan.evidence, cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs, dependencyGraphProofs: dependencyGraphAdmission.proofs });
   return merged(id, sourcePath, mergedSourceText, 'semantic-declaration-merge', hash, {
     baseSheetHash: sheets.base.sheetHash,
     workerSheetHash: sheets.worker.sheetHash,
@@ -64,6 +68,7 @@ function safeMergeCssSource(input = {}, context = {}) {
     workerChangedCssModuleContracts: moduleChanges.worker.length,
     headChangedCssModuleContracts: moduleChanges.head.length,
     parserEvidence,
+    shorthandExpansionEvidence,
     dependencyGraphEvidence,
     selectorTargetEvidence: selectorTargetPlan.evidence,
     cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs,
@@ -72,28 +77,21 @@ function safeMergeCssSource(input = {}, context = {}) {
   });
 }
 
-function declarationIndex(sheet) {
+function declarationIndex(sheet, hash) {
   const declarations = new Map();
   const order = [];
   const statements = [];
   const atRuleBlocks = new Map();
   const atRuleBlockOrder = [];
   const atRuleOccurrences = new Map();
+  const declarationOccurrences = new Map();
   for (const record of sheet.records) {
     const block = atRuleBlockEntry(record, atRuleOccurrenceKey(record, atRuleOccurrences));
     if (block) {
       atRuleBlocks.set(block.key, block);
       atRuleBlockOrder.push(block.key);
     }
-    if (record.kind === 'at-rule-statement') {
-      statements.push({
-        key: record.atRuleHash,
-        scopes: record.scopes ?? [],
-        statementText: record.statementText,
-        atRuleName: record.atRuleName,
-        conditionText: record.conditionText
-      });
-    }
+    if (record.kind === 'at-rule-statement') statements.push({ key: record.atRuleHash, scopes: record.scopes ?? [], statementText: record.statementText, atRuleName: record.atRuleName, conditionText: record.conditionText });
     if (record.kind !== 'rule') continue;
     const ruleKey = ruleIdentityKey(record);
     for (const declaration of record.declarations ?? []) {
@@ -105,15 +103,21 @@ function declarationIndex(sheet) {
         property: declaration.property,
         value: declaration.value,
         important: declaration.important,
+        declarationOrdinal: declaration.ordinal,
         declarationHash: declaration.declarationHash,
+        shorthandExpansion: deterministicShorthandExpansion(declaration.property, declaration.value, hash),
         selectorTargetGraphHash: record.selectorTargetGraphHash,
         proofGaps: proofGapsForDeclaration(record, declaration)
       };
+      declarationOccurrences.set(entry.key, [...(declarationOccurrences.get(entry.key) ?? []), entry]);
       declarations.set(entry.key, entry);
       order.push(entry.key);
     }
   }
-  return { declarations, order: unique(order), statements, atRuleBlocks, atRuleBlockOrder: unique(atRuleBlockOrder) };
+  const duplicateCascadeKeyGroups = [...declarationOccurrences.entries()]
+    .filter(([, entries]) => entries.length > 1)
+    .map(([cascadeKey, entries]) => ({ cascadeKey, count: entries.length, entries }));
+  return { declarations, order: unique(order), statements, atRuleBlocks, atRuleBlockOrder: unique(atRuleBlockOrder), duplicateCascadeKeyGroups };
 }
 
 function changedDeclarations(baseIndex, currentIndex, side) {
@@ -134,6 +138,8 @@ function proofGapConflicts(id, sourcePath, changed, indexes) {
       .filter((gap) => !canAdmitProofGap(gap, entry, changed, indexes))
       .map((gap) => conflict(id, sourcePath, 'css-proof-gap-blocked', gap.code, {
       cascadeKey: key,
+      property: entry.property,
+      shorthandExpansion: entry.shorthandExpansion,
       proofGap: gap
     }));
   });
@@ -202,7 +208,7 @@ function shorthandOverlapConflicts(id, sourcePath, workerChanges, headChanges) {
 function canAdmitProofGap(gap, entry, changed, indexes) {
   if (gap.code !== 'css-shorthand-expansion-unproved' || !entry) return false;
   const group = shorthandGroupForProperty(entry.property);
-  if (!group || hasRelatedExistingDeclaration(entry, indexes)) return false;
+  if (!group || entry.shorthandExpansion?.status !== 'expanded' || hasRelatedExistingDeclaration(entry, indexes)) return false;
   const oppositeChanges = [...changed.worker, ...changed.head].filter((change) => change.key !== entry.key);
   return !oppositeChanges.some((change) => declarationsOverlapByShorthandGroup(entry, change.after ?? change.before));
 }
@@ -239,9 +245,7 @@ function renderDeclarationIndex(index) {
   const chunks = [];
   for (const statement of index.statements ?? []) renderAtRuleStatement(chunks, statement);
   for (const key of index.atRuleBlockOrder ?? []) renderAtRuleBlock(chunks, index.atRuleBlocks.get(key));
-  for (const declarations of groups.values()) {
-    renderDeclarationGroup(chunks, declarations);
-  }
+  for (const declarations of groups.values()) renderDeclarationGroup(chunks, declarations);
   return `${chunks.join('\n').trimEnd()}\n`;
 }
 
@@ -263,21 +267,11 @@ function renderDeclarationGroup(chunks, declarations) {
 }
 
 function merged(id, sourcePath, sourceText, operation, hash, extra = {}) {
-  return result(id, sourcePath, 'merged', {
-    operation,
-    mergedSourceText: sourceText,
-    mergedSourceHash: hash?.(sourceText),
-    conflicts: [],
-    ...extra
-  });
+  return result(id, sourcePath, 'merged', { operation, mergedSourceText: sourceText, mergedSourceHash: hash?.(sourceText), conflicts: [], ...extra });
 }
 
 function blocked(id, sourcePath, reasonCode, conflicts = [], extra = {}) {
-  return result(id, sourcePath, 'blocked', {
-    operation: 'blocked',
-    conflicts: conflicts.length ? conflicts : [conflict(id, sourcePath, reasonCode, reasonCode)],
-    ...extra
-  });
+  return result(id, sourcePath, 'blocked', { operation: 'blocked', conflicts: conflicts.length ? conflicts : [conflict(id, sourcePath, reasonCode, reasonCode)], ...extra });
 }
 
 function result(id, sourcePath, status, body) {

package/dist/shorthand-expansion.d.ts

@@ -0,0 +1,44 @@
+export interface CssShorthandLonghandExpansion {
+  readonly property: string;
+  readonly value: string;
+}
+
+export interface CssShorthandExpansionEvidence {
+  readonly kind: 'frontier.lang.cssShorthandExpansionEvidence';
+  readonly version: 1;
+  readonly property: string;
+  readonly value: string;
+  readonly group?: string;
+  readonly status: 'expanded' | 'unsupported' | string;
+  readonly deterministic: boolean;
+  readonly reasonCode?: string;
+  readonly longhands?: readonly CssShorthandLonghandExpansion[];
+  readonly expansionHash?: string;
+}
+
+export interface CssSafeMergeShorthandExpansionEvidence {
+  readonly kind: 'frontier.lang.cssSafeMergeShorthandExpansionEvidence';
+  readonly version: 1;
+  readonly shorthandDeclarationCount: number;
+  readonly changedShorthandCount: number;
+  readonly expandedChangedShorthandCount: number;
+  readonly unsupportedChangedShorthandCount: number;
+  readonly deterministicExpansionClaim: boolean;
+  readonly sides: Readonly<Record<string, CssSafeMergeShorthandExpansionSideEvidence>>;
+  readonly changedShorthands: readonly CssSafeMergeChangedShorthandExpansion[];
+}
+
+export interface CssSafeMergeShorthandExpansionSideEvidence {
+  readonly shorthandDeclarationCount: number;
+  readonly expandedShorthandDeclarations: number;
+  readonly unsupportedShorthandDeclarations: number;
+  readonly supportedProperties: readonly string[];
+  readonly unsupportedProperties: readonly string[];
+}
+
+export interface CssSafeMergeChangedShorthandExpansion {
+  readonly cascadeKey: string;
+  readonly property: string;
+  readonly value: string;
+  readonly expansion: CssShorthandExpansionEvidence;
+}

package/package.json

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