toiljs 0.0.115 → 0.0.117

package/src/devserver/stream/manager.ts

@@ -1,167 +0,0 @@
-/**
- * Dev STREAM connection driver: the resident per-connection box lifecycle for the dev server, a
- * faithful port of the edge session driver `StreamWorker` (`toil-backend` `src/wasm/stream/worker.rs`)
- * and a sibling of `DaemonHost`. It owns one resident {@link DevStreamBox} per live connection (state
- * persists across that connection's events) and mtime-reloads the `release-stream.wasm` artifact so a
- * rebuild during `npm run dev` is picked up - a NEW connection then gets the new artifact while live
- * connections keep their resident box (mirroring the edge's per-connection pinning).
- *
- * It mirrors `StreamWorker`'s decisions byte-for-byte where they matter in dev: `acceptUpgrade` fires
- * `@connect` with the connect context and HONORS the guest accept/reject (the `@connect` bridge);
- * `dispatch` returns reply frames, a guest-reject close, or a TRAP-induced `STREAM_HOOK_TRAPPED` close
- * that discards the poisoned box. The edge-only concerns it omits (the node-mode gate, the per-node
- * RAM admission, and gas-metered kills) do not apply to a single-process dev server: dev serves one
- * app, has no RAM budget, and Node's `WebAssembly` has no gas middleware (a runaway loop hangs in dev,
- * only a real trap surfaces).
- *
- * Transport-agnostic: the dev WebSocket endpoint calls `acceptUpgrade` on a new socket, `dispatch` per
- * inbound frame (feeding the reply frames back out, or closing on a close code), and `close`/
- * `disconnect` on teardown. Kept transport-free so it is unit-testable without a socket.
- */
-
-import fs from 'node:fs';
-
-import { DevStreamBox } from './index.js';
-
-/** `0x0208 STREAM_REJECTED`: the upgrade is refused for a non-`@connect` reason (no artifact / load
- *  failure). Matches the edge `STREAM_REJECTED`. */
-export const STREAM_REJECTED = 0x0208;
-/** `0x0200 STREAM_HOOK_TRAPPED`: a hook TRAPPED (unreachable / OOB / abort); the box is discarded and
- *  the connection closed. Matches the edge `STREAM_HOOK_TRAPPED`. */
-export const STREAM_HOOK_TRAPPED = 0x0200;
-
-/** The outcome of an upgrade accept attempt (mirrors the edge `StreamUpgradeOutcome`). */
-export type StreamUpgradeOutcome =
-    | { readonly kind: 'accepted'; readonly streamId: bigint; readonly initialEgress: Buffer[] }
-    | { readonly kind: 'rejected'; readonly code: number; readonly initialEgress: Buffer[] };
-
-/** The outcome of driving one inbound frame (mirrors the edge `StreamDatagramOutcome`). */
-export type StreamDispatchResult =
-    | { readonly kind: 'reply'; readonly frames: Buffer[] }
-    | { readonly kind: 'close'; readonly code: number }
-    | { readonly kind: 'noConnection' };
-
-interface ResidentConn {
-    readonly box: DevStreamBox;
-    readonly streamId: bigint;
-}
-
-export class StreamDevHost {
-    private bytes: Buffer | null = null;
-    private loadedMtimeMs = -1;
-    private readonly conns = new Map<string, ResidentConn>();
-    /** Host-assigned stream id source: monotonic, never 0 (05 section 2.2). */
-    private nextStreamId = 1n;
-
-    constructor(private readonly streamWasmPath: string) {}
-
-    /** Number of live stream connections. */
-    get activeConnections(): number {
-        return this.conns.size;
-    }
-
-    /** Whether a connection is live under `connId`. */
-    has(connId: string): boolean {
-        return this.conns.has(connId);
-    }
-
-    /**
-     * Accept (or reject) an upgrade for `authority` + `path`, mirroring `StreamWorker::accept_upgrade`:
-     * (re)load the artifact on mtime change, instantiate a resident box, fire `@connect` WITH the
-     * connect context, and HONOR the guest's accept/reject. Returns the host-assigned stream id on
-     * accept, plus any initial egress staged by `@connect`, or a `0x02xx` reject code. Fails closed
-     * (no connection registered, box dropped) on a missing/unreadable artifact (`0x0208`), a
-     * `@connect` reject (the guest's code), or a load/connect trap (`0x0200`). Throws only on a
-     * duplicate `connId`.
-     */
-    acceptUpgrade(connId: string, authority: string, path: string): StreamUpgradeOutcome {
-        if (this.conns.has(connId))
-            throw new Error(`stream connection '${connId}' is already open`);
-        this.refresh();
-        if (!this.bytes) return { kind: 'rejected', code: STREAM_REJECTED, initialEgress: [] };
-        let box: DevStreamBox;
-        try {
-            box = DevStreamBox.load(this.bytes);
-        } catch {
-            return { kind: 'rejected', code: STREAM_REJECTED, initialEgress: [] };
-        }
-        const streamId = this.allocStreamId();
-        let outcome;
-        try {
-            outcome = box.onConnect(streamId, authority, path);
-        } catch {
-            return { kind: 'rejected', code: STREAM_HOOK_TRAPPED, initialEgress: [] }; // @connect trapped
-        }
-        if (outcome.kind === 'reject') {
-            return { kind: 'rejected', code: outcome.code, initialEgress: outcome.initialEgress };
-        }
-        this.conns.set(connId, { box, streamId });
-        return { kind: 'accepted', streamId, initialEgress: outcome.initialEgress };
-    }
-
-    /**
-     * Drive an inbound frame into the connection's `@message` hook, mirroring
-     * `StreamWorker::dispatch_datagram`: `reply` frames (to feed back out), a guest-`reject` `close`, a
-     * TRAP-induced `close` (discarding the poisoned box), or `noConnection` for an unknown id.
-     */
-    dispatch(connId: string, inbound: Buffer): StreamDispatchResult {
-        const conn = this.conns.get(connId);
-        if (!conn) return { kind: 'noConnection' };
-        try {
-            const out = conn.box.onMessage(conn.streamId, inbound);
-            if (out.kind === 'reply') return { kind: 'reply', frames: out.frames };
-            return { kind: 'close', code: out.code };
-        } catch {
-            // The @message hook TRAPPED (a real wasm trap; dev has no gas middleware) -> discard the
-            // poisoned box + close, mirroring the edge's STREAM_HOOK_TRAPPED (05 7.4).
-            this.conns.delete(connId);
-            return { kind: 'close', code: STREAM_HOOK_TRAPPED };
-        }
-    }
-
-    /** Graceful close: fire `@close` and drop the box. No-op if the connection is gone. */
-    close(connId: string): void {
-        const conn = this.conns.get(connId);
-        if (!conn) return;
-        try {
-            conn.box.onClose(conn.streamId);
-        } catch {
-            // a trapping @close still tears the connection down
-        }
-        this.conns.delete(connId);
-    }
-
-    /** Abrupt teardown: fire `@disconnect` and drop the box. No-op if the connection is gone. */
-    disconnect(connId: string): void {
-        const conn = this.conns.get(connId);
-        if (!conn) return;
-        try {
-            conn.box.onDisconnect(conn.streamId);
-        } catch {
-            // a trapping @disconnect still tears the connection down
-        }
-        this.conns.delete(connId);
-    }
-
-    /** (Re)read the artifact bytes when its mtime changes (mirrors `DaemonHost.refresh`). Clears the
-     *  bytes when the file is missing; leaves live connections' resident boxes untouched. */
-    private refresh(): void {
-        let mtimeMs: number;
-        try {
-            mtimeMs = fs.statSync(this.streamWasmPath).mtimeMs;
-        } catch {
-            this.bytes = null;
-            this.loadedMtimeMs = -1;
-            return;
-        }
-        if (mtimeMs === this.loadedMtimeMs && this.bytes) return;
-        this.bytes = fs.readFileSync(this.streamWasmPath);
-        this.loadedMtimeMs = mtimeMs;
-    }
-
-    private allocStreamId(): bigint {
-        const id = this.nextStreamId;
-        this.nextStreamId = id + 1n;
-        return id;
-    }
-}

package/src/devserver/stream/router.ts

@@ -1,101 +0,0 @@
-/**
- * The dev STREAM ROUTER (doc 08 sections 4.1/4.2): the `streamModule` that `wireStreams` drives. It
- * owns the `toilstream.catalog` route table + a single resident-box {@link StreamDevHost} for the app's
- * `release-stream.wasm`, and turns a route-matched WebSocket upgrade into a {@link StreamWsSession}
- * driving that box. `matchRoute` (4.2) lets `wireStreams` tell a `@stream` upgrade from a Vite-HMR one;
- * both the catalog and the box mtime-reload so a rebuild during `npm run dev` is picked up.
- */
-
-import fs from 'node:fs';
-
-import {
-    matchStreamRoute,
-    parseStreamCatalog,
-    type StreamCatalog,
-    type StreamDef,
-} from './catalog.js';
-import { StreamDevHost } from './manager.js';
-import { StreamWsSession } from './ws.js';
-
-/** The subset of the hyper-express `Websocket` the router drives (so it is unit-testable with a mock). */
-export interface StreamWs {
-    send(data: Buffer, isBinary: boolean): void;
-    close(code: number): void;
-    on(event: 'message', cb: (message: Buffer, isBinary: boolean) => void): void;
-    on(event: 'close', cb: () => void): void;
-}
-
-/** The upgrade context `wireStreams` stamps for a stream-route upgrade (doc 08 4.1). */
-export interface StreamUpgradeContext {
-    readonly kind: 'stream';
-    readonly route: string;
-    readonly url: string;
-    readonly authority: string;
-}
-
-export class StreamRouter {
-    private catalog: StreamCatalog = new Map();
-    private catalogMtimeMs = -1;
-    private readonly host: StreamDevHost;
-    private connSeq = 0;
-
-    constructor(private readonly streamWasmPath: string) {
-        this.host = new StreamDevHost(streamWasmPath);
-        this.refreshCatalog();
-    }
-
-    /** Live stream connections (diagnostics / tests). */
-    get activeConnections(): number {
-        return this.host.activeConnections;
-    }
-
-    /** doc 08 4.2: match a request path to a `@stream` route (re-reading the catalog on a rebuild), or
-     *  `null` when it is not a stream route (the upgrade is then proxied to Vite). */
-    matchRoute(path: string): StreamDef | null {
-        this.refreshCatalog();
-        return matchStreamRoute(this.catalog, path);
-    }
-
-    /** Handle a route-matched upgrade: open a resident box (`@connect`) and bridge the socket to it
-     *  (inbound frame -> `@message` -> reply frames out; socket close -> `@close`). On a `@connect`
-     *  reject the session closes the socket and registers no box. */
-    onUpgrade(ws: StreamWs, ctx: StreamUpgradeContext): void {
-        const connId = `s${String(++this.connSeq)}`;
-        const q = ctx.url.indexOf('?');
-        const path = q >= 0 ? ctx.url.slice(0, q) : ctx.url;
-        const session = new StreamWsSession(this.host, connId, ctx.authority, path, {
-            send: (frame) => {
-                ws.send(frame, true);
-            },
-            close: (code) => {
-                ws.close(code);
-            },
-        });
-        if (!session.onOpen()) return; // rejected -> socket closed, nothing resident
-        ws.on('message', (message: Buffer) => {
-            session.onMessage(message);
-        });
-        ws.on('close', () => {
-            session.onClose();
-        });
-    }
-
-    /** (Re)read the route table when the artifact mtime changes (mirrors `DaemonHost.refresh`). */
-    private refreshCatalog(): void {
-        let mtimeMs: number;
-        try {
-            mtimeMs = fs.statSync(this.streamWasmPath).mtimeMs;
-        } catch {
-            this.catalog = new Map();
-            this.catalogMtimeMs = -1;
-            return;
-        }
-        if (mtimeMs === this.catalogMtimeMs && this.catalog.size > 0) return;
-        try {
-            this.catalog = parseStreamCatalog(fs.readFileSync(this.streamWasmPath));
-        } catch {
-            this.catalog = new Map();
-        }
-        this.catalogMtimeMs = mtimeMs;
-    }
-}

package/src/devserver/stream/wire.ts

@@ -1,58 +0,0 @@
-/**
- * doc 08 section 4.1: the stream-aware WebSocket router that REPLACES `wireWebsocketProxy` when the dev
- * process serves streams. It intercepts upgrades whose path matches a `@stream` route (via the
- * {@link StreamRouter}) and drives them as resident-box connections; every OTHER upgrade (Vite HMR) is
- * piped upstream EXACTLY as before ({@link pipeToVite}), so HMR is byte-for-byte unchanged. The branch
- * is decided in `app.upgrade` (which stamps `ctx.kind`) and dispatched in the single catch-all
- * `app.ws` handler, mirroring the existing proxy's structure.
- */
-
-import { type Request, type Response, type Server, type Websocket } from '@dacely/hyper-express';
-
-import { pipeToVite, type ViteTarget } from '../http/proxy.js';
-import { type StreamRouter, type StreamUpgradeContext, type StreamWs } from './router.js';
-
-/** Whether this dev process serves streams (doc 08 4.1): `regional` / `continental` / `all`. An
- *  L1 (`hot`) or L4 (`daemon`) dev process does NOT - it rejects/redirects the upgrade. */
-export function streamEmulationEnabled(nodeMode: string): boolean {
-    return nodeMode === 'regional' || nodeMode === 'continental' || nodeMode === 'all';
-}
-
-export function wireStreams(app: Server, vite: ViteTarget, router: StreamRouter): void {
-    app.upgrade('/*', (request: Request, response: Response) => {
-        const def = router.matchRoute(request.path);
-        if (def !== null) {
-            // A @stream route: stamp the stream context; the ws handler drives the resident box.
-            response.upgrade({
-                kind: 'stream',
-                route: def.route,
-                url: request.url,
-                authority: request.headers['host'] ?? '',
-            });
-        } else {
-            // Anything else (Vite HMR): the existing proxy context, unchanged.
-            response.upgrade({
-                kind: 'vite',
-                url: request.url,
-                protocol: request.headers['sec-websocket-protocol'] ?? '',
-            });
-        }
-    });
-
-    app.ws(
-        '/*',
-        // idle_timeout 0: the stream emulator drives liveness itself; the Vite branch never idles out.
-        { message_type: 'Buffer', idle_timeout: 0, max_payload_length: 16 * 1024 * 1024 },
-        (ws: Websocket) => {
-            const ctx = ws.context as { kind?: string };
-            if (ctx.kind === 'stream') {
-                router.onUpgrade(
-                    ws as unknown as StreamWs,
-                    ws.context as unknown as StreamUpgradeContext,
-                );
-            } else {
-                pipeToVite(ws, vite, ws.context as { url: string; protocol: string });
-            }
-        },
-    );
-}

package/src/devserver/stream/ws.ts

@@ -1,78 +0,0 @@
-/**
- * Transport adapter that bridges ONE dev WebSocket connection to the {@link StreamDevHost} session
- * driver. It is the per-socket glue the dev WS endpoint instantiates: socket-open -> `acceptUpgrade`
- * (close on a `@connect`/gate reject), inbound frame -> `dispatch` (send reply frames back, or close
- * on a reject/trap close code), socket-close -> `@close` + drop. It owns NO transport itself - the
- * caller passes a {@link StreamWsTransport} of `send`/`close` callbacks - so it is unit-testable
- * without a live socket and reusable across whatever WS/WebTransport the endpoint ends up speaking.
- *
- * The endpoint that wires hyper-express `app.ws` to this (the URL convention + coexistence with the
- * Vite-HMR catch-all proxy + a `streamWasmFile` config) is the remaining live-server step; this is the
- * transport-agnostic core it drives.
- */
-
-import type { StreamDevHost } from './manager.js';
-
-/** The socket-side primitives this adapter needs: send one binary frame, and close with a code. */
-export interface StreamWsTransport {
-    /** Send one outbound binary frame to the client. */
-    send(frame: Buffer): void;
-    /** Close the connection with a `0x02xx` stream close code. */
-    close(code: number): void;
-}
-
-export class StreamWsSession {
-    private open = false;
-
-    constructor(
-        private readonly host: StreamDevHost,
-        private readonly connId: string,
-        private readonly authority: string,
-        private readonly path: string,
-        private readonly transport: StreamWsTransport,
-    ) {}
-
-    /** Whether the connection is accepted + live. */
-    get isOpen(): boolean {
-        return this.open;
-    }
-
-    /**
-     * Socket open: accept the upgrade (node gate is the endpoint's job; this drives the box). On a
-     * `@connect`/artifact reject the connection is closed with the code and no box is held. Returns
-     * whether the connection was accepted.
-     */
-    onOpen(): boolean {
-        const up = this.host.acceptUpgrade(this.connId, this.authority, this.path);
-        if (up.kind === 'rejected') {
-            for (const frame of up.initialEgress) this.transport.send(frame);
-            this.transport.close(up.code);
-            return false;
-        }
-        this.open = true;
-        for (const frame of up.initialEgress) this.transport.send(frame);
-        return true;
-    }
-
-    /** An inbound binary frame: dispatch it; send the reply frames, or close on a reject/trap code. */
-    onMessage(inbound: Buffer): void {
-        if (!this.open) return;
-        const r = this.host.dispatch(this.connId, inbound);
-        if (r.kind === 'reply') {
-            for (const frame of r.frames) this.transport.send(frame);
-        } else if (r.kind === 'close') {
-            // A guest reject or a TRAP close: close the socket; the socket-close event runs onClose,
-            // which fires @close + drops the box (a no-op if a trap already discarded it).
-            this.open = false;
-            this.transport.close(r.code);
-        }
-        // 'noConnection' cannot occur for a live, accepted session.
-    }
-
-    /** Socket close (client-initiated or after our own close): fire `@close` + drop the box. */
-    onClose(): void {
-        if (!this.open && !this.host.has(this.connId)) return;
-        this.open = false;
-        this.host.close(this.connId);
-    }
-}

package/src/devserver/wasm/sections.ts

@@ -1,59 +0,0 @@
-/**
- * Shared, bounds-checked wasm custom-section walker. Factored out of
- * `db/catalog.ts` so the three Toil section parsers (`toildb.catalog`,
- * `toilstream.catalog`, `toildaemon.catalog`, `toil.surface`) share ONE
- * magic-skipping loop instead of drifting copies.
- *
- * Every input is a tenant-built, possibly mid-rebuild wasm, so the walker must
- * never read past the buffer: a truncated/garbage section table returns `null`
- * (treated by callers as "no section"). Mirrors the host-side walker
- * (`toil-backend` custom-section reader) and the toilscript-side test walker.
- */
-
-/** Read a LEB128 from `buf` at `pos`; throws on overrun so a truncated module
- *  can never over-read (the caller catches and treats it as "no section"). */
-export function leb(buf: Buffer, pos: number): [number, number] {
-    let result = 0;
-    let shift = 0;
-    let p = pos;
-    for (;;) {
-        if (p >= buf.length) throw new RangeError('leb128 past end of buffer');
-        const b = buf[p++];
-        result |= (b & 0x7f) << shift;
-        if ((b & 0x80) === 0) break;
-        shift += 7;
-        if (shift > 35) throw new RangeError('leb128 too long');
-    }
-    return [result >>> 0, p];
-}
-
-/** The bytes of the named wasm custom section, or `null` if absent. Bounds-checked
- *  so a truncated/garbage module can never read past the buffer. */
-export function customSection(wasm: Buffer, want: string): Buffer | null {
-    if (
-        wasm.length < 8 ||
-        wasm[0] !== 0x00 ||
-        wasm[1] !== 0x61 ||
-        wasm[2] !== 0x73 ||
-        wasm[3] !== 0x6d
-    )
-        return null;
-    let pos = 8; // skip the 8-byte magic + version header
-    while (pos < wasm.length) {
-        const id = wasm[pos++];
-        let size: number;
-        [size, pos] = leb(wasm, pos);
-        const end = pos + size;
-        if (end > wasm.length || end < pos) return null; // truncated section table
-        if (id === 0) {
-            const [nameLen, namePos] = leb(wasm, pos);
-            if (
-                namePos + nameLen <= end &&
-                wasm.toString('latin1', namePos, namePos + nameLen) === want
-            )
-                return wasm.subarray(namePos + nameLen, end);
-        }
-        pos = end;
-    }
-    return null;
-}

package/src/devserver/wasm/surface.ts

@@ -1,115 +0,0 @@
-/**
- * Parse a compiled artifact's `toil.surface` custom section. Emitted into EVERY
- * Toil artifact by the toilscript `buildToilSurface` pass (hot AND cold). The dev
- * server reads it to decide whether each artifact carries the daemon surface
- * (start the daemon emulator) or the stream surface (Phase 4, deferred).
- *
- * Byte layout (RECONCILIATION Part 5, all little-endian; mirrors the toilscript
- * `CatWriter` emitter byte-for-byte):
- *
- *   u16 format_version = 1
- *   u8  target_mode            (0 = hot, 1 = cold; there is no target_mode = 2)
- *   u8  reserved0
- *   u32 surface_flags          (bit0 rest, bit1 stream, bit2 daemon,
- *                               bit3 scheduled, bit4 database, bit5 render)
- *   u16 abi_version
- *   str build_id               (u32 len + UTF-8)
- *   u32 fingerprint
- *   u32 data_coherence_hash
- *   u32 pair_coherence_hash    (exactly THREE u32 after build_id, not four)
- *
- * Fail-closed per Part 5's host rule: an absent or unparseable section is a
- * corrupt Toil artifact -> do not start that artifact's emulator.
- */
-
-import { DataReader } from 'toiljs/io';
-
-import { customSection } from './sections.js';
-
-export const SURFACE_FORMAT_VERSION = 1;
-export const SURFACE_ABI_VERSION = 1;
-
-const TARGET_HOT = 0;
-const TARGET_COLD = 1;
-const FLAG_REST = 1 << 0;
-const FLAG_STREAM = 1 << 1;
-const FLAG_DAEMON = 1 << 2;
-const FLAG_SCHEDULED = 1 << 3;
-const FLAG_DATABASE = 1 << 4;
-const FLAG_RENDER = 1 << 5;
-const FLAG_KNOWN_MASK =
-    FLAG_REST | FLAG_STREAM | FLAG_DAEMON | FLAG_SCHEDULED | FLAG_DATABASE | FLAG_RENDER;
-
-export interface SurfaceFlags {
-    readonly rest: boolean;
-    readonly stream: boolean;
-    readonly daemon: boolean;
-    readonly scheduled: boolean;
-    readonly database: boolean;
-    readonly render: boolean;
-}
-
-export interface Surface {
-    /** 0 = hot, 1 = cold. */
-    readonly targetMode: 'hot' | 'cold';
-    readonly flags: SurfaceFlags;
-    readonly abiVersion: number;
-    readonly buildId: string;
-    readonly fingerprint: number;
-    readonly dataCoherenceHash: number;
-    readonly pairCoherenceHash: number;
-}
-
-/** `'invalid'` => absent or corrupt (fail closed). Otherwise the parsed surface. */
-export function parseSurface(wasm: Buffer): Surface | 'invalid' {
-    let sec: Buffer | null;
-    try {
-        sec = customSection(wasm, 'toil.surface');
-    } catch {
-        return 'invalid'; // garbage section table
-    }
-    if (sec === null) return 'invalid';
-
-    const r = new DataReader(sec);
-    const version = r.readU16(); // format_version
-    if (!r.ok || version !== SURFACE_FORMAT_VERSION) return 'invalid';
-    const targetModeByte = r.readU8();
-    if (!r.ok || (targetModeByte !== TARGET_HOT && targetModeByte !== TARGET_COLD)) {
-        return 'invalid';
-    }
-    const targetMode = targetModeByte === TARGET_COLD ? 'cold' : 'hot';
-    const reserved0 = r.readU8(); // reserved0
-    if (!r.ok || reserved0 !== 0) return 'invalid';
-    const f = r.readU32(); // surface_flags
-    if (!r.ok || (f & ~FLAG_KNOWN_MASK) !== 0) return 'invalid';
-    if ((f & FLAG_SCHEDULED) !== 0 && (f & FLAG_DAEMON) === 0) return 'invalid';
-    if (targetMode === 'hot' && (f & (FLAG_DAEMON | FLAG_SCHEDULED)) !== 0) {
-        return 'invalid';
-    }
-    if (targetMode === 'cold' && (f & (FLAG_REST | FLAG_STREAM | FLAG_RENDER)) !== 0) {
-        return 'invalid';
-    }
-    const abiVersion = r.readU16();
-    if (!r.ok || abiVersion !== SURFACE_ABI_VERSION) return 'invalid';
-    const buildId = r.readString();
-    const fingerprint = r.readU32();
-    const dataCoherenceHash = r.readU32(); // exactly THREE u32 after build_id
-    const pairCoherenceHash = r.readU32();
-    if (!r.ok || r.remaining() !== 0) return 'invalid'; // PRESENT but corrupt => fail closed
-    return {
-        targetMode,
-        flags: {
-            rest: !!(f & 1),
-            stream: !!(f & 2),
-            daemon: !!(f & 4),
-            scheduled: !!(f & 8),
-            database: !!(f & 16),
-            render: !!(f & 32),
-        },
-        abiVersion,
-        buildId,
-        fingerprint,
-        dataCoherenceHash,
-        pairCoherenceHash,
-    };
-}