@shapeshift-labs/frontier-lang-css 0.1.16 → 0.1.18

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 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, 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, no duplicate ordered occurrences for any changed cascade key, 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, 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/css-module-contract-proof.d.ts

@@ -0,0 +1,57 @@
+export interface CssModuleContractProof {
+  readonly id?: string;
+  readonly kind: 'css-source-bound-module-contract-proof' | 'css-module-contract-proof' | 'css-source-bound-css-module-contract-proof' | string;
+  readonly status: 'passed' | string;
+  readonly sourcePath: string;
+  readonly side?: string;
+  readonly sides?: readonly string[];
+  readonly changeKind?: string;
+  readonly changeKinds?: readonly string[];
+  readonly contractKey?: string;
+  readonly contractKeys?: readonly string[];
+  readonly contractKind?: string;
+  readonly contractKinds?: readonly string[];
+  readonly baseSourceText?: string;
+  readonly workerSourceText?: string;
+  readonly headSourceText?: string;
+  readonly outputSourceText?: string;
+  readonly mergedSourceText?: string;
+  readonly baseSourceHash?: string;
+  readonly workerSourceHash?: string;
+  readonly headSourceHash?: string;
+  readonly outputSourceHash?: string;
+  readonly mergedSourceHash?: string;
+  readonly sourceTexts?: Readonly<Record<string,string>>;
+  readonly sourceHashes?: Readonly<Record<string,string>>;
+  readonly sources?: Readonly<Record<string,string>>;
+  readonly hashes?: Readonly<Record<string,string>>;
+  readonly moduleHash?: string;
+  readonly generatedClassNameMapHash?: string;
+  readonly jsTsUseSiteGraphHash?: string;
+  readonly cssModuleCompositionGraphHash?: string;
+  readonly icssGraphHash?: string;
+  readonly contractGraphHashes?: Readonly<Record<string,string>>;
+  readonly cssModuleGraphHashes?: Readonly<Record<string,string>>;
+  readonly proofLevel?: string;
+}
+
+export interface CssModuleContractProofRecord {
+  readonly id?: string;
+  readonly kind: string;
+  readonly status: 'passed';
+  readonly proofLevel: string;
+  readonly sourcePath?: string;
+  readonly side: string;
+  readonly changeKind: string;
+  readonly contractKey: string;
+  readonly contractKind: string;
+  readonly baseSourceHash?: string;
+  readonly workerSourceHash?: string;
+  readonly headSourceHash?: string;
+  readonly outputSourceHash?: string;
+  readonly moduleHash?: string;
+  readonly generatedClassNameMapHash?: string;
+  readonly jsTsUseSiteGraphHash?: string;
+  readonly cssModuleCompositionGraphHash?: string;
+  readonly icssGraphHash?: string;
+}

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 { 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';
 
 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 {
@@ -228,6 +229,7 @@ export interface CssSafeMergeAdmission {
   readonly browserCascadeEquivalenceClaim?: true;
   readonly cssCascadeRuntimeProofs?: readonly CssCascadeRuntimeProofRecord[];
   readonly cssDependencyGraphProofs?: readonly CssDependencyGraphProofRecord[];
+  readonly cssModuleContractProofs?: readonly CssModuleContractProofRecord[];
 }
 
 export interface CssSafeMergeResult {
@@ -241,7 +243,8 @@ 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 cssModuleContractProofs?: readonly CssModuleContractProofRecord[];
   readonly cascadeRuntimeProofs?: readonly CssCascadeRuntimeProofRecord[];
   readonly dependencyGraphProofs?: readonly CssDependencyGraphProofRecord[];
 }
@@ -286,19 +289,17 @@ export interface CssSelectorTargetEquivalence {
 
 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 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 cssCascadeRuntimeProof?: CssCascadeRuntimeProof; readonly cssCascadeRuntimeProofs?: readonly CssCascadeRuntimeProof[];
-  readonly cssCascadeRuntimeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;
+  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[]>>;
   readonly cascadeRuntimeProof?: CssCascadeRuntimeProof; readonly cascadeRuntimeProofs?: readonly CssCascadeRuntimeProof[];
   readonly cascadeRuntimeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;
-  readonly sourceBoundCascadeProof?: CssCascadeRuntimeProof; readonly sourceBoundCascadeProofs?: readonly CssCascadeRuntimeProof[];
-  readonly sourceBoundCascadeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;
+  readonly sourceBoundCascadeProof?: CssCascadeRuntimeProof; readonly sourceBoundCascadeProofs?: readonly CssCascadeRuntimeProof[]; readonly sourceBoundCascadeProofsByPath?: Readonly<Record<string, CssCascadeRuntimeProof | readonly CssCascadeRuntimeProof[]>>;
   readonly cssDependencyGraphProof?: CssDependencyGraphProof; readonly cssDependencyGraphProofs?: readonly CssDependencyGraphProof[]; readonly cssSourceBoundDependencyGraphProof?: CssDependencyGraphProof; readonly cssSourceBoundDependencyGraphProofs?: readonly CssDependencyGraphProof[];
   readonly cssDependencyGraphProofsByPath?: Readonly<Record<string, CssDependencyGraphProof | readonly CssDependencyGraphProof[]>>; readonly cssSourceBoundDependencyGraphProofsByPath?: Readonly<Record<string, CssDependencyGraphProof | readonly CssDependencyGraphProof[]>>;
+  readonly 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 baseGeneratedClassNameMap?: Readonly<Record<string, string>>; readonly workerGeneratedClassNameMap?: Readonly<Record<string, string>>; readonly headGeneratedClassNameMap?: Readonly<Record<string, string>>;
   readonly baseGeneratedClassNameMapHash?: string; readonly workerGeneratedClassNameMapHash?: string; readonly headGeneratedClassNameMapHash?: string;

package/dist/semantic-merge-css-module-proofs.js

@@ -0,0 +1,146 @@
+const CssModuleContractProofKinds = new Set(['css-source-bound-module-contract-proof', 'css-module-contract-proof', 'css-source-bound-css-module-contract-proof']);
+
+function admitCssModuleContractProofs({ id, sourcePath, input = {}, moduleChanges, binding, hash }) {
+  const proofs = cssModuleContractProofCandidates(input, sourcePath);
+  const admitted = [];
+  const conflicts = [
+    ...cssModuleOverlapConflicts(id, sourcePath, moduleChanges.worker, moduleChanges.head)
+  ];
+  for (const change of [...moduleChanges.worker, ...moduleChanges.head]) {
+    const proof = proofs.find((candidate) => isProofForChange(candidate, change, sourcePath, binding, hash));
+    if (proof) admitted.push(proofRecord(proof, change, sourcePath, binding, hash));
+    else conflicts.push(...proofConflictsForChange(id, sourcePath, change));
+  }
+  return { proofs: admitted, conflicts };
+}
+
+function proofConflictsForChange(id, sourcePath, change) {
+  const contract = change.after ?? change.before;
+  const requiredCodes = contract?.requiredProofGapCodes ?? [];
+  const gapConflicts = (change.proofGaps ?? [])
+    .filter((gap) => requiredCodes.includes(gap.code))
+    .map((gap) => conflict(id, sourcePath, 'css-module-proof-gap-blocked', gap.code, {
+      contractKey: change.key,
+      contractKind: contract.contractKind,
+      side: change.side,
+      changeKind: change.kind,
+      proofGap: gap
+    }));
+  if (gapConflicts.length) return gapConflicts;
+  return [conflict(id, sourcePath, 'css-module-contract-source-proof-blocked', 'css-module-contract-source-proof-unproved', {
+    contractKey: change.key,
+    contractKind: contract?.contractKind,
+    side: change.side,
+    changeKind: change.kind,
+    nextProof: 'css-source-bound-module-contract-proof'
+  })];
+}
+
+function cssModuleOverlapConflicts(id, sourcePath, workerChanges, headChanges) {
+  const headByKey = new Map(headChanges.map((change) => [change.key, change]));
+  return workerChanges.flatMap((workerChange) => {
+    const headChange = headByKey.get(workerChange.key);
+    if (!headChange || sameContractChange(workerChange, headChange)) return [];
+    const contract = workerChange.after ?? workerChange.before ?? headChange.after ?? headChange.before;
+    return [conflict(id, sourcePath, 'css-module-contract-conflict', 'css-module-contract-conflict', {
+      contractKey: workerChange.key,
+      contractKind: contract?.contractKind,
+      worker: contractChangeDetails(workerChange),
+      head: contractChangeDetails(headChange)
+    })];
+  });
+}
+
+function isProofForChange(proof, change, sourcePath, binding, hash) {
+  const contract = change.after ?? change.before;
+  return Boolean(proof && contract && typeof proof === 'object') &&
+    CssModuleContractProofKinds.has(proof.kind) &&
+    proof.status === 'passed' &&
+    proof.sourcePath === sourcePath &&
+    proofCoversValue(proof.side, proof.sides, change.side) &&
+    proofCoversValue(proof.changeKind, proof.changeKinds, change.kind) &&
+    proofCoversValue(proof.contractKey, proof.contractKeys, change.key) &&
+    proofCoversValue(proof.contractKind, proof.contractKinds, contract.contractKind) &&
+    proofSourceMatches(proof, 'base', binding.base, hash) &&
+    proofSourceMatches(proof, 'worker', binding.worker, hash) &&
+    proofSourceMatches(proof, 'head', binding.head, hash) &&
+    proofSourceMatches(proof, 'output', binding.output, hash) &&
+    contractHashesMatch(proof, contract);
+}
+
+function contractHashesMatch(proof, contract) {
+  return proofHashMatches(proof, 'moduleHash', contract.moduleHash) &&
+    proofHashMatches(proof, 'generatedClassNameMapHash', contract.generatedClassNameMapHash, contract.contractKind === 'css-module-export') &&
+    proofHashMatches(proof, 'jsTsUseSiteGraphHash', contract.jsTsUseSiteGraphHash, contract.contractKind === 'css-module-export') &&
+    proofHashMatches(proof, 'cssModuleCompositionGraphHash', contract.cssModuleCompositionGraphHash, contract.contractKind === 'css-module-composition') &&
+    proofHashMatches(proof, 'icssGraphHash', contract.icssGraphHash, contract.contractKind === 'icss-import' || contract.contractKind === 'icss-export');
+}
+
+function proofHashMatches(proof, field, expected, required = true) {
+  if (!required) return true;
+  if (!expected) return false;
+  return proof[field] === expected || proof.contractGraphHashes?.[field] === expected || proof.cssModuleGraphHashes?.[field] === expected;
+}
+
+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 proofRecord(proof, change, sourcePath, binding, hash) {
+  const contract = change.after ?? change.before;
+  return {
+    id: proof.id,
+    kind: proof.kind,
+    status: 'passed',
+    proofLevel: proof.proofLevel ?? 'css-module-contract-source-bound',
+    sourcePath,
+    side: change.side,
+    changeKind: change.kind,
+    contractKey: change.key,
+    contractKind: contract.contractKind,
+    baseSourceHash: hash?.(binding.base),
+    workerSourceHash: hash?.(binding.worker),
+    headSourceHash: hash?.(binding.head),
+    outputSourceHash: hash?.(binding.output),
+    moduleHash: contract.moduleHash,
+    generatedClassNameMapHash: contract.generatedClassNameMapHash,
+    jsTsUseSiteGraphHash: contract.jsTsUseSiteGraphHash,
+    cssModuleCompositionGraphHash: contract.cssModuleCompositionGraphHash,
+    icssGraphHash: contract.icssGraphHash
+  };
+}
+
+function cssModuleContractProofCandidates(input = {}, sourcePath) {
+  return [
+    input.cssModuleContractProof,
+    input.cssModuleContractProofs,
+    input.cssModuleContractProofsByPath?.[sourcePath],
+    input.cssSourceBoundModuleContractProof,
+    input.cssSourceBoundModuleContractProofs,
+    input.cssSourceBoundModuleContractProofsByPath?.[sourcePath],
+    input.cssSourceBoundCssModuleContractProof,
+    input.cssSourceBoundCssModuleContractProofs,
+    input.cssSourceBoundCssModuleContractProofsByPath?.[sourcePath]
+  ].flatMap(asArray).filter(Boolean);
+}
+
+function proofCoversValue(single, many, value) {
+  if (single !== undefined) return single === value;
+  if (Array.isArray(many)) return many.includes(value);
+  return true;
+}
+
+function sameContractChange(left, right) { return (left.after?.hash ?? '') === (right.after?.hash ?? '') && left.kind === right.kind; }
+function contractChangeDetails(change) { return { kind: change.kind, key: change.key, hash: change.after?.hash ?? change.before?.hash }; }
+function asArray(value) { return Array.isArray(value) ? value : value === undefined ? [] : [value]; }
+function conflict(id, sourcePath, code, reasonCode, details = {}) { return { code, gateId: 'css-semantic-merge', sourcePath, details: { reasonCode, conflictKey: `css#${id}#${reasonCode}#${details.contractKey ?? sourcePath ?? 'source'}`, ...details } }; }
+
+export { admitCssModuleContractProofs };

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

@@ -35,6 +35,7 @@ function cssModuleContractIndex(sheet, hash) {
   for (const entry of cssModules.exports ?? []) {
     const contractHash = hash?.({ kind: 'frontier.lang.css.module.export.contract.v1', name: entry.name, generatedName: entry.generatedName });
     contracts.set(`export:${entry.name}`, {
+      ...contractEvidence(cssModules),
       key: `export:${entry.name}`,
       contractKind: 'css-module-export',
       name: entry.name,
@@ -45,6 +46,7 @@ function cssModuleContractIndex(sheet, hash) {
   for (const entry of cssModules.compositions ?? []) {
     const key = ['composition', entry.localName, entry.sourceKind, entry.source ?? 'local'].join(':');
     contracts.set(key, {
+      ...contractEvidence(cssModules),
       key,
       contractKind: 'css-module-composition',
       name: entry.localName,
@@ -55,6 +57,7 @@ function cssModuleContractIndex(sheet, hash) {
   for (const entry of cssModules.icssImports ?? []) {
     const key = ['icss-import', entry.source, entry.importedName].join(':');
     contracts.set(key, {
+      ...contractEvidence(cssModules),
       key,
       contractKind: 'icss-import',
       name: entry.localName,
@@ -65,6 +68,7 @@ function cssModuleContractIndex(sheet, hash) {
   for (const entry of cssModules.icssExports ?? []) {
     const key = `icss-export:${entry.name}`;
     contracts.set(key, {
+      ...contractEvidence(cssModules),
       key,
       contractKind: 'icss-export',
       name: entry.name,
@@ -75,6 +79,16 @@ function cssModuleContractIndex(sheet, hash) {
   return { contracts, proofGaps: cssModules.proofGaps ?? [], moduleHash: cssModules.moduleHash };
 }
 
+function contractEvidence(cssModules) {
+  return {
+    moduleHash: cssModules.moduleHash,
+    generatedClassNameMapHash: cssModules.generatedClassNameMapHash,
+    jsTsUseSiteGraphHash: cssModules.jsTsUseSiteGraphHash,
+    cssModuleCompositionGraphHash: cssModules.cssModuleCompositionGraphHash,
+    icssGraphHash: cssModules.icssGraphHash
+  };
+}
+
 function changedContracts(baseIndex, currentIndex, side, sheet) {
   const keys = unique([...baseIndex.contracts.keys(), ...currentIndex.contracts.keys()]);
   return keys.flatMap((key) => {

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

@@ -1,9 +1,11 @@
-import { cssModuleContractChanges, cssModuleContractConflicts, sheetOptions, unsupportedSourceShapeChanges } from './semantic-merge-css-modules.js';
+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 { 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 = {}) {
@@ -21,7 +23,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')
@@ -39,8 +41,8 @@ function safeMergeCssSource(input = {}, context = {}) {
     ...shorthandOverlapConflicts(id, sourcePath, changed.worker, changed.head),
     ...atRuleBlockOverlapConflicts(id, sourcePath, blockChanges.worker, blockChanges.head, conflict)
   ];
-  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);
@@ -55,8 +57,9 @@ function safeMergeCssSource(input = {}, context = {}) {
     hash
   });
   const dependencyGraphAdmission = admitCssDependencyGraphProofs({ id, sourcePath, input, dependencyGraphEvidence, binding: { base, worker, head, output: mergedSourceText }, hash });
-  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, dependencyGraphEvidence, selectorTargetEvidence: selectorTargetPlan.evidence, cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs, dependencyGraphProofs: dependencyGraphAdmission.proofs });
+  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 });
   return merged(id, sourcePath, mergedSourceText, 'semantic-declaration-merge', hash, {
     baseSheetHash: sheets.base.sheetHash,
     workerSheetHash: sheets.worker.sheetHash,
@@ -66,15 +69,17 @@ function safeMergeCssSource(input = {}, context = {}) {
     workerChangedCssModuleContracts: moduleChanges.worker.length,
     headChangedCssModuleContracts: moduleChanges.head.length,
     parserEvidence,
+    shorthandExpansionEvidence,
     dependencyGraphEvidence,
     selectorTargetEvidence: selectorTargetPlan.evidence,
+    cssModuleContractProofs: cssModuleAdmission.proofs,
     cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs,
     dependencyGraphProofs: dependencyGraphAdmission.proofs,
     browserCascadeEquivalenceClaim: cascadeRuntimeAdmission.proofs.length > 0
   });
 }
 
-function declarationIndex(sheet) {
+function declarationIndex(sheet, hash) {
   const declarations = new Map();
   const order = [];
   const statements = [];
@@ -102,6 +107,7 @@ function declarationIndex(sheet) {
         important: declaration.important,
         declarationOrdinal: declaration.ordinal,
         declarationHash: declaration.declarationHash,
+        shorthandExpansion: deterministicShorthandExpansion(declaration.property, declaration.value, hash),
         selectorTargetGraphHash: record.selectorTargetGraphHash,
         proofGaps: proofGapsForDeclaration(record, declaration)
       };
@@ -134,6 +140,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 +210,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 +247,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 +269,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) {
@@ -299,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
+      cssCascadeRuntimeProofs: body.cascadeRuntimeProofs?.length ? body.cascadeRuntimeProofs : undefined, cssDependencyGraphProofs: body.dependencyGraphProofs?.length ? body.dependencyGraphProofs : undefined, cssModuleContractProofs: body.cssModuleContractProofs?.length ? body.cssModuleContractProofs : undefined
     }
   };
 }

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.16",
+  "version": "0.1.18",
   "description": "CSS semantic merge evidence and projection adapter for Frontier Lang semantic source documents.",
   "type": "module",
   "main": "./dist/index.js",