@soundscript/soundscript 0.1.13 → 0.1.15

package/project-transform/src/frontend/macro_rewrite.ts

@@ -0,0 +1,442 @@
+import ts from 'typescript';
+
+import { BUILTIN_DIRECTIVE_NAMES, createAnnotationLookup } from '../annotation_syntax.ts';
+import { scanMacroCandidates } from './macro_scanner.ts';
+import type {
+  MacroGeneratedSpan,
+  MacroParseDiagnostic,
+  MacroReplacement,
+  ParsedMacroArgument,
+  ParsedMacroInvocation,
+  RewriteResult,
+  SourceSpan,
+} from './macro_types.ts';
+
+type MacroSite =
+  | {
+    argumentSpans: readonly ParsedMacroArgument[];
+    declarationKind?: never;
+    declarationName?: never;
+    declarationSpan?: never;
+    invocationKind: 'arglist';
+    kind: 'call' | 'tag';
+    nameSpan: SourceSpan;
+    nameText: string;
+    replacementSpan: SourceSpan;
+    span: SourceSpan;
+    rewriteKind: 'expr' | 'stmt';
+    trailingBlockSpan?: never;
+  }
+  | {
+    argumentSpans: readonly ParsedMacroArgument[];
+    declarationKind: 'class' | 'function' | 'interface' | 'typeAlias';
+    declarationName: string | null;
+    declarationSpan: SourceSpan;
+    invocationKind: 'decl';
+    kind: 'annotation';
+    nameSpan: SourceSpan;
+    nameText: string;
+    preserveDeclaration: boolean;
+    replacementSpan: SourceSpan;
+    span: SourceSpan;
+    rewriteKind: 'stmt';
+    trailingBlockSpan?: never;
+  };
+
+interface ImportedMacroBindings {
+  readonly annotationNames: ReadonlySet<string>;
+  readonly callNames: ReadonlySet<string>;
+  readonly tagNames: ReadonlySet<string>;
+}
+
+export type ImportedMacroSiteKind = 'annotation' | 'call' | 'tag';
+
+function createSpan(fileName: string, start: number, end: number): SourceSpan {
+  return { fileName, start, end };
+}
+
+function createPlaceholder(
+  id: number,
+  rewriteKind: ParsedMacroInvocation['rewriteKind'],
+): string {
+  return rewriteKind === 'expr' ? `__sts_macro_expr(${id})` : `__sts_macro_stmt(${id});`;
+}
+
+function scriptKindForFile(fileName: string): ts.ScriptKind {
+  const lowered = fileName.toLowerCase();
+  if (lowered.endsWith('.sts') || lowered.endsWith('.tsx') || lowered.endsWith('.jsx')) {
+    return ts.ScriptKind.TSX;
+  }
+  if (lowered.endsWith('.js') || lowered.endsWith('.mjs') || lowered.endsWith('.cjs')) {
+    return ts.ScriptKind.JS;
+  }
+  return ts.ScriptKind.TS;
+}
+
+function collectImportedMacroBindings(
+  sourceFile: ts.SourceFile,
+  importedMacroSiteKindsBySpecifier: ReadonlyMap<string, ReadonlyMap<string, ImportedMacroSiteKind>>,
+): ImportedMacroBindings {
+  const callNames = new Set<string>();
+  const tagNames = new Set<string>();
+  const annotationNames = new Set<string>();
+
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement)) {
+      continue;
+    }
+
+    const explicitKinds = ts.isStringLiteral(statement.moduleSpecifier)
+      ? importedMacroSiteKindsBySpecifier.get(statement.moduleSpecifier.text)
+      : undefined;
+    if (!explicitKinds) {
+      continue;
+    }
+
+    if (statement.importClause?.name) {
+      const localName = statement.importClause.name.text;
+      const explicitKind = explicitKinds.get('default');
+      if (explicitKind === 'annotation' && !BUILTIN_DIRECTIVE_NAMES.has(localName)) {
+        annotationNames.add(localName);
+      } else if (explicitKind === 'call') {
+        callNames.add(localName);
+      } else if (explicitKind === 'tag') {
+        tagNames.add(localName);
+      }
+    }
+
+    const namedBindings = statement.importClause?.namedBindings;
+    if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+      continue;
+    }
+
+    for (const element of namedBindings.elements) {
+      const localName = element.name.text;
+      const exportName = element.propertyName?.text ?? localName;
+      const explicitKind = explicitKinds?.get(exportName);
+      if (explicitKind === 'annotation' && !BUILTIN_DIRECTIVE_NAMES.has(localName)) {
+        annotationNames.add(localName);
+        continue;
+      }
+      if (explicitKind === 'call') {
+        callNames.add(localName);
+        continue;
+      }
+      if (explicitKind === 'tag') {
+        tagNames.add(localName);
+        continue;
+      }
+    }
+  }
+
+  return { annotationNames, callNames, tagNames };
+}
+
+function parentExpressionStatement(node: ts.Node): ts.ExpressionStatement | null {
+  return ts.isExpressionStatement(node.parent) && node.parent.expression === node
+    ? node.parent
+    : null;
+}
+
+function getRewriteKindForCall(node: ts.CallExpression): 'expr' | 'stmt' {
+  return parentExpressionStatement(node) ? 'stmt' : 'expr';
+}
+
+function createCallSite(sourceFile: ts.SourceFile, node: ts.CallExpression): MacroSite {
+  const statement = parentExpressionStatement(node);
+  return {
+    kind: 'call',
+    argumentSpans: node.arguments.map((argument) => ({
+      kind: 'ExprArg' as const,
+      span: createSpan(sourceFile.fileName, argument.getStart(sourceFile), argument.getEnd()),
+    })),
+    invocationKind: 'arglist',
+    nameSpan: createSpan(
+      sourceFile.fileName,
+      node.expression.getStart(sourceFile),
+      node.expression.getEnd(),
+    ),
+    nameText: (node.expression as ts.Identifier).text,
+    replacementSpan: createSpan(
+      sourceFile.fileName,
+      statement?.getStart(sourceFile) ?? node.getStart(sourceFile),
+      statement?.getEnd() ?? node.getEnd(),
+    ),
+    span: createSpan(sourceFile.fileName, node.getStart(sourceFile), node.getEnd()),
+    rewriteKind: getRewriteKindForCall(node),
+  };
+}
+
+function createTagSite(sourceFile: ts.SourceFile, node: ts.TaggedTemplateExpression): MacroSite {
+  return {
+    kind: 'tag',
+    argumentSpans: [{
+      kind: 'ExprArg',
+      span: createSpan(
+        sourceFile.fileName,
+        node.template.getStart(sourceFile),
+        node.template.getEnd(),
+      ),
+    }],
+    invocationKind: 'arglist',
+    nameSpan: createSpan(sourceFile.fileName, node.tag.getStart(sourceFile), node.tag.getEnd()),
+    nameText: (node.tag as ts.Identifier).text,
+    replacementSpan: createSpan(sourceFile.fileName, node.getStart(sourceFile), node.getEnd()),
+    span: createSpan(sourceFile.fileName, node.getStart(sourceFile), node.getEnd()),
+    rewriteKind: 'expr',
+  };
+}
+
+function isMacroDeclarationTarget(
+  node: ts.Statement,
+): node is
+  | ts.ClassDeclaration
+  | ts.FunctionDeclaration
+  | ts.InterfaceDeclaration
+  | ts.TypeAliasDeclaration {
+  return ts.isClassDeclaration(node) || ts.isFunctionDeclaration(node) ||
+    ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node);
+}
+
+function findAnnotationSites(
+  annotationLookup: ReturnType<typeof createAnnotationLookup>,
+  sourceFile: ts.SourceFile,
+  node: ts.ClassDeclaration | ts.FunctionDeclaration | ts.InterfaceDeclaration | ts.TypeAliasDeclaration,
+  annotationNames: ReadonlySet<string>,
+): readonly MacroSite[] {
+  if (annotationNames.size === 0) {
+    return [];
+  }
+
+  const block = annotationLookup.getAttachedAnnotationBlock(node);
+  const matchedAnnotations = block?.annotations.filter((annotation) =>
+    annotation.nameRange && annotationNames.has(annotation.name)
+  ) ?? [];
+  if (!block || matchedAnnotations.length === 0) {
+    return [];
+  }
+
+  const nodeStart = node.getStart(sourceFile);
+  const declarationKind = ts.isClassDeclaration(node)
+    ? 'class'
+    : ts.isFunctionDeclaration(node)
+    ? 'function'
+    : ts.isInterfaceDeclaration(node)
+    ? 'interface'
+    : 'typeAlias';
+  return matchedAnnotations.map((annotation, index) => ({
+    kind: 'annotation',
+    argumentSpans: [],
+    declarationKind,
+    declarationName: node.name?.text ?? null,
+    declarationSpan: createSpan(sourceFile.fileName, nodeStart, node.getEnd()),
+    invocationKind: 'decl',
+    nameSpan: createSpan(
+      sourceFile.fileName,
+      annotation.nameRange!.start,
+      annotation.nameRange!.end,
+    ),
+    nameText: annotation.name,
+    preserveDeclaration: index === 0,
+    replacementSpan: createSpan(sourceFile.fileName, block.range.start, node.getEnd()),
+    span: createSpan(sourceFile.fileName, block.range.start, node.getEnd()),
+    rewriteKind: 'stmt',
+  }));
+}
+
+function collectMacroSites(
+  sourceFile: ts.SourceFile,
+  importedMacroSiteKindsBySpecifier: ReadonlyMap<string, ReadonlyMap<string, ImportedMacroSiteKind>>,
+  alwaysAvailableMacroSiteKinds: ReadonlyMap<string, ImportedMacroSiteKind>,
+): readonly MacroSite[] {
+  const bindings = collectImportedMacroBindings(sourceFile, importedMacroSiteKindsBySpecifier);
+  const annotationLookup = createAnnotationLookup(sourceFile);
+  for (const [name, kind] of alwaysAvailableMacroSiteKinds.entries()) {
+    if (kind === 'annotation') {
+      (bindings.annotationNames as Set<string>).add(name);
+      continue;
+    }
+    if (kind === 'call') {
+      (bindings.callNames as Set<string>).add(name);
+      continue;
+    }
+    (bindings.tagNames as Set<string>).add(name);
+  }
+  const sites: MacroSite[] = [];
+
+  for (const statement of sourceFile.statements) {
+    if (!isMacroDeclarationTarget(statement)) {
+      continue;
+    }
+
+    const annotationSites = findAnnotationSites(
+      annotationLookup,
+      sourceFile,
+      statement,
+      bindings.annotationNames,
+    );
+    sites.push(...annotationSites);
+  }
+
+  const visit = (node: ts.Node): void => {
+    if (
+      ts.isCallExpression(node) && ts.isIdentifier(node.expression) &&
+      bindings.callNames.has(node.expression.text)
+    ) {
+      sites.push(createCallSite(sourceFile, node));
+      return;
+    }
+
+    if (
+      ts.isTaggedTemplateExpression(node) &&
+      ts.isIdentifier(node.tag) &&
+      bindings.tagNames.has(node.tag.text)
+    ) {
+      sites.push(createTagSite(sourceFile, node));
+      return;
+    }
+
+    ts.forEachChild(node, visit);
+  };
+
+  ts.forEachChild(sourceFile, visit);
+  sites.sort((left, right) => left.replacementSpan.start - right.replacementSpan.start);
+
+  const filtered: MacroSite[] = [];
+  let currentEnd = -1;
+  let currentStart = -1;
+  for (const site of sites) {
+    const sameReplacementSpan = site.replacementSpan.start === currentStart &&
+      site.replacementSpan.end === currentEnd;
+    if (site.replacementSpan.start < currentEnd && !sameReplacementSpan) {
+      continue;
+    }
+    filtered.push(site);
+    currentStart = site.replacementSpan.start;
+    currentEnd = site.replacementSpan.end;
+  }
+
+  return filtered;
+}
+
+function createLegacySyntaxDiagnostic(
+  fileName: string,
+  start: number,
+  end: number,
+): MacroParseDiagnostic {
+  return {
+    fileName,
+    reason: 'legacy-syntax',
+    span: createSpan(fileName, start, end),
+  };
+}
+
+function toParsedInvocation(site: MacroSite): ParsedMacroInvocation {
+  return {
+    argumentSpans: site.argumentSpans,
+    declarationKind: site.kind === 'annotation' ? site.declarationKind : undefined,
+    declarationName: site.kind === 'annotation' ? site.declarationName : undefined,
+    preserveDeclaration: site.kind === 'annotation' ? site.preserveDeclaration : undefined,
+    declarationSpan: site.kind === 'annotation' ? site.declarationSpan : undefined,
+    fileName: site.span.fileName,
+    hashSpan: site.nameSpan,
+    nameSpan: site.nameSpan,
+    nameText: site.nameText,
+    siteKind: site.kind,
+    span: site.span,
+    trailingBlockSpan: undefined,
+    invocationKind: site.invocationKind,
+    rewriteKind: site.rewriteKind,
+  };
+}
+
+function buildRewriteResult(
+  text: string,
+  sites: readonly MacroSite[],
+): RewriteResult {
+  const replacements: MacroReplacement[] = [];
+  const generatedSpans: MacroGeneratedSpan[] = [];
+  const macrosById = new Map<number, ParsedMacroInvocation>();
+  let rewrittenText = '';
+  let cursor = 0;
+  let nextId = 1;
+
+  for (const site of sites) {
+    const id = nextId;
+    nextId += 1;
+    const placeholder = createPlaceholder(id, site.rewriteKind);
+    rewrittenText += text.slice(cursor, site.replacementSpan.start);
+    const generatedStart = rewrittenText.length;
+    rewrittenText += placeholder;
+    const generatedEnd = rewrittenText.length;
+    cursor = site.replacementSpan.end;
+
+    const rewrittenSpan = {
+      fileName: site.span.fileName,
+      start: generatedStart,
+      end: generatedEnd,
+    };
+    replacements.push({
+      id,
+      originalSpan: site.replacementSpan,
+      rewriteText: placeholder,
+      rewrittenSpan,
+    });
+    generatedSpans.push({
+      generatedEnd,
+      generatedFileName: site.span.fileName,
+      generatedStart,
+      id,
+      originalSpan: site.replacementSpan,
+    });
+    macrosById.set(id, toParsedInvocation(site));
+  }
+
+  rewrittenText += text.slice(cursor);
+  return {
+    diagnostics: [],
+    generatedSpans,
+    macrosById,
+    replacements,
+    rewrittenText,
+  };
+}
+
+export function rewriteMacroSource(
+  fileName: string,
+  text: string,
+  importedMacroSiteKindsBySpecifier: ReadonlyMap<string, ReadonlyMap<string, ImportedMacroSiteKind>> = new Map(),
+  alwaysAvailableMacroSiteKinds: ReadonlyMap<string, ImportedMacroSiteKind> = new Map(),
+): RewriteResult {
+  const legacyHashes = scanMacroCandidates(fileName, text).hashes.filter((hash) =>
+    hash.kind === 'macro-start'
+  );
+  if (legacyHashes.length > 0) {
+    const firstLegacyHash = legacyHashes[0]!;
+    return {
+      diagnostics: [
+        createLegacySyntaxDiagnostic(
+          fileName,
+          firstLegacyHash.span.start,
+          firstLegacyHash.span.end,
+        ),
+      ],
+      generatedSpans: [],
+      macrosById: new Map(),
+      replacements: [],
+      rewrittenText: text,
+    };
+  }
+
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    text,
+    ts.ScriptTarget.Latest,
+    true,
+    scriptKindForFile(fileName),
+  );
+  return buildRewriteResult(
+    text,
+    collectMacroSites(sourceFile, importedMacroSiteKindsBySpecifier, alwaysAvailableMacroSiteKinds),
+  );
+}

package/project-transform/src/frontend/macro_runtime_support.js

@@ -0,0 +1,232 @@
+import ts from 'typescript';
+import { builtinRuntimeImportSpecifier, isBuiltinRuntimeModuleSpecifier, } from '../soundscript_runtime_specifiers.js';
+import { dirname, join, normalize, relative } from '../platform/path.js';
+function extractSoundscriptSourceTarget(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const source = value.source;
+    return typeof source === 'string' ? source : null;
+}
+function normalizePath(fileName) {
+    const normalized = normalize(fileName);
+    return ts.sys.useCaseSensitiveFileNames ? normalized : normalized.toLowerCase();
+}
+function findNearestPackageJson(startFileName, host) {
+    let currentDirectory = dirname(startFileName);
+    const visited = new Set();
+    while (!visited.has(normalizePath(currentDirectory))) {
+        visited.add(normalizePath(currentDirectory));
+        const packageJsonPath = join(currentDirectory, 'package.json');
+        if (host.fileExists(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        const parentDirectory = dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            return null;
+        }
+        currentDirectory = parentDirectory;
+    }
+    return null;
+}
+function readPackageRuntimeMetadata(startFileName, host) {
+    const packageJsonPath = findNearestPackageJson(startFileName, host);
+    if (!packageJsonPath) {
+        return null;
+    }
+    const packageJsonText = host.readFile(packageJsonPath);
+    if (!packageJsonText) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(packageJsonText);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        return null;
+    }
+    const record = parsed;
+    const packageRoot = dirname(packageJsonPath);
+    const ordinaryExports = collectOrdinaryExportSubpaths(record.exports);
+    const soundscriptExports = new Map();
+    const soundscript = record.soundscript;
+    if (soundscript && typeof soundscript === 'object') {
+        const exportsRecord = soundscript.exports;
+        if (exportsRecord && typeof exportsRecord === 'object') {
+            for (const [subpath, target] of Object.entries(exportsRecord)) {
+                const sourceTarget = extractSoundscriptSourceTarget(target);
+                if (!sourceTarget) {
+                    continue;
+                }
+                soundscriptExports.set(subpath, normalize(sourceTarget.startsWith('/') ? sourceTarget : join(packageRoot, sourceTarget)));
+            }
+        }
+    }
+    return {
+        name: typeof record.name === 'string' && record.name.length > 0 ? record.name : undefined,
+        ordinaryExports,
+        packageJsonPath,
+        packageRoot,
+        soundscriptExports,
+    };
+}
+function exportShapeHasStringTarget(value) {
+    if (typeof value === 'string') {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.some((entry) => exportShapeHasStringTarget(entry));
+    }
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    return Object.values(value).some((entry) => exportShapeHasStringTarget(entry));
+}
+function collectOrdinaryExportSubpaths(exportsField) {
+    const subpaths = new Set();
+    if (typeof exportsField === 'string' || Array.isArray(exportsField)) {
+        if (exportShapeHasStringTarget(exportsField)) {
+            subpaths.add('.');
+        }
+        return subpaths;
+    }
+    if (!exportsField || typeof exportsField !== 'object') {
+        return subpaths;
+    }
+    const entries = Object.entries(exportsField);
+    const hasSubpathKeys = entries.some(([key]) => key.startsWith('.'));
+    if (hasSubpathKeys) {
+        for (const [key, value] of entries) {
+            if (key.startsWith('.') && exportShapeHasStringTarget(value)) {
+                subpaths.add(key);
+            }
+        }
+        return subpaths;
+    }
+    if (exportShapeHasStringTarget(exportsField)) {
+        subpaths.add('.');
+    }
+    return subpaths;
+}
+function createModuleResolutionHost(preparedProgram) {
+    const baseHost = preparedProgram.preparedHost.host;
+    return {
+        directoryExists: baseHost.directoryExists?.bind(baseHost),
+        fileExists: baseHost.fileExists.bind(baseHost),
+        getCurrentDirectory: baseHost.getCurrentDirectory?.bind(baseHost) ??
+            (() => ts.sys.getCurrentDirectory()),
+        getDirectories: baseHost.getDirectories?.bind(baseHost),
+        readFile: baseHost.readFile.bind(baseHost),
+        realpath: baseHost.realpath?.bind(baseHost),
+        useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,
+    };
+}
+function sanitizeSpecifierForIdentifier(specifier) {
+    return specifier.replace(/[^A-Za-z0-9_$]+/gu, '_').replace(/^_+/u, '');
+}
+function fnv1a(text, seed = 0x811c9dc5) {
+    let hash = seed >>> 0;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash >>> 0;
+}
+function createLocalName(kind, specifier, exportName) {
+    const hint = exportName ?? (sanitizeSpecifierForIdentifier(specifier) || 'runtime');
+    return `__sts_runtime_${kind}_${hint}_${fnv1a(`${kind}\u0000${specifier}\u0000${exportName ?? ''}`)
+        .toString(16)}`;
+}
+function toRelativeModuleSpecifier(fromFileName, toFileName) {
+    const raw = relative(dirname(fromFileName), toFileName).replaceAll('\\', '/');
+    return raw.startsWith('.') ? raw : `./${raw}`;
+}
+function resolveRelativeRuntimeFile(containingFileName, specifier, host) {
+    const basePath = normalize(join(dirname(containingFileName), specifier));
+    const candidates = [
+        basePath,
+        `${basePath}.ts`,
+        `${basePath}.tsx`,
+        `${basePath}.sts`,
+        `${basePath}.js`,
+        `${basePath}.mjs`,
+        `${basePath}.cjs`,
+        join(basePath, 'index.ts'),
+        join(basePath, 'index.tsx'),
+        join(basePath, 'index.sts'),
+        join(basePath, 'index.js'),
+    ];
+    for (const candidate of candidates) {
+        if (host.fileExists(candidate)) {
+            return normalize(candidate);
+        }
+    }
+    return null;
+}
+function publicSpecifierForPackageSubpath(packageName, subpath) {
+    return subpath === '.' ? packageName : `${packageName}/${subpath.replace(/^\.\/?/u, '')}`;
+}
+export function createMacroRuntimeImportResolver(preparedProgram, sourceFileName, macroModuleFileName) {
+    const resolutionHost = createModuleResolutionHost(preparedProgram);
+    return {
+        resolve(request) {
+            if (!request.specifier.startsWith('.')) {
+                if (isBuiltinRuntimeModuleSpecifier(request.specifier)) {
+                    const specifier = builtinRuntimeImportSpecifier(request.specifier) ?? request.specifier;
+                    return {
+                        exportName: request.exportName,
+                        kind: request.kind,
+                        localName: createLocalName(request.kind, specifier, request.exportName),
+                        specifier,
+                    };
+                }
+                throw new Error(`Runtime macro imports must stay within the defining package. Re-export "${request.specifier}" through the macro package and import that local subpath instead.`);
+            }
+            const resolvedModule = ts.resolveModuleName(request.specifier, macroModuleFileName, preparedProgram.options, resolutionHost, preparedProgram.preparedHost.reuseState.moduleResolutionCache).resolvedModule;
+            const runtimeFileName = resolvedModule?.resolvedFileName
+                ? normalize(resolvedModule.resolvedFileName)
+                : resolveRelativeRuntimeFile(macroModuleFileName, request.specifier, resolutionHost);
+            if (!runtimeFileName) {
+                throw new Error(`Could not resolve runtime import "${request.specifier}" from macro module "${macroModuleFileName}".`);
+            }
+            const macroPackage = readPackageRuntimeMetadata(macroModuleFileName, resolutionHost);
+            const runtimePackage = readPackageRuntimeMetadata(runtimeFileName, resolutionHost);
+            if (macroPackage &&
+                runtimePackage &&
+                normalizePath(macroPackage.packageJsonPath) !==
+                    normalizePath(runtimePackage.packageJsonPath)) {
+                throw new Error(`Runtime macro imports must stay within the defining package. "${request.specifier}" resolves outside the macro package.`);
+            }
+            let specifier = toRelativeModuleSpecifier(sourceFileName, runtimeFileName);
+            if (macroPackage?.name && macroPackage.soundscriptExports.size > 0) {
+                let publishedSubpath = null;
+                for (const [subpath, targetFileName] of macroPackage.soundscriptExports.entries()) {
+                    if (normalizePath(targetFileName) !== normalizePath(runtimeFileName)) {
+                        continue;
+                    }
+                    publishedSubpath = subpath;
+                    break;
+                }
+                if (!publishedSubpath) {
+                    throw new Error(`Runtime macro import "${request.specifier}" must resolve to a subpath published in package.json#soundscript.exports for package "${macroPackage.name}".`);
+                }
+                if (!macroPackage.ordinaryExports.has(publishedSubpath)) {
+                    throw new Error(`Runtime macro import "${request.specifier}" resolves to "${publicSpecifierForPackageSubpath(macroPackage.name, publishedSubpath)}", but that subpath is not published through package.json#exports.`);
+                }
+                specifier = publicSpecifierForPackageSubpath(macroPackage.name, publishedSubpath);
+            }
+            return {
+                exportName: request.exportName,
+                kind: request.kind,
+                localName: createLocalName(request.kind, specifier, request.exportName),
+                specifier,
+            };
+        },
+    };
+}