shardwire 0.0.1

package/dist/index.mjs

@@ -0,0 +1,818 @@
+// src/transport/ws/consumer-socket.ts
+import { WebSocket } from "ws";
+function createNodeWebSocket(url) {
+  return new WebSocket(url);
+}
+
+// src/utils/id.ts
+import { randomUUID } from "crypto";
+function createRequestId() {
+  return randomUUID();
+}
+function createConnectionId() {
+  return randomUUID();
+}
+
+// src/utils/backoff.ts
+function getBackoffDelay(attempt, config) {
+  const base = Math.min(config.maxDelayMs, config.initialDelayMs * 2 ** attempt);
+  if (!config.jitter) {
+    return base;
+  }
+  const spread = Math.floor(base * 0.2);
+  const min = Math.max(0, base - spread);
+  const max = base + spread;
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+// src/utils/logger.ts
+function withLogger(logger) {
+  return {
+    debug: logger?.debug ?? (() => void 0),
+    info: logger?.info ?? (() => void 0),
+    warn: logger?.warn ?? (() => void 0),
+    error: logger?.error ?? (() => void 0)
+  };
+}
+
+// src/core/protocol.ts
+var PROTOCOL_VERSION = 1;
+function makeEnvelope(type, payload, extras) {
+  const envelope = {
+    v: PROTOCOL_VERSION,
+    type,
+    ts: Date.now(),
+    payload
+  };
+  if (extras?.requestId) {
+    envelope.requestId = extras.requestId;
+  }
+  if (extras?.source) {
+    envelope.source = extras.source;
+  }
+  return envelope;
+}
+function parseEnvelope(raw) {
+  const parsed = JSON.parse(raw);
+  if (!parsed || parsed.v !== PROTOCOL_VERSION || typeof parsed.type !== "string") {
+    throw new Error("Invalid wire envelope.");
+  }
+  return parsed;
+}
+function stringifyEnvelope(envelope) {
+  return JSON.stringify(envelope);
+}
+
+// src/runtime/validation.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function assertPositiveNumber(name, value) {
+  if (typeof value !== "number" || Number.isNaN(value) || value <= 0) {
+    throw new Error(`${name} must be a positive number.`);
+  }
+}
+function assertHostOptions(options) {
+  if (!options.server) {
+    throw new Error("Host mode requires a server configuration.");
+  }
+  assertPositiveNumber("server.port", options.server.port);
+  if (!isNonEmptyString(options.server.secret)) {
+    throw new Error("server.secret is required.");
+  }
+  if (options.server.heartbeatMs !== void 0) {
+    assertPositiveNumber("server.heartbeatMs", options.server.heartbeatMs);
+  }
+  if (options.server.commandTimeoutMs !== void 0) {
+    assertPositiveNumber("server.commandTimeoutMs", options.server.commandTimeoutMs);
+  }
+  if (options.server.maxPayloadBytes !== void 0) {
+    assertPositiveNumber("server.maxPayloadBytes", options.server.maxPayloadBytes);
+  }
+}
+function assertConsumerOptions(options) {
+  if (!isNonEmptyString(options.url)) {
+    throw new Error("Consumer mode requires `url`.");
+  }
+  if (!isNonEmptyString(options.secret)) {
+    throw new Error("Consumer mode requires `secret`.");
+  }
+  if (options.requestTimeoutMs !== void 0) {
+    assertPositiveNumber("requestTimeoutMs", options.requestTimeoutMs);
+  }
+  if (options.reconnect?.initialDelayMs !== void 0) {
+    assertPositiveNumber("reconnect.initialDelayMs", options.reconnect.initialDelayMs);
+  }
+  if (options.reconnect?.maxDelayMs !== void 0) {
+    assertPositiveNumber("reconnect.maxDelayMs", options.reconnect.maxDelayMs);
+  }
+}
+function assertMessageName(kind, name) {
+  if (!isNonEmptyString(name)) {
+    throw new Error(`${kind} name must be a non-empty string.`);
+  }
+}
+function assertJsonPayload(kind, name, payload) {
+  try {
+    JSON.stringify(payload);
+  } catch {
+    throw new Error(`${kind} "${name}" payload must be JSON-serializable.`);
+  }
+}
+
+// src/consumer/index.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+function createConsumerShardwire(options) {
+  const logger = withLogger(options.logger);
+  const reconnectEnabled = options.reconnect?.enabled ?? true;
+  const initialDelayMs = options.reconnect?.initialDelayMs ?? 500;
+  const maxDelayMs = options.reconnect?.maxDelayMs ?? 1e4;
+  const jitter = options.reconnect?.jitter ?? true;
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  let socket = null;
+  let isClosed = false;
+  let isAuthed = false;
+  let reconnectAttempts = 0;
+  let reconnectTimer = null;
+  let connectPromise = null;
+  let connectResolve = null;
+  let connectReject = null;
+  let authTimeoutTimer = null;
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const eventHandlers = /* @__PURE__ */ new Map();
+  function clearAuthTimeout() {
+    if (authTimeoutTimer) {
+      clearTimeout(authTimeoutTimer);
+      authTimeoutTimer = null;
+    }
+  }
+  function resolveConnect() {
+    clearAuthTimeout();
+    connectResolve?.();
+    connectResolve = null;
+    connectReject = null;
+    connectPromise = null;
+  }
+  function rejectConnect(message) {
+    clearAuthTimeout();
+    if (connectReject) {
+      connectReject(new Error(message));
+    }
+    connectResolve = null;
+    connectReject = null;
+    connectPromise = null;
+  }
+  function sendRaw(data) {
+    if (!socket || socket.readyState !== 1) {
+      throw new Error("Shardwire consumer is not connected.");
+    }
+    socket.send(data);
+  }
+  function rejectAllPending(reason) {
+    for (const [requestId, pending] of pendingRequests.entries()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(reason));
+      pendingRequests.delete(requestId);
+    }
+  }
+  function scheduleReconnect() {
+    if (isClosed || !reconnectEnabled || reconnectTimer) {
+      return;
+    }
+    const delay = getBackoffDelay(reconnectAttempts, { initialDelayMs, maxDelayMs, jitter });
+    reconnectAttempts += 1;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      void connect().catch((error) => {
+        logger.warn("Reconnect attempt failed.", { error: String(error) });
+      });
+    }, delay);
+  }
+  function handleEvent(name, payload, meta) {
+    const handlers = eventHandlers.get(name);
+    if (!handlers || handlers.size === 0) {
+      return;
+    }
+    for (const handler of handlers) {
+      try {
+        handler(payload, meta);
+      } catch (error) {
+        logger.warn("Event handler threw an error.", { name, error: String(error) });
+      }
+    }
+  }
+  async function connect() {
+    if (isClosed) {
+      return;
+    }
+    if (socket && socket.readyState === 1 && isAuthed) {
+      return;
+    }
+    if (connectPromise) {
+      return connectPromise;
+    }
+    connectPromise = new Promise((resolve, reject) => {
+      connectResolve = resolve;
+      connectReject = reject;
+    });
+    socket = options.webSocketFactory ? options.webSocketFactory(options.url) : createNodeWebSocket(options.url);
+    socket.on("open", () => {
+      reconnectAttempts = 0;
+      isAuthed = false;
+      const hello = makeEnvelope("auth.hello", { secret: options.secret });
+      socket?.send(stringifyEnvelope(hello));
+      authTimeoutTimer = setTimeout(() => {
+        if (!isAuthed) {
+          rejectConnect("Shardwire auth timed out.");
+          socket?.close();
+        }
+      }, requestTimeoutMs);
+    });
+    socket.on("message", (raw) => {
+      try {
+        const serialized = typeof raw === "string" ? raw : String(raw);
+        const envelope = parseEnvelope(serialized);
+        switch (envelope.type) {
+          case "auth.ok":
+            isAuthed = true;
+            resolveConnect();
+            break;
+          case "auth.error": {
+            const payload = envelope.payload;
+            logger.error("Authentication failed for consumer.", {
+              code: payload.code,
+              message: payload.message
+            });
+            rejectConnect(payload.message);
+            rejectAllPending("Shardwire authentication failed.");
+            socket?.close();
+            break;
+          }
+          case "command.result":
+          case "command.error": {
+            const requestId = envelope.requestId;
+            if (!requestId) {
+              return;
+            }
+            const pending = pendingRequests.get(requestId);
+            if (!pending) {
+              return;
+            }
+            clearTimeout(pending.timer);
+            pending.resolve(envelope.payload);
+            pendingRequests.delete(requestId);
+            break;
+          }
+          case "event.emit": {
+            const payload = envelope.payload;
+            const meta = { ts: envelope.ts };
+            if (envelope.source) {
+              meta.source = envelope.source;
+            }
+            handleEvent(payload.name, payload.data, meta);
+            break;
+          }
+          case "ping":
+            sendRaw(stringifyEnvelope(makeEnvelope("pong", {})));
+            break;
+          default:
+            break;
+        }
+      } catch (error) {
+        logger.warn("Failed to parse consumer message.", { error: String(error) });
+      }
+    });
+    socket.on("close", () => {
+      rejectConnect("Shardwire connection closed.");
+      isAuthed = false;
+      if (!isClosed) {
+        scheduleReconnect();
+      }
+    });
+    socket.on("error", (error) => {
+      logger.warn("Consumer socket error.", { error: String(error) });
+    });
+    return connectPromise;
+  }
+  void connect().catch((error) => {
+    logger.warn("Initial connection attempt failed.", { error: String(error) });
+  });
+  return {
+    mode: "consumer",
+    async send(name, payload, sendOptions) {
+      assertMessageName("command", name);
+      assertJsonPayload("command", name, payload);
+      if (!isAuthed) {
+        try {
+          await connect();
+        } catch (error) {
+          return {
+            ok: false,
+            requestId: sendOptions?.requestId ?? "unknown",
+            ts: Date.now(),
+            error: {
+              code: "AUTH_ERROR",
+              message: error instanceof Error ? error.message : "Failed to authenticate."
+            }
+          };
+        }
+      }
+      if (!socket || socket.readyState !== 1) {
+        return {
+          ok: false,
+          requestId: sendOptions?.requestId ?? "unknown",
+          ts: Date.now(),
+          error: {
+            code: "TIMEOUT",
+            message: "Not connected to Shardwire host."
+          }
+        };
+      }
+      const requestId = sendOptions?.requestId ?? createRequestId();
+      const timeoutMs = sendOptions?.timeoutMs ?? requestTimeoutMs;
+      const promise = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pendingRequests.delete(requestId);
+          reject(new Error(`Command "${name}" timed out after ${timeoutMs}ms.`));
+        }, timeoutMs);
+        pendingRequests.set(requestId, { resolve, reject, timer });
+      });
+      sendRaw(
+        stringifyEnvelope(
+          makeEnvelope(
+            "command.request",
+            {
+              name,
+              data: payload
+            },
+            { requestId }
+          )
+        )
+      );
+      try {
+        return await promise;
+      } catch (error) {
+        return {
+          ok: false,
+          requestId,
+          ts: Date.now(),
+          error: {
+            code: "TIMEOUT",
+            message: error instanceof Error ? error.message : "Command request timeout."
+          }
+        };
+      }
+    },
+    on(name, handler) {
+      assertMessageName("event", name);
+      const casted = handler;
+      const existing = eventHandlers.get(name);
+      if (existing) {
+        existing.add(casted);
+      } else {
+        eventHandlers.set(name, /* @__PURE__ */ new Set([casted]));
+      }
+      return () => {
+        const handlers = eventHandlers.get(name);
+        if (!handlers) {
+          return;
+        }
+        handlers.delete(casted);
+        if (handlers.size === 0) {
+          eventHandlers.delete(name);
+        }
+      };
+    },
+    off(name, handler) {
+      assertMessageName("event", name);
+      const handlers = eventHandlers.get(name);
+      if (!handlers) {
+        return;
+      }
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        eventHandlers.delete(name);
+      }
+    },
+    connected() {
+      return Boolean(socket && socket.readyState === 1 && isAuthed);
+    },
+    async close() {
+      isClosed = true;
+      isAuthed = false;
+      rejectConnect("Shardwire consumer has been closed.");
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      rejectAllPending("Shardwire consumer has been closed.");
+      if (!socket) {
+        return;
+      }
+      await new Promise((resolve) => {
+        const current = socket;
+        if (!current) {
+          resolve();
+          return;
+        }
+        current.once("close", () => resolve());
+        current.close();
+      });
+      socket = null;
+    }
+  };
+}
+
+// src/discord/client.ts
+async function resolveDiscordClient(options) {
+  if (options.client) {
+    return { client: options.client, owned: false };
+  }
+  if (!options.token) {
+    return { owned: false };
+  }
+  const discordModule = await import("discord.js");
+  const created = new discordModule.Client({
+    intents: []
+  });
+  await created.login(options.token);
+  return { client: created, owned: true };
+}
+
+// src/runtime/reliability.ts
+async function withTimeout(promise, timeoutMs, timeoutMessage = "Operation timed out.") {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(timeoutMessage));
+    }, timeoutMs);
+    promise.then((value) => {
+      clearTimeout(timeout);
+      resolve(value);
+    }).catch((error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+  });
+}
+var DedupeCache = class {
+  constructor(ttlMs) {
+    this.ttlMs = ttlMs;
+  }
+  ttlMs;
+  cache = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    if (entry.expiresAt <= Date.now()) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  set(key, value) {
+    this.cache.set(key, { value, expiresAt: Date.now() + this.ttlMs });
+  }
+};
+
+// src/transport/ws/host-server.ts
+import { WebSocketServer } from "ws";
+
+// src/runtime/security.ts
+import { timingSafeEqual } from "crypto";
+function isSecretValid(provided, expected) {
+  const providedBuffer = Buffer.from(provided);
+  const expectedBuffer = Buffer.from(expected);
+  if (providedBuffer.length !== expectedBuffer.length) {
+    return false;
+  }
+  return timingSafeEqual(providedBuffer, expectedBuffer);
+}
+
+// src/transport/ws/host-server.ts
+var CLOSE_AUTH_REQUIRED = 4001;
+var CLOSE_AUTH_FAILED = 4003;
+var CLOSE_INVALID_PAYLOAD = 4004;
+var HostWebSocketServer = class {
+  constructor(config) {
+    this.config = config;
+    const serverConfig = config.options.server;
+    this.heartbeatMs = serverConfig.heartbeatMs ?? 3e4;
+    this.logger = withLogger(config.options.logger);
+    this.wss = new WebSocketServer({
+      host: serverConfig.host,
+      port: serverConfig.port,
+      path: serverConfig.path ?? "/shardwire",
+      maxPayload: serverConfig.maxPayloadBytes ?? 65536
+    });
+    this.wss.on("connection", (socket, request) => this.handleConnection(socket, request));
+    this.wss.on(
+      "error",
+      (error) => this.logger.error("Shardwire host server error.", { error: String(error) })
+    );
+    this.interval = setInterval(() => {
+      this.checkHeartbeats();
+    }, this.heartbeatMs);
+  }
+  config;
+  wss;
+  connections = /* @__PURE__ */ new Map();
+  logger;
+  heartbeatMs;
+  authTimeoutMs = 5e3;
+  interval;
+  emitEvent(name, data, source) {
+    const envelope = makeEnvelope(
+      "event.emit",
+      { name, data },
+      source ? { source } : void 0
+    );
+    const raw = stringifyEnvelope(envelope);
+    for (const state of this.connections.values()) {
+      if (!state.authenticated) {
+        continue;
+      }
+      this.safeSend(state.socket, raw);
+    }
+  }
+  async close() {
+    clearInterval(this.interval);
+    for (const connection of this.connections.values()) {
+      connection.socket.close();
+    }
+    this.connections.clear();
+    await new Promise((resolve, reject) => {
+      this.wss.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  handleConnection(socket, request) {
+    const allowlist = this.config.options.server.corsOrigins;
+    if (allowlist && allowlist.length > 0) {
+      const origin = request.headers.origin;
+      if (!origin || !allowlist.includes(origin)) {
+        socket.close(CLOSE_AUTH_FAILED, "Origin not allowed.");
+        return;
+      }
+    }
+    const state = {
+      id: createConnectionId(),
+      socket,
+      authenticated: false,
+      lastHeartbeatAt: Date.now()
+    };
+    this.connections.set(socket, state);
+    const authTimer = setTimeout(() => {
+      if (!state.authenticated) {
+        socket.close(CLOSE_AUTH_REQUIRED, "Authentication required.");
+      }
+    }, this.authTimeoutMs);
+    socket.on("message", async (raw) => {
+      try {
+        const parsed = parseEnvelope(raw.toString());
+        await this.handleMessage(state, parsed);
+      } catch (error) {
+        this.logger.warn("Invalid message payload from client.", { error: String(error) });
+        socket.close(CLOSE_INVALID_PAYLOAD, "Invalid payload.");
+      }
+    });
+    socket.on("close", () => {
+      clearTimeout(authTimer);
+      this.connections.delete(socket);
+    });
+    socket.on(
+      "error",
+      (error) => this.logger.warn("Socket error.", { connectionId: state.id, error: String(error) })
+    );
+  }
+  async handleMessage(state, envelope) {
+    if (envelope.type === "ping") {
+      state.lastHeartbeatAt = Date.now();
+      this.safeSend(state.socket, stringifyEnvelope(makeEnvelope("pong", {})));
+      return;
+    }
+    if (envelope.type === "pong") {
+      state.lastHeartbeatAt = Date.now();
+      return;
+    }
+    if (!state.authenticated) {
+      if (envelope.type !== "auth.hello") {
+        state.socket.close(CLOSE_AUTH_REQUIRED, "Authentication required.");
+        return;
+      }
+      const payload = envelope.payload;
+      if (!payload?.secret || !isSecretValid(payload.secret, this.config.options.server.secret)) {
+        this.safeSend(
+          state.socket,
+          stringifyEnvelope(
+            makeEnvelope("auth.error", {
+              code: "AUTH_ERROR",
+              message: "Invalid shared secret."
+            })
+          )
+        );
+        state.socket.close(CLOSE_AUTH_FAILED, "Invalid secret.");
+        return;
+      }
+      state.authenticated = true;
+      state.lastHeartbeatAt = Date.now();
+      if (payload.clientName) {
+        state.clientName = payload.clientName;
+      }
+      this.safeSend(
+        state.socket,
+        stringifyEnvelope(makeEnvelope("auth.ok", { connectionId: state.id }))
+      );
+      return;
+    }
+    if (envelope.type === "command.request") {
+      const payload = envelope.payload;
+      if (!envelope.requestId || !payload?.name) {
+        const invalid = {
+          ok: false,
+          requestId: envelope.requestId ?? "unknown",
+          ts: Date.now(),
+          error: {
+            code: "VALIDATION_ERROR",
+            message: "Invalid command request envelope."
+          }
+        };
+        this.safeSend(
+          state.socket,
+          stringifyEnvelope(makeEnvelope("command.error", invalid, { requestId: invalid.requestId }))
+        );
+        return;
+      }
+      const response = await this.config.onCommandRequest(
+        state,
+        payload,
+        envelope.requestId,
+        envelope.source
+      );
+      const responseType = response.ok ? "command.result" : "command.error";
+      this.safeSend(
+        state.socket,
+        stringifyEnvelope(makeEnvelope(responseType, response, { requestId: response.requestId }))
+      );
+      return;
+    }
+  }
+  checkHeartbeats() {
+    const now = Date.now();
+    const threshold = this.heartbeatMs * 2;
+    for (const state of this.connections.values()) {
+      if (!state.authenticated) {
+        continue;
+      }
+      if (now - state.lastHeartbeatAt > threshold) {
+        state.socket.terminate();
+        this.connections.delete(state.socket);
+        continue;
+      }
+      this.safeSend(state.socket, stringifyEnvelope(makeEnvelope("ping", {})));
+    }
+  }
+  safeSend(socket, payload) {
+    if (socket.readyState === 1) {
+      socket.send(payload);
+    }
+  }
+};
+
+// src/host/index.ts
+var DEFAULT_COMMAND_TIMEOUT_MS = 1e4;
+function createHostShardwire(options, runtimeHooks) {
+  const commandHandlers = /* @__PURE__ */ new Map();
+  const commandTimeoutMs = options.server.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+  const dedupeCache = new DedupeCache(commandTimeoutMs * 2);
+  const hostServer = new HostWebSocketServer({
+    options,
+    onCommandRequest: async (connection, payload, requestId, source) => {
+      const cacheKey = `${requestId}:${payload.name}`;
+      const cached = dedupeCache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+      const handler = commandHandlers.get(payload.name);
+      if (!handler) {
+        const failure = {
+          ok: false,
+          requestId,
+          ts: Date.now(),
+          error: {
+            code: "COMMAND_NOT_FOUND",
+            message: `No command handler registered for "${payload.name}".`
+          }
+        };
+        dedupeCache.set(cacheKey, failure);
+        return failure;
+      }
+      const context = {
+        requestId,
+        connectionId: connection.id,
+        receivedAt: Date.now()
+      };
+      if (source) {
+        context.source = source;
+      }
+      try {
+        const maybePromise = Promise.resolve(handler(payload.data, context));
+        const value = await withTimeout(
+          maybePromise,
+          commandTimeoutMs,
+          `Command "${payload.name}" timed out after ${commandTimeoutMs}ms.`
+        );
+        const success = {
+          ok: true,
+          requestId,
+          ts: Date.now(),
+          data: value
+        };
+        dedupeCache.set(cacheKey, success);
+        return success;
+      } catch (error) {
+        const isTimeout = error instanceof Error && /timed out/i.test(error.message);
+        const failure = {
+          ok: false,
+          requestId,
+          ts: Date.now(),
+          error: {
+            code: isTimeout ? "TIMEOUT" : "INTERNAL_ERROR",
+            message: error instanceof Error ? error.message : "Unknown command execution error."
+          }
+        };
+        dedupeCache.set(cacheKey, failure);
+        return failure;
+      }
+    }
+  });
+  return {
+    mode: "host",
+    onCommand(name, handler) {
+      assertMessageName("command", name);
+      commandHandlers.set(name, handler);
+      return () => {
+        commandHandlers.delete(name);
+      };
+    },
+    emitEvent(name, payload) {
+      assertMessageName("event", name);
+      assertJsonPayload("event", name, payload);
+      hostServer.emitEvent(name, payload, options.name);
+    },
+    broadcast(name, payload) {
+      assertMessageName("event", name);
+      assertJsonPayload("event", name, payload);
+      hostServer.emitEvent(name, payload, options.name);
+    },
+    close() {
+      return hostServer.close().then(async () => {
+        await runtimeHooks?.onClose?.();
+      });
+    }
+  };
+}
+
+// src/index.ts
+function isHostOptions(options) {
+  return "server" in options;
+}
+function createShardwire(options) {
+  if (!isHostOptions(options)) {
+    assertConsumerOptions(options);
+    return createConsumerShardwire(options);
+  }
+  assertHostOptions(options);
+  let ownedClientPromise;
+  if (!options.client && options.token) {
+    ownedClientPromise = resolveDiscordClient(options).then((state) => {
+      if (!state.owned || !state.client) {
+        return void 0;
+      }
+      return {
+        destroy: () => state.client?.destroy()
+      };
+    }).catch((error) => {
+      options.logger?.error?.("Failed to initialize discord.js client from token.", {
+        error: String(error)
+      });
+      return void 0;
+    });
+  }
+  return createHostShardwire(options, {
+    onClose: async () => {
+      const owned = await ownedClientPromise;
+      owned?.destroy();
+    }
+  });
+}
+export {
+  createShardwire
+};
+//# sourceMappingURL=index.mjs.map