@shapeshift-labs/frontier-lang-compiler 0.2.197 → 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, export-only ICSS graph hashes, and project-source graph hashes for cross-file `composes` / ICSS imports when every referenced `.module.css` source is present and source-inferred; package/bundler-only composition, unresolved 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

@@ -51,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;
 }
 
@@ -91,6 +98,9 @@ export interface NativeProjectSymbolGraphCssModuleUseSiteGraphRecord {
   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/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);
@@ -71,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)}`,
@@ -93,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
   });
 }
@@ -187,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,
@@ -219,58 +219,19 @@ function cssModuleUseSiteGraphRecord(cssModuleSourcePath, bindings, graphUseSite
     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

@@ -35,7 +35,7 @@ function createProjectCssModuleGraphRecords(semanticIndex, imports, importEdges,
     .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));

package/package.json

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