akanjs 0.0.1 → 2.0.0-beta.0

package/server/akanLib.ts

@@ -0,0 +1,43 @@
+import type { ConstantModel, ScalarConstantModel } from "akanjs/constant";
+import type { DatabaseCls, DatabaseModel } from "akanjs/document";
+import type { ServiceModel } from "akanjs/service";
+import type { DatabaseSignal, ServiceSignal } from "akanjs/signal";
+import type { AkanOption } from "./akanOption";
+
+export interface DatabaseModule {
+  constant: ConstantModel;
+  database: DatabaseModel;
+  service: ServiceModel;
+  signal: DatabaseSignal;
+}
+
+export interface ServiceModule {
+  service: ServiceModel;
+  signal: ServiceSignal;
+}
+
+export interface ScalarModule {
+  constant: ScalarConstantModel;
+  database: DatabaseCls;
+}
+
+export interface AkanLibProps {
+  databases: DatabaseModule[];
+  services: ServiceModule[];
+  scalars: ScalarModule[];
+  option: AkanOption<any>;
+}
+export class AkanLib {
+  readonly name: string;
+  readonly database: DatabaseModule[];
+  readonly service: ServiceModule[];
+  readonly scalar: ScalarModule[];
+  readonly option: AkanOption<any>;
+  constructor(name: string, props: AkanLibProps) {
+    this.name = name;
+    this.database = props.databases;
+    this.service = props.services;
+    this.scalar = props.scalars;
+    this.option = props.option;
+  }
+}

package/server/akanOption.ts

@@ -0,0 +1,42 @@
+import type { BaseEnv, PromiseOrObject } from "akanjs/base";
+import type { MiddlewareCls } from "akanjs/signal";
+import type { WebProxyRegistration } from "./proxy";
+import { HostBasePathWebProxy, LocaleWebProxy } from "./proxy";
+
+/** App/library server option builder for use objects, signal middleware, and web proxies. */
+export class AkanOption<Env extends BaseEnv = BaseEnv> {
+  readonly #getUses: ((env: Env) => Record<string, PromiseOrObject<unknown>>)[];
+  readonly #middlewares: MiddlewareCls[] = [];
+  readonly #webProxies: WebProxyRegistration[] = [];
+  constructor() {
+    this.#getUses = [];
+  }
+  use(fnOrObject: ((env: Env) => Record<string, PromiseOrObject<unknown>>) | Record<string, PromiseOrObject<unknown>>) {
+    if (typeof fnOrObject === "function")
+      this.#getUses.push(fnOrObject as (env: Env) => Record<string, PromiseOrObject<unknown>>);
+    else this.#getUses.push(() => fnOrObject);
+    return this;
+  }
+  applyMiddleware(...middlewares: MiddlewareCls[]) {
+    this.#middlewares.push(...middlewares);
+    return this;
+  }
+  applyWebProxy(...proxies: WebProxyRegistration[]) {
+    this.#webProxies.push(...proxies);
+    return this;
+  }
+  getUses(env: Env): Record<string, PromiseOrObject<unknown>> {
+    const uses = this.#getUses.map((fn) => fn(env));
+    return Object.assign({}, ...uses);
+  }
+  getMiddlewares(): MiddlewareCls[] {
+    return this.#middlewares;
+  }
+  getWebProxies(): WebProxyRegistration[] {
+    return this.#webProxies;
+  }
+}
+
+export function createDefaultAkanOption() {
+  return new AkanOption<BaseEnv>().applyWebProxy(LocaleWebProxy, HostBasePathWebProxy);
+}

package/server/akanServer.ts

@@ -0,0 +1,369 @@
+import { type BaseEnv, getEnv } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import type {
+  Adaptor,
+  AdaptorCls,
+  AkanIpcMessage,
+  DatabaseConfig,
+  Service,
+  ServiceCls,
+  SolidConfig,
+} from "akanjs/service";
+import type { ServerSignal, ServerSignalCls, WebsocketPublishData } from "akanjs/signal";
+import type { AkanLib, AkanLibProps } from "./akanLib";
+import type { BuilderRpc } from "./artifact";
+import { DiLifecycle } from "./di/diLifecycle";
+import type { HmrWsData, HmrWsHub } from "./hmr/wsHub";
+import { ShutdownManager } from "./lifecycle/shutdownManager";
+import { ProcessMetricsCollector } from "./processMetricsCollector";
+import { WebProxyRunner } from "./proxy";
+import { SignalResolver } from "./resolver";
+import { ApiRouter } from "./routing/apiRouter";
+import type { HttpRoutes, SignalRoutes, WebsocketRoutes } from "./types";
+import type { WebRouter } from "./webRouter";
+
+export interface AkanServerProps extends AkanLibProps {
+  env?: BaseEnv;
+  prefix?: string;
+  websocketPrefix?: string;
+}
+
+interface AkanAppPrepared {
+  routes: SignalRoutes["routes"];
+  routeOptions: SignalRoutes["routeOptions"];
+  wsRoutes: WebsocketRoutes;
+  renderEnvRoutes: HttpRoutes;
+  hmrHub: HmrWsHub | null;
+  builderRpc: BuilderRpc | null;
+  webRouter: WebRouter | null;
+  webProxyRunner: WebProxyRunner | null;
+}
+
+export class AkanServer {
+  status: "stopped" | "initializing" | "initialized" | "starting" | "running" | "stopping" = "stopped";
+
+  #server: Bun.Server<{ createdAt: number } | HmrWsData> | null = null;
+  #wsServer: Bun.Server<{ createdAt: number } | HmrWsData> | null = null;
+  #prepared: AkanAppPrepared | null = null;
+  readonly logger: Logger;
+  readonly name: string;
+  readonly libs: AkanLib[];
+  readonly env: BaseEnv & { database?: DatabaseConfig; solid?: SolidConfig };
+  prefix = "/api";
+  websocketPrefix = "/ws";
+  serverMode: "federation" | "batch" | "all";
+  shutdownTimeoutMs = 30_000;
+
+  #di: DiLifecycle;
+  #localPublish: ((roomId: string, data: object | object[]) => void) | null = null;
+  #metricsTimer: Timer | null = null;
+  constructor(
+    name = "AkanServer",
+    env: BaseEnv = getEnv(),
+    serverMode: "federation" | "batch" | "all" = (process.env.SERVER_MODE as
+      | "federation"
+      | "batch"
+      | "all"
+      | undefined) ?? "all",
+    ...libs: AkanLib[]
+  ) {
+    this.name = name;
+    this.logger = new Logger(name);
+    this.libs = libs;
+    this.env = { ...env };
+    this.serverMode = serverMode;
+    this.#di = new DiLifecycle(this.env, serverMode, ...libs);
+  }
+  setPrefix(prefix: string) {
+    this.prefix = prefix;
+    return this;
+  }
+  setWebsocketPrefix(websocketPrefix: string) {
+    this.websocketPrefix = websocketPrefix;
+    return this;
+  }
+  setDatabaseConfig(database: DatabaseConfig) {
+    if (this.status !== "stopped") throw new Error("Database config must be set before app initialization.");
+    this.env.database = database;
+    return this;
+  }
+  setSolidConfig(solid: SolidConfig) {
+    if (this.status !== "stopped") throw new Error("Solid config must be set before app initialization.");
+    this.env.solid = solid;
+    return this;
+  }
+  setShutdownTimeout(timeoutMs: number) {
+    this.shutdownTimeoutMs = timeoutMs;
+    return this;
+  }
+
+  get<Srv extends ServiceCls>(cls: Srv): InstanceType<Srv>;
+  get<Sig extends ServerSignalCls>(cls: Sig): InstanceType<Sig>;
+  get<Adp extends AdaptorCls>(cls: Adp): InstanceType<Adp>;
+  get(cls: ServiceCls | ServerSignalCls | AdaptorCls): Service | ServerSignal | Adaptor {
+    this.#assertCanGet();
+    return this.#di.getByClass(cls);
+  }
+
+  getService<T = Service>(refName: string): T {
+    this.#assertCanGet("Service", refName);
+    return this.#di.getService<T>(refName);
+  }
+
+  getSignal<T = ServerSignal>(refName: string): T {
+    this.#assertCanGet("Server signal", refName);
+    return this.#di.getSignal<T>(refName);
+  }
+
+  getAdaptor<T = Adaptor>(refName: string): T {
+    this.#assertCanGet("Adaptor", refName);
+    return this.#di.getAdaptor<T>(refName);
+  }
+
+  async init({ routes: initRoutes = true, web = true }: { routes?: boolean; web?: boolean } = {}) {
+    if (this.status !== "stopped") throw new Error("AkanServer is not able to init. It is already running.");
+    this.status = "initializing";
+    const { routes, wsRoutes, routeOptions } = await this.#di.initializeAll();
+    if (!initRoutes) {
+      this.#prepared = null;
+      this.status = "initialized";
+      return this;
+    }
+    if (!web) {
+      this.#prepared = {
+        routes,
+        routeOptions,
+        wsRoutes,
+        renderEnvRoutes: {},
+        hmrHub: null,
+        builderRpc: null,
+        webRouter: null,
+        webProxyRunner: null,
+      };
+      this.status = "initialized";
+      return this;
+    }
+    const { WebRouter } = await import("./webRouter");
+    const webRouter = await WebRouter.create({
+      upgradeHmrWs: (req, data) => this.#server?.upgrade(req, { data }) ?? false,
+    });
+    const { renderEnvRoutes, hmrHub, builderRpc } = await webRouter.initializeRoute();
+    const webProxyRunner = WebProxyRunner.create(this.#di.webProxies);
+    this.#prepared = { routes, routeOptions, wsRoutes, renderEnvRoutes, hmrHub, builderRpc, webRouter, webProxyRunner };
+    this.status = "initialized";
+    return this;
+  }
+
+  async listen() {
+    if (this.status !== "initialized" || !this.#prepared) {
+      throw new Error("AkanServer is not able to listen. Call `init` first.");
+    }
+    this.status = "starting";
+    const port = process.env.AKAN_CHILD_SOCKET
+      ? undefined
+      : Number(process.env.AKAN_CHILD_WS_PORT || process.env.PORT || 8282);
+    const unix = process.env.AKAN_CHILD_SOCKET || undefined;
+    this.logger.verbose(`${this.name} is serving on ${unix ? `unix://${unix}` : `port ${port}`}`);
+    const { routes, routeOptions, wsRoutes, renderEnvRoutes, hmrHub, webRouter, webProxyRunner } = this.#prepared;
+    const websocketHandlers = {
+      ...ApiRouter.buildWebsocketHandlers({
+        wsRoutes,
+        registry: this.#di.registry,
+        hmrHub,
+        hmrState: webRouter ? { state: webRouter.renderState } : null,
+        logger: this.logger,
+      }),
+      
+      data: {},
+    } as Bun.WebSocketHandler<{ createdAt: number } | HmrWsData>;
+    
+    this.#server = Bun.serve({
+      idleTimeout: 0,
+      ...(unix ? { unix } : { port }),
+      routes: ApiRouter.buildRoutes({
+        prefix: this.prefix,
+        websocketPrefix: this.websocketPrefix,
+        routes,
+        routeOptions,
+        renderEnvRoutes,
+        upgradeAppWs: (req, data) => this.#server?.upgrade(req, { data }) ?? false,
+        webProxyRunner,
+      }),
+      websocket: websocketHandlers,
+    } as Parameters<typeof Bun.serve>[0]);
+    if (unix && process.env.AKAN_CHILD_WS_PORT) {
+      const wsPort = Number(process.env.AKAN_CHILD_WS_PORT);
+      this.#wsServer = Bun.serve({
+        idleTimeout: 0,
+        port: wsPort,
+        routes: ApiRouter.buildRoutes({
+          prefix: this.prefix,
+          websocketPrefix: this.websocketPrefix,
+          routes,
+          routeOptions,
+          renderEnvRoutes,
+          upgradeAppWs: (req, data) => this.#wsServer?.upgrade(req, { data }) ?? false,
+          webProxyRunner,
+        }),
+        websocket: websocketHandlers,
+      });
+      this.logger.verbose(`${this.name} websocket fallback is serving on port ${wsPort}`);
+    }
+
+    const server = this.#server;
+    const wsServer = this.#wsServer;
+    hmrHub?.setPublisher((topic, payload) => {
+      server?.publish(topic, payload);
+      wsServer?.publish(topic, payload);
+    });
+
+    const websocket = this.#di.getWebsocketAdaptor();
+    if (!websocket) throw new Error("WebSocket Redis adaptor is not registered");
+    SignalResolver.setLocalPublish((roomId, data) => {
+      const publishData: WebsocketPublishData = { type: "pub", roomId, data };
+      server?.publish(roomId, JSON.stringify(publishData));
+      wsServer?.publish(roomId, JSON.stringify(publishData));
+    }, websocket);
+    this.#localPublish = (roomId, data) => {
+      const publishData: WebsocketPublishData = { type: "pub", roomId, data };
+      server?.publish(roomId, JSON.stringify(publishData));
+      wsServer?.publish(roomId, JSON.stringify(publishData));
+    };
+
+    this.status = "running";
+    this.#startMetricsReporting();
+    this.#di.registerSchedule(this.serverMode);
+    this.logger.verbose(`🚀 ${this.name} is running on ${unix ? `unix://${unix}` : `port ${port}`}`);
+    process.send?.({
+      type: "ready",
+      pid: process.pid,
+      replicaIdx: Number(process.env.AKAN_REPLICA_IDX ?? 0),
+      role: this.serverMode,
+      upstream: unix ? { type: "unix", socketPath: unix } : { type: "tcp", host: "127.0.0.1", port: Number(port) },
+      healthPath: "/_akan/app/child-health",
+    } satisfies AkanIpcMessage);
+    await this.#di.runSchedulerInit();
+    ShutdownManager.register(this.logger, () => this.stop());
+    return this;
+  }
+
+  async start({ listen, web = true }: { listen?: boolean; web?: boolean } = {}) {
+    const isScriptCommand = process.env.AKAN_COMMAND_TYPE === "script";
+    const shouldListen = (listen ?? !isScriptCommand) && this.serverMode !== "batch";
+    await this.init({ routes: shouldListen, web });
+    if (!shouldListen) {
+      const websocket = this.#di.getWebsocketAdaptor();
+      if (websocket) SignalResolver.setLocalPublish((roomId, data) => this.#localPublish?.(roomId, data), websocket);
+      this.status = "running";
+      if (!isScriptCommand) {
+        this.#startMetricsReporting();
+        this.#di.registerSchedule(this.serverMode);
+        process.on("message", (message) => this.#handleIpcMessage(message as AkanIpcMessage));
+        process.send?.({
+          type: "ready",
+          pid: process.pid,
+          replicaIdx: Number(process.env.AKAN_REPLICA_IDX ?? 0),
+          role: this.serverMode,
+        } satisfies AkanIpcMessage);
+        await this.#di.runSchedulerInit();
+        ShutdownManager.register(this.logger, () => this.stop());
+      }
+      return this;
+    }
+    process.on("message", (message) => this.#handleIpcMessage(message as AkanIpcMessage));
+    return this.listen();
+  }
+  async stop() {
+    if (this.status !== "running") {
+      this.logger.warn("AkanServer is not running. Cannot stop.");
+      return;
+    }
+
+    try {
+      const now = Date.now();
+      this.logger.info("Shutting down gracefully...");
+      this.status = "stopping";
+      this.#stopMetricsReporting();
+      this.#di.getWebsocketAdaptor()?.clearEventHandler();
+      this.#server?.stop(true);
+      this.#wsServer?.stop(true);
+      this.#server = null;
+      this.#wsServer = null;
+
+      this.#prepared?.webRouter?.dispose();
+      await this.#withShutdownTimeout(this.#di.destroyAll());
+      this.#prepared = null;
+      this.status = "stopped";
+      this.logger.info(`Shutdown completed successfully in ${Date.now() - now}ms`);
+    } catch (error) {
+      this.logger.error(`Error during shutdown: ${error instanceof Error ? error.message : String(error)}`);
+      this.status = "stopped";
+      throw error;
+    }
+  }
+
+  #handleIpcMessage(message: AkanIpcMessage) {
+    if (!message || typeof message !== "object") return;
+    if (message.type === "pubsub.deliver") this.#localPublish?.(message.roomId, message.data as object | object[]);
+    else if (message.type === "health.ping")
+      process.send?.({
+        type: "health.pong",
+        nonce: message.nonce,
+        sentAt: message.sentAt,
+        pid: process.pid,
+      } satisfies AkanIpcMessage);
+    else if (message.type === "shutdown") void this.stop();
+  }
+
+  #startMetricsReporting() {
+    if (this.#metricsTimer) return;
+    const report = () => {
+      void this.#reportMetrics();
+    };
+    report();
+    this.#metricsTimer = setInterval(report, ProcessMetricsCollector.parseMemoryLogIntervalMs());
+  }
+
+  async #reportMetrics() {
+    const metrics = await ProcessMetricsCollector.collect({
+      role: this.serverMode,
+      ...(this.#prepared?.webRouter?.getMetrics() ?? {}),
+    });
+    process.send?.({ type: "metrics.report", pid: process.pid, metrics } satisfies AkanIpcMessage);
+    if (process.env.AKAN_MEMORY_LOG === "1") {
+      this.logger.info(`memory role=${this.serverMode} ${ProcessMetricsCollector.format(metrics)}`);
+    }
+  }
+
+  #stopMetricsReporting() {
+    if (!this.#metricsTimer) return;
+    clearInterval(this.#metricsTimer);
+    this.#metricsTimer = null;
+  }
+
+  #assertCanGet(type = "Dependency", refName?: string) {
+    if (this.status === "initialized" || this.status === "running") return;
+    const target = refName ? `${type} "${refName}"` : type;
+    throw new Error(
+      `${target} is not initialized while AkanServer status is "${this.status}". ` +
+        "Call server.start() or server.init() first.",
+    );
+  }
+
+  async #withShutdownTimeout<T>(promise: Promise<T>) {
+    let timeout: Timer | null = null;
+    try {
+      return await Promise.race([
+        promise,
+        new Promise<T>((_, reject) => {
+          timeout = setTimeout(
+            () => reject(new Error(`Shutdown timed out after ${this.shutdownTimeoutMs}ms`)),
+            this.shutdownTimeoutMs,
+          );
+        }),
+      ]);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+}

package/server/artifact/builderRpc.ts

@@ -0,0 +1,124 @@
+import { Logger } from "akanjs/common";
+import type {
+  BuilderEvent,
+  BuilderMessage,
+  BuilderReq,
+  BuilderRes,
+  BuildRouteResultPayload,
+  CssPayload,
+  PagesBundlePayload,
+} from "./ipcTypes";
+import type { BuildRouteClientResult } from "./manifestTypes";
+
+export interface BuilderRpcEventHandlers {
+  /**
+   * Filesystem batch invalidation from the builder's watcher. The backend
+   * should treat this as a hint to clear its route cache and broadcast a
+   * dev reload to connected HMR clients.
+   */
+  onInvalidate?: (event: { kinds: ("code" | "css" | "config")[]; files: string[]; generation?: number }) => void;
+  /** Builder proactively recompiled CSS; payload includes base64 bytes. */
+  onCssUpdated?: (css: CssPayload) => void;
+  /**
+   * Builder emitted a freshly bundled `pages-*.js`. Backend should
+   * re-import it (e.g. by calling `RscWorker.reload({ pagesBundlePath,
+   * buildId })`) so new user code takes effect without spawning a new
+   * worker subprocess.
+   */
+  onPagesUpdated?: (bundle: PagesBundlePayload) => void;
+}
+
+/**
+ * Typed RPC facade around the raw `BuilderTransport`. Handles the
+ * correlation-id bookkeeping (request promise + resolver map) and exposes
+ * a narrow surface matching the three builder operations.
+ *
+ * Only one `BuilderRpc` instance should exist per backend process. It
+ * subscribes to the transport at construction and unsubscribes on
+ * `dispose()`.
+ */
+export class BuilderRpc {
+  readonly #logger = new Logger("BuilderRpc");
+  readonly #pending = new Map<number, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
+  readonly #offMessage: () => void;
+  readonly #proc = process;
+  readonly #send: (msg: BuilderReq) => void;
+  #nextId = 1;
+  #disposed = false;
+
+  constructor(handlers: BuilderRpcEventHandlers = {}) {
+    if (!this.#proc.send)
+      throw new Error("[builder] process.send unavailable — backend must be spawned by the CLI with ipc enabled");
+    this.#send = this.#proc.send.bind(this.#proc);
+    this.#offMessage = this.#listen((msg) => {
+      
+      if (msg.type === "build-route-res") {
+        const res = msg as BuilderRes;
+        const waiter = this.#pending.get(res.id);
+        if (!waiter) return;
+        this.#pending.delete(res.id);
+        if (res.ok) waiter.resolve(res.data);
+        else waiter.reject(new Error(`[builder] ${res.type} failed: ${res.error}`));
+        return;
+      }
+      
+      const ev = msg as BuilderEvent;
+      switch (ev.type) {
+        case "builder-ready":
+          this.#logger.verbose(`[builder] builder ready buildId=${ev.buildId}`);
+          return;
+        case "invalidate":
+          handlers.onInvalidate?.({ kinds: ev.kinds, files: ev.files, generation: ev.generation });
+          return;
+        case "css-updated":
+          handlers.onCssUpdated?.(ev.data);
+          return;
+        case "pages-updated":
+          handlers.onPagesUpdated?.(ev.data);
+          return;
+        default:
+          return;
+      }
+    });
+  }
+
+  async buildRoute(
+    routeId: string,
+    { seeds, knownEntries, generation }: { seeds: string[]; knownEntries: Set<string>; generation?: number },
+  ): Promise<BuildRouteClientResult> {
+    if (this.#disposed) throw new Error("[builder] rpc is disposed");
+    const id = this.#nextId++;
+    const payload = await new Promise<BuildRouteResultPayload>((resolve, reject) => {
+      this.#pending.set(id, { resolve: resolve as (v: unknown) => void, reject });
+      this.#send({ type: "build-route", id, routeId, seeds, knownEntries: [...knownEntries], generation });
+    });
+    return {
+      manifestDelta: payload.manifestDelta,
+      ssrManifestDelta: { moduleLoading: null, moduleMap: payload.ssrManifestDelta },
+      newEntries: payload.newEntries,
+      discoveredEntries: payload.discoveredEntries,
+      clientDeps: payload.clientDeps,
+      clientDepsByEntry: payload.clientDepsByEntry,
+    };
+  }
+
+  dispose(): void {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.#offMessage();
+    for (const [, waiter] of this.#pending) waiter.reject(new Error("[builder] rpc disposed"));
+    this.#pending.clear();
+  }
+
+  #listen(listener: (msg: BuilderMessage) => void): () => void {
+    const handler = (msg: unknown) => {
+      if (!msg || typeof msg !== "object") return;
+      listener(msg as BuilderMessage);
+    };
+    this.#proc.on("message", handler);
+    return () => {
+      if (this.#proc.off) this.#proc.off("message", handler);
+      else if (this.#proc.removeListener) this.#proc.removeListener("message", handler);
+    };
+  }
+}

package/server/artifact/index.ts

@@ -0,0 +1,6 @@
+export * from "./builderRpc";
+export * from "./ipcTypes";
+export * from "./manifestTypes";
+export * from "./routeClientCache";
+export * from "./routeSeedIndexStore";
+export * from "./routesManifestStore";

package/server/artifact/ipcTypes.ts

@@ -0,0 +1,46 @@
+export interface BuildRouteResultPayload {
+  manifestDelta: Record<string, { id: string; chunks: string[]; name: string; async: boolean }>;
+  ssrManifestDelta: Record<string, Record<string, { id: string; chunks: string[]; name: string; async: boolean }>>;
+  newEntries: string[];
+  discoveredEntries?: string[];
+  clientDeps: string[];
+  clientDepsByEntry?: Record<string, string[]>;
+  routeId?: string;
+  generation?: number;
+}
+
+export interface CssPayload {
+  cssAssets: Record<string, { cssUrl: string; cssRelPath: string }>;
+  cssBase64ByUrl: Record<string, string>;
+  generation?: number;
+  changedFiles?: string[];
+}
+
+export type BuilderReq = {
+  type: "build-route";
+  id: number;
+  routeId: string;
+  seeds: string[];
+  knownEntries: string[];
+  generation?: number;
+};
+
+export type BuilderRes =
+  | { type: "build-route-res"; id: number; ok: true; data: BuildRouteResultPayload }
+  | { type: "build-route-res"; id: number; ok: false; error: string };
+
+export interface PagesBundlePayload {
+  bundlePath: string;
+  buildId: number;
+  generation?: number;
+  changedFiles?: string[];
+}
+
+export type BuilderEvent =
+  | { type: "builder-ready"; buildId: string }
+  | { type: "backend-ready"; pid: number }
+  | { type: "invalidate"; kinds: ("code" | "css" | "config")[]; files: string[]; generation?: number }
+  | { type: "css-updated"; data: CssPayload }
+  | { type: "pages-updated"; data: PagesBundlePayload };
+
+export type BuilderMessage = BuilderReq | BuilderRes | BuilderEvent;

package/server/artifact/manifestTypes.ts

@@ -0,0 +1,19 @@
+import type { SsrManifest } from "../ssrTypes";
+
+export interface ClientManifestEntry {
+  id: string;
+  chunks: string[];
+  name: string;
+  async?: boolean;
+}
+
+export type ClientManifest = Record<string, ClientManifestEntry>;
+
+export interface BuildRouteClientResult {
+  manifestDelta: ClientManifest;
+  ssrManifestDelta: SsrManifest;
+  newEntries: string[];
+  discoveredEntries?: string[];
+  clientDeps: string[];
+  clientDepsByEntry?: Record<string, string[]>;
+}