@parcae/sdk 0.4.0 → 0.4.2

package/dist/chunk-LGUSPLZM.js

@@ -0,0 +1,866 @@
+import SocketIO from 'socket.io-client';
+import pako from 'pako';
+import { decompress } from 'compress-json';
+import { EventEmitter } from 'eventemitter3';
+import ShortId from 'short-unique-id';
+import { Model, FrontendAdapter } from '@parcae/model';
+
+// src/log.ts
+var isDev = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+function time() {
+  const d = /* @__PURE__ */ new Date();
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+}
+var log = {
+  info: (...args) => isDev && console.log(`%c${time()} SDK`, "color: #6b7", ...args),
+  warn: (...args) => isDev && console.warn(`%c${time()} SDK`, "color: #fb3", ...args),
+  error: (...args) => console.error(`%c${time()} SDK`, "color: #f44", ...args),
+  debug: (...args) => isDev && console.debug(`%c${time()} SDK`, "color: #888", ...args)
+};
+
+// ../../node_modules/.pnpm/proxy-compare@3.0.1/node_modules/proxy-compare/dist/index.js
+var TRACK_MEMO_SYMBOL = /* @__PURE__ */ Symbol();
+var GET_ORIGINAL_SYMBOL = /* @__PURE__ */ Symbol();
+var AFFECTED_PROPERTY = "a";
+var IS_TARGET_COPIED_PROPERTY = "f";
+var PROXY_PROPERTY = "p";
+var PROXY_CACHE_PROPERTY = "c";
+var TARGET_CACHE_PROPERTY = "t";
+var HAS_KEY_PROPERTY = "h";
+var ALL_OWN_KEYS_PROPERTY = "w";
+var HAS_OWN_KEY_PROPERTY = "o";
+var KEYS_PROPERTY = "k";
+var newProxy = (target, handler) => new Proxy(target, handler);
+var getProto = Object.getPrototypeOf;
+var objectsToTrack = /* @__PURE__ */ new WeakMap();
+var isObjectToTrack = (obj) => obj && (objectsToTrack.has(obj) ? objectsToTrack.get(obj) : getProto(obj) === Object.prototype || getProto(obj) === Array.prototype);
+var isObject = (x) => typeof x === "object" && x !== null;
+var needsToCopyTargetObject = (obj) => Object.values(Object.getOwnPropertyDescriptors(obj)).some((descriptor) => !descriptor.configurable && !descriptor.writable);
+var copyTargetObject = (obj) => {
+  if (Array.isArray(obj)) {
+    return Array.from(obj);
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
+  Object.values(descriptors).forEach((desc) => {
+    desc.configurable = true;
+  });
+  return Object.create(getProto(obj), descriptors);
+};
+var createProxyHandler = (origObj, isTargetCopied) => {
+  const state = {
+    [IS_TARGET_COPIED_PROPERTY]: isTargetCopied
+  };
+  let trackObject = false;
+  const recordUsage = (type, key) => {
+    if (!trackObject) {
+      let used = state[AFFECTED_PROPERTY].get(origObj);
+      if (!used) {
+        used = {};
+        state[AFFECTED_PROPERTY].set(origObj, used);
+      }
+      if (type === ALL_OWN_KEYS_PROPERTY) {
+        used[ALL_OWN_KEYS_PROPERTY] = true;
+      } else {
+        let set = used[type];
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          used[type] = set;
+        }
+        set.add(key);
+      }
+    }
+  };
+  const recordObjectAsUsed = () => {
+    trackObject = true;
+    state[AFFECTED_PROPERTY].delete(origObj);
+  };
+  const handler = {
+    get(target, key) {
+      if (key === GET_ORIGINAL_SYMBOL) {
+        return origObj;
+      }
+      recordUsage(KEYS_PROPERTY, key);
+      return createProxy(Reflect.get(target, key), state[AFFECTED_PROPERTY], state[PROXY_CACHE_PROPERTY], state[TARGET_CACHE_PROPERTY]);
+    },
+    has(target, key) {
+      if (key === TRACK_MEMO_SYMBOL) {
+        recordObjectAsUsed();
+        return true;
+      }
+      recordUsage(HAS_KEY_PROPERTY, key);
+      return Reflect.has(target, key);
+    },
+    getOwnPropertyDescriptor(target, key) {
+      recordUsage(HAS_OWN_KEY_PROPERTY, key);
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    },
+    ownKeys(target) {
+      recordUsage(ALL_OWN_KEYS_PROPERTY);
+      return Reflect.ownKeys(target);
+    }
+  };
+  if (isTargetCopied) {
+    handler.set = handler.deleteProperty = () => false;
+  }
+  return [handler, state];
+};
+var getOriginalObject = (obj) => (
+  // unwrap proxy
+  obj[GET_ORIGINAL_SYMBOL] || // otherwise
+  obj
+);
+var createProxy = (obj, affected, proxyCache2, targetCache) => {
+  if (!isObjectToTrack(obj))
+    return obj;
+  let targetAndCopied = targetCache && targetCache.get(obj);
+  if (!targetAndCopied) {
+    const target2 = getOriginalObject(obj);
+    if (needsToCopyTargetObject(target2)) {
+      targetAndCopied = [target2, copyTargetObject(target2)];
+    } else {
+      targetAndCopied = [target2];
+    }
+    targetCache === null || targetCache === void 0 ? void 0 : targetCache.set(obj, targetAndCopied);
+  }
+  const [target, copiedTarget] = targetAndCopied;
+  let handlerAndState = proxyCache2 && proxyCache2.get(target);
+  if (!handlerAndState || handlerAndState[1][IS_TARGET_COPIED_PROPERTY] !== !!copiedTarget) {
+    handlerAndState = createProxyHandler(target, !!copiedTarget);
+    handlerAndState[1][PROXY_PROPERTY] = newProxy(copiedTarget || target, handlerAndState[0]);
+    if (proxyCache2) {
+      proxyCache2.set(target, handlerAndState);
+    }
+  }
+  handlerAndState[1][AFFECTED_PROPERTY] = affected;
+  handlerAndState[1][PROXY_CACHE_PROPERTY] = proxyCache2;
+  handlerAndState[1][TARGET_CACHE_PROPERTY] = targetCache;
+  return handlerAndState[1][PROXY_PROPERTY];
+};
+var isAllOwnKeysChanged = (prevObj, nextObj) => {
+  const prevKeys = Reflect.ownKeys(prevObj);
+  const nextKeys = Reflect.ownKeys(nextObj);
+  return prevKeys.length !== nextKeys.length || prevKeys.some((k, i) => k !== nextKeys[i]);
+};
+var isChanged = (prevObj, nextObj, affected, cache, isEqual = Object.is) => {
+  if (isEqual(prevObj, nextObj)) {
+    return false;
+  }
+  if (!isObject(prevObj) || !isObject(nextObj))
+    return true;
+  const used = affected.get(getOriginalObject(prevObj));
+  if (!used)
+    return true;
+  if (cache) {
+    const hit = cache.get(prevObj);
+    if (hit === nextObj) {
+      return false;
+    }
+    cache.set(prevObj, nextObj);
+  }
+  let changed = null;
+  for (const key of used[HAS_KEY_PROPERTY] || []) {
+    changed = Reflect.has(prevObj, key) !== Reflect.has(nextObj, key);
+    if (changed)
+      return changed;
+  }
+  if (used[ALL_OWN_KEYS_PROPERTY] === true) {
+    changed = isAllOwnKeysChanged(prevObj, nextObj);
+    if (changed)
+      return changed;
+  } else {
+    for (const key of used[HAS_OWN_KEY_PROPERTY] || []) {
+      const hasPrev = !!Reflect.getOwnPropertyDescriptor(prevObj, key);
+      const hasNext = !!Reflect.getOwnPropertyDescriptor(nextObj, key);
+      changed = hasPrev !== hasNext;
+      if (changed)
+        return changed;
+    }
+  }
+  for (const key of used[KEYS_PROPERTY] || []) {
+    changed = isChanged(prevObj[key], nextObj[key], affected, cache, isEqual);
+    if (changed)
+      return changed;
+  }
+  if (changed === null)
+    throw new Error("invalid used");
+  return changed;
+};
+var getUntracked = (obj) => {
+  if (isObjectToTrack(obj)) {
+    return obj[GET_ORIGINAL_SYMBOL] || null;
+  }
+  return null;
+};
+var markToTrack = (obj, mark = true) => {
+  objectsToTrack.set(obj, mark);
+};
+var affectedToPathList = (obj, affected, onlyWithValues) => {
+  const list = [];
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (x, path) => {
+    var _a, _b, _c;
+    if (seen.has(x)) {
+      return;
+    }
+    if (isObject(x)) {
+      seen.add(x);
+    }
+    const used = isObject(x) && affected.get(getOriginalObject(x));
+    if (used) {
+      (_a = used[HAS_KEY_PROPERTY]) === null || _a === void 0 ? void 0 : _a.forEach((key) => {
+        const segment = `:has(${String(key)})`;
+        list.push(path ? [...path, segment] : [segment]);
+      });
+      if (used[ALL_OWN_KEYS_PROPERTY] === true) {
+        const segment = ":ownKeys";
+        list.push(path ? [...path, segment] : [segment]);
+      } else {
+        (_b = used[HAS_OWN_KEY_PROPERTY]) === null || _b === void 0 ? void 0 : _b.forEach((key) => {
+          const segment = `:hasOwn(${String(key)})`;
+          list.push(path ? [...path, segment] : [segment]);
+        });
+      }
+      (_c = used[KEYS_PROPERTY]) === null || _c === void 0 ? void 0 : _c.forEach((key) => {
+        if (!onlyWithValues || "value" in (Object.getOwnPropertyDescriptor(x, key) || {})) {
+          walk(x[key], path ? [...path, key] : [key]);
+        }
+      });
+    } else if (path) {
+      list.push(path);
+    }
+  };
+  walk(obj);
+  return list;
+};
+
+// ../../node_modules/.pnpm/valtio@2.3.1_@types+react@19.2.14_react@19.2.4/node_modules/valtio/esm/vanilla.mjs
+var isObject2 = (x) => typeof x === "object" && x !== null;
+var canProxyDefault = (x) => isObject2(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer) && !(x instanceof Promise);
+var createSnapshotDefault = (target, version) => {
+  const cache = snapCache.get(target);
+  if ((cache == null ? void 0 : cache[0]) === version) {
+    return cache[1];
+  }
+  const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
+  markToTrack(snap, true);
+  snapCache.set(target, [version, snap]);
+  Reflect.ownKeys(target).forEach((key) => {
+    if (Object.getOwnPropertyDescriptor(snap, key)) {
+      return;
+    }
+    const value = Reflect.get(target, key);
+    const { enumerable } = Reflect.getOwnPropertyDescriptor(
+      target,
+      key
+    );
+    const desc = {
+      value,
+      enumerable,
+      // This is intentional to avoid copying with proxy-compare.
+      // It's still non-writable, so it avoids assigning a value.
+      configurable: true
+    };
+    if (refSet.has(value)) {
+      markToTrack(value, false);
+    } else if (proxyStateMap.has(value)) {
+      const [target2, ensureVersion] = proxyStateMap.get(
+        value
+      );
+      desc.value = createSnapshotDefault(target2, ensureVersion());
+    }
+    Object.defineProperty(snap, key, desc);
+  });
+  return Object.preventExtensions(snap);
+};
+var createHandlerDefault = (isInitializing, addPropListener, removePropListener, notifyUpdate) => ({
+  deleteProperty(target, prop) {
+    Reflect.get(target, prop);
+    removePropListener(prop);
+    const deleted = Reflect.deleteProperty(target, prop);
+    if (deleted) {
+      notifyUpdate(void 0 );
+    }
+    return deleted;
+  },
+  set(target, prop, value, receiver) {
+    const hasPrevValue = !isInitializing() && Reflect.has(target, prop);
+    const prevValue = Reflect.get(target, prop, receiver);
+    if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) {
+      return true;
+    }
+    removePropListener(prop);
+    if (isObject2(value)) {
+      value = getUntracked(value) || value;
+    }
+    const nextValue = !proxyStateMap.has(value) && canProxy(value) ? proxy(value) : value;
+    addPropListener(prop, nextValue);
+    Reflect.set(target, prop, nextValue, receiver);
+    notifyUpdate(void 0 );
+    return true;
+  }
+});
+var proxyStateMap = /* @__PURE__ */ new WeakMap();
+var refSet = /* @__PURE__ */ new WeakSet();
+var snapCache = /* @__PURE__ */ new WeakMap();
+var versionHolder = [1];
+var proxyCache = /* @__PURE__ */ new WeakMap();
+var objectIs = Object.is;
+var newProxy2 = (target, handler) => new Proxy(target, handler);
+var canProxy = canProxyDefault;
+var createSnapshot = createSnapshotDefault;
+var createHandler = createHandlerDefault;
+function proxy(baseObject = {}) {
+  if (!isObject2(baseObject)) {
+    throw new Error("object required");
+  }
+  const found = proxyCache.get(baseObject);
+  if (found) {
+    return found;
+  }
+  let version = versionHolder[0];
+  const listeners = /* @__PURE__ */ new Set();
+  const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => {
+    if (version !== nextVersion) {
+      checkVersion = version = nextVersion;
+      listeners.forEach((listener) => listener(op, nextVersion));
+    }
+  };
+  let checkVersion = version;
+  const ensureVersion = (nextCheckVersion = versionHolder[0]) => {
+    if (checkVersion !== nextCheckVersion) {
+      checkVersion = nextCheckVersion;
+      propProxyStates.forEach(([propProxyState]) => {
+        const propVersion = propProxyState[1](nextCheckVersion);
+        if (propVersion > version) {
+          version = propVersion;
+        }
+      });
+    }
+    return version;
+  };
+  const createPropListener = (prop) => (op, nextVersion) => {
+    let newOp;
+    if (op) {
+      newOp = [...op];
+      newOp[1] = [prop, ...newOp[1]];
+    }
+    notifyUpdate(newOp, nextVersion);
+  };
+  const propProxyStates = /* @__PURE__ */ new Map();
+  const addPropListener = (prop, propValue) => {
+    const propProxyState = !refSet.has(propValue) && proxyStateMap.get(propValue);
+    if (propProxyState) {
+      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && propProxyStates.has(prop)) {
+        throw new Error("prop listener already exists");
+      }
+      if (listeners.size) {
+        const remove = propProxyState[2](createPropListener(prop));
+        propProxyStates.set(prop, [propProxyState, remove]);
+      } else {
+        propProxyStates.set(prop, [propProxyState]);
+      }
+    }
+  };
+  const removePropListener = (prop) => {
+    var _a;
+    const entry = propProxyStates.get(prop);
+    if (entry) {
+      propProxyStates.delete(prop);
+      (_a = entry[1]) == null ? void 0 : _a.call(entry);
+    }
+  };
+  const addListener = (listener) => {
+    listeners.add(listener);
+    if (listeners.size === 1) {
+      propProxyStates.forEach(([propProxyState, prevRemove], prop) => {
+        if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && prevRemove) {
+          throw new Error("remove already exists");
+        }
+        const remove = propProxyState[2](createPropListener(prop));
+        propProxyStates.set(prop, [propProxyState, remove]);
+      });
+    }
+    const removeListener = () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        propProxyStates.forEach(([propProxyState, remove], prop) => {
+          if (remove) {
+            remove();
+            propProxyStates.set(prop, [propProxyState]);
+          }
+        });
+      }
+    };
+    return removeListener;
+  };
+  let initializing = true;
+  const handler = createHandler(
+    () => initializing,
+    addPropListener,
+    removePropListener,
+    notifyUpdate
+  );
+  const proxyObject = newProxy2(baseObject, handler);
+  proxyCache.set(baseObject, proxyObject);
+  const proxyState = [baseObject, ensureVersion, addListener];
+  proxyStateMap.set(proxyObject, proxyState);
+  Reflect.ownKeys(baseObject).forEach((key) => {
+    const desc = Object.getOwnPropertyDescriptor(
+      baseObject,
+      key
+    );
+    if ("value" in desc && desc.writable) {
+      proxyObject[key] = baseObject[key];
+    }
+  });
+  initializing = false;
+  return proxyObject;
+}
+function subscribe(proxyObject, callback, notifyInSync) {
+  const proxyState = proxyStateMap.get(proxyObject);
+  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !proxyState) {
+    console.warn("Please use proxy object");
+  }
+  let promise;
+  const ops = [];
+  const addListener = proxyState[2];
+  let isListenerActive = false;
+  const listener = (op) => {
+    if (op) {
+      ops.push(op);
+    }
+    if (notifyInSync) {
+      callback(ops.splice(0));
+      return;
+    }
+    if (!promise) {
+      promise = Promise.resolve().then(() => {
+        promise = void 0;
+        if (isListenerActive) {
+          callback(ops.splice(0));
+        }
+      });
+    }
+  };
+  const removeListener = addListener(listener);
+  isListenerActive = true;
+  return () => {
+    isListenerActive = false;
+    removeListener();
+  };
+}
+function snapshot(proxyObject) {
+  const proxyState = proxyStateMap.get(proxyObject);
+  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !proxyState) {
+    console.warn("Please use proxy object");
+  }
+  const [target, ensureVersion] = proxyState;
+  return createSnapshot(target, ensureVersion());
+}
+
+// src/auth-gate.ts
+var AuthGate = class {
+  /** Reactive state — subscribe with valtio useSnapshot() */
+  state = proxy({
+    status: "pending",
+    userId: null,
+    version: 0
+  });
+  /** Awaitable — resolves when auth is confirmed (either way) */
+  ready;
+  _resolve = null;
+  constructor() {
+    this.ready = this._makePending();
+  }
+  /** Auth confirmed — user is authenticated */
+  resolve(userId) {
+    this.state.status = "authenticated";
+    log.info("auth: authenticated, userId:", userId);
+    this.state.userId = userId;
+    this.state.version++;
+    this._resolve?.();
+    this._resolve = null;
+  }
+  /** Auth confirmed — no user */
+  resolveUnauthenticated() {
+    this.state.status = "unauthenticated";
+    log.info("auth: unauthenticated");
+    this.state.userId = null;
+    this.state.version++;
+    this._resolve?.();
+    this._resolve = null;
+  }
+  /** Reset to pending (disconnect, token change) */
+  reset() {
+    if (this.state.status !== "pending") {
+      this.state.status = "pending";
+      log.info("auth: reset to pending");
+      this.state.userId = null;
+      this.ready = this._makePending();
+    }
+  }
+  _makePending() {
+    return new Promise((r) => {
+      this._resolve = r;
+    });
+  }
+};
+var uid = new ShortId({ length: 10 });
+var SOCKETS = /* @__PURE__ */ new Map();
+var SocketTransport = class extends EventEmitter {
+  auth = new AuthGate();
+  isConnected = false;
+  socket;
+  url;
+  version;
+  token;
+  inflight = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super();
+    this.url = config.url;
+    this.version = config.version ?? "v1";
+    this.token = config.token;
+    const socketPath = config.path ?? "/ws";
+    const socketKey = `${this.url}:${socketPath}`;
+    if (SOCKETS.has(socketKey)) {
+      this.socket = SOCKETS.get(socketKey);
+    } else {
+      this.socket = SocketIO(this.url, {
+        path: socketPath,
+        transports: ["websocket"],
+        withCredentials: true
+      });
+      SOCKETS.set(socketKey, this.socket);
+    }
+    this.socket.on("connect", () => {
+      this.isConnected = true;
+      log.info("socket connected");
+      this._doAuth();
+      this.emit("connected");
+    });
+    this.socket.on("disconnect", () => {
+      this.isConnected = false;
+      log.info("socket disconnected");
+      this.auth.reset();
+      this.emit("disconnected");
+    });
+    this.socket.on("error", (err) => this.emit("error", err));
+    if (this.socket.connected) {
+      this.isConnected = true;
+      log.info("socket connected");
+      this._doAuth();
+    }
+    if (this.token === null) {
+      this.auth.resolveUnauthenticated();
+    }
+  }
+  _doAuth() {
+    if (this.token === void 0) return;
+    if (this.token === null) {
+      this.auth.resolveUnauthenticated();
+      return;
+    }
+    log.info("authenticating with token", this.token?.slice(0, 8) + "...");
+    this.socket.emit("authenticate", this.token, (response) => {
+      const userId = response?.userId ?? null;
+      if (userId) {
+        this.auth.resolve(userId);
+      } else {
+        this.auth.resolveUnauthenticated();
+      }
+    });
+  }
+  async authenticate(token) {
+    this.token = token;
+    this.auth.reset();
+    if (token === null) {
+      this.auth.resolveUnauthenticated();
+      return { userId: null };
+    }
+    if (!this.socket.connected) {
+      return new Promise((resolve) => {
+        const handler = () => {
+          this.socket.off("connect", handler);
+          this.socket.emit("authenticate", token, (response) => {
+            const userId = response?.userId ?? null;
+            if (userId) this.auth.resolve(userId);
+            else this.auth.resolveUnauthenticated();
+            resolve({ userId });
+          });
+        };
+        this.socket.once("connect", handler);
+      });
+    }
+    return new Promise((resolve) => {
+      this.socket.emit("authenticate", token, (response) => {
+        const userId = response?.userId ?? null;
+        if (userId) this.auth.resolve(userId);
+        else this.auth.resolveUnauthenticated();
+        resolve({ userId });
+      });
+    });
+  }
+  // ── Request/Response ──────────────────────────────────────────────
+  async fetch(method, path, data = {}) {
+    await this.auth.ready;
+    if (!this.socket.connected) {
+      await new Promise((resolve, reject) => {
+        if (this.socket.connected) return resolve();
+        const timeout = setTimeout(() => {
+          cleanup();
+          reject(new Error("Connection timeout"));
+        }, 3e4);
+        const onConnect = () => {
+          cleanup();
+          resolve();
+        };
+        const onError = (err) => {
+          cleanup();
+          reject(err);
+        };
+        const cleanup = () => {
+          clearTimeout(timeout);
+          this.socket.off("connect", onConnect);
+          this.socket.off("connect_error", onError);
+        };
+        this.socket.once("connect", onConnect);
+        this.socket.once("connect_error", onError);
+      });
+    }
+    const upper = method.toUpperCase();
+    if (upper === "GET") {
+      const dedupeKey = `${path}:${JSON.stringify(data)}`;
+      const existing = this.inflight.get(dedupeKey);
+      if (existing) return existing;
+      const req = this._call(method, path, data);
+      this.inflight.set(dedupeKey, req);
+      req.finally(() => this.inflight.delete(dedupeKey));
+      return req;
+    }
+    return this._call(method, path, data);
+  }
+  _call(method, path, data) {
+    const id = uid.rnd();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.socket.off(id);
+        reject(new Error(`RPC timeout: ${method} ${path}`));
+      }, 3e4);
+      this.socket.once(id, (msg) => {
+        clearTimeout(timeout);
+        try {
+          const uncompressed = pako.ungzip(msg, { to: "string" });
+          const parsed = decompress(JSON.parse(uncompressed));
+          if (parsed.success) resolve(parsed.result);
+          else
+            reject(
+              new Error(
+                parsed.message || parsed.error || `${method} ${path} failed`
+              )
+            );
+        } catch (err) {
+          reject(err);
+        }
+      });
+      this.socket.emit(
+        "call",
+        id,
+        method.toUpperCase(),
+        `/${this.version}${path}`,
+        data
+      );
+    });
+  }
+  async get(path, data) {
+    return this.fetch("GET", path, data);
+  }
+  async post(path, data) {
+    return this.fetch("POST", path, data);
+  }
+  async put(path, data) {
+    return this.fetch("PUT", path, data);
+  }
+  async patch(path, data) {
+    return this.fetch("PATCH", path, data);
+  }
+  async delete(path, data) {
+    return this.fetch("DELETE", path, data);
+  }
+  subscribe(event, handler) {
+    this.socket.on(event, handler);
+    return () => this.socket.off(event, handler);
+  }
+  unsubscribe(event, handler) {
+    this.socket.off(event, handler);
+  }
+  async send(event, ...args) {
+    await this.auth.ready;
+    this.socket.emit(event, ...args);
+  }
+  disconnect() {
+    this.socket.disconnect();
+    this.isConnected = false;
+    log.info("socket disconnected");
+  }
+  async reconnect() {
+    this.socket.connect();
+  }
+};
+var SSETransport = class extends EventEmitter {
+  url;
+  version;
+  apiKey;
+  key = null;
+  eventSources = /* @__PURE__ */ new Map();
+  isConnected = true;
+  // HTTP is "always connected"
+  isLoading = true;
+  loading;
+  constructor(config) {
+    super();
+    this.url = config.url.replace(/\/$/, "");
+    this.version = config.version ?? "v1";
+    this.apiKey = config.key ?? null;
+    this.loading = this.resolveKey();
+  }
+  async resolveKey() {
+    try {
+      this.key = typeof this.apiKey === "function" ? await this.apiKey() : this.apiKey;
+      this.isLoading = false;
+      this.emit("connected");
+    } catch (err) {
+      this.isLoading = false;
+      this.emit("error", err);
+    }
+  }
+  headers() {
+    const h = { "Content-Type": "application/json" };
+    if (this.key) h["Authorization"] = `Bearer ${this.key}`;
+    return h;
+  }
+  fullUrl(path) {
+    return `${this.url}/${this.version}${path}`;
+  }
+  // ── Request/Response ──────────────────────────────────────────────────
+  async request(method, path, data) {
+    await this.loading;
+    const isGet = method.toUpperCase() === "GET";
+    let url = this.fullUrl(path);
+    if (isGet && data) {
+      const params = new URLSearchParams();
+      for (const [k, v] of Object.entries(data)) {
+        params.set(k, typeof v === "object" ? JSON.stringify(v) : String(v));
+      }
+      url += `?${params.toString()}`;
+    }
+    const res = await fetch(url, {
+      method: method.toUpperCase(),
+      headers: this.headers(),
+      body: isGet ? void 0 : JSON.stringify(data)
+    });
+    if (!res.ok) {
+      const body2 = await res.json().catch(() => ({ error: res.statusText }));
+      throw new Error(body2.error || body2.message || `HTTP ${res.status}`);
+    }
+    const body = await res.json();
+    if (body.success === false) throw new Error(body.error || "Request failed");
+    return body.result ?? body;
+  }
+  async get(path, data) {
+    return this.request("GET", path, data);
+  }
+  async post(path, data) {
+    return this.request("POST", path, data);
+  }
+  async put(path, data) {
+    return this.request("PUT", path, data);
+  }
+  async patch(path, data) {
+    return this.request("PATCH", path, data);
+  }
+  async delete(path, data) {
+    return this.request("DELETE", path, data);
+  }
+  // ── Subscriptions (via Server-Sent Events) ────────────────────────────
+  subscribe(event, handler) {
+    const url = `${this.url}/${this.version}/__events/${encodeURIComponent(event)}`;
+    const source = new EventSource(url, { withCredentials: true });
+    source.onmessage = (e) => {
+      try {
+        const data = JSON.parse(e.data);
+        handler(data);
+      } catch {
+        handler(e.data);
+      }
+    };
+    source.onerror = () => {
+    };
+    this.eventSources.set(event, source);
+    return () => {
+      source.close();
+      this.eventSources.delete(event);
+    };
+  }
+  unsubscribe(event) {
+    const source = this.eventSources.get(event);
+    if (source) {
+      source.close();
+      this.eventSources.delete(event);
+    }
+  }
+  // ── Control messages ──────────────────────────────────────────────────
+  async send(event, ...args) {
+    await this.request("POST", "/__control", { event, args });
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────
+  disconnect() {
+    for (const [, source] of this.eventSources) source.close();
+    this.eventSources.clear();
+    this.isConnected = false;
+    this.emit("disconnected");
+  }
+  async reconnect() {
+    this.loading = this.resolveKey();
+    await this.loading;
+  }
+};
+function createClient(config) {
+  const version = config.version ?? "v1";
+  let transport;
+  if (config.transport && typeof config.transport === "object") {
+    transport = config.transport;
+  } else if (config.transport === "sse") {
+    transport = new SSETransport({ url: config.url, version });
+  } else {
+    transport = new SocketTransport({
+      url: config.url,
+      version,
+      token: config.token
+    });
+  }
+  Model.use(new FrontendAdapter(transport));
+  return {
+    transport,
+    get: (p, d) => transport.get(p, d),
+    post: (p, d) => transport.post(p, d),
+    put: (p, d) => transport.put(p, d),
+    patch: (p, d) => transport.patch(p, d),
+    delete: (p, d) => transport.delete(p, d),
+    subscribe: (e, h) => transport.subscribe?.(e, h) ?? (() => {
+    }),
+    unsubscribe: (e, h) => transport.unsubscribe?.(e, h),
+    send: (e, ...a) => transport.send?.(e, ...a),
+    get isConnected() {
+      return transport.isConnected ?? false;
+    },
+    authenticate: (t) => transport.authenticate?.(t) ?? Promise.resolve({ userId: null }),
+    on: (e, h) => transport.on?.(e, h),
+    off: (e, h) => transport.off?.(e, h),
+    disconnect: () => transport.disconnect?.(),
+    reconnect: () => transport.reconnect?.() ?? Promise.resolve()
+  };
+}
+
+export { AuthGate, SSETransport, SocketTransport, affectedToPathList, createClient, createProxy, isChanged, log, snapshot, subscribe };
+//# sourceMappingURL=chunk-LGUSPLZM.js.map
+//# sourceMappingURL=chunk-LGUSPLZM.js.map