modality-ts 0.0.8 → 0.0.10

package/dist/{modality → cli}/features/extract/command.js

@@ -1,71 +1,115 @@
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { dirname, join, parse, resolve } from "node:path";
+import { dirname, extname, join, parse, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import * as ts from "typescript";
-import { extractUseStateSkeleton, runExtractionPipeline } from "modality-ts/extraction";
-import { canonicalJson, parseModelArtifact } from "modality-ts/kernel";
-import { routeVars as defaultRouteVars } from "modality-ts/source-router";
+import { runExtractionPipeline } from "modality-ts/extract";
+import { canonicalJson, parseModelArtifact, } from "modality-ts/core";
+import { routerSource } from "modality-ts/extract/sources/router";
 import { emitAppModel } from "../../codegen/model.js";
 import { loadAndApplyOverlay, loadOverlaySpec } from "../../overlay.js";
 import { createBuiltinModalityRegistry } from "../../registry/index.js";
 export async function runExtractCommand(options) {
-    const project = await loadExtractionProject(options.sourcePath);
-    const config = await loadModalityConfig(options.configPath ?? await findNearestConfig(project.configStartDir));
+    const sourcePaths = normalizedSourcePaths(options);
+    const project = await loadExtractionProject(sourcePaths);
+    const config = await loadModalityConfig(options.configPath ?? (await findNearestConfig(project.configStartDir)));
     const route = options.route ?? config.route ?? "/";
     const appModelPath = options.appModelPath ?? `${dirname(options.modelPath)}/app.model.ts`;
-    const packageJsonPath = options.packageJsonPath ?? config.packageJsonPath ?? await findNearestPackageJson(project.configStartDir);
+    const packageJsonPath = options.packageJsonPath ??
+        config.packageJsonPath ??
+        (await findNearestPackageJson(project.configStartDir));
     const dependencies = await readPackageDependencies(packageJsonPath);
     const registry = createBuiltinModalityRegistry({
         dependencies,
-        disabledPlugins: [...(config.disabledPlugins ?? []), ...(options.disabledPlugins ?? [])],
-        extraSourcePlugins: [...(config.plugins ?? []), ...(options.sourcePlugins ?? [])],
-        routerPlugin: options.routerPlugin ?? config.routerPlugin
+        disabledPlugins: [
+            ...(config.disabledPlugins ?? []),
+            ...(options.disabledPlugins ?? []),
+        ],
+        extraSourcePlugins: [
+            ...(config.plugins ?? []),
+            ...(options.sourcePlugins ?? []),
+        ],
+        routerPlugin: options.routerPlugin ?? config.routerPlugin,
     });
-    const effectApis = uniqueStrings([...(config.effectApis ?? []), ...(options.effectApis ?? []), ...project.effectApis]);
-    const bounds = { maxDepth: 12, maxPending: 3, maxInternalSteps: 16, ...(config.bounds ?? {}), ...(options.bounds ?? {}) };
+    const effectApis = uniqueStrings([
+        ...(config.effectApis ?? []),
+        ...(options.effectApis ?? []),
+        ...project.effectApis,
+    ]);
+    const bounds = {
+        maxDepth: 12,
+        maxPending: 3,
+        maxInternalSteps: 16,
+        ...(config.bounds ?? {}),
+        ...(options.bounds ?? {}),
+    };
     const pipeline = runExtractionPipeline({
         sourceText: project.sourceText,
         fileName: project.entryFile,
         route,
+        routePatterns: project.routes,
         effectApis,
         sourcePlugins: registry.sourcePlugins,
         routerPlugin: registry.routerPlugin,
-        extractHandlers: (sourceText, handlerOptions) => extractUseStateSkeleton(sourceText, { ...handlerOptions, routePatterns: project.routes })
     });
     const transitions = [...pipeline.transitions];
-    const discoveredRoutes = uniqueStrings([route, ...project.routes, ...transitionNavigatedRoutes(transitions)]);
+    const discoveredRoutes = uniqueStrings([
+        route,
+        ...project.routes,
+        ...transitionNavigatedRoutes(transitions),
+    ]);
+    const defaultRouter = routerSource();
     const routeVars = registry.routerPlugin
-        ? registry.routerPlugin.routeVars(discoveredRoutes, { route, bounds: { maxHistory: 4 } })
-        : defaultRouteVars(discoveredRoutes, { route, bounds: { maxHistory: 4 } });
+        ? registry.routerPlugin.routeVars(discoveredRoutes, {
+            route,
+            bounds: { maxHistory: 4 },
+        })
+        : defaultRouter.routeVars(discoveredRoutes, {
+            route,
+            bounds: { maxHistory: 4 },
+        });
     const templateVars = pipeline.templateFragments.flatMap((fragment) => fragment.vars);
     const stateVars = refineAssignedLiteralDomains([...pipeline.stateVars, ...templateVars], transitions);
     const extractedModel = {
         schemaVersion: 1,
         id: "extracted-model",
         bounds,
-        metadata: { sourceHashes: sourceHashes(project.sources), plugins: pluginProvenance(pipeline.plugins) },
-        vars: [...routeVars, ...pendingVars(effectApis, transitions, [...routeVars, ...stateVars], bounds.maxPending), ...stateVars],
-        transitions
+        metadata: {
+            sourceHashes: sourceHashes(project.sources),
+            plugins: pluginProvenance(pipeline.plugins),
+        },
+        vars: [
+            ...routeVars,
+            ...pendingVars(effectApis, transitions, [...routeVars, ...stateVars], bounds.maxPending),
+            ...stateVars,
+        ],
+        transitions,
     };
-    const overlaySpec = options.explainDrift && options.overlayPath ? await readOverlaySpec(extractedModel, options.overlayPath) : undefined;
-    const driftLines = overlaySpec ? explainOverlayDrift(extractedModel, overlaySpec) : [];
+    const overlaySpec = options.explainDrift && options.overlayPath
+        ? await readOverlaySpec(extractedModel, options.overlayPath)
+        : undefined;
+    const driftLines = overlaySpec
+        ? explainOverlayDrift(extractedModel, overlaySpec)
+        : [];
     const overlay = await loadAndApplyOverlay(extractedModel, options.overlayPath);
     if (overlay.errors.length > 0) {
-        throw new Error([`Overlay merge failed: ${overlay.errors.join("; ")}`, ...driftLines].join("\n"));
+        throw new Error([
+            `Overlay merge failed: ${overlay.errors.join("; ")}`,
+            ...driftLines,
+        ].join("\n"));
     }
     const warnings = [
         ...pipeline.warnings,
         ...overlay.warnings,
-        ...pluginConformanceWarnings(registry.sourcePlugins, dependencies)
+        ...pluginConformanceWarnings(registry.sourcePlugins, dependencies),
     ];
     const extractionCaveats = createExtractionCaveats(warnings);
     const model = {
         ...overlay.model,
         metadata: {
             ...overlay.model.metadata,
-            extractionCaveats
-        }
+            extractionCaveats,
+        },
     };
     const report = createExtractionReport(project.sourceFiles, model, warnings, overlay.ignoredVars, options.now ?? new Date());
     await mkdir(dirname(options.modelPath), { recursive: true });
@@ -88,15 +132,33 @@ export async function runExtractCommand(options) {
             `model=${options.modelPath}`,
             `appModel=${appModelPath}`,
             ...(options.overlayPath ? [`overlay=${options.overlayPath}`] : []),
-            ...(options.explainDrift ? (driftLines.length > 0 ? driftLines : ["overlay-drift=none"]) : []),
+            ...(options.explainDrift
+                ? driftLines.length > 0
+                    ? driftLines
+                    : ["overlay-drift=none"]
+                : []),
             ...(options.configPath ? [`config=${options.configPath}`] : []),
-            ...(options.expectModelPath ? [`expectedModel=${options.expectModelPath}`] : []),
-            ...(options.reportPath ? [`report=${options.reportPath}`] : [])
-        ]
+            ...(options.expectModelPath
+                ? [`expectedModel=${options.expectModelPath}`]
+                : []),
+            ...(options.reportPath ? [`report=${options.reportPath}`] : []),
+        ],
     };
 }
-async function loadExtractionProject(sourcePath) {
-    const resolved = resolve(sourcePath);
+function normalizedSourcePaths(options) {
+    const sourcePaths = options.sourcePaths ?? [];
+    const paths = [
+        ...sourcePaths,
+        ...(options.sourcePath ? [options.sourcePath] : []),
+    ];
+    if (paths.length === 0)
+        throw new Error("Missing source.tsx path");
+    return uniqueStrings(paths.map((path) => resolve(path)));
+}
+async function loadExtractionProject(sourcePaths) {
+    if (sourcePaths.length > 1)
+        return loadMultiFileExtractionProject(sourcePaths);
+    const resolved = sourcePaths[0];
     const info = await stat(resolved);
     if (!info.isDirectory()) {
         const source = await readFile(resolved, "utf8");
@@ -109,7 +171,7 @@ async function loadExtractionProject(sourcePath) {
             sources: imported.sources,
             routes: [],
             effectApis: fetchEffectApis(imported.sources.map((entry) => entry.text).join("\n")),
-            configStartDir: dirname(resolved)
+            configStartDir: dirname(resolved),
         };
     }
     const routesPath = join(resolved, "app", "routes.ts");
@@ -117,8 +179,11 @@ async function loadExtractionProject(sourcePath) {
     const rootPath = join(resolved, "app", "root.tsx");
     const roots = await existingFiles([rootPath]);
     const entries = [
-        ...await Promise.all(roots.map(async (path) => ({ path, text: await readFile(path, "utf8") }))),
-        ...await Promise.all(routeEntries.map(async (entry) => ({ path: resolve(dirname(routesPath), entry.file), text: await readFile(resolve(dirname(routesPath), entry.file), "utf8") })))
+        ...(await Promise.all(roots.map(async (path) => ({ path, text: await readFile(path, "utf8") })))),
+        ...(await Promise.all(routeEntries.map(async (entry) => ({
+            path: resolve(dirname(routesPath), entry.file),
+            text: await readFile(resolve(dirname(routesPath), entry.file), "utf8"),
+        })))),
     ];
     const tsconfig = await readTsConfigResolution(resolved);
     const imported = await sourceWithLocalImports(entries, tsconfig);
@@ -130,7 +195,30 @@ async function loadExtractionProject(sourcePath) {
         sources: imported.sources,
         routes: uniqueStrings(routeEntries.map((entry) => entry.pattern)),
         effectApis: fetchEffectApis(sourceText),
-        configStartDir: resolved
+        configStartDir: resolved,
+    };
+}
+async function loadMultiFileExtractionProject(sourcePaths) {
+    const projects = await Promise.all(sourcePaths.map((sourcePath) => loadExtractionProject([sourcePath])));
+    const sourcesByPath = new Map();
+    for (const project of projects) {
+        for (const source of project.sources) {
+            sourcesByPath.set(source.path, source);
+        }
+    }
+    const sources = [...sourcesByPath.values()].sort((left, right) => left.path.localeCompare(right.path));
+    const sourceText = sources.map((entry) => entry.text).join("\n");
+    return {
+        entryFile: projects.map((project) => project.entryFile).join(","),
+        sourceText,
+        sourceFiles: sources.map((entry) => entry.path),
+        sources,
+        routes: uniqueStrings(projects.flatMap((project) => project.routes)),
+        effectApis: uniqueStrings([
+            ...projects.flatMap((project) => project.effectApis),
+            ...fetchEffectApis(sourceText),
+        ]),
+        configStartDir: commonAncestor(projects.map((project) => project.configStartDir)),
     };
 }
 async function sourceWithLocalImports(entries, tsconfig) {
@@ -156,7 +244,9 @@ function localImportSpecifiers(source) {
     const specs = [];
     const parsed = tsCreateSourceFile(source);
     const visit = (node) => {
-        if (tsIsImportDeclaration(node) && tsIsStringLiteral(node.moduleSpecifier) && isLocalImportSpecifier(node.moduleSpecifier.text)) {
+        if (tsIsImportDeclaration(node) &&
+            tsIsStringLiteral(node.moduleSpecifier) &&
+            isLocalImportSpecifier(node.moduleSpecifier.text)) {
             specs.push(node.moduleSpecifier.text);
         }
         tsForEachChild(node, visit);
@@ -194,7 +284,8 @@ function importBases(baseDir, specifier, tsconfig) {
     if (specifier.startsWith("."))
         return [resolve(baseDir, specifier)];
     const matches = tsconfig.paths.flatMap((entry) => {
-        if (!specifier.startsWith(entry.prefix) || !specifier.endsWith(entry.suffix))
+        if (!specifier.startsWith(entry.prefix) ||
+            !specifier.endsWith(entry.suffix))
             return [];
         const star = specifier.slice(entry.prefix.length, specifier.length - entry.suffix.length);
         return entry.targets.map((target) => resolve(target.replace("*", star)));
@@ -206,7 +297,14 @@ function importBases(baseDir, specifier, tsconfig) {
 async function firstExistingModulePath(base) {
     const candidates = /\.[cm]?[jt]sx?$/.test(base)
         ? [base]
-        : [`${base}.ts`, `${base}.tsx`, `${base}.mts`, `${base}.cts`, join(base, "index.ts"), join(base, "index.tsx")];
+        : [
+            `${base}.ts`,
+            `${base}.tsx`,
+            `${base}.mts`,
+            `${base}.cts`,
+            join(base, "index.ts"),
+            join(base, "index.tsx"),
+        ];
     for (const candidate of candidates) {
         try {
             const candidateStat = await stat(candidate);
@@ -226,12 +324,18 @@ async function readTsConfigResolution(startDir) {
         return { paths: [] };
     const parsed = JSON.parse(await readFile(tsconfigPath, "utf8"));
     const configDir = dirname(tsconfigPath);
-    const baseUrl = parsed.compilerOptions?.baseUrl ? resolve(configDir, parsed.compilerOptions.baseUrl) : configDir;
+    const baseUrl = parsed.compilerOptions?.baseUrl
+        ? resolve(configDir, parsed.compilerOptions.baseUrl)
+        : configDir;
     const paths = Object.entries(parsed.compilerOptions?.paths ?? {}).map(([key, targets]) => {
         const star = key.indexOf("*");
         const prefix = star >= 0 ? key.slice(0, star) : key;
         const suffix = star >= 0 ? key.slice(star + 1) : "";
-        return { prefix, suffix, targets: targets.map((target) => resolve(baseUrl, target)) };
+        return {
+            prefix,
+            suffix,
+            targets: targets.map((target) => resolve(baseUrl, target)),
+        };
     });
     return { baseUrl, paths };
 }
@@ -273,11 +377,17 @@ function parseReactRouterRoutes(source) {
     const parsed = tsCreateSourceFile(source);
     const visit = (node) => {
         if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-            if (node.expression.text === "index" && ts.isStringLiteral(node.arguments[0])) {
+            if (node.expression.text === "index" &&
+                ts.isStringLiteral(node.arguments[0])) {
                 routes.push({ pattern: "/", file: node.arguments[0].text });
             }
-            if (node.expression.text === "route" && ts.isStringLiteral(node.arguments[0]) && ts.isStringLiteral(node.arguments[1])) {
-                routes.push({ pattern: reactRouterPathPattern(node.arguments[0].text), file: node.arguments[1].text });
+            if (node.expression.text === "route" &&
+                ts.isStringLiteral(node.arguments[0]) &&
+                ts.isStringLiteral(node.arguments[1])) {
+                routes.push({
+                    pattern: reactRouterPathPattern(node.arguments[0].text),
+                    file: node.arguments[1].text,
+                });
             }
         }
         tsForEachChild(node, visit);
@@ -296,7 +406,9 @@ function fetchEffectApis(sourceText) {
     const source = tsCreateSourceFile(sourceText);
     const ops = new Set();
     const visit = (node) => {
-        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "fetch") {
+        if (ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === "fetch") {
             const op = fetchOpId(node);
             if (op)
                 ops.add(op);
@@ -317,12 +429,13 @@ function fetchOpId(call) {
     return `${method} ${path}`;
 }
 function fetchPathValue(expression) {
-    if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression))
+    if (ts.isStringLiteral(expression) ||
+        ts.isNoSubstitutionTemplateLiteral(expression))
         return normalizeFetchPath(expression.text);
     if (ts.isTemplateExpression(expression)) {
         let value = expression.head.text;
         for (const span of expression.templateSpans)
-            value += ":id" + span.literal.text;
+            value += `:id${span.literal.text}`;
         return normalizeFetchPath(value);
     }
     return undefined;
@@ -333,15 +446,21 @@ function normalizeFetchPath(path) {
 function fetchMethodValue(expression) {
     if (!expression || !ts.isObjectLiteralExpression(expression))
         return undefined;
-    const method = expression.properties.find((property) => ts.isPropertyAssignment(property) && propertyName(property.name) === "method");
+    const method = expression.properties.find((property) => ts.isPropertyAssignment(property) &&
+        propertyName(property.name) === "method");
     const value = method ? literalString(method.initializer) : undefined;
     return value?.toUpperCase();
 }
 function literalString(expression) {
-    return ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression) ? expression.text : undefined;
+    return ts.isStringLiteral(expression) ||
+        ts.isNoSubstitutionTemplateLiteral(expression)
+        ? expression.text
+        : undefined;
 }
 function propertyName(name) {
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
+    if (ts.isIdentifier(name) ||
+        ts.isStringLiteral(name) ||
+        ts.isNumericLiteral(name))
         return name.text;
     return undefined;
 }
@@ -351,12 +470,33 @@ async function readOverlaySpec(model, overlayPath) {
 async function loadModalityConfig(configPath) {
     if (!configPath)
         return {};
-    const module = (await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`));
+    const module = (await importConfigModule(configPath));
     const exported = module.default ?? module.config ?? {};
     return typeof exported === "function" ? await exported() : exported;
 }
+async function importConfigModule(configPath) {
+    if (extname(configPath) === ".ts" || extname(configPath) === ".mts") {
+        const source = await readFile(configPath, "utf8");
+        const transpiled = ts.transpileModule(source, {
+            compilerOptions: {
+                module: ts.ModuleKind.ESNext,
+                target: ts.ScriptTarget.ES2022,
+                importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Remove,
+            },
+        }).outputText;
+        const encoded = Buffer.from(transpiled).toString("base64");
+        const url = `data:text/javascript;base64,${encoded}`;
+        return import(url);
+    }
+    return import(`${pathToFileURL(configPath).href}?t=${Date.now()}`);
+}
 async function findNearestConfig(startDir) {
-    const names = ["modality.config.ts", "modality.config.mts", "modality.config.js", "modality.config.mjs"];
+    const names = [
+        "modality.config.ts",
+        "modality.config.mts",
+        "modality.config.js",
+        "modality.config.mjs",
+    ];
     let dir = startDir;
     while (true) {
         for (const name of names) {
@@ -379,6 +519,25 @@ async function findNearestConfig(startDir) {
 function uniqueStrings(values) {
     return [...new Set(values)].sort();
 }
+function commonAncestor(paths) {
+    if (paths.length === 0)
+        return process.cwd();
+    const [first, ...rest] = paths.map((path) => resolve(path).split(/[\\/]+/));
+    if (!first)
+        return process.cwd();
+    let length = first.length;
+    for (const parts of rest) {
+        length = Math.min(length, parts.length);
+        for (let index = 0; index < length; index += 1) {
+            if (first[index] !== parts[index]) {
+                length = index;
+                break;
+            }
+        }
+    }
+    const prefix = first.slice(0, length).join("/");
+    return prefix === "" ? parse(paths[0]).root : prefix;
+}
 async function findNearestPackageJson(startDir) {
     let dir = startDir;
     while (true) {
@@ -404,7 +563,7 @@ async function readPackageDependencies(packageJsonPath) {
     return {
         ...(manifest.peerDependencies ?? {}),
         ...(manifest.devDependencies ?? {}),
-        ...(manifest.dependencies ?? {})
+        ...(manifest.dependencies ?? {}),
     };
 }
 function sha256(value) {
@@ -422,8 +581,12 @@ function createExtractionReport(sourceFiles, model, warnings, ignoredVars, now)
     const caveats = model.metadata?.extractionCaveats ?? emptyExtractionCaveats();
     const transitionHandlers = model.transitions.map((transition) => ({
         id: transition.id,
-        classification: transition.confidence === "manual" ? "overlay" : transition.confidence,
-        reasons: transition.confidence === "over-approx" ? overApproxReasons(transition) : []
+        classification: transition.confidence === "manual"
+            ? "overlay"
+            : transition.confidence,
+        reasons: transition.confidence === "over-approx"
+            ? overApproxReasons(transition)
+            : [],
     }));
     const transitionIds = new Set(transitionHandlers.map((handler) => handler.id));
     const unextractableHandlers = warnings
@@ -433,10 +596,11 @@ function createExtractionReport(sourceFiles, model, warnings, ignoredVars, now)
         .map((handler) => ({
         id: handler.id,
         classification: "unextractable",
-        reasons: [handler.reason]
+        reasons: [handler.reason],
     }));
     const handlers = [...transitionHandlers, ...unextractableHandlers];
-    const exactOrOverlay = handlers.filter((handler) => handler.classification === "exact" || handler.classification === "overlay").length;
+    const exactOrOverlay = handlers.filter((handler) => handler.classification === "exact" ||
+        handler.classification === "overlay").length;
     const unextractable = handlers.filter((handler) => handler.classification === "unextractable").length;
     return {
         schemaVersion: 1,
@@ -451,27 +615,51 @@ function createExtractionReport(sourceFiles, model, warnings, ignoredVars, now)
         domains: model.vars.map((decl) => ({
             varId: decl.id,
             domainKind: decl.domain.kind,
-            provenance: model.metadata?.domainProvenance?.[decl.id] ?? (decl.origin === "system" ? "system" : decl.origin === "library-template" ? "template" : decl.domain.kind === "tokens" ? "default-token" : "type-derived")
+            provenance: model.metadata?.domainProvenance?.[decl.id] ??
+                (decl.origin === "system"
+                    ? "system"
+                    : decl.origin === "library-template"
+                        ? "template"
+                        : decl.domain.kind === "tokens"
+                            ? "default-token"
+                            : "type-derived"),
         })),
         coverage: {
             handlersTotal: handlers.length,
             exactOrOverlay,
             unextractable,
             ignoredVars: ignoredVars.length,
-            percentExactOrOverlay: handlers.length === 0 ? 1 : exactOrOverlay / handlers.length
+            percentExactOrOverlay: handlers.length === 0 ? 1 : exactOrOverlay / handlers.length,
         },
-        warnings
+        warnings,
     };
 }
 function emptyExtractionCaveats() {
-    return { globalTaints: [], staleReads: [], unhandledRejections: [], unextractableHandlers: [] };
+    return {
+        globalTaints: [],
+        staleReads: [],
+        unhandledRejections: [],
+        unextractableHandlers: [],
+    };
 }
 function createExtractionCaveats(warnings) {
     return {
-        globalTaints: warnings.map(globalTaintFromWarning).filter(isCaveat).sort(compareCaveats),
-        staleReads: warnings.map(staleReadFromWarning).filter(isCaveat).sort(compareCaveats),
-        unhandledRejections: warnings.map(unhandledRejectionFromWarning).filter(isCaveat).sort(compareCaveats),
-        unextractableHandlers: warnings.map(unextractableHandlerFromWarning).filter(isCaveat).sort(compareCaveats)
+        globalTaints: warnings
+            .map(globalTaintFromWarning)
+            .filter(isCaveat)
+            .sort(compareCaveats),
+        staleReads: warnings
+            .map(staleReadFromWarning)
+            .filter(isCaveat)
+            .sort(compareCaveats),
+        unhandledRejections: warnings
+            .map(unhandledRejectionFromWarning)
+            .filter(isCaveat)
+            .sort(compareCaveats),
+        unextractableHandlers: warnings
+            .map(unextractableHandlerFromWarning)
+            .filter(isCaveat)
+            .sort(compareCaveats),
     };
 }
 function globalTaintFromWarning(warning) {
@@ -490,7 +678,7 @@ function isCaveat(value) {
     return Boolean(value);
 }
 function compareCaveats(left, right) {
-    return left.id.localeCompare(right.id) || left.reason.localeCompare(right.reason);
+    return (left.id.localeCompare(right.id) || left.reason.localeCompare(right.reason));
 }
 function pluginConformanceWarnings(sourcePlugins, dependencies) {
     if (!dependencies)
@@ -538,16 +726,21 @@ function pluginProvenance(plugins) {
 function transitionNavigatedRoutes(transitions) {
     const routes = new Set();
     const visit = (effect) => {
-        if (effect.kind === "navigate" && effect.to?.kind === "lit" && typeof effect.to.value === "string")
+        if (effect.kind === "navigate" &&
+            effect.to?.kind === "lit" &&
+            typeof effect.to.value === "string")
             routes.add(effect.to.value);
-        if (effect.kind === "seq")
-            effect.effects.forEach(visit);
+        if (effect.kind === "seq") {
+            for (const child of effect.effects)
+                visit(child);
+        }
         if (effect.kind === "if") {
             visit(effect.then);
             visit(effect.else);
         }
     };
-    transitions.forEach((transition) => visit(transition.effect));
+    for (const transition of transitions)
+        visit(transition.effect);
     return [...routes].sort();
 }
 function overApproxReasons(transition) {
@@ -561,7 +754,9 @@ function overApproxReasons(transition) {
     return [...reasons].sort();
 }
 function explainOverlayDrift(model, overlay) {
-    const transitionIds = model.transitions.map((transition) => transition.id).sort();
+    const transitionIds = model.transitions
+        .map((transition) => transition.id)
+        .sort();
     const varIds = model.vars.map((decl) => decl.id).sort();
     const lines = [];
     for (const transition of overlay.transitions ?? []) {
@@ -589,8 +784,12 @@ function formatDrift(kind, id, candidates) {
 }
 function nearestCandidates(id, candidates) {
     return candidates
-        .map((candidate) => ({ candidate, distance: editDistance(normalizeId(id), normalizeId(candidate)) }))
-        .sort((left, right) => left.distance - right.distance || left.candidate.localeCompare(right.candidate))
+        .map((candidate) => ({
+        candidate,
+        distance: editDistance(normalizeId(id), normalizeId(candidate)),
+    }))
+        .sort((left, right) => left.distance - right.distance ||
+        left.candidate.localeCompare(right.candidate))
         .slice(0, 3)
         .map(({ candidate, distance }) => `${candidate}(${distance})`);
 }
@@ -661,20 +860,22 @@ function pendingVars(effectApis, transitions = [], vars = [], maxPending = 3) {
                     fields: {
                         opId: { kind: "enum", values: ops },
                         continuation: { kind: "enum", values: continuations },
-                        args: { kind: "record", fields: argFields }
-                    }
+                        args: { kind: "record", fields: argFields },
+                    },
                 },
-                maxLen: maxPending
+                maxLen: maxPending,
             },
             origin: "system",
             scope: { kind: "global" },
-            initial: []
-        }
+            initial: [],
+        },
     ];
 }
 function enqueueOps(effect) {
     if (effect.kind === "enqueue")
-        return [{ op: effect.op, continuation: effect.continuation, args: effect.args }];
+        return [
+            { op: effect.op, continuation: effect.continuation, args: effect.args },
+        ];
     if (effect.kind === "seq")
         return effect.effects.flatMap(enqueueOps);
     if (effect.kind === "if")
@@ -702,7 +903,9 @@ function refineAssignedLiteralDomains(vars, transitions) {
         if (decl.origin === "library-template")
             return decl;
         const refinement = refinements.get(decl.id);
-        return refinement ? { ...decl, domain: mergeAssignedDomain(decl.domain, refinement) } : decl;
+        return refinement
+            ? { ...decl, domain: mergeAssignedDomain(decl.domain, refinement) }
+            : decl;
     });
 }
 function mergeAssignedDomain(left, right) {
@@ -725,7 +928,10 @@ function assignedLiteralDomains(effect) {
     if (effect.kind === "seq")
         return effect.effects.flatMap(assignedLiteralDomains);
     if (effect.kind === "if")
-        return [...assignedLiteralDomains(effect.then), ...assignedLiteralDomains(effect.else)];
+        return [
+            ...assignedLiteralDomains(effect.then),
+            ...assignedLiteralDomains(effect.else),
+        ];
     return [];
 }
 function domainForLiteral(value) {
@@ -743,9 +949,16 @@ function mergeArgDomains(left, right) {
     if (!left)
         return right;
     if (left.kind === "enum" && right.kind === "enum")
-        return { kind: "enum", values: [...new Set([...left.values, ...right.values])].sort() };
+        return {
+            kind: "enum",
+            values: [...new Set([...left.values, ...right.values])].sort(),
+        };
     if (left.kind === "boundedInt" && right.kind === "boundedInt")
-        return { kind: "boundedInt", min: Math.min(left.min, right.min), max: Math.max(left.max, right.max) };
+        return {
+            kind: "boundedInt",
+            min: Math.min(left.min, right.min),
+            max: Math.max(left.max, right.max),
+        };
     if (left.kind === right.kind)
         return left;
     return { kind: "tokens", count: 1 };