@webstir-io/webstir-backend 0.1.15 → 0.1.16

package/dist/watch.js

@@ -1,39 +1,43 @@
 import path from 'node:path';
 import { existsSync } from 'node:fs';
+import { mkdir, rm, stat } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
 import { performance } from 'node:perf_hooks';
-import { context as createEsbuildContext } from 'esbuild';
-import { collectOutputSizes, formatEsbuildMessage, shouldTypeCheck } from './build/pipeline.js';
+import { glob } from 'glob';
+import { ensureModuleDefinitionBuild, formatEsbuildMessage, shouldTypeCheck, } from './build/pipeline.js';
 import { discoverEntryPoints } from './build/entries.js';
 import { loadBackendModuleManifest } from './manifest/pipeline.js';
 import { createCacheReporter } from './cache/reporters.js';
-import { normalizeMode, resolveWorkspacePaths } from './workspace.js';
+import { normalizeMode, resolveWorkspacePaths, resolveWorkspaceRoot } from './workspace.js';
+const WATCH_POLL_INTERVAL_MS = 250;
 export async function startBackendWatch(options) {
-    const { workspaceRoot } = options;
-    const env = options.env ?? {};
+    const env = { ...process.env, ...(options.env ?? {}) };
+    const workspaceRoot = resolveWorkspaceRoot({
+        workspaceRoot: options.workspaceRoot,
+        env,
+    });
     const paths = resolveWorkspacePaths(workspaceRoot);
     const tsconfigPath = path.join(paths.sourceRoot, 'tsconfig.json');
     const mode = normalizeMode(env.WEBSTIR_MODULE_MODE);
-    const entryPoints = await discoverEntryPoints(paths.sourceRoot);
-    if (entryPoints.length === 0) {
+    const initialEntryPoints = await discoverEntryPoints(paths.sourceRoot);
+    if (initialEntryPoints.length === 0) {
         console.warn(`[webstir-backend] watch: no entry found under ${paths.sourceRoot} (index.ts/js)`);
         throw new Error('No backend entry point found.');
     }
     const nodeEnv = env.NODE_ENV ?? (mode === 'publish' ? 'production' : 'development');
+    const shouldReportBunBenchmark = isEnabled(env.WEBSTIR_BACKEND_WATCH_BUN_BENCHMARK);
     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 : 20;
     })();
     console.info(`[webstir-backend] watch:start (${mode})`);
-    // Start type-checker in watch mode (no emit) unless explicitly skipped for DX.
-    const shouldRunTypecheck = shouldTypeCheck(mode, env);
     let tscProc;
-    if (shouldRunTypecheck) {
+    if (shouldTypeCheck(mode, env)) {
         const tscArgs = ['-p', tsconfigPath, '--noEmit', '--watch'];
         tscProc = spawn('tsc', tscArgs, {
             stdio: ['ignore', 'pipe', 'pipe'],
-            env: { ...process.env, ...env, NODE_ENV: nodeEnv },
+            env: { ...env, NODE_ENV: nodeEnv },
             cwd: workspaceRoot,
         });
         tscProc.stdout?.on('data', (chunk) => {
@@ -54,98 +58,86 @@ export async function startBackendWatch(options) {
     else {
         console.info('[webstir-backend] watch: type-check skipped by WEBSTIR_BACKEND_TYPECHECK');
     }
-    const timingPlugin = {
-        name: 'webstir-watch-logger',
-        setup(build) {
-            let start = 0;
-            build.onStart(() => {
-                start = performance.now();
-            });
-            build.onEnd(async (result) => {
-                const end = performance.now();
-                const warnCount = result.warnings?.length ?? 0;
-                // errors is not in the typed result, but present at runtime
-                const errorList = result.errors ?? [];
-                const errorCount = Array.isArray(errorList) ? errorList.length : 0;
-                // Print detailed diagnostics with file:line when available (capped for readability)
-                if (errorCount > 0) {
-                    for (const msg of errorList.slice(0, diagMax)) {
-                        const text = formatEsbuildMessage(msg);
-                        console.error(`[webstir-backend][esbuild] ${text}`);
-                    }
-                    if (errorCount > diagMax) {
-                        console.error(`[webstir-backend][esbuild] ... ${errorCount - diagMax} more error(s) omitted`);
-                    }
-                }
-                if (warnCount > 0) {
-                    for (const msg of result.warnings.slice(0, diagMax)) {
-                        const text = formatEsbuildMessage(msg);
-                        console.warn(`[webstir-backend][esbuild] ${text}`);
-                    }
-                    if (warnCount > diagMax) {
-                        console.warn(`[webstir-backend][esbuild] ... ${warnCount - diagMax} more warning(s) omitted`);
-                    }
+    if (shouldReportBunBenchmark) {
+        console.info('[webstir-backend] watch: reporting primary Bun build timings via bunBenchmark* event fields.');
+    }
+    let stopping = false;
+    let watchTimer;
+    let currentSnapshot = await takeWatchSnapshot(workspaceRoot, paths.sourceRoot, tsconfigPath);
+    let buildInFlight = false;
+    let pendingBuild = false;
+    let buildFailure;
+    const runBuild = async () => {
+        if (stopping) {
+            return;
+        }
+        if (buildInFlight) {
+            pendingBuild = true;
+            return;
+        }
+        buildInFlight = true;
+        try {
+            do {
+                pendingBuild = false;
+                const nextSnapshot = await takeWatchSnapshot(workspaceRoot, paths.sourceRoot, tsconfigPath);
+                currentSnapshot = nextSnapshot;
+                const result = await performWatchBuild({
+                    workspaceRoot,
+                    sourceRoot: paths.sourceRoot,
+                    buildRoot: paths.buildRoot,
+                    tsconfigPath,
+                    mode,
+                    env,
+                    nodeEnv,
+                    diagMax,
+                    shouldReportBunBenchmark,
+                    onEvent: options.onEvent,
+                });
+                if (!result.succeeded) {
+                    buildFailure = new Error('Backend watch build failed.');
                 }
-                console.info(`[webstir-backend] watch:esbuild ${errorCount} error(s), ${warnCount} warning(s) in ${(end - start).toFixed(1)}ms`);
-                if (errorCount === 0) {
-                    const diagBuffer = [];
-                    const cacheReporter = createCacheReporter({
-                        workspaceRoot,
-                        buildRoot: paths.buildRoot,
-                        env,
-                        diagnostics: diagBuffer
-                    });
-                    try {
-                        const metafile = result.metafile;
-                        if (metafile && metafile.outputs) {
-                            const outputs = collectOutputSizes(metafile, paths.buildRoot);
-                            await cacheReporter.diffOutputs(outputs, mode);
-                        }
-                        const manifest = await loadBackendModuleManifest({
-                            workspaceRoot,
-                            buildRoot: paths.buildRoot,
-                            entryPoints,
-                            diagnostics: diagBuffer
-                        });
-                        await cacheReporter.diffManifest(manifest);
-                    }
-                    catch {
-                        // cache or manifest diff failure should not break watch
-                    }
-                    finally {
-                        for (const diag of diagBuffer) {
-                            const logger = diag.severity === 'error' ? console.error : diag.severity === 'warn' ? console.warn : console.info;
-                            logger(diag.message);
-                        }
-                    }
+                else {
+                    buildFailure = undefined;
                 }
-            });
-        },
+            } while (pendingBuild && !stopping);
+        }
+        finally {
+            buildInFlight = false;
+        }
     };
-    const ctx = await createEsbuildContext({
-        entryPoints,
-        bundle: false,
-        platform: 'node',
-        target: 'node20',
-        format: 'esm',
-        sourcemap: true,
-        outdir: paths.buildRoot,
-        outbase: paths.sourceRoot,
-        metafile: true,
-        tsconfig: existsSync(tsconfigPath) ? tsconfigPath : undefined,
-        define: { 'process.env.NODE_ENV': JSON.stringify(nodeEnv) },
-        logLevel: 'silent',
-        plugins: [timingPlugin],
-    });
-    await ctx.watch();
+    await runBuild();
     console.info('[webstir-backend] watch:ready');
+    const poll = async () => {
+        if (stopping) {
+            return;
+        }
+        try {
+            const nextSnapshot = await takeWatchSnapshot(workspaceRoot, paths.sourceRoot, tsconfigPath);
+            if (nextSnapshot !== currentSnapshot) {
+                currentSnapshot = nextSnapshot;
+                await runBuild();
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[webstir-backend] watch:poll failed: ${message}`);
+        }
+        finally {
+            if (!stopping) {
+                watchTimer = setTimeout(() => {
+                    void poll();
+                }, WATCH_POLL_INTERVAL_MS);
+            }
+        }
+    };
+    watchTimer = setTimeout(() => {
+        void poll();
+    }, WATCH_POLL_INTERVAL_MS);
     return {
         async stop() {
-            try {
-                await ctx.dispose();
-            }
-            catch {
-                // ignore
+            stopping = true;
+            if (watchTimer) {
+                clearTimeout(watchTimer);
             }
             try {
                 tscProc?.kill('SIGINT');
@@ -154,6 +146,262 @@ export async function startBackendWatch(options) {
                 // ignore
             }
             console.info('[webstir-backend] watch:stopped');
+            if (buildFailure) {
+                buildFailure = undefined;
+            }
+        },
+    };
+}
+async function performWatchBuild(options) {
+    const start = performance.now();
+    await emitWatchEvent(options.onEvent, {
+        type: 'build-start',
+    });
+    const diagnostics = [];
+    const entryPoints = await discoverEntryPoints(options.sourceRoot);
+    if (entryPoints.length === 0) {
+        diagnostics.push({
+            severity: 'error',
+            message: `No backend entry points found under ${options.sourceRoot}.`,
+        });
+        flushDiagnostics(diagnostics);
+        const end = performance.now();
+        await emitWatchEvent(options.onEvent, {
+            type: 'build-complete',
+            succeeded: false,
+            errorCount: 1,
+            warningCount: 0,
+            durationMs: end - start,
+        });
+        return {
+            succeeded: false,
+            errorCount: 1,
+            warningCount: 0,
+        };
+    }
+    const buildResult = await runPrimaryBunWatchBuild({
+        entryPoints,
+        sourceRoot: options.sourceRoot,
+        buildRoot: options.buildRoot,
+        tsconfigPath: options.tsconfigPath,
+        nodeEnv: options.nodeEnv,
+        diagMax: options.diagMax,
+    });
+    console.info(`[webstir-backend] watch:bun ${buildResult.errorCount} error(s), ${buildResult.warningCount} warning(s) in ${buildResult.durationMs.toFixed(1)}ms`);
+    if (buildResult.succeeded) {
+        const cacheReporter = createCacheReporter({
+            workspaceRoot: options.workspaceRoot,
+            buildRoot: options.buildRoot,
+            env: options.env,
+            diagnostics,
+        });
+        try {
+            await ensureModuleDefinitionBuild({
+                sourceRoot: options.sourceRoot,
+                buildRoot: options.buildRoot,
+                tsconfigPath: options.tsconfigPath,
+                mode: options.mode,
+                env: options.env,
+                diagnostics,
+            });
+            await cacheReporter.diffOutputs(collectBunOutputSizes(buildResult.outputs, options.buildRoot), options.mode);
+            const manifest = await loadBackendModuleManifest({
+                workspaceRoot: options.workspaceRoot,
+                buildRoot: options.buildRoot,
+                entryPoints,
+                diagnostics,
+            });
+            await cacheReporter.diffManifest(manifest);
+        }
+        catch {
+            // cache or manifest diff failure should not break watch
+        }
+    }
+    flushDiagnostics(diagnostics);
+    const end = performance.now();
+    const bunBenchmark = options.shouldReportBunBenchmark
+        ? {
+            succeeded: buildResult.succeeded,
+            errorCount: buildResult.errorCount,
+            warningCount: buildResult.warningCount,
+            durationMs: buildResult.durationMs,
+        }
+        : undefined;
+    await emitWatchEvent(options.onEvent, {
+        type: 'build-complete',
+        succeeded: buildResult.succeeded,
+        errorCount: buildResult.errorCount,
+        warningCount: buildResult.warningCount,
+        durationMs: end - start,
+        bunBenchmarkSucceeded: bunBenchmark?.succeeded,
+        bunBenchmarkErrorCount: bunBenchmark?.errorCount,
+        bunBenchmarkWarningCount: bunBenchmark?.warningCount,
+        bunBenchmarkDurationMs: bunBenchmark?.durationMs,
+    });
+    return {
+        succeeded: buildResult.succeeded,
+        errorCount: buildResult.errorCount,
+        warningCount: buildResult.warningCount,
+    };
+}
+async function runPrimaryBunWatchBuild(options) {
+    const build = getBunBuild();
+    if (!build) {
+        throw new Error('Bun.build() is not available in the current runtime.');
+    }
+    await rm(options.buildRoot, { recursive: true, force: true });
+    await mkdir(options.buildRoot, { recursive: true });
+    const start = performance.now();
+    const result = await build({
+        entrypoints: [...options.entryPoints],
+        root: options.sourceRoot,
+        outdir: options.buildRoot,
+        target: 'node',
+        format: 'esm',
+        splitting: false,
+        packages: 'external',
+        sourcemap: 'linked',
+        tsconfig: existsSync(options.tsconfigPath) ? options.tsconfigPath : undefined,
+        define: {
+            'process.env.NODE_ENV': JSON.stringify(options.nodeEnv),
         },
+        // Preserve the old esbuild watch behavior: transpile entries without requiring
+        // every relative import target to exist in minimal seeded workspaces.
+        plugins: [createRelativeImportPassthroughPlugin()],
+        throw: false,
+    });
+    const end = performance.now();
+    const { errorCount, warningCount } = logBunBuildResult(result, options.diagMax);
+    return {
+        succeeded: result.success && errorCount === 0,
+        errorCount,
+        warningCount,
+        durationMs: end - start,
+        outputs: result.outputs,
     };
 }
+function logBunBuildResult(result, diagMax) {
+    const logs = Array.isArray(result.logs) ? result.logs : [];
+    const errorLogs = logs.filter((log) => log.level === 'error');
+    const warningLogs = logs.filter((log) => log.level === 'warning');
+    for (const log of errorLogs.slice(0, diagMax)) {
+        console.error(`[webstir-backend][bun] ${formatEsbuildMessage(log)}`);
+    }
+    if (errorLogs.length > diagMax) {
+        console.error(`[webstir-backend][bun] ... ${errorLogs.length - diagMax} more error(s) omitted`);
+    }
+    for (const log of warningLogs.slice(0, diagMax)) {
+        console.warn(`[webstir-backend][bun] ${formatEsbuildMessage(log)}`);
+    }
+    if (warningLogs.length > diagMax) {
+        console.warn(`[webstir-backend][bun] ... ${warningLogs.length - diagMax} more warning(s) omitted`);
+    }
+    return {
+        errorCount: errorLogs.length,
+        warningCount: warningLogs.length,
+    };
+}
+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 takeWatchSnapshot(workspaceRoot, sourceRoot, tsconfigPath) {
+    const watchFiles = new Set();
+    const packageJsonPath = path.join(workspaceRoot, 'package.json');
+    if (existsSync(packageJsonPath)) {
+        watchFiles.add(packageJsonPath);
+    }
+    if (existsSync(tsconfigPath)) {
+        watchFiles.add(tsconfigPath);
+    }
+    const typesRoot = path.join(workspaceRoot, 'types');
+    const directoryRoots = [sourceRoot];
+    if (existsSync(typesRoot)) {
+        directoryRoots.push(typesRoot);
+    }
+    for (const directoryRoot of directoryRoots) {
+        for (const filePath of await listWatchFiles(directoryRoot)) {
+            watchFiles.add(filePath);
+        }
+    }
+    const entries = await Promise.all(Array.from(watchFiles)
+        .sort()
+        .map(async (filePath) => {
+        const fileStat = await stat(filePath);
+        return `${filePath}:${fileStat.size}:${fileStat.mtimeMs}`;
+    }));
+    return entries.join('|');
+}
+async function listWatchFiles(root) {
+    if (!existsSync(root)) {
+        return [];
+    }
+    const entries = await glob('**/*', {
+        cwd: root,
+        absolute: true,
+        dot: false,
+        nodir: false,
+    });
+    const files = [];
+    for (const entry of entries) {
+        try {
+            const entryStat = await stat(entry);
+            if (entryStat.isFile()) {
+                files.push(entry);
+            }
+        }
+        catch {
+            // Ignore files deleted between glob and stat.
+        }
+    }
+    return files;
+}
+function flushDiagnostics(diagnostics) {
+    for (const diag of diagnostics) {
+        const logger = diag.severity === 'error'
+            ? console.error
+            : diag.severity === 'warn'
+                ? console.warn
+                : console.info;
+        logger(diag.message);
+    }
+}
+async function emitWatchEvent(onEvent, event) {
+    if (!onEvent) {
+        return;
+    }
+    try {
+        await onEvent(event);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[webstir-backend] watch:event failed: ${message}`);
+    }
+}
+function getBunBuild() {
+    const runtime = globalThis;
+    const build = runtime.Bun?.build;
+    return typeof build === 'function' ? build.bind(runtime.Bun) : undefined;
+}
+function createRelativeImportPassthroughPlugin() {
+    return {
+        name: 'webstir-backend-watch-relative-imports',
+        setup(build) {
+            build.onResolve({ filter: /^\.\.?\// }, (args) => ({
+                path: args.path,
+                external: true,
+            }));
+        },
+    };
+}
+function isEnabled(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'on' || normalized === 'yes';
+}

package/dist/workspace.d.ts

@@ -1,4 +1,12 @@
 import type { ResolvedModuleWorkspace } from '@webstir-io/module-contract';
 export type BackendBuildMode = 'build' | 'publish' | 'test';
+interface ResolveWorkspaceRootOptions {
+    readonly workspaceRoot?: string;
+    readonly env?: Record<string, string | undefined>;
+    readonly cwd?: string;
+    readonly importMetaUrl?: string;
+}
+export declare function resolveWorkspaceRoot(options?: string | ResolveWorkspaceRootOptions): string;
 export declare function resolveWorkspacePaths(workspaceRoot: string): ResolvedModuleWorkspace;
 export declare function normalizeMode(rawMode: unknown): BackendBuildMode;
+export {};

package/dist/workspace.js

@@ -1,9 +1,33 @@
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const WORKSPACE_ROOT_PATTERN = /^(.*)[/\\](?:src|build)[/\\]backend(?:[/\\].*)?$/;
+export function resolveWorkspaceRoot(options) {
+    if (typeof options === 'string') {
+        return path.resolve(options);
+    }
+    const explicitRoot = options?.workspaceRoot?.trim();
+    if (explicitRoot) {
+        return path.resolve(explicitRoot);
+    }
+    const env = options?.env ?? process.env;
+    const envRoot = env.WORKSPACE_ROOT?.trim() || env.WEBSTIR_WORKSPACE_ROOT?.trim();
+    if (envRoot) {
+        return path.resolve(envRoot);
+    }
+    const inferredRoot = options?.importMetaUrl
+        ? inferWorkspaceRootFromImportMetaUrl(options.importMetaUrl)
+        : undefined;
+    if (inferredRoot) {
+        return inferredRoot;
+    }
+    return path.resolve(options?.cwd ?? process.cwd());
+}
 export function resolveWorkspacePaths(workspaceRoot) {
+    const resolvedWorkspaceRoot = resolveWorkspaceRoot(workspaceRoot);
     return {
-        sourceRoot: path.join(workspaceRoot, 'src', 'backend'),
-        buildRoot: path.join(workspaceRoot, 'build', 'backend'),
-        testsRoot: path.join(workspaceRoot, 'src', 'backend', 'tests')
+        sourceRoot: path.join(resolvedWorkspaceRoot, 'src', 'backend'),
+        buildRoot: path.join(resolvedWorkspaceRoot, 'build', 'backend'),
+        testsRoot: path.join(resolvedWorkspaceRoot, 'src', 'backend', 'tests'),
     };
 }
 export function normalizeMode(rawMode) {
@@ -13,3 +37,20 @@ export function normalizeMode(rawMode) {
     const normalized = rawMode.toLowerCase();
     return normalized === 'publish' || normalized === 'test' ? normalized : 'build';
 }
+function inferWorkspaceRootFromImportMetaUrl(importMetaUrl) {
+    try {
+        return inferWorkspaceRootFromFilePath(fileURLToPath(importMetaUrl));
+    }
+    catch {
+        return undefined;
+    }
+}
+function inferWorkspaceRootFromFilePath(filePath) {
+    const normalizedFilePath = path.resolve(filePath);
+    const match = normalizedFilePath.match(WORKSPACE_ROOT_PATTERN);
+    if (!match) {
+        return undefined;
+    }
+    const inferredRoot = match[1];
+    return inferredRoot || path.parse(normalizedFilePath).root;
+}

package/package.json

@@ -1,16 +1,49 @@
 {
   "name": "@webstir-io/webstir-backend",
-  "version": "0.1.15",
-  "description": "Reserved manifest for the future Webstir backend tooling package.",
+  "version": "0.1.16",
+  "description": "Backend build and runtime tooling for Webstir workspaces.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "bin": {
+    "webstir-backend-deploy": "dist/deploy-cli.js"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./runtime/forms": {
+      "types": "./dist/runtime/forms.d.ts",
+      "import": "./dist/runtime/forms.js",
+      "default": "./dist/runtime/forms.js"
+    },
+    "./runtime/request-hooks": {
+      "types": "./dist/runtime/request-hooks.d.ts",
+      "import": "./dist/runtime/request-hooks.js",
+      "default": "./dist/runtime/request-hooks.js"
+    },
+    "./runtime/session": {
+      "types": "./dist/runtime/session.d.ts",
+      "import": "./dist/runtime/session.js",
+      "default": "./dist/runtime/session.js"
+    },
+    "./runtime/views": {
+      "types": "./dist/runtime/views.d.ts",
+      "import": "./dist/runtime/views.js",
+      "default": "./dist/runtime/views.js"
+    },
+    "./runtime/bun": {
+      "types": "./dist/runtime/bun.d.ts",
+      "import": "./dist/runtime/bun.js",
+      "default": "./dist/runtime/bun.js"
+    },
+    "./runtime/deploy": {
+      "types": "./dist/runtime/deploy.d.ts",
+      "import": "./dist/runtime/deploy.js",
+      "default": "./dist/runtime/deploy.js"
+    },
     "./provider": {
       "types": "./dist/provider.d.ts",
       "import": "./dist/provider.js",
@@ -30,13 +63,12 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "node -e \"const { spawnSync } = require('node:child_process'); const glob = require('glob'); const files = glob.sync('tests/**/*.test.js'); if (!files.length) { console.error('No backend test files found'); process.exit(1); } const result = spawnSync(process.execPath, ['--test', ...files], { stdio: 'inherit' }); process.exit(result.status ?? 1);\"",
+    "test": "tsc -p tsconfig.json && bun test tests",
     "clean": "rm -rf dist",
-    "prepare": "npm run build",
-    "watch": "npm run build && node -e \"import('./dist/watch.js').then(m=>m.startBackendWatch({workspaceRoot:process.cwd(),env:{WEBSTIR_MODULE_MODE:'build'}}));\"",
-    "dev": "npm run watch",
-    "dev:fast": "WEBSTIR_BACKEND_TYPECHECK=skip npm run watch",
-    "smoke": "npm run build && node scripts/smoke.mjs",
+    "watch": "tsc -p tsconfig.json && bun -e \"import('./dist/watch.js').then(m=>m.startBackendWatch({env:{WEBSTIR_MODULE_MODE:'build'}}));\"",
+    "dev": "bun run watch",
+    "dev:fast": "WEBSTIR_BACKEND_TYPECHECK=skip bun run watch",
+    "smoke": "tsc -p tsconfig.json && bun scripts/smoke.mjs",
     "release": "bash scripts/publish.sh"
   },
   "files": [
@@ -45,25 +77,28 @@
     "src",
     "scripts",
     "tests",
-    "tsconfig.json",
-    "package-lock.json"
+    "tsconfig.json"
   ],
   "engines": {
-    "node": ">=20.18.1"
+    "bun": ">=1.3.11"
   },
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/webstir-io/webstir-backend.git"
+    "url": "git+https://github.com/webstir-io/webstir.git",
+    "directory": "packages/tooling/webstir-backend"
+  },
+  "homepage": "https://github.com/webstir-io/webstir/tree/main/packages/tooling/webstir-backend#readme",
+  "bugs": {
+    "url": "https://github.com/webstir-io/webstir/issues"
   },
   "dependencies": {
-    "@webstir-io/module-contract": "^0.1.13",
+    "@webstir-io/module-contract": "^0.1.16",
     "esbuild": "^0.25.10",
     "glob": "^10.4.1"
   },
   "devDependencies": {
     "@types/node": "^20.19.21",
-    "fastify": "^5.6.2",
     "pino": "^10.1.0",
     "typescript": "^5.7.2"
   },