@absolutejs/runtime 0.0.1

package/LICENSE

@@ -0,0 +1,88 @@
+# Business Source License 1.1
+
+**Licensor:** Alex Kahn
+
+**Licensed Work:** @absolutejs/runtime (https://github.com/absolutejs/runtime)
+
+**Change Date:** May 29, 2030
+
+**Change License:** Apache License, Version 2.0
+
+---
+
+## Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, permitting limited production use.
+
+### Additional Use Grant
+
+You may use the Licensed Work in production, provided your use does not include
+any of the following:
+
+1. **Offering a Competing Service.** You may not offer the Licensed Work, or
+   any derivative or substantial portion of it, to third parties as a hosted or
+   managed service that competes with a hosted Bun runtime, multi-tenant Bun application platform, or Bun-based platform-as-a-service (including, but not limited to, services like Vercel, Render, Fly.io, Railway, Bun's own hosted offerings, or any similar deployment platform for Bun applications). This includes any
+   product whose primary value to its users is the functionality the Licensed
+   Work provides.
+
+2. **Resale or Redistribution as a Standalone Product.** You may not sell,
+   license, or distribute the Licensed Work, or any derivative or fork of it,
+   as a standalone commercial product.
+
+3. **Removal of Attribution.** Any derivative work, fork, or redistribution of
+   the Licensed Work must prominently credit AbsoluteJS and include a link to
+   the original project repository (https://github.com/absolutejs/runtime).
+
+For clarity, the following uses are expressly permitted:
+
+- Using the Licensed Work to build and operate your own applications, websites,
+  internal tools, or SaaS products (whether commercial or non-commercial), so
+  long as the Licensed Work itself is not the primary product you are selling.
+- Using the Licensed Work as a dependency in commercial software you build and
+  sell, as long as the software is not itself a competing managed service of
+  the kind described in clause 1.
+- Providing consulting, development, or professional services to clients using
+  the Licensed Work.
+- Forking and modifying the Licensed Work for your own internal use, provided
+  attribution is maintained.
+
+### Change Date and Change License
+
+On the Change Date specified above, or on such other date as the Licensor may
+specify by written notice, the Licensed Work will be made available under the
+Change License (Apache License, Version 2.0). Until the Change Date, the terms
+of this Business Source License 1.1 apply.
+
+### Trademark
+
+This license does not grant you any rights to use the "AbsoluteJS" or
+"@absolutejs" name, logo, or any related trademarks. Forks and derivative works
+must not be named or branded in a manner that suggests endorsement by or
+affiliation with AbsoluteJS or the Licensor.
+
+### Notices
+
+You must not remove or obscure any licensing, copyright, or other notices
+included in the Licensed Work.
+
+### No Warranty
+
+THE LICENSED WORK IS PROVIDED "AS IS". THE LICENSOR HEREBY DISCLAIMS ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE LICENSOR BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR
+IN CONNECTION WITH THE LICENSED WORK OR THE USE OR OTHER DEALINGS IN THE
+LICENSED WORK.
+
+---
+
+## Contact
+
+For commercial licensing inquiries or additional permissions, contact:
+
+- **Alex Kahn**
+- alexkahndev@gmail.com
+- alexkahndev.github.io

package/README.md

@@ -0,0 +1,65 @@
+# @absolutejs/runtime
+
+Multi-tenant Bun runtime substrate. Wraps `Bun.spawn` so that "run this tenant's `bun run start` inside an idle-killing, metric-emitting child process" is one function call.
+
+Built for PaaS providers and platform layers that want to host many small Bun apps under one host process. The library SB-6 surfaces between `@absolutejs/isolated-jsc` + `@absolutejs/sync` and the hosted product downstream.
+
+```ts
+import { createRuntime } from '@absolutejs/runtime';
+
+const runtime = createRuntime({
+  source: { kind: 'directory', root: '/srv/tenants' },
+  idleAfterMs: 5 * 60 * 1000,
+  maxConcurrent: 100,
+  onMetrics: (event) => prometheus.observe(event),
+  onLog: (event) => loki.write(event),
+});
+
+// First call: spawns `bun run start` in /srv/tenants/tenant-42,
+// injects PORT, waits for readiness, returns the bound port.
+const tenant = await runtime.ensure('tenant-42');
+await fetch(`http://127.0.0.1:${tenant.port}/`);
+
+// Subsequent calls reuse the running process.
+runtime.touch('tenant-42'); // bump idle clock
+
+runtime.stats(); // { running, total }
+await runtime.dispose();
+```
+
+## v0.0.1 surface
+
+| API | Purpose |
+|---|---|
+| `createRuntime(options)` | Factory. Returns a `Runtime`. |
+| `runtime.ensure(key)` | Spawn-or-reuse. Single-flight on concurrent calls to the same key. Returns `{ key, port, pid, startedAt, lastTouchedAt }`. |
+| `runtime.touch(key)` | Bump the idle clock for an active tenant. Cheap; call before/after each request. |
+| `runtime.stats()` | `{ running, total }` snapshot. |
+| `runtime.kill(key)` | Force-kill. No-op if not running. |
+| `runtime.dispose()` | Kill all + stop the sweeper. Idempotent. |
+
+### Hibernation strategy (v0.0.1)
+
+**Idle-kill at the process layer**, plus the JSC-context hibernation any tenant gets for free via `@absolutejs/isolated-jsc`'s `createHibernatingIsolatePool`. Bun has no process-level snapshot/resume primitive shipped or tracked in an open issue as of 2026-05-29; when one lands we'll add an opt-in `hibernate: 'process-snapshot'` mode and keep idle-kill as the default.
+
+The trade-off the default makes explicit: first call after idle pays a full Bun cold spawn (~50–200ms). That's worth it for the free-tier multi-tenant economics; if the wake latency matters for your workload, set `idleAfterMs: 0` and rely on `maxConcurrent`'s LRU eviction instead.
+
+### Observability hooks
+
+`onLog`, `onMetrics`, and `onTransition` are pluggable. `onLog` receives newline-split stdout/stderr from every child; `onMetrics` fires on spawn with `durationMs`; `onTransition` fires on every state change (`spawn` / `ready` / `idle-kill` / `lru-evict` / `exit`).
+
+### Pluggable spawn + readiness
+
+`spawn` and `readiness` are overrides on `createRuntime`. The default `spawn` runs `['bun', 'run', 'start']` with `PORT` injected; the default `readiness` polls `http://127.0.0.1:${port}/` every 100ms with a 30s deadline. Tests use the spawn override to bypass disk; production use is mostly the defaults.
+
+## Architectural role
+
+- **`@absolutejs/isolated-jsc`** — heap-isolated *JS contexts*. One library down: the unit the runtime hibernates is a child process, not a JSC context.
+- **`@absolutejs/sync`** — reactive engine. Independent of the runtime; consumed inside tenant processes when the tenant uses it.
+- **`@absolutejs/runtime`** — *this library*. The process-pool layer.
+- **`@absolutejs/metering`** (planned) — consumes the runtime's metrics + handlerMetrics from sync into a cost-attribution → billing-events pipeline.
+- **`@absolutejs/router`** (planned) — multi-tenant routing in front of one or more runtime instances.
+
+## License
+
+CC BY-NC 4.0 — same as the rest of the AbsoluteJS ecosystem.

package/dist/index.d.ts

@@ -0,0 +1,192 @@
+/**
+ * `@absolutejs/runtime` — multi-tenant Bun runtime substrate.
+ *
+ * Wraps Bun's `spawn` so that "run this tenant's `bun run start` inside
+ * a hibernating, metric-emitting child process" is one function call.
+ * Built for PaaS providers that want to host many small Bun apps under
+ * one host process.
+ *
+ * Architectural role: SB-6's `@absolutejs/runtime` library. Consumers
+ * include the hosted `absolutejs.ai` PaaS (eventual) and anyone else
+ * who needs the same shape. Stays decoupled from `@absolutejs/sync`
+ * and `@absolutejs/isolated-jsc` — those libraries solve different
+ * layers of the same stack.
+ *
+ * v0.0.1 hibernation strategy (per the design doc, STRATEGY-CLOUD.md
+ * §9.5): idle-kill at the process layer. Bun has no shipped
+ * process-level snapshot/resume primitive as of 2026-05-29, and no
+ * open issue tracking one. When that primitive lands we'll add an
+ * opt-in `hibernate: 'process-snapshot'` mode and keep idle-kill as
+ * the default.
+ *
+ * @example
+ * ```ts
+ * import { createRuntime } from '@absolutejs/runtime';
+ *
+ * const runtime = createRuntime({
+ *   source: { kind: 'directory', root: '/srv/tenants' },
+ *   idleAfterMs: 5 * 60 * 1000, // 5 min
+ *   maxConcurrent: 100,
+ *   onMetrics: (event) => prometheus.observe(event),
+ *   onLog: (event) => loki.write(event),
+ * });
+ *
+ * // First call: spawns `bun run start` in /srv/tenants/tenant-42,
+ * // injects PORT, waits for readiness, returns the bound port.
+ * const tenant = await runtime.ensure('tenant-42');
+ * fetch(`http://localhost:${tenant.port}/`);
+ *
+ * // Subsequent calls reuse the running process.
+ * runtime.touch('tenant-42'); // bump idle clock
+ *
+ * runtime.stats(); // { running, total }
+ * await runtime.dispose();
+ * ```
+ */
+import type { Subprocess } from "bun";
+export type TenantSource = {
+    kind: "directory";
+    root: string;
+};
+/** Identity of a single tenant process at a point in time. */
+export type Tenant = {
+    /** The key the consumer used to address this tenant. */
+    key: string;
+    /** The port the child process bound to, discovered after readiness. */
+    port: number;
+    /** OS process id. */
+    pid: number;
+    /** Wall-clock when the child was spawned. */
+    startedAt: number;
+    /** Last time the consumer marked this tenant active. */
+    lastTouchedAt: number;
+};
+export type RuntimeMetricEvent = {
+    type: "spawn";
+    key: string;
+    pid: number;
+    port: number;
+    durationMs: number;
+};
+export type RuntimeLogEvent = {
+    key: string;
+    pid: number;
+    stream: "stdout" | "stderr";
+    /** A single line of output (newline-terminated lines are split client-side). */
+    line: string;
+    at: number;
+};
+export type RuntimeTransitionEvent = {
+    type: "spawn";
+    key: string;
+    pid: number;
+    port: number;
+} | {
+    type: "ready";
+    key: string;
+    pid: number;
+    port: number;
+    durationMs: number;
+} | {
+    type: "idle-kill";
+    key: string;
+    pid: number;
+    reason: "idle-threshold";
+    idleMs: number;
+} | {
+    type: "lru-evict";
+    key: string;
+    pid: number;
+    reason: "max-concurrent";
+} | {
+    type: "exit";
+    key: string;
+    pid: number;
+    exitCode: number | null;
+};
+export type ReadinessCheck = (args: {
+    key: string;
+    port: number;
+    /** Wall-clock spawn time so the check can compute its own elapsed. */
+    startedAt: number;
+}) => Promise<boolean>;
+export type SpawnFn = (args: {
+    cwd: string;
+    env: Record<string, string>;
+    onLogLine: (event: RuntimeLogEvent) => void;
+    key: string;
+}) => Promise<Subprocess>;
+/** Options for {@link createRuntime}. */
+export type RuntimeOptions = {
+    /** Where to find tenant project directories. */
+    source: TenantSource;
+    /**
+     * Kill the child process after this many ms with no `touch()` call.
+     * Default 5 minutes. Set to `0` to disable idle-kill (only LRU and
+     * explicit `kill()` shed processes then).
+     */
+    idleAfterMs?: number;
+    /**
+     * Max concurrent tenant processes. When a fresh `ensure()` would
+     * push past this, the least-recently-touched process is killed
+     * first. Default 100.
+     */
+    maxConcurrent?: number;
+    /**
+     * Background sweep interval. Default 10_000 ms. The sweep runs only
+     * when the runtime is non-empty and is unrefed so the process can
+     * exit cleanly.
+     */
+    sweepIntervalMs?: number;
+    /**
+     * Override the readiness check. Default: HTTP GET to
+     * `http://localhost:${port}/` with a 100ms retry loop, give up after
+     * 30s with a `Tenant readiness timed out` error.
+     */
+    readiness?: ReadinessCheck;
+    /**
+     * Override how a child process is spawned. Default: `Bun.spawn` with
+     * `['bun', 'run', 'start']`, stdio piped through `onLogLine`, env
+     * carrying `PORT=${allocatedPort}` and `NODE_ENV=production`. Tests
+     * use this to inject a fixture without writing to disk.
+     */
+    spawn?: SpawnFn;
+    /** Operational metrics — spawn/ready durations etc. */
+    onMetrics?: (event: RuntimeMetricEvent) => void;
+    /** stdout/stderr stream. Bounded internally; backpressure to the host. */
+    onLog?: (event: RuntimeLogEvent) => void;
+    /** Lifecycle events — spawn/ready/idle-kill/lru-evict/exit. */
+    onTransition?: (event: RuntimeTransitionEvent) => void;
+    /**
+     * Command to run when spawning. Default `['bun', 'run', 'start']`.
+     * Tests use this to point at a fixture script.
+     */
+    command?: readonly string[];
+};
+export type RuntimeStats = {
+    running: number;
+    total: number;
+};
+export type Runtime = {
+    /**
+     * Resolve `key` to a running tenant. Spawns if not running, waits
+     * for readiness, returns the live {@link Tenant} including the bound
+     * `port`. Concurrent calls to the same key share a single-flight
+     * spawn — N callers don't create N processes.
+     */
+    ensure: (key: string) => Promise<Tenant>;
+    /**
+     * Mark `key` as active right now. Bumps the idle clock; the next
+     * sweep won't consider it for idle-kill until `idleAfterMs` again.
+     * Cheap; safe to call before/after each request you route to this
+     * tenant.
+     */
+    touch: (key: string) => void;
+    /** Synchronous snapshot. */
+    stats: () => RuntimeStats;
+    /** Force-kill `key`. No-op if not running. */
+    kill: (key: string) => Promise<void>;
+    /** Dispose every running child + stop the sweep. Idempotent. */
+    dispose: () => Promise<void>;
+};
+export declare const createRuntime: (options: RuntimeOptions) => Runtime;

package/dist/index.js

@@ -0,0 +1,330 @@
+// @bun
+// src/index.ts
+var defaultReadiness = async ({ port, startedAt }) => {
+  const deadline = startedAt + 30000;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/`, {
+        signal: AbortSignal.timeout(2000)
+      });
+      return true;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  throw new Error("Tenant readiness timed out after 30s");
+};
+var allocateEphemeralPort = () => {
+  const server = Bun.listen({
+    hostname: "127.0.0.1",
+    port: 0,
+    socket: {
+      data: () => {},
+      open: () => {}
+    }
+  });
+  const port = server.port;
+  server.stop(true);
+  return port;
+};
+var splitLines = (() => {
+  const remainders = new Map;
+  return (key, chunk) => {
+    const prior = remainders.get(key) ?? "";
+    const combined = prior + chunk;
+    const parts = combined.split(`
+`);
+    remainders.set(key, parts.pop() ?? "");
+    return parts;
+  };
+})();
+var defaultSpawn = async ({
+  cwd,
+  env,
+  onLogLine,
+  key
+}) => {
+  const child = Bun.spawn({
+    cmd: ["bun", "run", "start"],
+    cwd,
+    env,
+    stderr: "pipe",
+    stdout: "pipe"
+  });
+  const readStream = (stream, label) => {
+    if (stream === undefined || stream === null)
+      return;
+    (async () => {
+      const reader = stream.getReader();
+      const decoder = new TextDecoder;
+      const splitKey = `${child.pid}:${label}`;
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done)
+            break;
+          const text = decoder.decode(value, { stream: true });
+          for (const line of splitLines(splitKey, text)) {
+            onLogLine({
+              at: Date.now(),
+              key,
+              line,
+              pid: child.pid,
+              stream: label
+            });
+          }
+        }
+      } catch {}
+    })();
+  };
+  readStream(child.stdout, "stdout");
+  readStream(child.stderr, "stderr");
+  return child;
+};
+var createRuntime = (options) => {
+  const source = options.source;
+  const idleAfterMs = options.idleAfterMs ?? 5 * 60 * 1000;
+  const maxConcurrent = options.maxConcurrent ?? 100;
+  const sweepIntervalMs = options.sweepIntervalMs ?? 1e4;
+  const readiness = options.readiness ?? defaultReadiness;
+  const spawn = options.spawn ?? defaultSpawn;
+  const onMetrics = options.onMetrics;
+  const onLog = options.onLog;
+  const onTransition = options.onTransition;
+  const entries = new Map;
+  let sweepTimer;
+  let disposed = false;
+  const emitMetric = (event) => {
+    if (onMetrics === undefined)
+      return;
+    try {
+      onMetrics(event);
+    } catch {}
+  };
+  const emitTransition = (event) => {
+    if (onTransition === undefined)
+      return;
+    try {
+      onTransition(event);
+    } catch {}
+  };
+  const emitLog = (event) => {
+    if (onLog === undefined)
+      return;
+    try {
+      onLog(event);
+    } catch {}
+  };
+  const tenantCwd = (key) => {
+    if (source.kind === "directory") {
+      return `${source.root}/${key}`;
+    }
+    throw new Error(`Unsupported tenant source kind: ${source.kind}`);
+  };
+  const killChild = async (entry) => {
+    const child = entry.child;
+    if (child === null)
+      return;
+    try {
+      child.kill();
+    } catch {}
+    try {
+      await child.exited;
+    } catch {}
+  };
+  const removeEntry = async (key, entry) => {
+    entries.delete(key);
+    await killChild(entry);
+  };
+  const startSweepIfNeeded = () => {
+    if (sweepTimer !== undefined || disposed)
+      return;
+    sweepTimer = setInterval(() => {
+      if (disposed)
+        return;
+      const now = Date.now();
+      for (const [key, entry] of entries) {
+        if (entry.tenant === null)
+          continue;
+        if (idleAfterMs <= 0)
+          continue;
+        const idleMs = now - entry.tenant.lastTouchedAt;
+        if (idleMs >= idleAfterMs) {
+          emitTransition({
+            idleMs,
+            key,
+            pid: entry.tenant.pid,
+            reason: "idle-threshold",
+            type: "idle-kill"
+          });
+          removeEntry(key, entry).catch(() => {});
+        }
+      }
+      if (entries.size === 0 && sweepTimer !== undefined) {
+        clearInterval(sweepTimer);
+        sweepTimer = undefined;
+      }
+    }, sweepIntervalMs);
+    if (typeof sweepTimer === "object" && sweepTimer !== null) {
+      sweepTimer.unref?.();
+    }
+  };
+  const evictLruIfNeeded = () => {
+    if (entries.size < maxConcurrent)
+      return;
+    let oldestKey;
+    let oldestEntry;
+    for (const [key, entry] of entries) {
+      if (entry.tenant === null)
+        continue;
+      if (oldestEntry === undefined || oldestEntry.tenant === null || entry.tenant.lastTouchedAt < oldestEntry.tenant.lastTouchedAt) {
+        oldestKey = key;
+        oldestEntry = entry;
+      }
+    }
+    if (oldestKey !== undefined && oldestEntry !== undefined && oldestEntry.tenant !== null) {
+      emitTransition({
+        key: oldestKey,
+        pid: oldestEntry.tenant.pid,
+        reason: "max-concurrent",
+        type: "lru-evict"
+      });
+      removeEntry(oldestKey, oldestEntry).catch(() => {});
+    }
+  };
+  const spawnFresh = async (key) => {
+    if (disposed)
+      throw new Error("runtime has been disposed");
+    evictLruIfNeeded();
+    const port = allocateEphemeralPort();
+    const startedAt = Date.now();
+    const cwd = tenantCwd(key);
+    const env = {
+      ...process.env,
+      NODE_ENV: "production",
+      PORT: String(port)
+    };
+    const child = await spawn({
+      cwd,
+      env,
+      key,
+      onLogLine: emitLog
+    });
+    emitTransition({ key, pid: child.pid, port, type: "spawn" });
+    child.exited.then((exitCode) => {
+      emitTransition({
+        exitCode: exitCode ?? null,
+        key,
+        pid: child.pid,
+        type: "exit"
+      });
+      const current = entries.get(key);
+      if (current !== undefined && current.child === child) {
+        entries.delete(key);
+      }
+    }).catch(() => {});
+    try {
+      await readiness({ key, port, startedAt });
+    } catch (error) {
+      try {
+        child.kill();
+      } catch {}
+      entries.delete(key);
+      throw error;
+    }
+    const tenant = {
+      key,
+      lastTouchedAt: Date.now(),
+      pid: child.pid,
+      port,
+      startedAt
+    };
+    const entry = entries.get(key);
+    if (entry !== undefined) {
+      entry.tenant = tenant;
+      entry.child = child;
+      entry.pending = null;
+    }
+    const durationMs = Date.now() - startedAt;
+    emitMetric({
+      durationMs,
+      key,
+      pid: child.pid,
+      port,
+      type: "spawn"
+    });
+    emitTransition({
+      durationMs,
+      key,
+      pid: child.pid,
+      port,
+      type: "ready"
+    });
+    startSweepIfNeeded();
+    return tenant;
+  };
+  return {
+    async ensure(key) {
+      if (disposed)
+        throw new Error("runtime has been disposed");
+      const existing = entries.get(key);
+      if (existing !== undefined) {
+        if (existing.tenant !== null) {
+          existing.tenant.lastTouchedAt = Date.now();
+          return existing.tenant;
+        }
+        if (existing.pending !== null) {
+          return existing.pending;
+        }
+      }
+      const fresh = {
+        child: null,
+        key,
+        pending: null,
+        tenant: null
+      };
+      const promise = spawnFresh(key);
+      fresh.pending = promise;
+      entries.set(key, fresh);
+      return promise;
+    },
+    touch(key) {
+      const entry = entries.get(key);
+      if (entry === undefined || entry.tenant === null)
+        return;
+      entry.tenant.lastTouchedAt = Date.now();
+    },
+    stats() {
+      let running = 0;
+      for (const entry of entries.values()) {
+        if (entry.tenant !== null)
+          running += 1;
+      }
+      return { running, total: entries.size };
+    },
+    async kill(key) {
+      const entry = entries.get(key);
+      if (entry === undefined)
+        return;
+      await removeEntry(key, entry);
+    },
+    async dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      if (sweepTimer !== undefined) {
+        clearInterval(sweepTimer);
+        sweepTimer = undefined;
+      }
+      const snapshot = [...entries.values()];
+      entries.clear();
+      await Promise.all(snapshot.map((entry) => killChild(entry)));
+    }
+  };
+};
+export {
+  createRuntime
+};
+
+//# debugId=950681D1A6FFFC5D64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": [
+    "/**\n * `@absolutejs/runtime` — multi-tenant Bun runtime substrate.\n *\n * Wraps Bun's `spawn` so that \"run this tenant's `bun run start` inside\n * a hibernating, metric-emitting child process\" is one function call.\n * Built for PaaS providers that want to host many small Bun apps under\n * one host process.\n *\n * Architectural role: SB-6's `@absolutejs/runtime` library. Consumers\n * include the hosted `absolutejs.ai` PaaS (eventual) and anyone else\n * who needs the same shape. Stays decoupled from `@absolutejs/sync`\n * and `@absolutejs/isolated-jsc` — those libraries solve different\n * layers of the same stack.\n *\n * v0.0.1 hibernation strategy (per the design doc, STRATEGY-CLOUD.md\n * §9.5): idle-kill at the process layer. Bun has no shipped\n * process-level snapshot/resume primitive as of 2026-05-29, and no\n * open issue tracking one. When that primitive lands we'll add an\n * opt-in `hibernate: 'process-snapshot'` mode and keep idle-kill as\n * the default.\n *\n * @example\n * ```ts\n * import { createRuntime } from '@absolutejs/runtime';\n *\n * const runtime = createRuntime({\n *   source: { kind: 'directory', root: '/srv/tenants' },\n *   idleAfterMs: 5 * 60 * 1000, // 5 min\n *   maxConcurrent: 100,\n *   onMetrics: (event) => prometheus.observe(event),\n *   onLog: (event) => loki.write(event),\n * });\n *\n * // First call: spawns `bun run start` in /srv/tenants/tenant-42,\n * // injects PORT, waits for readiness, returns the bound port.\n * const tenant = await runtime.ensure('tenant-42');\n * fetch(`http://localhost:${tenant.port}/`);\n *\n * // Subsequent calls reuse the running process.\n * runtime.touch('tenant-42'); // bump idle clock\n *\n * runtime.stats(); // { running, total }\n * await runtime.dispose();\n * ```\n */\n\nimport type { Subprocess } from \"bun\";\n\nexport type TenantSource =\n  | { kind: \"directory\"; root: string }\n  // Future: { kind: 's3'; bucket: string; prefix: string };\n  // Future: { kind: 'git'; remote: string };\n  ;\n\n/** Identity of a single tenant process at a point in time. */\nexport type Tenant = {\n  /** The key the consumer used to address this tenant. */\n  key: string;\n  /** The port the child process bound to, discovered after readiness. */\n  port: number;\n  /** OS process id. */\n  pid: number;\n  /** Wall-clock when the child was spawned. */\n  startedAt: number;\n  /** Last time the consumer marked this tenant active. */\n  lastTouchedAt: number;\n};\n\nexport type RuntimeMetricEvent = {\n  type: \"spawn\";\n  key: string;\n  pid: number;\n  port: number;\n  durationMs: number;\n};\n// Future: cpu / memory observation events emitted by the sweeper.\n\nexport type RuntimeLogEvent = {\n  key: string;\n  pid: number;\n  stream: \"stdout\" | \"stderr\";\n  /** A single line of output (newline-terminated lines are split client-side). */\n  line: string;\n  at: number;\n};\n\nexport type RuntimeTransitionEvent =\n  | { type: \"spawn\"; key: string; pid: number; port: number }\n  | { type: \"ready\"; key: string; pid: number; port: number; durationMs: number }\n  | {\n      type: \"idle-kill\";\n      key: string;\n      pid: number;\n      reason: \"idle-threshold\";\n      idleMs: number;\n    }\n  | { type: \"lru-evict\"; key: string; pid: number; reason: \"max-concurrent\" }\n  | { type: \"exit\"; key: string; pid: number; exitCode: number | null };\n\nexport type ReadinessCheck = (args: {\n  key: string;\n  port: number;\n  /** Wall-clock spawn time so the check can compute its own elapsed. */\n  startedAt: number;\n}) => Promise<boolean>;\n\nexport type SpawnFn = (args: {\n  cwd: string;\n  env: Record<string, string>;\n  onLogLine: (event: RuntimeLogEvent) => void;\n  key: string;\n}) => Promise<Subprocess>;\n\n/** Options for {@link createRuntime}. */\nexport type RuntimeOptions = {\n  /** Where to find tenant project directories. */\n  source: TenantSource;\n  /**\n   * Kill the child process after this many ms with no `touch()` call.\n   * Default 5 minutes. Set to `0` to disable idle-kill (only LRU and\n   * explicit `kill()` shed processes then).\n   */\n  idleAfterMs?: number;\n  /**\n   * Max concurrent tenant processes. When a fresh `ensure()` would\n   * push past this, the least-recently-touched process is killed\n   * first. Default 100.\n   */\n  maxConcurrent?: number;\n  /**\n   * Background sweep interval. Default 10_000 ms. The sweep runs only\n   * when the runtime is non-empty and is unrefed so the process can\n   * exit cleanly.\n   */\n  sweepIntervalMs?: number;\n  /**\n   * Override the readiness check. Default: HTTP GET to\n   * `http://localhost:${port}/` with a 100ms retry loop, give up after\n   * 30s with a `Tenant readiness timed out` error.\n   */\n  readiness?: ReadinessCheck;\n  /**\n   * Override how a child process is spawned. Default: `Bun.spawn` with\n   * `['bun', 'run', 'start']`, stdio piped through `onLogLine`, env\n   * carrying `PORT=${allocatedPort}` and `NODE_ENV=production`. Tests\n   * use this to inject a fixture without writing to disk.\n   */\n  spawn?: SpawnFn;\n  /** Operational metrics — spawn/ready durations etc. */\n  onMetrics?: (event: RuntimeMetricEvent) => void;\n  /** stdout/stderr stream. Bounded internally; backpressure to the host. */\n  onLog?: (event: RuntimeLogEvent) => void;\n  /** Lifecycle events — spawn/ready/idle-kill/lru-evict/exit. */\n  onTransition?: (event: RuntimeTransitionEvent) => void;\n  /**\n   * Command to run when spawning. Default `['bun', 'run', 'start']`.\n   * Tests use this to point at a fixture script.\n   */\n  command?: readonly string[];\n};\n\nexport type RuntimeStats = {\n  running: number;\n  total: number;\n};\n\nexport type Runtime = {\n  /**\n   * Resolve `key` to a running tenant. Spawns if not running, waits\n   * for readiness, returns the live {@link Tenant} including the bound\n   * `port`. Concurrent calls to the same key share a single-flight\n   * spawn — N callers don't create N processes.\n   */\n  ensure: (key: string) => Promise<Tenant>;\n  /**\n   * Mark `key` as active right now. Bumps the idle clock; the next\n   * sweep won't consider it for idle-kill until `idleAfterMs` again.\n   * Cheap; safe to call before/after each request you route to this\n   * tenant.\n   */\n  touch: (key: string) => void;\n  /** Synchronous snapshot. */\n  stats: () => RuntimeStats;\n  /** Force-kill `key`. No-op if not running. */\n  kill: (key: string) => Promise<void>;\n  /** Dispose every running child + stop the sweep. Idempotent. */\n  dispose: () => Promise<void>;\n};\n\n/* ─── internals ──────────────────────────────────────────────────────── */\n\ntype Entry = {\n  key: string;\n  /** Set while the spawn is in-flight; concurrent ensure() callers await it. */\n  pending: Promise<Tenant> | null;\n  tenant: Tenant | null;\n  child: Subprocess | null;\n};\n\nconst defaultReadiness: ReadinessCheck = async ({ port, startedAt }) => {\n  const deadline = startedAt + 30_000;\n  while (Date.now() < deadline) {\n    try {\n      const res = await fetch(`http://127.0.0.1:${port}/`, {\n        signal: AbortSignal.timeout(2_000),\n      });\n      // Any response — even 404 — means the server bound the port.\n      void res;\n      return true;\n    } catch {\n      await new Promise((resolve) => setTimeout(resolve, 100));\n    }\n  }\n  throw new Error(\"Tenant readiness timed out after 30s\");\n};\n\n/**\n * Ask the OS for a currently-free TCP port by binding 0 + closing.\n * Race window: another process can grab the port between close and\n * the child's bind. Acceptable for v0.0.1; production deployments\n * should use a coordinated port allocator (or have the child bind 0\n * and report back via stdout, which is a v0.0.2 follow-up).\n */\nconst allocateEphemeralPort = (): number => {\n  const server = Bun.listen({\n    hostname: \"127.0.0.1\",\n    port: 0,\n    socket: {\n      data: () => {},\n      open: () => {},\n    },\n  });\n  const port = server.port;\n  server.stop(true);\n  return port;\n};\n\nconst splitLines = (() => {\n  // Per-stream remainder, keyed by child pid + stream label.\n  const remainders = new Map<string, string>();\n  return (key: string, chunk: string): string[] => {\n    const prior = remainders.get(key) ?? \"\";\n    const combined = prior + chunk;\n    const parts = combined.split(\"\\n\");\n    remainders.set(key, parts.pop() ?? \"\");\n    return parts;\n  };\n})();\n\nconst defaultSpawn: SpawnFn = async ({\n  cwd,\n  env,\n  onLogLine,\n  key,\n}) => {\n  const child = Bun.spawn({\n    cmd: [\"bun\", \"run\", \"start\"],\n    cwd,\n    env,\n    stderr: \"pipe\",\n    stdout: \"pipe\",\n  });\n\n  // Stream stdout/stderr into onLogLine as newline-terminated lines.\n  const readStream = (\n    stream: ReadableStream<Uint8Array> | undefined | null,\n    label: \"stdout\" | \"stderr\",\n  ): void => {\n    if (stream === undefined || stream === null) return;\n    void (async () => {\n      const reader = stream.getReader();\n      const decoder = new TextDecoder();\n      const splitKey = `${child.pid}:${label}`;\n      try {\n        while (true) {\n          const { value, done } = await reader.read();\n          if (done) break;\n          const text = decoder.decode(value, { stream: true });\n          for (const line of splitLines(splitKey, text)) {\n            onLogLine({\n              at: Date.now(),\n              key,\n              line,\n              pid: child.pid,\n              stream: label,\n            });\n          }\n        }\n      } catch {\n        // stream errored on child exit; nothing to surface\n      }\n    })();\n  };\n  readStream(child.stdout as ReadableStream<Uint8Array> | undefined, \"stdout\");\n  readStream(child.stderr as ReadableStream<Uint8Array> | undefined, \"stderr\");\n\n  return child;\n};\n\nexport const createRuntime = (options: RuntimeOptions): Runtime => {\n  const source = options.source;\n  const idleAfterMs = options.idleAfterMs ?? 5 * 60 * 1000;\n  const maxConcurrent = options.maxConcurrent ?? 100;\n  const sweepIntervalMs = options.sweepIntervalMs ?? 10_000;\n  const readiness = options.readiness ?? defaultReadiness;\n  const spawn = options.spawn ?? defaultSpawn;\n  const onMetrics = options.onMetrics;\n  const onLog = options.onLog;\n  const onTransition = options.onTransition;\n\n  const entries = new Map<string, Entry>();\n  let sweepTimer: ReturnType<typeof setInterval> | undefined;\n  let disposed = false;\n\n  const emitMetric = (event: RuntimeMetricEvent): void => {\n    if (onMetrics === undefined) return;\n    try {\n      onMetrics(event);\n    } catch {\n      /* observational only */\n    }\n  };\n  const emitTransition = (event: RuntimeTransitionEvent): void => {\n    if (onTransition === undefined) return;\n    try {\n      onTransition(event);\n    } catch {\n      /* observational only */\n    }\n  };\n  const emitLog = (event: RuntimeLogEvent): void => {\n    if (onLog === undefined) return;\n    try {\n      onLog(event);\n    } catch {\n      /* observational only */\n    }\n  };\n\n  const tenantCwd = (key: string): string => {\n    if (source.kind === \"directory\") {\n      return `${source.root}/${key}`;\n    }\n    throw new Error(\n      `Unsupported tenant source kind: ${(source as { kind: string }).kind}`,\n    );\n  };\n\n  const killChild = async (entry: Entry): Promise<void> => {\n    const child = entry.child;\n    if (child === null) return;\n    try {\n      child.kill();\n    } catch {\n      /* already dead */\n    }\n    try {\n      await child.exited;\n    } catch {\n      /* ignore */\n    }\n  };\n\n  const removeEntry = async (key: string, entry: Entry): Promise<void> => {\n    entries.delete(key);\n    await killChild(entry);\n  };\n\n  const startSweepIfNeeded = (): void => {\n    if (sweepTimer !== undefined || disposed) return;\n    sweepTimer = setInterval(() => {\n      if (disposed) return;\n      const now = Date.now();\n      for (const [key, entry] of entries) {\n        if (entry.tenant === null) continue;\n        if (idleAfterMs <= 0) continue;\n        const idleMs = now - entry.tenant.lastTouchedAt;\n        if (idleMs >= idleAfterMs) {\n          emitTransition({\n            idleMs,\n            key,\n            pid: entry.tenant.pid,\n            reason: \"idle-threshold\",\n            type: \"idle-kill\",\n          });\n          void removeEntry(key, entry).catch(() => {});\n        }\n      }\n      if (entries.size === 0 && sweepTimer !== undefined) {\n        clearInterval(sweepTimer);\n        sweepTimer = undefined;\n      }\n    }, sweepIntervalMs);\n    if (typeof sweepTimer === \"object\" && sweepTimer !== null) {\n      (sweepTimer as { unref?: () => void }).unref?.();\n    }\n  };\n\n  const evictLruIfNeeded = (): void => {\n    if (entries.size < maxConcurrent) return;\n    let oldestKey: string | undefined;\n    let oldestEntry: Entry | undefined;\n    for (const [key, entry] of entries) {\n      if (entry.tenant === null) continue; // mid-spawn; don't evict\n      if (\n        oldestEntry === undefined ||\n        oldestEntry.tenant === null ||\n        entry.tenant.lastTouchedAt < oldestEntry.tenant.lastTouchedAt\n      ) {\n        oldestKey = key;\n        oldestEntry = entry;\n      }\n    }\n    if (oldestKey !== undefined && oldestEntry !== undefined && oldestEntry.tenant !== null) {\n      emitTransition({\n        key: oldestKey,\n        pid: oldestEntry.tenant.pid,\n        reason: \"max-concurrent\",\n        type: \"lru-evict\",\n      });\n      void removeEntry(oldestKey, oldestEntry).catch(() => {});\n    }\n  };\n\n  const spawnFresh = async (key: string): Promise<Tenant> => {\n    if (disposed) throw new Error(\"runtime has been disposed\");\n    evictLruIfNeeded();\n\n    const port = allocateEphemeralPort();\n    const startedAt = Date.now();\n    const cwd = tenantCwd(key);\n    const env: Record<string, string> = {\n      ...(process.env as Record<string, string>),\n      NODE_ENV: \"production\",\n      PORT: String(port),\n    };\n\n    const child = await spawn({\n      cwd,\n      env,\n      key,\n      onLogLine: emitLog,\n    });\n\n    emitTransition({ key, pid: child.pid, port, type: \"spawn\" });\n\n    // Reap the entry when the process exits — whether we killed it or\n    // it died on its own. Single source of truth for \"is this tenant\n    // running\": the entry's `tenant` field.\n    void child.exited\n      .then((exitCode) => {\n        emitTransition({\n          exitCode: exitCode ?? null,\n          key,\n          pid: child.pid,\n          type: \"exit\",\n        });\n        // Only delete if THIS entry is still the live one. A consumer\n        // who killed + immediately re-ensured may have replaced it.\n        const current = entries.get(key);\n        if (current !== undefined && current.child === child) {\n          entries.delete(key);\n        }\n      })\n      .catch(() => {});\n\n    try {\n      await readiness({ key, port, startedAt });\n    } catch (error) {\n      try {\n        child.kill();\n      } catch {\n        /* ignore */\n      }\n      entries.delete(key);\n      throw error;\n    }\n\n    const tenant: Tenant = {\n      key,\n      lastTouchedAt: Date.now(),\n      pid: child.pid,\n      port,\n      startedAt,\n    };\n    const entry = entries.get(key);\n    if (entry !== undefined) {\n      entry.tenant = tenant;\n      entry.child = child;\n      entry.pending = null;\n    }\n    const durationMs = Date.now() - startedAt;\n    emitMetric({\n      durationMs,\n      key,\n      pid: child.pid,\n      port,\n      type: \"spawn\",\n    });\n    emitTransition({\n      durationMs,\n      key,\n      pid: child.pid,\n      port,\n      type: \"ready\",\n    });\n    startSweepIfNeeded();\n    return tenant;\n  };\n\n  return {\n    async ensure(key) {\n      if (disposed) throw new Error(\"runtime has been disposed\");\n      const existing = entries.get(key);\n      if (existing !== undefined) {\n        if (existing.tenant !== null) {\n          existing.tenant.lastTouchedAt = Date.now();\n          return existing.tenant;\n        }\n        if (existing.pending !== null) {\n          return existing.pending;\n        }\n      }\n      const fresh: Entry = {\n        child: null,\n        key,\n        pending: null,\n        tenant: null,\n      };\n      const promise = spawnFresh(key);\n      fresh.pending = promise;\n      entries.set(key, fresh);\n      return promise;\n    },\n\n    touch(key) {\n      const entry = entries.get(key);\n      if (entry === undefined || entry.tenant === null) return;\n      entry.tenant.lastTouchedAt = Date.now();\n    },\n\n    stats() {\n      let running = 0;\n      for (const entry of entries.values()) {\n        if (entry.tenant !== null) running += 1;\n      }\n      return { running, total: entries.size };\n    },\n\n    async kill(key) {\n      const entry = entries.get(key);\n      if (entry === undefined) return;\n      await removeEntry(key, entry);\n    },\n\n    async dispose() {\n      if (disposed) return;\n      disposed = true;\n      if (sweepTimer !== undefined) {\n        clearInterval(sweepTimer);\n        sweepTimer = undefined;\n      }\n      const snapshot = [...entries.values()];\n      entries.clear();\n      await Promise.all(snapshot.map((entry) => killChild(entry)));\n    },\n  };\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "950681D1A6FFFC5D64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@absolutejs/runtime",
+  "version": "0.0.1",
+  "description": "Multi-tenant Bun runtime substrate for PaaS providers — spawn isolated child Bun processes per tenant, idle-kill, metric emit. The library SB-6 surfaces between isolated-jsc + sync and the hosted product downstream.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/absolutejs/runtime.git"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "license": "BSL-1.1",
+  "author": "Alex Kahn",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "absolutejs",
+    "bun",
+    "paas",
+    "multi-tenant",
+    "runtime",
+    "hibernation",
+    "process-pool"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && bun build src/index.ts --outdir dist --sourcemap --target=bun && tsc --project tsconfig.build.json",
+    "test": "bun test tests/",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write \"./**/*.{ts,json,md}\"",
+    "check:package": "bun run typecheck && bun run build && bun run test",
+    "release": "bun run format && bun run check:package && bun publish"
+  },
+  "peerDependencies": {
+    "bun-types": ">= 1.3.0"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.14",
+    "prettier": "3.5.3",
+    "typescript": "5.8.3"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md"]
+}