@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/checker/engine/context.ts

@@ -0,0 +1,340 @@
+import ts from 'typescript';
+
+import { type AnnotationLookup, createAnnotationLookup } from '../../annotation_syntax.ts';
+import { normalizeRuntimeContext } from '../../config.ts';
+import { isForeignSourceFile } from '../../soundscript_packages.ts';
+import { createAnalysisFactStore } from './facts.ts';
+import type {
+  AnalysisContext,
+  CreateAnalysisContextOptions,
+  ExportSummary,
+  PredicateVerificationTargetFact,
+} from './types.ts';
+
+function isNode(subject: ts.Node | ts.Symbol): subject is ts.Node {
+  return 'kind' in subject;
+}
+
+function traverseNode(
+  node: ts.Node,
+  visitor: (node: ts.Node) => void,
+  isGeneratedNode: (node: ts.Node) => boolean,
+): void {
+  if (!ts.isSourceFile(node) && isGeneratedNode(node)) {
+    return;
+  }
+
+  visitor(node);
+  ts.forEachChild(node, (child) => traverseNode(child, visitor, isGeneratedNode));
+}
+
+export function createAnalysisContext(options: CreateAnalysisContextOptions): AnalysisContext {
+  const checker = options.program.getTypeChecker();
+  const factStore = createAnalysisFactStore();
+  const nodeIds = new WeakMap<ts.Node, number>();
+  const symbolIds = new WeakMap<ts.Symbol, number>();
+  const exportSummariesBySymbolId = new Map<number, ExportSummary>();
+  const annotationLookups = new WeakMap<ts.SourceFile, AnnotationLookup>();
+  const generatedNodeCache = new WeakMap<ts.Node, boolean>();
+  const sourceFiles = options.program.getSourceFiles().filter(
+    (sourceFile: ts.SourceFile) =>
+      !options.program.isSourceFileDefaultLibrary(sourceFile) &&
+      (
+        !options.program.isSourceFileFromExternalLibrary(sourceFile) ||
+        !isForeignSourceFile(sourceFile.fileName, ts.sys)
+      ) &&
+      (options.includeSourceFile?.(sourceFile) ?? true),
+  );
+  const runtime = options.runtime ?? normalizeRuntimeContext({
+    externs: [],
+    target: 'js-node',
+  });
+  let nextNodeId = 1;
+  let nextSymbolId = 1;
+
+  function getSubjectCacheKey(subject: ts.Node | ts.Symbol): string {
+    if (isNode(subject)) {
+      return `node:${context.getNodeId(subject)}`;
+    }
+
+    return `symbol:${context.getSymbolId(subject)}`;
+  }
+
+  function getCanonicalExportSummarySymbol(symbol: ts.Symbol): ts.Symbol {
+    let currentSymbol = symbol;
+    const visitedSymbols = new Set<ts.Symbol>();
+
+    while (!visitedSymbols.has(currentSymbol)) {
+      visitedSymbols.add(currentSymbol);
+
+      if (currentSymbol.flags & ts.SymbolFlags.Alias) {
+        const aliasedSymbol = checker.getAliasedSymbol(currentSymbol);
+        if (aliasedSymbol && aliasedSymbol !== currentSymbol) {
+          currentSymbol = aliasedSymbol;
+          continue;
+        }
+      }
+
+      const exportedSymbol = checker.getExportSymbolOfSymbol(currentSymbol);
+      if (exportedSymbol !== currentSymbol) {
+        currentSymbol = exportedSymbol;
+        continue;
+      }
+
+      return currentSymbol;
+    }
+
+    return currentSymbol;
+  }
+
+  const context: AnalysisContext = {
+    checker,
+    exportSummaries: {
+      canonicalizeSymbol(symbol: ts.Symbol): ts.Symbol {
+        return getCanonicalExportSummarySymbol(symbol);
+      },
+      get(symbol: ts.Symbol): ExportSummary | undefined {
+        return exportSummariesBySymbolId.get(
+          context.getSymbolId(getCanonicalExportSummarySymbol(symbol)),
+        );
+      },
+      set(symbol: ts.Symbol, summary: ExportSummary): ExportSummary {
+        exportSummariesBySymbolId.set(
+          context.getSymbolId(getCanonicalExportSummarySymbol(symbol)),
+          summary,
+        );
+        return summary;
+      },
+    },
+    facts: {
+      getAliasRelationship(source: ts.Node | ts.Symbol, target: ts.Node | ts.Symbol, compute) {
+        return factStore.getOrCompute(
+          'alias',
+          `${getSubjectCacheKey(source)}->${getSubjectCacheKey(target)}`,
+          compute,
+        );
+      },
+      getEffectSummary(node: ts.Node, compute) {
+        return factStore.getOrCompute('effectSummary', `node:${context.getNodeId(node)}`, compute);
+      },
+      getFlowBranchStructure(node: ts.Statement, compute) {
+        return factStore.getOrCompute(
+          'flowBranchStructure',
+          `node:${context.getNodeId(node)}`,
+          compute,
+        );
+      },
+      getFlowChildRegionStructure(node: ts.Statement, compute) {
+        return factStore.getOrCompute(
+          'flowChildRegionStructure',
+          `node:${context.getNodeId(node)}`,
+          compute,
+        );
+      },
+      getFlowConditionStructure(node: ts.Expression, compute) {
+        return factStore.getOrCompute(
+          'flowConditionStructure',
+          `node:${context.getNodeId(node)}`,
+          compute,
+        );
+      },
+      getFlowInvalidationStructure(node: ts.Node, optionsKey: string, compute) {
+        return factStore.getOrCompute(
+          'flowInvalidationStructure',
+          `node:${context.getNodeId(node)}|options:${optionsKey}`,
+          compute,
+        );
+      },
+      getFlowStatementStructure(node: ts.Statement, compute) {
+        return factStore.getOrCompute(
+          'flowStatementStructure',
+          `node:${context.getNodeId(node)}`,
+          compute,
+        );
+      },
+      getFlowRegionStructure(node: ts.Node, optionsKey: string, compute) {
+        return factStore.getOrCompute(
+          'flowRegionStructure',
+          `node:${context.getNodeId(node)}|options:${optionsKey}`,
+          compute,
+        );
+      },
+      getForeignProjection(symbol: ts.Symbol, compute) {
+        return factStore.getOrCompute(
+          'foreignProjection',
+          `symbol:${context.getSymbolId(symbol)}`,
+          compute,
+        );
+      },
+      getMutability(subject: ts.Node | ts.Symbol, compute) {
+        return factStore.getOrCompute('mutability', getSubjectCacheKey(subject), compute);
+      },
+      getNamespaceResolver(node: ts.Node, compute) {
+        const key = `node:${context.getNodeId(node)}`;
+        const cached = factStore.get('namespaceResolver', key) as
+          | import('./types.ts').NamespaceResolverFact
+          | undefined;
+        if (cached) {
+          return cached;
+        }
+
+        const created = compute();
+        if (created) {
+          factStore.set('namespaceResolver', key, created);
+        }
+
+        return created;
+      },
+      getNamespaceShape(node: ts.Node, compute) {
+        const key = `node:${context.getNodeId(node)}`;
+        const cached = factStore.get('namespaceShape', key) as
+          | import('./types.ts').NamespaceShapeFact
+          | undefined;
+        if (cached) {
+          return cached;
+        }
+
+        const created = compute();
+        if (created) {
+          factStore.set('namespaceShape', key, created);
+        }
+
+        return created;
+      },
+      getNamespaceResolverSymbol(symbol: ts.Symbol) {
+        return factStore.get(
+          'namespaceResolver',
+          `symbol:${context.getSymbolId(symbol)}`,
+        ) as import('./types.ts').NamespaceResolverFact | undefined;
+      },
+      getNamespaceShapeSymbol(symbol: ts.Symbol) {
+        return factStore.get(
+          'namespaceShape',
+          `symbol:${context.getSymbolId(symbol)}`,
+        ) as import('./types.ts').NamespaceShapeFact | undefined;
+      },
+      getNarrowing(node: ts.Node, symbol: ts.Symbol, compute) {
+        return factStore.getOrCompute(
+          'narrowing',
+          `node:${context.getNodeId(node)}|symbol:${context.getSymbolId(symbol)}`,
+          compute,
+        );
+      },
+      getNonOrdinaryRecovery(node: ts.Node, family, compute) {
+        return factStore.getOrCompute(
+          'nonOrdinaryRecovery',
+          `node:${context.getNodeId(node)}|family:${family}`,
+          compute,
+        );
+      },
+      getPredicateVerificationTarget(node: ts.Node, compute) {
+        const key = `node:${context.getNodeId(node)}`;
+        const cached = factStore.get<PredicateVerificationTargetFact>(
+          'predicateVerificationTarget',
+          key,
+        );
+        if (cached) {
+          return cached;
+        }
+
+        const created = compute();
+        if (created) {
+          factStore.set('predicateVerificationTarget', key, created);
+        }
+
+        return created;
+      },
+      getUnsafeValueOrigin(symbol: ts.Symbol) {
+        return factStore.get(
+          'unsafeValueOrigin',
+          `symbol:${context.getSymbolId(symbol)}`,
+        );
+      },
+      setForeignProjection(symbol: ts.Symbol, fact) {
+        factStore.set('foreignProjection', `symbol:${context.getSymbolId(symbol)}`, fact);
+        return fact;
+      },
+      setNamespaceResolverSymbol(symbol: ts.Symbol, fact) {
+        factStore.set('namespaceResolver', `symbol:${context.getSymbolId(symbol)}`, fact);
+        return fact;
+      },
+      setNamespaceShapeSymbol(symbol: ts.Symbol, fact) {
+        factStore.set('namespaceShape', `symbol:${context.getSymbolId(symbol)}`, fact);
+        return fact;
+      },
+      setSymbolProvenance(symbol: ts.Symbol, fact) {
+        factStore.set('symbolProvenance', `symbol:${context.getSymbolId(symbol)}`, fact);
+        return fact;
+      },
+      setUnsafeValueOrigin(symbol: ts.Symbol, fact) {
+        factStore.set('unsafeValueOrigin', `symbol:${context.getSymbolId(symbol)}`, fact);
+        return fact;
+      },
+      getSymbolProvenance(symbol: ts.Symbol, compute) {
+        return factStore.getOrCompute(
+          'symbolProvenance',
+          `symbol:${context.getSymbolId(symbol)}`,
+          compute,
+        );
+      },
+    },
+    isGeneratedNode(node: ts.Node): boolean {
+      const cached = generatedNodeCache.get(node);
+      if (cached !== undefined) {
+        return cached;
+      }
+
+      const generated = options.isGeneratedNode?.(node) ?? false;
+      generatedNodeCache.set(node, generated);
+      return generated;
+    },
+    program: options.program,
+    runtime,
+    workingDirectory: options.workingDirectory,
+    forEachSourceFile(visitor: (sourceFile: ts.SourceFile) => void): void {
+      for (const sourceFile of sourceFiles) {
+        visitor(sourceFile);
+      }
+    },
+    getAnnotationLookup(sourceFile: ts.SourceFile): AnnotationLookup {
+      const cachedLookup = annotationLookups.get(sourceFile);
+      if (cachedLookup) {
+        return cachedLookup;
+      }
+
+      const createdLookup = createAnnotationLookup(sourceFile);
+      annotationLookups.set(sourceFile, createdLookup);
+      return createdLookup;
+    },
+    getNodeId(node: ts.Node): number {
+      const cachedId = nodeIds.get(node);
+      if (cachedId !== undefined) {
+        return cachedId;
+      }
+
+      const createdId = nextNodeId;
+      nextNodeId += 1;
+      nodeIds.set(node, createdId);
+      return createdId;
+    },
+    getSourceFiles(): readonly ts.SourceFile[] {
+      return sourceFiles;
+    },
+    getSymbolId(symbol: ts.Symbol): number {
+      const cachedId = symbolIds.get(symbol);
+      if (cachedId !== undefined) {
+        return cachedId;
+      }
+
+      const createdId = nextSymbolId;
+      nextSymbolId += 1;
+      symbolIds.set(symbol, createdId);
+      return createdId;
+    },
+    traverse(node: ts.Node, visitor: (currentNode: ts.Node) => void): void {
+      traverseNode(node, visitor, context.isGeneratedNode);
+    },
+  };
+
+  return context;
+}

package/project-transform/src/checker/engine/diagnostic_codes.js

@@ -0,0 +1,72 @@
+export const SOUND_DIAGNOSTIC_CODES = {
+    anyType: 'SOUND1001',
+    typeAssertion: 'SOUND1002',
+    nonNullAssertion: 'SOUND1003',
+    numericEnum: 'SOUND1004',
+    unsoundImportUse: 'SOUND1005',
+    malformedAnnotation: 'SOUND1006',
+    unknownAnnotation: 'SOUND1007',
+    predicateBodyMismatch: 'SOUND1017',
+    overloadImplementationMismatch: 'SOUND1018',
+    unsoundRelation: 'SOUND1019',
+    unsoundFlowNarrowing: 'SOUND1020',
+    nullPrototypeObjectCreation: 'SOUND1021',
+    unsupportedJavaScriptFeature: 'SOUND1022',
+    bannedTypeScriptPragma: 'SOUND1023',
+    exoticObjectWidening: 'SOUND1024',
+    throwNonError: 'SOUND1025',
+    duplicateAnnotation: 'SOUND1026',
+    invalidAnnotationTarget: 'SOUND1027',
+    annotationArgumentsNotSupported: 'SOUND1028',
+    ambientRuntimeDeclarationRequiresExtern: 'SOUND1029',
+    exportedAmbientRuntimeDeclaration: 'SOUND1030',
+    invalidVarianceAnnotation: 'SOUND1031',
+    varianceAnnotationMismatch: 'SOUND1032',
+    reservedAnnotationNameConflict: 'SOUND1033',
+    unsupportedAsyncSurface: 'SOUND1034',
+    receiverSensitiveCallableValue: 'SOUND1035',
+    constructionLifecycleViolation: 'SOUND1036',
+    fieldReadBeforeInitialization: 'SOUND1037',
+    definiteAssignmentAssertion: 'SOUND1038',
+};
+export const SOUND_DIAGNOSTIC_MESSAGES = {
+    anyType: "Type 'any' is not supported in soundscript.",
+    typeAssertion: 'Unchecked type assertions are not supported in soundscript.',
+    nonNullAssertion: 'Non-null assertions are not supported in soundscript.',
+    numericEnum: 'Numeric enums are not supported in soundscript.',
+    unsoundImportUse: "Value from unsound import cannot be used without an explicit interop boundary ('// #[interop]').",
+    malformedAnnotation: 'Malformed soundscript annotation comment.',
+    unknownAnnotation: 'Unknown soundscript annotation.',
+    predicateBodyMismatch: 'User-defined type guard or assertion body does not match its declared predicate.',
+    overloadImplementationMismatch: 'Overload implementation does not satisfy individual signatures.',
+    unsoundRelation: 'This assignment depends on an unsound type relation in soundscript.',
+    unsoundFlowNarrowing: 'This narrowing is no longer valid in soundscript after aliasing, mutation, or suspension.',
+    nullPrototypeObjectCreation: 'Null-prototype object creation is not supported in soundscript.',
+    unsupportedJavaScriptFeature: 'This JavaScript feature is not supported in soundscript.',
+    bannedTypeScriptPragma: 'TypeScript pragma comments are not supported in soundscript.',
+    exoticObjectWidening: 'Exotic object values are not assignable to plain `object` in soundscript.',
+    throwNonError: 'Only `Error` values may be thrown in soundscript.',
+    duplicateAnnotation: 'Duplicate soundscript annotation in the same annotation block.',
+    invalidAnnotationTarget: 'soundscript annotation is not valid on this target.',
+    annotationArgumentsNotSupported: 'This soundscript annotation does not support arguments in v1.',
+    ambientRuntimeDeclarationRequiresExtern: "Ambient runtime declarations in soundscript files require a site-local '// #[extern]' marker.",
+    exportedAmbientRuntimeDeclaration: 'Ambient runtime declarations may not be exported from soundscript files.',
+    invalidVarianceAnnotation: 'Variance annotation contract is invalid.',
+    varianceAnnotationMismatch: "Variance annotation does not match the declaration's proven variance.",
+    reservedAnnotationNameConflict: 'Reserved builtin annotation names cannot be reused for imported declaration macros.',
+    unsupportedAsyncSurface: 'This async surface is not supported in soundscript. Only compiler-owned Promise semantics are supported.',
+    receiverSensitiveCallableValue: 'Receiver-sensitive callables are not first-class values in soundscript.',
+    constructionLifecycleViolation: 'Construction-time dispatch and this escape are not allowed before construction completes.',
+    fieldReadBeforeInitialization: 'Instance fields may not be read before definite initialization in soundscript.',
+    definiteAssignmentAssertion: 'Definite-assignment assertions are not supported in soundscript.',
+};
+export const COMPILER_DIAGNOSTIC_CODES = {
+    unsupportedCompilerSubset: 'COMPILER2001',
+    heapRuntimeGeneralizationBoundary: 'COMPILER2002',
+    valueClassesRequireJsEmit: 'COMPILER2003',
+};
+export const COMPILER_DIAGNOSTIC_MESSAGES = {
+    unsupportedCompilerSubset: 'This construct is accepted by the checker but not yet supported by the compiler backend.',
+    heapRuntimeGeneralizationBoundary: 'This construct needs heap runtime substrate generalization or fallback lowering that is not implemented yet.',
+    valueClassesRequireJsEmit: '#[value] classes are only supported on JS emit paths in v1.',
+};

package/project-transform/src/checker/engine/diagnostic_codes.ts

@@ -0,0 +1,95 @@
+export const SOUND_DIAGNOSTIC_CODES = {
+  anyType: 'SOUND1001',
+  typeAssertion: 'SOUND1002',
+  nonNullAssertion: 'SOUND1003',
+  numericEnum: 'SOUND1004',
+  unsoundImportUse: 'SOUND1005',
+  malformedAnnotation: 'SOUND1006',
+  unknownAnnotation: 'SOUND1007',
+  predicateBodyMismatch: 'SOUND1017',
+  overloadImplementationMismatch: 'SOUND1018',
+  unsoundRelation: 'SOUND1019',
+  unsoundFlowNarrowing: 'SOUND1020',
+  nullPrototypeObjectCreation: 'SOUND1021',
+  unsupportedJavaScriptFeature: 'SOUND1022',
+  bannedTypeScriptPragma: 'SOUND1023',
+  exoticObjectWidening: 'SOUND1024',
+  throwNonError: 'SOUND1025',
+  duplicateAnnotation: 'SOUND1026',
+  invalidAnnotationTarget: 'SOUND1027',
+  annotationArgumentsNotSupported: 'SOUND1028',
+  ambientRuntimeDeclarationRequiresExtern: 'SOUND1029',
+  exportedAmbientRuntimeDeclaration: 'SOUND1030',
+  invalidVarianceAnnotation: 'SOUND1031',
+  varianceAnnotationMismatch: 'SOUND1032',
+  reservedAnnotationNameConflict: 'SOUND1033',
+  unsupportedAsyncSurface: 'SOUND1034',
+  receiverSensitiveCallableValue: 'SOUND1035',
+  constructionLifecycleViolation: 'SOUND1036',
+  fieldReadBeforeInitialization: 'SOUND1037',
+  definiteAssignmentAssertion: 'SOUND1038',
+} as const;
+
+export type SoundDiagnosticCode =
+  (typeof SOUND_DIAGNOSTIC_CODES)[keyof typeof SOUND_DIAGNOSTIC_CODES];
+
+export const SOUND_DIAGNOSTIC_MESSAGES = {
+  anyType: "Type 'any' is not supported in soundscript.",
+  typeAssertion: 'Unchecked type assertions are not supported in soundscript.',
+  nonNullAssertion: 'Non-null assertions are not supported in soundscript.',
+  numericEnum: 'Numeric enums are not supported in soundscript.',
+  unsoundImportUse:
+    "Value from unsound import cannot be used without an explicit interop boundary ('// #[interop]').",
+  malformedAnnotation: 'Malformed soundscript annotation comment.',
+  unknownAnnotation: 'Unknown soundscript annotation.',
+  predicateBodyMismatch:
+    'User-defined type guard or assertion body does not match its declared predicate.',
+  overloadImplementationMismatch: 'Overload implementation does not satisfy individual signatures.',
+  unsoundRelation: 'This assignment depends on an unsound type relation in soundscript.',
+  unsoundFlowNarrowing:
+    'This narrowing is no longer valid in soundscript after aliasing, mutation, or suspension.',
+  nullPrototypeObjectCreation: 'Null-prototype object creation is not supported in soundscript.',
+  unsupportedJavaScriptFeature: 'This JavaScript feature is not supported in soundscript.',
+  bannedTypeScriptPragma: 'TypeScript pragma comments are not supported in soundscript.',
+  exoticObjectWidening: 'Exotic object values are not assignable to plain `object` in soundscript.',
+  throwNonError: 'Only `Error` values may be thrown in soundscript.',
+  duplicateAnnotation: 'Duplicate soundscript annotation in the same annotation block.',
+  invalidAnnotationTarget: 'soundscript annotation is not valid on this target.',
+  annotationArgumentsNotSupported: 'This soundscript annotation does not support arguments in v1.',
+  ambientRuntimeDeclarationRequiresExtern:
+    "Ambient runtime declarations in soundscript files require a site-local '// #[extern]' marker.",
+  exportedAmbientRuntimeDeclaration:
+    'Ambient runtime declarations may not be exported from soundscript files.',
+  invalidVarianceAnnotation: 'Variance annotation contract is invalid.',
+  varianceAnnotationMismatch:
+    "Variance annotation does not match the declaration's proven variance.",
+  reservedAnnotationNameConflict:
+    'Reserved builtin annotation names cannot be reused for imported declaration macros.',
+  unsupportedAsyncSurface:
+    'This async surface is not supported in soundscript. Only compiler-owned Promise semantics are supported.',
+  receiverSensitiveCallableValue:
+    'Receiver-sensitive callables are not first-class values in soundscript.',
+  constructionLifecycleViolation:
+    'Construction-time dispatch and this escape are not allowed before construction completes.',
+  fieldReadBeforeInitialization:
+    'Instance fields may not be read before definite initialization in soundscript.',
+  definiteAssignmentAssertion:
+    'Definite-assignment assertions are not supported in soundscript.',
+} as const;
+
+export const COMPILER_DIAGNOSTIC_CODES = {
+  unsupportedCompilerSubset: 'COMPILER2001',
+  heapRuntimeGeneralizationBoundary: 'COMPILER2002',
+  valueClassesRequireJsEmit: 'COMPILER2003',
+} as const;
+
+export type CompilerDiagnosticCode =
+  (typeof COMPILER_DIAGNOSTIC_CODES)[keyof typeof COMPILER_DIAGNOSTIC_CODES];
+
+export const COMPILER_DIAGNOSTIC_MESSAGES = {
+  unsupportedCompilerSubset:
+    'This construct is accepted by the checker but not yet supported by the compiler backend.',
+  heapRuntimeGeneralizationBoundary:
+    'This construct needs heap runtime substrate generalization or fallback lowering that is not implemented yet.',
+  valueClassesRequireJsEmit: '#[value] classes are only supported on JS emit paths in v1.',
+} as const;

package/project-transform/src/checker/engine/facts.js

@@ -0,0 +1,35 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _InMemoryAnalysisFactStore_buckets;
+class InMemoryAnalysisFactStore {
+    constructor() {
+        _InMemoryAnalysisFactStore_buckets.set(this, new Map());
+    }
+    get(kind, key) {
+        return __classPrivateFieldGet(this, _InMemoryAnalysisFactStore_buckets, "f").get(kind)?.get(key);
+    }
+    getOrCompute(kind, key, compute) {
+        const existing = this.get(kind, key);
+        if (existing) {
+            return existing;
+        }
+        const created = compute();
+        this.set(kind, key, created);
+        return created;
+    }
+    set(kind, key, value) {
+        let bucket = __classPrivateFieldGet(this, _InMemoryAnalysisFactStore_buckets, "f").get(kind);
+        if (!bucket) {
+            bucket = new Map();
+            __classPrivateFieldGet(this, _InMemoryAnalysisFactStore_buckets, "f").set(kind, bucket);
+        }
+        bucket.set(key, value);
+    }
+}
+_InMemoryAnalysisFactStore_buckets = new WeakMap();
+export function createAnalysisFactStore() {
+    return new InMemoryAnalysisFactStore();
+}

package/project-transform/src/checker/engine/facts.ts

@@ -0,0 +1,48 @@
+import type { AnalysisFactKind, AnalysisFactValue } from './types.ts';
+
+interface AnalysisFactCache {
+  get<TFact extends AnalysisFactValue>(kind: AnalysisFactKind, key: string): TFact | undefined;
+  getOrCompute<TFact extends AnalysisFactValue>(
+    kind: AnalysisFactKind,
+    key: string,
+    compute: () => TFact,
+  ): TFact;
+  set<TFact extends AnalysisFactValue>(kind: AnalysisFactKind, key: string, value: TFact): void;
+}
+
+class InMemoryAnalysisFactStore implements AnalysisFactCache {
+  readonly #buckets = new Map<AnalysisFactKind, Map<string, AnalysisFactValue>>();
+
+  get<TFact extends AnalysisFactValue>(kind: AnalysisFactKind, key: string): TFact | undefined {
+    return this.#buckets.get(kind)?.get(key) as TFact | undefined;
+  }
+
+  getOrCompute<TFact extends AnalysisFactValue>(
+    kind: AnalysisFactKind,
+    key: string,
+    compute: () => TFact,
+  ): TFact {
+    const existing = this.get<TFact>(kind, key);
+    if (existing) {
+      return existing;
+    }
+
+    const created = compute();
+    this.set(kind, key, created);
+    return created;
+  }
+
+  set<TFact extends AnalysisFactValue>(kind: AnalysisFactKind, key: string, value: TFact): void {
+    let bucket = this.#buckets.get(kind);
+    if (!bucket) {
+      bucket = new Map<string, AnalysisFactValue>();
+      this.#buckets.set(kind, bucket);
+    }
+
+    bucket.set(key, value);
+  }
+}
+
+export function createAnalysisFactStore(): AnalysisFactCache {
+  return new InMemoryAnalysisFactStore();
+}

package/project-transform/src/checker/engine/types.js

@@ -0,0 +1 @@
+export {};