@shapeshift-labs/frontier-lang-compiler 0.2.196 → 0.2.198

package/README.md

@@ -611,7 +611,8 @@ Recent residual closures represented in the matrix shards:
 - Module/export/import graph now records no-substitution template dynamic imports and parser-backed CommonJS helper `require` templates as static module edges while keeping expression templates proof-required.
 - Module/export/import graph now records no-substitution/static template host dependencies for `new URL`, workers, resolver calls, and `importScripts` while leaving expression templates unsupported.
 - Module/export/import graph now emits dynamic host dependency targets as `<host-dependency>` edges with expression hashes and proof-required unresolved evidence instead of omitting them.
-- CSS Modules graph records now infer local class export evidence, source-local composition graph hashes, and export-only ICSS graph hashes from `.module.css` source via `@shapeshift-labs/frontier-lang-css`, while file composition graphs, ICSS imports, generated class-name maps, bundler transform identity, source-map proof, dynamic member access, writes, and helper-call equivalence remain fail-closed without host evidence.
+- CSS Modules graph records now infer local class export evidence, source-local composition graph hashes, export-only ICSS graph hashes, project-source graph hashes for cross-file `composes` / ICSS imports when every referenced `.module.css` source is present and source-inferred, and source-bounded class helper token graph hashes for single top-level `className` helper calls whose CSS Module reads are statically enumerable; package/bundler-only composition, unresolved ICSS imports, generated class-name maps, bundler transform identity, source-map proof, dynamic member access, writes, nested helper calls, and arbitrary helper runtime equivalence remain fail-closed without host evidence.
+- CSS Modules use-site graph evidence now suppresses `css-module-helper-call-unproved` only for source-bounded helper calls with deterministic token enumeration, while preserving transform proof blockers and keeping nested calls/dynamic keys on review routes.
 - Type/public API graph now includes bounded TypeChecker assignability oracle proof for simple public type aliases while keeping semantic/runtime equivalence claims false.
 - JSX/TSX graph now records same-file and project-local named/default/barrel-import static component prop passthrough as `jsx-render-component-prop-flow-static-passthrough-evidence` and blocks dynamic callsite values with `jsx-render-component-prop-flow-dynamic-value-unsupported`.
 - JSX/TSX graph now records static `memo` / `forwardRef` / `observer` / `React.lazy` component wrapper chains as component-wrapper render-risk evidence while keeping render, lazy-load, and runtime equivalence explicitly unproved.

package/dist/declarations/native-project-css-modules.d.ts

@@ -23,7 +23,9 @@ export interface NativeProjectSymbolGraphCssModuleImportBindingRecord {
   readonly generatedClassNameMapHash?: string;
   readonly jsTsUseSiteGraphHash?: string;
   readonly cssModuleCompositionGraphHash?: string;
+  readonly cssModuleCompositionGraphSource?: 'supplied' | 'source-local' | 'project-source' | string;
   readonly icssGraphHash?: string;
+  readonly icssGraphSource?: 'supplied' | 'source-export-only' | 'project-source' | string;
   readonly bundlerTransformHash?: string;
   readonly sourceMapProofHash?: string;
   readonly signatureHash?: string;
@@ -49,6 +51,13 @@ export interface NativeProjectSymbolGraphCssModuleUseSiteRecord {
   readonly jsxPropRecordId?: string;
   readonly scopeReferenceRecordId?: string;
   readonly conditionalRuntimePresence?: boolean;
+  readonly helperCallProofLevel?: 'css-module-class-helper-source-bounded-token-graph' | string;
+  readonly helperCallGraphHash?: string;
+  readonly helperCalleeName?: string;
+  readonly helperCalleeRoot?: string;
+  readonly helperCalleeSource?: 'known-package-import' | 'local-name-convention' | string;
+  readonly helperModuleSpecifier?: string;
+  readonly helperImportEdgeId?: string;
   readonly signatureHash?: string;
 }
 
@@ -85,6 +94,13 @@ export interface NativeProjectSymbolGraphCssModuleUseSiteGraphRecord {
   readonly blockerCount: number;
   readonly generatedClassNameMapHash?: string;
   readonly cssModuleExportNamesHash?: string;
+  readonly cssModuleCompositionGraphHash?: string;
+  readonly cssModuleCompositionGraphSource?: 'supplied' | 'source-local' | 'project-source' | string;
+  readonly icssGraphHash?: string;
+  readonly icssGraphSource?: 'supplied' | 'source-export-only' | 'project-source' | string;
+  readonly cssModuleClassNameHelperGraphHash?: string;
+  readonly cssModuleClassNameHelperProofLevels?: readonly string[];
+  readonly cssModuleClassNameHelperSources?: readonly string[];
   readonly bundlerTransformHash?: string;
   readonly sourceMapProofHash?: string;
   readonly status: 'ready' | 'blocked' | string;

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

@@ -0,0 +1,219 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord, localKey } from './projectSymbolGraphCssModuleUtils.js';
+import { cssModuleMemberAccess, identifierOccurrences } from './projectSymbolGraphCssModuleMemberAccess.js';
+
+const KnownClassHelperModules = new Set(['clsx', 'classnames']);
+const LocalClassHelperNames = new Set(['cx', 'cn', 'clsx', 'classnames', 'classNames']);
+
+function cssModuleClassHelperCalleeEvidence(importEdges = []) {
+  const result = new Map();
+  for (const edge of importEdges ?? []) {
+    if (!edge?.sourcePath || !edge.localName || !KnownClassHelperModules.has(edge.moduleSpecifier)) continue;
+    if (String(edge.importKind ?? '').startsWith('type')) continue;
+    result.set(localKey(edge.sourcePath, edge.localName), compactRecord({
+      helperCalleeName: edge.localName,
+      helperCalleeRoot: edge.localName,
+      helperCalleeSource: 'known-package-import',
+      helperModuleSpecifier: edge.moduleSpecifier,
+      helperImportKind: edge.importKind,
+      helperImportedName: edge.importedName,
+      helperImportEdgeId: edge.id
+    }));
+  }
+  return result;
+}
+
+function cssModuleClassHelperCallProof(expressionText, binding, prop, helperCalleeEvidence) {
+  const call = readTopLevelClassHelperCall(expressionText);
+  if (!call) return undefined;
+  const calleeEvidence = helperCalleeEvidence.get(localKey(prop.sourcePath, call.calleeRoot))
+    ?? localClassHelperCalleeEvidence(call);
+  if (!calleeEvidence) return undefined;
+  if (classHelperCallHasUnsafeSyntax(expressionText, call.open)) return undefined;
+  const accessRecords = cssModuleHelperAccessRecords(expressionText, binding);
+  if (!accessRecords.length) return undefined;
+  const helperCallGraphHash = hashSemanticValue({
+    kind: 'frontier.lang.cssModuleClassNameHelperCallGraph.v1',
+    proofLevel: 'css-module-class-helper-source-bounded-token-graph',
+    sourcePath: prop.sourcePath,
+    sourceHash: prop.sourceHash,
+    cssModuleImportBindingId: binding.id,
+    cssModuleSourcePath: binding.cssModuleSourcePath,
+    cssModuleHash: binding.cssModuleHash,
+    jsxPropRecordId: prop.id,
+    helperCalleeName: call.calleeText,
+    helperCalleeRoot: call.calleeRoot,
+    helperCalleeSource: calleeEvidence.helperCalleeSource,
+    helperModuleSpecifier: calleeEvidence.helperModuleSpecifier,
+    expressionText,
+    accessRecords
+  });
+  return compactRecord({
+    proofLevel: 'css-module-class-helper-source-bounded-token-graph',
+    helperCallGraphHash,
+    helperCalleeName: call.calleeText,
+    helperCalleeRoot: call.calleeRoot,
+    helperCalleeSource: calleeEvidence.helperCalleeSource,
+    helperModuleSpecifier: calleeEvidence.helperModuleSpecifier,
+    helperImportEdgeId: calleeEvidence.helperImportEdgeId
+  });
+}
+
+function cssModuleHelperArgumentIsConditional(expressionText, occurrenceStart) {
+  const prefix = expressionText.slice(0, occurrenceStart);
+  const suffix = expressionText.slice(occurrenceStart);
+  const lastComma = prefix.lastIndexOf(',');
+  const argumentPrefix = prefix.slice(lastComma + 1);
+  const nextComma = suffix.indexOf(',');
+  const argumentText = `${argumentPrefix}${nextComma === -1 ? suffix : suffix.slice(0, nextComma)}`;
+  return /(?:&&|\|\||\?)/.test(argumentText);
+}
+
+function cssModuleMemberWriteOperation(sourceText, start, end) {
+  if (hasPrefixUpdateOperator(sourceText, start)) return 'update';
+  let index = end;
+  while (index < sourceText.length && /\s/.test(sourceText[index])) index += 1;
+  if (sourceText.slice(index, index + 2) === '++' || sourceText.slice(index, index + 2) === '--') return 'update';
+  return assignmentOperatorAt(sourceText, index) ? 'assignment' : undefined;
+}
+
+function localClassHelperCalleeEvidence(call) {
+  return LocalClassHelperNames.has(call.calleeRoot)
+    ? { helperCalleeName: call.calleeText, helperCalleeRoot: call.calleeRoot, helperCalleeSource: 'local-name-convention' }
+    : undefined;
+}
+
+function cssModuleHelperAccessRecords(expressionText, binding) {
+  const records = [];
+  for (const occurrence of identifierOccurrences(expressionText, binding.localName)) {
+    const access = cssModuleMemberAccess(expressionText, occurrence.end);
+    if (!access || access.status === 'blocked') return [];
+    if (cssModuleMemberWriteOperation(expressionText, occurrence.start, access.end)) return [];
+    records.push({
+      receiverLocalName: binding.localName,
+      exportName: access.memberName,
+      accessKind: access.accessKind,
+      expressionText: expressionText.slice(occurrence.start, access.end),
+      start: occurrence.start,
+      end: access.end,
+      conditionalRuntimePresence: cssModuleHelperArgumentIsConditional(expressionText, occurrence.start) || undefined
+    });
+  }
+  return records;
+}
+
+function readTopLevelClassHelperCall(expressionText) {
+  const value = String(expressionText ?? '').trim();
+  const callee = /^(?:[A-Za-z_$][\w$]*|this)(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)*/.exec(value)?.[0];
+  if (!callee) return undefined;
+  let index = callee.length;
+  while (index < value.length && /\s/.test(value[index])) index += 1;
+  if (value[index] !== '(') return undefined;
+  const close = findMatchingDelimiter(value, index, '(', ')');
+  if (close === -1) return undefined;
+  let tail = close + 1;
+  while (tail < value.length && /\s/.test(value[tail])) tail += 1;
+  if (tail !== value.length) return undefined;
+  const calleeText = callee.replace(/\s+/g, '');
+  return { calleeText, calleeRoot: calleeText.split(/[?.]+/)[0], open: index };
+}
+
+function classHelperCallHasUnsafeSyntax(expressionText, topLevelOpen) {
+  const value = String(expressionText ?? '');
+  if (value.includes('...') || value.includes('=>') || /\b(?:function|class|new|await|yield)\b/.test(value)) return true;
+  if (/`[\s\S]*\$\{[\s\S]*`/.test(value)) return true;
+  if (/(?:\+\+|--|\*\*=|>>>=|<<=|>>=|&&=|\|\|=|\?\?=|\+=|-=|\*=|\/=|%=|&=|\|=|\^=)/.test(value)) return true;
+  if (/(^|[^=!<>])=(?!=|>)/.test(value)) return true;
+  for (const callOpen of callOpenIndexes(value)) if (callOpen !== topLevelOpen) return true;
+  return !delimitersAreBalanced(value);
+}
+
+function callOpenIndexes(sourceText) {
+  const indexes = [];
+  for (let index = 0; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    if (char === '\'' || char === '"' || char === '`') {
+      const end = readQuotedOrStaticTemplateEnd(sourceText, index, char);
+      if (end === -1) return [...indexes, -1];
+      index = end;
+      continue;
+    }
+    if (char !== '(') continue;
+    let before = index - 1;
+    while (before >= 0 && /\s/.test(sourceText[before])) before -= 1;
+    if (before >= 0 && /[A-Za-z0-9_$\].]/.test(sourceText[before])) indexes.push(index);
+  }
+  return indexes;
+}
+
+function delimitersAreBalanced(sourceText) {
+  const stack = [];
+  const pairs = { '(': ')', '[': ']', '{': '}' };
+  for (let index = 0; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    if (char === '\'' || char === '"' || char === '`') {
+      const end = readQuotedOrStaticTemplateEnd(sourceText, index, char);
+      if (end === -1) return false;
+      index = end;
+      continue;
+    }
+    if (pairs[char]) stack.push(pairs[char]);
+    else if ((char === ')' || char === ']' || char === '}') && stack.pop() !== char) return false;
+  }
+  return stack.length === 0;
+}
+
+function findMatchingDelimiter(sourceText, open, openChar, closeChar) {
+  let depth = 0;
+  for (let index = open; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    if (char === '\'' || char === '"' || char === '`') {
+      const end = readQuotedOrStaticTemplateEnd(sourceText, index, char);
+      if (end === -1) return -1;
+      index = end;
+      continue;
+    }
+    if (char === openChar) depth += 1;
+    else if (char === closeChar && --depth === 0) return index;
+  }
+  return -1;
+}
+
+function readQuotedOrStaticTemplateEnd(sourceText, start, quote) {
+  for (let index = start + 1; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    if (char === '\\') {
+      index += 1;
+      continue;
+    }
+    if (quote === '`' && char === '$' && sourceText[index + 1] === '{') return -1;
+    if (char === quote) return index;
+  }
+  return -1;
+}
+
+function assignmentOperatorAt(code, index) {
+  for (const operator of ['>>>=', '**=', '<<=', '>>=', '&&=', '||=', '??=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '=']) {
+    if (!code.startsWith(operator, index)) continue;
+    if (operator === '=' && (code[index + 1] === '=' || code[index + 1] === '>')) return undefined;
+    return operator;
+  }
+  return undefined;
+}
+
+function hasPrefixUpdateOperator(code, tokenStart) {
+  let index = tokenStart - 1;
+  while (index >= 0 && /\s/.test(code[index])) index -= 1;
+  const operator = code.slice(index - 1, index + 1);
+  if (operator !== '++' && operator !== '--') return false;
+  let before = index - 2;
+  while (before >= 0 && /\s/.test(code[before])) before -= 1;
+  return before < 0 || !/[A-Za-z0-9_$)\]]/.test(code[before]);
+}
+
+export {
+  cssModuleClassHelperCalleeEvidence,
+  cssModuleClassHelperCallProof,
+  cssModuleHelperArgumentIsConditional,
+  cssModuleMemberWriteOperation
+};

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

@@ -0,0 +1,255 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+function withProjectCssModuleDependencyGraphs(cssSourcesByPath) {
+  const enriched = new Map(cssSourcesByPath);
+  for (const [sourcePath, cssSource] of cssSourcesByPath.entries()) {
+    const cssModuleEvidence = cssSource?.cssModuleEvidence;
+    if (!cssModuleEvidence || cssSource.cssModuleEvidenceSource !== 'inferred-source') continue;
+    const computedCompositionGraphHash = cssModuleEvidence.cssModuleCompositionGraphHash
+      ? undefined
+      : projectCssModuleCompositionGraphHash(sourcePath, enriched);
+    const computedIcssGraphHash = cssModuleEvidence.icssGraphHash
+      ? undefined
+      : projectCssModuleIcssGraphHash(sourcePath, enriched);
+    if (!computedCompositionGraphHash && !computedIcssGraphHash) continue;
+    enriched.set(sourcePath, {
+      ...cssSource,
+      cssModuleEvidence: {
+        ...cssModuleEvidence,
+        cssModuleCompositionGraphHash: computedCompositionGraphHash ?? cssModuleEvidence.cssModuleCompositionGraphHash,
+        cssModuleCompositionGraphSource: computedCompositionGraphHash ? 'project-source' : cssModuleEvidence.cssModuleCompositionGraphSource,
+        icssGraphHash: computedIcssGraphHash ?? cssModuleEvidence.icssGraphHash,
+        icssGraphSource: computedIcssGraphHash ? 'project-source' : cssModuleEvidence.icssGraphSource,
+        proofGaps: cssModuleProofGapsWithout(cssModuleEvidence.proofGaps, [
+          ...(computedCompositionGraphHash ? ['css-module-composition-resolution-unproved'] : []),
+          ...(computedIcssGraphHash ? ['css-module-icss-graph-unproved'] : [])
+        ])
+      }
+    });
+  }
+  return enriched;
+}
+
+function projectCssModuleCompositionGraphHash(sourcePath, cssSourcesByPath) {
+  const source = projectCssModuleSource(sourcePath, cssSourcesByPath);
+  const compositions = cssModuleCompositions(source?.cssModuleEvidence);
+  if (!compositions.length) return undefined;
+  const graph = {
+    sources: new Map(),
+    edges: []
+  };
+  if (!visitCssModuleCompositionSource(sourcePath, cssSourcesByPath, graph, [])) return undefined;
+  return hashSemanticValue({
+    kind: 'frontier.lang.css.modules.projectCompositionGraph.v1',
+    rootSourcePath: sourcePath,
+    sources: sortedValues(graph.sources),
+    edges: graph.edges.sort(stableRecordCompare)
+  });
+}
+
+function visitCssModuleCompositionSource(sourcePath, cssSourcesByPath, graph, stack) {
+  if (graph.sources.has(sourcePath)) return true;
+  if (stack.includes(sourcePath)) return false;
+  const cssSource = projectCssModuleSource(sourcePath, cssSourcesByPath);
+  const evidence = cssSource?.cssModuleEvidence;
+  if (!evidence) return false;
+  const exportNames = cssModuleExportNames(evidence);
+  graph.sources.set(sourcePath, {
+    sourcePath,
+    sourceHash: evidence.sourceHash ?? cssSource.sourceHash,
+    moduleHash: evidence.moduleHash,
+    exportNames
+  });
+  for (const composition of cssModuleCompositions(evidence)) {
+    const sourceKind = composition.sourceKind ?? (composition.source ? 'file' : 'local');
+    if (sourceKind === 'file') {
+      const targetSourcePath = resolveRelativeCssSourcePath(sourcePath, composition.source);
+      const target = projectCssModuleSource(targetSourcePath, cssSourcesByPath);
+      if (!target) return false;
+      const targetExportNames = cssModuleExportNames(target.cssModuleEvidence);
+      if (composition.names?.some((name) => !targetExportNames.includes(name))) return false;
+      graph.edges.push(compositionGraphEdge(composition, {
+        sourcePath,
+        sourceKind,
+        targetSourcePath,
+        targetSourceHash: target.cssModuleEvidence?.sourceHash ?? target.sourceHash,
+        targetModuleHash: target.cssModuleEvidence?.moduleHash
+      }));
+      if (!visitCssModuleCompositionSource(targetSourcePath, cssSourcesByPath, graph, [...stack, sourcePath])) return false;
+      continue;
+    }
+    if (sourceKind !== 'local' && sourceKind !== 'global') return false;
+    graph.edges.push(compositionGraphEdge(composition, { sourcePath, sourceKind }));
+  }
+  return true;
+}
+
+function projectCssModuleIcssGraphHash(sourcePath, cssSourcesByPath) {
+  const source = projectCssModuleSource(sourcePath, cssSourcesByPath);
+  const evidence = source?.cssModuleEvidence;
+  if (!cssModuleIcssImports(evidence).length && !cssModuleIcssExports(evidence).length) return undefined;
+  const graph = {
+    sources: new Map(),
+    imports: [],
+    exports: []
+  };
+  if (!visitCssModuleIcssSource(sourcePath, cssSourcesByPath, graph, [])) return undefined;
+  return hashSemanticValue({
+    kind: 'frontier.lang.css.modules.projectIcssGraph.v1',
+    rootSourcePath: sourcePath,
+    sources: sortedValues(graph.sources),
+    imports: graph.imports.sort(stableRecordCompare),
+    exports: graph.exports.sort(stableRecordCompare)
+  });
+}
+
+function visitCssModuleIcssSource(sourcePath, cssSourcesByPath, graph, stack) {
+  if (graph.sources.has(sourcePath)) return true;
+  if (stack.includes(sourcePath)) return false;
+  const cssSource = projectCssModuleSource(sourcePath, cssSourcesByPath);
+  const evidence = cssSource?.cssModuleEvidence;
+  if (!evidence) return false;
+  graph.sources.set(sourcePath, {
+    sourcePath,
+    sourceHash: evidence.sourceHash ?? cssSource.sourceHash,
+    moduleHash: evidence.moduleHash,
+    icssExportNames: cssModuleIcssExportNames(evidence)
+  });
+  for (const exported of cssModuleIcssExports(evidence)) {
+    graph.exports.push({
+      sourcePath,
+      name: exported.name,
+      value: exported.value,
+      exportHash: exported.exportHash
+    });
+  }
+  for (const imported of cssModuleIcssImports(evidence)) {
+    const targetSourcePath = resolveRelativeCssSourcePath(sourcePath, imported.source);
+    const target = projectCssModuleSource(targetSourcePath, cssSourcesByPath);
+    if (!target) return false;
+    const targetExportNames = cssModuleIcssExportNames(target.cssModuleEvidence);
+    if (!targetExportNames.includes(imported.importedName)) return false;
+    graph.imports.push({
+      sourcePath,
+      targetSourcePath,
+      targetSourceHash: target.cssModuleEvidence?.sourceHash ?? target.sourceHash,
+      targetModuleHash: target.cssModuleEvidence?.moduleHash,
+      importedName: imported.importedName,
+      localName: imported.localName,
+      importHash: imported.importHash
+    });
+    if (!visitCssModuleIcssSource(targetSourcePath, cssSourcesByPath, graph, [...stack, sourcePath])) return false;
+  }
+  return true;
+}
+
+function projectCssModuleSource(sourcePath, cssSourcesByPath) {
+  if (!sourcePath) return undefined;
+  const cssSource = cssSourcesByPath.get(sourcePath);
+  if (!cssSource?.cssModuleEvidence || cssSource.cssModuleEvidenceSource !== 'inferred-source') return undefined;
+  return cssSource;
+}
+
+function compositionGraphEdge(composition, extra) {
+  return {
+    sourcePath: extra.sourcePath,
+    localName: composition.localName,
+    names: [...(composition.names ?? [])],
+    source: composition.source,
+    sourceKind: extra.sourceKind,
+    targetSourcePath: extra.targetSourcePath,
+    targetSourceHash: extra.targetSourceHash,
+    targetModuleHash: extra.targetModuleHash,
+    compositionHash: composition.compositionHash
+  };
+}
+
+function resolveRelativeCssSourcePath(sourcePath, specifier) {
+  if (!sourcePath || !specifier || !String(specifier).startsWith('.')) return undefined;
+  const cleanSpecifier = String(specifier).split(/[?#]/)[0];
+  const parts = String(sourcePath).split('/');
+  parts.pop();
+  for (const part of cleanSpecifier.split('/')) {
+    if (!part || part === '.') continue;
+    if (part === '..') {
+      if (!parts.length) return undefined;
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
+  }
+  return parts.join('/');
+}
+
+function cssModuleCompositions(evidence) {
+  return arrayValue(evidence?.compositions);
+}
+
+function cssModuleIcssImports(evidence) {
+  return [
+    ...arrayValue(evidence?.icssImports),
+    ...arrayValue(evidence?.icss?.imports)
+  ];
+}
+
+function cssModuleIcssExports(evidence) {
+  return [
+    ...arrayValue(evidence?.icssExports),
+    ...arrayValue(evidence?.icss?.exports)
+  ];
+}
+
+function cssModuleExportNames(evidence) {
+  return uniqueSortedStrings([
+    ...arrayValue(evidence?.exportNames),
+    ...arrayValue(evidence?.localClassNames),
+    ...arrayValue(evidence?.classNames),
+    ...cssModuleExportRecordNames(evidence?.exports),
+    ...objectKeys(evidence?.exports),
+    ...objectKeys(evidence?.generatedClassNameMap),
+    ...objectKeys(evidence?.classMap)
+  ]);
+}
+
+function cssModuleIcssExportNames(evidence) {
+  return uniqueSortedStrings([
+    ...arrayValue(evidence?.icssExportNames),
+    ...cssModuleExportRecordNames(evidence?.icssExports),
+    ...objectKeys(evidence?.icssExports),
+    ...cssModuleExportRecordNames(evidence?.icss?.exports),
+    ...objectKeys(evidence?.icss?.exports)
+  ]);
+}
+
+function cssModuleExportRecordNames(value) {
+  return Array.isArray(value)
+    ? value.map((entry) => entry?.name ?? entry?.localName ?? entry?.exportedName).filter(Boolean)
+    : [];
+}
+
+function cssModuleProofGapsWithout(proofGaps, codes) {
+  const remove = new Set(codes);
+  return arrayValue(proofGaps).filter((gap) => !remove.has(gap?.code));
+}
+
+function sortedValues(map) {
+  return [...map.values()].sort(stableRecordCompare);
+}
+
+function stableRecordCompare(left, right) {
+  return JSON.stringify(left).localeCompare(JSON.stringify(right));
+}
+
+function arrayValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function objectKeys(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? Object.keys(value) : [];
+}
+
+function uniqueSortedStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))].sort();
+}
+
+export { withProjectCssModuleDependencyGraphs };

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

@@ -0,0 +1,89 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { semanticSpanForHash } from './projectSymbolGraphCssModuleUtils.js';
+
+function cssModuleUseSiteGraphHashes(cssModuleSourcePath, bindings, graphUseSites, graphBlockers) {
+  const helperGraph = cssModuleClassNameHelperGraphSummary(graphUseSites);
+  return {
+    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)
+    }),
+    graphHash: hashSemanticValue({
+      kind: 'frontier.lang.cssModuleUseSiteGraph.v1',
+      cssModuleSourcePath,
+      bindings: bindings.map((binding) => binding.signatureHash).sort(),
+      useSites: graphUseSites.map((site) => site.signatureHash).sort(),
+      blockers: graphBlockers.map((blocker) => blocker.signatureHash).sort()
+    }),
+    ...helperGraph
+  };
+}
+
+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,
+    helperCallProofLevel: site.helperCallProofLevel,
+    helperCallGraphHash: site.helperCallGraphHash,
+    helperCalleeName: site.helperCalleeName,
+    helperCalleeSource: site.helperCalleeSource,
+    helperModuleSpecifier: site.helperModuleSpecifier
+  });
+}
+
+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 cssModuleClassNameHelperGraphSummary(useSites) {
+  const helperHashes = uniqueSortedStrings(useSites.map((site) => site.helperCallGraphHash));
+  if (!helperHashes.length) return {};
+  return {
+    cssModuleClassNameHelperGraphHash: hashSemanticValue({
+      kind: 'frontier.lang.cssModuleClassNameHelperGraph.v1',
+      helperCallGraphHashes: helperHashes
+    }),
+    cssModuleClassNameHelperProofLevels: uniqueSortedStrings(useSites.map((site) => site.helperCallProofLevel)),
+    cssModuleClassNameHelperSources: uniqueSortedStrings(useSites.map((site) => site.helperCalleeSource))
+  };
+}
+
+function stableStringCompare(left, right) { return left.localeCompare(right); }
+
+function uniqueSortedStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))].sort();
+}
+
+export { cssModuleUseSiteGraphHashes };

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

@@ -7,6 +7,7 @@ import {
   semanticSpanForHash,
   sourceSpanForRange
 } from './projectSymbolGraphCssModuleUtils.js';
+import { cssModuleUseSiteGraphHashes } from './projectSymbolGraphCssModuleGraphHashes.js';
 
 function cssModuleImportBindingRecord(edge, index, documentsById, cssSourcesByPath) {
   const cssSourcePath = edge.resolvedModulePath ?? cssModuleSpecifierPath(edge.moduleSpecifier);
@@ -54,7 +55,9 @@ function cssModuleImportBindingRecord(edge, index, documentsById, cssSourcesByPa
     generatedClassNameMapHash: cssModuleEvidence?.generatedClassNameMapHash ?? cssModuleGeneratedClassNameMapHash(cssModuleEvidence),
     jsTsUseSiteGraphHash: cssModuleEvidence?.jsTsUseSiteGraphHash,
     cssModuleCompositionGraphHash: cssModuleEvidence?.cssModuleCompositionGraphHash,
+    cssModuleCompositionGraphSource: cssModuleEvidence?.cssModuleCompositionGraphSource,
     icssGraphHash: cssModuleEvidence?.icssGraphHash,
+    icssGraphSource: cssModuleEvidence?.icssGraphSource,
     bundlerTransformHash: cssSource?.bundlerTransformHash,
     sourceMapProofHash: cssSource?.sourceMapProofHash,
     signatureHash
@@ -69,7 +72,12 @@ function cssModuleUseSiteRecord(binding, input) {
     accessKind: input.accessKind,
     exportName: input.exportName,
     expressionText: input.expressionText,
-    sourceSpan: semanticSpanForHash(input.sourceSpan)
+    sourceSpan: semanticSpanForHash(input.sourceSpan),
+    helperCallProofLevel: input.helperCallProofLevel,
+    helperCallGraphHash: input.helperCallGraphHash,
+    helperCalleeName: input.helperCalleeName,
+    helperCalleeSource: input.helperCalleeSource,
+    helperModuleSpecifier: input.helperModuleSpecifier
   });
   return compactRecord({
     id: `css_module_use_${idFragment(binding.id)}_${idFragment(signatureHash)}`,
@@ -91,6 +99,13 @@ function cssModuleUseSiteRecord(binding, input) {
     jsxPropRecordId: input.jsxPropRecordId,
     scopeReferenceRecordId: input.scopeReferenceRecordId,
     conditionalRuntimePresence: input.conditionalRuntimePresence,
+    helperCallProofLevel: input.helperCallProofLevel,
+    helperCallGraphHash: input.helperCallGraphHash,
+    helperCalleeName: input.helperCalleeName,
+    helperCalleeRoot: input.helperCalleeRoot,
+    helperCalleeSource: input.helperCalleeSource,
+    helperModuleSpecifier: input.helperModuleSpecifier,
+    helperImportEdgeId: input.helperImportEdgeId,
     signatureHash
   });
 }
@@ -185,20 +200,7 @@ 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,
-    bindings: bindings.map((binding) => binding.signatureHash).sort(),
-    useSites: graphUseSites.map((site) => site.signatureHash).sort(),
-    blockers: graphBlockers.map((blocker) => blocker.signatureHash).sort()
-  });
+  const graphHashes = cssModuleUseSiteGraphHashes(cssModuleSourcePath, bindings, graphUseSites, graphBlockers);
   return compactRecord({
     kind: 'frontier.lang.cssModuleUseSiteGraph',
     version: 1,
@@ -213,58 +215,23 @@ function cssModuleUseSiteGraphRecord(cssModuleSourcePath, bindings, graphUseSite
     blockerCount: graphBlockers.length,
     generatedClassNameMapHash: bindings.find((binding) => binding.generatedClassNameMapHash)?.generatedClassNameMapHash,
     cssModuleExportNamesHash: bindings.find((binding) => binding.cssModuleExportNamesHash)?.cssModuleExportNamesHash,
+    cssModuleCompositionGraphHash: bindings.find((binding) => binding.cssModuleCompositionGraphHash)?.cssModuleCompositionGraphHash,
+    cssModuleCompositionGraphSource: bindings.find((binding) => binding.cssModuleCompositionGraphSource)?.cssModuleCompositionGraphSource,
+    icssGraphHash: bindings.find((binding) => binding.icssGraphHash)?.icssGraphHash,
+    icssGraphSource: bindings.find((binding) => binding.icssGraphSource)?.icssGraphSource,
+    cssModuleClassNameHelperGraphHash: graphHashes.cssModuleClassNameHelperGraphHash,
+    cssModuleClassNameHelperProofLevels: graphHashes.cssModuleClassNameHelperProofLevels,
+    cssModuleClassNameHelperSources: graphHashes.cssModuleClassNameHelperSources,
     bundlerTransformHash: bindings.find((binding) => binding.bundlerTransformHash)?.bundlerTransformHash,
     sourceMapProofHash: bindings.find((binding) => binding.sourceMapProofHash)?.sourceMapProofHash,
-    jsTsUseSiteGraphHash,
+    jsTsUseSiteGraphHash: graphHashes.jsTsUseSiteGraphHash,
     status: graphBlockers.length ? 'blocked' : 'ready',
-    graphHash,
+    graphHash: graphHashes.graphHash,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false
   });
 }
 
-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 });

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

@@ -16,6 +16,12 @@ import {
   cssModuleStaticExpressionAccess,
   identifierOccurrences
 } from './projectSymbolGraphCssModuleMemberAccess.js';
+import {
+  cssModuleClassHelperCalleeEvidence,
+  cssModuleClassHelperCallProof,
+  cssModuleHelperArgumentIsConditional,
+  cssModuleMemberWriteOperation
+} from './projectSymbolGraphCssModuleClassHelpers.js';
 
 function cssModuleLexicalUseSites(importBindings, sourceTextsByPath) {
   const useSites = [];
@@ -43,7 +49,7 @@ function cssModuleMemberUseSites(binding, sourceText, blockers) {
       blockers.push(cssModuleAccessBlocker(binding, sourceText, occurrence.start, access.end ?? occurrence.end, access.reasonCode, access.expressionText));
       continue;
     }
-    const writeOperation = memberWriteOperation(sourceText, occurrence.start, access.end);
+    const writeOperation = cssModuleMemberWriteOperation(sourceText, occurrence.start, access.end);
     if (writeOperation) {
       blockers.push(cssModuleAccessBlocker(binding, sourceText, occurrence.start, access.end, 'css-module-member-write-unsupported', sourceText.slice(occurrence.start, access.end), { writeOperation }));
       continue;
@@ -93,9 +99,10 @@ function cssModuleDestructuringUseSites(binding, sourceText, blockers) {
   return useSites;
 }
 
-function cssModuleJsxUseSites(bindingsByLocal, jsxPropRecords) {
+function cssModuleJsxUseSites(bindingsByLocal, jsxPropRecords, importEdges = []) {
   const useSites = [];
   const blockers = [];
+  const helperCalleeEvidence = cssModuleClassHelperCalleeEvidence(importEdges);
   for (const prop of jsxPropRecords ?? []) {
     const root = prop.propValueReferenceRoot;
     const sourceBindings = root ? bindingsByLocal.get(localKey(prop.sourcePath, root)) ?? [] : [];
@@ -103,8 +110,8 @@ function cssModuleJsxUseSites(bindingsByLocal, jsxPropRecords) {
     const classNameBindings = bindingsForSourcePath(bindingsByLocal, prop.sourcePath);
     if (prop.propName !== 'className' || !classNameBindings.length) continue;
     useSites.push(...cssModuleJsxStaticComputedUseSites(classNameBindings, prop));
-    useSites.push(...cssModuleJsxHelperUseSites(classNameBindings, prop));
-    blockers.push(...cssModuleJsxBlockers(classNameBindings, prop));
+    useSites.push(...cssModuleJsxHelperUseSites(classNameBindings, prop, helperCalleeEvidence));
+    blockers.push(...cssModuleJsxBlockers(classNameBindings, prop, helperCalleeEvidence));
   }
   return { useSites, blockers };
 }
@@ -148,15 +155,16 @@ function cssModuleJsxStaticComputedUseSites(classNameBindings, prop) {
   });
 }
 
-function cssModuleJsxHelperUseSites(classNameBindings, prop) {
+function cssModuleJsxHelperUseSites(classNameBindings, prop, helperCalleeEvidence) {
   const expressionText = prop.propValueExpressionText ?? prop.propValueDynamicText ?? '';
   if (!cssModuleExpressionHasCall(expressionText)) return [];
   const useSites = [];
   for (const binding of classNameBindings) {
+    const helperProof = cssModuleClassHelperCallProof(expressionText, binding, prop, helperCalleeEvidence);
     for (const occurrence of identifierOccurrences(expressionText, binding.localName)) {
       const access = cssModuleMemberAccess(expressionText, occurrence.end);
       if (!access || access.status === 'blocked') continue;
-      if (memberWriteOperation(expressionText, occurrence.start, access.end)) continue;
+      if (cssModuleMemberWriteOperation(expressionText, occurrence.start, access.end)) continue;
       useSites.push(cssModuleUseSiteRecord(binding, {
         useSiteKind: 'jsx-className-helper',
         accessKind: access.accessKind,
@@ -167,14 +175,21 @@ function cssModuleJsxHelperUseSites(classNameBindings, prop) {
         sourceHash: prop.sourceHash,
         sourceSpan: prop.sourceSpan,
         jsxPropRecordId: prop.id,
-        conditionalRuntimePresence: cssModuleHelperArgumentIsConditional(expressionText, occurrence.start) || undefined
+        conditionalRuntimePresence: cssModuleHelperArgumentIsConditional(expressionText, occurrence.start) || undefined,
+        helperCallProofLevel: helperProof?.proofLevel,
+        helperCallGraphHash: helperProof?.helperCallGraphHash,
+        helperCalleeName: helperProof?.helperCalleeName,
+        helperCalleeRoot: helperProof?.helperCalleeRoot,
+        helperCalleeSource: helperProof?.helperCalleeSource,
+        helperModuleSpecifier: helperProof?.helperModuleSpecifier,
+        helperImportEdgeId: helperProof?.helperImportEdgeId
       }));
     }
   }
   return useSites;
 }
 
-function cssModuleJsxBlockers(classNameBindings, prop) {
+function cssModuleJsxBlockers(classNameBindings, prop, helperCalleeEvidence) {
   if (prop.propValueKind === 'string') {
     return classNameBindings.map((binding) => cssModulePropBlocker(binding, prop, 'css-module-string-literal-classname-unproved'));
   }
@@ -183,43 +198,18 @@ function cssModuleJsxBlockers(classNameBindings, prop) {
   return classNameBindings.flatMap((binding) => {
     if (!expressionText.includes(binding.localName)) return [];
     const reasonCodes = [];
-    if (cssModuleExpressionHasCall(expressionText)) reasonCodes.push('css-module-helper-call-unproved');
+    const helperProof = cssModuleClassHelperCallProof(expressionText, binding, prop, helperCalleeEvidence);
+    if (cssModuleExpressionHasCall(expressionText) && !helperProof) reasonCodes.push('css-module-helper-call-unproved');
     if (cssModuleExpressionHasBlockedAccess(expressionText, binding.localName)) reasonCodes.push('css-module-dynamic-member-access-unproved');
     if (!reasonCodes.length && cssModuleStaticExpressionAccess(expressionText, binding.localName)) return [];
     if (!reasonCodes.length && prop.propValueDynamicBlockerReasonCode) {
-      reasonCodes.push(jsxDynamicReason(prop.propValueDynamicBlockerReasonCode));
+      const dynamicReason = jsxDynamicReason(prop.propValueDynamicBlockerReasonCode);
+      if (dynamicReason !== 'css-module-helper-call-unproved' || !helperProof) reasonCodes.push(dynamicReason);
     }
     return [...new Set(reasonCodes)].map((reasonCode) => cssModulePropBlocker(binding, prop, reasonCode));
   });
 }
 
-function memberWriteOperation(sourceText, start, end) {
-  if (hasPrefixUpdateOperator(sourceText, start)) return 'update';
-  let index = end;
-  while (index < sourceText.length && /\s/.test(sourceText[index])) index += 1;
-  if (sourceText.slice(index, index + 2) === '++' || sourceText.slice(index, index + 2) === '--') return 'update';
-  return assignmentOperatorAt(sourceText, index) ? 'assignment' : undefined;
-}
-
-function assignmentOperatorAt(code, index) {
-  for (const operator of ['>>>=', '**=', '<<=', '>>=', '&&=', '||=', '??=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '=']) {
-    if (!code.startsWith(operator, index)) continue;
-    if (operator === '=' && (code[index + 1] === '=' || code[index + 1] === '>')) return undefined;
-    return operator;
-  }
-  return undefined;
-}
-
-function hasPrefixUpdateOperator(code, tokenStart) {
-  let index = tokenStart - 1;
-  while (index >= 0 && /\s/.test(code[index])) index -= 1;
-  const operator = code.slice(index - 1, index + 1);
-  if (operator !== '++' && operator !== '--') return false;
-  let before = index - 2;
-  while (before >= 0 && /\s/.test(code[before])) before -= 1;
-  return before < 0 || !/[A-Za-z0-9_$)\]]/.test(code[before]);
-}
-
 function destructuringProperty(text) {
   const value = String(text ?? '').trim();
   const [rawName, rawLocal] = value.split(':').map((part) => part.trim());
@@ -249,16 +239,6 @@ function splitTopLevelComma(text, baseOffset) {
   return parts;
 }
 
-function cssModuleHelperArgumentIsConditional(expressionText, occurrenceStart) {
-  const prefix = expressionText.slice(0, occurrenceStart);
-  const suffix = expressionText.slice(occurrenceStart);
-  const lastComma = prefix.lastIndexOf(',');
-  const argumentPrefix = prefix.slice(lastComma + 1);
-  const nextComma = suffix.indexOf(',');
-  const argumentText = `${argumentPrefix}${nextComma === -1 ? suffix : suffix.slice(0, nextComma)}`;
-  return /(?:&&|\|\||\?)/.test(argumentText);
-}
-
 function jsxDynamicReason(reasonCode) {
   if (reasonCode.includes('call')) return 'css-module-helper-call-unproved';
   if (reasonCode.includes('computed')) return 'css-module-dynamic-member-access-unproved';

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

@@ -15,6 +15,7 @@ import {
   cssModuleTransformBlockers,
   cssModuleUseSiteGraphRecords
 } from './projectSymbolGraphCssModuleRecords.js';
+import { withProjectCssModuleDependencyGraphs } from './projectSymbolGraphCssModuleDependencyGraphs.js';
 import {
   cssModuleJsxUseSites,
   cssModuleLexicalUseSites
@@ -27,13 +28,14 @@ function createProjectCssModuleGraphRecords(semanticIndex, imports, importEdges,
   const cssSourcesByPath = new Map(imports
     .map((imported) => [sourcePathForImport(imported), cssModuleSourceRecord(imported)])
     .filter(([sourcePath]) => sourcePath));
+  const cssSourcesWithDependencyGraphsByPath = withProjectCssModuleDependencyGraphs(cssSourcesByPath);
   const documentsById = new Map((semanticIndex?.documents ?? []).map((document) => [document.id, document]));
   const importBindings = uniqueRecords(importEdges
     .filter(isCssModuleBindingEdge)
-    .map((edge, index) => cssModuleImportBindingRecord(edge, index, documentsById, cssSourcesByPath)));
+    .map((edge, index) => cssModuleImportBindingRecord(edge, index, documentsById, cssSourcesWithDependencyGraphsByPath)));
   const bindingsByLocal = groupBindingsByLocal(importBindings);
   const { useSites: lexicalUseSites, blockers: lexicalBlockers } = cssModuleLexicalUseSites(importBindings, sourceTextsByPath);
-  const { useSites: jsxUseSites, blockers: jsxBlockers } = cssModuleJsxUseSites(bindingsByLocal, jsxPropRecords);
+  const { useSites: jsxUseSites, blockers: jsxBlockers } = cssModuleJsxUseSites(bindingsByLocal, jsxPropRecords, importEdges);
   const namedImportBlockers = importBindings
     .filter((binding) => binding.importKind === 'named')
     .map((binding) => cssModuleNamedExportBlocker(binding));
@@ -43,7 +45,7 @@ function createProjectCssModuleGraphRecords(semanticIndex, imports, importEdges,
   const missingTransformBlockers = usedImportBindings
     .flatMap((binding) => cssModuleTransformBlockers(binding));
   const missingDependencyGraphBlockers = usedImportBindings
-    .flatMap((binding) => cssModuleDependencyGraphBlockers(binding, cssSourcesByPath));
+    .flatMap((binding) => cssModuleDependencyGraphBlockers(binding, cssSourcesWithDependencyGraphsByPath));
   const bindingsById = new Map(importBindings.map((binding) => [binding.id, binding]));
   const missingExportBlockers = cssModuleMissingExportBlockers(bindingsById, cssModuleUseSites);
   const cssModuleUseSiteBlockers = uniqueRecords([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.196",
+  "version": "0.2.198",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",