@crouton-kit/crouter 0.3.40 → 0.3.41

package/dist/core/hearth/providers/blaxel.js

@@ -1,364 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-import { SandboxInstance, VolumeInstance, getVolume, listSandboxes } from '@blaxel/core';
-import { general } from '../../errors.js';
-const TERMINATED_STATES = new Set(['TERMINATED', 'DELETING', 'DEACTIVATED', 'DEACTIVATING', 'FAILED']);
-const PROVISIONING_STATES = new Set(['UPLOADING', 'BUILDING', 'DEPLOYING', 'BUILT']);
-function readCrtrVersion() {
-    const file = new URL('../../../../package.json', import.meta.url);
-    const pkg = JSON.parse(readFileSync(file, 'utf8'));
-    if (typeof pkg.version !== 'string' || pkg.version.trim() === '') {
-        throw general('missing crtr package version', { packageJson: file.pathname });
-    }
-    return pkg.version;
-}
-function defaultImageRef(templateVersion) {
-    return `crouter-hearth-home-${templateVersion.replace(/\./g, '-')}`;
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function shStatus(status) {
-    if (status === undefined || status === null || status === '')
-        return 'unknown';
-    const normalized = status.toUpperCase();
-    if (normalized === 'DEPLOYED')
-        return 'running';
-    if (normalized === 'RUNNING' || normalized === 'STANDBY')
-        return 'running';
-    if (TERMINATED_STATES.has(normalized))
-        return 'terminated';
-    if (PROVISIONING_STATES.has(normalized))
-        return 'provisioning';
-    if (normalized === 'PAUSED' || normalized === 'SUSPENDED')
-        return 'paused';
-    return status;
-}
-function record(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return null;
-    return value;
-}
-function rawFromSandbox(sandbox) {
-    return {
-        metadata: sandbox.metadata,
-        status: sandbox.status ?? null,
-        spec: sandbox.spec,
-    };
-}
-function rawFromVolume(volume) {
-    return {
-        metadata: volume.metadata,
-        status: volume.status ?? null,
-        spec: volume.spec,
-    };
-}
-function toEnvVars(envs) {
-    if (envs === undefined)
-        return undefined;
-    return Object.entries(envs)
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([name, value]) => ({ name, value }));
-}
-function resolveExecCommand(input) {
-    const hasCommand = typeof input.command === 'string';
-    const hasArgv = input.argv !== undefined;
-    if (hasCommand === hasArgv) {
-        throw general('provider exec requires exactly one of command or argv', { hasCommand, hasArgv });
-    }
-    if (hasCommand) {
-        const command = input.command?.trim() ?? '';
-        if (command === '')
-            throw general('provider exec command must not be empty');
-        return command;
-    }
-    const argv = input.argv ?? [];
-    if (argv.length === 0)
-        throw general('provider exec argv must not be empty');
-    for (const arg of argv) {
-        if (typeof arg !== 'string' || arg === '')
-            throw general('provider exec argv contains an empty argument');
-    }
-    return argv.map(shellQuote).join(' ');
-}
-// The Blaxel SDK (@blaxel/core 0.2.94) does not always reject with an `Error` instance — a 404
-// comes back as a plain object (e.g. `{code:404,error:"Sandbox not found"}`), and `String()` on
-// such an object yields the useless literal "[object Object]", which matches none of the regex
-// below. Recognize the structured shape directly (a numeric-or-string `404` status field) AND
-// fall back to JSON-serializing the value (mirroring wake.ts's `serializeError`) before running
-// the message regex, so both an `Error("... not found")` and a plain-object 404 are caught.
-export function isMissingResourceError(error) {
-    const fields = record(error);
-    if (fields !== null) {
-        for (const key of ['code', 'status', 'status_code', 'statusCode']) {
-            const value = fields[key];
-            if (value === 404 || value === '404')
-                return true;
-        }
-    }
-    const message = error instanceof Error ? error.message : (JSON.stringify(error) ?? String(error));
-    return /\b(not found|404|does not exist|missing)\b/i.test(message);
-}
-// Accepts either a live `SandboxInstance` or a raw wire `Sandbox` page item — only the
-// `metadata`/`status`/`spec` fields are read, so mapping raw list pages avoids constructing
-// `SandboxInstance`s (whose `list()` eagerly warms an H2 session per sandbox — pointless for a
-// destroy sweep).
-function toMachineRef(sandbox) {
-    const metadata = sandbox.metadata;
-    const status = sandbox.status ?? undefined;
-    return {
-        providerName: 'blaxel',
-        machineId: metadata.name,
-        state: shStatus(status),
-        updatedAt: metadata.updatedAt ?? null,
-        raw: rawFromSandbox(sandbox),
-    };
-}
-function toRouteRef(machineId, targetPort, preview, raw) {
-    const url = preview.spec.url ?? null;
-    return {
-        routeId: preview.name,
-        machineId,
-        targetPort,
-        url,
-        concreteUrl: url,
-        concreteUrlSource: 'provider',
-        raw: raw ?? null,
-    };
-}
-export class BlaxelMachineProvider {
-    providerName = 'blaxel';
-    imageRef;
-    templateVersion;
-    volumeSizeGb;
-    config;
-    constructor(options = {}) {
-        const templateVersion = options.templateVersion ?? readCrtrVersion();
-        const volumeSizeGb = options.volumeSizeGb ?? 4;
-        if (!Number.isInteger(volumeSizeGb) || volumeSizeGb < 4) {
-            throw general('Blaxel Hearth home volume must be at least 4 GB', { volumeSizeGb });
-        }
-        this.imageRef = options.image ?? defaultImageRef(templateVersion);
-        this.templateVersion = templateVersion;
-        this.volumeSizeGb = volumeSizeGb;
-        this.config = {
-            region: options.region ?? 'us-west-2',
-            memory: options.memory ?? 2048,
-            image: this.imageRef,
-            templateVersion: this.templateVersion,
-            volumeSizeGb: this.volumeSizeGb,
-        };
-    }
-    async createVolume(input) {
-        const volume = await VolumeInstance.createIfNotExists({ name: input.name, size: this.config.volumeSizeGb * 1024, region: this.config.region });
-        return {
-            volumeId: volume.metadata.name ?? input.name,
-            name: input.name,
-            raw: rawFromVolume(volume),
-        };
-    }
-    async createMachine(input) {
-        const sandbox = await SandboxInstance.createIfNotExists({
-            name: input.name ?? input.tenantId,
-            // Tag every sandbox with the home's stable volume id so the recreate sweep can scope its
-            // destructive list to this home's family only (orphan-cleanup-fix MAJOR-1). Unset on
-            // callers that pass no externalId.
-            ...(input.externalId === undefined ? {} : { externalId: input.externalId }),
-            // A targeted recreate (auto-upgrade roll / rollback, design §4.1) passes
-            // an explicit `image`; the normal provision/wake path leaves it unset
-            // and uses the provider's construction-time config image. `createIfNotExists`
-            // only honors this on genuine creation — the roll path destroys the old
-            // sandbox first so the name is free (blaxel-home.ts `recreateOnImage`).
-            image: input.image ?? this.config.image,
-            memory: this.config.memory,
-            region: this.config.region,
-            volumes: input.volumeMount === undefined || input.volumeMount === null ? undefined : [{ name: input.volumeMount.volumeName, mountPath: input.volumeMount.path, readOnly: false }],
-            envs: toEnvVars(input.envs),
-            ports: input.ports?.map((port) => ({ target: port.target, protocol: port.protocol })),
-            // Snapshot-never-kill (P3.4): this is the only discoverable Blaxel suspend/standby
-            // primitive (@blaxel/core 0.2.94) — there is no imperative pause()/standby() call, only
-            // this create-time runtime flag. Once set, Blaxel's platform idle timer snapshots and
-            // transparently restores the sandbox on the next request instead of tearing it down.
-            // Every Hearth home is created with this on; it is never optional per-home.
-            snapshotEnabled: true,
-        });
-        await sandbox.wait({ maxWait: 90_000, interval: 500 }).catch(() => sandbox);
-        return toMachineRef(sandbox);
-    }
-    // orphan-cleanup-fix.md §3.2 + MAJOR-1/MINOR-1: the deterministic name-family sweep enumerates
-    // a home's generations via LIST scoped to the caller-owned `externalId` tag, then destroys the
-    // ones whose name is in the family. Over-listing is harmless — a FAILED/detached record still
-    // shows up here and destroy tolerates not_found, which is exactly what closes the autonomous-
-    // standby-detach orphan gap. Drives the generated `listSandboxes` client directly (bypassing
-    // `SandboxInstance.list()`, which never follows a cursor and warms an H2 session per sandbox):
-    // loops until exhausted so a future SDK version crossing Blaxel-Version 2026-04-28 (cursor
-    // pagination, 50/page) cannot silently truncate the sweep to page 1. At the SDK's pinned
-    // 2026-04-16 the server returns a bare array (the full set) and the loop breaks on the first
-    // page.
-    async listMachines(filter) {
-        const machines = [];
-        let cursor;
-        for (;;) {
-            const { data: raw } = await listSandboxes({
-                query: {
-                    limit: 200,
-                    ...(cursor === undefined ? {} : { cursor }),
-                    ...(filter?.externalId === undefined ? {} : { externalId: filter.externalId }),
-                },
-                throwOnError: true,
-            });
-            const page = Array.isArray(raw) ? raw : (raw?.data ?? []);
-            machines.push(...page.map(toMachineRef));
-            if (Array.isArray(raw))
-                break; // legacy bare array (Blaxel-Version < 2026-04-28) = full set
-            cursor = raw?.meta?.nextCursor || undefined; // empty when there are no more pages
-            if (cursor === undefined)
-                break;
-        }
-        return machines;
-    }
-    async getMachine(machineId) {
-        try {
-            const sandbox = await SandboxInstance.get(machineId);
-            return toMachineRef(sandbox);
-        }
-        catch (error) {
-            if (!isMissingResourceError(error))
-                throw error;
-            return {
-                providerName: 'blaxel',
-                machineId,
-                state: 'terminated',
-                raw: { error: error instanceof Error ? error.message : String(error) },
-            };
-        }
-    }
-    async exec(machineId, input) {
-        if (input.stdin !== undefined && input.background === true) {
-            throw general('provider exec stdin is not supported for background commands', { machineId });
-        }
-        const sandbox = await SandboxInstance.get(machineId);
-        const stdinBody = input.stdin;
-        const stdinPath = stdinBody === undefined ? null : `/tmp/crtr-hearth-exec-${randomUUID()}.stdin`;
-        if (stdinPath !== null && stdinBody !== undefined) {
-            if (stdinBody instanceof Uint8Array) {
-                await sandbox.fs.writeBinary(stdinPath, stdinBody);
-            }
-            else {
-                await sandbox.fs.write(stdinPath, stdinBody);
-            }
-        }
-        const command = stdinPath === null ? resolveExecCommand(input) : `${resolveExecCommand(input)} < ${shellQuote(stdinPath)}`;
-        let response;
-        try {
-            response = await sandbox.process.exec({
-                command,
-                env: input.env,
-                timeout: Math.ceil((input.timeoutMs ?? 55_000) / 1000),
-                workingDir: input.cwd,
-                ...(input.background === true ? { waitForCompletion: false } : { waitForCompletion: true }),
-            });
-        }
-        finally {
-            if (stdinPath !== null)
-                await sandbox.fs.rm(stdinPath).catch(() => undefined);
-        }
-        const result = record(response) ?? {};
-        return {
-            exitCode: typeof result.exitCode === 'number' ? result.exitCode : null,
-            timedOut: false,
-            stdout: typeof result.stdout === 'string' ? result.stdout : typeof result.logs === 'string' ? result.logs : '',
-            stderr: typeof result.stderr === 'string' ? result.stderr : '',
-            raw: result,
-        };
-    }
-    async waitForPort(machineId, port, opts) {
-        const sandbox = await SandboxInstance.get(machineId);
-        try {
-            await sandbox.process.exec({
-                command: 'true',
-                waitForPorts: [port],
-                waitForCompletion: true,
-                timeout: Math.ceil((opts?.maxWaitMs ?? 60_000) / 1000),
-            });
-        }
-        catch (error) {
-            throw general(`blaxel sandbox ${machineId} never opened port ${port}`, {
-                machineId,
-                port,
-                cause: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async publishHttpPort(machineId, input) {
-        const sandbox = await SandboxInstance.get(machineId);
-        const previewName = input.routeName ?? input.routeId ?? `${machineId}-http`;
-        const preview = await sandbox.previews.createIfNotExists({
-            metadata: { name: previewName },
-            spec: { port: input.targetPort, public: true },
-        });
-        return toRouteRef(machineId, input.targetPort, { name: preview.name, spec: preview.spec }, {
-            preview: { metadata: preview.metadata, spec: preview.spec },
-            input,
-        });
-    }
-    async health() {
-        try {
-            await VolumeInstance.list();
-            return { ok: true, providerName: 'blaxel' };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                providerName: 'blaxel',
-                status: error instanceof Error ? error.message : String(error),
-                raw: { error: error instanceof Error ? error.message : String(error) },
-            };
-        }
-    }
-    async destroy(machineId) {
-        try {
-            await SandboxInstance.delete(machineId);
-            return { kind: 'destroyed' };
-        }
-        catch (error) {
-            if (isMissingResourceError(error))
-                return { kind: 'not_found' };
-            throw error;
-        }
-    }
-    async destroyVolume(volumeId) {
-        try {
-            await VolumeInstance.delete(volumeId);
-            return { kind: 'destroyed' };
-        }
-        catch (error) {
-            if (isMissingResourceError(error))
-                return { kind: 'not_found' };
-            throw error;
-        }
-    }
-    // recreate-race-fix.md §3.1: read the platform's own positive attachment signal
-    // (`Volume.state.attachedTo`) rather than inferring detach from a sandbox GET/delete —
-    // that read/create consistency split is exactly what raced the old same-name recreate.
-    // `VolumeInstance.get`'s backing `volume` field is TS-private (no public state getter
-    // in @blaxel/core 0.2.94), so this calls the underlying `getVolume` SDK function
-    // directly instead — same request `VolumeInstance.get` makes, with `state` exposed.
-    // A 404 (or any other failure) throws, wrapped with the volumeId for context: a missing
-    // home volume is a real incident, never something to continue past (volume-is-sacred).
-    async getVolumeAttachment(volumeId) {
-        let attachedTo;
-        try {
-            const { data } = await getVolume({ path: { volumeName: volumeId }, throwOnError: true });
-            attachedTo = data.state?.attachedTo;
-        }
-        catch (error) {
-            throw general(`blaxel volume ${volumeId} attachment check failed`, {
-                volumeId,
-                cause: error instanceof Error ? error.message : String(error),
-            });
-        }
-        const trimmed = (attachedTo ?? '').trim();
-        return trimmed === '' ? null : trimmed;
-    }
-}

package/dist/core/hearth/providers/types.d.ts

@@ -1,93 +0,0 @@
-import type { MachineId, MachineRef, MachineState, M0Config, RouteRef } from '../types.js';
-export interface ExecResult {
-    exitCode: number | null;
-    timedOut: boolean;
-    stdout: string;
-    stderr: string;
-    raw?: Record<string, unknown> | null;
-}
-export interface ExecInput {
-    command?: string;
-    argv?: readonly string[];
-    stdin?: string | Uint8Array;
-    timeoutMs?: number;
-    background?: boolean;
-    env?: Record<string, string>;
-    cwd?: string;
-}
-export interface VolumeRef {
-    volumeId: string;
-    name: string;
-    raw?: Record<string, unknown> | null;
-}
-export interface CreateMachineInput {
-    tenantId: string;
-    externalId?: string;
-    template?: string | null;
-    envs?: Record<string, string>;
-    enableNetwork?: boolean;
-    name?: string | null;
-    image?: string | null;
-    ports?: {
-        target: number;
-        protocol: 'HTTP';
-    }[];
-    volumeMount?: {
-        volumeName: string;
-        path: string;
-    } | null;
-    raw?: Record<string, unknown> | null;
-}
-export interface PublishHttpPortInput {
-    machineId: MachineId;
-    targetPort: number;
-    subdomain?: string | null;
-    routeId?: string | null;
-    routeName?: string | null;
-    raw?: Record<string, unknown> | null;
-}
-export interface HealthResult {
-    ok: boolean;
-    providerName: string;
-    status?: string | null;
-    raw?: Record<string, unknown> | null;
-}
-export type DestroyOutcome = {
-    kind: 'destroyed';
-} | {
-    kind: 'not_found';
-};
-export interface MachineProvider {
-    readonly providerName: 'blaxel';
-    readonly imageRef: string;
-    readonly templateVersion: string;
-    readonly volumeSizeGb: number;
-    createVolume(input: {
-        name: string;
-    }): Promise<VolumeRef>;
-    createMachine(input: CreateMachineInput): Promise<MachineRef>;
-    getMachine(machineId: MachineId): Promise<MachineRef>;
-    /** List machine records, optionally scoped to a caller-owned `externalId` tag. The recreate
-     *  cleanup sweep passes the home's `providerVolumeId` as the filter so only sandboxes Hearth
-     *  itself tagged for this home come back, then intersects that with the generation NAME FAMILY
-     *  matcher — a tag∩name intersection on a destructive op, so no id-format or workspace name
-     *  discipline is load-bearing for other homes' safety (orphan-cleanup-fix MAJOR-1). The result
-     *  is NOT a promise of every machine in the workspace; without a filter it lists broadly, with
-     *  one it lists only tagged matches. Implementations must page until exhausted (MINOR-1). */
-    listMachines(filter?: {
-        externalId?: string;
-    }): Promise<MachineRef[]>;
-    exec(machineId: MachineId, input: ExecInput): Promise<ExecResult>;
-    waitForPort(machineId: MachineId, port: number, opts?: {
-        maxWaitMs?: number;
-    }): Promise<void>;
-    publishHttpPort(machineId: MachineId, input: PublishHttpPortInput): Promise<RouteRef>;
-    health(): Promise<HealthResult>;
-    destroy(machineId: MachineId): Promise<DestroyOutcome>;
-    destroyVolume(volumeId: string): Promise<DestroyOutcome>;
-    /** The resource currently holding this volume ("sandbox:<name>"), or null if detached.
-     *  A missing volume (404) throws — a home volume disappearing is always an incident,
-     *  never something to continue past (recreate-race-fix.md §3.1). */
-    getVolumeAttachment(volumeId: string): Promise<string | null>;
-}
-export type { MachineState, M0Config, RouteRef };

package/dist/core/hearth/types.d.ts

@@ -1,155 +0,0 @@
-export type TenantId = string;
-export type MachineId = string;
-export type SnapshotId = string;
-export type RouteId = string;
-export type RelayToken = string;
-export type GuestNodeId = string;
-export type HomeId = string;
-export type UserId = string;
-export type RelayAuthRef = string;
-export type MachineState = 'provisioning' | 'running' | 'paused' | 'stopped' | 'suspended' | 'restoring' | 'terminating' | 'terminated' | 'unknown' | string;
-export type RouteUrlSource = 'provider' | 'config' | 'derived' | 'unknown';
-export interface HomeStorageRef {
-    kind: 'volume';
-    durability: 'durable-volume';
-    longTermContract: true;
-    ownerMachineId: MachineId;
-    guestHome: string;
-    volumeId: string;
-    mountPath: string;
-}
-export interface MachineRef {
-    providerName: string;
-    machineId: MachineId;
-    state: MachineState;
-    guestIp?: string | null;
-    sshPort?: number | null;
-    updatedAt?: string | null;
-    raw?: Record<string, unknown> | null;
-}
-export interface SnapshotRef {
-    snapshotId: SnapshotId;
-    machineId: MachineId;
-    stateKey?: string | null;
-    memoryKey?: string | null;
-    diskKey?: string | null;
-    sizeBytes?: number | null;
-    createdAt?: string | null;
-    raw?: Record<string, unknown> | null;
-}
-export interface RouteRef {
-    routeId: RouteId;
-    machineId: MachineId;
-    targetPort: number;
-    url?: string | null;
-    subdomain?: string | null;
-    createdAt?: string | null;
-    concreteUrl?: string | null;
-    concreteUrlSource?: RouteUrlSource | null;
-    raw?: Record<string, unknown> | null;
-}
-export interface BootstrapMarker {
-    tenantId: TenantId;
-    nodeId: GuestNodeId;
-    daemonPid: number;
-    brokerPid: number;
-    crtrHome: string;
-    piAgentDir: string;
-    sessionFile?: string | null;
-    webPort: number;
-    createdAt: string;
-}
-export interface VerifyBaseline {
-    machineId: MachineId;
-    nodeId: GuestNodeId;
-    sessionFile: string;
-    sessionLineCount: number;
-    webPort: number;
-    capturedAt: string;
-    daemonPid?: number | null;
-    brokerPid?: number | null;
-    socketPath?: string | null;
-}
-export type VerifyPhase = 'pre-suspend' | 'post-restore' | 'post-recreate';
-export interface VerifyCheck {
-    name: string;
-    status: 'PASS' | 'FAIL';
-    detail?: string;
-    value?: string | number | boolean | null;
-}
-export interface VerifyResult {
-    phase: VerifyPhase;
-    checks: VerifyCheck[];
-    passed: boolean;
-    machineState: MachineState;
-    nodeId?: GuestNodeId | null;
-    routeUrl?: string | null;
-    hearth_m0_verified?: boolean;
-    hearth_m0_recreate_verified?: boolean;
-    warmResume?: boolean | null;
-    restoreLatencyMs?: number | null;
-    recreateLatencyMs?: number | null;
-    baseline?: VerifyBaseline | null;
-}
-export interface HomeProviderDescriptor {
-    homeId: HomeId;
-    tenantId: TenantId;
-    userId?: UserId | null;
-    providerName: 'blaxel';
-    providerSandboxId: MachineId;
-    providerVolumeId: string;
-    previewEndpoint?: string | null;
-    homeAgentTarget: GuestNodeId;
-    relayAuthRef?: RelayAuthRef | null;
-    relayToken: RelayToken;
-    status?: MachineState | null;
-    templateVersion?: string | null;
-    raw?: Record<string, unknown> | null;
-}
-export interface HomeProviderRefresh {
-    providerName: 'blaxel';
-    providerSandboxId: MachineId;
-    providerVolumeId: string;
-    previewEndpoint?: string | null;
-    route?: RouteRef | null;
-    homeAgentTarget: GuestNodeId;
-    relayAuthRef?: RelayAuthRef | null;
-    templateVersion: string;
-    status: MachineState;
-    machine?: MachineRef | null;
-    updatedAt: string;
-}
-export interface HomeRecord {
-    tenantId: TenantId;
-    providerName: string;
-    machineId: MachineId;
-    homeStorage: HomeStorageRef;
-    state: MachineState;
-    nodeId?: GuestNodeId | null;
-    webRoute?: RouteRef | null;
-    latestSnapshot?: SnapshotRef | null;
-    verifyBaseline?: VerifyBaseline | null;
-    bootstrapMarker?: BootstrapMarker | null;
-    relayToken?: RelayToken | null;
-    templateVersion?: string | null;
-    warmResume?: boolean | null;
-    restoreLatencyMs?: number | null;
-    recreateLatencyMs?: number | null;
-    createdAt: string;
-    updatedAt: string;
-    raw?: Record<string, unknown> | null;
-}
-export interface M0Config {
-    providerName: string;
-    guestUser: string;
-    guestHome: string;
-    guestCodePath: string;
-    piPackages: string[];
-    webPort: number;
-    nodeKind: string;
-    piAuthJson?: string | null;
-    relayToken?: RelayToken | null;
-    imageRef?: string;
-    templateVersion?: string;
-    volumeSizeGb?: number;
-}

package/dist/hearth/control-plane/__tests__/error-serialization.test.js

@@ -1,29 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-// Bug-regression test (independent review of commit 6018050, recreate-race-fix.md §3.6):
-// `JSON.stringify` returns `undefined` (does not throw) for `undefined`, a function, or a
-// symbol — a naive `JSON.stringify(error)` rider would silently hand that `undefined` back to
-// callers. In `relay.ts` that `undefined` message then makes `message.startsWith('relay ')`
-// THROW inside the very catch block meant to handle it (a control-flow regression §3.6
-// promised not to introduce); in `wake.ts` it would OMIT the `error` field from the
-// `hearth.roll.incident` JSON line entirely. Both serializers must fall back to `String`
-// whenever `JSON.stringify` yields `undefined`, not only when it throws.
-test('serializeError (wake.ts) never returns undefined for undefined/function/symbol rejections', async () => {
-    const { serializeError } = await import('../wake.js');
-    for (const value of [undefined, function unnamed() { }, Symbol('boom')]) {
-        const result = serializeError(value);
-        assert.equal(typeof result, 'string', `serializeError(${String(value)}) must return a string, never JS \`undefined\``);
-        assert.ok(result.length > 0, `serializeError(${String(value)}) must be a non-empty string`);
-    }
-});
-test('serializeRelayError (relay.ts) never returns undefined for undefined/function/symbol rejections, and the relay control-flow checks it feeds never throw', async () => {
-    const { serializeRelayError } = await import('../relay.js');
-    for (const value of [undefined, function unnamed() { }, Symbol('boom')]) {
-        const result = serializeRelayError(value);
-        assert.equal(typeof result, 'string');
-        assert.ok(result.length > 0, `serializeRelayError(${String(value)}) must be a non-empty string`);
-        // The exact control flow `proxyHttp`'s catch runs on this value — must not throw.
-        assert.doesNotThrow(() => result.startsWith('relay '));
-        assert.doesNotThrow(() => /timed out/i.test(result));
-    }
-});