@wabot-dev/framework 0.9.27 → 2.0.0-beta.0

package/dist/build/build.js

@@ -1,7 +1,16 @@
 import { realpathSync, existsSync } from 'node:fs';
 import { readdir, mkdir, writeFile, rm, readFile } from 'node:fs/promises';
-import { resolve, join, relative, sep, isAbsolute } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import path, { resolve, join, relative, sep, isAbsolute } from 'node:path';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { __decorate, __metadata } from 'tslib';
+import { createHash } from 'node:crypto';
+import debug from 'debug';
+import * as esbuild from 'esbuild';
+import { createContext, options, h } from 'preact';
+import { renderToString } from 'preact-render-to-string';
+import { Server } from 'node:http';
+import express from 'express';
+import 'preact/hooks';
 
 const TEST_FILE_PATTERNS = /\.(test|spec|unit|integration|e2e|multiprocess)\.(ts|js)$/;
 const DEFAULT_DIRECTORIES = ['src'];
@@ -57,7 +66,7 @@ async function scanDir(dir, excludedNames, excludedPaths) {
         }
         if (!entry.isFile())
             return [];
-        if (!(name.endsWith('.ts') || name.endsWith('.js')))
+        if (!/\.(ts|tsx|js|jsx)$/.test(name))
             return [];
         if (name.endsWith('.d.ts'))
             return [];
@@ -68,6 +77,983 @@ async function scanDir(dir, excludedNames, excludedPaths) {
     return subResults.flat();
 }
 
+await import('reflect-metadata');
+const { injectable, container, singleton, inject, scoped, Lifecycle } = await import('tsyringe');
+
+function errorToPlainObject(error) {
+    const { name, message, stack } = error;
+    const extra = {};
+    for (const key of Object.keys(error)) {
+        if (key === 'message' || key === 'stack')
+            continue;
+        extra[key] = error[key];
+    }
+    return { name, message, stack, ...extra };
+}
+
+const levelColors = {
+    trace: 0,
+    debug: 0,
+    info: 0,
+    warn: 5,
+    error: 1,
+    fatal: 1,
+};
+const levelToSeverity = {
+    warn: 'warning',
+    error: 'error',
+    fatal: 'fatal',
+};
+/**
+ * Logger with 6 severity levels. Uses the `debug` library for output.
+ *
+ * ## Level verbosity contract
+ *
+ * - **fatal** — The process cannot continue. Something is critically broken
+ *   (uncaught exceptions, unhandled rejections). Investigate immediately.
+ *
+ * - **error** — An operation failed unexpectedly. Always include: what failed,
+ *   why (the Error), and enough context to locate the problem (IDs, names).
+ *
+ * - **warn** — Something unusual happened but the system handled it gracefully.
+ *   Known limitations, safety guards triggered, recoverable issues.
+ *
+ * - **info** — Key lifecycle events the user cares about: systems starting or
+ *   stopping, configuration applied, significant state changes. Should read
+ *   like a high-level audit log.
+ *
+ * - **debug** — Internal operational details for developers troubleshooting.
+ *   Step-by-step flow, lock acquisition, query execution, reconciliation steps.
+ *
+ * - **trace** — Very fine-grained: every HTTP request, every socket event,
+ *   every message sent or received.
+ */
+class Logger {
+    static monitor = null;
+    debuggers;
+    name;
+    constructor(name) {
+        this.name = name;
+        this.debuggers = {};
+        for (const level of Object.keys(levelColors)) {
+            const dbg = debug(`${name}:${level}`);
+            dbg.color = '' + levelColors[level];
+            this.debuggers[level] = dbg;
+        }
+    }
+    static setMonitor(monitor) {
+        Logger.monitor = monitor;
+    }
+    static getMonitor() {
+        return Logger.monitor;
+    }
+    /** Very fine-grained: every HTTP request, socket event, message sent/received. */
+    trace(...args) {
+        this.log('trace', args);
+    }
+    /** Internal operational details for developers: step-by-step flow, lock acquisition, queries. */
+    debug(...args) {
+        this.log('debug', args);
+    }
+    /** Key lifecycle events: systems start/stop, configuration applied, significant state changes. */
+    info(...args) {
+        this.log('info', args);
+    }
+    /** Something unusual happened but the system recovered. Known limitations, safety guards. */
+    warn(...args) {
+        this.log('warn', args);
+    }
+    /** Operation failed unexpectedly. Always include: what failed + why (Error) + identifiers. */
+    error(...args) {
+        this.log('error', args);
+    }
+    /** Process cannot continue. Uncaught exceptions, unhandled rejections. Investigate immediately. */
+    fatal(...args) {
+        this.log('fatal', args);
+    }
+    log(level, args) {
+        const debugg = this.debuggers[level];
+        const formattedArgs = this.formatArgs(args);
+        debugg(...formattedArgs);
+        this.sendToMonitor(level, args);
+    }
+    sendToMonitor(level, args) {
+        const severity = levelToSeverity[level];
+        if (!severity || !Logger.monitor)
+            return;
+        const context = {
+            logger: this.name,
+            level: severity,
+            timestamp: new Date(),
+            extra: this.extractExtra(args),
+        };
+        const error = args.find((arg) => arg instanceof Error);
+        if (error) {
+            Logger.monitor.captureError(error, context);
+        }
+        else {
+            const message = args
+                .filter((arg) => !(arg instanceof Error))
+                .map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg)))
+                .join(' ');
+            Logger.monitor.captureMessage(message, context);
+        }
+    }
+    extractExtra(args) {
+        const extra = {};
+        let index = 0;
+        for (const arg of args) {
+            if (arg instanceof Error)
+                continue;
+            if (typeof arg === 'object' && arg !== null) {
+                Object.assign(extra, arg);
+            }
+            else if (typeof arg !== 'string') {
+                extra[`arg${index}`] = arg;
+            }
+            index++;
+        }
+        return Object.keys(extra).length > 0 ? extra : {};
+    }
+    formatArgs(args) {
+        return args.map((arg) => {
+            if (arg instanceof Error) {
+                return JSON.stringify(errorToPlainObject(arg));
+            }
+            if (arg === null) {
+                return 'null';
+            }
+            if (typeof arg === 'object') {
+                try {
+                    return JSON.stringify(arg);
+                }
+                catch (e) {
+                    return '[Circular]';
+                }
+            }
+            return arg;
+        });
+    }
+}
+
+/**
+ * Marker attached to components wrapped with {@link island}. The UI renderer
+ * uses it to decide which components must hydrate on the client; the bundler
+ * uses {@link IslandMeta.id} (assigned from the `*.island.tsx` file location) to
+ * emit a per-island client bundle.
+ */
+const ISLAND_MARKER = Symbol.for('wabot.ui.island');
+function getIslandMeta(component) {
+    return typeof component === 'function'
+        ? component[ISLAND_MARKER]
+        : undefined;
+}
+function isIsland(component) {
+    return getIslandMeta(component) != null;
+}
+/** Assign the stable bundle id to an island, done during island discovery. */
+function setIslandId(component, id) {
+    const meta = getIslandMeta(component);
+    if (meta)
+        meta.id = id;
+}
+
+/** Files matching this are treated as islands (default export wrapped with island()). */
+const ISLAND_FILE_PATTERN = /\.island\.(tsx|jsx)$/;
+/** Deterministic, readable, collision-resistant id from a project-relative path. */
+function toIslandId(relPath) {
+    const base = path
+        .basename(relPath)
+        .replace(ISLAND_FILE_PATTERN, '')
+        .replace(/[^a-zA-Z0-9_-]/g, '_') || 'island';
+    const hash = createHash('sha1').update(relPath).digest('hex').slice(0, 8);
+    return `${base}-${hash}`;
+}
+function isIslandFile(file) {
+    return ISLAND_FILE_PATTERN.test(file);
+}
+/**
+ * Discovers `*.island.tsx` modules, assigns each a stable id, and stamps that
+ * id onto the imported island component (ESM module singletons mean the view
+ * renders the same instance, so the renderer can read the id during SSR).
+ */
+let IslandRegistry = class IslandRegistry {
+    islands = new Map();
+    logger = new Logger('wabot:ui:islands');
+    async discover(files, cwd = process.cwd()) {
+        for (const absPath of files.filter(isIslandFile)) {
+            const relPath = path.relative(cwd, absPath).split(path.sep).join('/');
+            const id = toIslandId(relPath);
+            try {
+                const mod = await import(pathToFileURL(absPath).href);
+                const component = mod.default;
+                if (!isIsland(component)) {
+                    this.logger.warn(`${relPath}: default export is not an island(); skipping`);
+                    continue;
+                }
+                setIslandId(component, id);
+                this.islands.set(id, { id, importPath: absPath, relPath });
+            }
+            catch (err) {
+                this.logger.error(`Failed to load island ${relPath}`, err);
+            }
+        }
+        return this.list();
+    }
+    register(island) {
+        this.islands.set(island.id, island);
+    }
+    list() {
+        return [...this.islands.values()];
+    }
+    get(id) {
+        return this.islands.get(id);
+    }
+    get size() {
+        return this.islands.size;
+    }
+};
+IslandRegistry = __decorate([
+    singleton()
+], IslandRegistry);
+
+const ISLAND_ENTRY_NAMESPACE = 'wabot-island';
+/** Reserved island-entry id for the boosted-navigation runtime bundle. */
+const NAV_ENTRY_ID = '__wabot_nav';
+function toUrl(base, outdir, cwd, outPath) {
+    const abs = path.resolve(cwd, outPath);
+    const rel = path.relative(outdir, abs).split(path.sep).join('/');
+    return base + rel;
+}
+/** Build the island asset manifest from an esbuild metafile. */
+function manifestFromMetafile(metafile, opts) {
+    const { base, outdir, cwd } = opts;
+    const islands = {};
+    let nav;
+    for (const [outPath, output] of Object.entries(metafile.outputs)) {
+        const entryPoint = output.entryPoint;
+        if (!entryPoint || !entryPoint.startsWith(`${ISLAND_ENTRY_NAMESPACE}:`))
+            continue;
+        const id = entryPoint.slice(ISLAND_ENTRY_NAMESPACE.length + 1);
+        if (id === NAV_ENTRY_ID) {
+            nav = toUrl(base, outdir, cwd, outPath);
+            continue;
+        }
+        const css = output.cssBundle ? [toUrl(base, outdir, cwd, output.cssBundle)] : [];
+        islands[id] = { js: toUrl(base, outdir, cwd, outPath), css };
+    }
+    return { base, islands, nav };
+}
+function emptyManifest(base = '/_wabot/') {
+    return { base, islands: {} };
+}
+
+/** Absolute path to the generic boosted-navigation client core, bundled as an
+ * extra entry so it shares the island runtime chunk. */
+const NAV_RUNTIME_MODULE = fileURLToPath(new URL('./navRuntime', import.meta.url));
+/**
+ * Source of the nav entry. Imports the island hydrate/unmount hooks from the
+ * renderer's runtime module (the same module island entries import, so they
+ * share one registry instance) and wires them into the generic nav core.
+ */
+function navEntrySource(runtimeModule) {
+    return (`import { hydrateAll, unmountRemoved } from ${JSON.stringify(runtimeModule)}\n` +
+        `import { startNavigation } from ${JSON.stringify(NAV_RUNTIME_MODULE)}\n` +
+        `startNavigation({ hydrateAll, unmountRemoved })\n`);
+}
+function mimeFor(servePath) {
+    if (servePath.endsWith('.js'))
+        return 'text/javascript; charset=utf-8';
+    if (servePath.endsWith('.css'))
+        return 'text/css; charset=utf-8';
+    if (servePath.endsWith('.map'))
+        return 'application/json; charset=utf-8';
+    return 'application/octet-stream';
+}
+function entrySources(islands, client) {
+    const sources = new Map();
+    for (const island of islands) {
+        // keyed by bare id; esbuild records the entry as `${namespace}:${path}`.
+        sources.set(island.id, client.islandEntrySource({ id: island.id, importPath: island.importPath }));
+    }
+    sources.set(NAV_ENTRY_ID, navEntrySource(client.runtimeModule));
+    return sources;
+}
+function islandEntryPlugin(sources, cwd) {
+    const prefix = `${ISLAND_ENTRY_NAMESPACE}:`;
+    const filter = new RegExp(`^${ISLAND_ENTRY_NAMESPACE}:`);
+    return {
+        name: 'wabot-island-entries',
+        setup(build) {
+            build.onResolve({ filter }, (args) => ({
+                path: args.path.slice(prefix.length),
+                namespace: ISLAND_ENTRY_NAMESPACE,
+            }));
+            build.onLoad({ filter: /.*/, namespace: ISLAND_ENTRY_NAMESPACE }, (args) => ({
+                contents: sources.get(args.path) ?? '',
+                loader: 'js',
+                resolveDir: cwd,
+            }));
+        },
+    };
+}
+function baseBuildOptions(islands, client, opts) {
+    const jsxMode = client.esbuildJsx?.jsx ?? 'automatic';
+    return {
+        entryPoints: [
+            ...islands.map((i) => ({ in: `${ISLAND_ENTRY_NAMESPACE}:${i.id}`, out: i.id })),
+            // Boosted-navigation runtime, shared across the app's views.
+            { in: `${ISLAND_ENTRY_NAMESPACE}:${NAV_ENTRY_ID}`, out: '_nav' },
+        ],
+        bundle: true,
+        splitting: true,
+        format: 'esm',
+        platform: 'browser',
+        outdir: opts.outdir,
+        absWorkingDir: opts.cwd,
+        metafile: true,
+        alias: opts.alias,
+        sourcemap: opts.dev ? 'linked' : false,
+        minify: !opts.dev,
+        entryNames: '[name]',
+        chunkNames: 'chunks/[name]-[hash]',
+        assetNames: 'assets/[name]-[hash]',
+        jsx: jsxMode,
+        ...(jsxMode === 'automatic'
+            ? { jsxImportSource: client.esbuildJsx?.jsxImportSource }
+            : {
+                jsxFactory: client.esbuildJsx?.jsxFactory,
+                jsxFragment: client.esbuildJsx?.jsxFragmentFactory,
+            }),
+        loader: { '.module.css': 'local-css' },
+        logLevel: 'silent',
+    };
+}
+/**
+ * Bundles island client code with esbuild. In dev it watches and serves from
+ * memory; in prod it writes hashed assets to disk and returns a manifest.
+ */
+class UiBundler {
+    islands;
+    client;
+    base;
+    cwd;
+    alias;
+    logger = new Logger('wabot:ui:bundler');
+    ctx = null;
+    served = new Map();
+    manifest;
+    rebuildListeners = new Set();
+    constructor(options) {
+        this.islands = options.islands;
+        this.client = options.client;
+        this.base = options.base ?? '/_wabot/';
+        this.cwd = options.cwd ?? process.cwd();
+        this.alias = options.alias;
+        this.manifest = emptyManifest(this.base);
+    }
+    /** Start a watching dev build; assets are kept in memory and served via getFile(). */
+    async startDev() {
+        const outdir = path.resolve(this.cwd, '.wabot-ui-dev');
+        const sources = entrySources(this.islands, this.client);
+        const onEnd = {
+            name: 'wabot-dev-refresh',
+            setup: (build) => {
+                build.onEnd((result) => {
+                    this.ingest(result, outdir);
+                    for (const listener of this.rebuildListeners)
+                        listener();
+                });
+            },
+        };
+        this.ctx = await esbuild.context({
+            ...baseBuildOptions(this.islands, this.client, {
+                outdir,
+                dev: true,
+                cwd: this.cwd,
+                alias: this.alias,
+            }),
+            write: false,
+            plugins: [islandEntryPlugin(sources, this.cwd), onEnd],
+        });
+        await this.ctx.rebuild();
+        await this.ctx.watch();
+        this.logger.info(`watching ${this.islands.length} island(s)`);
+    }
+    /** Build once and write hashed assets to outDir; returns the manifest. */
+    async buildProd(outDir) {
+        const outdir = path.resolve(this.cwd, outDir);
+        const sources = entrySources(this.islands, this.client);
+        const result = await esbuild.build({
+            ...baseBuildOptions(this.islands, this.client, {
+                outdir,
+                dev: false,
+                cwd: this.cwd,
+                alias: this.alias,
+            }),
+            write: true,
+            plugins: [islandEntryPlugin(sources, this.cwd)],
+        });
+        this.manifest = manifestFromMetafile(result.metafile, {
+            base: this.base,
+            outdir,
+            cwd: this.cwd,
+        });
+        this.logger.info(`built ${this.islands.length} island(s) -> ${outDir}`);
+        return this.manifest;
+    }
+    ingest(result, outdir) {
+        this.served.clear();
+        for (const file of result.outputFiles ?? []) {
+            const rel = path.relative(outdir, file.path).split(path.sep).join('/');
+            const servePath = this.base + rel;
+            this.served.set(servePath, { contents: file.contents, type: mimeFor(servePath) });
+        }
+        if (result.metafile) {
+            this.manifest = manifestFromMetafile(result.metafile, {
+                base: this.base,
+                outdir,
+                cwd: this.cwd,
+            });
+        }
+    }
+    getFile(servePath) {
+        return this.served.get(servePath);
+    }
+    getManifest() {
+        return this.manifest;
+    }
+    onRebuild(listener) {
+        this.rebuildListeners.add(listener);
+    }
+    async dispose() {
+        await this.ctx?.dispose();
+        this.ctx = null;
+    }
+}
+
+function getClassHierarchy$2(cls) {
+    const classes = [];
+    let proto = Object.getPrototypeOf(cls.prototype);
+    while (proto && proto.constructor !== Object) {
+        classes.push(proto.constructor);
+        proto = Object.getPrototypeOf(proto);
+    }
+    return classes;
+}
+let UiControllerMetadataStore = class UiControllerMetadataStore {
+    controllers = new Map();
+    views = new Map();
+    actions = new Map();
+    middlewares = new Map();
+    saveControllerMetadata(metadata) {
+        this.controllers.set(metadata.controllerConstructor, metadata);
+    }
+    saveViewMetadata(metadata) {
+        let controllerViews = this.views.get(metadata.controllerConstructor);
+        if (!controllerViews) {
+            this.views.set(metadata.controllerConstructor, (controllerViews = new Map()));
+        }
+        controllerViews.set(metadata.functionName, metadata);
+    }
+    saveActionMetadata(metadata) {
+        let controllerActions = this.actions.get(metadata.controllerConstructor);
+        if (!controllerActions) {
+            this.actions.set(metadata.controllerConstructor, (controllerActions = new Map()));
+        }
+        controllerActions.set(metadata.functionName, metadata);
+    }
+    saveMiddlewareMetadata(metadata) {
+        let controllerMiddlewares = this.middlewares.get(metadata.controllerConstructor);
+        if (!controllerMiddlewares) {
+            this.middlewares.set(metadata.controllerConstructor, (controllerMiddlewares = new Map()));
+        }
+        let methodMiddlewares = controllerMiddlewares.get(metadata.functionName);
+        if (!methodMiddlewares) {
+            controllerMiddlewares.set(metadata.functionName, (methodMiddlewares = []));
+        }
+        methodMiddlewares.unshift(metadata);
+    }
+    getAllUiControllerConstructors() {
+        return Array.from(this.controllers.keys());
+    }
+    getController(controllerConstructor) {
+        const controller = this.controllers.get(controllerConstructor);
+        if (!controller) {
+            throw new Error(`${controllerConstructor.name} should be decorated with @uiController`);
+        }
+        return controller;
+    }
+    collectMethodMiddlewares(hierarchy, functionName) {
+        const middlewares = [];
+        for (const cls of [...hierarchy].reverse()) {
+            const classMiddlewares = this.middlewares.get(cls)?.get(functionName);
+            if (classMiddlewares) {
+                middlewares.push(...classMiddlewares);
+            }
+        }
+        return middlewares;
+    }
+    getControllerViewsInfo(controllerConstructor) {
+        const controller = this.getController(controllerConstructor);
+        const hierarchy = [controllerConstructor, ...getClassHierarchy$2(controllerConstructor)];
+        const viewsMap = new Map();
+        for (const cls of [...hierarchy].reverse()) {
+            const classViews = this.views.get(cls);
+            if (classViews) {
+                for (const [name, view] of classViews)
+                    viewsMap.set(name, view);
+            }
+        }
+        return [...viewsMap.values()].map((view) => ({
+            ...view,
+            controllerConstructor,
+            controller,
+            middlewares: this.collectMethodMiddlewares(hierarchy, view.functionName),
+        }));
+    }
+    getControllerActionsInfo(controllerConstructor) {
+        const controller = this.getController(controllerConstructor);
+        const hierarchy = [controllerConstructor, ...getClassHierarchy$2(controllerConstructor)];
+        const actionsMap = new Map();
+        for (const cls of [...hierarchy].reverse()) {
+            const classActions = this.actions.get(cls);
+            if (classActions) {
+                for (const [name, action] of classActions)
+                    actionsMap.set(name, action);
+            }
+        }
+        return [...actionsMap.values()].map((action) => ({
+            ...action,
+            controllerConstructor,
+            controller,
+            middlewares: this.collectMethodMiddlewares(hierarchy, action.functionName),
+        }));
+    }
+};
+UiControllerMetadataStore = __decorate([
+    singleton()
+], UiControllerMetadataStore);
+
+let UiRendererRegistry = class UiRendererRegistry {
+    renderers = new Map();
+    defaultRenderer = null;
+    /** Register a renderer. The first one registered becomes the default. */
+    register(renderer) {
+        this.renderers.set(renderer.id, renderer);
+        if (!this.defaultRenderer)
+            this.defaultRenderer = renderer;
+    }
+    /** Register a renderer and make it the default. */
+    setDefault(renderer) {
+        this.renderers.set(renderer.id, renderer);
+        this.defaultRenderer = renderer;
+    }
+    has(id) {
+        return this.renderers.has(id);
+    }
+    hasDefault() {
+        return this.defaultRenderer != null;
+    }
+    get(id) {
+        if (id) {
+            const renderer = this.renderers.get(id);
+            if (!renderer) {
+                throw new Error(`UI renderer "${id}" is not registered`);
+            }
+            return renderer;
+        }
+        if (!this.defaultRenderer) {
+            throw new Error('No default UI renderer registered. Import "@wabot-dev/framework/ui" to register the Preact renderer, or register your own with UiRendererRegistry.setDefault().');
+        }
+        return this.defaultRenderer;
+    }
+};
+UiRendererRegistry = __decorate([
+    singleton()
+], UiRendererRegistry);
+
+const SKIP_PROPS = new Set(['children', 'ref', 'key']);
+/**
+ * Serialize the props an island was rendered with so the client can hydrate it
+ * with the same data. Drops `children`/`ref`/`key` and any function-valued
+ * props (event handlers belong inside the island, not in its serialized props).
+ */
+function serializeProps(props) {
+    const out = {};
+    for (const key in props) {
+        if (SKIP_PROPS.has(key))
+            continue;
+        const value = props[key];
+        if (typeof value === 'function')
+            continue;
+        out[key] = value;
+    }
+    try {
+        return JSON.stringify(out);
+    }
+    catch {
+        return '{}';
+    }
+}
+
+({
+    logger: new Logger('wabot:error'),
+});
+
+const _IS_OPTIONAL_DUMMY_VALIDATOR_ = (value) => {
+    return { value, errors: [] };
+};
+
+function validateArray(value, options) {
+    if (!Array.isArray(value)) {
+        return {
+            error: { description: 'Should be an array', items: [] },
+        };
+    }
+    if (options?.minLength != null && value.length < options.minLength) {
+        return {
+            error: { description: 'exceeds the established min length limit', items: [] },
+        };
+    }
+    if (options?.maxLength != null && value.length > options.maxLength) {
+        return {
+            error: { description: 'exceeds the established max length limit', items: [] },
+        };
+    }
+    const { itemsValidator } = options ?? {};
+    const valueOut = [];
+    const errorItems = [];
+    for (const item of value) {
+        let itemOut = item;
+        const itemErrors = [];
+        for (const itemValidator of itemsValidator ?? []) {
+            const { error, value } = itemValidator.validator(itemOut, itemValidator.options);
+            if (error) {
+                itemErrors.push(error);
+            }
+            else {
+                itemOut = value;
+            }
+        }
+        if (itemErrors.length == 0) {
+            valueOut.push(itemOut);
+            errorItems.push(null);
+        }
+        else {
+            valueOut.push(null);
+            errorItems.push(itemErrors);
+        }
+    }
+    if (errorItems.some((x) => x != null)) {
+        return {
+            error: { description: 'Error on some items', items: errorItems },
+        };
+    }
+    return {
+        value: valueOut,
+    };
+}
+
+function getClassHierarchy$1(cls) {
+    const classes = [];
+    let proto = Object.getPrototypeOf(cls.prototype);
+    while (proto && proto.constructor !== Object) {
+        classes.push(proto.constructor);
+        proto = Object.getPrototypeOf(proto);
+    }
+    return classes;
+}
+let ValidationMetadataStore = class ValidationMetadataStore {
+    validators = new Map();
+    saveValidatorMetadata(validatorMetadata) {
+        let modelValidators = this.validators.get(validatorMetadata.modelConstructor);
+        if (!modelValidators) {
+            this.validators.set(validatorMetadata.modelConstructor, (modelValidators = new Map()));
+        }
+        let propertyValidators = modelValidators.get(validatorMetadata.propertyName);
+        if (!propertyValidators) {
+            propertyValidators = [];
+            modelValidators.set(validatorMetadata.propertyName, propertyValidators);
+        }
+        propertyValidators.unshift(validatorMetadata);
+        const arrayValidatorMetadata = propertyValidators.find((x) => x.validator === validateArray);
+        if (!arrayValidatorMetadata) {
+            return;
+        }
+        if (!arrayValidatorMetadata.validatorOptions) {
+            arrayValidatorMetadata.validatorOptions = {};
+        }
+        const arrayValidatorOptions = arrayValidatorMetadata.validatorOptions;
+        if (!arrayValidatorOptions.itemsValidator) {
+            arrayValidatorOptions.itemsValidator = [];
+        }
+        const removeValidatorsMetadata = [];
+        for (const validatorMetadata of propertyValidators) {
+            if (validatorMetadata.validator === validateArray ||
+                validatorMetadata.validator === _IS_OPTIONAL_DUMMY_VALIDATOR_) {
+                continue;
+            }
+            arrayValidatorOptions.itemsValidator.push({
+                options: validatorMetadata.validatorOptions,
+                validator: validatorMetadata.validator,
+            });
+            removeValidatorsMetadata.push(validatorMetadata);
+        }
+        for (const toRemove of removeValidatorsMetadata) {
+            const indexToRemove = propertyValidators.indexOf(toRemove);
+            propertyValidators.splice(indexToRemove, 1);
+        }
+    }
+    getModelValidatorsInfo(modelConstructor) {
+        const constructors = getClassHierarchy$1(modelConstructor);
+        constructors.unshift(modelConstructor);
+        const modelValidators = {
+            modelConstructor: modelConstructor,
+            modelHierarchy: constructors,
+            properties: Object.assign({}, ...constructors.map((x) => this.getConstructorPropertiesValidatorsInfo(x))),
+        };
+        return modelValidators;
+    }
+    getConstructorPropertiesValidatorsInfo(modelConstructor) {
+        const properties = {};
+        [...(this.validators.get(modelConstructor)?.values() ?? [])].forEach((propertyValidatorsMetadata) => {
+            const propertyName = propertyValidatorsMetadata.at(0)?.propertyName;
+            if (!propertyName) {
+                return;
+            }
+            let propertyInfo = properties[propertyName];
+            if (!propertyInfo) {
+                propertyInfo = {};
+                properties[propertyName] = propertyInfo;
+            }
+            let validators = propertyInfo.validators;
+            if (!validators) {
+                validators = [];
+                propertyInfo.validators = validators;
+            }
+            propertyValidatorsMetadata.forEach((propertyValidatorMetadata) => {
+                if (propertyValidatorMetadata.validator === _IS_OPTIONAL_DUMMY_VALIDATOR_) {
+                    propertyInfo.isOptional = true;
+                }
+                else {
+                    validators.push(propertyValidatorMetadata);
+                }
+            });
+        });
+        return properties;
+    }
+};
+ValidationMetadataStore = __decorate([
+    singleton()
+], ValidationMetadataStore);
+
+let HttpServerProvider = class HttpServerProvider {
+    server = null;
+    listening = false;
+    logger = new Logger('wabot:http');
+    getHttpServer() {
+        if (!this.server) {
+            this.server = new Server();
+        }
+        return this.server;
+    }
+    listen() {
+        if (!this.server || this.listening) {
+            return;
+        }
+        this.listening = true;
+        const PORT = process.env.PORT || 3000;
+        this.server.listen(PORT, () => {
+            this.logger.info(`Server listening on port ${PORT}`);
+        });
+    }
+};
+HttpServerProvider = __decorate([
+    singleton()
+], HttpServerProvider);
+
+let ExpressProvider = class ExpressProvider {
+    httpServerProvider;
+    expressApp = null;
+    logger = new Logger('wabot:express');
+    constructor(httpServerProvider) {
+        this.httpServerProvider = httpServerProvider;
+    }
+    getExpress() {
+        if (!this.expressApp) {
+            this.expressApp = this.createExpress();
+        }
+        return this.expressApp;
+    }
+    listen() {
+        this.httpServerProvider.listen();
+    }
+    createExpress() {
+        const expressApp = express();
+        expressApp.use((req, res, next) => {
+            const start = process.hrtime();
+            res.on('finish', () => {
+                const [seconds, nanoseconds] = process.hrtime(start);
+                const ms = (seconds * 1000 + nanoseconds / 1e6).toFixed(2);
+                this.logger.trace(`${req.method} ${req.originalUrl} ${res.statusCode} - ${ms}ms`);
+            });
+            next();
+        });
+        const httpServer = this.httpServerProvider.getHttpServer();
+        httpServer.on('request', expressApp);
+        return expressApp;
+    }
+};
+ExpressProvider = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [HttpServerProvider])
+], ExpressProvider);
+
+function getClassHierarchy(cls) {
+    const classes = [];
+    let proto = Object.getPrototypeOf(cls.prototype);
+    while (proto && proto.constructor !== Object) {
+        classes.push(proto.constructor);
+        proto = Object.getPrototypeOf(proto);
+    }
+    return classes;
+}
+let RestControllerMetadataStore = class RestControllerMetadataStore {
+    endPoints = new Map();
+    middlewares = new Map();
+    restControllers = new Map();
+    saveControllerMetadata(controllerMetadata) {
+        this.restControllers.set(controllerMetadata.controllerConstructor, controllerMetadata);
+    }
+    saveEndPointMetadata(endPointMetadata) {
+        let controllerEndPoints = this.endPoints.get(endPointMetadata.controllerConstructor);
+        if (!controllerEndPoints) {
+            this.endPoints.set(endPointMetadata.controllerConstructor, (controllerEndPoints = new Map()));
+        }
+        controllerEndPoints.set(endPointMetadata.functionName, endPointMetadata);
+    }
+    saveMiddlewareMetadata(middlewareMetadata) {
+        let controllerMiddlewares = this.middlewares.get(middlewareMetadata.controllerConstructor);
+        if (!controllerMiddlewares) {
+            this.middlewares.set(middlewareMetadata.controllerConstructor, (controllerMiddlewares = new Map()));
+        }
+        let methodMiddlewares = controllerMiddlewares.get(middlewareMetadata.functionName);
+        if (!methodMiddlewares) {
+            controllerMiddlewares.set(middlewareMetadata.functionName, (methodMiddlewares = []));
+        }
+        methodMiddlewares.unshift(middlewareMetadata);
+    }
+    getAllRestControllerConstructors() {
+        return Array.from(this.restControllers.keys());
+    }
+    getControllerEndPointsInfo(controllerConstructor) {
+        const controller = this.restControllers.get(controllerConstructor);
+        if (!controller) {
+            throw new Error(`${controllerConstructor.name} should be decorated with @restController`);
+        }
+        const hierarchy = [controllerConstructor, ...getClassHierarchy(controllerConstructor)];
+        const endPointsMap = new Map();
+        for (const cls of [...hierarchy].reverse()) {
+            const classEndPoints = this.endPoints.get(cls);
+            if (classEndPoints) {
+                for (const [name, endPoint] of classEndPoints) {
+                    endPointsMap.set(name, endPoint);
+                }
+            }
+        }
+        if (!endPointsMap.size) {
+            return [];
+        }
+        return [...endPointsMap.values()].map((endPoint) => {
+            const middlewares = [];
+            for (const cls of [...hierarchy].reverse()) {
+                const classMiddlewares = this.middlewares.get(cls)?.get(endPoint.functionName);
+                if (classMiddlewares) {
+                    middlewares.push(...classMiddlewares);
+                }
+            }
+            return {
+                ...endPoint,
+                controllerConstructor,
+                middlewares,
+                controller,
+            };
+        });
+    }
+};
+RestControllerMetadataStore = __decorate([
+    singleton()
+], RestControllerMetadataStore);
+
+/** SSR context carrying the current view node so `<Outlet/>` can render it. */
+const OutletContext = createContext(null);
+
+/** Absolute path (no extension) to the browser hydration runtime, resolved by esbuild. */
+const PREACT_CLIENT_RUNTIME = fileURLToPath(new URL('./preactClientRuntime', import.meta.url));
+let currentCollector = null;
+const WRAPPED = '__wabotIslandWrapped';
+// Global Preact diff hook (`__b`), invoked per vnode *during* rendering by
+// preact-render-to-string. While an SSR collector is active, replace each
+// island vnode with a <wabot-island> host element that wraps the island's
+// server HTML and carries its serialized props, and record the island so the
+// page can ship its client bundle. Installed once on import (server only).
+const preactOptions = options;
+const previousDiffHook = preactOptions.__b;
+preactOptions.__b = (vnode) => {
+    if (currentCollector && vnode && typeof vnode.type === 'function' && !vnode[WRAPPED]) {
+        const meta = getIslandMeta(vnode.type);
+        if (meta) {
+            const props = vnode.props ?? {};
+            const id = meta.id ?? meta.name;
+            if (!currentCollector.seen.has(id)) {
+                currentCollector.seen.add(id);
+                currentCollector.islands.push({ id, props });
+            }
+            vnode.type = 'wabot-island';
+            vnode.props = {
+                'data-island': id,
+                'data-props': serializeProps(props),
+                children: h(meta.component, props),
+            };
+            vnode[WRAPPED] = true;
+        }
+    }
+    previousDiffHook?.(vnode);
+};
+/**
+ * Default UI renderer backed by Preact + @preact/signals. Renders views to HTML
+ * and emits hydration hosts for any component wrapped with `island()`.
+ */
+class PreactRenderer {
+    id = 'preact';
+    client = {
+        runtimeModule: PREACT_CLIENT_RUNTIME,
+        esbuildJsx: { jsx: 'automatic', jsxImportSource: 'preact' },
+        islandEntrySource: ({ id, importPath }) => `import { registerIsland } from ${JSON.stringify(PREACT_CLIENT_RUNTIME)}\n` +
+            `import Island from ${JSON.stringify(importPath)}\n` +
+            `registerIsland(${JSON.stringify(id)}, Island)\n`,
+    };
+    renderToString(node, context) {
+        // With a layout, render the view inside the shell where <Outlet/> sits.
+        // Without one (or for boosted-nav fragments), render the view directly.
+        const Layout = context?.layout;
+        const tree = Layout
+            ? h(OutletContext.Provider, { value: node }, h(Layout, {}))
+            : node;
+        const collector = { islands: [], seen: new Set() };
+        const previous = currentCollector;
+        currentCollector = collector;
+        try {
+            const html = renderToString(tree);
+            return { html, islands: collector.islands, styles: [] };
+        }
+        finally {
+            currentCollector = previous;
+        }
+    }
+}
+
 const MANIFEST_BANNER = '// auto-generated by @wabot-dev/framework build, do not edit';
 /**
  * Convert an absolute source path into an ESM import specifier relative to
@@ -83,13 +1069,27 @@ function toManifestImport(absFile, manifestDir) {
     return rel.replace(/\.tsx?$/, '.js').replace(/\.jsx$/, '.js');
 }
 function generateManifest(absFiles, manifestDir) {
-    const imports = [...absFiles]
-        .sort()
-        .map((f) => `import '${toManifestImport(f, manifestDir)}'`);
+    const imports = [...absFiles].sort().map((f) => `import '${toManifestImport(f, manifestDir)}'`);
     return `${MANIFEST_BANNER}\n${imports.join('\n')}\n`;
 }
-function generateEntry(manifestDir, consumerEntry, frameworkPackageName) {
+/**
+ * Generates a module that imports each island and stamps its stable id, so the
+ * preloaded (prod) server can emit the matching `data-island` markers at SSR.
+ */
+function generateIslandsRegistration(islands, manifestDir, frameworkPackageName) {
+    const lines = [MANIFEST_BANNER, `import { setIslandId } from '${frameworkPackageName}'`];
+    [...islands]
+        .sort((a, b) => a.absFile.localeCompare(b.absFile))
+        .forEach((island, i) => {
+        lines.push(`import __island${i} from '${toManifestImport(island.absFile, manifestDir)}'`);
+        lines.push(`setIslandId(__island${i}, ${JSON.stringify(island.id)})`);
+    });
+    return lines.join('\n') + '\n';
+}
+function generateEntry(manifestDir, consumerEntry, frameworkPackageName, hasIslands = false) {
     const lines = [MANIFEST_BANNER, "import './manifest.js'"];
+    if (hasIslands)
+        lines.push("import './islands.js'");
     if (consumerEntry) {
         const spec = toManifestImport(consumerEntry, manifestDir);
         lines.push(`import * as __wabot_user_entry from '${spec}'`);
@@ -144,10 +1144,18 @@ async function runBuild(options = {}) {
     }
     const entryResolved = existsSync(entry) ? entry : null;
     const filesForManifest = discovered.filter((f) => f !== entry);
+    const islands = filesForManifest.filter(isIslandFile).map((absFile) => ({
+        absFile,
+        id: toIslandId(relative(cwd, absFile).split(sep).join('/')),
+    }));
+    const hasIslands = islands.length > 0;
     const manifestSrc = generateManifest(filesForManifest, manifestDir);
-    const entrySrc = generateEntry(manifestDir, entryResolved, FRAMEWORK_PACKAGE);
+    const entrySrc = generateEntry(manifestDir, entryResolved, FRAMEWORK_PACKAGE, hasIslands);
     await writeFile(resolve(manifestDir, 'manifest.ts'), manifestSrc, 'utf-8');
     await writeFile(resolve(manifestDir, 'entry.ts'), entrySrc, 'utf-8');
+    if (hasIslands) {
+        await writeFile(resolve(manifestDir, 'islands.ts'), generateIslandsRegistration(islands, manifestDir, FRAMEWORK_PACKAGE), 'utf-8');
+    }
     let tsup;
     try {
         tsup = await import('tsup');
@@ -171,6 +1179,21 @@ async function runBuild(options = {}) {
                 : undefined,
             external: config.external ?? ['pg'],
         });
+        // Emit island client bundles after tsup (which cleans outDir first).
+        if (hasIslands) {
+            const uiOut = resolve(outDir, 'ui');
+            const bundler = new UiBundler({
+                islands: islands.map(({ absFile, id }) => ({
+                    id,
+                    importPath: absFile,
+                    relPath: relative(cwd, absFile).split(sep).join('/'),
+                })),
+                client: new PreactRenderer().client,
+                cwd,
+            });
+            const uiManifest = await bundler.buildProd(uiOut);
+            await writeFile(resolve(uiOut, 'manifest.json'), JSON.stringify(uiManifest, null, 2), 'utf-8');
+        }
     }
     finally {
         if (!options.keep) {