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

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'; 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';
+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;
@@ -229,6 +229,7 @@ export interface CssSafeMergeAdmission {
   readonly browserCascadeEquivalenceClaim?: true;
   readonly cssCascadeRuntimeProofs?: readonly CssCascadeRuntimeProofRecord[];
   readonly cssDependencyGraphProofs?: readonly CssDependencyGraphProofRecord[];
+  readonly cssModuleContractProofs?: readonly CssModuleContractProofRecord[];
 }
 
 export interface CssSafeMergeResult {
@@ -243,6 +244,7 @@ export interface CssSafeMergeResult {
   readonly workerChangedDeclarations?: number; readonly headChangedDeclarations?: number;
   readonly workerChangedCssModuleContracts?: number; readonly headChangedCssModuleContracts?: number;
   readonly parserEvidence?: CssSafeMergeParserEvidence; readonly shorthandExpansionEvidence?: CssSafeMergeShorthandExpansionEvidence; readonly selectorTargetEvidence?: CssSafeMergeSelectorTargetEvidence; readonly dependencyGraphEvidence?: CssDependencyGraphEvidence;
+  readonly cssModuleContractProofs?: readonly CssModuleContractProofRecord[];
   readonly cascadeRuntimeProofs?: readonly CssCascadeRuntimeProofRecord[];
   readonly dependencyGraphProofs?: readonly CssDependencyGraphProofRecord[];
 }
@@ -287,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.js

@@ -1,4 +1,5 @@
-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';
@@ -40,7 +41,6 @@ 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);
@@ -57,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, shorthandExpansionEvidence, 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,
@@ -71,6 +72,7 @@ function safeMergeCssSource(input = {}, context = {}) {
     shorthandExpansionEvidence,
     dependencyGraphEvidence,
     selectorTargetEvidence: selectorTargetPlan.evidence,
+    cssModuleContractProofs: cssModuleAdmission.proofs,
     cascadeRuntimeProofs: cascadeRuntimeAdmission.proofs,
     dependencyGraphProofs: dependencyGraphAdmission.proofs,
     browserCascadeEquivalenceClaim: cascadeRuntimeAdmission.proofs.length > 0
@@ -293,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/package.json

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