@makaio/framework 1.0.0-dev-1781023871421 → 1.0.0-dev-1781081952714

package/dist/runtime-bun/index.d.mts

@@ -0,0 +1,385 @@
+import { IMakaioBus } from "@makaio/framework/bus";
+import { DispatchingAuth, TransportAuth } from "@makaio/framework/node/transports";
+import { BridgeBrowserOptions, CoreBootOptions, CoreBootOptions as CoreBootOptions$1, CredentialProvider, DescriptorSourcePackageGroup, DiscoveredExtension, ExplicitDescriptorDiscovery, ExtensionDiscovery, FileConfigStorage, FileRegistryCache, FilesystemDescriptorDiscovery, FilesystemDescriptorDiscoveryOptions, FrameworkModuleResolver, HonoRouteGraph, HonoRouteGraph as HonoRouteGraph$1, HonoRouteGraphOptions, HttpContributionPhase, HttpRouteContribution, HttpRouteGraphBuilder, LoadExtensionsOptions, MachineKeyStatus, MachineKeyValidation, MakaioRuntime, MakaioRuntime as MakaioRuntime$1, NodeCredentialProvider, PersistedMachineIdentity, ServerTransportProvider, ServerTransportProvider as ServerTransportProvider$1, StoredCredentialProvider, TransportReadyInfo, bootMakaioRuntimeCore, bridgeExtensionBrowserEntries, createHonoRouteGraph, createHttpRouteGraphBuilder, entrypointStem, isCliContributionLike, isMakaioExtensionLike, isMissingOptionalRuntimePackage, isWithinDirectory, loadExtensions, loadOrCreateMachineIdentity, machineKeysExist, registerAdapterNameResolver, resolveConventionEntrypoint, resolveStaticModelRegistryPath, runMigrations, tryImport, validateMachineKeys } from "@makaio/framework/runtime-node";
+
+//#region runtimes/bun/src/bus-server-transport.d.ts
+/**
+ * Configuration options for {@link BunBusServerTransportProvider}.
+ */
+interface BunBusServerTransportOptions {
+  /**
+   * Auth strategy.
+   *
+   * When `undefined` the server runs with no authentication. Pass a
+   * {@link DispatchingAuth} to support hot-swapping E2E auth after machine
+   * identity is loaded.
+   */
+  auth?: TransportAuth;
+  /**
+   * Loopback transport registry name for in-process cross-client relay.
+   *
+   * Defaults to `'bun'`.
+   */
+  loopbackName?: string;
+}
+/**
+ * Minimal contract for the raw Bun `ServerWebSocket` fields used by the adapter.
+ *
+ * Avoids importing Bun-specific types so this module compiles with standard
+ * TypeScript (tests, CI).
+ */
+interface RawServerWebSocket {
+  send(data: string | ArrayBufferView | ArrayBufferLike, compress?: boolean): number;
+  close(code?: number, reason?: string): void;
+  readonly readyState: number;
+}
+/**
+ * Native Bun WebSocket handler shape for use with `Bun.serve({ websocket })`.
+ *
+ * The composition root passes an instance of this (obtained from
+ * {@link BunBusServerTransportProvider.createWebSocketHandler}) directly to
+ * `Bun.serve` so the bus transport operates independently of the Hono app.
+ *
+ * Setting `binaryType: 'arraybuffer'` ensures binary frames are delivered as
+ * `ArrayBuffer`, which matches the {@link BunServerWebSocketAdapter.dispatchMessage}
+ * signature and avoids a Node `Buffer` conversion step.
+ */
+interface BunWebSocketHandler {
+  /**
+   * Instructs Bun to deliver binary frames as `ArrayBuffer` objects.
+   *
+   * Without this, Bun's default `binaryType` is `'nodebuffer'` which delivers
+   * binary frames as Node `Buffer` instances. Setting `'arraybuffer'` keeps the
+   * message type consistent with `dispatchMessage`'s `string | ArrayBuffer`
+   * signature.
+   */
+  binaryType: 'arraybuffer';
+  /**
+   * Called when a new WebSocket connection is opened.
+   * @param ws - The raw Bun server-side WebSocket.
+   */
+  open(ws: RawServerWebSocket): void;
+  /**
+   * Called when a message is received from the client.
+   * @param ws - The raw Bun server-side WebSocket.
+   * @param message - The message payload (string or ArrayBuffer when binaryType is arraybuffer).
+   */
+  message(ws: RawServerWebSocket, message: string | ArrayBuffer): void;
+  /**
+   * Called when the WebSocket connection is closed.
+   * @param ws - The raw Bun server-side WebSocket.
+   * @param code - WebSocket close code.
+   * @param reason - WebSocket close reason string.
+   */
+  close(ws: RawServerWebSocket, code: number, reason: string): void;
+}
+/**
+ * Platform-specific bus server transport provider for Bun.
+ *
+ * Uses a native Bun WebSocket handler (obtained from
+ * {@link createWebSocketHandler}) and {@link HonoWebSocketBridge} to accept
+ * WebSocket connections and feed them into the framework bus server. The
+ * handler is wired directly to `Bun.serve({ websocket })`, making the bus
+ * transport independent of the Hono app lifecycle — route graph rebuilds
+ * (which create a fresh `new Hono()`) do not affect the bus.
+ */
+declare class BunBusServerTransportProvider implements ServerTransportProvider$1 {
+  private readonly options;
+  /** WebSocket bridge between the native handler and ServerTransport. */
+  private readonly bridge;
+  /** Active bus server instance. Set during connect, cleared on disconnect. */
+  private busServer;
+  /**
+   * Whether the bus server has completed startup and is accepting connections.
+   * Guards against WebSocket upgrade requests racing with bus startup.
+   */
+  private busReady;
+  /**
+   * Set synchronously at the top of {@link connect} to close the TOCTOU window
+   * between the guard check and the first `await`.
+   */
+  private connecting;
+  /**
+   * @param options - Transport configuration.
+   */
+  constructor(options: BunBusServerTransportOptions);
+  /**
+   * The {@link DispatchingAuth} instance if the caller passed one.
+   *
+   * Exposed so composition roots that need to hot-swap E2E auth after machine
+   * identity becomes available can call `dispatchingAuth.setE2EAuth(e2eAuth)`.
+   * @returns The {@link DispatchingAuth} instance, or `undefined` when auth was
+   *   not provided or is not a `DispatchingAuth`.
+   */
+  get dispatchingAuth(): DispatchingAuth | undefined;
+  /**
+   * Create a native Bun WebSocket handler for `Bun.serve({ websocket })`.
+   *
+   * The returned handler replaces the former Hono `upgradeWebSocket` route.
+   * The composition root passes this to `Bun.serve()` directly, making the
+   * bus transport independent of Hono app lifecycle (and route graph rebuilds).
+   *
+   * A `WeakMap` keyed on the raw `ServerWebSocket` object stores the
+   * per-connection {@link BunServerWebSocketAdapter} so there is no mutation
+   * of the Bun socket and no memory leak when connections close.
+   * @returns Bun-native WebSocket handler with `open`, `message`, and `close`
+   *   callbacks, plus `binaryType: 'arraybuffer'` to ensure binary frames
+   *   arrive as `ArrayBuffer` rather than Node `Buffer`.
+   */
+  createWebSocketHandler(): BunWebSocketHandler;
+  /**
+   * Start the bus server and mark the transport as ready to accept connections.
+   * @param bus - Bus instance to attach the transport to.
+   * @param _machineId - Machine identifier (unused; callers provide auth externally).
+   */
+  connect(bus: IMakaioBus, _machineId: string): Promise<void>;
+  /**
+   * Stop the bus server and close the bridge.
+   *
+   * The Bun server is owned by the composition root and is not closed here.
+   */
+  disconnect(): Promise<void>;
+  /**
+   * Stop the bus server and mark the transport as not ready.
+   * @param reason - Context string used in error log messages.
+   */
+  private stopBusServer;
+}
+//#endregion
+//#region runtimes/bun/src/bun-route-graph-fetch.d.ts
+/**
+ * Minimal Bun server capability needed to upgrade an HTTP request to a
+ * WebSocket connection.
+ */
+interface BunRouteGraphUpgradeServer {
+  /**
+   * Upgrade a request to the native Bun WebSocket handler.
+   * @param request - Incoming HTTP request.
+   * @returns `true` when Bun accepted the upgrade.
+   */
+  upgrade(request: Request): boolean;
+}
+/**
+ * Fetch handler shape accepted by `Bun.serve` for a route-graph backed server.
+ */
+type BunRouteGraphFetch = (request: Request, server: BunRouteGraphUpgradeServer) => Response | Promise<Response> | undefined | Promise<undefined>;
+/**
+ * Create the Bun fetch facade for a route graph plus native WebSocket server.
+ *
+ * Bun's `websocket` handlers are invoked only after the fetch handler calls
+ * `server.upgrade(request)`. This wrapper keeps that infrastructure concern at
+ * the Bun platform boundary while all non-WebSocket HTTP requests continue to
+ * flow through the stable {@link HonoRouteGraph.fetch} facade.
+ * @param routeGraph - Stable route graph facade for HTTP requests.
+ * @returns Bun-compatible fetch function that upgrades bus WebSocket requests.
+ */
+declare function createBunRouteGraphFetch(routeGraph: HonoRouteGraph$1): BunRouteGraphFetch;
+//#endregion
+//#region runtimes/bun/src/http-server-utils.d.ts
+/**
+ * Minimal Bun server interface for port resolution.
+ *
+ * Duck-typed against `ReturnType<typeof Bun.serve>` — covers the address
+ * properties used by this module without importing `bun-types`.
+ */
+interface BunServer {
+  /** The TCP port the server is listening on. */
+  readonly port: number;
+  /** The hostname the server is bound to (e.g. `'localhost'` or `'0.0.0.0'`). */
+  readonly hostname: string;
+  /**
+   * Stop the server when the runtime owns the HTTP listener.
+   * @param closeActiveConnections - Whether active connections should be closed.
+   */
+  stop?: (closeActiveConnections?: boolean) => void | Promise<void>;
+}
+/**
+ * Resolve the bound TCP port from a Bun server.
+ *
+ * Unlike Node's `http.Server`, Bun's server exposes the port synchronously as
+ * a plain property — no need to call `server.address()`.
+ * @param server - Bun server instance returned by `Bun.serve()`.
+ * @returns Numeric TCP port.
+ */
+declare function resolveListeningPort(server: BunServer): number;
+/**
+ * Bound address resolved from a Bun server instance.
+ */
+interface BunServerAddress {
+  /** Bound TCP port. */
+  port: number;
+  /** Bound host address (e.g. `'localhost'` or `'0.0.0.0'`). */
+  host: string;
+}
+//#endregion
+//#region runtimes/bun/src/boot.d.ts
+/**
+ * Options for {@link bootMakaioRuntime} (Bun platform).
+ *
+ * Extends the platform-agnostic {@link CoreBootOptions} with the Bun server
+ * instance and the pre-constructed transport. The composition root creates the
+ * transport and extracts the WebSocket handler before starting the Bun server,
+ * then passes both here.
+ */
+interface BunBootMakaioRuntimeOptions extends CoreBootOptions$1 {
+  /**
+   * Bun server instance, already listening.
+   *
+   * Must be started with the WebSocket handler obtained from
+   * {@link BunBusServerTransportProvider.createWebSocketHandler} so that the
+   * bus transport can accept connections.
+   */
+  bunServer: BunServer;
+  /**
+   * Pre-constructed bus server transport provider.
+   *
+   * The composition root creates the transport, calls
+   * {@link BunBusServerTransportProvider.createWebSocketHandler} to get the
+   * native handler for `Bun.serve`, then passes the transport here.
+   * This ensures the WebSocket handler is registered before boot begins.
+   */
+  transport: BunBusServerTransportProvider;
+}
+/**
+ * Boot the full Makaio runtime against a pre-existing Bun server.
+ *
+ * Delegates all startup logic to the platform-agnostic
+ * {@link bootMakaioRuntimeCore}. The caller owns the Bun server and transport
+ * lifecycle. This function owns everything from step 1 (Config) through
+ * step 12 (Ready) and returns a {@link MakaioRuntime} handle that the caller
+ * uses to shut down.
+ * @param options - Boot configuration including the pre-bound Bun server and
+ *   pre-constructed transport provider.
+ * @returns Runtime handle with `port`, `machineId`, and `shutdown()`.
+ */
+declare function bootMakaioRuntime(options: BunBootMakaioRuntimeOptions): Promise<MakaioRuntime$1>;
+//#endregion
+//#region runtimes/bun/src/bun-host-contributions.d.ts
+/** Bun-native host hooks exposed by extensions that need HTTP/WebSocket routing. */
+interface BunHostContribution {
+  /** Wrap the host fetch handler with extension-owned routing. */
+  readonly createFetch?: (next: BunRouteGraphFetch) => BunRouteGraphFetch;
+  /** Wrap the host WebSocket handler with extension-owned routing. */
+  readonly createWebSocketHandler?: (next: BunWebSocketHandler) => BunWebSocketHandler;
+}
+/** Extension package shape that carries Bun host hooks. */
+interface BunHostExtensionPackage {
+  /** Extension package name. */
+  readonly name: string;
+  /** Human-readable extension package name. */
+  readonly displayName: string;
+  /** Extension package version. */
+  readonly version?: string;
+  /** Bun-native host hooks consumed by Bun composition roots. */
+  readonly bun: BunHostContribution;
+}
+/** Minimal active-extension iterator exposed by ExtensionCoordinator. */
+interface ActiveBunHostExtensionIterator {
+  /**
+   * Iterate active extension packages after coordinator startup.
+   * @param callback - Receives active package metadata.
+   */
+  forEachActiveExtension(callback: (name: string, pkg: Pick<BunHostExtensionPackage, 'name' | 'displayName'>) => void): void;
+}
+/** Mutable router passed to `Bun.serve` before runtime boot finishes. */
+interface BunHostRouter {
+  /** Stable fetch delegate for `Bun.serve`. */
+  readonly fetch: BunRouteGraphFetch;
+  /** Stable WebSocket delegate for `Bun.serve`. */
+  readonly websocket: BunWebSocketHandler;
+  /**
+   * Activate Bun host hooks from packages that survived extension lifecycle gates.
+   * @param packages - Active extension packages with optional Bun hooks.
+   */
+  activate(packages: readonly BunHostExtensionPackage[]): void;
+}
+/**
+ * Create a stable Bun router whose delegates can be activated after extension boot.
+ *
+ * The force point is lifecycle order: `Bun.serve` needs stable callbacks before
+ * the runtime starts, while extension host hooks must only affect routing after
+ * the coordinator has accepted the package as active.
+ * @param baseFetch - Base route-graph fetch handler.
+ * @param baseWebSocket - Base bus WebSocket handler.
+ * @returns Mutable router with stable `Bun.serve` delegates.
+ */
+declare function createBunHostRouter(baseFetch: BunRouteGraphFetch, baseWebSocket: BunWebSocketHandler): BunHostRouter;
+/**
+ * Collect Bun host packages from the coordinator's active extension snapshot.
+ * @param coordinator - Active extension iterator captured during boot.
+ * @returns Active packages with valid Bun host hooks.
+ */
+declare function collectActiveBunHostPackages(coordinator: ActiveBunHostExtensionIterator): readonly BunHostExtensionPackage[];
+/**
+ * Normalize a static extension module default into Bun host packages.
+ * @param value - Extension package or package array.
+ * @returns Packages with valid Bun host hooks.
+ */
+declare function normalizeBunHostPackages(value: unknown): readonly BunHostExtensionPackage[];
+/**
+ * Compose Bun fetch host hooks in package order.
+ * @param baseFetch - Base fetch handler.
+ * @param packages - Packages with optional Bun hooks.
+ * @returns Wrapped fetch handler.
+ */
+declare function composeBunHostFetch(baseFetch: BunRouteGraphFetch, packages: readonly BunHostExtensionPackage[]): BunRouteGraphFetch;
+/**
+ * Compose Bun WebSocket host hooks in package order.
+ * @param baseHandler - Base WebSocket handler.
+ * @param packages - Packages with optional Bun hooks.
+ * @returns Wrapped WebSocket handler.
+ */
+declare function composeBunHostWebSocket(baseHandler: BunWebSocketHandler, packages: readonly BunHostExtensionPackage[]): BunWebSocketHandler;
+//#endregion
+//#region runtimes/bun/src/graceful-shutdown.d.ts
+/** Options for a Bun composition root shutdown handler. */
+interface BunGracefulShutdownOptions {
+  /** Log prefix without brackets, e.g. `server` or `relay`. */
+  readonly label: string;
+  /** Runtime handle returned by `bootMakaioRuntime`. */
+  readonly runtime: Pick<MakaioRuntime$1, 'shutdown'>;
+  /** Bun server owned by the composition root. */
+  readonly bunServer: BunServer;
+  /** Force-exit timeout in milliseconds. Defaults to 10 seconds. */
+  readonly timeoutMs?: number;
+  /** Process exit hook, primarily for tests. Defaults to `process.exit`. */
+  readonly exit?: (code: number) => never;
+}
+/**
+ * Create an idempotent signal shutdown handler for Bun composition roots.
+ * @param options - Runtime, server, and logging configuration.
+ * @returns Signal handler suitable for `process.once`.
+ */
+declare function createGracefulShutdown(options: BunGracefulShutdownOptions): (signal: string) => Promise<void>;
+//#endregion
+//#region runtimes/bun/src/server-env.d.ts
+/** Resolved Bun HTTP server bind configuration. */
+interface BunServerEnvConfig {
+  /** HTTP server port. */
+  readonly port: number;
+  /** Bind host. */
+  readonly host: string;
+}
+/** Policy for invalid environment values. */
+type InvalidBunServerEnvPolicy = 'throw' | 'warn';
+/** Options for reading Bun server bind configuration from an env object. */
+interface ReadBunServerEnvOptions {
+  /** Application label used in warnings. */
+  readonly appName: string;
+  /** Environment object. Defaults to `process.env`. */
+  readonly env?: NodeJS.ProcessEnv;
+  /** Default HTTP port. Defaults to 3000. */
+  readonly defaultPort?: number;
+  /** Default bind host. Defaults to `0.0.0.0`. */
+  readonly defaultHost?: string;
+  /** Invalid-value policy. Defaults to `throw`. */
+  readonly invalid?: InvalidBunServerEnvPolicy;
+}
+/**
+ * Read and validate Bun server bind configuration from environment variables.
+ * @param options - Env source, defaults, and invalid-value policy.
+ * @returns Resolved Bun server bind configuration.
+ */
+declare function readBunServerEnv(options: ReadBunServerEnvOptions): BunServerEnvConfig;
+//#endregion
+export { type ActiveBunHostExtensionIterator, type BridgeBrowserOptions, type BunBootMakaioRuntimeOptions, type BunBusServerTransportOptions, BunBusServerTransportProvider, type BunGracefulShutdownOptions, type BunHostContribution, type BunHostExtensionPackage, type BunHostRouter, type BunRouteGraphFetch, type BunRouteGraphUpgradeServer, type BunServer, type BunServerAddress, type BunServerEnvConfig, type BunWebSocketHandler, type CoreBootOptions, type CredentialProvider, type DescriptorSourcePackageGroup, type DiscoveredExtension, ExplicitDescriptorDiscovery, type ExtensionDiscovery, FileConfigStorage, FileRegistryCache, FilesystemDescriptorDiscovery, type FilesystemDescriptorDiscoveryOptions, type FrameworkModuleResolver, type HonoRouteGraph, type HonoRouteGraphOptions, type HttpContributionPhase, type HttpRouteContribution, type HttpRouteGraphBuilder, type InvalidBunServerEnvPolicy, type LoadExtensionsOptions, type MachineKeyStatus, type MachineKeyValidation, type MakaioRuntime, NodeCredentialProvider, type PersistedMachineIdentity, type ReadBunServerEnvOptions, type ServerTransportProvider, StoredCredentialProvider, type TransportReadyInfo, bootMakaioRuntime, bootMakaioRuntimeCore, bridgeExtensionBrowserEntries, collectActiveBunHostPackages, composeBunHostFetch, composeBunHostWebSocket, createBunHostRouter, createBunRouteGraphFetch, createGracefulShutdown, createHonoRouteGraph, createHttpRouteGraphBuilder, entrypointStem, isCliContributionLike, isMakaioExtensionLike, isMissingOptionalRuntimePackage, isWithinDirectory, loadExtensions, loadOrCreateMachineIdentity, machineKeysExist, normalizeBunHostPackages, readBunServerEnv, registerAdapterNameResolver, resolveConventionEntrypoint, resolveListeningPort, resolveStaticModelRegistryPath, runMigrations, tryImport, validateMachineKeys };

package/dist/runtime-bun/index.mjs

@@ -0,0 +1 @@
+import{DispatchingAuth as e,createWebSocketCloseEvent as t}from"@makaio/framework/node/transports";import{HonoWebSocketBridge as n,startBusServer as r}from"@makaio/framework/node/bus-server";import{ExplicitDescriptorDiscovery as i,FileConfigStorage as a,FileRegistryCache as o,FilesystemDescriptorDiscovery as s,NodeCredentialProvider as c,StoredCredentialProvider as l,bootMakaioRuntimeCore as u,bootMakaioRuntimeCore as d,bridgeExtensionBrowserEntries as f,createHonoRouteGraph as p,createHttpRouteGraphBuilder as m,entrypointStem as h,isCliContributionLike as g,isMakaioExtensionLike as _,isMissingOptionalRuntimePackage as v,isWithinDirectory as y,loadExtensions as b,loadOrCreateMachineIdentity as x,machineKeysExist as S,registerAdapterNameResolver as C,resolveConventionEntrypoint as w,resolveStaticModelRegistryPath as T,runMigrations as E,tryImport as D,validateMachineKeys as O}from"@makaio/framework/runtime-node";import{isIP as k}from"node:net";var A=class{raw;eventListeners={message:new Set,close:new Set,error:new Set,open:new Set};constructor(e){this.raw=e}get readyState(){return this.raw.readyState}send(e){if(typeof e==`string`){this.raw.send(e);return}if(e instanceof Blob){e.arrayBuffer().then(e=>{this.raw.readyState===1&&this.raw.send(new Uint8Array(e))}).catch(()=>{this.dispatchError()});return}if(e instanceof ArrayBuffer){this.raw.send(new Uint8Array(e));return}ArrayBuffer.isView(e)&&this.raw.send(e)}close(e,t){this.raw.close(e,t)}addEventListener(e,t){this.eventListeners[e]?.add(t)}removeEventListener(e,t){this.eventListeners[e]?.delete(t)}dispatchMessage(e){let t=new MessageEvent(`message`,{data:e});for(let e of this.eventListeners.message)e(t)}dispatchClose(e,n){let r=t(e,n);for(let e of this.eventListeners.close)e(r)}dispatchError(){let e=new Event(`error`);for(let t of this.eventListeners.error)t(e)}},j=class{options;bridge;busServer=null;busReady=!1;connecting=!1;constructor(e){this.options=e,this.bridge=new n}get dispatchingAuth(){return this.options.auth instanceof e?this.options.auth:void 0}createWebSocketHandler(){let e=this.bridge,t=()=>this.busReady,n=new WeakMap;return{binaryType:`arraybuffer`,open(r){if(!t()){r.close(1013,`Bus server not ready`);return}let i=new A(r);n.set(r,i),e.accept(i)},message(e,t){n.get(e)?.dispatchMessage(t)},close(e,t,r){n.get(e)?.dispatchClose(t,r),n.delete(e)}}}async connect(e,t){if(this.connecting||this.busServer)throw Error(`[BunBusServerTransport] connect() called while transport is already connected or connecting`);this.connecting=!0;try{this.busServer=await r({websocket:this.bridge,bus:e,auth:this.options.auth,loopbackName:this.options.loopbackName??`bun`}),this.busReady=!0}catch(e){throw await this.stopBusServer(`startup error`),e}finally{this.connecting=!1}}async disconnect(){await this.stopBusServer(`shutdown`),this.bridge.close()}async stopBusServer(e){this.busReady=!1,this.busServer&&=(await this.busServer.stop().catch(t=>{console.error(`[BunBusServerTransport] Failed to stop bus server during ${e}:`,t)}),null)}};function M(e){if(e.headers.get(`upgrade`)?.toLowerCase()!==`websocket`)return!1;let{pathname:t}=new URL(e.url);return t===`/bus`?!0:t===`/`&&e.headers.get(`origin`)===null}function N(e){return(t,n)=>M(t)?n.upgrade(t)?void 0:new Response(`WebSocket upgrade failed`,{status:426,headers:{Upgrade:`websocket`}}):e.fetch(t)}function ee(e){return e.port}async function P(e){let{port:t,hostname:n}=e.bunServer,r=e.createMount??(await import(`../create-static-mount-CFGo91CI.mjs`)).defaultCreateMount;return d(e.transport,t,n,{...e,createMount:r})}function F(e,t){let n=e,r=t;return{fetch(e,t){return n(e,t)},websocket:{binaryType:t.binaryType,open(e){r.open(e)},message(e,t){r.message(e,t)},close(e,t,n){r.close(e,t,n)}},activate(i){n=R(e,i),r=z(t,i)}}}function I(e){let t=[];return e.forEachActiveExtension((e,n)=>{B(n)&&t.push(n)}),t}function L(e){return Array.isArray(e)?e.flatMap(e=>L(e)):B(e)?[e]:[]}function R(e,t){return t.reduce((e,t)=>t.bun.createFetch?.(e)??e,e)}function z(e,t){return t.reduce((e,t)=>t.bun.createWebSocketHandler?.(e)??e,e)}function B(e){if(!H(e))return!1;let t=e.bun;return typeof e.name==`string`&&typeof e.displayName==`string`&&V(t)}function V(e){if(!H(e))return!1;let t=e.createFetch,n=e.createWebSocketHandler;return(t===void 0||typeof t==`function`)&&(n===void 0||typeof n==`function`)}function H(e){return typeof e==`object`&&!!e}function U(e){let t=e.timeoutMs??1e4,n=e.exit??(e=>process.exit(e)),r=!1;return async i=>{if(r)return;r=!0,console.info(`[${e.label}] ${i} received, shutting down...`);let a=setTimeout(()=>{console.error(`[${e.label}] Graceful shutdown timed out, forcing exit`),n(1)},t);try{process.env.MAKAIO_DEBUG&&console.info(`[${e.label}] Shutting down runtime...`),await e.runtime.shutdown(),process.env.MAKAIO_DEBUG&&console.info(`[${e.label}] Stopping Bun server...`),W(e.bunServer,e.label),process.env.MAKAIO_DEBUG&&console.info(`[${e.label}] Shutdown complete`),clearTimeout(a),n(0)}catch(t){W(e.bunServer,e.label),clearTimeout(a),console.error(`[${e.label}] Shutdown error:`,t),n(1)}}}function W(e,t){let n=e.stop?.(!0);G(n)&&n.catch(e=>{console.warn(`[${t}] Bun server stop failed during shutdown:`,e)})}function G(e){return typeof e==`object`&&!!e&&typeof e.catch==`function`}const K=/^(?=.{1,253}$)(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/;function q(e){let t=e.env??process.env,n=e.defaultPort??3e3,r=e.defaultHost??`0.0.0.0`;return{port:J(t.PORT,n,e),host:Y(t.HOST,r,e)}}function J(e,t,n){let r=e?.trim(),i=r&&/^\d+$/.test(r)?Number.parseInt(r,10):NaN;return Number.isInteger(i)&&i>=1&&i<=65535?i:e===void 0?t:Z(`Invalid PORT: ${e}`,t,n)}function Y(e,t,n){let r=e?.trim();return r&&X(r)?r:e===void 0?t:Q(`Invalid HOST: ${e}`,t,n)}function X(e){return k(e)!==0||e===`localhost`||K.test(e)}function Z(e,t,n){return $(e,String(t),n),t}function Q(e,t,n){return $(e,t,n),t}function $(e,t,n){if((n.invalid??`throw`)===`throw`)throw Error(e);console.warn(`[${n.appName}] ${e}, falling back to ${t}`)}export{j as BunBusServerTransportProvider,i as ExplicitDescriptorDiscovery,a as FileConfigStorage,o as FileRegistryCache,s as FilesystemDescriptorDiscovery,c as NodeCredentialProvider,l as StoredCredentialProvider,P as bootMakaioRuntime,u as bootMakaioRuntimeCore,f as bridgeExtensionBrowserEntries,I as collectActiveBunHostPackages,R as composeBunHostFetch,z as composeBunHostWebSocket,F as createBunHostRouter,N as createBunRouteGraphFetch,U as createGracefulShutdown,p as createHonoRouteGraph,m as createHttpRouteGraphBuilder,h as entrypointStem,g as isCliContributionLike,_ as isMakaioExtensionLike,v as isMissingOptionalRuntimePackage,y as isWithinDirectory,b as loadExtensions,x as loadOrCreateMachineIdentity,S as machineKeysExist,L as normalizeBunHostPackages,q as readBunServerEnv,C as registerAdapterNameResolver,w as resolveConventionEntrypoint,ee as resolveListeningPort,T as resolveStaticModelRegistryPath,E as runMigrations,D as tryImport,O as validateMachineKeys};

package/dist/runtime-node/bus/runtime/namespace.d.mts

@@ -0,0 +1,61 @@
+import * as _$zod from "zod";
+import * as _$_makaio_core0 from "@makaio/framework/core";
+import * as _$zod_v4_core0 from "zod/v4/core";
+
+//#region runtimes/node/src/bus/runtime/namespace.d.ts
+/**
+ * Runtime namespace for bus operations.
+ *
+ * Provides typed subjects for querying runtime-specific resources.
+ * Registered globally so lifecycle files can import subjects.
+ */
+declare const RuntimeNamespace: _$_makaio_core0.BusNamespaceDefinition<"runtime", {
+  database: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      db: _$zod.ZodUnknown;
+    }, _$zod_v4_core0.$strip>;
+  };
+  machineIdentity: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      identity: _$zod.ZodUnknown;
+    }, _$zod_v4_core0.$strip>;
+  };
+  busPort: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      port: _$zod.ZodNumber;
+    }, _$zod_v4_core0.$strip>;
+  };
+}>;
+/**
+ * Runtime subjects for type-safe bus operations.
+ *
+ * Subjects:
+ * - database: Query for Drizzle database handle
+ * - machineIdentity: Query for machine identity
+ * - busPort: Query for the bus server WebSocket port
+ */
+declare const RuntimeSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSubjectDefinitions<"runtime", {
+  database: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      db: _$zod.ZodUnknown;
+    }, _$zod_v4_core0.$strip>;
+  };
+  machineIdentity: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      identity: _$zod.ZodUnknown;
+    }, _$zod_v4_core0.$strip>;
+  };
+  busPort: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      port: _$zod.ZodNumber;
+    }, _$zod_v4_core0.$strip>;
+  };
+}>, "runtime">;
+//#endregion
+export { RuntimeNamespace, RuntimeSubjects };

package/dist/runtime-node/bus/runtime/namespace.mjs

@@ -0,0 +1 @@
+import{RuntimeSchemas as e}from"./schemas.mjs";import{createBusNamespace as t}from"@makaio/framework/core";const n=t(`runtime`,e),r=n.subjects;export{n as RuntimeNamespace,r as RuntimeSubjects};

package/dist/runtime-node/bus/runtime/schemas.d.mts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+
+//#region runtimes/node/src/bus/runtime/schemas.d.ts
+/**
+ * Runtime resource schemas.
+ *
+ * Provides bus subjects for querying runtime-specific resources
+ * (database, machine identity) that vary by runtime environment.
+ * NodeRuntime registers providers; memory-only runtimes leave them unregistered.
+ */
+declare const RuntimeSchemas: {
+  /**
+   * Query for database handle.
+   * Registered by NodeRuntime. Absent in memory-only runtimes.
+   *
+   * Subject: `runtime.database`
+   * Type: Request (RPC)
+   */
+  database: {
+    request: z.ZodObject<{}, z.core.$strip>;
+    response: z.ZodObject<{
+      db: z.ZodUnknown;
+    }, z.core.$strip>;
+  };
+  /**
+   * Query for machine identity (E2E encryption keys).
+   * Registered by NodeRuntime. Absent in memory-only runtimes.
+   *
+   * Subject: `runtime.machineIdentity`
+   * Type: Request (RPC)
+   */
+  machineIdentity: {
+    request: z.ZodObject<{}, z.core.$strip>;
+    response: z.ZodObject<{
+      identity: z.ZodUnknown;
+    }, z.core.$strip>;
+  };
+  /**
+   * Query for the bus server WebSocket port.
+   * Registered at the app entry point (Electron main, CLI) where the bus
+   * server is created. Absent in memory-only runtimes.
+   *
+   * Subject: `runtime.busPort`
+   * Type: Request (RPC)
+   */
+  busPort: {
+    request: z.ZodObject<{}, z.core.$strip>;
+    response: z.ZodObject<{
+      port: z.ZodNumber;
+    }, z.core.$strip>;
+  };
+};
+//#endregion
+export { RuntimeSchemas };

package/dist/runtime-node/bus/runtime/schemas.mjs

@@ -0,0 +1 @@
+import{z as e}from"zod";const t={database:{request:e.object({}),response:e.object({db:e.unknown()})},machineIdentity:{request:e.object({}),response:e.object({identity:e.unknown()})},busPort:{request:e.object({}),response:e.object({port:e.number()})}};export{t as RuntimeSchemas};

package/dist/runtime-node/extension-discovery.d.mts

@@ -0,0 +1,2 @@
+import { a as FilesystemDescriptorDiscovery, i as ExtensionEntrypointModule, n as ExplicitDescriptorDiscovery, o as FilesystemDescriptorDiscoveryOptions, r as ExtensionDiscovery, s as MergedDescriptorDiscovery, t as DiscoveredExtension } from "../extension-discovery-CkV_VRdJ.mjs";
+export { DiscoveredExtension, ExplicitDescriptorDiscovery, ExtensionDiscovery, ExtensionEntrypointModule, FilesystemDescriptorDiscovery, FilesystemDescriptorDiscoveryOptions, MergedDescriptorDiscovery };

package/dist/runtime-node/extension-discovery.mjs

@@ -0,0 +1 @@
+import*as e from"node:fs/promises";import*as t from"node:path";import{glob as n}from"glob";import{parseExtensionDescriptor as r}from"@makaio/framework/contracts";var i=class{localNodeModulesDir;extensionsDir;nodeModulesDir;constructor(e,n){this.localNodeModulesDir=n?.localNodeModulesDir??t.join(e??process.cwd(),`node_modules`),this.extensionsDir=n?.extensionsDir??!1,this.nodeModulesDir=n?.nodeModulesDir??!1}async discover(){let[e,t,n]=await Promise.all([this.scanLocal(),this.scanInstalled(),this.scanGlobalNpm()]);return this.deduplicate(e,t,n)}async scanLocal(){if(this.localNodeModulesDir===!1)return[];let e=[t.join(this.localNodeModulesDir,`*/descriptor.json`),t.join(this.localNodeModulesDir,`@*/*/descriptor.json`)];return this.scanPatterns(e,`local`)}async scanInstalled(){if(this.extensionsDir===!1)return[];let e=[t.join(this.extensionsDir,`*/descriptor.json`),t.join(this.extensionsDir,`@*/*/descriptor.json`)];return this.scanPatterns(e,`installed`)}async scanGlobalNpm(){if(this.nodeModulesDir===!1)return[];let e=[t.join(this.nodeModulesDir,`*/descriptor.json`),t.join(this.nodeModulesDir,`@*/*/descriptor.json`)];return this.scanPatterns(e,`global-npm`)}async scanPatterns(i,a){let o=[];for(let s of i){let i=s.split(t.sep).join(`/`),c;try{c=await n(i,{windowsPathsNoEscape:!0})}catch(e){console.warn(`[extensions] Skipping scan for pattern ${i}:`,e instanceof Error?e.message:e);continue}for(let n of c)try{let i=await e.readFile(n,`utf-8`),s=r(JSON.parse(i)),c=t.dirname(n);o.push({descriptor:s,extensionPath:c,source:a})}catch(e){console.warn(`[extensions] Skipping invalid descriptor at ${n}:`,e instanceof Error?e.message:e)}}return o}deduplicate(...e){return s(e)}},a=class{extensions;constructor(e){this.extensions=e}async discover(){return this.extensions}},o=class{discoveries;constructor(e){this.discoveries=e}async discover(){return s(await Promise.all(this.discoveries.map(e=>e.discover())))}};function s(e){let t=new Map;for(let n of e)for(let e of n)t.has(e.descriptor.name)||t.set(e.descriptor.name,e);return[...t.values()]}export{a as ExplicitDescriptorDiscovery,i as FilesystemDescriptorDiscovery,o as MergedDescriptorDiscovery};

package/dist/runtime-node/extension-validation.d.mts

@@ -0,0 +1,2 @@
+import { a as isMakaioExtensionLike, c as resolveConventionEntrypoint, i as isCliContributionLike, o as isWithinDirectory, r as entrypointStem } from "../load-extensions-D9nbDIiW.mjs";
+export { entrypointStem, isCliContributionLike, isMakaioExtensionLike, isWithinDirectory, resolveConventionEntrypoint };

package/dist/runtime-node/extension-validation.mjs

@@ -0,0 +1 @@
+import{a as e,c as t,n,o as r,r as i}from"../load-extensions-C-TqCwzL.mjs";export{n as entrypointStem,i as isCliContributionLike,e as isMakaioExtensionLike,r as isWithinDirectory,t as resolveConventionEntrypoint};