@aethervtt/shard-net 0.0.0-stage → 0.4.1

package/dist/conditions.js

@@ -0,0 +1,128 @@
+import { Rng } from "@aethervtt/shard-core";
+function isConditioned(transport) {
+  return typeof transport.setConditions === "function";
+}
+const defaultNow = () => globalThis.performance?.now() ?? Date.now();
+class ConditionedConnection {
+  inner;
+  shared;
+  outbound = [];
+  inbound = [];
+  messageFns = [];
+  lastReliableOut = 0;
+  lastReliableIn = 0;
+  lost = 0;
+  constructor(inner, shared) {
+    this.inner = inner;
+    this.shared = shared;
+    inner.onMessage((channel, bytes) => {
+      this.schedule(this.inbound, channel, bytes.slice(), "in");
+    });
+  }
+  get peer() {
+    return this.inner.peer;
+  }
+  send(channel, bytes) {
+    this.schedule(this.outbound, channel, bytes.slice(), "out");
+    const now = this.shared.now();
+    while (this.outbound.length > 0 && this.outbound[0].at <= now) {
+      const m = this.outbound.shift();
+      this.inner.send(m.channel, m.bytes);
+    }
+  }
+  schedule(queue, channel, bytes, dir) {
+    const c = this.shared.conditions;
+    const rng = this.shared.rng;
+    const now = this.shared.now();
+    if (channel === "unreliable" && c.loss > 0 && rng.float() < c.loss) {
+      this.lost++;
+      return;
+    }
+    let at = now + (c.latency + rng.float() * c.jitter) * 1e3;
+    if (channel === "reliable" || !c.reorder) {
+      const last = dir === "in" ? this.lastReliableIn : this.lastReliableOut;
+      if (at < last) at = last;
+      if (dir === "in") this.lastReliableIn = at;
+      else this.lastReliableOut = at;
+    }
+    insert(queue, { at, channel, bytes });
+    if (channel === "unreliable" && c.duplicate > 0 && rng.float() < c.duplicate) {
+      insert(queue, { at: at + rng.float() * c.jitter * 1e3, channel, bytes });
+    }
+  }
+  pump() {
+    this.inner.pump?.();
+    const now = this.shared.now();
+    let n = 0;
+    while (n < this.outbound.length && this.outbound[n].at <= now) n++;
+    for (const m of this.outbound.splice(0, n)) this.inner.send(m.channel, m.bytes);
+    n = 0;
+    while (n < this.inbound.length && this.inbound[n].at <= now) n++;
+    for (const m of this.inbound.splice(0, n)) {
+      for (const fn of this.messageFns) fn(m.channel, m.bytes);
+    }
+  }
+  onMessage(fn) {
+    this.messageFns.push(fn);
+    return () => {
+      const i = this.messageFns.indexOf(fn);
+      if (i !== -1) this.messageFns.splice(i, 1);
+    };
+  }
+  onClose(fn) {
+    return this.inner.onClose(fn);
+  }
+  close(reason) {
+    this.inner.close(reason);
+  }
+  stats() {
+    const s = this.inner.stats();
+    return { ...s, lost: s.lost + this.lost };
+  }
+}
+function insert(queue, m) {
+  let i = queue.length;
+  while (i > 0 && queue[i - 1].at > m.at) i--;
+  queue.splice(i, 0, m);
+}
+function simulateConditions(transport, options = {}) {
+  const shared = {
+    conditions: {
+      latency: options.latency ?? 0,
+      jitter: options.jitter ?? 0,
+      loss: options.loss ?? 0,
+      duplicate: options.duplicate ?? 0,
+      reorder: options.reorder ?? true
+    },
+    rng: new Rng(options.seed ?? 1),
+    now: options.now ?? defaultNow
+  };
+  const wrapped = {
+    name: `${transport.name}+conditions`,
+    caps: transport.caps,
+    get conditions() {
+      return shared.conditions;
+    },
+    setConditions(conditions) {
+      shared.conditions = { ...shared.conditions, ...conditions };
+    },
+    async connect(address, connectOptions) {
+      return new ConditionedConnection(await transport.connect(address, connectOptions), shared);
+    }
+  };
+  if (transport.listen) {
+    const listen = transport.listen.bind(transport);
+    wrapped.listen = async (listenOptions) => {
+      const inner = await listen(listenOptions);
+      return {
+        onConnection: (fn) => inner.onConnection((connection) => fn(new ConditionedConnection(connection, shared))),
+        close: () => inner.close()
+      };
+    };
+  }
+  return wrapped;
+}
+export {
+  isConditioned,
+  simulateConditions
+};

package/dist/host.d.ts

@@ -0,0 +1,38 @@
+import { App, type Plugin, type Runner } from '@aethervtt/shard-runtime';
+import { type NetOptions } from './plugin.js';
+import type { NetSessionProvider, NetTransport } from './transport.js';
+export interface HostOptions<U = unknown, L = unknown, S = unknown> {
+    /** The server App's plugins (the game's rules), made fresh for it. */
+    plugins?: () => Plugin[];
+    /** Server net options: replicate, commands, events, accept, players, interest, meta… */
+    net: Omit<NetOptions<U, L, S>, 'role' | 'transport' | 'address' | 'session' | 'code'>;
+    /** How remote players reach the host: a lobby such as `webRtcLobby` (0091). */
+    session: NetSessionProvider;
+    fixedHz?: number;
+    seed?: number;
+    /** Default `intervalRunner()`: the host keeps simulating without a display to pace it. */
+    runner?: Runner;
+    /** Makes the server App (default `new App`): a project's headless build, say (0092). */
+    createApp?: () => App;
+    /** Runs after the server App's init, before it runs (an asset scan). */
+    afterInit?: (app: App) => Promise<void>;
+}
+export interface Host {
+    /** The server App, running. */
+    readonly app: App;
+    /** The room code remote players join with. */
+    readonly code: string;
+    /** The host player's own connection: spread into the client's `netPlugin`. */
+    readonly local: {
+        readonly transport: NetTransport;
+        readonly address: string;
+    };
+    /** Saves players (0090), closes the room and every connection, and stops the server. */
+    stop(): Promise<void>;
+}
+/**
+ * Hosts a game from this process (0091): runs the server App next to the player's client App,
+ * takes remote players through `session`, and gives the host player a loopback connection. The
+ * host player is an ordinary client of its own server.
+ */
+export declare function startHost<U = unknown, L = unknown, S = unknown>(options: HostOptions<U, L, S>): Promise<Host>;

package/dist/host.js

@@ -0,0 +1,55 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { App, intervalRunner } from "@aethervtt/shard-runtime";
+import { loopback } from "./loopback.js";
+import { netPlugin, netSession } from "./plugin.js";
+function mergeListeners(listeners) {
+  return {
+    onConnection(fn) {
+      const offs = listeners.map((l) => l.onConnection(fn));
+      return () => {
+        for (const off of offs) off();
+      };
+    },
+    async close() {
+      await Promise.all(listeners.map((l) => l.close()));
+    }
+  };
+}
+async function startHost(options) {
+  const local = loopback({ maxMessage: options.session.caps?.maxMessage ?? 1 << 20 });
+  const address = "host";
+  const remote = options.session;
+  const session = {
+    name: `host+${remote.name}`,
+    ...remote.caps ? { caps: remote.caps } : {},
+    async host(listen) {
+      const [hosted, mine] = await Promise.all([remote.host(listen), local.listen({ address })]);
+      return { code: hosted.code, listener: mergeListeners([hosted.listener, mine]) };
+    },
+    join: (code, join) => remote.join(code, join)
+  };
+  const app = options.createApp?.() ?? new App({ fixedHz: options.fixedHz ?? 60, seed: options.seed ?? 0 });
+  for (const p of options.plugins?.() ?? []) app.addPlugin(p);
+  app.addPlugin(netPlugin({ ...options.net, role: "server", session }));
+  app.setRunner(options.runner ?? intervalRunner());
+  await app.init();
+  await options.afterInit?.(app);
+  const net = netSession(app.world);
+  await net.ready;
+  if (net.code === void 0) {
+    throw new ShardError("net/cannot-listen", `The ${remote.name} session gave no room code`);
+  }
+  const running = app.run();
+  return {
+    app,
+    code: net.code,
+    local: { transport: local, address },
+    async stop() {
+      await app.dispose();
+      await running;
+    }
+  };
+}
+export {
+  startHost
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { NetClient, PendingCommand } from './client.js';
+export { Connected, Disconnected, Focus, NetClock, type NetClockData, NetId, NetRole, type NetRoleData, type NetRoleName, type PeerInfo, PeerJoined, PeerLeft, Peers, PlayerSaveFailed, Relevance, Replicated, } from './components.js';
+export { type ConditionedTransport, type ConditionsOptions, isConditioned, type NetConditions, simulateConditions, } from './conditions.js';
+export { type Host, type HostOptions, startHost } from './host.js';
+export { allOf, alwaysInterest, anyOf, type GridInterestOptions, gridInterest, type InterestPeer, type InterestPolicy, ownerInterest, RelevanceSet, teamInterest, } from './interest.js';
+export { type LoopbackOptions, loopback } from './loopback.js';
+export { commands, connected, hasAuthority, type NetOptions, NetSession, type NetSessionData, NetSystems, netPlugin, netSession, onClient, onServer, type SendEventOptions, savePlayer, sendCommand, sendEvent, } from './plugin.js';
+export { defineNetCommand, defineNetEvent, type NetCommandDef, type NetEventData, type NetEventDef, ownerOf, ownerOnly, type ReplicateOptions, type ReplicationEntry, type ReplicationMode, replicate, } from './registry.js';
+export { type AcceptResult, type JoinContext, type LeaveContext, NetServer, type PeerStats, type PlayerHooks, ServerCommand, } from './server.js';
+export { type Channel, type ConnectionStats, type ConnectOptions, directSession, type ListenOptions, type NetConnection, type NetListener, type NetSessionProvider, type NetTransport, type PeerId, type SessionInfo, type TransportCaps, } from './transport.js';
+export { buildManifest, Fragmenter, type Manifest, Msg, PROTOCOL_VERSION } from './wire.js';

package/dist/index.js

@@ -0,0 +1,110 @@
+import { NetClient, PendingCommand } from "./client.js";
+import {
+  Connected,
+  Disconnected,
+  Focus,
+  NetClock,
+  NetId,
+  NetRole,
+  PeerJoined,
+  PeerLeft,
+  Peers,
+  PlayerSaveFailed,
+  Relevance,
+  Replicated
+} from "./components.js";
+import {
+  isConditioned,
+  simulateConditions
+} from "./conditions.js";
+import { startHost } from "./host.js";
+import {
+  allOf,
+  alwaysInterest,
+  anyOf,
+  gridInterest,
+  ownerInterest,
+  RelevanceSet,
+  teamInterest
+} from "./interest.js";
+import { loopback } from "./loopback.js";
+import {
+  commands,
+  connected,
+  hasAuthority,
+  NetSession,
+  NetSystems,
+  netPlugin,
+  netSession,
+  onClient,
+  onServer,
+  savePlayer,
+  sendCommand,
+  sendEvent
+} from "./plugin.js";
+import {
+  defineNetCommand,
+  defineNetEvent,
+  ownerOf,
+  ownerOnly,
+  replicate
+} from "./registry.js";
+import {
+  NetServer,
+  ServerCommand
+} from "./server.js";
+import {
+  directSession
+} from "./transport.js";
+import { buildManifest, Fragmenter, Msg, PROTOCOL_VERSION } from "./wire.js";
+export {
+  Connected,
+  Disconnected,
+  Focus,
+  Fragmenter,
+  Msg,
+  NetClient,
+  NetClock,
+  NetId,
+  NetRole,
+  NetServer,
+  NetSession,
+  NetSystems,
+  PROTOCOL_VERSION,
+  PeerJoined,
+  PeerLeft,
+  Peers,
+  PendingCommand,
+  PlayerSaveFailed,
+  Relevance,
+  RelevanceSet,
+  Replicated,
+  ServerCommand,
+  allOf,
+  alwaysInterest,
+  anyOf,
+  buildManifest,
+  commands,
+  connected,
+  defineNetCommand,
+  defineNetEvent,
+  directSession,
+  gridInterest,
+  hasAuthority,
+  isConditioned,
+  loopback,
+  netPlugin,
+  netSession,
+  onClient,
+  onServer,
+  ownerInterest,
+  ownerOf,
+  ownerOnly,
+  replicate,
+  savePlayer,
+  sendCommand,
+  sendEvent,
+  simulateConditions,
+  startHost,
+  teamInterest
+};

package/dist/interest.d.ts

@@ -0,0 +1,67 @@
+import { type ComponentDef, type Entity, type Fields, type World } from '@aethervtt/shard-core';
+import type { PeerId } from './transport.js';
+/**
+ * A set of entities with a stable iteration order. Membership is a stamp per entity index, so
+ * `clear` is O(1) and refilling it every tick allocates nothing once it has grown.
+ */
+export declare class RelevanceSet {
+    private readonly list;
+    private stamp;
+    private marks;
+    private ids;
+    private grow;
+    add(entity: Entity): void;
+    has(entity: Entity): boolean;
+    get size(): number;
+    /** The entity at `i`, in the order they were added. */
+    at(i: number): Entity;
+    /** A copy, for tools. */
+    get entities(): Entity[];
+    clear(): void;
+    /** Keeps the entities `keep` returns true for. */
+    retain(keep: (entity: Entity) => boolean): void;
+}
+/** What a policy knows about the peer it decides for. */
+export interface InterestPeer {
+    readonly id: PeerId;
+    /** The entities the peer owns and its `Focus` entities, this tick. */
+    readonly focus: readonly Entity[];
+    /** Whether the peer has the entity now: policies keep known entities a little longer. */
+    knows(entity: Entity): boolean;
+}
+/**
+ * Decides which replicated entities a peer receives (0087). The server runs it every network
+ * tick; anything it leaves out is never encoded for that peer, and despawns on its side.
+ */
+export interface InterestPolicy {
+    readonly name: string;
+    /** Once per network tick, before any peer: rebuild shared indexes. */
+    prepare?(world: World): void;
+    update(world: World, peer: InterestPeer, out: RelevanceSet): void;
+}
+/** Every replicated entity (with all of `filter`, if given): turn order, scores, the board. */
+export declare function alwaysInterest(filter?: readonly ComponentDef[]): InterestPolicy;
+/** Entities the peer owns, and their children (through `ChildOf`). */
+export declare function ownerInterest(): InterestPolicy;
+export interface GridInterestOptions {
+    /** Cell edge in metres. */
+    cellSize: number;
+    /** Cells around each focus cell a peer receives (Chebyshev distance). */
+    range: number;
+    /** Cells on Y too (space, tall worlds). Default false: cells are columns on X and Z. */
+    vertical?: boolean;
+}
+/**
+ * Entities within `range` cells of the peer's focus (0087), by world position. A known entity
+ * stays relevant one cell further, so one at the edge doesn't flicker in and out.
+ */
+export declare function gridInterest(options: GridInterestOptions): InterestPolicy;
+/**
+ * Entities whose `field` of `component` equals that of the peer's first focus entity having it:
+ * teammates see each other wherever they are.
+ */
+export declare function teamInterest<F extends Fields>(component: ComponentDef<F>, field: keyof F & string): InterestPolicy;
+/** Everything any of the policies includes. */
+export declare function anyOf(...policies: InterestPolicy[]): InterestPolicy;
+/** What every policy includes. */
+export declare function allOf(...policies: InterestPolicy[]): InterestPolicy;

package/dist/interest.js

@@ -0,0 +1,277 @@
+import {
+  ChildOf,
+  entityIndex
+} from "@aethervtt/shard-core";
+import { GlobalTransform, Transform } from "@aethervtt/shard-transform";
+import { Replicated } from "./components.js";
+import { NumberList } from "./vec.js";
+class RelevanceSet {
+  list = new NumberList();
+  stamp = 1;
+  marks = new Uint32Array(64);
+  ids = new Float64Array(64);
+  grow(index) {
+    let size = this.marks.length;
+    while (size <= index) size *= 2;
+    const marks = new Uint32Array(size);
+    marks.set(this.marks);
+    const ids = new Float64Array(size);
+    ids.set(this.ids);
+    this.marks = marks;
+    this.ids = ids;
+  }
+  add(entity) {
+    const i = entityIndex(entity);
+    if (i >= this.marks.length) this.grow(i);
+    if (this.marks[i] === this.stamp && this.ids[i] === entity) return;
+    this.marks[i] = this.stamp;
+    this.ids[i] = entity;
+    this.list.push(entity);
+  }
+  has(entity) {
+    const i = entityIndex(entity);
+    return i < this.marks.length && this.marks[i] === this.stamp && this.ids[i] === entity;
+  }
+  get size() {
+    return this.list.length;
+  }
+  /** The entity at `i`, in the order they were added. */
+  at(i) {
+    return this.list.data[i];
+  }
+  /** A copy, for tools. */
+  get entities() {
+    return this.list.toArray();
+  }
+  clear() {
+    this.list.clear();
+    if (++this.stamp === 4294967295) {
+      this.marks.fill(0);
+      this.stamp = 1;
+    }
+  }
+  /** Keeps the entities `keep` returns true for. */
+  retain(keep) {
+    const data = this.list.data;
+    let n = 0;
+    for (let i = 0; i < this.list.length; i++) {
+      const e = data[i];
+      if (keep(e)) data[n++] = e;
+      else this.marks[entityIndex(e)] = 0;
+    }
+    this.list.length = n;
+  }
+}
+function cachedQuery(desc) {
+  let world;
+  let query;
+  return (w) => {
+    if (w !== world || !query) {
+      world = w;
+      query = w.query(desc());
+    }
+    return query;
+  };
+}
+function alwaysInterest(filter = []) {
+  const query = cachedQuery(() => ({ with: [Replicated, ...filter] }));
+  return {
+    name: "always",
+    update(world, _peer, out) {
+      const q = query(world);
+      for (const table of q.tables) {
+        for (let row = 0; row < table.count; row++) out.add(table.entities[row]);
+      }
+    }
+  };
+}
+function ownerInterest() {
+  const query = cachedQuery(() => ({ with: [Replicated] }));
+  const children = cachedQuery(() => ({ with: [Replicated, ChildOf] }));
+  return {
+    name: "owner",
+    update(world, peer, out) {
+      const q = query(world);
+      for (const table of q.tables) {
+        const owner = table.column(Replicated, "owner");
+        for (let row = 0; row < table.count; row++) {
+          if (owner[row] === peer.id) out.add(table.entities[row]);
+        }
+      }
+      addChildren(children(world), out);
+    }
+  };
+}
+function addChildren(q, out) {
+  for (let depth = 0; depth < 8; depth++) {
+    const before = out.size;
+    for (const table of q.tables) {
+      const parent = table.column(ChildOf, "parent");
+      for (let row = 0; row < table.count; row++) {
+        if (parent[row] >= 0 && out.has(parent[row])) out.add(table.entities[row]);
+      }
+    }
+    if (out.size === before) return;
+  }
+}
+const BIAS = 65536;
+const SPAN = 131072;
+function gridInterest(options) {
+  const { cellSize, range } = options;
+  const vertical = options.vertical ?? false;
+  const buckets = /* @__PURE__ */ new Map();
+  const cellOf = /* @__PURE__ */ new Map();
+  let lastTick = 0;
+  const p = [0, 0, 0];
+  const key = (x, y, z) => ((x + BIAS) * SPAN + (vertical ? y + BIAS : 0)) * SPAN + (z + BIAS);
+  function position(table, row, out) {
+    if (table.has(ChildOf) && table.has(GlobalTransform)) {
+      const m = table.column(GlobalTransform, "matrix");
+      out[0] = m[row * 12 + 3];
+      out[1] = m[row * 12 + 7];
+      out[2] = m[row * 12 + 11];
+    } else {
+      const t = table.column(Transform, "translation");
+      out[0] = t[row * 3];
+      out[1] = t[row * 3 + 1];
+      out[2] = t[row * 3 + 2];
+    }
+  }
+  function cellKey(pos) {
+    return key(
+      Math.floor(pos[0] / cellSize),
+      Math.floor(pos[1] / cellSize),
+      Math.floor(pos[2] / cellSize)
+    );
+  }
+  function move(entity, next) {
+    const prev = cellOf.get(entity);
+    if (prev === next) return;
+    if (prev !== void 0) {
+      const list2 = buckets.get(prev);
+      const i = list2.indexOf(entity);
+      if (i !== -1) list2.splice(i, 1);
+    }
+    cellOf.set(entity, next);
+    let list = buckets.get(next);
+    if (!list) {
+      list = [];
+      buckets.set(next, list);
+    }
+    list.push(entity);
+  }
+  function focusCell(world, entity) {
+    if (!world.isAlive(entity) || !world.has(entity, Transform)) return void 0;
+    position(world.entityTable(entity), world.entityRow(entity), p);
+    return cellKey(p);
+  }
+  const query = cachedQuery(() => ({ with: [Replicated, Transform] }));
+  return {
+    name: "grid",
+    prepare(world) {
+      const q = query(world);
+      for (const table of q.tables) {
+        const moved = table.lastStructural > lastTick || table.lastChanged(Transform) > lastTick || table.has(ChildOf) && table.lastChanged(GlobalTransform) > lastTick;
+        if (!moved) continue;
+        for (let row = 0; row < table.count; row++) {
+          const e = table.entities[row];
+          position(table, row, p);
+          move(e, cellKey(p));
+        }
+      }
+      lastTick = world.tick;
+    },
+    update(world, peer, out) {
+      const reach = range + 1;
+      for (const f of peer.focus) {
+        const center = focusCell(world, f);
+        if (center === void 0) continue;
+        const cz = center % SPAN - BIAS;
+        const rest = Math.floor(center / SPAN);
+        const cy = vertical ? rest % SPAN - BIAS : 0;
+        const cx = Math.floor(rest / SPAN) - BIAS;
+        const yr = vertical ? reach : 0;
+        for (let dx = -reach; dx <= reach; dx++) {
+          for (let dy = -yr; dy <= yr; dy++) {
+            for (let dz = -reach; dz <= reach; dz++) {
+              const list = buckets.get(key(cx + dx, cy + dy, cz + dz));
+              if (!list) continue;
+              const edge = Math.abs(dx) === reach || Math.abs(dy) === reach || Math.abs(dz) === reach;
+              for (let i = list.length - 1; i >= 0; i--) {
+                const e = list[i];
+                if (!world.isAlive(e)) {
+                  list.splice(i, 1);
+                  cellOf.delete(e);
+                  continue;
+                }
+                if (!edge || peer.knows(e)) out.add(e);
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function teamInterest(component, field) {
+  const query = cachedQuery(() => ({ with: [Replicated, component] }));
+  return {
+    name: "team",
+    update(world, peer, out) {
+      let team;
+      for (const f of peer.focus) {
+        if (world.isAlive(f) && world.has(f, component)) {
+          team = world.entityTable(f).column(component, field)[world.entityRow(f)];
+          break;
+        }
+      }
+      if (team === void 0) return;
+      const q = query(world);
+      for (const table of q.tables) {
+        const column = table.column(component, field);
+        for (let row = 0; row < table.count; row++) {
+          if (column[row] === team) out.add(table.entities[row]);
+        }
+      }
+    }
+  };
+}
+function anyOf(...policies) {
+  return {
+    name: `anyOf(${policies.map((p) => p.name).join(", ")})`,
+    prepare(world) {
+      for (const p of policies) p.prepare?.(world);
+    },
+    update(world, peer, out) {
+      for (const p of policies) p.update(world, peer, out);
+    }
+  };
+}
+function allOf(...policies) {
+  const scratch = new RelevanceSet();
+  return {
+    name: `allOf(${policies.map((p) => p.name).join(", ")})`,
+    prepare(world) {
+      for (const p of policies) p.prepare?.(world);
+    },
+    update(world, peer, out) {
+      const [first, ...rest] = policies;
+      if (!first) return;
+      first.update(world, peer, out);
+      for (const p of rest) {
+        scratch.clear();
+        p.update(world, peer, scratch);
+        out.retain((e) => scratch.has(e));
+      }
+    }
+  };
+}
+export {
+  RelevanceSet,
+  allOf,
+  alwaysInterest,
+  anyOf,
+  gridInterest,
+  ownerInterest,
+  teamInterest
+};

package/dist/loopback.d.ts

@@ -0,0 +1,12 @@
+import { ShardError } from '@aethervtt/shard-core';
+import type { NetTransport } from './transport.js';
+export interface LoopbackOptions {
+    /** Defaults to 1 MiB. Tests lower it to exercise fragmenting. */
+    maxMessage?: number;
+}
+export declare function tooLarge(size: number, max: number): ShardError;
+/**
+ * An in-process transport (0086): a server App and client Apps in one process connect by address.
+ * Delivery is immediate; wrap it in `simulateConditions` for latency and loss.
+ */
+export declare function loopback(options?: LoopbackOptions): NetTransport;