@shapeshift-labs/frontier-lang-compiler 0.2.181 → 0.2.183

package/dist/internal/index-impl/projectSymbolGraphCssModuleRecords.js

@@ -185,6 +185,13 @@ function cssModuleUseSiteGraphRecords(importBindings, useSites, blockers) {
 }
 
 function cssModuleUseSiteGraphRecord(cssModuleSourcePath, bindings, graphUseSites, graphBlockers) {
+  const jsTsUseSiteGraphHash = hashSemanticValue({
+    kind: 'frontier.lang.cssModuleJsTsUseSiteGraph.v1',
+    cssModuleSourcePath,
+    bindings: bindings.map(cssModuleUseSiteBindingSignature).sort(stableStringCompare),
+    useSites: graphUseSites.map(cssModuleUseSiteSignature).sort(stableStringCompare),
+    blockers: graphBlockers.map(cssModuleUseSiteBlockerSignature).sort(stableStringCompare)
+  });
   const graphHash = hashSemanticValue({
     kind: 'frontier.lang.cssModuleUseSiteGraph.v1',
     cssModuleSourcePath,
@@ -208,6 +215,7 @@ function cssModuleUseSiteGraphRecord(cssModuleSourcePath, bindings, graphUseSite
     cssModuleExportNamesHash: bindings.find((binding) => binding.cssModuleExportNamesHash)?.cssModuleExportNamesHash,
     bundlerTransformHash: bindings.find((binding) => binding.bundlerTransformHash)?.bundlerTransformHash,
     sourceMapProofHash: bindings.find((binding) => binding.sourceMapProofHash)?.sourceMapProofHash,
+    jsTsUseSiteGraphHash,
     status: graphBlockers.length ? 'blocked' : 'ready',
     graphHash,
     autoMergeClaim: false,
@@ -215,6 +223,48 @@ function cssModuleUseSiteGraphRecord(cssModuleSourcePath, bindings, graphUseSite
   });
 }
 
+function cssModuleUseSiteBindingSignature(binding) {
+  return JSON.stringify({
+    sourcePath: binding.sourcePath,
+    sourceHash: binding.sourceHash,
+    moduleSpecifier: binding.moduleSpecifier,
+    resolvedModulePath: binding.resolvedModulePath,
+    importKind: binding.importKind,
+    importedName: binding.importedName,
+    localName: binding.localName
+  });
+}
+
+function cssModuleUseSiteSignature(site) {
+  return JSON.stringify({
+    jsSourcePath: site.jsSourcePath,
+    jsSourceHash: site.jsSourceHash,
+    exportName: site.exportName,
+    useSiteKind: site.useSiteKind,
+    accessKind: site.accessKind,
+    receiverLocalName: site.receiverLocalName,
+    localReferenceName: site.localReferenceName,
+    expressionText: site.expressionText,
+    sourceSpan: semanticSpanForHash(site.sourceSpan),
+    conditionalRuntimePresence: site.conditionalRuntimePresence
+  });
+}
+
+function cssModuleUseSiteBlockerSignature(blocker) {
+  return JSON.stringify({
+    sourcePath: blocker.sourcePath,
+    sourceHash: blocker.sourceHash,
+    moduleSpecifier: blocker.moduleSpecifier,
+    localName: blocker.localName,
+    expressionText: blocker.expressionText,
+    reasonCode: blocker.reasonCode,
+    writeOperation: blocker.writeOperation,
+    sourceSpan: semanticSpanForHash(blocker.sourceSpan)
+  });
+}
+
+function stableStringCompare(left, right) { return left.localeCompare(right); }
+
 function cssModuleExportHash(binding, exportName) {
   if (!exportName || !Array.isArray(binding.cssModuleExportNames) || !binding.cssModuleExportNames.includes(exportName)) return undefined;
   return hashSemanticValue({ kind: 'frontier.lang.cssModuleExport.v1', cssModuleHash: binding.cssModuleHash, exportName });
@@ -260,13 +310,4 @@ function uniqueSortedStrings(values) {
   return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))].sort();
 }
 
-export {
-  cssModuleAccessBlocker,
-  cssModuleBindingBlocker,
-  cssModuleImportBindingRecord,
-  cssModuleMissingExportBlockers,
-  cssModulePropBlocker,
-  cssModuleTransformBlockers,
-  cssModuleUseSiteGraphRecords,
-  cssModuleUseSiteRecord
-};
+export { cssModuleAccessBlocker, cssModuleBindingBlocker, cssModuleImportBindingRecord, cssModuleMissingExportBlockers, cssModulePropBlocker, cssModuleTransformBlockers, cssModuleUseSiteGraphRecords, cssModuleUseSiteRecord };

package/dist/js-ts-safe-project-merge-css-module-proofs.js

@@ -0,0 +1,318 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { parseCssSemanticSheet } from '@shapeshift-labs/frontier-lang-css';
+import { createJsTsProjectSafeMergeGraphArtifacts } from './js-ts-safe-project-merge-graph.js';
+import { hashText, safeId } from './js-ts-safe-project-merge-core.js';
+import { importNativeSource } from './internal/index-impl/importNativeSource.js';
+
+const CssModulePathPattern = /\.module\.css(?:[?#].*)?$/i;
+const CssModuleContractProofGap = 'css-module-contract-source-proof-unproved';
+
+function createProjectCssModuleMergeEvidence(input, files, projectId) {
+  const cssModuleFiles = files.filter((file) => isCssModulePath(file.sourcePath));
+  if (!cssModuleFiles.length || input.disableProjectCssModuleProofSynthesis === true) return undefined;
+  const proofFiles = projectCssModuleProofFiles(files, input);
+  if (!proofFiles.length || !projectJsTsSourcesStable(files, input)) return {
+    status: 'blocked',
+    reasonCode: 'css-module-js-ts-output-graph-unproved',
+    graphsByPath: new Map(),
+    graphArtifacts: undefined
+  };
+  const cssImports = proofFiles
+    .filter((file) => isCssModulePath(file.sourcePath))
+    .map((file) => cssModuleProofImport(input, file))
+    .filter(Boolean);
+  const graphArtifacts = createJsTsProjectSafeMergeGraphArtifacts({
+    ...input,
+    includeOutputProjectSymbolGraph: true,
+    outputProjectImports: cssImports
+  }, proofFiles, `${projectId}_css_module_project_proof`);
+  const graphs = graphArtifacts?.projectSymbolGraph?.cssModuleUseSiteGraphs ?? [];
+  return {
+    status: 'ready',
+    graphsByPath: new Map(graphs.map((graph) => [graph.cssModuleSourcePath, graph])),
+    graphArtifacts
+  };
+}
+
+function projectCssModuleMergeOptionsForFile(evidence, sourcePath) {
+  const graph = evidence?.graphsByPath?.get(sourcePath);
+  if (!graph?.jsTsUseSiteGraphHash) return {};
+  return {
+    jsTsUseSiteGraphHash: graph.jsTsUseSiteGraphHash,
+    projectCssModuleUseSiteGraphHash: graph.graphHash,
+    projectCssModuleUseSiteGraphStatus: graph.status
+  };
+}
+
+function projectCssModuleProofOptionsForBlockedMerge(input) {
+  const { evidence, sourcePath, mergeOptions, firstResult, base, worker, head } = input;
+  if (!isCssModulePath(sourcePath) || !firstResult?.candidateMergedSourceHash) return undefined;
+  if (!hasOnlyCssModuleContractProofGap(firstResult)) return missingTransformProofBlockedResult(input);
+  const graph = evidence?.graphsByPath?.get(sourcePath);
+  const transformConflictResult = missingTransformProofBlockedResult(input);
+  if (transformConflictResult) return transformConflictResult;
+  if (graph?.status !== 'ready' || !graph.jsTsUseSiteGraphHash) return undefined;
+  const generatedClassNameMapHash = cssModuleGeneratedClassNameMapHash(mergeOptions);
+  if (!generatedClassNameMapHash) return undefined;
+  const proofHashes = cssModuleContractProofHashes({
+    sourcePath,
+    base,
+    worker,
+    head,
+    output: firstResult.candidateMergedSourceText,
+    generatedClassNameMapHash,
+    jsTsUseSiteGraphHash: graph.jsTsUseSiteGraphHash,
+    mergeOptions
+  });
+  if (!proofHashes.length) return undefined;
+  return {
+    mergeOptions: {
+      cssModuleContractProofs: proofHashes.map((proof, index) => ({
+        id: `project_css_module_contract_${safeId(sourcePath)}_${index}`,
+        kind: 'css-source-bound-module-contract-proof',
+        status: 'passed',
+        sourcePath,
+        baseSourceHash: hashText(base),
+        workerSourceHash: hashText(worker),
+        headSourceHash: hashText(head),
+        outputSourceHash: firstResult.candidateMergedSourceHash,
+        moduleHash: proof.moduleHash,
+        generatedClassNameMapHash,
+        jsTsUseSiteGraphHash: graph.jsTsUseSiteGraphHash,
+        cssModuleCompositionGraphHash: proof.cssModuleCompositionGraphHash,
+        icssGraphHash: proof.icssGraphHash,
+        bundlerTransformHash: firstString(mergeOptions.bundlerTransformHash, mergeOptions.cssModuleBundlerTransformHash),
+        sourceMapProofHash: firstString(mergeOptions.sourceMapProofHash, mergeOptions.cssModuleSourceMapProofHash),
+        proofLevel: 'css-module-contract-project-source-bound'
+      }))
+    }
+  };
+}
+
+function projectCssModuleOutputProjectImports(evidence, fileResults, input) {
+  if (!evidence) return [];
+  return fileResults
+    .filter((file) => file.status === 'merged' && isCssModulePath(file.sourcePath) && typeof file.outputSourceText === 'string')
+    .map((file) => cssModuleOutputProjectImport(evidence, file, input))
+    .filter(Boolean);
+}
+
+function mergeOutputProjectImports(input, imports) {
+  if (!imports.length) return input;
+  return {
+    ...input,
+    outputProjectImports: [...normalizeProjectImports(input.outputProjectImports ?? input.projectGraphImports?.output), ...imports]
+  };
+}
+
+function missingTransformProofBlockedResult({ firstResult, sourcePath, mergeOptions }) {
+  if (!firstResult || !hasOnlyCssModuleContractProofGap(firstResult)) return undefined;
+  const conflicts = [];
+  if (!firstString(mergeOptions.bundlerTransformHash, mergeOptions.cssModuleBundlerTransformHash)) {
+    conflicts.push(cssModuleProofConflict(firstResult.id, sourcePath, 'css-module-bundler-transform-identity-unproved'));
+  }
+  if (!firstString(mergeOptions.sourceMapProofHash, mergeOptions.cssModuleSourceMapProofHash)) {
+    conflicts.push(cssModuleProofConflict(firstResult.id, sourcePath, 'css-module-source-map-proof-unproved'));
+  }
+  if (!conflicts.length) return undefined;
+  const mergedConflicts = [...(firstResult.conflicts ?? []), ...conflicts];
+  return {
+    result: {
+      ...firstResult,
+      conflicts: mergedConflicts,
+      admission: {
+        ...(firstResult.admission ?? {}),
+        reasonCodes: uniqueStrings([
+          ...(firstResult.admission?.reasonCodes ?? []),
+          ...conflicts.map((conflict) => conflict.details.reasonCode)
+        ])
+      }
+    }
+  };
+}
+
+function cssModuleContractProofHashes(input) {
+  const options = {
+    sourcePath: input.sourcePath,
+    generatedClassNameMapHash: input.generatedClassNameMapHash,
+    jsTsUseSiteGraphHash: input.jsTsUseSiteGraphHash,
+    cssModuleCompositionGraphHash: firstString(input.mergeOptions.cssModuleCompositionGraphHash),
+    icssGraphHash: firstString(input.mergeOptions.icssGraphHash)
+  };
+  const sheets = [
+    parseCssModuleSheet(input.base, options),
+    parseCssModuleSheet(input.worker, options),
+    parseCssModuleSheet(input.head, options),
+    parseCssModuleSheet(input.output, options)
+  ].filter(Boolean);
+  const hashes = new Map();
+  for (const sheet of sheets) {
+    const cssModules = sheet.cssModules;
+    if (!cssModules?.moduleHash) continue;
+    hashes.set(cssModules.moduleHash, {
+      moduleHash: cssModules.moduleHash,
+      cssModuleCompositionGraphHash: cssModules.cssModuleCompositionGraphHash,
+      icssGraphHash: cssModules.icssGraphHash
+    });
+  }
+  return [...hashes.values()];
+}
+
+function parseCssModuleSheet(sourceText, options) {
+  if (typeof sourceText !== 'string') return undefined;
+  try {
+    return parseCssSemanticSheet(sourceText, options);
+  } catch {
+    return undefined;
+  }
+}
+
+function cssModuleGeneratedClassNameMapHash(mergeOptions) {
+  return firstString(mergeOptions.generatedClassNameMapHash, mergeOptions.cssModuleGeneratedClassNameMapHash)
+    ?? (mergeOptions.generatedClassNameMap ? hashSemanticValue({
+      kind: 'frontier.lang.css.modules.generatedClassNameMap.v1',
+      generatedClassNameMap: mergeOptions.generatedClassNameMap
+    }) : undefined);
+}
+
+function hasOnlyCssModuleContractProofGap(result) {
+  const conflicts = result?.conflicts ?? [];
+  return conflicts.length > 0 && conflicts.every((conflict) => conflict.details?.reasonCode === CssModuleContractProofGap);
+}
+
+function cssModuleProofImport(input, file) {
+  const mergeOptions = cssMergeOptionsForProjectFile(input, file.sourcePath);
+  return importNativeSource({
+    language: 'css',
+    sourcePath: file.sourcePath,
+    sourceText: file.sourceText,
+    sourceHash: file.sourceHash,
+    metadata: {
+      generatedClassNameMap: mergeOptions.generatedClassNameMap,
+      generatedClassNameMapHash: cssModuleGeneratedClassNameMapHash(mergeOptions),
+      cssModuleCompositionGraphHash: mergeOptions.cssModuleCompositionGraphHash,
+      icssGraphHash: mergeOptions.icssGraphHash,
+      bundlerTransformHash: firstString(mergeOptions.bundlerTransformHash, mergeOptions.cssModuleBundlerTransformHash),
+      sourceMapProofHash: firstString(mergeOptions.sourceMapProofHash, mergeOptions.cssModuleSourceMapProofHash)
+    }
+  });
+}
+
+function cssModuleOutputProjectImport(evidence, file, input) {
+  const mergeOptions = cssMergeOptionsForProjectFile(input, file.sourcePath);
+  const graph = evidence.graphsByPath?.get(file.sourcePath);
+  const proof = file.result?.cssModuleContractProofs?.[0] ?? file.result?.admission?.cssModuleContractProofs?.[0];
+  return importNativeSource({
+    language: 'css',
+    sourcePath: file.sourcePath,
+    sourceText: file.outputSourceText,
+    sourceHash: file.outputHash,
+    metadata: {
+      generatedClassNameMap: mergeOptions.generatedClassNameMap,
+      generatedClassNameMapHash: proof?.generatedClassNameMapHash ?? cssModuleGeneratedClassNameMapHash(mergeOptions),
+      jsTsUseSiteGraphHash: proof?.jsTsUseSiteGraphHash ?? graph?.jsTsUseSiteGraphHash,
+      cssModuleCompositionGraphHash: proof?.cssModuleCompositionGraphHash ?? mergeOptions.cssModuleCompositionGraphHash,
+      icssGraphHash: proof?.icssGraphHash ?? mergeOptions.icssGraphHash,
+      bundlerTransformHash: firstString(mergeOptions.bundlerTransformHash, mergeOptions.cssModuleBundlerTransformHash),
+      sourceMapProofHash: firstString(mergeOptions.sourceMapProofHash, mergeOptions.cssModuleSourceMapProofHash)
+    }
+  });
+}
+
+function normalizeProjectImports(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.filter(Boolean);
+  if (value instanceof Map) return [...value.values()].filter(Boolean);
+  if (typeof value === 'object') return Object.values(value).filter(Boolean);
+  return [];
+}
+
+function projectCssModuleProofFiles(files, input) {
+  return files.flatMap((file) => {
+    const sourceText = isCssModulePath(file.sourcePath)
+      ? cssModuleProofSourceText(file)
+      : stableJsTsSourceText(file, input);
+    if (typeof sourceText !== 'string') return [];
+    return [{
+      sourcePath: file.sourcePath,
+      language: file.language ?? languageForPath(file.sourcePath, input),
+      sourceText,
+      sourceHash: hashText(sourceText)
+    }];
+  });
+}
+
+function projectJsTsSourcesStable(files, input) {
+  return files
+    .filter((file) => isJsTsLanguage(file.language ?? languageForPath(file.sourcePath, input)))
+    .every((file) => typeof stableJsTsSourceText(file, input) === 'string');
+}
+
+function cssModuleProofSourceText(file) {
+  return firstString(file.workerSourceText, file.headSourceText, file.baseSourceText);
+}
+
+function stableJsTsSourceText(file, input) {
+  if (!isJsTsLanguage(file.language ?? languageForPath(file.sourcePath, input))) return undefined;
+  const base = file.baseSourceText;
+  const worker = file.workerDeleted ? undefined : file.workerSourceText ?? base;
+  const head = file.headDeleted ? undefined : file.headSourceText ?? base;
+  if (typeof worker === 'string' && worker === head) return worker;
+  if (typeof base === 'string' && base === worker && base === head) return base;
+  return undefined;
+}
+
+function cssMergeOptionsForProjectFile(input, sourcePath) {
+  const byPath = input.cssMergeOptionsByPath ?? input.styleMergeOptionsByPath;
+  return {
+    ...(input.cssMergeOptions ?? input.styleMergeOptions),
+    ...(byPath?.[sourcePath] ?? {})
+  };
+}
+
+function cssModuleProofConflict(id, sourcePath, reasonCode) {
+  return {
+    code: 'css-module-project-proof-blocked',
+    gateId: 'css-semantic-merge',
+    sourcePath,
+    details: {
+      reasonCode,
+      conflictKey: `css#${id}#${reasonCode}#${sourcePath ?? 'source'}`,
+      proofGap: {
+        code: reasonCode,
+        status: 'not-claimed',
+        failClosed: true,
+        semanticEquivalenceClaim: false
+      }
+    }
+  };
+}
+
+function isCssModulePath(path) {
+  return CssModulePathPattern.test(String(path ?? ''));
+}
+
+function languageForPath(sourcePath, input) {
+  const path = String(sourcePath ?? '').toLowerCase();
+  if (path.endsWith('.css')) return 'css';
+  if (path.endsWith('.tsx')) return 'tsx';
+  if (path.endsWith('.jsx')) return 'jsx';
+  if (path.endsWith('.ts') || path.endsWith('.mts') || path.endsWith('.cts')) return 'typescript';
+  if (path.endsWith('.js') || path.endsWith('.mjs') || path.endsWith('.cjs')) return 'javascript';
+  return input.language;
+}
+
+function isJsTsLanguage(language) {
+  return ['javascript', 'typescript', 'jsx', 'tsx', 'js', 'ts'].includes(String(language ?? '').toLowerCase());
+}
+
+function firstString(...values) {
+  for (const value of values) if (value !== undefined && value !== null && String(value)) return String(value);
+  return undefined;
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+export { createProjectCssModuleMergeEvidence, mergeOutputProjectImports, projectCssModuleMergeOptionsForFile, projectCssModuleOutputProjectImports, projectCssModuleProofOptionsForBlockedMerge };

package/dist/js-ts-safe-project-merge-html-css.js

@@ -2,6 +2,7 @@ import { safeMergeCssSource } from '@shapeshift-labs/frontier-lang-css';
 import { safeMergeHtmlSource } from '@shapeshift-labs/frontier-lang-html';
 import { compactRecord } from './js-ts-safe-merge-context.js';
 import { hashText, safeId, uniqueStrings } from './js-ts-safe-project-merge-core.js';
+import { projectCssModuleMergeOptionsForFile, projectCssModuleProofOptionsForBlockedMerge } from './js-ts-safe-project-merge-css-module-proofs.js';
 import { htmlRuntimeBoundaryChanges, htmlRuntimeBoundaryProofForChange, htmlRuntimeBoundaryProofRecord, htmlRuntimeBoundaryProvenResult } from './js-ts-safe-project-merge-html-runtime-boundaries.js';
 
 function projectFileLanguage(file, input) {
@@ -9,15 +10,26 @@ function projectFileLanguage(file, input) {
 }
 
 function maybeMergeHtmlCssProjectFile(options) {
-  const { file, input, projectId, context, base, worker, head, sourceInput } = options;
+  const { file, input, projectId, context, base, worker, head, sourceInput, projectCssModuleMergeEvidence } = options;
   const language = String(context.language ?? '').toLowerCase();
   const merge = language === 'html' ? safeMergeHtmlSource : language === 'css' ? safeMergeCssSource : undefined;
   if (!merge) return undefined;
   const resultId = `${projectId}_${safeId(file.sourcePath)}`;
-  const mergeOptions = htmlCssMergeOptionsForProjectFile(input, file.sourcePath, language);
+  const mergeOptions = {
+    ...htmlCssMergeOptionsForProjectFile(input, file.sourcePath, language),
+    ...(language === 'css' ? projectCssModuleMergeOptionsForFile(projectCssModuleMergeEvidence, file.sourcePath) : {})
+  };
   const runtimeBoundaryProofs = language === 'html' ? htmlRuntimeBoundaryProofCandidates(input, file.sourcePath, mergeOptions) : [];
   const runtimeBoundaryMergeOptions = runtimeBoundaryProofs.length ? { htmlRuntimeBoundaryProofs: runtimeBoundaryProofs, htmlSourceBoundRuntimeBoundaryProofs: runtimeBoundaryProofs } : {};
-  const result = merge({ ...sourceInput, ...mergeOptions, ...context, ...runtimeBoundaryMergeOptions, id: resultId, baseSourceText: base, workerSourceText: worker, headSourceText: head });
+  let result = merge({ ...sourceInput, ...mergeOptions, ...context, ...runtimeBoundaryMergeOptions, id: resultId, baseSourceText: base, workerSourceText: worker, headSourceText: head, includeBlockedMergeCandidate: language === 'css' || sourceInput.includeBlockedMergeCandidate === true });
+  if (language === 'css' && result.status === 'blocked') {
+    const proofOptions = projectCssModuleProofOptionsForBlockedMerge({ evidence: projectCssModuleMergeEvidence, sourcePath: file.sourcePath, mergeOptions, firstResult: result, base, worker, head });
+    if (proofOptions?.mergeOptions) {
+      result = merge({ ...sourceInput, ...mergeOptions, ...proofOptions.mergeOptions, ...context, id: resultId, baseSourceText: base, workerSourceText: worker, headSourceText: head });
+    } else if (proofOptions?.result) {
+      result = proofOptions.result;
+    }
+  }
   const admittedResult = language === 'html' && result.status === 'merged'
     ? blockHtmlProofGapChanges({ result, id: resultId, sourcePath: file.sourcePath, base, worker, head, runtimeBoundaryProofs }) ?? result
     : result;

package/dist/js-ts-safe-project-merge.js

@@ -20,6 +20,7 @@ import { applyProjectSymbolRenameClassifications, classifyProjectSymbolRenames }
 import { applyProjectSplitMergeClassifications, classifyProjectSplitMerges } from './js-ts-safe-project-merge-split-merge.js';
 import { projectConfidence, projectEvidence, projectSummary, projectSummaryWithConfidenceEvidence } from './js-ts-safe-project-merge-summary.js';
 import { maybeMergeHtmlCssProjectFile, projectFileLanguage } from './js-ts-safe-project-merge-html-css.js';
+import { createProjectCssModuleMergeEvidence, mergeOutputProjectImports, projectCssModuleOutputProjectImports } from './js-ts-safe-project-merge-css-module-proofs.js';
 
 function safeMergeJsTsProject(input = {}) {
   const id = String(input.id ?? 'js_ts_project_safe_merge');
@@ -27,7 +28,8 @@ function safeMergeJsTsProject(input = {}) {
   const projectMoveRenames = classifyProjectMoveRenames(files, input, id);
   const projectSymbolRenames = classifyProjectSymbolRenames(files, input);
   const projectSplitMerges = classifyProjectSplitMerges(files);
-  const mergedFileResults = files.map((file) => mergeProjectFile(file, input, id, projectSymbolRenames));
+  const projectCssModuleMergeEvidence = createProjectCssModuleMergeEvidence(input, files, id);
+  const mergedFileResults = files.map((file) => mergeProjectFile(file, input, id, projectSymbolRenames, projectCssModuleMergeEvidence));
   const fileResults = applyProjectSplitMergeClassifications(
     applyProjectSymbolRenameClassifications(
       applyProjectMoveRenameClassifications(mergedFileResults, projectMoveRenames, files, input),
@@ -63,6 +65,7 @@ function safeMergeJsTsProject(input = {}) {
       parserTriviaEvidence: outputParserTriviaEvidence(inputFilesByPath.get(file.sourcePath), file),
       operation: file.operation
     }));
+  const graphInput = mergeOutputProjectImports(input, projectCssModuleOutputProjectImports(projectCssModuleMergeEvidence, fileResults, input));
   const outputDeclarationGate = blockedFiles.length === 0
     ? createJsTsProjectMergeDeclarationGate(input, outputFiles, id)
     : undefined;
@@ -70,10 +73,10 @@ function safeMergeJsTsProject(input = {}) {
     ? createJsTsProjectMergeDeclarationEmitParityProof(input, files, outputFiles, id)
     : undefined;
   const projectGraphDelta = blockedFiles.length === 0 && input.includeProjectGraphDelta
-    ? createJsTsProjectSafeMergeGraphDelta(input, files, outputFiles, id)
+    ? createJsTsProjectSafeMergeGraphDelta(graphInput, files, outputFiles, id)
     : undefined;
   const graphArtifacts = projectGraphDelta?.stages?.output ?? (blockedFiles.length === 0 && input.includeOutputProjectSymbolGraph
-    ? createJsTsProjectSafeMergeGraphArtifacts(input, outputFiles, id)
+    ? createJsTsProjectSafeMergeGraphArtifacts(graphInput, outputFiles, id)
     : undefined);
   const outputDiagnosticsGate = blockedFiles.length === 0
     ? createJsTsProjectMergeDiagnosticsGate(input, outputFiles, id, { fileResults })
@@ -212,7 +215,7 @@ function outputParserTriviaEvidence(file, resultFile) {
     : undefined;
 }
 
-function mergeProjectFile(file, input, projectId, projectSymbolRenames) {
+function mergeProjectFile(file, input, projectId, projectSymbolRenames, projectCssModuleMergeEvidence) {
   const base = file.baseSourceText;
   const worker = file.workerDeleted ? undefined : file.workerSourceText ?? base;
   const head = file.headDeleted ? undefined : file.headSourceText ?? base;
@@ -243,7 +246,7 @@ function mergeProjectFile(file, input, projectId, projectSymbolRenames) {
       ? syntheticFile(file, context, undefined, 'head-deleted-worker-unchanged')
       : blockedFile(file, context, 'head-file-delete-conflict');
   }
-  const nonJsTsMerge = maybeMergeHtmlCssProjectFile({ file, input, projectId, context, base, worker, head, sourceInput: sourceMergeInputForProjectFile(input) });
+  const nonJsTsMerge = maybeMergeHtmlCssProjectFile({ file, input, projectId, context, base, worker, head, sourceInput: sourceMergeInputForProjectFile(input), projectCssModuleMergeEvidence });
   if (nonJsTsMerge) return nonJsTsMerge;
   const result = safeMergeJsTsSource({
     ...sourceMergeInputForProjectFile(input),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.181",
+  "version": "0.2.183",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",
@@ -63,7 +63,7 @@
   "dependencies": {
     "@shapeshift-labs/frontier-lang-c": "0.2.9",
     "@shapeshift-labs/frontier-lang-checker": "0.3.8",
-    "@shapeshift-labs/frontier-lang-css": "^0.1.18",
+    "@shapeshift-labs/frontier-lang-css": "^0.1.21",
     "@shapeshift-labs/frontier-lang-html": "^0.1.14",
     "@shapeshift-labs/frontier-lang-javascript": "0.2.9",
     "@shapeshift-labs/frontier-lang-kernel": "0.3.12",