@soundscript/soundscript 0.1.16 → 0.1.17

package/json.js

@@ -12,7 +12,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _JsonLikeParser_instances, _JsonLikeParser_index, _JsonLikeParser_text, _JsonLikeParser_consumeKeyword, _JsonLikeParser_parseArray, _JsonLikeParser_parseNumber, _JsonLikeParser_parseObject, _JsonLikeParser_parseString, _JsonLikeParser_consumeDigits, _JsonLikeParser_skipWhitespace, _JsonLikeParser_isDigit, _JsonLikeParser_error;
 import { Failure } from '@soundscript/soundscript/failures';
 import { isErr, resultOf } from '@soundscript/soundscript/result';
-import { F32, F64, format as formatNumeric, I8, I16, I32, I64, isNumeric, toHostNumber, U8, U16, U32, U64, } from './numerics.sts';
+import { F32, F64, format as formatNumeric, I8, I16, I32, I64, isNumeric, toHostNumber, U8, U16, U32, U64, } from './numerics.js';
 const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
 const MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
 export class JsonParseFailure extends Failure {

package/numerics.js

@@ -10,10 +10,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _MachineNumericBox_key, _MachineNumericBox_payload;
-import { fromCompare } from './compare.sts';
-import { Failure } from './failures.sts';
-import { fromHashEq, stringHash } from './hash.sts';
-import { err, ok } from './result.sts';
+import { fromCompare } from './compare.js';
+import { Failure } from './failures.js';
+import { fromHashEq, stringHash } from './hash.js';
+import { err, ok } from './result.js';
 export class NumericOverflowFailure extends Failure {
     constructor(leaf, operation) {
         super(`Checked ${operation} overflowed for ${leaf}.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soundscript/soundscript",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "license": "ISC",
   "type": "module",
   "sideEffects": false,
@@ -232,11 +232,11 @@
     "typescript": "5.9.3"
   },
   "optionalDependencies": {
-    "@soundscript/cli-darwin-arm64": "0.1.16",
-    "@soundscript/cli-darwin-x64": "0.1.16",
-    "@soundscript/cli-linux-arm64": "0.1.16",
-    "@soundscript/cli-linux-x64": "0.1.16",
-    "@soundscript/cli-win32-x64": "0.1.16"
+    "@soundscript/cli-darwin-arm64": "0.1.17",
+    "@soundscript/cli-darwin-x64": "0.1.17",
+    "@soundscript/cli-linux-arm64": "0.1.17",
+    "@soundscript/cli-linux-x64": "0.1.17",
+    "@soundscript/cli-win32-x64": "0.1.17"
   },
   "repository": {
     "type": "git",

package/project-transform/src/checker/rules/flow.js

@@ -3,6 +3,7 @@ import { SOUND_DIAGNOSTIC_CODES, SOUND_DIAGNOSTIC_MESSAGES } from '../engine/dia
 import { getNodeDiagnosticRange, } from '../diagnostics.js';
 import { getFlowChildRegionStructure, getFlowRegionStructure, materializeConditionStructures, } from './flow_facts.js';
 import { cloneState, FLOW_FACT_ENVIRONMENT, isFunctionLikeWithBody, prepareChildRegionState, recordExecutedExpressionAliases, recordVariableAliases, statementAffectsNarrow, } from './flow_invalidation.js';
+import { isConstLocalBindingPath } from './flow_shared.js';
 import { isInsideSyntheticErrorNormalizationHelper } from './generated_helpers.js';
 function boundaryKindLabel(kind) {
     switch (kind) {
@@ -114,6 +115,15 @@ function findInvalidation(context, statement, activeFacts, state) {
     }
     return undefined;
 }
+function factRequiresBoundaryInvalidation(fact) {
+    if (fact.path.segments.length !== 0 || !isConstLocalBindingPath(fact.path)) {
+        return true;
+    }
+    return fact.kind !== 'discriminantLiteral' &&
+        fact.kind !== 'nonNull' &&
+        fact.kind !== 'truthy' &&
+        fact.kind !== 'typeof';
+}
 function analyzeStatements(context, regionNode, statements, state, diagnostics, inheritedFacts = [], options = {}) {
     const region = regionNode ? getFlowRegionStructure(context, regionNode, statements, options) : {
         entries: statements.map((statement) => ({
@@ -134,7 +144,8 @@ function analyzeStatements(context, regionNode, statements, state, diagnostics,
                 boundaryKind: classifyBoundaryKind(sequentialAnalysis.invalidatingNode),
             }));
         }
-        const activeSequentialFacts = [...inheritedFacts, ...sequentialAnalysis.facts];
+        const activeSequentialFacts = [...inheritedFacts, ...sequentialAnalysis.facts]
+            .filter(factRequiresBoundaryInvalidation);
         const invalidatingNode = findInvalidation(context, statement, activeSequentialFacts, state);
         if (invalidatingNode) {
             diagnostics.push(createDiagnostic(context, invalidatingNode));
@@ -187,7 +198,8 @@ function analyzeRootRegion(context, regionNode, statements, diagnostics) {
 export function runFlowRules(context) {
     const diagnostics = [];
     context.forEachSourceFile((sourceFile) => {
-        analyzeRootRegion(context, sourceFile, sourceFile.statements.filter((statement) => !context.isGeneratedNode(statement)), diagnostics);
+        const rootStatements = sourceFile.statements.filter((statement) => !context.isGeneratedNode(statement));
+        analyzeRootRegion(context, sourceFile, rootStatements, diagnostics);
         context.traverse(sourceFile, (node) => {
             if (!isFunctionLikeWithBody(node)) {
                 return;
@@ -195,7 +207,8 @@ export function runFlowRules(context) {
             if (isInsideSyntheticErrorNormalizationHelper(node)) {
                 return;
             }
-            analyzeRootRegion(context, ts.isBlock(node.body) ? node.body : undefined, getRootStatements(node.body).filter((statement) => !context.isGeneratedNode(statement)), diagnostics);
+            const bodyStatements = getRootStatements(node.body).filter((statement) => !context.isGeneratedNode(statement));
+            analyzeRootRegion(context, ts.isBlock(node.body) ? node.body : undefined, bodyStatements, diagnostics);
         });
     });
     return diagnostics;

package/project-transform/src/checker/rules/flow.ts

@@ -25,6 +25,7 @@ import {
   recordVariableAliases,
   statementAffectsNarrow,
 } from './flow_invalidation.ts';
+import { isConstLocalBindingPath } from './flow_shared.ts';
 import { isInsideSyntheticErrorNormalizationHelper } from './generated_helpers.ts';
 
 type InvalidationBoundaryKind =
@@ -181,6 +182,19 @@ function findInvalidation(
   return undefined;
 }
 
+function factRequiresBoundaryInvalidation(
+  fact: FlowFact<NormalizedPath>,
+): boolean {
+  if (fact.path.segments.length !== 0 || !isConstLocalBindingPath(fact.path)) {
+    return true;
+  }
+
+  return fact.kind !== 'discriminantLiteral' &&
+    fact.kind !== 'nonNull' &&
+    fact.kind !== 'truthy' &&
+    fact.kind !== 'typeof';
+}
+
 function analyzeStatements(
   context: AnalysisContext,
   regionNode: ts.Node | undefined,
@@ -218,7 +232,8 @@ function analyzeStatements(
         }),
       );
     }
-    const activeSequentialFacts = [...inheritedFacts, ...sequentialAnalysis.facts];
+    const activeSequentialFacts = [...inheritedFacts, ...sequentialAnalysis.facts]
+      .filter(factRequiresBoundaryInvalidation);
     const invalidatingNode = findInvalidation(context, statement, activeSequentialFacts, state);
     if (invalidatingNode) {
       diagnostics.push(createDiagnostic(context, invalidatingNode));
@@ -305,10 +320,11 @@ export function runFlowRules(context: AnalysisContext): SoundDiagnostic[] {
   const diagnostics: SoundDiagnostic[] = [];
 
   context.forEachSourceFile((sourceFile) => {
+    const rootStatements = sourceFile.statements.filter((statement) => !context.isGeneratedNode(statement));
     analyzeRootRegion(
       context,
       sourceFile,
-      sourceFile.statements.filter((statement) => !context.isGeneratedNode(statement)),
+      rootStatements,
       diagnostics,
     );
 
@@ -320,10 +336,11 @@ export function runFlowRules(context: AnalysisContext): SoundDiagnostic[] {
         return;
       }
 
+      const bodyStatements = getRootStatements(node.body).filter((statement) => !context.isGeneratedNode(statement));
       analyzeRootRegion(
         context,
         ts.isBlock(node.body) ? node.body : undefined,
-        getRootStatements(node.body).filter((statement) => !context.isGeneratedNode(statement)),
+        bodyStatements,
         diagnostics,
       );
     });

package/project-transform/src/checker/rules/unsound_syntax.js

@@ -1583,9 +1583,6 @@ function getUnsupportedFeatureDiagnostic(context, node) {
             return unsupportedFeature(node.expression, 'prototypeMutation');
         }
     }
-    if (ts.isForInStatement(node)) {
-        return unsupportedFeature(node, 'forIn');
-    }
     if (ts.isLabeledStatement(node)) {
         return unsupportedFeature(node.label, 'labeledStatement');
     }

package/project-transform/src/checker/rules/unsound_syntax.ts

@@ -2381,10 +2381,6 @@ function getUnsupportedFeatureDiagnostic(
     }
   }
 
-  if (ts.isForInStatement(node)) {
-    return unsupportedFeature(node, 'forIn');
-  }
-
   if (ts.isLabeledStatement(node)) {
     return unsupportedFeature(node.label, 'labeledStatement');
   }

package/project-transform/src/cli.js

@@ -11,7 +11,7 @@ import { createTempDirectory, fileExistsSync, makeDirectory, readStdinText, remo
 import { materializeRuntimeGraph, } from './runtime/materialize.js';
 import { runProgram } from './run_program.js';
 import { projectEditorFile } from './editor_projection.js';
-export const VERSION = '0.1.16';
+export const VERSION = '0.1.17';
 const FINDINGS_EXIT_CODE = 1;
 const CLI_FAILURE_EXIT_CODE = 2;
 function createCliDiagnostic(code, message, filePath, details) {

package/project-transform/src/cli.ts

@@ -59,7 +59,7 @@ import {
 import { runProgram, type RunProgramOptions, type RunProgramResult } from './run_program.ts';
 import { projectEditorFile } from './editor_projection.ts';
 
-export const VERSION = '0.1.16';
+export const VERSION = '0.1.17';
 const FINDINGS_EXIT_CODE = 1;
 const CLI_FAILURE_EXIT_CODE = 2;
 

package/project-transform/src/compiler/compile_project.js

@@ -2,14 +2,14 @@ import ts from 'typescript';
 import { dirname, relative } from '../platform/path.js';
 import { createAnnotationLookup } from '../annotation_syntax.js';
 import { createSoundStdlibCompilerHost } from '../bundled/sound_stdlib.js';
-import { formatDiagnostics, getNodeDiagnosticRange, hasErrorDiagnostics, toMergedDiagnostic, } from '../checker/diagnostics.js';
+import { formatDiagnostics, getNodeDiagnosticRange, hasErrorDiagnostics, remapDiagnosticFilePaths, toMergedDiagnostic, } from '../checker/diagnostics.js';
 import { COMPILER_DIAGNOSTIC_CODES, COMPILER_DIAGNOSTIC_MESSAGES, } from '../checker/engine/diagnostic_codes.js';
 import { createAnalysisContext } from '../checker/engine/context.js';
 import { runSoundAnalysis } from '../checker/rules/index.js';
 import { runUniversalPolicyAnalysis } from '../checker/rules/universal.js';
 import { collectSoundscriptRootNames, getConfigFileParsingDiagnostics, loadConfig, } from '../config.js';
 import { createBuiltinExpandedProgram } from '../frontend/builtin_macro_support.js';
-import { getLineAndCharacterOfPosition, mapProgramEnclosingRangeToSource, toSourceFileName, } from '../frontend/project_frontend.js';
+import { getLineAndCharacterOfPosition, getPositionOfLineAndCharacter, mapProgramEnclosingRangeToSource, toSourceFileName, } from '../frontend/project_frontend.js';
 import { CompilerUnsupportedError } from './errors.js';
 import { lowerProgramToCompilerIR, validateHonestHeapBoundarySurfaces } from './lower.js';
 import { CompilerToolchainError, packageCompilerOutput, } from './toolchain.js';
@@ -57,6 +57,72 @@ function createCompilerDiagnosticForNode(node, overrides) {
         ...getNodeDiagnosticRange(node),
     };
 }
+function remapDiagnostics(diagnostics) {
+    return diagnostics.map((diagnostic) => remapDiagnosticFilePaths(diagnostic, toSourceFileName));
+}
+function hasRelatedInformation(diagnostic) {
+    return 'relatedInformation' in diagnostic;
+}
+function remapPreparedDiagnosticRange(diagnostic, preparedFile, diagnosticPreparedFiles) {
+    const remappedFilePath = diagnostic.filePath
+        ? toSourceFileName(diagnostic.filePath)
+        : diagnostic.filePath;
+    if (!preparedFile ||
+        !diagnostic.filePath ||
+        diagnostic.line === undefined ||
+        diagnostic.column === undefined) {
+        const remappedDiagnostic = {
+            ...diagnostic,
+            filePath: remappedFilePath,
+        };
+        if (hasRelatedInformation(diagnostic)) {
+            remappedDiagnostic.relatedInformation = diagnostic.relatedInformation?.map((relatedInformation) => remapPreparedDiagnosticRange(relatedInformation, relatedInformation.filePath
+                ? diagnosticPreparedFiles.get(toSourceFileName(relatedInformation.filePath))
+                : undefined, diagnosticPreparedFiles));
+        }
+        return remappedDiagnostic;
+    }
+    const programStart = getPositionOfLineAndCharacter(preparedFile.rewrittenText, diagnostic.line - 1, diagnostic.column - 1);
+    const programEnd = diagnostic.endLine !== undefined && diagnostic.endColumn !== undefined
+        ? getPositionOfLineAndCharacter(preparedFile.rewrittenText, diagnostic.endLine - 1, diagnostic.endColumn - 1)
+        : programStart;
+    const mappedRange = mapProgramEnclosingRangeToSource(preparedFile, programStart, programEnd);
+    const mappedStart = getLineAndCharacterOfPosition(preparedFile.originalText, mappedRange.start);
+    const mappedEnd = getLineAndCharacterOfPosition(preparedFile.originalText, mappedRange.end);
+    const remappedDiagnostic = {
+        ...diagnostic,
+        filePath: remappedFilePath,
+        line: mappedStart.line + 1,
+        column: mappedStart.character + 1,
+        endLine: mappedEnd.line + 1,
+        endColumn: mappedEnd.character + 1,
+    };
+    if (hasRelatedInformation(diagnostic)) {
+        remappedDiagnostic.relatedInformation = diagnostic.relatedInformation?.map((relatedInformation) => {
+            const relatedPreparedFile = relatedInformation.filePath
+                ? diagnosticPreparedFiles.get(toSourceFileName(relatedInformation.filePath))
+                : undefined;
+            return remapPreparedDiagnosticRange(relatedInformation, relatedPreparedFile, diagnosticPreparedFiles);
+        });
+    }
+    return remappedDiagnostic;
+}
+function remapSoundDiagnostics(diagnostics, diagnosticPreparedFiles) {
+    return diagnostics.map((diagnostic) => {
+        const preparedFile = diagnostic.filePath
+            ? diagnosticPreparedFiles.get(toSourceFileName(diagnostic.filePath))
+            : undefined;
+        return remapPreparedDiagnosticRange(diagnostic, preparedFile, diagnosticPreparedFiles);
+    });
+}
+function remapCompilerDiagnostics(diagnostics, diagnosticPreparedFiles) {
+    return diagnostics.map((diagnostic) => {
+        const preparedFile = diagnostic.filePath
+            ? diagnosticPreparedFiles.get(toSourceFileName(diagnostic.filePath))
+            : undefined;
+        return remapPreparedDiagnosticRange(diagnostic, preparedFile, diagnosticPreparedFiles);
+    });
+}
 function createProgram(options) {
     const loadedConfig = loadConfig(options.projectPath, { target: options.target });
     const soundscriptRootNames = collectSoundscriptRootNames(options.projectPath, loadedConfig);
@@ -78,7 +144,7 @@ function createProgram(options) {
         analysisPreparedProgram: expandedProgram.analysisPreparedProgram,
         diagnosticPreparedFiles: expandedProgram.diagnosticPreparedFiles,
         dispose: () => expandedProgram.dispose(),
-        frontendDiagnostics: expandedProgram.frontendDiagnostics(),
+        frontendDiagnostics: remapDiagnostics(expandedProgram.frontendDiagnostics()),
         program: expandedProgram.program,
         runtime: loadedConfig.runtime,
         tsDiagnosticPrograms: expandedProgram.tsDiagnosticPrograms,
@@ -193,7 +259,7 @@ function collectDiagnostics(analysisPreparedProgram, diagnosticPreparedFiles, pr
         workingDirectory,
         includeSourceFile: (sourceFile) => !sourceFile.isDeclarationFile,
     });
-    const universalDiagnostics = runUniversalPolicyAnalysis(analysisContext);
+    const universalDiagnostics = remapSoundDiagnostics(runUniversalPolicyAnalysis(analysisContext), diagnosticPreparedFiles);
     if (hasErrorDiagnostics(tsDiagnostics)) {
         return [...frontendDiagnostics, ...tsDiagnostics, ...universalDiagnostics];
     }
@@ -201,7 +267,7 @@ function collectDiagnostics(analysisPreparedProgram, diagnosticPreparedFiles, pr
         ...frontendDiagnostics,
         ...tsDiagnostics,
         ...universalDiagnostics,
-        ...runSoundAnalysis(analysisContext),
+        ...remapSoundDiagnostics(runSoundAnalysis(analysisContext), diagnosticPreparedFiles),
     ];
 }
 function findUnsupportedValueClass(program) {
@@ -242,13 +308,13 @@ export function compileProject(options) {
         }
         const unsupportedValueClass = findUnsupportedValueClass(program);
         if (unsupportedValueClass) {
-            const compilerDiagnostics = [
+            const compilerDiagnostics = remapCompilerDiagnostics([
                 createCompilerDiagnosticForNode(unsupportedValueClass, {
                     code: COMPILER_DIAGNOSTIC_CODES.valueClassesRequireJsEmit,
                     message: COMPILER_DIAGNOSTIC_MESSAGES.valueClassesRequireJsEmit,
                     hint: 'Use `soundscript build`, `soundscript node`, or another JS emit path for `#[value]`, or remove the annotation before compiling to Wasm.',
                 }),
-            ];
+            ], diagnosticPreparedFiles);
             return {
                 diagnostics: compilerDiagnostics,
                 output: formatDiagnostics(compilerDiagnostics, options.workingDirectory),
@@ -286,11 +352,11 @@ export function compileProject(options) {
                     hint: error.diagnosticHint,
                     notes: error.diagnosticNotes,
                 };
-                const compilerDiagnostics = [
+                const compilerDiagnostics = remapCompilerDiagnostics([
                     error.node
                         ? createCompilerDiagnosticForNode(error.node, diagnosticOverrides)
                         : createCompilerDiagnostic(options.projectPath, diagnosticOverrides),
-                ];
+                ], diagnosticPreparedFiles);
                 return {
                     diagnostics: compilerDiagnostics,
                     output: formatDiagnostics(compilerDiagnostics, options.workingDirectory),

package/project-transform/src/compiler/compile_project.ts

@@ -10,6 +10,7 @@ import {
   getNodeDiagnosticRange,
   hasErrorDiagnostics,
   type MergedDiagnostic,
+  remapDiagnosticFilePaths,
   toMergedDiagnostic,
 } from '../checker/diagnostics.ts';
 import {
@@ -29,6 +30,7 @@ import {
 import { createBuiltinExpandedProgram } from '../frontend/builtin_macro_support.ts';
 import {
   getLineAndCharacterOfPosition,
+  getPositionOfLineAndCharacter,
   mapProgramEnclosingRangeToSource,
   type PreparedSourceFile,
   toSourceFileName,
@@ -118,6 +120,115 @@ function createCompilerDiagnosticForNode(
   };
 }
 
+function remapDiagnostics<T extends MergedDiagnostic>(diagnostics: readonly T[]): T[] {
+  return diagnostics.map((diagnostic) => remapDiagnosticFilePaths(diagnostic, toSourceFileName));
+}
+
+function hasRelatedInformation(
+  diagnostic: MergedDiagnostic | DiagnosticRelatedInformation,
+): diagnostic is MergedDiagnostic {
+  return 'relatedInformation' in diagnostic;
+}
+
+function remapPreparedDiagnosticRange<T extends MergedDiagnostic | DiagnosticRelatedInformation>(
+  diagnostic: T,
+  preparedFile: PreparedSourceFile | undefined,
+  diagnosticPreparedFiles: ReadonlyMap<string, PreparedSourceFile>,
+): T {
+  const remappedFilePath = diagnostic.filePath
+    ? toSourceFileName(diagnostic.filePath)
+    : diagnostic.filePath;
+
+  if (
+    !preparedFile ||
+    !diagnostic.filePath ||
+    diagnostic.line === undefined ||
+    diagnostic.column === undefined
+  ) {
+    const remappedDiagnostic = {
+      ...diagnostic,
+      filePath: remappedFilePath,
+    } as T;
+    if (hasRelatedInformation(diagnostic)) {
+      (remappedDiagnostic as MergedDiagnostic).relatedInformation = diagnostic.relatedInformation?.map(
+        (relatedInformation) =>
+          remapPreparedDiagnosticRange(
+            relatedInformation,
+            relatedInformation.filePath
+              ? diagnosticPreparedFiles.get(toSourceFileName(relatedInformation.filePath))
+              : undefined,
+            diagnosticPreparedFiles,
+          ),
+      );
+    }
+    return remappedDiagnostic;
+  }
+
+  const programStart = getPositionOfLineAndCharacter(
+    preparedFile.rewrittenText,
+    diagnostic.line - 1,
+    diagnostic.column - 1,
+  );
+  const programEnd = diagnostic.endLine !== undefined && diagnostic.endColumn !== undefined
+    ? getPositionOfLineAndCharacter(
+      preparedFile.rewrittenText,
+      diagnostic.endLine - 1,
+      diagnostic.endColumn - 1,
+    )
+    : programStart;
+  const mappedRange = mapProgramEnclosingRangeToSource(preparedFile, programStart, programEnd);
+  const mappedStart = getLineAndCharacterOfPosition(preparedFile.originalText, mappedRange.start);
+  const mappedEnd = getLineAndCharacterOfPosition(preparedFile.originalText, mappedRange.end);
+
+  const remappedDiagnostic = {
+    ...diagnostic,
+    filePath: remappedFilePath,
+    line: mappedStart.line + 1,
+    column: mappedStart.character + 1,
+    endLine: mappedEnd.line + 1,
+    endColumn: mappedEnd.character + 1,
+  } as T;
+  if (hasRelatedInformation(diagnostic)) {
+    (remappedDiagnostic as MergedDiagnostic).relatedInformation = diagnostic.relatedInformation?.map(
+      (relatedInformation) => {
+        const relatedPreparedFile = relatedInformation.filePath
+          ? diagnosticPreparedFiles.get(toSourceFileName(relatedInformation.filePath))
+          : undefined;
+        return remapPreparedDiagnosticRange(
+          relatedInformation,
+          relatedPreparedFile,
+          diagnosticPreparedFiles,
+        );
+      },
+    );
+  }
+  return remappedDiagnostic;
+}
+
+function remapSoundDiagnostics<T extends MergedDiagnostic>(
+  diagnostics: readonly T[],
+  diagnosticPreparedFiles: ReadonlyMap<string, PreparedSourceFile>,
+): T[] {
+  return diagnostics.map((diagnostic) => {
+    const preparedFile = diagnostic.filePath
+      ? diagnosticPreparedFiles.get(toSourceFileName(diagnostic.filePath))
+      : undefined;
+    return remapPreparedDiagnosticRange(diagnostic, preparedFile, diagnosticPreparedFiles);
+  });
+}
+
+function remapCompilerDiagnostics<T extends MergedDiagnostic>(
+  diagnostics: readonly T[],
+  diagnosticPreparedFiles: ReadonlyMap<string, PreparedSourceFile>,
+): T[] {
+  return diagnostics.map((diagnostic) => {
+    const preparedFile = diagnostic.filePath
+      ? diagnosticPreparedFiles.get(toSourceFileName(diagnostic.filePath))
+      : undefined;
+    return remapPreparedDiagnosticRange(diagnostic, preparedFile, diagnosticPreparedFiles);
+  });
+}
+
 function createProgram(options: CompileProjectOptions): {
   analysisPreparedProgram: {
     toProgramFileName(fileName: string): string;
@@ -159,7 +270,7 @@ function createProgram(options: CompileProjectOptions): {
     analysisPreparedProgram: expandedProgram.analysisPreparedProgram,
     diagnosticPreparedFiles: expandedProgram.diagnosticPreparedFiles,
     dispose: () => expandedProgram.dispose(),
-    frontendDiagnostics: expandedProgram.frontendDiagnostics(),
+    frontendDiagnostics: remapDiagnostics(expandedProgram.frontendDiagnostics()),
     program: expandedProgram.program,
     runtime: loadedConfig.runtime,
     tsDiagnosticPrograms: expandedProgram.tsDiagnosticPrograms,
@@ -356,7 +467,10 @@ function collectDiagnostics(
     workingDirectory,
     includeSourceFile: (sourceFile) => !sourceFile.isDeclarationFile,
   });
-  const universalDiagnostics = runUniversalPolicyAnalysis(analysisContext);
+  const universalDiagnostics = remapSoundDiagnostics(
+    runUniversalPolicyAnalysis(analysisContext),
+    diagnosticPreparedFiles,
+  );
   if (hasErrorDiagnostics(tsDiagnostics)) {
     return [...frontendDiagnostics, ...tsDiagnostics, ...universalDiagnostics];
   }
@@ -365,7 +479,7 @@ function collectDiagnostics(
     ...frontendDiagnostics,
     ...tsDiagnostics,
     ...universalDiagnostics,
-    ...runSoundAnalysis(analysisContext),
+    ...remapSoundDiagnostics(runSoundAnalysis(analysisContext), diagnosticPreparedFiles),
   ];
 }
 
@@ -430,14 +544,14 @@ export function compileProject(options: CompileProjectOptions): CompileProjectRe
 
     const unsupportedValueClass = findUnsupportedValueClass(program);
     if (unsupportedValueClass) {
-      const compilerDiagnostics = [
+      const compilerDiagnostics = remapCompilerDiagnostics([
         createCompilerDiagnosticForNode(unsupportedValueClass, {
           code: COMPILER_DIAGNOSTIC_CODES.valueClassesRequireJsEmit,
           message: COMPILER_DIAGNOSTIC_MESSAGES.valueClassesRequireJsEmit,
           hint:
             'Use `soundscript build`, `soundscript node`, or another JS emit path for `#[value]`, or remove the annotation before compiling to Wasm.',
         }),
-      ];
+      ], diagnosticPreparedFiles);
       return {
         diagnostics: compilerDiagnostics,
         output: formatDiagnostics(compilerDiagnostics, options.workingDirectory),
@@ -475,11 +589,11 @@ export function compileProject(options: CompileProjectOptions): CompileProjectRe
           hint: error.diagnosticHint,
           notes: error.diagnosticNotes,
         };
-        const compilerDiagnostics = [
+        const compilerDiagnostics = remapCompilerDiagnostics([
           error.node
             ? createCompilerDiagnosticForNode(error.node, diagnosticOverrides)
             : createCompilerDiagnostic(options.projectPath, diagnosticOverrides),
-        ];
+        ], diagnosticPreparedFiles);
         return {
           diagnostics: compilerDiagnostics,
           output: formatDiagnostics(compilerDiagnostics, options.workingDirectory),

package/project-transform/src/compiler/ir.ts

@@ -1337,6 +1337,15 @@ export interface CompilerWhileStatementIR {
   body: CompilerStatementIR[];
 }
 
+export interface CompilerTrapStatementIR {
+  kind: 'trap';
+}
+
+export interface CompilerThrowTaggedStatementIR {
+  kind: 'throw_tagged';
+  value: CompilerExpressionIR;
+}
+
 export type CompilerStatementIR =
   | CompilerLocalSetStatementIR
   | CompilerReturnStatementIR
@@ -1350,7 +1359,9 @@ export type CompilerStatementIR =
   | CompilerBoxSetStatementIR
   | CompilerDynamicObjectPropertySetStatementIR
   | CompilerIfStatementIR
-  | CompilerWhileStatementIR;
+  | CompilerWhileStatementIR
+  | CompilerTrapStatementIR
+  | CompilerThrowTaggedStatementIR;
 
 export interface CompilerTaggedPrimitiveBoundaryKindsIR {
   includesBoolean?: boolean;
@@ -1442,6 +1453,7 @@ export interface CompilerFunctionIR {
   hostImport?: {
     module: string;
     name: string;
+    construct?: boolean;
     promiseResult?: boolean;
   };
   hostClassConstructorParams?: readonly CompilerFunctionHostClassConstructorParamIR[];
@@ -1455,6 +1467,9 @@ export interface CompilerFunctionIR {
   hostDynamicCollectionParams?: readonly CompilerFunctionHostDynamicCollectionParamIR[];
   hostPromiseParams?: readonly string[];
   hostPromiseResult?: boolean;
+  hostGeneratorResult?: boolean;
+  hostAsyncGeneratorResult?: boolean;
+  usesAsyncGeneratorHostStepBridge?: boolean;
   hostFallbackClosureProperties?: readonly CompilerFunctionHostFallbackClosurePropertyIR[];
   hostFallbackClassConstructorProperties?:
     readonly CompilerFunctionHostFallbackClassConstructorPropertyIR[];
@@ -1494,6 +1509,7 @@ export interface CompilerFunctionHostDynamicCollectionParamIR {
 
 export interface CompilerModuleIR {
   closureSignatures?: readonly CompilerClosureSignatureIR[];
+  syncTryCatchClosureSignatureId?: number;
   functions: CompilerFunctionIR[];
   jsHostImports?: readonly CompilerJsHostImportIR[];
   stringLiterals?: readonly string[];
@@ -1503,10 +1519,12 @@ export interface CompilerModuleIR {
 
 export interface CompilerJsHostImportIR {
   hostImportName: string;
+  bindingKind: 'function' | 'constructor' | 'static_method' | 'property';
   importKind: 'default' | 'named';
   importerModulePath: string;
   moduleSpecifier: string;
   exportName?: string;
+  memberName?: string;
 }
 
 export interface CompilerClosureSignatureIR {