oxianjs 0.21.3 → 0.22.0-next.29ff900

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# oxianjs
+
+## 0.22.0
+
+### Minor Changes
+
+- Prepare the 0.22 prerelease line with a breaking removal of the unused generic
+  owner, owner-host and Postgres-owner APIs. Durable ownership moves to the
+  concrete Copilotz runtime, whose replacement implementation remains pending.
+
+  Retain worker dispatch, transports, sessions and independent Node connection
+  budgeting. Publish the existing Node-portable root and explicit subpaths, with
+  installed-package type and in-process/WebSocket proofs; remove the owner-only
+  PostgreSQL dependency and CI service.
+
+  This base version is used for merge-triggered `0.22.0-next.<mergeSHA>` builds
+  on npm's `next` tag and the same-version JSR mirror. It does not authorize a
+  stable `v0.22.0` tag or move npm's `latest` tag. See the migration and
+  retirement documentation for removed APIs, supported exports and preserved
+  conformance evidence.

package/README.md

@@ -0,0 +1,14 @@
+# Oxian for Node
+
+Fetch-native applications and streaming work over in-process or WebSocket transports.
+
+Requires Node 24 or newer. This package exports the portable root, http, hypervisor,
+protocol, providers, transport, work, worker, and adapters/node. The providers
+subpath contains only portable providers; it does not include local processes.
+
+The filesystem app factories, config loader, file router, local composition, edge,
+Deno adapter, and CLI remain available only in the Deno/JSR package during the
+Node migration. The retired owner, host, and PostgreSQL-owner APIs are not included;
+see the [retirement and migration notes](docs/owner-retirement.md).
+
+See https://github.com/AxionCompany/oxian-js for documentation.

package/docs/migration-0.22.md

@@ -0,0 +1,70 @@
+# Migrating to the 0.22 prerelease
+
+The 0.22.0 source base introduces a breaking removal of unused owner APIs.
+Successful verification on `main` publishes `0.22.0-next.<mergeSHA>` to npm's
+`next` tag and mirrors the exact same version to JSR. This is a prerelease:
+`latest` stays at 0.21.3, and no `v0.22.0` stable tag is created by this work.
+
+Use `npm install oxianjs@next` to try the new Node package. For a reproducible
+installation, pin the exact returned version. JSR users should likewise select
+the matching published next version rather than assume a stable 0.22.0 exists.
+Current source API examples use the base version; substitute that next version
+when installing from the registry.
+
+## Removed APIs
+
+The `/owner`, `/host`, and `/adapters/postgres` package entrypoints no longer
+exist. This removes `createOwner`, `createMemoryOwnerStore`, command/snapshot
+sessions, `createOwnerHost`, shard maps and the Postgres-owner store. The
+standalone implementation was unused by applications. It is not retained behind
+aliases or compatibility stubs, and importing those entrypoints now fails.
+
+A downstream experiment that still uses these APIs must remain pinned to its
+previous version or preserved checkout until its concrete replacement is ready.
+The full Git history and the behavioral migration inventory remain available;
+see [retirement evidence](owner-retirement.md). No database data is deleted or
+migrated by upgrading the package.
+
+Copilotz will own its durable command and storage runtime. That replacement,
+authenticated reverse calls, real-table group commits, recovery and deployment
+integration are not implemented by this release. Removing the library does not
+certify those guarantees or add worker-to-owner invocation to the protocol.
+
+## Retained Node surface
+
+The npm build now exposes:
+
+- `oxianjs`: the portable application, HTTP, Hypervisor, worker and work core
+- `/adapters/node`: the Node HTTP/WebSocket listener and connection budget
+- `/http`, `/hypervisor`, `/protocol`, `/transport`, `/work`, `/worker`
+- `/providers`: the portable provider contract, externally attached provider,
+  Cloud Run Jobs provider and conformance helpers
+
+Node 24 or newer is required. `ws` is the Node listener's runtime dependency;
+Postgres and its type dependency have been removed. Importing the portable root
+still does not create listeners, spawn processes or require a database.
+
+The npm `/providers` subpath excludes the Deno local-process provider. The
+Deno-bound `/app`, `/config`, `/local`, `/router`, `/edge`, `/cli`, `/bin`, and
+`/adapters/deno` remain available only in the retained JSR surface during the
+Node migration. The npm build is deliberately not advertised as full JSR parity.
+
+## Node listener migration
+
+`serve({ hypervisor })` still defaults to a 1,000-connection budget. To share a
+lower limit between listeners, import `createConnectionBudget` from
+`oxianjs/adapters/node` and pass the same value as each listener's `budget`.
+This replaces the old owner-host object for that purpose. Budget acquisition
+refuses excess upgrades with HTTP 503; socket closure releases the lease once,
+including for rejected upgrades. Closing a listener does not close an injected
+budget or the application-owned Hypervisor.
+
+## Verification
+
+The release retains Oxian's protocol, supervisor, transport, worker and
+Hypervisor suites. CI checks Node and Deno plus an installed npm tarball:
+public exports, missing retired subpaths, declaration consumption, absence of
+tests/raw TypeScript in the npm payload, and real in-process and Node WebSocket
+work dispatch. Historical owner tests remain migration evidence, not executable
+replacement coverage. Stable publication still requires its separate exact-tag
+workflow and is outside this prerelease.

package/docs/owner-retirement.md

@@ -0,0 +1,122 @@
+# Durable owner retirement: migration evidence
+
+Status: owner API retirement, 2026-10-16. This is an inventory of preserved
+requirements and historical evidence, not a replacement implementation or a
+claim that Copilotz owner conformance passes.
+
+## Release and compatibility
+
+This change prepares the 0.22.0 base for `0.22.0-next.<mergeSHA>` prereleases.
+The successful main verification workflow publishes npm `next` and the matching
+JSR version. It leaves npm `latest` at 0.21.3. No stable tag is part of this
+release. See [the migration notes](migration-0.22.md) for the removed entrypoints
+and retained transport boundary.
+
+## Boundary
+
+Oxian keeps its portable application/worker/Hypervisor, transports, dispatch,
+session fencing, admission hooks and protocol. The unused generic owner,
+owner-host and Postgres-owner API is removed. Durable command handling and
+application storage belong in the concrete Copilotz runtime. The approved
+worker-originated owner-call extension is still to be specified and built.
+There is no retained test-only owner runtime or placeholder owner API.
+
+The Node listener's connection limiter remains, independently of ownership.
+It can be shared across listeners, refuses overload, and releases leases on
+socket closure. Its active tests live beside the adapter.
+
+## Immutable recovery points
+
+- Public main before retirement:
+  `6cf55dc13834bafcfe9ef4c4067372b68982ae2f`
+  ([source](https://github.com/AxionCompany/oxian-js/tree/6cf55dc13834bafcfe9ef4c4067372b68982ae2f))
+- Preserved local owner-records work:
+  `2dfebacf3408c0e25672289ec31e7201588d6cca`, on the separate recovery branch
+  and in the transferred Git bundle. This commit is not a public release.
+- Copilotz's unpushed parallel-kernel work and uncommitted wire changes remain
+  in their original checkout. Their behavioral cases are reference material;
+  the new runtime must use Copilotz's real tables, not adopt `owner_records`.
+
+Use `git show <commit>:<path>` to recover an exact historical test. The retirement
+branch starts at public main; it neither cherry-picks nor deletes the unpublished
+owner-records commit. No existing database is modified by deleting these APIs.
+
+## Test inventory
+
+At the public-main recovery point, five files declare 46 cases:
+
+| Historical path | Cases | Disposition |
+|---|---:|---|
+| `tests/owner/owner_test.ts` | 18 | Receipt/command cases for the concrete Copilotz owner |
+| `tests/owner/sequence_test.ts` | 9 | Sequence/alarm cases for the real event log |
+| `tests/owner/remote_test.ts` | 5 | Snapshot/recovery cases for authenticated worker calls |
+| `tests/owner/postgres_test.ts` | 10 | Real-table transaction/fence cases |
+| `tests/host/host_test.ts` | 4 | Two ownership cases remain migration work; two connection-budget cases rehomed |
+
+`tests/owner/postgres_database.ts` was the test helper, not a conformance case.
+Its Mac-specific local-cluster setup and the owner-only CI database service are
+removed with the suites. The local owner-records commit adds three Postgres
+cases, bringing its historical total to 49. Removing executable tests here
+must not be reported as completion of their replacement coverage.
+
+## Behavioral cases to port
+
+The destination is tests next to Copilotz's concrete owner and storage code,
+using existing domain/event tables. The F5/F7/F9 contracts and guarantee map
+remain the acceptance bar. This checklist is evidence, not the whole plan.
+
+| Guarantee | Historical tests or fixture | Replacement requirement |
+|---|---|---|
+| Result, effects and receipt are atomic | `owner_test.ts`: “a committed command returns its result and keeps its receipt” | One fenced outer transaction on real tables |
+| Compatible replay, conflicting reuse, identity domains | “the same request returns its receipt; a different request is rejected”; “identity domains do not share receipts” | Stable logical intent, distinct incarnation/occurrence keys and separate current authority |
+| Command-local rollback and timestamp | “one failing command rolls back only itself”; “a thrown command rolls back its writes and keeps the rest of the group”; “a lease crossed inside a group fails only the later command” | A savepoint and timestamp per command; no partial effects or publication |
+| Unknown versus definitive commit outcome | “a lost commit stops the owner and the successor trusts receipts”; “a lost commit that aborted reruns each command once”; “a definitive rollback retries each command on its own” | Successor waits for server outcome; receipt recovery before preparing a different effect |
+| Outer output gate | “post-commit callbacks run only after the commit is durable”; “a failed command does not run its post-commit callback” | Results, materialization, dispatch and notifications follow the outer commit |
+| Admission and bounded queue | “admission admits 32 and recovers a receipt at capacity”; “a full queue refuses and a stopped owner reports ownership lost” | Atomic cap and bounded refusal; receipt recovery at capacity |
+| Input/result isolation | “a command runs the input that was submitted”; “changing a returned receipt does not change the recorded one”; “commands in one group keep their own results” | Caller mutation cannot change accepted intent or recorded outcome |
+| Epoch fencing | “a stale owner fails once a successor acquires the epoch”; Postgres takeover/open-transaction/assignment cases | Fence actual writes; takeover blocks behind unresolved transaction; routing alone is not authority |
+| Mixed group uncertainty | `postgres_test.ts` lost-commit fixture mixes compatible duplicate, conflicting duplicate, success and failure, under committed/aborted outcomes | Keep this matrix and add actual in-flight COMMIT uncertainty |
+| Failed transaction cleanup | Postgres failed-BEGIN/rollback case | Discard an unusable pooled connection |
+| Receipt recovery without stale mutation | `remote_test.ts`: “an old session cannot mutate after takeover and can still read receipts” | Authenticated, owner-scoped same-worker recovery; no implicit protected-value hydration |
+| Snapshot lifecycle | Remaining four `remote_test.ts` cases | Repeatable snapshot, cancellation, takeover, idle/lifetime expiry and in-flight failure; bounded sessions |
+| Gap-free event sequence | `sequence_test.ts`: “a failed command and a duplicate consume no sequence”; “a rolled-back group consumes no sequence” | Existing `events.seq` shares effects/receipts/fence commit |
+| Atomic attach and repair | “attach captures the head of its commit”; “a heartbeat head shows a dropped last update”; “a dropped push resets that observer” | Real push transport, reset and heartbeat-head repair |
+| Durable alarms | Remaining four `sequence_test.ts` cases; Postgres alarm revision/sequence takeover cases | Wake after restart, early-timer guard, transient-read retry, rollback cleanup and actual scheduler semantics |
+| Placement | `host_test.ts`: “a shard that does not own an id does not move its epoch”; “one process runs every owner assigned to it” | Named-owner routing and host-specific activation; no ownership claim from process count alone |
+| Node overload protection | Former final two `host_test.ts` cases | Active `src/adapters/node/connection-budget.test.ts`; no owner-host dependency |
+
+The three extra `2dfebac` cases assert that commit-after-rollback cannot persist
+writes; committed records survive takeover while rolled-back writes do not;
+and records are owner-isolated with bounded read-only snapshots. Preserve those
+invariants against Copilotz tables. Generic map insertion order and the
+`owner_records` schema are not requirements on domain storage.
+
+## Limits of the old evidence
+
+- Lost COMMIT responses were injected after completed commit/rollback. Killing
+  an open transaction does not exercise an owner dying during COMMIT.
+- Remote-session tests use local helpers, not authenticated worker RPC or the
+  combined worker, connection, owner and execution-attempt fences.
+- Observer tests manually acknowledge/reset; real dropped transport messages,
+  subscriber authorization and end-to-end repair remain to prove.
+- Alarm tests do not establish exact-due schedule claims, occurrence identity,
+  misfire skipping, or paused/manual-run semantics.
+- These files do not establish fresh stream allocation across attempts,
+  protected-value grants, two-phase settlement, await/resume, effect
+  reconciliation, full activation readiness, or saturated HTTP/Action progress.
+
+These missing cases remain work. Retirement neither drops them nor marks them
+passing. Durable Object activation/storage and production routing remain
+host-specific work; deleting the old library does not implement either.
+
+## Evidence that remains active in Oxian
+
+All protocol, supervisor, transport, worker and Hypervisor suites remain.
+In particular, `tests/protocol/*` and `tests/supervisor/*` retain their 95 declared
+cases for byte/sequence credit, capacity reservation, cancellation, drain,
+half-close, session generations, credential resume, durable acceptance and
+committed-versus-indeterminate dispatch. The installed npm-package proof now
+uses retained worker dispatch instead of the deleted owner/host API.
+
+No generic substring deletion of “owner” is appropriate: existing transport
+resource ownership and admission responsibilities still have their own meaning.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "oxianjs",
-  "version": "0.21.3",
-  "description": "Oxian owners and the in-process host",
+  "version": "0.22.0-next.29ff900",
+  "description": "Fetch-native applications and streaming worker dispatch",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -12,17 +12,52 @@
     "node": ">=24"
   },
   "exports": {
-    "./host": {
-      "types": "./src/host/index.d.ts",
-      "default": "./src/host/index.js"
+    ".": {
+      "types": "./src/mod.d.ts",
+      "default": "./src/mod.js"
     },
-    "./owner": {
-      "types": "./src/owner/index.d.ts",
-      "default": "./src/owner/index.js"
+    "./adapters/node": {
+      "types": "./src/adapters/node/index.d.ts",
+      "default": "./src/adapters/node/index.js"
+    },
+    "./http": {
+      "types": "./src/http/index.d.ts",
+      "default": "./src/http/index.js"
+    },
+    "./hypervisor": {
+      "types": "./src/hypervisor/index.d.ts",
+      "default": "./src/hypervisor/index.js"
+    },
+    "./protocol": {
+      "types": "./src/protocol/index.d.ts",
+      "default": "./src/protocol/index.js"
+    },
+    "./providers": {
+      "types": "./src/providers/core.d.ts",
+      "default": "./src/providers/core.js"
+    },
+    "./transport": {
+      "types": "./src/transport/index.d.ts",
+      "default": "./src/transport/index.js"
+    },
+    "./work": {
+      "types": "./src/work/index.d.ts",
+      "default": "./src/work/index.js"
+    },
+    "./worker": {
+      "types": "./src/worker/index.d.ts",
+      "default": "./src/worker/index.js"
     }
   },
+  "dependencies": {
+    "ws": "8.22.0"
+  },
   "files": [
     "src",
-    "LICENSE"
+    "docs/owner-retirement.md",
+    "docs/migration-0.22.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
   ]
 }

package/src/adapters/node/connection-budget.d.ts

@@ -0,0 +1,17 @@
+/** Maximum accepted WebSocket connections in a listener's budget. */
+export declare const CONNECTION_BUDGET = 1000;
+/** One accepted connection. Releasing it twice is harmless. */
+export type ConnectionLease = Readonly<{
+    release(): void;
+}>;
+/** May be shared by several listeners in the same process. */
+export type ConnectionBudget = Readonly<{
+    connect(): ConnectionLease;
+    snapshot(): Readonly<{
+        connections: number;
+        budget: number;
+    }>;
+    /** Refuses new connections; existing leases can still be released. */
+    close(): void;
+}>;
+export declare function createConnectionBudget(maxConnections?: number): ConnectionBudget;

package/src/adapters/node/connection-budget.js

@@ -0,0 +1,34 @@
+/** Maximum accepted WebSocket connections in a listener's budget. */
+export const CONNECTION_BUDGET = 1_000;
+export function createConnectionBudget(maxConnections = CONNECTION_BUDGET) {
+    if (!Number.isSafeInteger(maxConnections) ||
+        maxConnections < 1 ||
+        maxConnections > CONNECTION_BUDGET) {
+        throw new RangeError(`maxConnections must be from 1 to ${CONNECTION_BUDGET}`);
+    }
+    let connections = 0;
+    let closed = false;
+    return Object.freeze({
+        connect() {
+            if (closed)
+                throw new Error("connection budget is closed");
+            if (connections >= maxConnections) {
+                throw new Error("connection budget exceeded");
+            }
+            connections += 1;
+            let released = false;
+            return Object.freeze({
+                release() {
+                    if (released)
+                        return;
+                    released = true;
+                    connections -= 1;
+                },
+            });
+        },
+        snapshot: () => Object.freeze({ connections, budget: maxConnections }),
+        close() {
+            closed = true;
+        },
+    });
+}

package/src/adapters/node/index.d.ts

@@ -0,0 +1,4 @@
+export { serve } from "./server.ts";
+export type { NodeServeOptions } from "./types.ts";
+export { CONNECTION_BUDGET, createConnectionBudget, } from "./connection-budget.ts";
+export type { ConnectionBudget, ConnectionLease } from "./connection-budget.ts";

package/src/adapters/node/index.js

@@ -0,0 +1,2 @@
+export { serve } from "./server.js";
+export { CONNECTION_BUDGET, createConnectionBudget, } from "./connection-budget.js";

package/src/adapters/node/server.d.ts

@@ -0,0 +1,4 @@
+import type { HypervisorListener } from "../../hypervisor/types.ts";
+import type { NodeServeOptions } from "./types.ts";
+/** Starts a Node listener for an existing application-owned Hypervisor. */
+export declare function serve(options: NodeServeOptions): Promise<HypervisorListener>;

package/src/adapters/node/server.js

@@ -0,0 +1,178 @@
+import { createServer, } from "node:http";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { WebSocketServer } from "ws";
+import { createConnectionBudget, } from "./connection-budget.js";
+import { observeListenerSettlement } from "../../hypervisor/internal/listener.js";
+import { createHypervisorError, listenerUrl, } from "../../hypervisor/internal/primitives.js";
+import { WORKER_PROTOCOL_LIMITS } from "../../protocol/limits.js";
+import { adaptWebSocket } from "../../transport/socket.js";
+/** Starts a Node listener for an existing application-owned Hypervisor. */
+export async function serve(options) {
+    const { hypervisor, hostname = "127.0.0.1", port = 0, signal } = options;
+    const budget = options.budget ?? createConnectionBudget();
+    if (!hypervisor.snapshot().acceptingConnections) {
+        throw createHypervisorError("shutting_down", "cannot listen after Hypervisor shutdown begins");
+    }
+    signal?.throwIfAborted();
+    const selected = new WeakMap();
+    const sockets = new WebSocketServer({
+        noServer: true,
+        perMessageDeflate: false,
+        maxPayload: WORKER_PROTOCOL_LIMITS.maxDataPayloadBytes +
+            WORKER_PROTOCOL_LIMITS.maxControlFrameBytes,
+        handleProtocols: (offered, request) => {
+            const protocol = selected.get(request);
+            return protocol !== undefined && offered.has(protocol) ? protocol : false;
+        },
+    });
+    let origin = listenerUrl(hostname, port);
+    const server = createServer((request, response) => {
+        void respond(request, response);
+    });
+    async function respond(request, response) {
+        try {
+            const decision = hypervisor.prepare(toRequest(request, origin, true));
+            if (decision.kind === "upgrade") {
+                decision.cancel("upgrade_event_required");
+                await send(response, new Response("WebSocket upgrade required", { status: 400 }));
+                return;
+            }
+            await send(response, await decision.response);
+        }
+        catch {
+            if (!response.headersSent)
+                response.writeHead(500);
+            response.end();
+        }
+    }
+    server.on("upgrade", (request, socket, head) => {
+        void upgrade(request, socket, head);
+    });
+    async function upgrade(request, socket, head) {
+        if (takeConnection(budget, socket) === "refused") {
+            await reject(socket, new Response("connection budget exceeded", { status: 503 }));
+            return;
+        }
+        let cancel;
+        const failed = () => cancel?.("upgrade_closed");
+        socket.on("error", failed);
+        socket.once("close", failed);
+        try {
+            const decision = hypervisor.prepare(toRequest(request, origin, false));
+            if (decision.kind === "response") {
+                await reject(socket, await decision.response);
+                return;
+            }
+            cancel = decision.cancel;
+            selected.set(request, decision.protocol);
+            sockets.handleUpgrade(request, socket, head, (connection) => {
+                socket.removeListener("error", failed);
+                socket.removeListener("close", failed);
+                cancel = undefined;
+                try {
+                    decision.attach(adaptWebSocket(connection), decision.protocol);
+                }
+                catch {
+                    decision.cancel("connection_rejected");
+                    connection.close(4400, "connection_rejected");
+                }
+            });
+        }
+        catch {
+            cancel?.("invalid_upgrade");
+            socket.destroy();
+        }
+    }
+    sockets.on("wsClientError", (_error, socket) => {
+        socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+    });
+    const finished = Promise.withResolvers();
+    server.on("error", (error) => finished.reject(error));
+    server.once("close", () => finished.resolve());
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, hostname, () => {
+            server.removeListener("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (address === null || typeof address === "string") {
+        throw new TypeError("Hypervisor listener must use a TCP address");
+    }
+    origin = listenerUrl(address.address, address.port);
+    let closed;
+    const shutdown = () => {
+        if (closed !== undefined)
+            return closed;
+        for (const client of sockets.clients)
+            client.terminate();
+        sockets.close();
+        server.close();
+        server.closeAllConnections();
+        closed = finished.promise.catch(() => undefined);
+        return closed;
+    };
+    const listener = Object.freeze({
+        hostname: address.address,
+        port: address.port,
+        url: origin,
+        finished: finished.promise,
+        shutdown,
+    });
+    observeListenerSettlement({
+        finished: finished.promise,
+        signal,
+        close: shutdown,
+        cleanup: () => undefined,
+    });
+    return listener;
+}
+function takeConnection(budget, socket) {
+    if (budget === undefined)
+        return undefined;
+    let held;
+    try {
+        held = budget.connect();
+    }
+    catch {
+        return "refused";
+    }
+    if (socket.destroyed)
+        held.release();
+    else
+        socket.once("close", () => held.release());
+    return undefined;
+}
+function toRequest(request, origin, withBody) {
+    const headers = new Headers();
+    for (let index = 0; index < request.rawHeaders.length; index += 2) {
+        headers.append(request.rawHeaders[index], request.rawHeaders[index + 1]);
+    }
+    const hasBody = withBody && request.method !== "GET" && request.method !== "HEAD";
+    return new Request(new URL(request.url ?? "/", origin), {
+        method: request.method,
+        headers,
+        ...(hasBody
+            ? {
+                body: Readable.toWeb(request),
+                duplex: "half",
+            }
+            : {}),
+    });
+}
+async function send(target, response) {
+    target.writeHead(response.status, [...response.headers.entries()].flat());
+    if (response.body === null) {
+        target.end();
+        return;
+    }
+    await pipeline(Readable.fromWeb(response.body), target);
+}
+async function reject(socket, response) {
+    const body = Buffer.from(await response.arrayBuffer());
+    socket.write(`HTTP/1.1 ${response.status} ${response.statusText || "Rejected"}\r\n` +
+        `Connection: close\r\nContent-Length: ${body.length}\r\n\r\n`);
+    socket.end(body);
+}

package/src/adapters/node/types.d.ts

@@ -0,0 +1,7 @@
+import type { ConnectionBudget } from "./connection-budget.ts";
+import type { Hypervisor, HypervisorListenOptions } from "../../hypervisor/types.ts";
+export type NodeServeOptions = Readonly<{
+    hypervisor: Hypervisor;
+    /** Each accepted upgrade takes one connection from this shared budget. */
+    budget?: ConnectionBudget;
+}> & HypervisorListenOptions;

package/src/app/application.d.ts

@@ -0,0 +1,6 @@
+import type { Application, ApplicationOptions } from "./types.ts";
+/**
+ * Initializes one Fetch-native application instance. Route modules have
+ * already been imported and validated by the file-router factory.
+ */
+export declare function createApplication<State = undefined>(options: ApplicationOptions<State>): Promise<Application<State>>;