@mionjs/devtools 0.8.8 → 0.13.0

package/dist/core/unplugin.js

@@ -0,0 +1,636 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createUnplugin } from 'unplugin';
+import { getExePath } from '@mionjs/bin-compiler';
+import { DIAGNOSTIC_CATALOG } from "./go-generated/diagnosticCatalog.generated.js";
+import { ResolverClient } from "./resolver-client.js";
+import { applyEdits, sourceHash } from "./apply-edits.js";
+import { Level } from "./protocol.js";
+import { PURE_FN_ARTIFACT_DIR } from "./go-generated/runtypes-constants.generated.js";
+import { assertValidClientRoutes, assertValidModuleMode } from "./option-guards.js";
+import { mayHoldDrizzleSchemas, mayHoldMarkerCalls } from "./markerImports.js";
+import { isDowngraded, resolveDowngradeErrors } from "./downgradeErrors.js";
+import { resolveGrouped, resolveShowInfo } from "./levels.js";
+import { haltError, hostHalt, hostWarn, printFindings, surfaceDiagnostics } from "./surface.js";
+import { DevReporter } from "./devReporter.js";
+import { createTypeDepsIndex, depKey } from "./type-deps.js";
+import { warnBelowTypeScriptFloor } from "./typescript-floor.js";
+export const PLUGIN_NAME = '@mionjs/devtools';
+const BUNDLED_API_ID = '#bundled-api';
+const bundledApiStubPath = () => {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const compiled = path.join(here, 'bundledApiStub.js');
+    return fs.existsSync(compiled) ? compiled : path.join(here, 'bundledApiStub.ts');
+};
+export const unplugin = createUnplugin((rawOptions, meta) => {
+    const options = rawOptions ?? {};
+    const transformMode = options.transformMode ?? 'edits';
+    let downgrade = resolveDowngradeErrors(options.downgradeErrors);
+    let showInfo = resolveShowInfo(options.levels);
+    let grouped = resolveGrouped(options.logStyle);
+    const reportMode = options.pureFnReport ?? (options.onPureFnReport || options.onBatchReport ? 'callback' : false);
+    if (reportMode !== false && reportMode !== 'file' && reportMode !== 'callback') {
+        throw new Error(`[@mionjs/devtools] unknown pureFnReport ${JSON.stringify(options.pureFnReport)} — expected 'file' | 'callback' | false`);
+    }
+    const reportEnabled = reportMode !== false;
+    const writeReportFile = reportMode === 'file';
+    if (transformMode !== 'go' && transformMode !== 'edits') {
+        throw new Error(`[@mionjs/devtools] unknown transformMode ${JSON.stringify(options.transformMode)} — expected 'go' | 'edits'`);
+    }
+    const enrichOptions = options.enrich;
+    const enrichFriendly = enrichOptions?.friendly === true;
+    const enrichMock = enrichOptions?.mock === true;
+    const enrichI18n = enrichOptions?.i18n;
+    const enrichI18nEnabled = enrichI18n !== undefined;
+    const enrichLocales = enrichI18n?.locales ?? [];
+    const enrichSourceLocale = enrichI18n?.sourceLocale;
+    const anyEnrichFamily = enrichFriendly || enrichMock || enrichI18nEnabled;
+    const suppressEnrichHmr = enrichOptions?.suppressHmr ?? anyEnrichFamily;
+    let resolver = null;
+    let activeBuilds = 0;
+    let siteFiles = new Set();
+    let cwdAbs = '';
+    let genDirAbs = '';
+    let pureFnArtifact = {};
+    let viteRoot = '';
+    let viteCommand = '';
+    let viteMode = '';
+    let viteLogger;
+    const isDevServer = () => options.devServer ?? (viteCommand === 'serve' && viteMode !== 'test');
+    const halts = (diagnostic) => diagnostic.level === Level.Error || (diagnostic.level === Level.RuntimeError && !isDevServer());
+    const devPrint = (block) => viteLogger ? viteLogger.warn(block, { clear: false, timestamp: true }) : console.warn(`[@mionjs/devtools] ${block}`);
+    const devReporter = new DevReporter(devPrint, () => cwdAbs || process.cwd(), () => grouped);
+    const devRegenerateFailed = (error) => devPrint(`@mionjs/devtools: regenerating after an edit failed: ${error instanceof Error ? error.message : String(error)}`);
+    function ensureResolver() {
+        if (resolver)
+            return;
+        cwdAbs = path.resolve(options.cwd ?? (viteRoot || process.cwd()));
+        genDirAbs = options.genDir ? path.resolve(cwdAbs, options.genDir) : '';
+        assertValidModuleMode(options.moduleMode);
+        assertValidClientRoutes(options.clientRoutes);
+        const binaryPath = options.binary ?? getExePath();
+        resolver = new ResolverClient(binaryPath, cwdAbs, options.tsconfig ?? '', {
+            ...(options.emitMode ? { emitMode: options.emitMode } : {}),
+            ...(options.validate?.numberMode ? { numberMode: options.validate.numberMode } : {}),
+            ...(options.inlineMode ? { inlineMode: options.inlineMode } : {}),
+            ...(options.parallelScan !== undefined ? { parallelScan: options.parallelScan } : {}),
+            ...(options.parallelRender !== undefined ? { parallelRender: options.parallelRender } : {}),
+            ...(options.moduleMode ? { moduleMode: options.moduleMode } : {}),
+            ...(options.singleThreaded !== undefined ? { singleThreaded: options.singleThreaded } : {}),
+            ...(options.hashLength !== undefined ? { hashLength: options.hashLength } : {}),
+            ...(options.patternSampleCount !== undefined ? { patternSampleCount: options.patternSampleCount } : {}),
+            ...(options.patternSampleRetries !== undefined ? { patternSampleRetries: options.patternSampleRetries } : {}),
+            ...(options.jsonMaxBytes !== undefined ? { jsonMaxBytes: options.jsonMaxBytes } : {}),
+            ...(options.markers?.packages?.length ? { markerPackages: options.markers.packages } : {}),
+            ...(options.markers?.checkPackage === false ? { markerPackageCheck: false } : {}),
+            ...(options.jsRuntime ? { jsRuntime: options.jsRuntime } : {}),
+            ...(reportEnabled ? { pureFnReportWire: true } : {}),
+            ...(writeReportFile ? { pureFnReportFile: true } : {}),
+            ...(genDirAbs ? { genDir: genDirAbs } : {}),
+            ...(options.clientRoutes ? { clientRoutes: options.clientRoutes } : {}),
+            transformRelative: true,
+            ...(options.sourcesContent === false ? { omitSourcesContent: true } : {}),
+            ...(enrichFriendly ? { enrichFriendly: true } : {}),
+            ...(enrichMock ? { enrichMock: true } : {}),
+            ...(enrichI18nEnabled ? { enrichI18n: true } : {}),
+            ...(enrichLocales.length > 0 ? { enrichLocales } : {}),
+            ...(enrichSourceLocale ? { enrichSourceLocale } : {}),
+        });
+        if (options.detachResolver)
+            resolver.unref();
+    }
+    const typeDeps = createTypeDepsIndex(cwdAbs || process.cwd());
+    function declareTypeDeps(ctx, rel, deps) {
+        typeDeps.record(rel, deps);
+        if (!deps || deps.length === 0)
+            return;
+        for (const dep of deps) {
+            if (!fileExists(dep))
+                continue;
+            try {
+                ctx.addWatchFile?.(dep);
+            }
+            catch {
+            }
+        }
+    }
+    const fileExistsCache = new Map();
+    function fileExists(file) {
+        const cached = fileExistsCache.get(file);
+        if (cached !== undefined)
+            return cached;
+        let exists = false;
+        try {
+            exists = fs.existsSync(file);
+        }
+        catch {
+            exists = false;
+        }
+        fileExistsCache.set(file, exists);
+        return exists;
+    }
+    function siteKey(file) {
+        const rel = path.isAbsolute(file) ? path.relative(cwdAbs || process.cwd(), file) : file;
+        return rel.split(path.sep).join('/');
+    }
+    function surfaceNewErrors(ctx, diagnostics, activeFile) {
+        const cwd = cwdAbs || process.cwd();
+        if (isDevServer()) {
+            const fatal = devReporter.fatalIn(activeFile, diagnostics);
+            devReporter.add(diagnostics.filter((diagnostic) => diagnostic.level !== Level.Error), downgrade);
+            if (fatal.length > 0)
+                hostHalt(ctx, haltError(fatal[0], fatal.length, activeFile, cwd));
+            return;
+        }
+        const errors = diagnostics.filter((diagnostic) => diagnostic.level === Level.Error || diagnostic.level === Level.RuntimeError);
+        surfaceDiagnostics(ctx, errors, { halts, downgrade, activeFile, cwd, grouped });
+    }
+    async function transformViaGo(ctx, rel, driftCheck) {
+        const result = await resolver.transform([rel]);
+        if (result.addedRunTypes || result.addedPureFns)
+            await regenerate();
+        surfaceNewErrors(ctx, result.diagnostics ?? [], rel);
+        if (result.sites.length === 0 && (result.replacements?.length ?? 0) === 0)
+            return null;
+        const fileResult = result.transformed[rel];
+        if (!fileResult || typeof fileResult.code !== 'string')
+            return null;
+        declareTypeDeps(ctx, rel, fileResult.typeDeps);
+        if (driftCheck && fileResult.sourceHash !== undefined && fileResult.sourceHash !== sourceHash(driftCheck.code)) {
+            hostWarn(ctx, `@mionjs/devtools: transform 'go' source drift on ${rel} — the rewrite was applied to the resolver's copy, not the source another plugin handed us. ` +
+                `Order @mionjs/devtools first among enforce:'pre' plugins so it sees pristine source.`);
+        }
+        return { code: fileResult.code, map: (fileResult.map ?? undefined) };
+    }
+    async function transformViaEdits(ctx, rel, code) {
+        const incomingHash = sourceHash(code);
+        let result = await resolver.transform([rel], { emitEdits: true });
+        if (result.addedRunTypes || result.addedPureFns)
+            await regenerate();
+        surfaceNewErrors(ctx, result.diagnostics ?? [], rel);
+        if (result.sites.length === 0 && (result.replacements?.length ?? 0) === 0)
+            return null;
+        let fileResult = result.transformed[rel];
+        if (!fileResult)
+            return null;
+        if (fileResult.sourceHash !== undefined && fileResult.sourceHash !== incomingHash) {
+            hostWarn(ctx, `@mionjs/devtools: transform 'edits' source drift on ${rel} — re-syncing via setSources. ` +
+                `An enforce:'pre' plugin likely edited this file before @mionjs/devtools; order @mionjs/devtools first to avoid the extra round-trip.`);
+            try {
+                await resolver.setSources({ [rel]: code });
+                result = await resolver.transform([rel], { emitEdits: true });
+                if (result.addedRunTypes || result.addedPureFns)
+                    await regenerate();
+            }
+            catch {
+                return transformViaGo(ctx, rel);
+            }
+            surfaceNewErrors(ctx, result.diagnostics ?? [], rel);
+            if (result.sites.length === 0 && (result.replacements?.length ?? 0) === 0)
+                return null;
+            fileResult = result.transformed[rel];
+            if (!fileResult || (fileResult.sourceHash !== undefined && fileResult.sourceHash !== incomingHash)) {
+                return transformViaGo(ctx, rel);
+            }
+        }
+        declareTypeDeps(ctx, rel, fileResult.typeDeps);
+        try {
+            const applied = applyEdits(rel, code, fileResult.importBlock ?? '', fileResult.edits ?? []);
+            return { code: applied.code, map: applied.map };
+        }
+        catch (error) {
+            hostWarn(ctx, `@mionjs/devtools: 'edits' apply failed on ${rel} (${String(error)}) — falling back to 'go' mode.`);
+            return transformViaGo(ctx, rel);
+        }
+    }
+    async function writeMirrorFiles(files) {
+        let created = 0;
+        let updated = 0;
+        for (const file of files) {
+            try {
+                const existing = await fs.promises.readFile(file.path, 'utf8').catch(() => null);
+                if (existing === file.content)
+                    continue;
+                await fs.promises.mkdir(path.dirname(file.path), { recursive: true });
+                await fs.promises.writeFile(file.path, file.content);
+                if (file.added)
+                    created += 1;
+                else
+                    updated += 1;
+            }
+            catch {
+            }
+        }
+        return { created, updated };
+    }
+    async function syncEnrich(files) {
+        if (!resolver || !anyEnrichFamily)
+            return;
+        try {
+            const result = await resolver.enrich(files);
+            const written = await writeMirrorFiles(result.files);
+            if (files.length === 0 && written.created + written.updated > 0) {
+                console.log(`[@mionjs/devtools] enrich sync: scaffolded ${written.created} new mirror file(s), reconciled ${written.updated} — review & commit; fill the blanks before a production build (its completeness gate fails on unfilled scaffolds).`);
+            }
+        }
+        catch {
+        }
+    }
+    async function enrichDriftGate(ctx) {
+        if (!resolver || !anyEnrichFamily)
+            return;
+        let stale;
+        let incomplete;
+        try {
+            const result = await resolver.enrich([]);
+            stale = [];
+            for (const file of result.files) {
+                const existing = await fs.promises.readFile(file.path, 'utf8').catch(() => null);
+                if (existing !== file.content)
+                    stale.push(file.path);
+            }
+            incomplete = result.diagnostics ?? [];
+        }
+        catch {
+            return;
+        }
+        if (stale.length === 0 && incomplete.length === 0)
+            return;
+        for (const stalePath of stale) {
+            hostWarn(ctx, `@mionjs/devtools: enrichment mirror out of date or missing: ${stalePath} — run \`mion enrich --update\` and commit it.`);
+        }
+        let fatal = 0;
+        const findings = [];
+        for (const diagnostic of incomplete) {
+            const standDown = isDowngraded(downgrade, diagnostic) ||
+                (DIAGNOSTIC_CATALOG[diagnostic.code]?.completeness === true && (downgrade.all || downgrade.codes.has(diagnostic.code)));
+            findings.push({ diagnostic, downgraded: standDown });
+            if (!standDown)
+                fatal += 1;
+        }
+        printFindings(ctx, findings, grouped, cwdAbs || process.cwd());
+        const staleCount = downgrade.all ? 0 : stale.length;
+        if (staleCount === 0 && fatal === 0)
+            return;
+        const parts = [];
+        if (staleCount > 0)
+            parts.push(`${staleCount} out of date or missing`);
+        if (fatal > 0)
+            parts.push(`${fatal} incomplete or stale (unfilled @todo / blank value / @rtOrphan carcass)`);
+        hostHalt(ctx, new Error(`@mionjs/devtools: enrichment is not production-ready — ${parts.join(', ')}. ` +
+            `Run \`mion enrich --update\`, fill the blanks, and commit. (mirrors are never written during a production build)`));
+    }
+    async function regenerate() {
+        const gen = await resolver.generate();
+        pureFnArtifact = gen.pureFnArtifact;
+        return gen;
+    }
+    async function writePureFnArtifact(dir) {
+        if (!dir)
+            return;
+        const artifactDir = path.join(dir, PURE_FN_ARTIFACT_DIR);
+        const files = Object.keys(pureFnArtifact);
+        if (files.length === 0) {
+            await fs.promises.rm(artifactDir, { recursive: true, force: true });
+            return;
+        }
+        const live = new Set();
+        for (const rel of files) {
+            const target = path.join(artifactDir, ...rel.split('/'));
+            live.add(target);
+            const content = pureFnArtifact[rel];
+            const existing = await fs.promises.readFile(target, 'utf8').catch(() => null);
+            if (existing === content)
+                continue;
+            await fs.promises.mkdir(path.dirname(target), { recursive: true });
+            await fs.promises.writeFile(target, content);
+        }
+        await pruneArtifactDir(artifactDir, live);
+    }
+    async function pruneArtifactDir(dir, live) {
+        let empty = true;
+        for (const entry of await fs.promises.readdir(dir, { withFileTypes: true })) {
+            const target = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (await pruneArtifactDir(target, live))
+                    await fs.promises.rmdir(target);
+                else
+                    empty = false;
+            }
+            else if (live.has(target))
+                empty = false;
+            else
+                await fs.promises.rm(target, { force: true });
+        }
+        return empty;
+    }
+    function outputDirOf(output) {
+        const base = output.absWorkingDir ?? process.cwd();
+        const dir = output.dir ?? output.outdir;
+        if (dir)
+            return path.resolve(base, dir);
+        const file = output.file ?? output.outfile;
+        return file ? path.dirname(path.resolve(base, file)) : '';
+    }
+    async function writeArtifactForOutput(output) {
+        await writePureFnArtifact(outputDirOf(output));
+    }
+    function writeArtifactAfterEmit(compiler) {
+        compiler.hooks.afterEmit.tapPromise(PLUGIN_NAME, () => writePureFnArtifact(compiler.options.output.path ?? ''));
+    }
+    function reportGenerate(gen) {
+        options.onGenerate?.({
+            outDir: gen.outDir,
+            batchesModule: gen.batchesModule,
+            routerInitFiles: gen.routerInitFiles.map((file) => path.resolve(file)),
+        });
+    }
+    const sourceOverlay = new Map();
+    let overlaySeeded = false;
+    function overlayKey(rel) {
+        return rel.split(path.sep).join('/');
+    }
+    function seedOverlay() {
+        if (overlaySeeded)
+            return;
+        overlaySeeded = true;
+        const skip = new Set(['node_modules', '.git', '.next', 'dist', 'coverage']);
+        const walk = (dir) => {
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (skip.has(entry.name))
+                    continue;
+                const full = path.join(dir, entry.name);
+                if (genDirAbs && full === genDirAbs)
+                    continue;
+                if (entry.isDirectory()) {
+                    walk(full);
+                    continue;
+                }
+                if (!/\.[mc]?[jt]sx?$/.test(entry.name))
+                    continue;
+                try {
+                    sourceOverlay.set(overlayKey(path.relative(cwdAbs, full)), fs.readFileSync(full, 'utf8'));
+                }
+                catch {
+                }
+            }
+        };
+        walk(cwdAbs || process.cwd());
+    }
+    async function applyHotUpdate(ctx, updates) {
+        if (!resolver)
+            return [];
+        const relevant = updates.filter((update) => /\.[mc]?[jt]sx?$/.test(update.file));
+        if (relevant.length === 0)
+            return [];
+        const rels = relevant.map((update) => path.relative(cwdAbs || process.cwd(), update.file));
+        seedOverlay();
+        relevant.forEach((update, index) => {
+            if (typeof update.content === 'string')
+                sourceOverlay.set(overlayKey(rels[index]), update.content);
+        });
+        const sources = Object.fromEntries(sourceOverlay);
+        if (Object.keys(sources).length > 0) {
+            try {
+                await resolver.setSources(sources);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (message.includes('config-tsconfig-not-loaded'))
+                    console.error(`[@mionjs/devtools] HMR update skipped — ${message}`);
+                return [];
+            }
+        }
+        let result;
+        try {
+            result = await resolver.scanFiles(rels);
+        }
+        catch {
+            return [];
+        }
+        const withSites = new Set([
+            ...(result.sites ?? []).map((site) => siteKey(site.file)),
+            ...(result.replacements ?? []).map((replacement) => siteKey(replacement.file)),
+            ...(result.batchSites ?? []).map((site) => siteKey(site.file)),
+        ]);
+        for (const rel of rels) {
+            if (withSites.has(siteKey(rel)))
+                siteFiles.add(siteKey(rel));
+            else
+                siteFiles.delete(siteKey(rel));
+        }
+        if (reportEnabled && options.onPureFnReport && result.pureFnSites)
+            options.onPureFnReport(result.pureFnSites, 'update');
+        if (reportEnabled && options.onBatchReport)
+            options.onBatchReport(result.batchSites ?? [], 'update', relevant.map((update) => path.resolve(update.file)));
+        try {
+            const gen = await regenerate();
+            for (const file of gen.siteFiles)
+                siteFiles.add(siteKey(file));
+            reportGenerate(gen);
+            if (isDevServer())
+                devReporter.update(gen.diagnostics ?? [], downgrade);
+        }
+        catch (error) {
+            if (isDevServer()) {
+                devRegenerateFailed(error);
+                devReporter.add(result.diagnostics ?? [], downgrade);
+            }
+        }
+        if (anyEnrichFamily)
+            await syncEnrich(rels);
+        if (!isDevServer())
+            surfaceDiagnostics(ctx, result.diagnostics ?? [], {
+                halts: () => false,
+                downgrade,
+                showInfo,
+                cwd: cwdAbs || process.cwd(),
+                grouped,
+            });
+        const stale = staleSiteFiles(relevant.map((update) => update.file));
+        if (stale.length > 0 && options.onSiteFilesChanged) {
+            try {
+                options.onSiteFilesChanged(stale);
+            }
+            catch (error) {
+                hostWarn(ctx, `@mionjs/devtools: onSiteFilesChanged threw — ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return stale;
+    }
+    function staleSiteFiles(changed) {
+        const edited = new Set(changed.map((file) => depKey(file, cwdAbs || process.cwd())));
+        const stale = new Set();
+        for (const siteFile of typeDeps.affectedSiteFiles(changed))
+            stale.add(siteFile);
+        for (const siteFile of typeDeps.unknownSiteFiles())
+            stale.add(siteFile);
+        for (const file of edited)
+            stale.delete(file);
+        return [...stale].sort();
+    }
+    function isUnderEnrichedDir(file) {
+        if (!genDirAbs)
+            return false;
+        const enrichedRoot = path.join(genDirAbs, 'enriched');
+        const rel = path.relative(enrichedRoot, path.resolve(file));
+        return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+    }
+    return {
+        name: PLUGIN_NAME,
+        rtHotUpdate: applyHotUpdate,
+        rtWritePureFnArtifact: writePureFnArtifact,
+        rtGenDir: () => genDirAbs,
+        enforce: 'pre',
+        async buildStart() {
+            activeBuilds += 1;
+            warnBelowTypeScriptFloor(options.cwd ?? process.cwd(), PLUGIN_NAME);
+            ensureResolver();
+            const gen = await regenerate();
+            if (gen.outDir)
+                genDirAbs = gen.outDir;
+            downgrade = resolveDowngradeErrors(options.downgradeErrors ?? gen.downgradeErrors);
+            showInfo = resolveShowInfo(options.levels ?? gen.levels);
+            grouped = resolveGrouped(options.logStyle ?? gen.logStyle);
+            if (reportEnabled && options.onPureFnReport)
+                options.onPureFnReport(gen.pureFnSites ?? [], 'build');
+            if (reportEnabled && options.onBatchReport)
+                options.onBatchReport(gen.batchSites ?? [], 'build');
+            siteFiles = new Set(gen.siteFiles.map(siteKey));
+            reportGenerate(gen);
+            if (isDevServer())
+                devReporter.update(gen.diagnostics ?? [], downgrade);
+            else
+                surfaceDiagnostics(this, gen.diagnostics ?? [], { halts, downgrade, showInfo, cwd: cwdAbs || process.cwd(), grouped });
+            if (anyEnrichFamily) {
+                if (viteCommand === 'serve')
+                    await syncEnrich([]);
+                else
+                    await enrichDriftGate(this);
+            }
+        },
+        buildEnd() {
+            if (activeBuilds > 0)
+                activeBuilds -= 1;
+            if (activeBuilds > 0)
+                return;
+            resolver?.close();
+            resolver = null;
+        },
+        transformInclude(id) {
+            return /\.[mc]?[jt]sx?$/.test(id);
+        },
+        ...(meta.framework !== 'bun' && options.clientRoutes === 'fetch'
+            ? {
+                resolveId(id) {
+                    return id === BUNDLED_API_ID ? bundledApiStubPath() : null;
+                },
+            }
+            : {}),
+        async transform(code, id) {
+            if (!resolver)
+                return null;
+            if (!/\.[mc]?[jt]sx?$/.test(id))
+                return null;
+            const rel = path.relative(cwdAbs || process.cwd(), id);
+            const inSiteSet = siteFiles.has(siteKey(rel));
+            if (!inSiteSet && !mayHoldMarkerCalls(code, id, options.markers) && !mayHoldDrizzleSchemas(code))
+                return null;
+            try {
+                return await (transformMode === 'edits' ? transformViaEdits(this, rel, code) : transformViaGo(this, rel, { code }));
+            }
+            catch (error) {
+                if (!inSiteSet && error instanceof Error && error.message.includes('source file not in program'))
+                    return null;
+                throw error;
+            }
+        },
+        rollup: { writeBundle: writeArtifactForOutput },
+        rolldown: { writeBundle: writeArtifactForOutput },
+        esbuild: {
+            setup(build) {
+                build.onEnd(() => writePureFnArtifact(outputDirOf(build.initialOptions)));
+            },
+        },
+        webpack: writeArtifactAfterEmit,
+        rspack: writeArtifactAfterEmit,
+        bun: {
+            setup(build) {
+                if (typeof build.onEnd === 'function')
+                    build.onEnd(() => writePureFnArtifact(outputDirOf({ outdir: build.config?.outdir })));
+            },
+        },
+        vite: {
+            writeBundle: writeArtifactForOutput,
+            buildApp: {
+                order: 'post',
+                async handler(builder) {
+                    const environments = Object.values(builder?.environments ?? {});
+                    if (environments.length === 0 || environments.some((environment) => environment.isBuilt))
+                        return;
+                    activeBuilds += 1;
+                    try {
+                        for (const environment of environments)
+                            await builder.build(environment);
+                    }
+                    finally {
+                        activeBuilds -= 1;
+                        if (activeBuilds <= 0) {
+                            resolver?.close();
+                            resolver = null;
+                        }
+                    }
+                },
+            },
+            configResolved(cfg) {
+                viteRoot = cfg.root;
+                viteLogger = cfg.logger;
+                if (cfg.command)
+                    viteCommand = cfg.command;
+                if (cfg.mode)
+                    viteMode = cfg.mode;
+                ensureResolver();
+            },
+            async handleHotUpdate(ctx) {
+                if (!resolver)
+                    return;
+                const file = ctx.file;
+                if (!file)
+                    return;
+                if (suppressEnrichHmr && isUnderEnrichedDir(file))
+                    return [];
+                if (!/\.[mc]?[jt]sx?$/.test(file))
+                    return;
+                const content = typeof ctx.read === 'function' ? await ctx.read() : undefined;
+                const stale = await applyHotUpdate(this, [{ file, content }]);
+                if (stale.length === 0)
+                    return;
+                const graph = ctx.server?.moduleGraph;
+                if (!graph?.getModulesByFile)
+                    return;
+                const modules = new Map();
+                for (const existing of ctx.modules ?? [])
+                    modules.set(existing, existing);
+                for (const siteFile of stale) {
+                    for (const mod of graph.getModulesByFile(siteFile) ?? []) {
+                        graph.invalidateModule?.(mod);
+                        modules.set(mod, mod);
+                    }
+                }
+                return [...modules.values()];
+            },
+        },
+    };
+});
+export default unplugin;
+export { formatDowngraded, formatTscDiagnostic } from "./surface.js";
+export { ENTRY_MODULE_PREFIX, ENTRY_MODULE_SUFFIX, ENTRY_BINDING_PREFIX, CACHE_MODULES, } from "./go-generated/runtypes-constants.generated.js";
+//# sourceMappingURL=unplugin.js.map