@webstir-io/webstir-backend 0.1.15 → 0.1.16

package/dist/build/pipeline.js

@@ -1,5 +1,7 @@
 import path from 'node:path';
 import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { mkdir, rm } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
 import { performance } from 'node:perf_hooks';
 import { build as esbuild, context as esbuildContext } from 'esbuild';
@@ -14,57 +16,76 @@ if (typeof process !== 'undefined' && typeof process.once === 'function') {
 export async function runBackendBuildPipeline(options) {
     const { sourceRoot, buildRoot, tsconfigPath, diagnostics, incremental, mode } = options;
     const env = options.env ?? {};
+    const bundler = options.bundler ??
+        resolveBackendBundler({
+            env,
+            incremental,
+            diagnostics,
+        });
     console.info(`[webstir-backend] ${mode}:tsc start`);
     if (shouldTypeCheck(mode, env)) {
         await runTypeCheck(tsconfigPath, env, diagnostics);
     }
     else {
-        diagnostics.push({ severity: 'info', message: '[webstir-backend] type-check skipped by WEBSTIR_BACKEND_TYPECHECK' });
+        diagnostics.push({
+            severity: 'info',
+            message: '[webstir-backend] type-check skipped by WEBSTIR_BACKEND_TYPECHECK',
+        });
     }
     console.info(`[webstir-backend] ${mode}:tsc done`);
     const entryPoints = await discoverEntryPoints(sourceRoot);
     if (entryPoints.length === 0) {
         diagnostics.push({
             severity: 'warn',
-            message: `No backend entry points found under ${sourceRoot} (expected index.* or functions/*/index.* or jobs/*/index.*).`
+            message: `No backend entry points found under ${sourceRoot} (expected index.* or functions/*/index.* or jobs/*/index.*).`,
         });
     }
-    console.info(`[webstir-backend] ${mode}:esbuild start`);
-    const outputs = await runEsbuild({
+    if (bundler === 'bun') {
+        await resetBuildRoot(buildRoot);
+    }
+    console.info(`[webstir-backend] ${mode}:${bundler} start`);
+    const outputs = bundler === 'bun'
+        ? await runBunBuild({
+            sourceRoot,
+            buildRoot,
+            tsconfigPath,
+            mode,
+            env,
+            incremental,
+            diagnostics,
+            entryPoints,
+        })
+        : await runEsbuild({
+            sourceRoot,
+            buildRoot,
+            tsconfigPath,
+            mode,
+            env,
+            incremental,
+            diagnostics,
+            entryPoints,
+        });
+    console.info(`[webstir-backend] ${mode}:${bundler} done`);
+    await ensureModuleDefinitionBuild({
         sourceRoot,
         buildRoot,
         tsconfigPath,
         mode,
         env,
-        incremental,
         diagnostics,
-        entryPoints
     });
-    console.info(`[webstir-backend] ${mode}:esbuild done`);
-    const moduleSource = await discoverModuleDefinitionSource(sourceRoot);
-    if (moduleSource) {
-        await buildModuleDefinition({
-            sourceFile: moduleSource,
-            sourceRoot,
-            buildRoot,
-            tsconfigPath,
-            mode,
-            env,
-            diagnostics
-        });
-    }
     const includePublishSourcemaps = mode === 'publish' && shouldEmitPublishSourcemaps(env);
     return {
         entryPoints,
         outputs,
-        includePublishSourcemaps
+        includePublishSourcemaps,
     };
 }
 async function runTypeCheck(tsconfigPath, env, diagnostics) {
     if (!existsSync(tsconfigPath)) {
         diagnostics.push({
             severity: 'warn',
-            message: `TypeScript config not found at ${tsconfigPath}; skipping type-check.`
+            message: `TypeScript config not found at ${tsconfigPath}; skipping type-check.`,
         });
         return;
     }
@@ -73,8 +94,8 @@ async function runTypeCheck(tsconfigPath, env, diagnostics) {
             stdio: 'pipe',
             env: {
                 ...process.env,
-                ...env
-            }
+                ...env,
+            },
         });
         let stdout = '';
         let stderr = '';
@@ -85,9 +106,12 @@ async function runTypeCheck(tsconfigPath, env, diagnostics) {
             stderr += chunk.toString();
         });
         child.on('error', (err) => {
-            const code = (err && typeof err === 'object') ? err.code : undefined;
+            const code = err.code;
             if (code === 'ENOENT') {
-                diagnostics.push({ severity: 'warn', message: 'TypeScript compiler (tsc) not found in PATH; skipping type-check.' });
+                diagnostics.push({
+                    severity: 'warn',
+                    message: 'TypeScript compiler (tsc) not found in PATH; skipping type-check.',
+                });
                 resolve();
                 return;
             }
@@ -101,7 +125,7 @@ async function runTypeCheck(tsconfigPath, env, diagnostics) {
                 diagnostics.push({
                     severity: 'error',
                     message: `Type checking failed (exit code ${code}).`,
-                    file: tsconfigPath
+                    file: tsconfigPath,
                 });
                 if (stderr.trim()) {
                     diagnostics.push({ severity: 'error', message: stderr.trim() });
@@ -124,6 +148,32 @@ export function shouldTypeCheck(mode, env) {
     }
     return true;
 }
+export function resolveBackendBundler(options) {
+    const requestedBundler = normalizeBackendBundler(options.env?.WEBSTIR_BACKEND_BUNDLER);
+    if (requestedBundler !== 'bun') {
+        return 'esbuild';
+    }
+    if (options.incremental) {
+        options.diagnostics?.push({
+            severity: 'info',
+            message: '[webstir-backend] WEBSTIR_BACKEND_BUNDLER=bun requested for an incremental build; falling back to esbuild.',
+        });
+        return 'esbuild';
+    }
+    if (!getBunBuild()) {
+        options.diagnostics?.push({
+            severity: 'warn',
+            message: '[webstir-backend] WEBSTIR_BACKEND_BUNDLER=bun requested outside a Bun runtime; falling back to esbuild.',
+        });
+        return 'esbuild';
+    }
+    return 'bun';
+}
+function normalizeBackendBundler(rawBundler) {
+    return typeof rawBundler === 'string' && rawBundler.trim().toLowerCase() === 'bun'
+        ? 'bun'
+        : 'esbuild';
+}
 function shouldEmitPublishSourcemaps(env) {
     const flag = env?.WEBSTIR_BACKEND_SOURCEMAPS;
     if (typeof flag !== 'string') {
@@ -139,36 +189,74 @@ async function discoverModuleDefinitionSource(sourceRoot) {
             cwd: sourceRoot,
             absolute: true,
             nodir: true,
-            dot: false
+            dot: false,
         });
         if (matches.length > 0) {
             return matches[0];
         }
     }
+    const indexPatterns = ['index.{ts,tsx,js,mjs}'];
+    for (const pattern of indexPatterns) {
+        const matches = await glob(pattern, {
+            cwd: sourceRoot,
+            absolute: true,
+            nodir: true,
+            dot: false,
+        });
+        for (const candidate of matches) {
+            if (await sourceExportsNamedModuleDefinition(candidate)) {
+                return candidate;
+            }
+        }
+    }
     return undefined;
 }
+async function sourceExportsNamedModuleDefinition(sourceFile) {
+    try {
+        const source = await readFile(sourceFile, 'utf8');
+        return (/\bexport\s+(const|let|var)\s+module\b/.test(source) ||
+            /\bexport\s*\{\s*module\b/.test(source));
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureModuleDefinitionBuild(options) {
+    const moduleSource = await discoverModuleDefinitionSource(options.sourceRoot);
+    if (!moduleSource) {
+        return;
+    }
+    await buildModuleDefinition({
+        sourceFile: moduleSource,
+        sourceRoot: options.sourceRoot,
+        buildRoot: options.buildRoot,
+        tsconfigPath: options.tsconfigPath,
+        mode: options.mode,
+        env: options.env,
+        diagnostics: options.diagnostics,
+    });
+}
 async function buildModuleDefinition(options) {
-    const { sourceFile, sourceRoot, buildRoot, tsconfigPath, mode, env, diagnostics } = options;
+    const { sourceFile, buildRoot, tsconfigPath, mode, env, diagnostics } = options;
     const isProduction = mode === 'publish';
     const nodeEnv = env?.NODE_ENV ?? (isProduction ? 'production' : 'development');
     const emitPublishSourcemaps = isProduction && shouldEmitPublishSourcemaps(env);
     const define = {
-        'process.env.NODE_ENV': JSON.stringify(nodeEnv)
+        'process.env.NODE_ENV': JSON.stringify(nodeEnv),
     };
     try {
         await esbuild({
             entryPoints: [sourceFile],
-            bundle: false,
+            bundle: true,
+            packages: 'external',
             platform: 'node',
             target: 'node20',
             format: 'esm',
             sourcemap: isProduction ? emitPublishSourcemaps : true,
-            outdir: buildRoot,
-            outbase: sourceRoot,
-            entryNames: '[dir]/[name]',
+            outfile: path.join(buildRoot, 'module.js'),
             tsconfig: existsSync(tsconfigPath) ? tsconfigPath : undefined,
             define,
-            logLevel: 'silent'
+            logLevel: 'silent',
         });
     }
     catch (error) {
@@ -194,22 +282,43 @@ export async function buildSupportFile(options) {
     const nodeEnv = env?.NODE_ENV ?? (isProduction ? 'production' : 'development');
     const emitPublishSourcemaps = isProduction && shouldEmitPublishSourcemaps(env);
     const define = {
-        'process.env.NODE_ENV': JSON.stringify(nodeEnv)
+        'process.env.NODE_ENV': JSON.stringify(nodeEnv),
     };
-    try {
-        await esbuild({
-            entryPoints: [sourceFile],
-            bundle: false,
-            platform: 'node',
-            target: 'node20',
-            format: 'esm',
-            sourcemap: isProduction ? emitPublishSourcemaps : true,
-            outdir: buildRoot,
-            outbase: sourceRoot,
-            tsconfig: existsSync(tsconfigPath) ? tsconfigPath : undefined,
-            define,
-            logLevel: 'silent'
+    const bundler = options.bundler ??
+        resolveBackendBundler({
+            env,
+            incremental: false,
+            diagnostics,
         });
+    const diagMax = readDiagMax(env, 50);
+    try {
+        if (bundler === 'bun') {
+            const result = await runBunCompile({
+                entryPoints: [sourceFile],
+                sourceRoot,
+                buildRoot,
+                tsconfigPath,
+                define,
+                minify: false,
+                includeSourceMaps: isProduction ? emitPublishSourcemaps : true,
+            });
+            ensureBunCompileSucceeded(result, diagnostics, `${mode}:bun:support`, diagMax);
+        }
+        else {
+            await esbuild({
+                entryPoints: [sourceFile],
+                bundle: false,
+                platform: 'node',
+                target: 'node20',
+                format: 'esm',
+                sourcemap: isProduction ? emitPublishSourcemaps : true,
+                outdir: buildRoot,
+                outbase: sourceRoot,
+                tsconfig: existsSync(tsconfigPath) ? tsconfigPath : undefined,
+                define,
+                logLevel: 'silent',
+            });
+        }
     }
     catch (error) {
         if (error instanceof Error) {
@@ -234,13 +343,9 @@ async function runEsbuild(options) {
     }
     const entrySignature = useIncremental ? createEntrySignature(entryPoints) : undefined;
     const nodeEnv = env?.NODE_ENV ?? (isProduction ? 'production' : 'development');
-    const diagMax = (() => {
-        const raw = env?.WEBSTIR_BACKEND_DIAG_MAX;
-        const n = typeof raw === 'string' ? parseInt(raw, 10) : NaN;
-        return Number.isFinite(n) && n > 0 ? n : 50;
-    })();
+    const diagMax = readDiagMax(env, 50);
     const define = {
-        'process.env.NODE_ENV': JSON.stringify(nodeEnv)
+        'process.env.NODE_ENV': JSON.stringify(nodeEnv),
     };
     const emitPublishSourcemaps = isProduction && shouldEmitPublishSourcemaps(env);
     const start = performance.now();
@@ -267,7 +372,7 @@ async function runEsbuild(options) {
                 tsconfig: existsSync(tsconfigPath) ? tsconfigPath : undefined,
                 define,
                 logLevel: 'silent',
-                metafile: true
+                metafile: true,
             });
         }
         else if (useIncremental && incrementalKey && entrySignature) {
@@ -292,11 +397,11 @@ async function runEsbuild(options) {
                     tsconfig: existsSync(tsconfigPath) ? tsconfigPath : undefined,
                     define,
                     logLevel: 'silent',
-                    metafile: true
+                    metafile: true,
                 });
                 incrementalBuildCache.set(incrementalKey, {
                     entrySignature,
-                    context: ctx
+                    context: ctx,
                 });
                 result = await ctx.rebuild();
             }
@@ -317,7 +422,7 @@ async function runEsbuild(options) {
                 tsconfig: existsSync(tsconfigPath) ? tsconfigPath : undefined,
                 define,
                 logLevel: 'silent',
-                metafile: true
+                metafile: true,
             });
         }
         const warnCount = result.warnings?.length ?? 0;
@@ -327,14 +432,14 @@ async function runEsbuild(options) {
         if (warnCount > diagMax) {
             diagnostics.push({
                 severity: 'info',
-                message: `[webstir-backend] ${isProduction ? 'publish:esbuild' : `${mode}:esbuild`} ... ${warnCount - diagMax} more warning(s) omitted`
+                message: `[webstir-backend] ${isProduction ? 'publish:esbuild' : `${mode}:esbuild`} ... ${warnCount - diagMax} more warning(s) omitted`,
             });
         }
         const end = performance.now();
         const reuseSuffix = reusedIncremental ? ' (incremental)' : '';
         diagnostics.push({
             severity: 'info',
-            message: `[webstir-backend] ${isProduction ? 'publish:esbuild' : `${mode}:esbuild`} 0 error(s), ${warnCount} warning(s) in ${(end - start).toFixed(1)}ms${reuseSuffix}`
+            message: `[webstir-backend] ${isProduction ? 'publish:esbuild' : `${mode}:esbuild`} 0 error(s), ${warnCount} warning(s) in ${(end - start).toFixed(1)}ms${reuseSuffix}`,
         });
         return collectOutputSizes(result.metafile, buildRoot);
     }
@@ -353,12 +458,21 @@ async function runEsbuild(options) {
                 diagnostics.push({ severity: 'warn', message: formatEsbuildMessage(w) });
             }
             if (errs.length > diagMax) {
-                diagnostics.push({ severity: 'info', message: `[webstir-backend] ${mode}:esbuild ... ${errs.length - diagMax} more error(s) omitted` });
+                diagnostics.push({
+                    severity: 'info',
+                    message: `[webstir-backend] ${mode}:esbuild ... ${errs.length - diagMax} more error(s) omitted`,
+                });
             }
             if (warns.length > diagMax) {
-                diagnostics.push({ severity: 'info', message: `[webstir-backend] ${mode}:esbuild ... ${warns.length - diagMax} more warning(s) omitted` });
+                diagnostics.push({
+                    severity: 'info',
+                    message: `[webstir-backend] ${mode}:esbuild ... ${warns.length - diagMax} more warning(s) omitted`,
+                });
             }
-            diagnostics.push({ severity: 'info', message: `[webstir-backend] ${mode}:esbuild ${errs.length} error(s), ${warns.length} warning(s) in ${(end - start).toFixed(1)}ms` });
+            diagnostics.push({
+                severity: 'info',
+                message: `[webstir-backend] ${mode}:esbuild ${errs.length} error(s), ${warns.length} warning(s) in ${(end - start).toFixed(1)}ms`,
+            });
         }
         else if (error instanceof Error) {
             diagnostics.push({ severity: 'error', message: error.message });
@@ -369,6 +483,130 @@ async function runEsbuild(options) {
         throw new Error('esbuild failed.');
     }
 }
+async function runBunBuild(options) {
+    const { sourceRoot, buildRoot, tsconfigPath, mode, env, diagnostics, entryPoints } = options;
+    const isProduction = mode === 'publish';
+    if (!entryPoints || entryPoints.length === 0) {
+        return undefined;
+    }
+    const nodeEnv = env?.NODE_ENV ?? (isProduction ? 'production' : 'development');
+    const diagMax = readDiagMax(env, 50);
+    const define = {
+        'process.env.NODE_ENV': JSON.stringify(nodeEnv),
+    };
+    const emitPublishSourcemaps = isProduction && shouldEmitPublishSourcemaps(env);
+    const start = performance.now();
+    try {
+        const result = await runBunCompile({
+            entryPoints,
+            sourceRoot,
+            buildRoot,
+            tsconfigPath,
+            define,
+            minify: isProduction,
+            includeSourceMaps: isProduction ? emitPublishSourcemaps : true,
+        });
+        const { errorCount, warningCount } = pushBunLogs(diagnostics, result.logs, `${mode}:bun`, diagMax);
+        const end = performance.now();
+        diagnostics.push({
+            severity: 'info',
+            message: `[webstir-backend] ${mode}:bun ${errorCount} error(s), ${warningCount} warning(s) in ${(end - start).toFixed(1)}ms`,
+        });
+        if (!result.success || errorCount > 0) {
+            throw new Error('bun build failed.');
+        }
+        return collectBunOutputSizes(result.outputs, buildRoot);
+    }
+    catch (error) {
+        const end = performance.now();
+        if (error instanceof Error) {
+            diagnostics.push({ severity: 'error', message: error.message });
+        }
+        else {
+            diagnostics.push({ severity: 'error', message: String(error) });
+        }
+        diagnostics.push({
+            severity: 'info',
+            message: `[webstir-backend] ${mode}:bun failed in ${(end - start).toFixed(1)}ms`,
+        });
+        throw new Error('bun build failed.');
+    }
+}
+async function runBunCompile(options) {
+    const build = getBunBuild();
+    if (!build) {
+        throw new Error('Bun.build() is not available in the current runtime.');
+    }
+    return await build({
+        entrypoints: [...options.entryPoints],
+        root: options.sourceRoot,
+        outdir: options.buildRoot,
+        target: 'node',
+        format: 'esm',
+        splitting: false,
+        packages: 'external',
+        minify: options.minify,
+        sourcemap: options.includeSourceMaps ? 'linked' : 'none',
+        tsconfig: existsSync(options.tsconfigPath) ? options.tsconfigPath : undefined,
+        define: options.define,
+        throw: false,
+    });
+}
+function ensureBunCompileSucceeded(result, diagnostics, label, diagMax) {
+    const { errorCount } = pushBunLogs(diagnostics, result.logs, label, diagMax);
+    if (!result.success || errorCount > 0) {
+        throw new Error('bun build failed.');
+    }
+}
+function pushBunLogs(diagnostics, logs, label, diagMax) {
+    const entries = Array.isArray(logs) ? logs : [];
+    const errorLogs = entries.filter((log) => log.level === 'error');
+    const warningLogs = entries.filter((log) => log.level === 'warning');
+    for (const entry of errorLogs.slice(0, diagMax)) {
+        diagnostics.push({ severity: 'error', message: formatEsbuildMessage(entry) });
+    }
+    for (const entry of warningLogs.slice(0, diagMax)) {
+        diagnostics.push({ severity: 'warn', message: formatEsbuildMessage(entry) });
+    }
+    if (errorLogs.length > diagMax) {
+        diagnostics.push({
+            severity: 'info',
+            message: `[webstir-backend] ${label} ... ${errorLogs.length - diagMax} more error(s) omitted`,
+        });
+    }
+    if (warningLogs.length > diagMax) {
+        diagnostics.push({
+            severity: 'info',
+            message: `[webstir-backend] ${label} ... ${warningLogs.length - diagMax} more warning(s) omitted`,
+        });
+    }
+    return {
+        errorCount: errorLogs.length,
+        warningCount: warningLogs.length,
+    };
+}
+function getBunBuild() {
+    const runtime = globalThis;
+    const build = runtime.Bun?.build;
+    return typeof build === 'function' ? build.bind(runtime.Bun) : undefined;
+}
+function collectBunOutputSizes(outputs, buildRoot) {
+    const collected = {};
+    for (const output of outputs ?? []) {
+        const rel = path.relative(buildRoot, output.path);
+        collected[rel] = typeof output.size === 'number' ? output.size : 0;
+    }
+    return collected;
+}
+async function resetBuildRoot(buildRoot) {
+    await rm(buildRoot, { recursive: true, force: true });
+    await mkdir(buildRoot, { recursive: true });
+}
+function readDiagMax(env, fallback) {
+    const raw = env?.WEBSTIR_BACKEND_DIAG_MAX;
+    const n = typeof raw === 'string' ? parseInt(raw, 10) : NaN;
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
 function createIncrementalKey(mode, buildRoot) {
     return `${mode}:${path.resolve(buildRoot)}`;
 }
@@ -414,8 +652,12 @@ function isEsbuildFailure(error) {
     return typeof error === 'object' && error !== null && ('errors' in error || 'warnings' in error);
 }
 export function formatEsbuildMessage(msg) {
-    const text = typeof msg?.text === 'string' ? msg.text : String(msg);
-    const loc = msg?.location;
+    const text = typeof msg.message === 'string'
+        ? msg.message
+        : typeof msg.text === 'string'
+            ? msg.text
+            : String(msg);
+    const loc = msg.location ?? msg.position;
     if (loc && typeof loc.file === 'string') {
         const position = typeof loc.line === 'number' ? `${loc.line}:${loc.column ?? 1}` : '1:1';
         return `${loc.file}:${position} ${text}`;

package/dist/cache/diff.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { mkdir } from 'node:fs/promises';
+import { readTextFile, writeTextFile } from '../utils/bun.js';
 export async function persistAndDiffOutputs(workspaceRoot, _buildRoot, outputs, env, diagnostics, mode) {
     if (!outputs)
         return;
@@ -10,7 +11,7 @@ export async function persistAndDiffOutputs(workspaceRoot, _buildRoot, outputs,
         await mkdir(webstirDir, { recursive: true });
         let previous = {};
         try {
-            const raw = await readFile(cachePath, 'utf8');
+            const raw = await readTextFile(cachePath);
             previous = JSON.parse(raw);
         }
         catch {
@@ -29,10 +30,10 @@ export async function persistAndDiffOutputs(workspaceRoot, _buildRoot, outputs,
             const removedInfo = removed.length > 0 ? `, removed=${removed.length}` : '';
             diagnostics.push({
                 severity: 'info',
-                message: `[webstir-backend] ${mode}:changed ${changed.length} file(s): ${list}${omitted}${removedInfo}`
+                message: `[webstir-backend] ${mode}:changed ${changed.length} file(s): ${list}${omitted}${removedInfo}`,
             });
         }
-        await writeFile(cachePath, JSON.stringify(outputs, null, 2), 'utf8');
+        await writeTextFile(cachePath, JSON.stringify(outputs, null, 2));
     }
     catch {
         // ignore cache errors
@@ -45,15 +46,15 @@ export async function persistAndDiffManifest(workspaceRoot, manifest, env, diagn
         const cachePath = path.join(webstirDir, 'backend-manifest-digest.json');
         await mkdir(webstirDir, { recursive: true });
         const routeKeys = Array.isArray(manifest.routes)
-            ? manifest.routes.map((r) => `${(r.method ?? '').toUpperCase()} ${r.path ?? ''}`)
+            ? manifest.routes.map((route) => `${(route.method ?? '').toUpperCase()} ${route.path ?? ''}`)
             : [];
         const viewPaths = Array.isArray(manifest.views)
-            ? manifest.views.map((v) => `${v.path ?? ''}`)
+            ? manifest.views.map((view) => `${view.path ?? ''}`)
             : [];
         const caps = Array.isArray(manifest.capabilities) ? manifest.capabilities : [];
         let previous;
         try {
-            const raw = await readFile(cachePath, 'utf8');
+            const raw = await readTextFile(cachePath);
             previous = JSON.parse(raw);
         }
         catch {
@@ -101,7 +102,7 @@ export async function persistAndDiffManifest(workspaceRoot, manifest, env, diagn
             }
         }
         const digest = { routes: routeKeys, views: viewPaths, capabilities: caps };
-        await writeFile(cachePath, JSON.stringify(digest, null, 2), 'utf8');
+        await writeTextFile(cachePath, JSON.stringify(digest, null, 2));
     }
     catch {
         // ignore cache errors

package/dist/cache/reporters.js

@@ -8,7 +8,7 @@ export function createCacheReporter(options) {
         },
         async diffManifest(manifest) {
             await persistAndDiffManifest(workspaceRoot, manifest, env, diagnosticsTarget);
-        }
+        },
     };
 }
 function shouldLogCacheDiffs(env) {

package/dist/deploy-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};