@webstir-io/webstir-backend 0.1.15

package/dist/build/pipeline.js

@@ -0,0 +1,424 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { performance } from 'node:perf_hooks';
+import { build as esbuild, context as esbuildContext } from 'esbuild';
+import { glob } from 'glob';
+import { discoverEntryPoints } from './entries.js';
+const incrementalBuildCache = new Map();
+if (typeof process !== 'undefined' && typeof process.once === 'function') {
+    process.once('exit', () => {
+        clearIncrementalCache();
+    });
+}
+export async function runBackendBuildPipeline(options) {
+    const { sourceRoot, buildRoot, tsconfigPath, diagnostics, incremental, mode } = options;
+    const env = options.env ?? {};
+    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' });
+    }
+    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.*).`
+        });
+    }
+    console.info(`[webstir-backend] ${mode}:esbuild start`);
+    const outputs = await runEsbuild({
+        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
+    };
+}
+async function runTypeCheck(tsconfigPath, env, diagnostics) {
+    if (!existsSync(tsconfigPath)) {
+        diagnostics.push({
+            severity: 'warn',
+            message: `TypeScript config not found at ${tsconfigPath}; skipping type-check.`
+        });
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        const child = spawn('tsc', ['-p', tsconfigPath, '--noEmit'], {
+            stdio: 'pipe',
+            env: {
+                ...process.env,
+                ...env
+            }
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', (err) => {
+            const code = (err && typeof err === 'object') ? err.code : undefined;
+            if (code === 'ENOENT') {
+                diagnostics.push({ severity: 'warn', message: 'TypeScript compiler (tsc) not found in PATH; skipping type-check.' });
+                resolve();
+                return;
+            }
+            reject(err);
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                diagnostics.push({
+                    severity: 'error',
+                    message: `Type checking failed (exit code ${code}).`,
+                    file: tsconfigPath
+                });
+                if (stderr.trim()) {
+                    diagnostics.push({ severity: 'error', message: stderr.trim() });
+                }
+                if (stdout.trim()) {
+                    diagnostics.push({ severity: 'info', message: stdout.trim() });
+                }
+                reject(new Error('Type checking failed.'));
+            }
+        });
+    });
+}
+export function shouldTypeCheck(mode, env) {
+    const flag = env?.WEBSTIR_BACKEND_TYPECHECK;
+    if (typeof flag === 'string' && flag.toLowerCase() === 'skip') {
+        return false;
+    }
+    if (mode === 'publish') {
+        return true;
+    }
+    return true;
+}
+function shouldEmitPublishSourcemaps(env) {
+    const flag = env?.WEBSTIR_BACKEND_SOURCEMAPS;
+    if (typeof flag !== 'string') {
+        return false;
+    }
+    const normalized = flag.trim().toLowerCase();
+    return normalized === 'on' || normalized === 'true' || normalized === '1' || normalized === 'yes';
+}
+async function discoverModuleDefinitionSource(sourceRoot) {
+    const patterns = ['module.{ts,tsx,js,mjs}', 'module/index.{ts,tsx,js,mjs}'];
+    for (const pattern of patterns) {
+        const matches = await glob(pattern, {
+            cwd: sourceRoot,
+            absolute: true,
+            nodir: true,
+            dot: false
+        });
+        if (matches.length > 0) {
+            return matches[0];
+        }
+    }
+    return undefined;
+}
+async function buildModuleDefinition(options) {
+    const { sourceFile, sourceRoot, 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)
+    };
+    try {
+        await esbuild({
+            entryPoints: [sourceFile],
+            bundle: false,
+            platform: 'node',
+            target: 'node20',
+            format: 'esm',
+            sourcemap: isProduction ? emitPublishSourcemaps : true,
+            outdir: buildRoot,
+            outbase: sourceRoot,
+            entryNames: '[dir]/[name]',
+            tsconfig: existsSync(tsconfigPath) ? tsconfigPath : undefined,
+            define,
+            logLevel: 'silent'
+        });
+    }
+    catch (error) {
+        if (isEsbuildFailure(error)) {
+            for (const e of error.errors ?? []) {
+                diagnostics.push({ severity: 'error', message: formatEsbuildMessage(e) });
+            }
+            for (const w of error.warnings ?? []) {
+                diagnostics.push({ severity: 'warn', message: formatEsbuildMessage(w) });
+            }
+        }
+        else if (error instanceof Error) {
+            diagnostics.push({ severity: 'error', message: error.message });
+        }
+        else {
+            diagnostics.push({ severity: 'error', message: String(error) });
+        }
+    }
+}
+export async function buildSupportFile(options) {
+    const { sourceFile, sourceRoot, 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)
+    };
+    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'
+        });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            diagnostics.push({ severity: 'error', message: error.message });
+        }
+        else {
+            diagnostics.push({ severity: 'error', message: String(error) });
+        }
+        throw error;
+    }
+}
+async function runEsbuild(options) {
+    const { sourceRoot, buildRoot, tsconfigPath, mode, env, diagnostics, entryPoints } = options;
+    const isProduction = mode === 'publish';
+    const useIncremental = !isProduction && options.incremental === true;
+    const incrementalKey = useIncremental ? createIncrementalKey(mode, buildRoot) : undefined;
+    if (!entryPoints || entryPoints.length === 0) {
+        if (incrementalKey) {
+            await disposeIncrementalBuild(incrementalKey);
+        }
+        return undefined;
+    }
+    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 define = {
+        'process.env.NODE_ENV': JSON.stringify(nodeEnv)
+    };
+    const emitPublishSourcemaps = isProduction && shouldEmitPublishSourcemaps(env);
+    const start = performance.now();
+    try {
+        let reusedIncremental = false;
+        let result;
+        if (isProduction) {
+            if (incrementalKey) {
+                await disposeIncrementalBuild(incrementalKey);
+            }
+            result = await esbuild({
+                entryPoints: entryPoints,
+                bundle: true,
+                packages: 'external',
+                platform: 'node',
+                target: 'node20',
+                format: 'esm',
+                minify: true,
+                sourcemap: emitPublishSourcemaps,
+                legalComments: 'none',
+                outdir: buildRoot,
+                outbase: sourceRoot,
+                entryNames: '[dir]/[name]',
+                tsconfig: existsSync(tsconfigPath) ? tsconfigPath : undefined,
+                define,
+                logLevel: 'silent',
+                metafile: true
+            });
+        }
+        else if (useIncremental && incrementalKey && entrySignature) {
+            const cached = incrementalBuildCache.get(incrementalKey);
+            if (cached && cached.entrySignature === entrySignature) {
+                reusedIncremental = true;
+                result = await cached.context.rebuild();
+            }
+            else {
+                if (cached) {
+                    await disposeIncrementalBuild(incrementalKey);
+                }
+                const ctx = await esbuildContext({
+                    entryPoints: entryPoints,
+                    bundle: false,
+                    platform: 'node',
+                    target: 'node20',
+                    format: 'esm',
+                    sourcemap: true,
+                    outdir: buildRoot,
+                    outbase: sourceRoot,
+                    tsconfig: existsSync(tsconfigPath) ? tsconfigPath : undefined,
+                    define,
+                    logLevel: 'silent',
+                    metafile: true
+                });
+                incrementalBuildCache.set(incrementalKey, {
+                    entrySignature,
+                    context: ctx
+                });
+                result = await ctx.rebuild();
+            }
+        }
+        else {
+            if (incrementalKey) {
+                await disposeIncrementalBuild(incrementalKey);
+            }
+            result = await esbuild({
+                entryPoints: entryPoints,
+                bundle: false,
+                platform: 'node',
+                target: 'node20',
+                format: 'esm',
+                sourcemap: true,
+                outdir: buildRoot,
+                outbase: sourceRoot,
+                tsconfig: existsSync(tsconfigPath) ? tsconfigPath : undefined,
+                define,
+                logLevel: 'silent',
+                metafile: true
+            });
+        }
+        const warnCount = result.warnings?.length ?? 0;
+        for (const w of (result.warnings ?? []).slice(0, diagMax)) {
+            diagnostics.push({ severity: 'warn', message: formatEsbuildMessage(w) });
+        }
+        if (warnCount > diagMax) {
+            diagnostics.push({
+                severity: 'info',
+                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}`
+        });
+        return collectOutputSizes(result.metafile, buildRoot);
+    }
+    catch (error) {
+        const end = performance.now();
+        if (incrementalKey) {
+            await disposeIncrementalBuild(incrementalKey);
+        }
+        if (isEsbuildFailure(error)) {
+            const errs = error.errors ?? [];
+            const warns = error.warnings ?? [];
+            for (const e of errs.slice(0, diagMax)) {
+                diagnostics.push({ severity: 'error', message: formatEsbuildMessage(e) });
+            }
+            for (const w of warns.slice(0, diagMax)) {
+                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` });
+            }
+            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 ${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 });
+        }
+        else {
+            diagnostics.push({ severity: 'error', message: String(error) });
+        }
+        throw new Error('esbuild failed.');
+    }
+}
+function createIncrementalKey(mode, buildRoot) {
+    return `${mode}:${path.resolve(buildRoot)}`;
+}
+async function disposeIncrementalBuild(key) {
+    const cached = incrementalBuildCache.get(key);
+    if (cached) {
+        try {
+            await cached.context.dispose();
+        }
+        catch {
+            // ignore
+        }
+        incrementalBuildCache.delete(key);
+    }
+}
+function clearIncrementalCache() {
+    for (const [key, entry] of incrementalBuildCache.entries()) {
+        try {
+            entry.context.dispose();
+        }
+        catch {
+            // ignore
+        }
+        incrementalBuildCache.delete(key);
+    }
+}
+function createEntrySignature(entryPoints) {
+    return Array.from(entryPoints).sort().join('|');
+}
+export function collectOutputSizes(metafile, buildRoot) {
+    const outputs = {};
+    if (!metafile || typeof metafile !== 'object') {
+        return outputs;
+    }
+    const mf = metafile;
+    for (const [outPath, info] of Object.entries(mf.outputs ?? {})) {
+        const rel = path.relative(buildRoot, outPath);
+        outputs[rel] = typeof info.bytes === 'number' ? info.bytes : 0;
+    }
+    return outputs;
+}
+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;
+    if (loc && typeof loc.file === 'string') {
+        const position = typeof loc.line === 'number' ? `${loc.line}:${loc.column ?? 1}` : '1:1';
+        return `${loc.file}:${position} ${text}`;
+    }
+    return text;
+}

package/dist/cache/diff.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleManifest, ModuleDiagnostic } from '@webstir-io/module-contract';
+import type { BackendBuildMode } from '../workspace.js';
+export declare function persistAndDiffOutputs(workspaceRoot: string, _buildRoot: string, outputs: Record<string, number> | undefined, env: Record<string, string | undefined>, diagnostics: ModuleDiagnostic[], mode: BackendBuildMode): Promise<void>;
+export declare function persistAndDiffManifest(workspaceRoot: string, manifest: ModuleManifest, env: Record<string, string | undefined>, diagnostics: ModuleDiagnostic[]): Promise<void>;

package/dist/cache/diff.js

@@ -0,0 +1,114 @@
+import path from 'node:path';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+export async function persistAndDiffOutputs(workspaceRoot, _buildRoot, outputs, env, diagnostics, mode) {
+    if (!outputs)
+        return;
+    try {
+        const diagMax = resolveDiagMax(env);
+        const webstirDir = path.join(workspaceRoot, '.webstir');
+        const cachePath = path.join(webstirDir, 'backend-outputs.json');
+        await mkdir(webstirDir, { recursive: true });
+        let previous = {};
+        try {
+            const raw = await readFile(cachePath, 'utf8');
+            previous = JSON.parse(raw);
+        }
+        catch {
+            // first run or unreadable cache
+        }
+        const changed = [];
+        for (const [rel, bytes] of Object.entries(outputs)) {
+            if (previous[rel] !== bytes) {
+                changed.push(rel);
+            }
+        }
+        const removed = Object.keys(previous).filter((rel) => outputs[rel] === undefined);
+        if (changed.length + removed.length > 0) {
+            const list = changed.slice(0, diagMax).join(', ');
+            const omitted = changed.length > diagMax ? ` (+${changed.length - diagMax} more)` : '';
+            const removedInfo = removed.length > 0 ? `, removed=${removed.length}` : '';
+            diagnostics.push({
+                severity: 'info',
+                message: `[webstir-backend] ${mode}:changed ${changed.length} file(s): ${list}${omitted}${removedInfo}`
+            });
+        }
+        await writeFile(cachePath, JSON.stringify(outputs, null, 2), 'utf8');
+    }
+    catch {
+        // ignore cache errors
+    }
+}
+export async function persistAndDiffManifest(workspaceRoot, manifest, env, diagnostics) {
+    try {
+        const diagMax = resolveDiagMax(env);
+        const webstirDir = path.join(workspaceRoot, '.webstir');
+        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 ?? ''}`)
+            : [];
+        const viewPaths = Array.isArray(manifest.views)
+            ? manifest.views.map((v) => `${v.path ?? ''}`)
+            : [];
+        const caps = Array.isArray(manifest.capabilities) ? manifest.capabilities : [];
+        let previous;
+        try {
+            const raw = await readFile(cachePath, 'utf8');
+            previous = JSON.parse(raw);
+        }
+        catch {
+            // first run; no diff
+        }
+        if (previous) {
+            const prevRoutes = new Set(previous.routes);
+            const prevViews = new Set(previous.views);
+            const nextRoutes = new Set(routeKeys);
+            const nextViews = new Set(viewPaths);
+            const addedRoutes = [];
+            const removedRoutes = [];
+            const addedViews = [];
+            const removedViews = [];
+            for (const r of nextRoutes)
+                if (!prevRoutes.has(r))
+                    addedRoutes.push(r);
+            for (const r of prevRoutes)
+                if (!nextRoutes.has(r))
+                    removedRoutes.push(r);
+            for (const v of nextViews)
+                if (!prevViews.has(v))
+                    addedViews.push(v);
+            for (const v of prevViews)
+                if (!nextViews.has(v))
+                    removedViews.push(v);
+            if (addedRoutes.length + removedRoutes.length + addedViews.length + removedViews.length > 0) {
+                const list = (items) => items.slice(0, diagMax).join(', ');
+                const routeDelta = `routes +${addedRoutes.length}/-${removedRoutes.length}`;
+                const viewDelta = `views +${addedViews.length}/-${removedViews.length}`;
+                let msg = `[webstir-backend] manifest changed: ${routeDelta}; ${viewDelta}`;
+                const details = [];
+                if (addedRoutes.length > 0)
+                    details.push(`added routes: ${list(addedRoutes)}`);
+                if (removedRoutes.length > 0)
+                    details.push(`removed routes: ${list(removedRoutes)}`);
+                if (addedViews.length > 0)
+                    details.push(`added views: ${list(addedViews)}`);
+                if (removedViews.length > 0)
+                    details.push(`removed views: ${list(removedViews)}`);
+                if (details.length > 0) {
+                    msg += ` — ${details.join(' | ')}`;
+                }
+                diagnostics.push({ severity: 'info', message: msg });
+            }
+        }
+        const digest = { routes: routeKeys, views: viewPaths, capabilities: caps };
+        await writeFile(cachePath, JSON.stringify(digest, null, 2), 'utf8');
+    }
+    catch {
+        // ignore cache errors
+    }
+}
+function resolveDiagMax(env, fallback = 50) {
+    const raw = env?.WEBSTIR_BACKEND_DIAG_MAX;
+    const n = typeof raw === 'string' ? parseInt(raw, 10) : NaN;
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}

package/dist/cache/reporters.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleDiagnostic, ModuleManifest } from '@webstir-io/module-contract';
+import type { BackendBuildMode } from '../workspace.js';
+export interface CacheReporter {
+    readonly diffOutputs: (outputs: Record<string, number> | undefined, mode: BackendBuildMode) => Promise<void>;
+    readonly diffManifest: (manifest: ModuleManifest) => Promise<void>;
+}
+export declare function createCacheReporter(options: {
+    readonly workspaceRoot: string;
+    readonly buildRoot: string;
+    readonly env: Record<string, string | undefined>;
+    readonly diagnostics: ModuleDiagnostic[];
+}): CacheReporter;

package/dist/cache/reporters.js

@@ -0,0 +1,23 @@
+import { persistAndDiffManifest, persistAndDiffOutputs } from './diff.js';
+export function createCacheReporter(options) {
+    const { workspaceRoot, buildRoot, env, diagnostics } = options;
+    const diagnosticsTarget = shouldLogCacheDiffs(env) ? diagnostics : [];
+    return {
+        async diffOutputs(outputs, mode) {
+            await persistAndDiffOutputs(workspaceRoot, buildRoot, outputs, env, diagnosticsTarget, mode);
+        },
+        async diffManifest(manifest) {
+            await persistAndDiffManifest(workspaceRoot, manifest, env, diagnosticsTarget);
+        }
+    };
+}
+function shouldLogCacheDiffs(env) {
+    const raw = env?.WEBSTIR_BACKEND_CACHE_LOG;
+    if (!raw)
+        return true;
+    const normalized = raw.trim().toLowerCase();
+    if (['off', '0', 'false', 'quiet', 'silent', 'skip'].includes(normalized)) {
+        return false;
+    }
+    return true;
+}

package/dist/diagnostics/summary.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleDiagnostic } from '@webstir-io/module-contract';
+export declare function pushEntryBucketSummary(diagnostics: ModuleDiagnostic[], entryPoints: readonly string[]): void;
+type Severity = 'info' | 'warn' | 'error';
+export declare function normalizeLogLevel(value: unknown): Severity;
+export declare function filterDiagnostics(list: readonly ModuleDiagnostic[], min: Severity): readonly ModuleDiagnostic[];
+export {};

package/dist/diagnostics/summary.js

@@ -0,0 +1,27 @@
+export function pushEntryBucketSummary(diagnostics, entryPoints) {
+    try {
+        const server = entryPoints.filter((p) => p === 'index.js' || /(^|\/)index\.js$/.test(p) && !/^(functions|jobs)\//.test(p)).length;
+        const functionsCount = entryPoints.filter((p) => p.startsWith('functions/')).length;
+        const jobsCount = entryPoints.filter((p) => p.startsWith('jobs/')).length;
+        diagnostics.push({
+            severity: 'info',
+            message: `[webstir-backend] entries by bucket: server=${server} functions=${functionsCount} jobs=${jobsCount}`
+        });
+    }
+    catch {
+        // best-effort only
+    }
+}
+export function normalizeLogLevel(value) {
+    if (typeof value !== 'string')
+        return 'info';
+    const v = value.toLowerCase();
+    if (v === 'error' || v === 'warn' || v === 'info')
+        return v;
+    return 'info';
+}
+export function filterDiagnostics(list, min) {
+    const rank = (s) => (s === 'error' ? 3 : s === 'warn' ? 2 : 1);
+    const threshold = rank(min);
+    return list.filter((d) => rank(d.severity) >= threshold);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { backendProvider } from './provider.js';
+export { startBackendWatch } from './watch.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { backendProvider } from './provider.js';
+export { startBackendWatch } from './watch.js';

package/dist/manifest/pipeline.d.ts

@@ -0,0 +1,13 @@
+import type { ModuleDiagnostic, ModuleManifest } from '@webstir-io/module-contract';
+export interface LoadManifestOptions {
+    readonly workspaceRoot: string;
+    readonly buildRoot: string;
+    readonly entryPoints: readonly string[];
+    readonly diagnostics: ModuleDiagnostic[];
+}
+export declare function loadBackendModuleManifest(options: LoadManifestOptions): Promise<ModuleManifest>;
+export declare function summarizeBuiltManifest(buildRoot: string): Promise<{
+    routes: number;
+    views: number;
+    capabilities?: readonly string[];
+} | undefined>;