@hanzo/base 0.2.0

package/dist/chunk-LBAV5X5P.js

@@ -0,0 +1,996 @@
+// src/core/state.ts
+var VersionTracker = class {
+  constructor(maxHistory = 128) {
+    this._history = [];
+    this._version = { querySet: 0, ts: 0n, identity: 0 };
+    this._maxHistory = maxHistory;
+  }
+  get current() {
+    return { ...this._version };
+  }
+  get history() {
+    return this._history;
+  }
+  /**
+   * Advance the version and record a transition.
+   * Returns the new version.
+   */
+  advance(modifications, serverTs) {
+    const start = { ...this._version };
+    this._version = {
+      querySet: this._version.querySet + 1,
+      ts: serverTs ?? this._version.ts,
+      identity: this._version.identity
+    };
+    const transition = {
+      startVersion: start,
+      endVersion: { ...this._version },
+      modifications
+    };
+    this._history.push(transition);
+    if (this._history.length > this._maxHistory) {
+      this._history.shift();
+    }
+    return { ...this._version };
+  }
+  /** Update identity hash (e.g. on auth change). */
+  setIdentity(identity) {
+    this._version = { ...this._version, identity };
+  }
+  /** Update the high-water timestamp without bumping querySet. */
+  updateTimestamp(ts) {
+    if (ts > this._version.ts) {
+      this._version = { ...this._version, ts };
+    }
+  }
+  /** Simple FNV-1a-like hash for identity derivation. */
+  static hashIdentity(token) {
+    let h = 2166136261;
+    for (let i = 0; i < token.length; i++) {
+      h ^= token.charCodeAt(i);
+      h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+  }
+};
+
+// src/core/store.ts
+function queryHash(collection, filter) {
+  return `${collection}::${filter}`;
+}
+function mergeOptimistic(server, optimistic, collection) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of server) {
+    map.set(r.id, r);
+  }
+  for (const entry of optimistic) {
+    if (entry.collection !== collection) continue;
+    if (entry.record === null && entry.deletedId) {
+      map.delete(entry.deletedId);
+    } else if (entry.record) {
+      map.set(entry.record.id, entry.record);
+    }
+  }
+  return Array.from(map.values());
+}
+var QueryStore = class {
+  constructor() {
+    this._slots = /* @__PURE__ */ new Map();
+    this._optimistic = [];
+    this._version = new VersionTracker();
+  }
+  get version() {
+    return this._version.current;
+  }
+  // ---- Query cache --------------------------------------------------------
+  /** Return cached effective (server+optimistic) result or undefined. */
+  getQuery(collection, filter = "") {
+    const slot = this._slots.get(queryHash(collection, filter));
+    if (!slot) return void 0;
+    return mergeOptimistic(slot.serverRecords, this._optimistic, collection);
+  }
+  /** Overwrite the server-truth cache for a query and notify. */
+  setQuery(collection, filter, data) {
+    const hash = queryHash(collection, filter);
+    let slot = this._slots.get(hash);
+    if (!slot) {
+      slot = { key: { collection, filter }, serverRecords: [], listeners: /* @__PURE__ */ new Set() };
+      this._slots.set(hash, slot);
+    }
+    slot.serverRecords = data;
+    this._version.advance(
+      data.map((r) => ({ type: "QueryUpdated", collection, record: r }))
+    );
+    this._notify(slot);
+  }
+  // ---- Optimistic mutations -----------------------------------------------
+  /** Apply an optimistic create/update. Returns a mutationId for rollback. */
+  optimisticSet(collection, record) {
+    const mutationId = `opt_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    this._optimistic.push({
+      mutationId,
+      collection,
+      record,
+      createdAt: Date.now()
+    });
+    this._notifyCollection(collection);
+    return mutationId;
+  }
+  /** Apply an optimistic delete. */
+  optimisticDelete(collection, id) {
+    const mutationId = `opt_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    this._optimistic.push({
+      mutationId,
+      collection,
+      record: null,
+      deletedId: id,
+      createdAt: Date.now()
+    });
+    this._notifyCollection(collection);
+    return mutationId;
+  }
+  /** Remove a single optimistic mutation and re-derive. */
+  rollbackOptimistic(mutationId) {
+    const idx = this._optimistic.findIndex((e) => e.mutationId === mutationId);
+    if (idx === -1) return;
+    const entry = this._optimistic[idx];
+    this._optimistic.splice(idx, 1);
+    this._notifyCollection(entry.collection);
+  }
+  /** Drop all optimistic entries for a collection. */
+  clearOptimistic(collection) {
+    for (let i = this._optimistic.length - 1; i >= 0; i--) {
+      if (this._optimistic[i].collection === collection) {
+        this._optimistic.splice(i, 1);
+      }
+    }
+    this._notifyCollection(collection);
+  }
+  // ---- Server event ingestion ---------------------------------------------
+  /**
+   * Apply a realtime SSE event from the server.
+   * `action` is one of "create", "update", "delete".
+   */
+  applyServerUpdate(collection, action, record) {
+    const mods = [];
+    for (const slot of this._slots.values()) {
+      if (slot.key.collection !== collection) continue;
+      if (action === "delete") {
+        const before = slot.serverRecords.length;
+        slot.serverRecords = slot.serverRecords.filter((r) => r.id !== record.id);
+        if (slot.serverRecords.length !== before) {
+          mods.push({ type: "QueryRemoved", collection, id: record.id });
+        }
+      } else {
+        const idx = slot.serverRecords.findIndex((r) => r.id === record.id);
+        if (idx >= 0) {
+          slot.serverRecords[idx] = record;
+        } else {
+          slot.serverRecords.push(record);
+        }
+        mods.push({ type: "QueryUpdated", collection, record });
+      }
+    }
+    if (mods.length > 0) {
+      const ts = record.updated ? BigInt(new Date(record.updated).getTime()) * 1000n : void 0;
+      this._version.advance(mods, ts);
+    }
+    this._notifyCollection(collection);
+  }
+  // ---- Subscriptions ------------------------------------------------------
+  /** Subscribe to effective-state changes for a query. Returns unsubscribe. */
+  subscribe(collection, filter, callback) {
+    const hash = queryHash(collection, filter);
+    let slot = this._slots.get(hash);
+    if (!slot) {
+      slot = { key: { collection, filter }, serverRecords: [], listeners: /* @__PURE__ */ new Set() };
+      this._slots.set(hash, slot);
+    }
+    slot.listeners.add(callback);
+    return () => {
+      slot.listeners.delete(callback);
+      if (slot.listeners.size === 0 && slot.serverRecords.length === 0) {
+        this._slots.delete(hash);
+      }
+    };
+  }
+  // ---- Internal -----------------------------------------------------------
+  _notify(slot) {
+    if (slot.listeners.size === 0) return;
+    const effective = mergeOptimistic(slot.serverRecords, this._optimistic, slot.key.collection);
+    for (const cb of slot.listeners) {
+      try {
+        cb(effective);
+      } catch {
+      }
+    }
+  }
+  _notifyCollection(collection) {
+    for (const slot of this._slots.values()) {
+      if (slot.key.collection === collection) {
+        this._notify(slot);
+      }
+    }
+  }
+};
+
+// src/core/realtime.ts
+var RealtimeService = class {
+  constructor(baseUrl, getToken) {
+    this._eventSource = null;
+    this._state = "disconnected";
+    this._connectionListeners = /* @__PURE__ */ new Set();
+    /** Dedup map: hash -> Subscription. */
+    this._subscriptions = /* @__PURE__ */ new Map();
+    /** SSE client id assigned by the server on connect. */
+    this._clientId = null;
+    /** Reconnect state. */
+    this._reconnectAttempts = 0;
+    this._reconnectTimer = null;
+    this._maxReconnectDelay = 3e4;
+    this._baseReconnectDelay = 500;
+    /** High-water mark of observed server timestamps. */
+    this._maxTimestamp = 0n;
+    /** Set to true when disconnect() is called explicitly. */
+    this._intentionalDisconnect = false;
+    this._baseUrl = baseUrl.replace(/\/$/, "");
+    this._getToken = getToken;
+  }
+  // ---- Public API ---------------------------------------------------------
+  get state() {
+    return this._state;
+  }
+  get maxTimestamp() {
+    return this._maxTimestamp;
+  }
+  /**
+   * Subscribe to realtime events for a collection topic.
+   *
+   * Topic is usually "*" (all changes) or a record id.
+   * Returns an unsubscribe function.
+   */
+  subscribe(collection, topic, callback) {
+    const hash = this._hash(collection, topic);
+    let sub = this._subscriptions.get(hash);
+    if (!sub) {
+      sub = { collection, topic, callbacks: /* @__PURE__ */ new Set() };
+      this._subscriptions.set(hash, sub);
+    }
+    sub.callbacks.add(callback);
+    if (this._subscriptions.size === 1 && !this._eventSource) {
+      this._connect();
+    } else if (this._clientId) {
+      this._submitSubscriptions();
+    }
+    return () => {
+      sub.callbacks.delete(callback);
+      if (sub.callbacks.size === 0) {
+        this._subscriptions.delete(hash);
+        if (this._clientId) {
+          this._submitSubscriptions();
+        }
+      }
+      if (this._subscriptions.size === 0) {
+        this.disconnect();
+      }
+    };
+  }
+  /** Remove all subscribers for a topic, or all topics if none specified. */
+  unsubscribe(topic) {
+    if (topic) {
+      this._subscriptions.delete(topic);
+    } else {
+      this._subscriptions.clear();
+    }
+    if (this._subscriptions.size === 0) {
+      this.disconnect();
+    }
+  }
+  /** Register a connection-state listener. Returns unsubscribe. */
+  onConnectionChange(callback) {
+    this._connectionListeners.add(callback);
+    return () => {
+      this._connectionListeners.delete(callback);
+    };
+  }
+  /** Explicitly disconnect. */
+  disconnect() {
+    this._intentionalDisconnect = true;
+    this._clearReconnect();
+    if (this._eventSource) {
+      this._eventSource.close();
+      this._eventSource = null;
+    }
+    this._clientId = null;
+    this._setState("disconnected");
+  }
+  // ---- Connection ---------------------------------------------------------
+  _connect() {
+    if (this._eventSource) return;
+    this._intentionalDisconnect = false;
+    this._setState("connecting");
+    const url = `${this._baseUrl}/api/realtime`;
+    this._eventSource = new EventSource(url);
+    this._eventSource.addEventListener("PB_CONNECT", (e) => {
+      try {
+        const data = JSON.parse(e.data);
+        this._clientId = data.clientId;
+        this._reconnectAttempts = 0;
+        this._setState("connected");
+        this._submitSubscriptions();
+      } catch {
+      }
+    });
+    this._eventSource.onmessage = (e) => {
+      this._handleMessage(e);
+    };
+    this._eventSource.onerror = () => {
+      this._eventSource?.close();
+      this._eventSource = null;
+      this._clientId = null;
+      this._setState("disconnected");
+      if (!this._intentionalDisconnect) {
+        this._scheduleReconnect();
+      }
+    };
+  }
+  _handleMessage(e) {
+    let payload;
+    try {
+      payload = JSON.parse(e.data);
+    } catch {
+      return;
+    }
+    const action = payload.action;
+    const record = payload.record;
+    if (!record?.id) return;
+    const ts = record.updated ?? record.created;
+    if (ts) {
+      const n = BigInt(new Date(ts).getTime()) * 1000n;
+      if (n > this._maxTimestamp) {
+        this._maxTimestamp = n;
+      }
+    }
+    const collectionName = record.collectionName ?? "";
+    for (const sub of this._subscriptions.values()) {
+      if (sub.collection !== collectionName) continue;
+      if (sub.topic !== "*" && sub.topic !== record.id) continue;
+      const event = { action, record };
+      for (const cb of sub.callbacks) {
+        try {
+          cb(event);
+        } catch {
+        }
+      }
+    }
+  }
+  /** Submit current subscription set to the server via POST. */
+  async _submitSubscriptions() {
+    if (!this._clientId) return;
+    const topics = [];
+    for (const sub of this._subscriptions.values()) {
+      topics.push(`${sub.collection}/${sub.topic}`);
+    }
+    const token = this._getToken();
+    try {
+      await fetch(`${this._baseUrl}/api/realtime`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...token ? { Authorization: token } : {}
+        },
+        body: JSON.stringify({
+          clientId: this._clientId,
+          subscriptions: topics
+        })
+      });
+    } catch {
+    }
+  }
+  // ---- Reconnect ----------------------------------------------------------
+  _scheduleReconnect() {
+    this._clearReconnect();
+    const delay = Math.min(
+      this._baseReconnectDelay * Math.pow(2, this._reconnectAttempts),
+      this._maxReconnectDelay
+    );
+    const jitter = delay * (0.75 + Math.random() * 0.5);
+    this._reconnectAttempts++;
+    this._reconnectTimer = setTimeout(() => {
+      this._reconnectTimer = null;
+      this._connect();
+    }, jitter);
+  }
+  _clearReconnect() {
+    if (this._reconnectTimer !== null) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+  }
+  // ---- State --------------------------------------------------------------
+  _setState(state) {
+    if (this._state === state) return;
+    this._state = state;
+    for (const cb of this._connectionListeners) {
+      try {
+        cb(state);
+      } catch {
+      }
+    }
+  }
+  // ---- Helpers ------------------------------------------------------------
+  _hash(collection, topic) {
+    return `${collection}::${topic}`;
+  }
+};
+
+// src/core/collection.ts
+var CollectionService = class {
+  constructor(collectionIdOrName, baseUrl, getToken, setAuth, store, realtime) {
+    this.collectionIdOrName = collectionIdOrName;
+    this._baseUrl = baseUrl.replace(/\/$/, "");
+    this._getToken = getToken;
+    this._setAuth = setAuth;
+    this._store = store;
+    this._realtime = realtime;
+  }
+  // ---- CRUD ---------------------------------------------------------------
+  async getList(page = 1, perPage = 30, options) {
+    const params = new URLSearchParams();
+    params.set("page", String(page));
+    params.set("perPage", String(perPage));
+    this._applyOptions(params, options);
+    const result = await this._request(
+      "GET",
+      `${this._collectionPath()}/records?${params}`,
+      void 0,
+      options
+    );
+    const cacheFilter = options?.filter ?? "";
+    this._store.setQuery(
+      this.collectionIdOrName,
+      cacheFilter,
+      result.items
+    );
+    return result;
+  }
+  async getFullList(options) {
+    const batch = options?.batch ?? 200;
+    let page = 1;
+    let all = [];
+    while (true) {
+      const result = await this.getList(page, batch, options);
+      all = all.concat(result.items);
+      if (all.length >= result.totalItems || result.items.length < batch) {
+        break;
+      }
+      page++;
+    }
+    return all;
+  }
+  async getOne(id, options) {
+    const params = new URLSearchParams();
+    this._applyOptions(params, options);
+    const qs = params.toString();
+    const path = `${this._collectionPath()}/records/${encodeURIComponent(id)}${qs ? "?" + qs : ""}`;
+    return this._request("GET", path, void 0, options);
+  }
+  async getFirstListItem(filter, options) {
+    const opts = { ...options, filter };
+    const result = await this.getList(1, 1, opts);
+    if (result.items.length === 0) {
+      throw new ClientResponseError({
+        url: this._baseUrl,
+        status: 404,
+        data: { message: "The requested resource wasn't found." }
+      });
+    }
+    return result.items[0];
+  }
+  async create(data, options) {
+    const params = new URLSearchParams();
+    this._applyOptions(params, options);
+    const qs = params.toString();
+    const path = `${this._collectionPath()}/records${qs ? "?" + qs : ""}`;
+    let mutationId;
+    if (!(data instanceof FormData) && typeof data === "object") {
+      const tempId = `__temp_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+      const optimistic = {
+        id: tempId,
+        collectionName: this.collectionIdOrName,
+        ...data
+      };
+      mutationId = this._store.optimisticSet(this.collectionIdOrName, optimistic);
+    }
+    try {
+      const body = data instanceof FormData ? data : JSON.stringify(data);
+      const contentType = data instanceof FormData ? void 0 : "application/json";
+      const record = await this._request("POST", path, body, options, contentType);
+      if (mutationId) {
+        this._store.rollbackOptimistic(mutationId);
+      }
+      this._store.applyServerUpdate(this.collectionIdOrName, "create", record);
+      return record;
+    } catch (err) {
+      if (mutationId) {
+        this._store.rollbackOptimistic(mutationId);
+      }
+      throw err;
+    }
+  }
+  async update(id, data, options) {
+    const params = new URLSearchParams();
+    this._applyOptions(params, options);
+    const qs = params.toString();
+    const path = `${this._collectionPath()}/records/${encodeURIComponent(id)}${qs ? "?" + qs : ""}`;
+    let mutationId;
+    if (!(data instanceof FormData) && typeof data === "object") {
+      const optimistic = {
+        id,
+        collectionName: this.collectionIdOrName,
+        ...data
+      };
+      mutationId = this._store.optimisticSet(this.collectionIdOrName, optimistic);
+    }
+    try {
+      const body = data instanceof FormData ? data : JSON.stringify(data);
+      const contentType = data instanceof FormData ? void 0 : "application/json";
+      const record = await this._request("PATCH", path, body, options, contentType);
+      if (mutationId) {
+        this._store.rollbackOptimistic(mutationId);
+      }
+      this._store.applyServerUpdate(this.collectionIdOrName, "update", record);
+      return record;
+    } catch (err) {
+      if (mutationId) {
+        this._store.rollbackOptimistic(mutationId);
+      }
+      throw err;
+    }
+  }
+  async delete(id, options) {
+    const params = new URLSearchParams();
+    this._applyOptions(params, options);
+    const qs = params.toString();
+    const path = `${this._collectionPath()}/records/${encodeURIComponent(id)}${qs ? "?" + qs : ""}`;
+    const mutationId = this._store.optimisticDelete(this.collectionIdOrName, id);
+    try {
+      await this._request("DELETE", path, void 0, options);
+      this._store.rollbackOptimistic(mutationId);
+      this._store.applyServerUpdate(this.collectionIdOrName, "delete", { id });
+      return true;
+    } catch (err) {
+      this._store.rollbackOptimistic(mutationId);
+      throw err;
+    }
+  }
+  // ---- Realtime -----------------------------------------------------------
+  /**
+   * Subscribe to realtime events for this collection.
+   * `topic` is "*" for all changes or a specific record id.
+   */
+  subscribe(topic, callback) {
+    return this._realtime.subscribe(this.collectionIdOrName, topic, callback);
+  }
+  /** Unsubscribe from a specific topic or all topics for this collection. */
+  unsubscribe(topic) {
+    this._realtime.unsubscribe(
+      topic ? `${this.collectionIdOrName}/${topic}` : this.collectionIdOrName
+    );
+  }
+  // ---- Auth methods (for auth collections) --------------------------------
+  async authWithPassword(identity, password, options) {
+    const params = new URLSearchParams();
+    this._applyOptions(params, options);
+    const qs = params.toString();
+    const path = `${this._collectionPath()}/auth-with-password${qs ? "?" + qs : ""}`;
+    const result = await this._request(
+      "POST",
+      path,
+      JSON.stringify({ identity, password }),
+      options,
+      "application/json"
+    );
+    this._setAuth(result.token, result.record);
+    return result;
+  }
+  async authWithOAuth2(oauthOptions, options) {
+    const params = new URLSearchParams();
+    this._applyOptions(params, options);
+    const qs = params.toString();
+    const path = `${this._collectionPath()}/auth-with-oauth2${qs ? "?" + qs : ""}`;
+    const result = await this._request(
+      "POST",
+      path,
+      JSON.stringify(oauthOptions),
+      options,
+      "application/json"
+    );
+    this._setAuth(result.token, result.record);
+    return result;
+  }
+  async requestVerification(email, options) {
+    const path = `${this._collectionPath()}/request-verification`;
+    await this._request(
+      "POST",
+      path,
+      JSON.stringify({ email }),
+      options,
+      "application/json"
+    );
+    return true;
+  }
+  async confirmVerification(token, options) {
+    const path = `${this._collectionPath()}/confirm-verification`;
+    await this._request(
+      "POST",
+      path,
+      JSON.stringify({ token }),
+      options,
+      "application/json"
+    );
+    return true;
+  }
+  async requestPasswordReset(email, options) {
+    const path = `${this._collectionPath()}/request-password-reset`;
+    await this._request(
+      "POST",
+      path,
+      JSON.stringify({ email }),
+      options,
+      "application/json"
+    );
+    return true;
+  }
+  async confirmPasswordReset(token, password, passwordConfirm, options) {
+    const path = `${this._collectionPath()}/confirm-password-reset`;
+    await this._request(
+      "POST",
+      path,
+      JSON.stringify({ token, password, passwordConfirm }),
+      options,
+      "application/json"
+    );
+    return true;
+  }
+  // ---- Internal -----------------------------------------------------------
+  _collectionPath() {
+    return `/api/collections/${encodeURIComponent(this.collectionIdOrName)}`;
+  }
+  _applyOptions(params, options) {
+    if (!options) return;
+    if (options.filter) params.set("filter", options.filter);
+    if (options.sort) params.set("sort", options.sort);
+    if (options.expand) params.set("expand", options.expand);
+    if (options.fields) params.set("fields", options.fields);
+    if (options.query) {
+      for (const [k, v] of Object.entries(options.query)) {
+        params.set(k, v);
+      }
+    }
+  }
+  async _request(method, path, body, options, contentType) {
+    const url = `${this._baseUrl}${path}`;
+    const token = this._getToken();
+    const headers = {
+      ...options?.headers ?? {}
+    };
+    if (token) {
+      headers["Authorization"] = token;
+    }
+    if (contentType) {
+      headers["Content-Type"] = contentType;
+    }
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ?? void 0,
+      signal: options?.signal
+    });
+    if (!response.ok) {
+      const data = await response.json().catch(() => ({}));
+      throw new ClientResponseError({
+        url,
+        status: response.status,
+        data
+      });
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return response.json();
+  }
+};
+var ClientResponseError = class extends Error {
+  constructor(errorData) {
+    const message = errorData.data?.message ?? `ClientResponseError ${errorData.status}`;
+    super(message);
+    this.name = "ClientResponseError";
+    this.url = errorData.url;
+    this.status = errorData.status;
+    this.data = errorData.data;
+    this.isAbort = errorData.status === 0;
+  }
+  toJSON() {
+    return { url: this.url, status: this.status, data: this.data };
+  }
+};
+
+// src/core/client.ts
+var MemoryAuthStore = class {
+  constructor() {
+    this._token = "";
+    this._record = null;
+    this._listeners = /* @__PURE__ */ new Set();
+  }
+  get token() {
+    return this._token;
+  }
+  get record() {
+    return this._record;
+  }
+  get isValid() {
+    if (!this._token) return false;
+    try {
+      const parts = this._token.split(".");
+      if (parts.length !== 3) return false;
+      const payload = JSON.parse(atob(parts[1].replace(/-/g, "+").replace(/_/g, "/")));
+      if (typeof payload.exp === "number") {
+        return payload.exp > Date.now() / 1e3;
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  save(token, record) {
+    this._token = token;
+    this._record = record;
+    this._notify();
+  }
+  clear() {
+    this._token = "";
+    this._record = null;
+    this._notify();
+  }
+  onChange(callback) {
+    this._listeners.add(callback);
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+  _notify() {
+    for (const cb of this._listeners) {
+      try {
+        cb(this._token, this._record);
+      } catch {
+      }
+    }
+  }
+};
+var FileService = class {
+  constructor(baseUrl) {
+    this._baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  /**
+   * Build a full URL to a record file.
+   * Compatible with PocketBase's pb.files.getURL().
+   */
+  getURL(record, filename, options) {
+    if (!filename || !record.id) return "";
+    const collectionId = record.collectionId ?? record.collectionName ?? "";
+    const parts = [
+      this._baseUrl,
+      "api",
+      "files",
+      encodeURIComponent(collectionId),
+      encodeURIComponent(record.id),
+      encodeURIComponent(filename)
+    ];
+    let url = parts.join("/");
+    const params = new URLSearchParams();
+    if (options?.thumb) params.set("thumb", options.thumb);
+    if (options?.token) params.set("token", options.token);
+    const qs = params.toString();
+    if (qs) url += "?" + qs;
+    return url;
+  }
+};
+var BaseClient = class {
+  /**
+   * Create a BaseClient.
+   *
+   * Accepts either a config object or a plain URL string for convenience:
+   *   new BaseClient('https://myapp.hanzo.ai')
+   *   new BaseClient({ url: 'https://myapp.hanzo.ai' })
+   */
+  constructor(configOrUrl) {
+    this._collections = /* @__PURE__ */ new Map();
+    const config = typeof configOrUrl === "string" ? { url: configOrUrl } : configOrUrl;
+    this.url = config.url.replace(/\/$/, "");
+    this.authStore = config.authStore ?? new MemoryAuthStore();
+    this.store = new QueryStore();
+    this.realtime = new RealtimeService(this.url, () => this.authStore.token);
+    this.files = new FileService(this.url);
+    this._versionTracker = new VersionTracker();
+    this.authStore.onChange((token) => {
+      this._versionTracker.setIdentity(
+        token ? VersionTracker.hashIdentity(token) : 0
+      );
+    });
+  }
+  // ---- PocketBase-compatible collection() API -----------------------------
+  /** Get or create a CollectionService for the given name/id. */
+  collection(nameOrId) {
+    let svc = this._collections.get(nameOrId);
+    if (!svc) {
+      svc = new CollectionService(
+        nameOrId,
+        this.url,
+        () => this.authStore.token,
+        (token, record) => this.authStore.save(token, record),
+        this.store,
+        this.realtime
+      );
+      this._collections.set(nameOrId, svc);
+    }
+    return svc;
+  }
+  // ---- State version ------------------------------------------------------
+  /** Current state version from the QueryStore's internal tracker. */
+  get version() {
+    return this.store.version;
+  }
+  // ---- Direct convenience API (kept for backwards compatibility) ----------
+  _headers() {
+    const h = { "Content-Type": "application/json" };
+    if (this.authStore.token) {
+      h["Authorization"] = this.authStore.token;
+    }
+    return h;
+  }
+  async _request(method, path, body) {
+    const res = await fetch(`${this.url}${path}`, {
+      method,
+      headers: this._headers(),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      let detail;
+      try {
+        detail = JSON.parse(text);
+      } catch {
+        detail = text;
+      }
+      throw new BaseClientError(res.status, detail);
+    }
+    if (res.status === 204) return void 0;
+    return res.json();
+  }
+  async list(collection, options) {
+    const params = new URLSearchParams();
+    if (options?.filter) params.set("filter", options.filter);
+    if (options?.sort) params.set("sort", options.sort);
+    if (options?.expand) params.set("expand", options.expand);
+    if (options?.fields) params.set("fields", options.fields);
+    if (options?.page) params.set("page", String(options.page));
+    if (options?.perPage) params.set("perPage", String(options.perPage));
+    const qs = params.toString();
+    const path = `/api/collections/${encodeURIComponent(collection)}/records${qs ? "?" + qs : ""}`;
+    const result = await this._request("GET", path);
+    this.store.setQuery(collection, options?.filter ?? "", result.items);
+    return result;
+  }
+  async getOne(collection, id, options) {
+    const params = new URLSearchParams();
+    if (options?.expand) params.set("expand", options.expand);
+    if (options?.fields) params.set("fields", options.fields);
+    const qs = params.toString();
+    const path = `/api/collections/${encodeURIComponent(collection)}/records/${encodeURIComponent(id)}${qs ? "?" + qs : ""}`;
+    return this._request("GET", path);
+  }
+  async create(collection, data) {
+    const path = `/api/collections/${encodeURIComponent(collection)}/records`;
+    const record = await this._request("POST", path, data);
+    this.store.applyServerUpdate(collection, "create", record);
+    return record;
+  }
+  async update(collection, id, data) {
+    const path = `/api/collections/${encodeURIComponent(collection)}/records/${encodeURIComponent(id)}`;
+    const record = await this._request("PATCH", path, data);
+    this.store.applyServerUpdate(collection, "update", record);
+    return record;
+  }
+  async delete(collection, id) {
+    const path = `/api/collections/${encodeURIComponent(collection)}/records/${encodeURIComponent(id)}`;
+    await this._request("DELETE", path);
+    this.store.applyServerUpdate(collection, "delete", { id });
+  }
+  // ---- Auth (direct convenience) ------------------------------------------
+  async signInWithPassword(collection, identity, password) {
+    const path = `/api/collections/${encodeURIComponent(collection)}/auth-with-password`;
+    const result = await this._request("POST", path, {
+      identity,
+      password
+    });
+    this.authStore.save(result.token, result.record);
+    return result;
+  }
+  async signUp(collection, data) {
+    return this.create(collection, data);
+  }
+  async refreshAuth(collection) {
+    const path = `/api/collections/${encodeURIComponent(collection)}/auth-refresh`;
+    const result = await this._request("POST", path);
+    this.authStore.save(result.token, result.record);
+    return result;
+  }
+  signOut() {
+    this.authStore.clear();
+  }
+  // ---- Raw request --------------------------------------------------------
+  /**
+   * Send a raw request to the Base API.
+   * Convenience for endpoints not covered by CollectionService.
+   */
+  async send(path, options = {}) {
+    const method = options.method ?? "GET";
+    let url = `${this.url}${path}`;
+    if (options.query) {
+      const params = new URLSearchParams(options.query);
+      url += "?" + params.toString();
+    }
+    const headers = { ...options.headers };
+    if (this.authStore.token) {
+      headers["Authorization"] = this.authStore.token;
+    }
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: options.body,
+      signal: options.signal
+    });
+    if (!response.ok) {
+      const data = await response.json().catch(() => ({}));
+      throw new BaseClientError(
+        response.status,
+        data
+      );
+    }
+    if (response.status === 204) return void 0;
+    return response.json();
+  }
+  // ---- Health check -------------------------------------------------------
+  async health() {
+    return this.send("/api/health");
+  }
+  // ---- Realtime convenience -----------------------------------------------
+  /**
+   * Subscribe to realtime events for a collection topic.
+   * Also wires events into the QueryStore automatically.
+   */
+  subscribeAndSync(collection, topic = "*", callback) {
+    return this.realtime.subscribe(collection, topic, (event) => {
+      this.store.applyServerUpdate(collection, event.action, event.record);
+      callback?.(event);
+    });
+  }
+  // ---- Cleanup ------------------------------------------------------------
+  /** Disconnect realtime and clear caches. */
+  disconnect() {
+    this.realtime.disconnect();
+  }
+};
+var BaseClientError = class extends Error {
+  constructor(status, detail) {
+    super(`BaseClient error ${status}`);
+    this.name = "BaseClientError";
+    this.status = status;
+    this.detail = detail;
+  }
+};
+
+export { BaseClient, BaseClientError, ClientResponseError, CollectionService, FileService, MemoryAuthStore, QueryStore, RealtimeService, VersionTracker };
+//# sourceMappingURL=chunk-LBAV5X5P.js.map
+//# sourceMappingURL=chunk-LBAV5X5P.js.map