@crouton-kit/crouter 0.3.39 → 0.3.41

package/dist/hearth/control-plane/main.js

@@ -1,88 +0,0 @@
-// control-plane/main.ts — the CP process entrypoint. Generalizes the
-// wake-proxy's main.ts startup shape (load config, build server, install
-// signal handling, listen) onto the CP modules: config.ts, db.ts (open +
-// migrate, never seed), and server.ts. Run via the `hearth:control-plane`
-// package script.
-import { general } from '../../core/errors.js';
-import { loadControlPlaneConfig } from './config.js';
-import { getControlPlaneDb } from './db.js';
-import { redactSecrets } from './secrets.js';
-import { tenantSessionAuthRedactedMessage } from './session.js';
-import { createControlPlaneServer } from './server.js';
-import { controlPlaneRelay } from './relay.js';
-import { startSchedulerIngress } from './register.js';
-function redact(message) {
-    return redactSecrets(tenantSessionAuthRedactedMessage(message));
-}
-function log(level, message, details = {}) {
-    process.stderr.write(`${JSON.stringify({ level, message, details })}\n`);
-}
-async function shutdown(server, scheduler, signal) {
-    log('info', 'hearth control plane shutting down', { signal });
-    scheduler.stop();
-    server.closeIdleConnections?.();
-    server.closeAllConnections?.();
-    await new Promise((resolve) => {
-        server.close(() => resolve());
-    });
-    process.exit(0);
-}
-async function main() {
-    const config = loadControlPlaneConfig();
-    // Opens (or reuses) the CP db and runs the schema migration gate only —
-    // no row is ever written here. The control plane registers no homes at
-    // startup; `home` rows are created by the provisioner (P3.2) via
-    // `createHome`, not by this process.
-    const db = getControlPlaneDb();
-    const server = createControlPlaneServer(config, { db, relay: controlPlaneRelay });
-    // Start the always-on cron scan loop. Webhook ingress is mounted inside the
-    // server route tree (register.ts); the scheduler is the one background loop
-    // that needs an explicit start/stop handle.
-    const scheduler = startSchedulerIngress();
-    let shuttingDown = false;
-    const beginShutdown = (signal) => {
-        if (shuttingDown)
-            return;
-        shuttingDown = true;
-        void shutdown(server, scheduler, signal).catch((error) => {
-            const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
-            log('error', 'hearth control plane shutdown failed', { error: redact(message) });
-            process.exit(1);
-        });
-    };
-    process.on('SIGINT', () => beginShutdown('SIGINT'));
-    process.on('SIGTERM', () => beginShutdown('SIGTERM'));
-    process.on('uncaughtException', (error) => {
-        log('error', 'hearth control plane uncaught exception', { error: redact(error instanceof Error ? (error.stack ?? error.message) : String(error)) });
-        process.exit(1);
-    });
-    process.on('unhandledRejection', (reason) => {
-        log('error', 'hearth control plane unhandled rejection', { error: redact(reason instanceof Error ? (reason.stack ?? reason.message) : String(reason)) });
-        process.exit(1);
-    });
-    await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(config.port, config.host, () => {
-            log('info', 'hearth control plane listening', {
-                host: config.host,
-                port: config.port,
-                publicOrigin: config.publicOrigin,
-                cookieSecure: config.cookieSecure,
-                wakeTimeoutMs: config.wakeTimeoutMs,
-                readyTimeoutMs: config.readyTimeoutMs,
-            });
-            resolve();
-        });
-    }).catch((error) => {
-        throw general(`hearth control plane failed to bind ${config.host}:${config.port}`, {
-            host: config.host,
-            port: config.port,
-            error: error instanceof Error ? error.message : String(error),
-        });
-    });
-}
-void main().catch((error) => {
-    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
-    log('error', 'hearth control plane failed to start', { error: redact(message) });
-    process.exit(1);
-});

package/dist/hearth/control-plane/node-message.d.ts

@@ -1,31 +0,0 @@
-import { type HomeBackend } from '../../core/hearth/provider.js';
-import type { M0Config } from '../../core/hearth/types.js';
-import { getHomeById } from './registry.js';
-import type { HomeId } from './types.js';
-import { ensureAwake } from './wake.js';
-export type NodeMessageTier = 'critical' | 'urgent' | 'normal' | 'deferred';
-/** Indirection seam so a smoke script can fake `ensureAwake`/the registry/the
- *  provider backend without a real DB/provider (mirrors `wake.ts`'s
- *  `wakeInternals`). Production code never reassigns these. */
-export declare const nodeMessageInternals: {
-    ensureAwake: typeof ensureAwake;
-    getHomeById: typeof getHomeById;
-    getHomeBackend: (config: M0Config) => HomeBackend;
-    loadM0Config: () => M0Config;
-};
-/**
- * Wake `home_id` then deliver `body` to its home agent by running
- * `crtr node msg --to <home_agent_target> --tier <tier>` in-guest, through
- * the provider exec stdin seam (P2.6) — `body` is the exec `stdin`, never
- * part of `argv`/command text.
- *
- * Exec happens only AFTER `ensureAwake` resolves (R-TRIG-1), so the in-guest
- * broker + inbox watcher exist to receive it. `home_agent_target` is read
- * fresh from the registry both before and after the wake and asserted equal
- * — a provider recreate during `ensureAwake` may refresh
- * `provider_sandbox_id`/`preview_endpoint`, but the target node id is stable
- * across recreate (R-WAKE-6) and this primitive refuses to deliver if that
- * invariant is ever violated. The sandbox id used for exec is read
- * POST-wake, since a recreate makes the pre-wake sandbox id stale.
- */
-export declare function wakeAndExecNodeMessage(home_id: HomeId, body: string, tier: string): Promise<void>;

package/dist/hearth/control-plane/node-message.js

@@ -1,98 +0,0 @@
-// control-plane/node-message.ts — P4.4 lower-level node-message exec primitive.
-//
-// `wakeAndExecNodeMessage(home_id, body, tier)`: `ensureAwake(home_id)`
-// (wake.ts, T3.1) FIRST, then run `crtr node msg --to <home_agent_target>
-// --tier <tier>` in-guest through the P2.6 stdin-capable provider exec seam
-// (`HomeBackend.exec`, provider.ts) — `body` travels on stdin (the `msg`
-// command's body is positional-or-stdin; this primitive always uses stdin),
-// never as a positional argv element, shell-interpolated command string,
-// heredoc, or base64 blob. The ONLY things passed as argv tokens are the
-// static command words, `--to`/`--tier` flags, the resolved
-// `home_agent_target`, and the whitelisted tier — never the body.
-//
-// This is the LOWER-LEVEL primitive only (master plan P4.4): no envelope
-// construction, no ACL, no rate-limit, no audit. Those are P5's
-// `triggers/deliver.ts` chokepoint (P5.3) — it authorizes, audits, and calls
-// THIS primitive with the serialized envelope on stdin. The CP never writes
-// a home's inbox file directly; this primitive (via the in-guest `crtr`
-// CLI's own inbox-append) is the only path to it, and scheduler/ingress must
-// call this — never provider exec directly.
-import { general } from '../../core/errors.js';
-import { loadM0Config } from '../../core/hearth/config.js';
-import { getHomeBackend } from '../../core/hearth/provider.js';
-import { getHomeById } from './registry.js';
-import { ensureAwake } from './wake.js';
-const TIERS = ['critical', 'urgent', 'normal', 'deferred'];
-/** Reject anything outside the whitelist BEFORE any wake/exec is attempted —
- *  an invalid tier never reaches the provider, let alone a home. */
-function requireTier(tier) {
-    if (TIERS.includes(tier))
-        return tier;
-    throw general(`invalid node-message tier: ${tier}`, { tier, allowed: TIERS });
-}
-function requireHomeField(value, field, home_id) {
-    if (value === null || value === undefined || (typeof value === 'string' && value.trim() === '')) {
-        throw general(`home ${home_id} is missing ${field} — cannot deliver node message`, { home_id, field });
-    }
-    return value;
-}
-/** Indirection seam so a smoke script can fake `ensureAwake`/the registry/the
- *  provider backend without a real DB/provider (mirrors `wake.ts`'s
- *  `wakeInternals`). Production code never reassigns these. */
-export const nodeMessageInternals = {
-    ensureAwake,
-    getHomeById,
-    getHomeBackend: (config) => getHomeBackend(config),
-    loadM0Config: () => loadM0Config(),
-};
-function readHome(home_id) {
-    const home = nodeMessageInternals.getHomeById(home_id);
-    if (home === null)
-        throw general(`home not found: ${home_id}`, { home_id });
-    return home;
-}
-/**
- * Wake `home_id` then deliver `body` to its home agent by running
- * `crtr node msg --to <home_agent_target> --tier <tier>` in-guest, through
- * the provider exec stdin seam (P2.6) — `body` is the exec `stdin`, never
- * part of `argv`/command text.
- *
- * Exec happens only AFTER `ensureAwake` resolves (R-TRIG-1), so the in-guest
- * broker + inbox watcher exist to receive it. `home_agent_target` is read
- * fresh from the registry both before and after the wake and asserted equal
- * — a provider recreate during `ensureAwake` may refresh
- * `provider_sandbox_id`/`preview_endpoint`, but the target node id is stable
- * across recreate (R-WAKE-6) and this primitive refuses to deliver if that
- * invariant is ever violated. The sandbox id used for exec is read
- * POST-wake, since a recreate makes the pre-wake sandbox id stale.
- */
-export async function wakeAndExecNodeMessage(home_id, body, tier) {
-    const validTier = requireTier(tier);
-    const before = readHome(home_id);
-    const target = requireHomeField(before.home_agent_target, 'home_agent_target', home_id);
-    await nodeMessageInternals.ensureAwake(home_id);
-    const after = readHome(home_id);
-    if (after.home_agent_target !== target) {
-        throw general(`home_agent_target changed during wake for home ${home_id} — refusing to deliver`, {
-            home_id,
-            before: target,
-            after: after.home_agent_target,
-        });
-    }
-    const sandboxId = requireHomeField(after.provider_sandbox_id, 'provider_sandbox_id', home_id);
-    const backend = nodeMessageInternals.getHomeBackend(nodeMessageInternals.loadM0Config());
-    // Static argv only: command words, the `--to`/`--tier` flags, the resolved
-    // target, and the whitelisted tier. `body` is carried on `stdin` — never
-    // appended here.
-    const result = await backend.exec(sandboxId, {
-        argv: ['crtr', 'node', 'msg', '--to', target, '--tier', validTier],
-        stdin: body,
-    });
-    if (result.exitCode !== 0) {
-        throw general(`node-message exec failed for home ${home_id} (exit ${String(result.exitCode)})`, {
-            home_id,
-            exitCode: result.exitCode,
-            stderr: result.stderr,
-        });
-    }
-}

package/dist/hearth/control-plane/register.d.ts

@@ -1,15 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { type SchedulerLoopHandle } from './scheduler/scan-loop.js';
-/** True for `POST /webhook/:routing_key` (the only ingress method/shape). A
- *  non-POST on a `/webhook/*` path is reported by the caller as 405; a
- *  malformed key is handled as 404 inside `handleWebhook`. */
-export declare function isWebhookRequest(method: string | undefined, pathname: string): boolean;
-/** True when the path is under `/webhook/` regardless of method — lets the CP
- *  server answer a wrong-method request on the webhook lane with 405 rather
- *  than falling through to 404. */
-export declare function isWebhookPath(pathname: string): boolean;
-/** Dispatch a webhook request to the ingress handler with production deps. */
-export declare function handleWebhookRequest(req: IncomingMessage, res: ServerResponse): Promise<void>;
-/** Start the cron scan loop. Returns a handle whose `stop()` clears the loop
- *  timer — call it from CP shutdown. */
-export declare function startSchedulerIngress(): SchedulerLoopHandle;

package/dist/hearth/control-plane/register.js

@@ -1,34 +0,0 @@
-// control-plane/register.ts — the single wiring entrypoint for the scheduler +
-// webhook ingress slice (master plan P5.6). The CP `server.ts` and `main.ts`
-// each carry ONE call site into here; this module owns the wiring body.
-//
-// Two seams:
-//   - `isWebhookRequest` / `handleWebhookRequest`: the PUBLIC webhook ingress
-//     lane. It is authenticated ONLY by the per-route HMAC signature (verified
-//     inside `handleWebhook`), so it is mounted OUTSIDE the CP's session/
-//     registry gate — a browser session is neither required nor consulted.
-//   - `startSchedulerIngress`: launches the always-on cron scan loop at CP
-//     startup and returns a stop handle for graceful shutdown.
-import { extractRoutingKey, handleWebhook } from './ingress/webhook-route.js';
-import { startSchedulerLoop } from './scheduler/scan-loop.js';
-/** True for `POST /webhook/:routing_key` (the only ingress method/shape). A
- *  non-POST on a `/webhook/*` path is reported by the caller as 405; a
- *  malformed key is handled as 404 inside `handleWebhook`. */
-export function isWebhookRequest(method, pathname) {
-    return method === 'POST' && extractRoutingKey(pathname) !== null;
-}
-/** True when the path is under `/webhook/` regardless of method — lets the CP
- *  server answer a wrong-method request on the webhook lane with 405 rather
- *  than falling through to 404. */
-export function isWebhookPath(pathname) {
-    return pathname === '/webhook' || pathname.startsWith('/webhook/');
-}
-/** Dispatch a webhook request to the ingress handler with production deps. */
-export async function handleWebhookRequest(req, res) {
-    await handleWebhook(req, res);
-}
-/** Start the cron scan loop. Returns a handle whose `stop()` clears the loop
- *  timer — call it from CP shutdown. */
-export function startSchedulerIngress() {
-    return startSchedulerLoop();
-}

package/dist/hearth/control-plane/registry.d.ts

@@ -1,22 +0,0 @@
-import { DatabaseSync } from 'node:sqlite';
-import type { CreateHomeInput, Home, HomeHealthVerdict, HomeId, HomePatch, HomeStatus, RefreshProviderPointersInput, ResolvedHome, TenantSession, TouchWakeInput } from './types.js';
-export declare function createHome(input: CreateHomeInput, db?: DatabaseSync): Home;
-export declare function getHomeById(home_id: HomeId | null | undefined, db?: DatabaseSync): Home | null;
-/** Resolve a tenant session to its registry row. A null return is a hard
- *  auth/404 boundary: callers must turn it into unauthorized/not-found before
- *  wake or relay. This module intentionally performs a plain row read, so a
- *  suspended home remains resolvable/readable (R-REG-1). */
-export declare function resolveHome(tenant_id: string, user_id: string, db?: DatabaseSync): ResolvedHome | null;
-export declare function resolveHomeForSession(session: TenantSession | null, db?: DatabaseSync): ResolvedHome | null;
-export declare function getHomeBySandbox(provider_sandbox_id: string | null | undefined, db?: DatabaseSync): Home | null;
-export declare function updateHome(home_id: HomeId, mutate: (current: Home) => HomePatch, db?: DatabaseSync): Home;
-export declare function refreshProviderPointers(home_id: HomeId, pointers: RefreshProviderPointersInput, db?: DatabaseSync): Home;
-export declare function setHomeStatus(home_id: HomeId, status: HomeStatus, db?: DatabaseSync): Home;
-/** Set the home's health verdict. The auto-upgrade roll (wake.ts `rollHome`)
- *  is the first natural producer of `health_verdict`: a completed roll/
- *  rollback writes `'healthy'`, a roll AND rollback both failing writes
- *  `'degraded'` (design §4/§5). */
-export declare function setHealthVerdict(home_id: HomeId, health_verdict: HomeHealthVerdict, db?: DatabaseSync): Home;
-export declare function touchWake(home_id: HomeId, input?: TouchWakeInput, db?: DatabaseSync): Home;
-export declare function touchReady(home_id: HomeId, at?: string, db?: DatabaseSync): Home;
-export declare function touchSuspend(home_id: HomeId, at?: string, db?: DatabaseSync): Home;

package/dist/hearth/control-plane/registry.js

@@ -1,168 +0,0 @@
-import { general } from '../../core/errors.js';
-import { getControlPlaneDb } from './db.js';
-const HOME_COLUMNS = [
-    'home_id',
-    'tenant_id',
-    'user_id',
-    'provider',
-    'provider_sandbox_id',
-    'provider_volume_id',
-    'preview_endpoint',
-    'home_agent_target',
-    'relay_auth_ref',
-    'status',
-    'template_version',
-    'last_ready_at',
-    'last_wake_at',
-    'last_suspend_at',
-    'last_wake_latency_ms',
-    'health_verdict',
-    'created_at',
-    'updated_at',
-];
-const SELECT_HOME = `SELECT ${HOME_COLUMNS.join(', ')} FROM home`;
-function nowIso() {
-    return new Date().toISOString();
-}
-function nonEmpty(name, value) {
-    const trimmed = value.trim();
-    if (trimmed === '')
-        throw general(`${name} must not be empty`, { field: name });
-    return trimmed;
-}
-function normalizeCreateHome(input) {
-    const now = nowIso();
-    return {
-        home_id: nonEmpty('home_id', input.home_id),
-        tenant_id: nonEmpty('tenant_id', input.tenant_id),
-        user_id: nonEmpty('user_id', input.user_id),
-        provider: input.provider ?? 'blaxel',
-        provider_sandbox_id: input.provider_sandbox_id ?? null,
-        provider_volume_id: input.provider_volume_id ?? null,
-        preview_endpoint: input.preview_endpoint ?? null,
-        home_agent_target: input.home_agent_target ?? null,
-        relay_auth_ref: input.relay_auth_ref ?? null,
-        status: input.status ?? 'provisioning',
-        template_version: input.template_version ?? null,
-        last_ready_at: input.last_ready_at ?? null,
-        last_wake_at: input.last_wake_at ?? null,
-        last_suspend_at: input.last_suspend_at ?? null,
-        last_wake_latency_ms: input.last_wake_latency_ms ?? null,
-        health_verdict: input.health_verdict ?? 'unknown',
-        created_at: input.created_at ?? now,
-        updated_at: input.updated_at ?? input.created_at ?? now,
-    };
-}
-function mapHome(row) {
-    if (row === undefined || row === null)
-        return null;
-    return row;
-}
-function changedColumns(patch) {
-    return Object.keys(patch).filter((key) => patch[key] !== undefined);
-}
-function runTransaction(db, body) {
-    db.exec('BEGIN IMMEDIATE');
-    try {
-        const value = body();
-        db.exec('COMMIT');
-        return value;
-    }
-    catch (error) {
-        try {
-            db.exec('ROLLBACK');
-        }
-        catch {
-            // The original error is the useful one; rollback failure only means the
-            // transaction was already closed by SQLite.
-        }
-        throw error;
-    }
-}
-export function createHome(input, db = getControlPlaneDb()) {
-    const home = normalizeCreateHome(input);
-    db.prepare(`
-INSERT INTO home (${HOME_COLUMNS.join(', ')})
-VALUES (${HOME_COLUMNS.map(() => '?').join(', ')})
-`).run(...HOME_COLUMNS.map((column) => home[column]));
-    return home;
-}
-export function getHomeById(home_id, db = getControlPlaneDb()) {
-    if (home_id === null || home_id === undefined || home_id.trim() === '')
-        return null;
-    return mapHome(db.prepare(`${SELECT_HOME} WHERE home_id = ?`).get(home_id));
-}
-/** Resolve a tenant session to its registry row. A null return is a hard
- *  auth/404 boundary: callers must turn it into unauthorized/not-found before
- *  wake or relay. This module intentionally performs a plain row read, so a
- *  suspended home remains resolvable/readable (R-REG-1). */
-export function resolveHome(tenant_id, user_id, db = getControlPlaneDb()) {
-    const tenant = tenant_id.trim();
-    const user = user_id.trim();
-    if (tenant === '' || user === '')
-        return null;
-    return mapHome(db.prepare(`${SELECT_HOME} WHERE tenant_id = ? AND user_id = ?`).get(tenant, user));
-}
-export function resolveHomeForSession(session, db = getControlPlaneDb()) {
-    if (session === null)
-        return null;
-    return resolveHome(session.tenant_id, session.user_id, db);
-}
-export function getHomeBySandbox(provider_sandbox_id, db = getControlPlaneDb()) {
-    if (provider_sandbox_id === null || provider_sandbox_id === undefined || provider_sandbox_id.trim() === '')
-        return null;
-    return mapHome(db.prepare(`${SELECT_HOME} WHERE provider_sandbox_id = ?`).get(provider_sandbox_id));
-}
-export function updateHome(home_id, mutate, db = getControlPlaneDb()) {
-    return runTransaction(db, () => {
-        const current = getHomeById(home_id, db);
-        if (current === null)
-            throw general(`home not found: ${home_id}`, { home_id });
-        const patch = mutate(current);
-        const columns = changedColumns(patch);
-        const updated_at = nowIso();
-        if (columns.length === 0) {
-            db.prepare('UPDATE home SET updated_at = ? WHERE home_id = ?').run(updated_at, home_id);
-            return { ...current, updated_at };
-        }
-        const assignments = columns.map((column) => `${column} = ?`).join(', ');
-        const values = columns.map((column) => {
-            const value = patch[column];
-            if (value === undefined)
-                throw general(`home patch column ${column} was unexpectedly undefined`, { column });
-            return value;
-        });
-        db.prepare(`UPDATE home SET ${assignments}, updated_at = ? WHERE home_id = ?`).run(...values, updated_at, home_id);
-        return getHomeById(home_id, db);
-    });
-}
-export function refreshProviderPointers(home_id, pointers, db = getControlPlaneDb()) {
-    return updateHome(home_id, () => ({
-        provider_sandbox_id: pointers.provider_sandbox_id,
-        preview_endpoint: pointers.preview_endpoint,
-        status: pointers.status,
-        template_version: pointers.template_version,
-    }), db);
-}
-export function setHomeStatus(home_id, status, db = getControlPlaneDb()) {
-    return updateHome(home_id, () => ({ status }), db);
-}
-/** Set the home's health verdict. The auto-upgrade roll (wake.ts `rollHome`)
- *  is the first natural producer of `health_verdict`: a completed roll/
- *  rollback writes `'healthy'`, a roll AND rollback both failing writes
- *  `'degraded'` (design §4/§5). */
-export function setHealthVerdict(home_id, health_verdict, db = getControlPlaneDb()) {
-    return updateHome(home_id, () => ({ health_verdict }), db);
-}
-export function touchWake(home_id, input = {}, db = getControlPlaneDb()) {
-    return updateHome(home_id, () => ({
-        last_wake_at: input.at ?? nowIso(),
-        last_wake_latency_ms: input.latency_ms,
-    }), db);
-}
-export function touchReady(home_id, at = nowIso(), db = getControlPlaneDb()) {
-    return updateHome(home_id, () => ({ last_ready_at: at }), db);
-}
-export function touchSuspend(home_id, at = nowIso(), db = getControlPlaneDb()) {
-    return updateHome(home_id, () => ({ last_suspend_at: at }), db);
-}

package/dist/hearth/control-plane/relay.d.ts

@@ -1,44 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { Socket } from 'node:net';
-import { WebSocket } from 'ws';
-import { type ControlPlaneConfig } from './config.js';
-import { type WakeResult } from './wake.js';
-import type { HomeId, ResolvedHome } from './types.js';
-import type { RelayDispatcher } from './server.js';
-/** Serialize a non-`Error` rejection for a log line without collapsing it to `"[object Object]"`
- *  (`String(error)` on a plain object) — recreate-race-fix.md §3.6. Falls back to `String` only
- *  if the value itself isn't JSON-serializable (a circular structure, a BigInt, etc). */
-export declare function serializeRelayError(error: unknown): string;
-/** Join the validated origin-form request target onto `previewEndpoint` and
- *  reject anything that would escape that origin (criterion 4: "reject
- *  scheme-relative/absolute external escapes"). */
-export declare function buildUpstreamHttpUrl(previewEndpoint: string, rawRequestUrl: string | undefined): URL;
-export interface RelayDeps {
-    ensureAwake?: (home_id: HomeId) => Promise<WakeResult>;
-    resolveRunning?: (home_id: HomeId) => WakeResult | null;
-    invalidateWarmVerdict?: (home_id: HomeId) => void;
-    loadConfig?: () => ControlPlaneConfig;
-}
-/** Forward one HTTP request to `home` (criterion 1: only after the caller's
- *  session/registry gate already resolved `home`, and only after
- *  `ensureAwake(home.home_id)` succeeds). Mirrors M0 `proxy.ts`'s
- *  fast-path-then-escalate shape: a fresh warm-verdict cache hit
- *  (`resolveRunning`, P4.2) is forwarded directly without re-entering the
- *  wake pipeline; only a missing/stale verdict, or a running route that just
- *  failed on a safely-replayable method, escalates to a bounded
- *  `ensureAwake`. */
-export declare function proxyHttp(req: IncomingMessage, res: ServerResponse, home: ResolvedHome, deps?: RelayDeps): Promise<void>;
-export interface ProxyWebSocketDeps extends RelayDeps {
-    createUpstream?: (url: string, relayToken: string) => WebSocket;
-}
-/** `RelayDispatcher.proxyUpgrade`: complete the WS handshake on the already
- *  session+registry-gated socket (`server.ts`'s `handleUpgrade`), then bridge
- *  it to the home. Errors after this point close the browser socket in-band
- *  with a WS close code (1011/1013) rather than a raw TCP reset, so the
- *  client sees a clean failure (criterion 4: "keep ... close behavior from
- *  M0 where applicable"). */
-export declare function proxyUpgrade(req: IncomingMessage, socket: Socket, head: Buffer, home: ResolvedHome, deps?: ProxyWebSocketDeps): void;
-/** The real `RelayDispatcher` `main.ts` wires in once the CP server is built
- *  — `server.ts`'s default (`notImplementedRelay`) is only ever used when a
- *  caller (test/smoke) doesn't inject one. */
-export declare const controlPlaneRelay: RelayDispatcher;