super-dsh 0.1.3 → 0.1.4

package/superd-hub/dist/world-provision.js

@@ -0,0 +1,196 @@
+/**
+ * Nested-world profile provisioning — the publish story.
+ *
+ * The dev line (test/smoke.mjs) hand-provisions every world's nested profile
+ * (`<home>/agents/<label>/profiles/web`) and the `@pgmi-builds/*` links its
+ * resolution needs. A foreign install has NO line bootstrap:
+ *
+ *   dsh plugin --profile <name> add super-dsh
+ *
+ * mounts the hub + adapter world plugins into the consumer's profile, and the
+ * spawn call sites (adapter world-plugins, hub join) must provision the same
+ * layout THEMSELVES or every world spawn fails on a missing profile.
+ *
+ * This module is the library form of that bootstrap, called by all six spawn
+ * sites. Layout invariants (super-dsh/AGENTS.md S7):
+ *
+ *   - `<worldHome>/profiles/web/package.json` — bundles `[dsh-base, dsh-web-app,
+ *     adapterPkg]`; the world tree is a full sibling root, nothing shared.
+ *   - `<worldHome>/profiles/web/cordis.patch.yml` — per-world home pinning:
+ *     every home-resolving DSH plugin reads THIS tree's nested root.
+ *   - `<worldHome>/profiles/web/node_modules/@pgmi-builds/{adapter,hub}` —
+ *     the plugin-add shape: with the host table widened (spawnWorld, spec
+ *     §2.1), these profile-local links serve the local-physical leg for the
+ *     world's own packages. No `@deepseek-ai` scope anywhere — those names
+ *     ride the host's installation entries.
+ *
+ * Link identity rule: both links point INSIDE the running line tree — the hub
+ * at this module's own package root, the adapter at its sibling
+ * `agent-<key>` directory — identical in the dev repo layout and inside the
+ * published single `super-dsh` package, so ctx0 and every world root share
+ * one hub/adapter instance with zero registry involvement.
+ *
+ * Returns whether the layout was provisioned; false (logged) when the
+ * adapter sibling does not exist next to the hub — a foreign composition
+ * this module does not own.
+ */
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+const HUB_SCOPE = '@pgmi-builds';
+/** The profile bundles every world tree composes besides its adapter. */
+const WORLD_BASE_BUNDLES = ['@deepseek-ai/dsh-base', '@deepseek-ai/dsh-web-app'];
+/**
+ * Resolve the running dsh installation's package.json — the anchor worlds
+ * resolve `@deepseek-ai` bundles and the fallback closure from.
+ *
+ * Precedence: `$SUPERD_DSH_ANCHOR` (the repo dev lines' contract — the
+ * launcher pins the checkout build), then a walk UP from the
+ * `@deepseek-ai/dsh-app-boot` this module resolved (the host always provides
+ * it) to the nearest ancestor package named `@deepseek-ai/dsh` — the
+ * packaged-install layout (`<install>/@deepseek-ai/dsh/node_modules/
+ * @deepseek-ai/dsh-app-boot`) lands on the install root in two hops. No
+ * machine-specific path ships in code.
+ * @throws when neither yields an installation (mis-launched composition).
+ */
+export function resolveInstallAnchor(host) {
+    // Spec §2.3: the host's launcher facts win — a world plugin runs in ctx0,
+    // where `profileContext` carries the exact anchor the live table was
+    // computed from. Env and the realpath walk remain for table-less harnesses.
+    const launcher = host?.get('profileContext');
+    if (launcher?.installAnchor !== undefined)
+        return launcher.installAnchor;
+    const fromEnv = process.env.SUPERD_DSH_ANCHOR;
+    if (fromEnv !== undefined && fromEnv !== '')
+        return fromEnv;
+    let dir = dirname(resolveHostPackageDir('@deepseek-ai/dsh-app-boot'));
+    while (true) {
+        const manifest = join(dir, 'package.json');
+        if (existsSync(manifest)) {
+            try {
+                const name = JSON.parse(readFileSync(manifest, 'utf8')).name;
+                if (name === '@deepseek-ai/dsh')
+                    return manifest;
+            }
+            catch { /* malformed intermediate manifest — keep walking */ }
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            throw new Error('super-dsh: cannot derive the dsh installation anchor (set SUPERD_DSH_ANCHOR)');
+        }
+        dir = parent;
+    }
+}
+/** First `node_modules` search-path candidate that exists for a specifier,
+ *  resolved to its REALPATH — farm and pnpm links must not leak into the
+ *  ancestor walk (the install tree only exists behind the symlink). */
+function resolveHostPackageDir(spec) {
+    const require = createRequire(import.meta.url);
+    // Interception first: under the launcher's resolution table the profile
+    // tree holds NO physical @deepseek-ai, but require.resolve goes through
+    // the patched Module._resolveFilename and lands on the installation's
+    // copy directly. resolve.paths() cannot see the table — it only lists
+    // physical walk-up candidates (the retired profiles-level farm is what
+    // used to plug this gap on consumer machines; 0.1.3-r prod evidence).
+    try {
+        return realpathSync(dirname(require.resolve(`${spec}/package.json`)));
+    }
+    catch { /* not intercepted or ./package.json not exported — walk */ }
+    for (const searchPath of require.resolve.paths(`${spec}/x`) ?? []) {
+        const candidate = join(searchPath, spec);
+        if (existsSync(join(candidate, 'package.json')))
+            return realpathSync(candidate);
+    }
+    throw new Error(`super-dsh: cannot resolve ${spec} from the running host (set SUPERD_DSH_ANCHOR)`);
+}
+/**
+ * Provision one world's nested profile (idempotent: rewrites profile files,
+ * re-links packages — lstat-safe against dangling links). Returns whether
+ * the layout landed.
+ *
+ * Never throws: any provisioning failure is logged and returns false so the
+ * calling world plugin degrades to a not-ready roster row instead of failing
+ * the loader entry — a failed apply would take down the whole host boot.
+ */
+export function provisionWorldProfile(opts) {
+    try {
+        return provisionWorldProfileUnchecked(opts);
+    }
+    catch (cause) {
+        console.error(`[super-dsh] provisioning world '${opts.key}' failed:`, cause);
+        return false;
+    }
+}
+function provisionWorldProfileUnchecked(opts) {
+    // Single-pack topology: this module lives at `<line>/superd-hub/dist/`, and
+    // every adapter is a SIBLING directory (`<line>/agent-<key>`) — the same
+    // layout in the repo (dev link: lines) and inside the published `super-dsh`
+    // package. The adapter link therefore points at the sibling; no registry
+    // resolution is involved anywhere.
+    const hubRoot = dirname(dirname(fileURLToPath(import.meta.url))); // <line>/superd-hub
+    const lineRoot = dirname(hubRoot); // monolith root / repo super-dsh/
+    const adapterDir = join(lineRoot, `agent-${opts.key}`);
+    if (!existsSync(join(adapterDir, 'package.json')))
+        return false;
+    const profileName = opts.profileName ?? 'web';
+    const profDir = join(opts.worldHome, 'profiles', profileName);
+    mkdirSync(profDir, { recursive: true });
+    writeFileSync(join(profDir, 'package.json'), JSON.stringify({
+        name: `superd-${opts.key}-world-profile`,
+        private: true,
+        dsh: { profile: { bundles: [...WORLD_BASE_BUNDLES, opts.adapterPkg] } },
+    }, null, 2) + '\n');
+    // Per-world home pinning (smoke.mjs parity): settings, credentials,
+    // attachments, shell env and skills all land inside `agents/<key>/`.
+    // (`agent-instructions` keeps its base `maxBytes` home — instruction
+    // discovery root, not agent data.)
+    //
+    // 0.1.7: the profile hmr row arms itself wherever a profileContext exists,
+    // and its config reload recomposes the tree from THE PROFILE LAYERS ALONE —
+    // spawn-time extraPatches do not survive it. The zero-listener posture is
+    // therefore PERSISTED in this layer (webserver disabled + ephemeral port,
+    // hmr itself off — a world's composition is a spawn-time fact and must not
+    // be re-derived), exactly mirroring worldMountPatches.
+    writeFileSync(join(profDir, 'cordis.patch.yml'), [
+        '# Per-world home pinning (dshHomePath is this tree\'s nested home).',
+        ...['settings', 'credentials', 'attachment-local', 'shell-env', 'skill-filesystem'].flatMap((id) => [`- id: ${id}`, '  config:', '    dshHome: !!js dshHomePath()']),
+        '# Zero-listener posture (0.1.7): persisted so hmr/launcher recomposition',
+        '# cannot re-enable the world\'s own listener (default port 3080).',
+        '- id: webserver',
+        '  disabled: true',
+        '  config:',
+        '    host: 127.0.0.1',
+        '    port: 0',
+        '- id: hmr',
+        '  disabled: true',
+        '',
+    ].join('\n'));
+    // @pgmi-builds links, plugin-add shape: adapter + hub into the world
+    // profile's OWN node_modules (resolveBundleDir consults the profile
+    // directory; the local-physical leg of the widened host table consumes
+    // the same links for row imports — spec §2.1). Dangling links first
+    // (lstat: existsSync is false for them, which skipped rmSync and crashed
+    // symlinkSync with EEXIST after repo moves).
+    const links = [
+        [opts.adapterPkg.slice(HUB_SCOPE.length + 1), adapterDir],
+        ['superd-hub', hubRoot],
+    ];
+    const linkRoot = join(profDir, 'node_modules');
+    mkdirSync(join(linkRoot, HUB_SCOPE), { recursive: true });
+    for (const [name, target] of links) {
+        const dst = join(linkRoot, HUB_SCOPE, name);
+        const st = lstatSync(dst, { throwIfNoEntry: false });
+        if (st)
+            rmSync(dst, { recursive: true, force: true });
+        symlinkSync(target, dst);
+    }
+    // Retired machinery (spec §3): scrub the profiles-level farm this function
+    // wrote before 2026-09-25. Stale links there sit inside the widened
+    // local-physical walk and would shadow the host table's installation
+    // entries with frozen-generation targets.
+    const staleFarm = join(opts.worldHome, 'profiles', 'node_modules');
+    rmSync(join(staleFarm, '@deepseek-ai'), { recursive: true, force: true });
+    rmSync(join(staleFarm, HUB_SCOPE), { recursive: true, force: true });
+    return true;
+}

package/{agent-hub → superd-hub}/dist/world-web-server.js

@@ -204,11 +204,17 @@ export class WorldWebServer {
      * happily re-root them under this world's label.
      */
     renderIndex(html) {
+        // Injection rows FIRST, the client shim LAST: index-inject rows may need
+        // to own the transport global before anything else materializes — the
+        // page-trust component's `window.__DSH_TRANSPORT__ = { ownsHost: true }`
+        // guards on absence, while the shim MERGES into an existing object
+        // (`globalThis.__DSH_TRANSPORT__ = globalThis.__DSH_TRANSPORT__ || {}`).
+        // Shim-first would create the object and silently eat the verdict.
         const rows = [
-            { kind: 'script', placement: 'head', text: renderClientShim(this.labelPath) },
             // No hub-invented widget here: the world composes the hub's own client
             // plugin (see worldMountPatches), so its selector IS the native one.
             ...this.collectIndexInjections(),
+            { kind: 'script', placement: 'head', text: renderClientShim(this.labelPath) },
         ];
         const rendered = this.applyIndexTaps(renderIndexInjections(html, rows));
         // The roster rides the outbound pass (htmlRewrite), not this one: the mount

package/{agent-hub → superd-hub}/package.json

@@ -1,43 +1,36 @@
 {
-  "name": "@pgmi-builds/agent-hub",
+  "name": "@pgmi-builds/superd-hub",
   "version": "0.1.0",
-  "description": "Agent Worlds hub host half: world inventory control plane, roster, world spawner and the single-origin per-world mount carrier (no server-side selection; the addressed world is the request's mount path)",
+  "description": "Super D hub host half: world inventory control plane, roster, world spawner and the single-origin per-world mount carrier (no server-side selection; the addressed world is the request's mount path)",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
-    "./client": "./lib/client/index.js",
     "./world": "./dist/world-entry.js",
-    "./join": "./dist/world-join.js"
+    "./join": "./dist/world-join.js",
+    "./web-trust": "./dist/web-trust.js"
   },
   "files": [
     "dist",
-    "lib",
     "cordis.patch.yml"
   ],
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "inject": [
-        "@deepseek-ai/dsh-client-ui-slots"
-      ],
-      "platform": "web"
     }
   },
   "scripts": {
     "build": "tsc -p .",
-    "build-client": "node scripts/build-client.mjs",
     "test": "node --test --test-force-exit test/*.test.mjs"
   },
   "dependencies": {
+    "js-yaml": "^4.3.2",
     "ws": "^8.21.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "*",
-    "@deepseek-ai/dsh-api-gateway": "*",
-    "@deepseek-ai/dsh-host-webserver": "*",
-    "@deepseek-ai/dsh-typert-protocol": "*"
+    "@deepseek-ai/dsh-api-gateway": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-host-webserver": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-typert-protocol": ">=0.1.5-0 <0.3.0-0"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis": {
@@ -54,8 +47,8 @@
     }
   },
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^26.5.1",
-    "tsdown": "^0.15.12",
     "typescript": "5.9.3"
   },
   "publishConfig": {

package/agent-hub/dist/spawn-world.js

@@ -1,72 +0,0 @@
-/**
- * spawnWorld (S2): spawn a sibling ROOT context for a foreign agent world
- * from the CTX0 tree — the library form of the PoC (ADR 0008 mechanism,
- * .scratch/multi-context-poc/spawner2.mjs collapsed into a function).
- *
- * AW-A posture: SHARED home (ADR 0008 constraint 2 fallback). The ctxN
- * `dshHomePath` service override is an AW-C1 item (spec §三/§十一.2) — the
- * boot() provide/prepare ordering fact is pinned by
- * test/boot-prepare-ordering.test.mjs. Data detachment at this stage comes
- * from the adapter side (foreign app-home redirection, spec §七).
- *
- * Profile resolution: loadProfile(name, profileName, installAnchor, home)
- * reads profiles under `<home>/profiles/<profileName>` and heals the
- * `@deepseek-ai/*` fallback farm into `<home>/profiles/node_modules` from
- * the install anchor (single instance — same physical installation).
- */
-import { loadProfile, boot } from '@deepseek-ai/dsh-app-boot';
-import { provideCmdline } from '@deepseek-ai/dsh-cmdline';
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-const EMPTY_ROOT = '[]\n';
-export async function spawnWorld(opts) {
-    const profile = loadProfile(opts.appName, opts.profileName, opts.installAnchor, opts.home);
-    // Empty include root: the tree is composed entirely as patch layers
-    // (bundle rows in profile order + profile patch + extras).
-    writeFileSync(join(profile.dir, 'cordis.yml'), EMPTY_ROOT);
-    const patches = [
-        ...profile.layers.flatMap((l) => l.patches),
-        ...profile.patches,
-        ...(opts.extraPatches ?? []),
-    ];
-    // Bare plugin names resolve from the installation's node_modules (the
-    // anchor owns the complete plugin closure). Same cordis on both sides —
-    // no cross-copy Symbol split.
-    // Loader wants a file:// URL base; accept a plain path and normalize.
-    const rawBase = opts.bareModuleBaseUrl ?? join(opts.installAnchor, '..', 'node_modules', '/');
-    const bareModuleBaseUrl = rawBase.startsWith('file:')
-        ? rawBase
-        : pathToFileURL(rawBase.endsWith('/') ? rawBase : rawBase + '/').href;
-    // Embedding-host facts via the PUBLIC cmdline API (risk-2 probe: boot owns
-    // dshHomePath, so the prepare slot is for OUR provides — cmdlineArgs is not
-    // boot-provided and upstream documents the empty-args embedding path).
-    // Worlds take no flags and never open a browser; exit = dispose own fiber.
-    // LAN authorities for the world's trust fence (deploy-level, env-driven):
-    // the world webserver must accept the Host the browser actually sends.
-    const trusted = (process.env.AW_TRUSTED_HOSTS ?? '')
-        .split(/[\s,]+/).filter(Boolean)
-        .flatMap((h) => ['--trusted-host', h]);
-    let fiber;
-    const ctxW = await boot(opts.appName, join(profile.dir, 'cordis.yml'), patches, (ctx) => {
-        provideCmdline(ctx, {
-            args: ['--no-open', ...trusted],
-            exit: () => { void fiber?.dispose(); },
-        });
-        // This tree reads its own home from here on: sessions, settings.yaml,
-        // workspace store — all under the world's nested root.
-        //
-        // `set` (not `provide`): boot already registered `dshHomePath` on this
-        // root, and cordis refuses a second `provide` in the same scope
-        // ("service … has been registered at <root>"). `set` is the documented
-        // "overwrite a provided service's value" path for the owning fiber, which
-        // the prepare slot is — and ADR 0008 constraint 2 prescribes exactly this
-        // in-tree override (process.env is a shared resolver and must not change).
-        if (opts.dataHome !== undefined) {
-            const dataHome = opts.dataHome;
-            ctx.set('dshHomePath', (...segments) => join(dataHome, ...segments));
-        }
-    }, bareModuleBaseUrl);
-    fiber = ctxW.fiber;
-    return ctxW;
-}

package/agent-hub/dist/world-mux.js

@@ -1,224 +0,0 @@
-/**
- * Per-world Remote stream mux server (AW-B DL6).
- *
- * Upstream's `RemoteStreamMuxServer` owns `/api/remote.mux` for the native
- * gateway and is NOT reachable from outside its package (root exports omit it;
- * `./src/*` cannot be imported at runtime). So this is our own wire-compatible
- * implementation of the same protocol, bound to the ADDRESSED world's
- * `openWireStream`:
- *
- *   browser → server   { type:'open', streamId, endpoint, payload }
- *                      { type:'cancel', streamId }
- *   server → browser   { type:'item', streamId, value }
- *                      { type:'end', streamId }
- *                      { type:'error', streamId, error:{code,message,details} }
- *
- * Heartbeat: ping every interval, terminate after two missed pongs (same
- * policy as upstream).
- */
-/** Specifier is widened on purpose: `ws` is a runtime peer, not a typed dep. */
-const WS_MODULE = 'ws';
-const MAX_MISSED_HEARTBEATS = 2;
-const DEFAULT_HEARTBEAT_MS = 30_000;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function exactKeys(value, keys) {
-    const own = Object.keys(value);
-    return own.length === keys.length && keys.every(key => Object.hasOwn(value, key));
-}
-function validId(value) {
-    return typeof value === 'string' && value.length > 0;
-}
-/**
- * Parse one browser text frame.
- * @param text - complete WebSocket text message.
- * @returns the validated request.
- * @throws {Error} on a malformed frame.
- */
-export function parseClientMessage(text) {
-    let raw;
-    try {
-        raw = JSON.parse(text);
-    }
-    catch {
-        throw new Error('world-mux: invalid client message');
-    }
-    if (!isRecord(raw))
-        throw new Error('world-mux: invalid client message');
-    if (raw['type'] === 'cancel' && exactKeys(raw, ['type', 'streamId']) && validId(raw['streamId'])) {
-        return { type: 'cancel', streamId: raw['streamId'] };
-    }
-    if (raw['type'] === 'open'
-        && exactKeys(raw, ['type', 'streamId', 'endpoint', 'payload'])
-        && validId(raw['streamId'])
-        && typeof raw['endpoint'] === 'string'
-        && raw['endpoint'].length > 0) {
-        return { type: 'open', streamId: raw['streamId'], endpoint: raw['endpoint'], payload: raw['payload'] };
-    }
-    throw new Error('world-mux: invalid client message');
-}
-/** Default failure mapper: keep the error code when it looks like one. */
-export function defaultFailure(error) {
-    if (isRecord(error)) {
-        const code = typeof error['code'] === 'string' ? error['code'] : undefined;
-        const message = typeof error['message'] === 'string' ? error['message'] : undefined;
-        if (code !== undefined)
-            return { code, message: message ?? code, details: {} };
-    }
-    return { code: 'gateway/stream-error', message: error instanceof Error ? error.message : String(error), details: {} };
-}
-/** One world's mux endpoint. */
-export class WorldMuxServer {
-    open;
-    options;
-    server;
-    ws;
-    heartbeat;
-    connections = new Set();
-    missed = new WeakMap();
-    closed = false;
-    constructor(open, options = {}) {
-        this.open = open;
-        this.options = options;
-    }
-    /** Take over one accepted upgrade request. */
-    async handleUpgrade(req, socket, head) {
-        const { server, ws } = await this.load();
-        server.handleUpgrade(req, socket, head, (client) => {
-            this.missed.set(client, 0);
-            client.on('pong', () => { this.missed.set(client, 0); });
-            this.startHeartbeat();
-            const done = this.runConnection(client, ws);
-            this.connections.add(done);
-            void done.then(() => { this.connections.delete(done); });
-        });
-    }
-    /** Terminate every socket and wait for the active streams to unwind. */
-    async close() {
-        this.closed = true;
-        clearInterval(this.heartbeat);
-        this.heartbeat = undefined;
-        const server = this.server;
-        if (server !== undefined) {
-            for (const client of server.clients)
-                client.terminate();
-            await new Promise((resolve) => { server.close(() => resolve()); });
-        }
-        await Promise.all([...this.connections]);
-    }
-    async load() {
-        if (this.server !== undefined && this.ws !== undefined)
-            return { server: this.server, ws: this.ws };
-        const mod = (await import(WS_MODULE));
-        const ws = typeof mod.WebSocketServer === 'function' ? mod : mod.default;
-        const server = new ws.WebSocketServer({ noServer: true });
-        this.server = server;
-        this.ws = ws;
-        return { server, ws };
-    }
-    async runConnection(client, ws) {
-        const streams = new Map();
-        let writes = Promise.resolve();
-        const send = (message) => {
-            let text;
-            try {
-                text = JSON.stringify(message);
-            }
-            catch (cause) {
-                return Promise.reject(new Error('world-mux: item is not JSON serializable', { cause }));
-            }
-            const delivery = writes.then(() => new Promise((resolve, reject) => {
-                if (client.readyState !== ws.WebSocket.OPEN) {
-                    reject(new Error('world-mux: socket is closed'));
-                    return;
-                }
-                client.send(text, (error) => { if (error)
-                    reject(error);
-                else
-                    resolve(); });
-            }));
-            writes = delivery.catch(() => undefined);
-            return delivery;
-        };
-        const pump = async (streamId, endpoint, payload, active) => {
-            try {
-                const source = await this.open(endpoint, payload, active.abort.signal);
-                for await (const value of source) {
-                    await send({ type: 'item', streamId, value });
-                }
-                if (!active.abort.signal.aborted)
-                    await send({ type: 'end', streamId });
-            }
-            catch (error) {
-                if (!active.abort.signal.aborted && client.readyState === ws.WebSocket.OPEN) {
-                    const failure = (this.options.failure ?? defaultFailure)(error);
-                    try {
-                        await send({ type: 'error', streamId, error: failure });
-                    }
-                    catch {
-                        client.close(1011, 'Remote stream failure could not be delivered');
-                    }
-                }
-            }
-        };
-        await new Promise((resolve) => {
-            client.once('close', () => { resolve(); });
-            client.on('error', () => { client.terminate(); });
-            client.on('message', (data, isBinary) => {
-                if (isBinary === true) {
-                    client.close(1003, 'text messages required');
-                    return;
-                }
-                let message;
-                try {
-                    message = parseClientMessage(String(data));
-                }
-                catch {
-                    client.close(1008, 'invalid Remote stream request');
-                    return;
-                }
-                if (message.type === 'cancel') {
-                    streams.get(message.streamId)?.abort.abort(new Error('Remote stream cancelled'));
-                    return;
-                }
-                if (streams.has(message.streamId)) {
-                    client.close(1008, 'duplicate Remote stream id');
-                    return;
-                }
-                const abort = new AbortController();
-                const active = { abort, done: Promise.resolve() };
-                streams.set(message.streamId, active);
-                const done = pump(message.streamId, message.endpoint, message.payload, active);
-                active.done = done;
-                void done.then(() => streams.delete(message.streamId), () => streams.delete(message.streamId));
-            });
-        });
-        const active = [...streams.values()];
-        for (const stream of active)
-            stream.abort.abort(new Error('Remote stream socket closed'));
-        await Promise.all(active.map(stream => stream.done));
-    }
-    startHeartbeat() {
-        if (this.heartbeat !== undefined || this.closed)
-            return;
-        const interval = this.options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS;
-        this.heartbeat = setInterval(() => {
-            const server = this.server;
-            if (server === undefined)
-                return;
-            for (const client of server.clients) {
-                if (client.readyState !== (this.ws?.WebSocket.OPEN ?? 1))
-                    continue;
-                const missed = this.missed.get(client) ?? 0;
-                if (missed >= MAX_MISSED_HEARTBEATS) {
-                    client.terminate();
-                    continue;
-                }
-                this.missed.set(client, missed + 1);
-                client.ping();
-            }
-        }, interval);
-        this.heartbeat.unref();
-    }
-}