@shapeshift-labs/frontier-lang-compiler 0.2.195 → 0.2.197

package/README.md

@@ -611,7 +611,7 @@ 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 from `.module.css` source via `@shapeshift-labs/frontier-lang-css`, while generated class-name maps, bundler transform identity, source-map proof, dynamic member access, writes, and helper-call equivalence remain fail-closed.
+- 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.
 - 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;
@@ -85,6 +87,10 @@ 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 bundlerTransformHash?: string;
   readonly sourceMapProofHash?: string;
   readonly status: 'ready' | 'blocked' | string;

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/projectSymbolGraphCssModuleRecords.js

@@ -54,7 +54,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
@@ -213,6 +215,10 @@ 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,
     bundlerTransformHash: bindings.find((binding) => binding.bundlerTransformHash)?.bundlerTransformHash,
     sourceMapProofHash: bindings.find((binding) => binding.sourceMapProofHash)?.sourceMapProofHash,
     jsTsUseSiteGraphHash,

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,10 +28,11 @@ 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);
@@ -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.195",
+  "version": "0.2.197",
   "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.26",
+    "@shapeshift-labs/frontier-lang-css": "^0.1.27",
     "@shapeshift-labs/frontier-lang-html": "^0.1.16",
     "@shapeshift-labs/frontier-lang-javascript": "0.2.9",
     "@shapeshift-labs/frontier-lang-kernel": "0.3.12",