@aethervtt/shard-net 0.0.0-stage → 0.4.1

package/dist/loopback.js

@@ -0,0 +1,103 @@
+import { ShardError } from "@aethervtt/shard-core";
+class LoopbackEnd {
+  peer;
+  other;
+  messageFns = [];
+  closeFns = [];
+  counters = { rtt: 0, sentBytes: 0, receivedBytes: 0, lost: 0 };
+  open = true;
+  maxMessage;
+  constructor(peer, maxMessage) {
+    this.peer = peer;
+    this.maxMessage = maxMessage;
+  }
+  send(channel, bytes) {
+    if (!this.open) return;
+    if (bytes.length > this.maxMessage) throw tooLarge(bytes.length, this.maxMessage);
+    this.counters.sentBytes += bytes.length;
+    this.other?.receive(channel, bytes.slice());
+  }
+  receive(channel, bytes) {
+    if (!this.open) return;
+    this.counters.receivedBytes += bytes.length;
+    for (const fn of this.messageFns) fn(channel, bytes);
+  }
+  onMessage(fn) {
+    this.messageFns.push(fn);
+    return () => remove(this.messageFns, fn);
+  }
+  onClose(fn) {
+    this.closeFns.push(fn);
+    return () => remove(this.closeFns, fn);
+  }
+  close(reason) {
+    if (!this.open) return;
+    this.shut(void 0);
+    this.other?.shut(
+      new ShardError("net/transport-closed", reason ?? "The other side closed the connection")
+    );
+  }
+  shut(reason) {
+    if (!this.open) return;
+    this.open = false;
+    for (const fn of [...this.closeFns]) fn(reason);
+  }
+  stats() {
+    return { ...this.counters };
+  }
+}
+function remove(list, item) {
+  const i = list.indexOf(item);
+  if (i !== -1) list.splice(i, 1);
+}
+function tooLarge(size, max) {
+  return new ShardError("net/message-too-large", `A ${size}-byte message is over ${max} bytes`, {
+    hint: "Reliable messages are split automatically; keep unreliable ones under maxMessage."
+  });
+}
+function loopback(options = {}) {
+  const maxMessage = options.maxMessage ?? 1 << 20;
+  const listeners = /* @__PURE__ */ new Map();
+  let nextPeer = 1;
+  return {
+    name: "loopback",
+    caps: { unreliable: true, maxMessage },
+    async connect(address) {
+      const accept = listeners.get(address);
+      if (!accept) {
+        throw new ShardError("net/connect-failed", `Nothing listens at "${address}"`, {
+          hint: 'Start the server (role: "server") before connecting clients.'
+        });
+      }
+      const client = new LoopbackEnd(0, maxMessage);
+      const server = new LoopbackEnd(nextPeer++, maxMessage);
+      client.other = server;
+      server.other = client;
+      accept(server);
+      return client;
+    },
+    async listen(options2) {
+      const address = options2.address ?? "";
+      if (listeners.has(address)) {
+        throw new ShardError("net/address-in-use", `Something already listens at "${address}"`);
+      }
+      const fns = [];
+      listeners.set(address, (end) => {
+        for (const fn of fns) fn(end);
+      });
+      return {
+        onConnection(fn) {
+          fns.push(fn);
+          return () => remove(fns, fn);
+        },
+        async close() {
+          listeners.delete(address);
+        }
+      };
+    }
+  };
+}
+export {
+  loopback,
+  tooLarge
+};

package/dist/plugin.d.ts

@@ -0,0 +1,101 @@
+import { type Condition, type Entity, type Fields, type InferFields, type JsonObject, type World } from '@aethervtt/shard-core';
+import { type Plugin } from '@aethervtt/shard-runtime';
+import { NetClient, PendingCommand } from './client.js';
+import { type NetRoleName } from './components.js';
+import { type InterestPolicy } from './interest.js';
+import { type NetCommandDef, type NetEventDef, type ReplicationEntry } from './registry.js';
+import { type AcceptResult, NetServer, type PlayerHooks, type ServerCommand } from './server.js';
+import { type NetSessionProvider, type NetTransport, type PeerId } from './transport.js';
+import { type Manifest } from './wire.js';
+/** `U`: what `accept` returns as `user`; `L`: what `players.load` returns; `S`: what `capture` returns. */
+export interface NetOptions<U = unknown, L = unknown, S = unknown> {
+    role: NetRoleName;
+    /** With `address`: the transport to listen or connect on. A server without one runs locally. */
+    transport?: NetTransport;
+    address?: string;
+    /** Instead of transport + address: a lobby or relay, and the room code to host or join. */
+    session?: NetSessionProvider;
+    code?: string;
+    /** Server: what a lobby lists for the room (a name, a mode). */
+    meta?: JsonObject;
+    /** Network ticks per second. Must divide the app's fixedHz. Default: 30, or fixedHz if lower. */
+    tickRate?: number;
+    maxPeers?: number;
+    /** Sent with hello; the server's `accept` sees it. */
+    token?: string;
+    /** Server: refuse a peer by returning an error. */
+    /**
+     * Server: admit a peer (`{ user }`, or nothing) or refuse it (a ShardError, or a throw). May be
+     * async: the peer receives nothing until it settles (0090).
+     */
+    accept?(peer: PeerId, token: string, world: World): AcceptResult<U> | Promise<AcceptResult<U>>;
+    /** Server: load a player on join and save it on leave (0090). */
+    players?: PlayerHooks<U, L, S>;
+    /** Server: seconds `accept` and `players.load` may take together. Default 15. */
+    joinTimeout?: number;
+    replicate?: readonly ReplicationEntry[];
+    commands?: readonly NetCommandDef[];
+    events?: readonly NetEventDef[];
+    /** Server: which entities each peer receives. Default: every replicated entity. */
+    interest?: InterestPolicy;
+    /** Server: bytes of entity data per peer per network tick. Default: unlimited. */
+    budget?: {
+        bytesPerTick?: number;
+    };
+    /** Server: commands a peer may send per second. Default 30. */
+    commandsPerSecond?: number;
+    /** Client: spawns a replicated entity from its prefab (0087). Default: a bare entity. */
+    spawnPrefab?: (world: World, prefab: string) => Entity;
+    /** The clock in ms (pings, rate limits). Default: frame time. */
+    now?: () => number;
+}
+export interface NetSessionData {
+    readonly role: NetRoleName;
+    readonly manifest: Manifest;
+    readonly server: NetServer | undefined;
+    readonly client: NetClient | undefined;
+    readonly transport: NetTransport | undefined;
+    /** Server: the room code (or address) players join with, once listening. */
+    code: string | undefined;
+    /** Settles when the server listens or the client's connection opens (not the handshake). */
+    ready: Promise<void>;
+}
+export declare const NetSession: import("@aethervtt/shard-core").ResourceDef<NetSessionData>;
+/** The net plugin's systems, to order game systems around them. */
+export declare const NetSystems: {
+    readonly receive: import("@aethervtt/shard-core").SystemDef<undefined>;
+    readonly interpolate: import("@aethervtt/shard-core").SystemDef<undefined>;
+    readonly send: import("@aethervtt/shard-core").SystemDef<undefined>;
+};
+/** Multiplayer (0086, 0087, 0089): one plugin per app, as server or client. */
+export declare function netPlugin<U = unknown, L = unknown, S = unknown>(options: NetOptions<U, L, S>): Plugin;
+/** Runs on the server, and in a game without networking. */
+export declare const onServer: Condition;
+/** Runs only on a client. */
+export declare const onClient: Condition;
+/** Client: after the handshake. Server: listening (always, without a transport). */
+export declare const connected: Condition;
+/**
+ * Server: saves a connected player now through `players.capture` and `players.store` (autosaves),
+ * without despawning anything. Resolves when the store does (0090).
+ */
+export declare function savePlayer(world: World, peer: PeerId): Promise<void>;
+/** Whether this app decides the entity's state: the server always; a client for what it owns. */
+export declare function hasAuthority(world: World, entity: Entity): boolean;
+export declare function netSession(world: World): NetSessionData;
+/**
+ * Sends a command to the server. On the server itself (single-player, tests) it is handled
+ * locally by the same systems. The answer arrives in the returned object's `status`.
+ */
+export declare function sendCommand<F extends Fields>(world: World, def: NetCommandDef<F>, data: Partial<InferFields<F>>): PendingCommand;
+/** Server: commands of this type waiting for an answer. Call `accept()` or `reject()` on each. */
+export declare function commands<F extends Fields>(world: World, def: NetCommandDef<F>): ServerCommand<InferFields<F>>[];
+export interface SendEventOptions {
+    /** `all` (default), one peer, or a filter evaluated once per peer. */
+    to?: PeerId | 'all' | ((peer: PeerId) => boolean);
+}
+/**
+ * Server: sends an event to clients (and to this world, so local code reads the same stream).
+ * Clients read it with `ctx.reader(def.event)`.
+ */
+export declare function sendEvent<F extends Fields>(world: World, def: NetEventDef<F>, data: Partial<InferFields<F>>, options?: SendEventOptions): void;

package/dist/plugin.js

@@ -0,0 +1,373 @@
+import {
+  condition,
+  defineResource,
+  defineSchema,
+  defineSystem,
+  First,
+  Last,
+  PreUpdate,
+  ShardError,
+  t
+} from "@aethervtt/shard-core";
+import {
+  definePlugin,
+  FixedTime,
+  Time
+} from "@aethervtt/shard-runtime";
+import { NetClient, PendingCommand } from "./client.js";
+import * as components from "./components.js";
+import { NetClock, NetRole, Replicated } from "./components.js";
+import { isConditioned } from "./conditions.js";
+import { alwaysInterest } from "./interest.js";
+import { replicate } from "./registry.js";
+import {
+  NetServer
+} from "./server.js";
+import { directSession } from "./transport.js";
+import { buildManifest } from "./wire.js";
+const NetSession = defineResource("net/NetSession", {
+  description: "The running network session: role, manifest, and the server or client (0086)."
+});
+const receive = defineSystem({
+  name: "net/receive",
+  description: "Drains connections: handshakes, acks, commands (server); state and events (client).",
+  run(_, world) {
+    const session = world.resource(NetSession);
+    session.server?.receive();
+    session.client?.receive();
+  }
+});
+const interpolate = defineSystem({
+  name: "net/interpolate",
+  description: "Writes interpolated values for remote entities.",
+  run(_, world) {
+    world.resource(NetSession).client?.interpolate();
+  }
+});
+const send = defineSystem({
+  name: "net/send",
+  description: "Sends state, answers and events (server) or acks and pings (client) on network ticks.",
+  run(_, world) {
+    const session = world.resource(NetSession);
+    session.server?.send();
+    session.client?.send();
+  }
+});
+const NetSystems = { receive, interpolate, send };
+function netPlugin(options) {
+  let session;
+  return definePlugin({
+    name: "net",
+    provides: [components],
+    build(app) {
+      const fixedHz = app.fixedHz;
+      const tickRate = options.tickRate ?? Math.min(30, fixedHz);
+      const ticksPerNet = fixedHz / tickRate;
+      if (!Number.isInteger(ticksPerNet) || ticksPerNet < 1) {
+        throw new ShardError(
+          "net/tick-rate",
+          `tickRate ${tickRate} doesn't divide fixedHz ${fixedHz}`,
+          {
+            hint: "Use a network rate that divides the fixed rate: 60 Hz takes 60, 30, 20, 15 or 10."
+          }
+        );
+      }
+      const manifest = buildManifest(
+        [replicate(Replicated, { channel: "reliable" }), ...options.replicate ?? []],
+        options.commands ?? [],
+        options.events ?? []
+      );
+      const world = app.world;
+      const now = options.now ?? (() => world.resource(Time).elapsed * 1e3);
+      const transport = options.transport;
+      const maxMessage = transport?.caps.maxMessage ?? options.session?.caps?.maxMessage ?? 1 << 20;
+      world.insertResource(NetRole, {
+        role: options.role,
+        peer: 0,
+        connected: options.role === "server" && !transport && !options.session,
+        tick: 0
+      });
+      let server;
+      let client;
+      if (options.role === "server") {
+        server = new NetServer(world, {
+          manifest,
+          interest: options.interest ?? alwaysInterest(),
+          ticksPerNet,
+          maxPeers: options.maxPeers ?? 64,
+          bytesPerTick: options.budget?.bytesPerTick ?? Number.POSITIVE_INFINITY,
+          maxMessage,
+          commandsPerSecond: options.commandsPerSecond ?? 30,
+          ...options.accept ? { accept: options.accept.bind(options) } : {},
+          ...options.players ? { players: options.players } : {},
+          joinTimeout: (options.joinTimeout ?? 15) * 1e3,
+          now
+        });
+        world.insertResource(NetClock, { serverTick: 0, offsetTicks: 0, rtt: 0, jitter: 0 });
+      } else {
+        client = new NetClient(world, {
+          manifest,
+          ticksPerNet,
+          maxMessage,
+          token: options.token ?? "",
+          spawnPrefab: options.spawnPrefab,
+          now
+        });
+      }
+      session = {
+        role: options.role,
+        manifest,
+        server,
+        client,
+        transport,
+        code: void 0,
+        ready: Promise.resolve()
+      };
+      world.insertResource(NetSession, session);
+      app.addSystems(First, receive);
+      app.addSystems(PreUpdate, interpolate.runIf(onClient));
+      app.addSystems(Last, send);
+      app.addMethod(...netMethods);
+    },
+    ready(app) {
+      const s = session;
+      const provider = options.session ?? (options.transport ? directSession(options.transport) : void 0);
+      if (!provider) return;
+      const role = app.world.resource(NetRole);
+      if (s.server) {
+        const server = s.server;
+        s.ready = provider.host({
+          address: options.code ?? options.address ?? "",
+          maxPeers: options.maxPeers ?? 64,
+          ...options.meta ? { meta: options.meta } : {}
+        }).then(({ code, listener }) => {
+          server.attach(listener);
+          s.code = code;
+          role.connected = true;
+        });
+        return s.ready;
+      }
+      const client = s.client;
+      s.ready = provider.join(options.code ?? options.address ?? "", { token: options.token ?? "" }).then((connection) => client.attach(connection));
+      s.ready.catch((err) => {
+        client.lastError = err instanceof ShardError ? err : new ShardError("net/connect-failed", `Couldn't connect: ${String(err)}`);
+      });
+      return void 0;
+    },
+    async dispose() {
+      session?.client?.dispose();
+      await session?.server?.dispose();
+    }
+  });
+}
+function roleOf(world) {
+  return world.tryResource(NetRole)?.role;
+}
+const onServer = condition("net/onServer", (world) => roleOf(world) !== "client");
+const onClient = condition("net/onClient", (world) => roleOf(world) === "client");
+const connected = condition(
+  "net/connected",
+  (world) => world.tryResource(NetRole)?.connected ?? false
+);
+async function savePlayer(world, peer) {
+  const server = netSession(world).server;
+  if (!server) throw notAuthority("save players");
+  await server.save(peer);
+}
+function hasAuthority(world, entity) {
+  const role = world.tryResource(NetRole);
+  if (!role || role.role === "server") return true;
+  return world.tryGet(entity, Replicated)?.owner === role.peer && role.peer !== 0;
+}
+function netSession(world) {
+  const session = world.tryResource(NetSession);
+  if (!session) {
+    throw new ShardError("net/no-session", "Networking is not set up in this app", {
+      hint: "Add netPlugin({ role }) to the app."
+    });
+  }
+  return session;
+}
+function sendCommand(world, def, data) {
+  const session = netSession(world);
+  if (session.client) return session.client.sendCommand(def, data);
+  const pending = new PendingCommand(def, 0);
+  const server = session.server;
+  if (server.commandIndexOf(def) === void 0) {
+    throw new ShardError("net/unknown-command", `${def.name} isn't in netPlugin({ commands })`, {
+      hint: "List every net command in the plugin options on both sides."
+    });
+  }
+  server.local(def, data, (cmd) => {
+    pending.status = cmd.status;
+    pending.error = cmd.error;
+  });
+  return pending;
+}
+function commands(world, def) {
+  const session = world.tryResource(NetSession);
+  if (!session) return [];
+  const server = session.server;
+  if (!server) throw notAuthority(`read ${def.name} commands`);
+  return server.pending(def);
+}
+function sendEvent(world, def, data, options = {}) {
+  const session = world.tryResource(NetSession);
+  if (!session) {
+    const tick = world.tryResource(FixedTime)?.tick ?? 0;
+    world.send(def.event, { data, tick });
+    return;
+  }
+  const server = session.server;
+  if (!server) throw notAuthority(`send ${def.name}`);
+  server.sendEvent(def, data, options.to ?? "all");
+}
+function notAuthority(what) {
+  return new ShardError("net/not-authority", `Only the server can ${what}`, {
+    hint: "Run this in a system gated with onServer."
+  });
+}
+const NoParams = defineSchema("net/NoParams", {});
+const EntityParams = defineSchema("net/EntityParams", { entity: t.entity() });
+const PeerParams = defineSchema("net/PeerParams", { peer: t.u32(), reason: t.string() });
+const ConditionParams = defineSchema("net/ConditionParams", {
+  latency: t.f32({ default: -1 }),
+  jitter: t.f32({ default: -1 }),
+  loss: t.f32({ default: -1 }),
+  duplicate: t.f32({ default: -1 })
+});
+const netMethods = [
+  {
+    name: "net.describe",
+    description: "Role, peer, tick, clock, transport and the replicated types.",
+    params: NoParams,
+    handler: ({ world }) => {
+      const session = netSession(world);
+      return {
+        ...world.resource(NetRole),
+        code: session.code ?? null,
+        clock: { ...world.resource(NetClock) },
+        transport: session.transport ? { name: session.transport.name, ...session.transport.caps } : null,
+        components: session.manifest.components.map((c) => ({
+          name: c.def.name,
+          mode: c.mode,
+          channel: c.channel,
+          redacted: c.visibleTo !== void 0
+        })),
+        commands: session.manifest.commands.map((c) => c.name),
+        events: session.manifest.events.map((e) => e.name),
+        lastError: session.client?.lastError?.toJSON() ?? null
+      };
+    }
+  },
+  {
+    name: "net.peers",
+    description: "Server: connected peers with RTT and traffic counters.",
+    params: NoParams,
+    handler: ({ world }) => {
+      const server = netSession(world).server;
+      if (!server) return [];
+      return [...server.peers.values()].map((p) => ({
+        id: p.info.id,
+        state: p.info.state,
+        rtt: p.info.rtt,
+        user: p.info.user ?? null,
+        joinedTick: p.info.joinedTick,
+        known: p.known.size,
+        relevant: p.relevant.size,
+        stats: p.stats
+      }));
+    }
+  },
+  {
+    name: "net.stats",
+    description: "Server: bytes per peer and per component, deferred entities, resends.",
+    params: NoParams,
+    handler: ({ world }) => {
+      const server = netSession(world).server;
+      if (!server) return {};
+      return Object.fromEntries([...server.peers.values()].map((p) => [p.id, p.stats]));
+    }
+  },
+  {
+    name: "net.inspect",
+    description: "Server: an entity's net id, owner, and per peer relevance and redaction.",
+    params: EntityParams,
+    handler: ({ world }, params) => {
+      const server = netSession(world).server;
+      if (!server) throw notAuthority("inspect relevance");
+      return server.inspect(params.entity);
+    }
+  },
+  {
+    name: "net.relevance",
+    description: "Server: the entities one peer receives now.",
+    params: PeerParams,
+    handler: ({ world }, params) => {
+      const peer = netSession(world).server?.peers.get(params.peer);
+      return peer ? [...peer.relevant.entities] : [];
+    }
+  },
+  {
+    name: "net.commands",
+    description: "Server: recent commands with status and error code.",
+    params: NoParams,
+    handler: ({ world }) => (netSession(world).server?.recentCommands ?? []).map((c) => ({
+      name: c.def.name,
+      peer: c.peer,
+      tick: c.arrivedTick,
+      status: c.status,
+      code: c.error?.code ?? null
+    }))
+  },
+  {
+    name: "net.events",
+    description: "Server: recent events and their recipients.",
+    params: NoParams,
+    handler: ({ world }) => netSession(world).server?.recentEvents ?? []
+  },
+  {
+    name: "net.conditions",
+    description: "Reads, and with params sets, simulated latency/jitter/loss (negative keeps).",
+    params: ConditionParams,
+    handler: ({ world }, params) => {
+      const transport = netSession(world).transport;
+      if (!transport || !isConditioned(transport)) {
+        throw new ShardError("net/no-conditions", "This transport has no simulated conditions", {
+          hint: "Wrap the transport with simulateConditions()."
+        });
+      }
+      const next = {};
+      for (const key of ["latency", "jitter", "loss", "duplicate"]) {
+        const v = params[key];
+        if (v >= 0) next[key] = v;
+      }
+      transport.setConditions(next);
+      return transport.conditions;
+    }
+  },
+  {
+    name: "net.disconnect",
+    description: "Server: disconnects a peer.",
+    params: PeerParams,
+    handler: ({ world }, params) => {
+      const server = netSession(world).server;
+      if (!server) throw notAuthority("disconnect peers");
+      return server.disconnect(params.peer, params.reason || void 0);
+    }
+  }
+];
+export {
+  NetSession,
+  NetSystems,
+  commands,
+  connected,
+  hasAuthority,
+  netPlugin,
+  netSession,
+  onClient,
+  onServer,
+  savePlayer,
+  sendCommand,
+  sendEvent
+};

package/dist/registry.d.ts

@@ -0,0 +1,53 @@
+import { type ComponentDef, type Entity, type EventDef, type Fields, type InferFields, type Quantize, type World } from '@aethervtt/shard-core';
+import type { PeerId } from './transport.js';
+export type ReplicationMode = 'set' | 'interpolate';
+export interface ReplicateOptions<F extends Fields = Fields> {
+    /** `set` (default) writes values as they arrive; `interpolate` renders remote entities smoothly. */
+    mode?: ReplicationMode;
+    /** `unreliable` (default) resends until acked; `reliable` arrives in order. */
+    channel?: 'reliable' | 'unreliable';
+    /** Float quantization per field. */
+    quantize?: {
+        readonly [K in keyof F]?: Quantize;
+    };
+    /** Redaction: false keeps the component off that peer's wire. */
+    visibleTo?: (world: World, peer: PeerId, entity: Entity) => boolean;
+}
+export interface ReplicationEntry {
+    readonly def: ComponentDef;
+    readonly mode: ReplicationMode;
+    readonly channel: 'reliable' | 'unreliable';
+    readonly quantize: Readonly<Record<string, Quantize>>;
+    readonly visibleTo: ((world: World, peer: PeerId, entity: Entity) => boolean) | undefined;
+}
+/** A component to replicate, and how (0087). Pass the result to `netPlugin({ replicate })`. */
+export declare function replicate<F extends Fields>(def: ComponentDef<F>, options?: ReplicateOptions<F>): ReplicationEntry;
+/** Redaction helper: only the entity's owner receives the component. */
+export declare function ownerOnly(world: World, peer: PeerId, entity: Entity): boolean;
+/** The peer that owns a replicated entity (0 for the server), or undefined if it isn't one. */
+export declare function ownerOf(world: World, entity: Entity): PeerId | undefined;
+export interface NetCommandDef<F extends Fields = Fields> {
+    readonly kind: 'net-command';
+    readonly name: string;
+    readonly schema: ComponentDef<F>;
+}
+export interface NetEventDef<F extends Fields = Fields> {
+    readonly kind: 'net-event';
+    readonly name: string;
+    readonly schema: ComponentDef<F>;
+    /** Received events are sent here: read them with `ctx.reader(def.event)`. */
+    readonly event: EventDef<NetEventData<F>>;
+}
+export interface NetEventData<F extends Fields = Fields> {
+    readonly data: InferFields<F>;
+    /** The server tick the event was sent on. */
+    readonly tick: number;
+}
+/** A request a client sends and the server validates and answers (0089). */
+export declare function defineNetCommand<const F extends Fields>(name: string, fields: F, options?: {
+    description?: string;
+}): NetCommandDef<F>;
+/** A message the server sends to all clients, one, or a filter (0089). */
+export declare function defineNetEvent<const F extends Fields>(name: string, fields: F, options?: {
+    description?: string;
+}): NetEventDef<F>;

package/dist/registry.js

@@ -0,0 +1,44 @@
+import {
+  defineEvent,
+  defineSchema,
+  ShardError
+} from "@aethervtt/shard-core";
+import { Replicated } from "./components.js";
+function replicate(def, options = {}) {
+  if (!def.serializable && def.name !== "net/Replicated") {
+    throw new ShardError("net/not-replicable", `${def.name} is derived and can't replicate`, {
+      hint: "Replicate the components it is computed from."
+    });
+  }
+  return {
+    def,
+    mode: options.mode ?? "set",
+    channel: options.channel ?? "unreliable",
+    quantize: options.quantize ?? {},
+    visibleTo: options.visibleTo
+  };
+}
+function ownerOnly(world, peer, entity) {
+  return ownerOf(world, entity) === peer;
+}
+function ownerOf(world, entity) {
+  return world.tryGet(entity, Replicated)?.owner;
+}
+function defineNetCommand(name, fields, options = {}) {
+  return { kind: "net-command", name, schema: defineSchema(name, fields, options) };
+}
+function defineNetEvent(name, fields, options = {}) {
+  return {
+    kind: "net-event",
+    name,
+    schema: defineSchema(name, fields, options),
+    event: defineEvent(name)
+  };
+}
+export {
+  defineNetCommand,
+  defineNetEvent,
+  ownerOf,
+  ownerOnly,
+  replicate
+};