@idapt/browser-app-sdk 0.1.0

package/dist/react.cjs

@@ -0,0 +1,4167 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/react/context.tsx
+
+// ../sdk/src/errors.ts
+var IdaptError = class extends Error {
+  constructor(init) {
+    super(init.message, init.cause ? { cause: init.cause } : void 0);
+    this.name = "IdaptError";
+    this.code = init.code;
+    this.type = init.type;
+    this.subCode = init.subCode;
+    this.status = init.status ?? 0;
+    this.body = init.body;
+  }
+};
+var NetworkError = class extends IdaptError {
+  constructor(init) {
+    super({ ...init, code: "network_error" });
+    this.name = "NetworkError";
+  }
+};
+var AuthError = class extends IdaptError {
+  constructor(init) {
+    super({ ...init, code: init.code ?? "auth_expired" });
+    this.name = "AuthError";
+  }
+};
+var PermissionError = class extends IdaptError {
+  constructor(init) {
+    super({ ...init, code: "permission_denied" });
+    this.name = "PermissionError";
+  }
+};
+var NotFoundError = class extends IdaptError {
+  constructor(init) {
+    super({ ...init, code: "not_found" });
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends IdaptError {
+  constructor(init) {
+    super({ ...init, code: "conflict" });
+    this.name = "ConflictError";
+  }
+};
+var RateLimitError = class extends IdaptError {
+  constructor(init) {
+    super({ ...init, code: "rate_limited" });
+    this.name = "RateLimitError";
+    this.retryAfter = init.retryAfter;
+  }
+};
+var InvalidRequestError = class extends IdaptError {
+  constructor(init) {
+    super({ ...init, code: "invalid_request" });
+    this.name = "InvalidRequestError";
+  }
+};
+var ServiceUnavailableError = class extends IdaptError {
+  constructor(init) {
+    super({ ...init, code: "service_unavailable" });
+    /** Always `true` — a 503 means "retry later", the request was fine. */
+    this.retryable = true;
+    this.name = "ServiceUnavailableError";
+    this.retryAfter = init.retryAfter;
+  }
+};
+var ServerError = class extends IdaptError {
+  constructor(init) {
+    super({ ...init, code: "server_error" });
+    this.name = "ServerError";
+  }
+};
+function errorFromStatus(status, message, body) {
+  const { type, subCode } = extractErrorFields(body);
+  const base = { message, status, body, type, subCode };
+  if (status === 401) return new AuthError(base);
+  if (status === 403) return new PermissionError(base);
+  if (status === 404) return new NotFoundError(base);
+  if (status === 409) return new ConflictError(base);
+  if (status === 422) {
+    return new InvalidRequestError(base);
+  }
+  if (status === 429) {
+    const retryAfter = extractRetryAfter(body);
+    return new RateLimitError({ ...base, retryAfter });
+  }
+  if (status === 503) {
+    const retryAfter = extractRetryAfter(body);
+    return new ServiceUnavailableError({ ...base, retryAfter });
+  }
+  if (status >= 500) return new ServerError(base);
+  return new IdaptError({ ...base, code: "unknown" });
+}
+function extractErrorFields(body) {
+  if (!body || typeof body !== "object" || !("error" in body)) return {};
+  const err = body.error;
+  if (!err || typeof err !== "object") return {};
+  const out = {};
+  const t = err.type;
+  if (typeof t === "string") out.type = t;
+  const c = err.code;
+  if (typeof c === "string") out.subCode = c;
+  return out;
+}
+function extractRetryAfter(body) {
+  if (body && typeof body === "object" && "retry_after" in body) {
+    const v = body.retry_after;
+    if (typeof v === "number") return v;
+  }
+  return void 0;
+}
+
+// ../sdk/src/http.ts
+async function request(ctx, req) {
+  const res = await send(ctx, req);
+  return handleResponse(res, {
+    expectJson: req.expectJson !== false,
+    expectBlob: req.expectBlob === true
+  });
+}
+async function requestRaw(ctx, req) {
+  const res = await send(ctx, req);
+  if (!res.ok) {
+    await handleResponse(res, {
+      expectJson: req.expectJson !== false,
+      expectBlob: false
+    });
+  }
+  return res;
+}
+async function send(ctx, req) {
+  const doFetch = ctx.fetch ?? globalThis.fetch;
+  if (!doFetch) {
+    throw new NetworkError({
+      message: "No fetch implementation available"
+    });
+  }
+  const url = buildUrl(ctx.apiUrl, req.path, req.query);
+  const callerSetsAuth = hasAuthorizationHeader(req.headers);
+  const mintedBearer = !!ctx.getToken && !callerSetsAuth;
+  const cookieMode = !mintedBearer && ctx.auth === "cookie";
+  const body = buildBody(req);
+  const doSend = async (authHeader) => {
+    const headers = {
+      ...authHeader ? { Authorization: authHeader } : {},
+      // Context defaults (e.g. User-Agent), then per-request overrides win.
+      ...ctx.headers ?? {},
+      ...req.headers ?? {}
+    };
+    if (body.contentType) headers["Content-Type"] ?? (headers["Content-Type"] = body.contentType);
+    try {
+      return await doFetch(url, {
+        method: req.method,
+        headers,
+        body: body.value,
+        signal: req.signal,
+        // Send the httpOnly app-key cookie ONLY in cookie mode (same-origin on
+        // the app subdomain). Bearer / minted-bearer omit it to avoid leaking
+        // ambient cookies — the minted JWT is the sole credential there.
+        ...cookieMode ? { credentials: "include" } : {}
+      });
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") throw err;
+      throw new NetworkError({
+        message: err instanceof Error ? err.message : "Network failure",
+        cause: err
+      });
+    }
+  };
+  if (mintedBearer && ctx.getToken) {
+    let res = await doSend(`Bearer ${await ctx.getToken()}`);
+    if (res.status === 401 && ctx.onUnauthorized) {
+      ctx.onUnauthorized();
+      res = await doSend(`Bearer ${await ctx.getToken()}`);
+    }
+    return res;
+  }
+  return doSend(cookieMode ? null : `Bearer ${ctx.key}`);
+}
+function hasAuthorizationHeader(headers) {
+  if (!headers) return false;
+  return Object.keys(headers).some((k) => k.toLowerCase() === "authorization");
+}
+function buildBody(req) {
+  if (req.bodyRaw !== void 0) return { value: req.bodyRaw };
+  if (req.body !== void 0) {
+    return {
+      value: JSON.stringify(req.body),
+      contentType: "application/json"
+    };
+  }
+  return { value: void 0 };
+}
+async function handleResponse(res, mode) {
+  const ct = res.headers.get("content-type") ?? "";
+  const isJson = ct.includes("application/json");
+  if (!res.ok) {
+    let parsed;
+    let message = `API error: ${res.status}`;
+    try {
+      if (isJson) {
+        parsed = await res.json();
+        if (parsed && typeof parsed === "object" && "error" in parsed && parsed.error && typeof parsed.error === "object" && "message" in parsed.error && typeof parsed.error.message === "string") {
+          message = parsed.error.message;
+        }
+      } else {
+        parsed = await res.text();
+      }
+    } catch {
+    }
+    throw errorFromStatus(res.status, message, parsed);
+  }
+  if (res.status === 204) {
+    return void 0;
+  }
+  try {
+    if (mode.expectBlob) return await res.blob();
+    if (mode.expectJson && isJson) return await res.json();
+    return await res.text();
+  } catch (err) {
+    throw new IdaptError({
+      code: "server_error",
+      message: "Invalid response body",
+      status: res.status,
+      cause: err
+    });
+  }
+}
+function buildUrl(apiUrl, path, query) {
+  const base = apiUrl.replace(/\/+$/, "");
+  const cleanPath = path.startsWith("/") ? path : `/${path}`;
+  const qs = buildQuery(query);
+  return base + cleanPath + qs;
+}
+function buildQuery(query) {
+  if (!query) return "";
+  const entries = [];
+  for (const [k, v] of Object.entries(query)) {
+    if (v === null || v === void 0) continue;
+    if (typeof v !== "string" && typeof v !== "number" && typeof v !== "boolean") {
+      continue;
+    }
+    entries.push([k, String(v)]);
+  }
+  if (entries.length === 0) return "";
+  const sp = new URLSearchParams(entries);
+  return `?${sp.toString()}`;
+}
+
+// ../sdk/src/api/_files-core.ts
+async function listFiles(ctx, query = {}, opts = {}) {
+  const res = await request(ctx, {
+    method: "GET",
+    path: "/api/v1/drive/files",
+    query,
+    signal: opts.signal
+  });
+  return res.data ?? [];
+}
+async function getFileText(ctx, id, opts = {}) {
+  return request(ctx, {
+    method: "GET",
+    path: `/api/v1/drive/files/${id}`,
+    signal: opts.signal,
+    expectJson: false
+  });
+}
+async function getFileBlob(ctx, id, opts = {}) {
+  return request(ctx, {
+    method: "GET",
+    path: `/api/v1/drive/files/${id}`,
+    signal: opts.signal,
+    expectBlob: true
+  });
+}
+async function uploadFile(ctx, input, opts = {}) {
+  const form = new FormData();
+  const filename = input.name ?? (input.file instanceof globalThis.File ? input.file.name : "upload");
+  form.set("file", input.file, filename);
+  if (input.name) form.set("name", input.name);
+  if (input.parent_id) form.set("parent_id", input.parent_id);
+  if (input.workspace_id) form.set("workspace_id", input.workspace_id);
+  if (input.skip_if_exists) form.set("skip_if_exists", "true");
+  const res = await request(ctx, {
+    method: "POST",
+    path: "/api/v1/drive/files",
+    bodyRaw: form,
+    signal: opts.signal
+  });
+  return res.data;
+}
+async function patchFile(ctx, id, input, opts = {}) {
+  const body = { ...input };
+  if (opts.expectedUpdatedAt) body.expected_updated_at = opts.expectedUpdatedAt;
+  const res = await request(ctx, {
+    method: "PATCH",
+    path: `/api/v1/drive/files/${id}`,
+    body,
+    signal: opts.signal
+  });
+  return res.data;
+}
+async function deleteFile(ctx, id, opts = {}) {
+  return request(ctx, {
+    method: "DELETE",
+    path: `/api/v1/drive/files/${id}`,
+    signal: opts.signal
+  });
+}
+async function restoreFile(ctx, id, opts = {}) {
+  const res = await request(ctx, {
+    method: "POST",
+    path: `/api/v1/drive/files/${id}/restore`,
+    signal: opts.signal
+  });
+  return res.data;
+}
+async function permanentDeleteFile(ctx, id, opts = {}) {
+  return request(ctx, {
+    method: "DELETE",
+    path: `/api/v1/drive/files/${id}/permanent-delete`,
+    signal: opts.signal
+  });
+}
+async function createFolder(ctx, input, opts = {}) {
+  const res = await request(ctx, {
+    method: "POST",
+    path: "/api/v1/drive/files/folders",
+    body: input,
+    signal: opts.signal
+  });
+  return res.data;
+}
+async function moveFile(ctx, id, parentId, opts = {}) {
+  const res = await request(ctx, {
+    method: "POST",
+    path: `/api/v1/drive/files/${id}/move`,
+    body: { parent_id: parentId },
+    signal: opts.signal
+  });
+  return res.data;
+}
+async function runFile(ctx, id, input = {}, opts = {}) {
+  const res = await request(ctx, {
+    method: "POST",
+    path: `/api/v1/drive/files/${id}/run`,
+    body: input,
+    signal: opts.signal
+  });
+  return res.data;
+}
+
+// ../sdk/src/api/agents.ts
+var AgentsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async list(query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/agents",
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async create(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/agents",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async get(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/agents/${id}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async update(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/agents/${id}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async delete(id, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/agents/${id}`,
+      signal: opts.signal
+    });
+  }
+  async archive(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/agents/${id}/archive`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async unarchive(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/agents/${id}/unarchive`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async restore(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/agents/${id}/restore`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async permanentDelete(id, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/agents/${id}/permanent-delete`,
+      signal: opts.signal
+    });
+  }
+  async move(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/agents/${id}/move`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async copyToWorkspace(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/agents/${id}/copy-to-workspace`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/api-keys.ts
+var ApiKeysApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async list(query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/api-keys",
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Mint a new API key. The returned object includes a one-shot `key` field
+   * with the plaintext — store it immediately, there is no way to retrieve
+   * it later.
+   */
+  async create(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/api-keys",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async update(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/api-keys/${id}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Revoke (delete) a key. Subsequent calls with that key 401. */
+  async delete(id, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/api-keys/${id}`,
+      signal: opts.signal
+    });
+  }
+  /**
+   * Rotate a key and return the replacement plaintext once. API-key
+   * management remains first-party session-only on the server, so calls made
+   * with a raw `uk_` bearer key receive 403.
+   */
+  async rotate(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/api-keys/${id}/rotate`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/audio.ts
+var AudioApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /** Text-to-speech. Responds HTTP 201 with the written file ref under `data`. */
+  async speak(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/audio/speech",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async transcribe(input, opts = {}) {
+    const form = new FormData();
+    const filename = input.filename ?? (input.file instanceof File ? input.file.name : "audio");
+    form.set("file", input.file, filename);
+    if (input.model) form.set("model", input.model);
+    if (input.language) form.set("language", input.language);
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/audio/transcriptions",
+      bodyRaw: form,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async *streamSpeech(input, opts = {}) {
+    const res = await requestRaw(this.ctx, {
+      method: "POST",
+      path: "/api/v1/audio/speech/stream",
+      body: input,
+      signal: opts.signal,
+      expectJson: false
+    });
+    yield* parseSpeechStream(res, opts.signal);
+  }
+  async *streamTranscribe(input, opts = {}) {
+    const form = new FormData();
+    const filename = input.filename ?? (input.file instanceof File ? input.file.name : "audio");
+    form.set("file", input.file, filename);
+    if (input.model) form.set("model", input.model);
+    if (input.language) form.set("language", input.language);
+    const res = await requestRaw(this.ctx, {
+      method: "POST",
+      path: "/api/v1/audio/transcriptions/stream",
+      bodyRaw: form,
+      signal: opts.signal,
+      expectJson: false
+    });
+    yield* parseTranscriptionStream(res, opts.signal);
+  }
+};
+async function* parseSpeechStream(response, signal) {
+  for await (const frame of parseSse(response, signal)) {
+    const payload = safeJson(frame.data);
+    if (frame.event === "chunk") {
+      const audio = payload?.audio;
+      if (typeof audio === "string") yield { type: "chunk", audio };
+    } else if (frame.event === "done") {
+      const event = { type: "done" };
+      const totalBytes = numberOrUndefined(payload?.totalBytes);
+      const durationMs = numberOrUndefined(payload?.durationMs);
+      const charCount = numberOrUndefined(payload?.charCount);
+      if (totalBytes !== void 0) event.total_bytes = totalBytes;
+      if (durationMs !== void 0) event.duration_ms = durationMs;
+      if (charCount !== void 0) event.char_count = charCount;
+      if (typeof payload?.cached === "boolean") event.cached = payload.cached;
+      yield event;
+    } else if (frame.event === "error") {
+      yield errorEvent(payload);
+    }
+  }
+}
+async function* parseTranscriptionStream(response, signal) {
+  for await (const frame of parseSse(response, signal)) {
+    const payload = safeJson(frame.data);
+    if (frame.event === "partial") {
+      const text = payload?.text;
+      if (typeof text === "string") yield { type: "partial", text };
+    } else if (frame.event === "final") {
+      const text = payload?.text;
+      if (typeof text === "string") yield { type: "final", text };
+    } else if (frame.event === "error") {
+      yield errorEvent(payload);
+    }
+  }
+}
+async function* parseSse(response, signal) {
+  if (!response.body) return;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) return;
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
+      while (true) {
+        const boundary = buffer.indexOf("\n\n");
+        if (boundary === -1) break;
+        const block = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const parsed = parseSseBlock(block);
+        if (parsed) yield parsed;
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function parseSseBlock(block) {
+  let event = "message";
+  let data = "";
+  for (const line of block.split("\n")) {
+    if (!line) continue;
+    if (line.startsWith("event: ")) event = line.slice(7).trim();
+    else if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data: ")) data += line.slice(6);
+    else if (line.startsWith("data:")) data += line.slice(5);
+  }
+  if (!data && event === "message") return null;
+  return { event, data };
+}
+function safeJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function numberOrUndefined(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function errorEvent(payload) {
+  const event = {
+    type: "error"
+  };
+  const status = numberOrUndefined(payload?.status);
+  const retryAfter = numberOrUndefined(payload?.retryAfter);
+  if (status !== void 0) event.status = status;
+  if (retryAfter !== void 0) event.retry_after = retryAfter;
+  return event;
+}
+
+// ../sdk/src/api/blobs.ts
+var enc = encodeURIComponent;
+var BlobsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /** List objects in a namespace (prefix-filterable). */
+  async list(namespace, opts = {}) {
+    const q = new URLSearchParams();
+    if (opts.prefix) q.set("prefix", opts.prefix);
+    if (opts.cursor) q.set("cursor", opts.cursor);
+    if (opts.limit) q.set("limit", String(opts.limit));
+    const qs = q.toString() ? `?${q.toString()}` : "";
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/blobs/${enc(namespace)}${qs}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Upload (upsert) an object's bytes. Returns its metadata.
+   *
+   * Sent as `multipart/form-data` (the bytes ride a `file` part, with an
+   * optional `content_type` field) — the same upload convention as
+   * `client.files.upload`, so it flows through the one multipart transport and
+   * is reachable identically via `client.call("blobs put", …)`. The SDK leaves
+   * `Content-Type` unset so the runtime picks the multipart boundary.
+   */
+  async put(namespace, key, content, contentType, opts = {}) {
+    const ct = contentType ?? (content instanceof Blob && content.type ? content.type : "application/octet-stream");
+    const blob = content instanceof Blob ? content : new Blob([content], { type: ct });
+    const form = new FormData();
+    form.set("file", blob, key);
+    form.set("content_type", ct);
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/blobs/${enc(namespace)}/${enc(key)}`,
+      // No explicit Content-Type — the runtime sets the multipart boundary.
+      bodyRaw: form,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Download an object's raw bytes (preserving its stored Content-Type).
+   *
+   * `GET /blobs/:ns/:key` returns JSON metadata + a signed URL by default (the
+   * agent/CLI form); `?download=true` is the raw-bytes escape hatch this facade
+   * uses. For the JSON reference instead, call `client.call("blobs get", …)`.
+   */
+  async get(namespace, key, opts = {}) {
+    const res = await requestRaw(this.ctx, {
+      method: "GET",
+      path: `/api/v1/blobs/${enc(namespace)}/${enc(key)}?download=true`,
+      signal: opts.signal,
+      expectJson: false
+    });
+    const blob = await res.blob();
+    return {
+      blob,
+      contentType: res.headers.get("content-type") ?? "application/octet-stream"
+    };
+  }
+  /** Read an object's metadata (no bytes). */
+  async head(namespace, key, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/blobs/${enc(namespace)}/${enc(key)}/meta`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Delete an object (idempotent). */
+  async delete(namespace, key, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/blobs/${enc(namespace)}/${enc(key)}`,
+      signal: opts.signal
+    });
+  }
+  /** Mint a time-limited direct-download URL for an object. */
+  async createSignedUrl(namespace, key, expiresIn, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/blobs/${enc(namespace)}/${enc(key)}/signed-url`,
+      body: { expires_in: expiresIn },
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** List the blob namespaces in the workspace. */
+  async listNamespaces(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/blobs",
+      signal: opts.signal
+    });
+    return res.data.map((n) => n.namespace);
+  }
+};
+function bindPath(binding, args) {
+  let path = binding.path;
+  const rest = { ...args };
+  for (const param of binding.pathParams) {
+    const value = rest[param];
+    if (value === void 0 || value === null || value === "") {
+      throw new IdaptError({
+        code: "invalid_request",
+        message: `missing required path argument \`${param}\` for \`${binding.command}\``
+      });
+    }
+    delete rest[param];
+    path = path.replace(`:${param}`, encodeURIComponent(String(value)));
+  }
+  return { path: `/api/v1${path}`, rest };
+}
+function buildMultipart(rest) {
+  const form = new FormData();
+  for (const [k, v] of Object.entries(rest)) {
+    if (v === void 0 || v === null) continue;
+    if (v instanceof Blob) {
+      const filename = v instanceof File ? v.name : k === "files" ? "files" : "file";
+      form.set(k, v, filename);
+    } else if (Array.isArray(v) && v.every((x) => x instanceof Blob)) {
+      for (const part of v) {
+        const filename = part instanceof File ? part.name : k;
+        form.append(k, part, filename);
+      }
+    } else if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+      form.set(k, String(v));
+    } else {
+      form.set(k, JSON.stringify(v));
+    }
+  }
+  return form;
+}
+function buildRequest(binding, path, rest, signal) {
+  const base = { method: binding.method, path, signal };
+  switch (binding.argLocation) {
+    case "query":
+      return { ...base, query: rest };
+    case "body":
+      return { ...base, body: rest };
+    case "multipart":
+      return { ...base, bodyRaw: buildMultipart(rest) };
+    default:
+      return base;
+  }
+}
+async function* parseSse2(response, signal) {
+  if (!response.body) return;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) return;
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
+      while (true) {
+        const boundary = buffer.indexOf("\n\n");
+        if (boundary === -1) break;
+        const block = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const frame = parseSseBlock2(block);
+        if (frame) yield frame;
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function parseSseBlock2(block) {
+  let event = "message";
+  let data = "";
+  for (const line of block.split("\n")) {
+    if (!line) continue;
+    if (line.startsWith("event: ")) event = line.slice(7).trim();
+    else if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data: ")) data += line.slice(6);
+    else if (line.startsWith("data:")) data += line.slice(5);
+  }
+  if (!data && event === "message") return null;
+  return { event, data };
+}
+function isSseBinding(binding) {
+  return !!binding.binaryContentTypes?.some(
+    (t) => t.toLowerCase().includes("text/event-stream")
+  );
+}
+async function executeCommand(binding, args = {}, ctx, opts = {}) {
+  const { path, rest } = bindPath(binding, args);
+  const req = buildRequest(binding, path, rest, opts.signal);
+  {
+    if (isSseBinding(binding) && !opts.bufferBinary) {
+      const res = await requestRaw(ctx, { ...req, expectJson: false });
+      return parseSse2(res, opts.signal);
+    }
+    return await request(ctx, { ...req, expectBlob: true });
+  }
+}
+
+// ../sdk/src/generated/command-bindings.generated.ts
+var COMMAND_BINDINGS = {
+  "chat stream": {
+    "command": "chat stream",
+    "method": "POST",
+    "path": "/chats/:id/messages/stream",
+    "pathParams": [
+      "id"
+    ],
+    "argLocation": "body",
+    "binaryContentTypes": [
+      "text/event-stream"
+    ]
+  }};
+
+// ../sdk/src/api/chats.ts
+var ChatsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  // ---------------------------------------------------------------------------
+  //  CRUD
+  // ---------------------------------------------------------------------------
+  async list(query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/chats",
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async create(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/chats",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async get(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/chats/${id}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async update(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/chats/${id}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async delete(id, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/chats/${id}`,
+      signal: opts.signal
+    });
+  }
+  async archive(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/chats/${id}/archive`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async unarchive(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/chats/${id}/unarchive`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async restore(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/chats/${id}/restore`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async permanentDelete(id, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/chats/${id}/permanent-delete`,
+      signal: opts.signal
+    });
+  }
+  // ---------------------------------------------------------------------------
+  //  Sub-resources
+  // ---------------------------------------------------------------------------
+  /** `GET /chats/:id/cost` — token usage + spend snapshot. */
+  async cost(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/chats/${id}/cost`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** `GET /chats/:id/message-costs` - per-message and per-run cost details. */
+  async messageCosts(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/chats/${id}/message-costs`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** `POST /chats/:id/stop` - request cancellation of the active run. */
+  async stop(id, input = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/chats/${id}/stop`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** `GET /chats/:id/export` - stream a transcript as a Blob. */
+  async export(id, query = {}, opts = {}) {
+    return request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/chats/${id}/export`,
+      query,
+      expectBlob: true,
+      signal: opts.signal
+    });
+  }
+  async copyToAgent(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/chats/${id}/copy-to-agent`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async copyToWorkspace(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/chats/${id}/copy-to-workspace`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async forkToWorkspace(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/chats/${id}/fork-to-workspace`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** `GET /chats/:id/messages` — paginated history. */
+  async listMessages(id, query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/chats/${id}/messages`,
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * `POST /chats/:id/messages` — send a user message + (optionally) wait
+   * for the assistant reply synchronously. Responds HTTP 201 with a
+   * `oneOf`: a completed `{status, chat_id, model_id, user_message_id,
+   * message}` or a pending `{status, pending_token, chat_id}`. The pending
+   * handle is `pending_token` — an opaque workflow handle, NOT a
+   * resourceId. See `SendMessageResult`.
+   */
+  async sendMessage(id, input, opts = {}) {
+    return request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/chats/${id}/messages`,
+      body: input,
+      signal: opts.signal
+    });
+  }
+  /**
+   * `POST /chats/:id/messages/stream` — send a user message and stream the
+   * assistant reply token-by-token as Server-Sent Events. The real-time twin
+   * of {@link sendMessage}: same body, but instead of one finished JSON reply
+   * you get an `AsyncIterable` of raw SSE frames as the model generates.
+   *
+   * Each yielded `{ event, data }` has `data` as a JSON string — parse it per
+   * the frame's `event`:
+   *   - `token`   → `{ chat_id, message_id, text, reasoning? }` (`text` is the
+   *                 FULL accumulated snapshot — render by REPLACING, not
+   *                 appending)
+   *   - `message` → `{ chat_id, message_id, role }` (assistant row finalized)
+   *   - `done`    → `{ chat_id, message_id, status }` (terminal; loop ends)
+   *   - `heartbeat` → keep-alive ping, ignore.
+   *
+   *   for await (const frame of client.chats.stream(chatId, { content })) {
+   *     if (frame.event === "token") {
+   *       const { text } = JSON.parse(frame.data);
+   *       render(text);
+   *     }
+   *   }
+   *
+   * Delegates to the generic spec-driven executor, which turns the
+   * `text/event-stream` binary binding into the async iterable. Equivalent to
+   * `client.call("chat stream", input)`.
+   */
+  stream(id, input, opts = {}) {
+    return executeCommand(
+      COMMAND_BINDINGS["chat stream"],
+      { id, ...input },
+      this.ctx,
+      opts
+    );
+  }
+  /** `GET /chats/:id/runs` — model execution runs tied to this chat. */
+  async listRuns(id, query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/chats/${id}/runs`,
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * `POST /chats/:id/messages/:message_id/reprompt` — regenerate the
+   * assistant response to an existing user message. The original AI reply
+   * is preserved; a sibling assistant message is created so branching
+   * stays intact.
+   *
+   *   Before:  [User A] → [AI B]
+   *   After:   [User A] ─┬─ [AI B]
+   *                      └─ [AI C]   ← C.prevMessageId = A
+   *
+   * With `wait=true` (default) the server blocks until the new sibling is
+   * available; with `wait=false` returns `{ status: "pending", ... }` and
+   * the new message can be polled via `listMessages`.
+   */
+  async repromptMessage(chatId, messageId, input = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/chats/${chatId}/messages/${messageId}/reprompt`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/code.ts
+var CodeRunsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Execute a code file. Returns the full `ExecutionRun` row — `id`,
+   * `status`, `stdout`, `stderr`, `exit_code`, and the run timestamps —
+   * the same shape as `GET /code-runs/:id`.
+   */
+  async run(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/code-runs",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** List recent execution runs. */
+  async list(query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/code-runs",
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Get a single execution run by id. */
+  async get(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/code-runs/${id}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/computers.ts
+var ComputersApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  // ---------------------------------------------------------------------------
+  //  CRUD
+  // ---------------------------------------------------------------------------
+  async list(query, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/computers",
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async create(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/computers/pair-tokens",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async get(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/computers/${id}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async update(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/computers/${id}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async delete(id, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/computers/${id}`,
+      signal: opts.signal
+    });
+  }
+  // ---------------------------------------------------------------------------
+  //  Lifecycle
+  // ---------------------------------------------------------------------------
+  async archive(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/computers/${id}/archive`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async unarchive(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/computers/${id}/unarchive`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Wake a hibernated cloud computer. Errors with 409 from non-hibernated states. */
+  async start(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/computers/${id}/start`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Stop a running cloud computer; preserves provider-local disk state. */
+  async stop(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/computers/${id}/stop`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Hibernate a running cloud computer; deallocates compute, snapshots state. */
+  async hibernate(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/computers/${id}/hibernate`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Daemon connectivity probe; returns a success flag + duration.
+   * Rate-limited per computer. `serverInfo` is a structured
+   * `{version, uptime_seconds}` object (was a free-form blob).
+   */
+  async testConnection(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/computers/${id}/test-connection`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  // ---------------------------------------------------------------------------
+  //  Exec & tmux
+  // ---------------------------------------------------------------------------
+  async exec(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/computers/${id}/exec`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * tmux dispatcher. Each `op` returns a different shape — see the route
+   * docs for the per-op payload. Common case: `op: "run"` starts a window,
+   * `op: "capture"` reads its output.
+   */
+  async tmux(id, input, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/computers/${id}/tmux`,
+        body: input,
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  /** Convenience over `tmux({ op: "list" })`. */
+  async listTmuxWindows(id, opts = {}) {
+    const result = await this.tmux(id, { op: "list" }, opts);
+    return result.windows ?? [];
+  }
+  // ---------------------------------------------------------------------------
+  //  SFTP
+  // ---------------------------------------------------------------------------
+  /**
+   * Unified SFTP dispatcher. Returns op-shaped payload. For streaming
+   * uploads/downloads use `sftpUpload` / `sftpDownload`.
+   */
+  async sftp(id, input, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/computers/${id}/sftp`,
+        body: input,
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  /** Convenience: `sftp({op:"list"})` returning the entries array directly. */
+  async sftpList(id, path, opts = {}) {
+    const result = await this.sftp(id, { op: "list", path }, opts);
+    return result;
+  }
+  /**
+   * Multipart upload of a file/folder member. Falls back to single-file mode
+   * when `relative_path` is omitted.
+   */
+  async sftpUpload(id, input, opts = {}) {
+    const form = new FormData();
+    form.append("file", input.file);
+    form.append("path", input.path);
+    if (input.relative_path) form.append("relative_path", input.relative_path);
+    if (input.conflict_mode) form.append("conflict_mode", input.conflict_mode);
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/computers/${id}/sftp/upload`,
+        bodyRaw: form,
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  /**
+   * Stream a remote file (or a folder as `tar.gz`) as a `Blob`. The server
+   * sends the real MIME type on `Content-Type`.
+   */
+  async sftpDownload(id, remotePath, opts = {}) {
+    return request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/computers/${id}/sftp/download`,
+      query: { path: remotePath },
+      expectBlob: true,
+      signal: opts.signal
+    });
+  }
+  // ---------------------------------------------------------------------------
+  //  Ports (managed only)
+  // ---------------------------------------------------------------------------
+  async listPorts(id, query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/computers/${id}/ports`,
+      query: query.refresh ? { refresh: "true" } : void 0,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async updatePort(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/computers/${id}/ports`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  // ---------------------------------------------------------------------------
+  //  Unix users
+  // ---------------------------------------------------------------------------
+  /**
+   * List the computer's Unix users. The v1 contract returns a list envelope
+   * — `data` is the user array, with `current_user`, `has_root_access` and
+   * `has_sudo_access` as sibling top-level keys. This convenience method
+   * returns just the array; use `listUsersWithMeta` for the access flags.
+   */
+  async listUsers(id, opts = {}) {
+    return (await this.listUsersWithMeta(id, opts)).data;
+  }
+  /**
+   * Like `listUsers` but returns the full v1 list envelope, including the
+   * `current_user` daemon user and the `has_root_access` / `has_sudo_access`
+   * capability flags.
+   */
+  async listUsersWithMeta(id, opts = {}) {
+    return request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/computers/${id}/users`,
+      signal: opts.signal
+    });
+  }
+  /** Fetch one Unix user by username (`GET /v1/computers/{id}/users/{username}`). */
+  async getUser(id, username, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/computers/${id}/users/${username}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Create a Unix user. The user fields are returned directly under `data`.
+   * Responds 201 on creation, 200 when the user already existed.
+   */
+  async createUser(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/computers/${id}/users`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Update a Unix user. The user fields are returned directly under `data`. */
+  async updateUser(id, username, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/computers/${id}/users/${username}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async deleteUser(id, username, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/computers/${id}/users/${username}`,
+      signal: opts.signal
+    });
+  }
+  // ---------------------------------------------------------------------------
+  //  User env vars
+  // ---------------------------------------------------------------------------
+  async listUserEnvVars(id, username, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/computers/${id}/users/${username}/env`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async createUserEnvVar(id, username, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/computers/${id}/users/${username}/env`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Remove an env-var binding from a user. A binding is addressed by its
+   * env-var `name` (the route segment is `{name}`, not a UUID).
+   */
+  async deleteUserEnvVar(id, username, name, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/computers/${id}/users/${username}/env/${name}`,
+      signal: opts.signal
+    });
+  }
+  /** Bootstrap `~/.idapt-env` + `.bashrc` sourcing on a user. Idempotent. */
+  async setupUserEnv(id, username, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/computers/${id}/users/${username}/env/setup`,
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  async checkUserEnvSetup(id, username, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "GET",
+        path: `/api/v1/computers/${id}/users/${username}/env/setup`,
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  /** Rewrite the computer's `~/.idapt-env` from the DB-recorded bindings. */
+  async syncUserEnv(id, username, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/computers/${id}/users/${username}/env/sync`,
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  async checkUserEnvSync(id, username, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "GET",
+        path: `/api/v1/computers/${id}/users/${username}/env/sync`,
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  // ---------------------------------------------------------------------------
+  //  Workspace links (share LOCAL INFERENCE into other workspaces)
+  // ---------------------------------------------------------------------------
+  /**
+   * List the workspaces a computer's LOCAL INFERENCE is shared into. The home
+   * workspace is never listed (it already has full access). The route returns
+   * the links under a `links` key (not a standard list envelope).
+   */
+  async listWorkspaceLinks(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/computers/${id}/workspace-links`,
+      signal: opts.signal
+    });
+    return res.data.links;
+  }
+  /**
+   * Share a computer's LOCAL INFERENCE into another workspace (never shell /
+   * files / tunnels). `workspaceId` is the target workspace's `ws_…`
+   * resourceId or slug. Requires EDIT on the computer's home workspace and
+   * membership of the target. Rejects the home workspace and duplicates.
+   */
+  async linkWorkspace(id, workspaceId, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/computers/${id}/workspace-links`,
+        body: { workspace_id: workspaceId },
+        signal: opts.signal
+      }
+    );
+    return res.data.link;
+  }
+  /**
+   * Stop sharing a computer's local inference into a workspace. `workspaceId`
+   * is the target workspace's `ws_…` resourceId. Idempotent — unlinking a
+   * non-existent link still succeeds.
+   */
+  async unlinkWorkspace(id, workspaceId, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/computers/${id}/workspace-links/${workspaceId}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  // ---------------------------------------------------------------------------
+  //  Pair-token redemption (daemon bootstrap)
+  // ---------------------------------------------------------------------------
+  /**
+   * Redeem a one-time pair token for a long-lived computer identity. The
+   * token itself is the auth — we swap the bearer for the token on this
+   * call only (same pattern as `triggers.fire`).
+   *
+   * Used by `idapt up --token` to bootstrap a daemon. The request body is
+   * snake_case; the response is wrapped in the standard `{data:{…}}`
+   * envelope. `computer_id` is a resourceId.
+   */
+  async pair(input, opts = {}) {
+    const localCtx = {
+      apiUrl: this.ctx.apiUrl,
+      key: input.token,
+      fetch: this.ctx.fetch
+    };
+    const res = await request(localCtx, {
+      method: "POST",
+      path: "/api/v1/computers/pair",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/datastore.ts
+var enc2 = encodeURIComponent;
+var DatastoreApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /** List keys in a namespace (prefix-filterable). */
+  async list(namespace, opts = {}) {
+    const q = new URLSearchParams();
+    if (opts.prefix) q.set("prefix", opts.prefix);
+    if (opts.cursor) q.set("cursor", opts.cursor);
+    if (opts.limit) q.set("limit", String(opts.limit));
+    const qs = q.toString() ? `?${q.toString()}` : "";
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/datastore/${enc2(namespace)}${qs}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Read a KV entry. */
+  async get(namespace, key, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/datastore/${enc2(namespace)}/${enc2(key)}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Upsert a KV entry (optionally with a TTL). */
+  async set(namespace, key, value, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/datastore/${enc2(namespace)}/${enc2(key)}`,
+      body: { value, ttl_seconds: opts.ttlSeconds },
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Delete a KV entry (idempotent). */
+  async delete(namespace, key, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/datastore/${enc2(namespace)}/${enc2(key)}`,
+      signal: opts.signal
+    });
+  }
+  /** Atomically add `by` (default 1) to a numeric counter. */
+  async increment(namespace, key, by = 1, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/datastore/${enc2(namespace)}/${enc2(key)}/increment`,
+        body: { by },
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  /** List the namespaces in the workspace. */
+  async listNamespaces(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/datastore",
+      signal: opts.signal
+    });
+    return res.data.map((n) => n.namespace);
+  }
+  /** Read several keys at once. */
+  async batchGet(namespace, keys, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/datastore/${enc2(namespace)}`,
+        body: { op: "get", keys },
+        signal: opts.signal
+      }
+    );
+    return res.data.entries ?? [];
+  }
+  /** Upsert several entries at once. */
+  async batchSet(namespace, entries, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/datastore/${enc2(namespace)}`,
+      body: {
+        op: "set",
+        entries: entries.map((e) => ({
+          key: e.key,
+          value: e.value,
+          ttl_seconds: e.ttlSeconds
+        }))
+      },
+      signal: opts.signal
+    });
+    return res.data.count ?? 0;
+  }
+  /** Delete several keys at once; returns the count removed. */
+  async batchDelete(namespace, keys, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/datastore/${enc2(namespace)}`,
+      body: { op: "delete", keys },
+      signal: opts.signal
+    });
+    return res.data.count ?? 0;
+  }
+};
+
+// ../sdk/src/api/docs.ts
+var DocsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Fetch the OpenAPI spec as a plain object. Shape is `OpenAPI.Document`
+   * from the standard spec — typed as `Record<string, unknown>` here so
+   * consumers can narrow as needed without pulling in an openapi-types
+   * dependency.
+   */
+  async get(opts = {}) {
+    return request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/docs",
+      signal: opts.signal
+    });
+  }
+};
+
+// ../sdk/src/api/files.ts
+var FilesApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  // ---------------------------------------------------------------------------
+  //  CRUD
+  // ---------------------------------------------------------------------------
+  list(query = {}, opts = {}) {
+    return listFiles(this.ctx, query, opts);
+  }
+  /** Multipart upload a Blob/File. Returns the partial file record. */
+  upload(input, opts = {}) {
+    return uploadFile(this.ctx, input, opts);
+  }
+  /**
+   * Fetch a file's raw text content. Use for text-like files (source code,
+   * Markdown, JSON strings). For binary content (images, PDFs, zips) use
+   * `getBlob()` instead — `getText()` will UTF-8 decode and corrupt bytes.
+   */
+  getText(id, opts = {}) {
+    return getFileText(this.ctx, id, opts);
+  }
+  /**
+   * Fetch a file's raw bytes as a Blob. The server sends the real MIME
+   * type on `Content-Type`; the returned Blob's `.type` reflects it.
+   */
+  getBlob(id, opts = {}) {
+    return getFileBlob(this.ctx, id, opts);
+  }
+  /**
+   * Patch file metadata or content. Supports `expectedUpdatedAt` for
+   * optimistic concurrency — pass it when you know the version you read.
+   */
+  patch(id, input, opts = {}) {
+    return patchFile(this.ctx, id, input, opts);
+  }
+  delete(id, opts = {}) {
+    return deleteFile(this.ctx, id, opts);
+  }
+  restore(id, opts = {}) {
+    return restoreFile(this.ctx, id, opts);
+  }
+  permanentDelete(id, opts = {}) {
+    return permanentDeleteFile(this.ctx, id, opts);
+  }
+  // ---------------------------------------------------------------------------
+  //  Folder / move / run
+  // ---------------------------------------------------------------------------
+  /**
+   * Idempotent create-or-get a folder. Returns the existing folder (with
+   * `200`) or the new one (`201`) — consumers don't need to distinguish.
+   */
+  createFolder(input, opts = {}) {
+    return createFolder(this.ctx, input, opts);
+  }
+  move(id, parentId, opts = {}) {
+    return moveFile(this.ctx, id, parentId, opts);
+  }
+  /**
+   * Execute a code file (js/ts/py/sh) in a sandboxed Lambda. Returns the
+   * full `ExecutionRun` record (status, stdout/stderr, exit code, timestamps).
+   */
+  run(id, input = {}, opts = {}) {
+    return runFile(this.ctx, id, input, opts);
+  }
+};
+
+// ../sdk/src/api/guide.ts
+var GuideApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Fetch the SKILL.md document. Returns `{ content, format }` — the route
+   * responds with a JSON envelope, not raw text.
+   */
+  async get(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/guide",
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/images.ts
+var ImagesApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async listModels(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/images/models",
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Generate an image. Responds HTTP 201 with the written file ref under `data`. */
+  async generate(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/images/generations",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/models.ts
+var ModelsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async list(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/models",
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/notifications.ts
+var NotificationsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  // ---------------------------------------------------------------------------
+  //  Per-row verbs
+  // ---------------------------------------------------------------------------
+  /**
+   * List notification rows. Returns the `data` array directly; the
+   * unfiltered unread tally lives at the TOP LEVEL of the wire envelope
+   * (`unread_count`, a sibling of `data`/`pagination`) — use `listWithMeta`
+   * when you need it.
+   */
+  async list(query = {}, opts = {}) {
+    const res = await this.listWithMeta(query, opts);
+    return res.data;
+  }
+  /**
+   * Like `list()` but returns the full envelope so callers can read the
+   * top-level `unread_count` (e.g. to drive an unread badge).
+   */
+  async listWithMeta(query = {}, opts = {}) {
+    return request(
+      this.ctx,
+      {
+        method: "GET",
+        path: "/api/v1/notifications",
+        query,
+        signal: opts.signal
+      }
+    );
+  }
+  async get(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/notifications/${id}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * PATCH a single recipient row. The body accepts only the `is_read` and
+   * `archived` booleans; at least one must be supplied (422 otherwise).
+   * Returns the full updated `Notification`.
+   */
+  async update(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/notifications/${id}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Shorthand for `update(id, { is_read: true })`. */
+  markRead(id, opts = {}) {
+    return this.update(id, { is_read: true }, opts);
+  }
+  /** Shorthand for `update(id, { archived: true })`. */
+  archive(id, opts = {}) {
+    return this.update(id, { archived: true }, opts);
+  }
+  /** Shorthand for `update(id, { archived: false })`. */
+  unarchive(id, opts = {}) {
+    return this.update(id, { archived: false }, opts);
+  }
+  async delete(id, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/notifications/${id}`,
+      signal: opts.signal
+    });
+  }
+  // ---------------------------------------------------------------------------
+  //  Bulk
+  // ---------------------------------------------------------------------------
+  /**
+   * Mark every unread, non-archived, non-deleted notification as read.
+   * Resolves once the bulk update lands — the v1 response is an empty
+   * `{ data: {} }` envelope.
+   */
+  async readAll(opts = {}) {
+    await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/notifications/read-all",
+      signal: opts.signal
+    });
+  }
+  // ---------------------------------------------------------------------------
+  //  Send (admin / owner)
+  // ---------------------------------------------------------------------------
+  /**
+   * Send a notification to workspace members. The caller must be an admin/owner
+   * of the workspace; `recipient_ids` (profile resourceIds) and the broadcast
+   * targets are mutually exclusive — pass one via `audience`.
+   */
+  async send(input, opts = {}) {
+    const body = {
+      workspace_id: input.workspace_id,
+      title: input.title,
+      message: input.message,
+      channels: input.channels,
+      urgency: input.urgency,
+      dedup_key: input.dedup_key,
+      data: input.data,
+      deep_link: input.deep_link
+    };
+    if (Array.isArray(input.audience)) {
+      body.recipient_ids = input.audience;
+    } else {
+      body.target = input.audience;
+    }
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: "/api/v1/notifications",
+        body,
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  // ---------------------------------------------------------------------------
+  //  Config + preferences
+  // ---------------------------------------------------------------------------
+  /**
+   * Fetch the per-user toast/sound/quiet-hours/digest config. The response
+   * is flat — the config object IS `data`, with no inner `{config}` wrapper.
+   */
+  async getConfig(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/notifications/config",
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** PATCH a subset of the config. Returns the full flat config. */
+  async updateConfig(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: "/api/v1/notifications/config",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Fetch the (type, subtype?, channel) preference matrix. The response is
+   * flat — `data` IS the preference array, with no inner `{preferences}`
+   * wrapper.
+   */
+  async getPreferences(opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "GET",
+        path: "/api/v1/notifications/preferences",
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  /**
+   * Bulk-update preferences. Each entry sets one (type, subtype?, channel)
+   * row. Empty `updates[]` → 422. Returns the full flat preference array.
+   */
+  async updatePreferences(updates, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "PATCH",
+        path: "/api/v1/notifications/preferences",
+        body: { updates },
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/provider-endpoints.ts
+var ProviderEndpointsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async list(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/ai-gateway/provider-endpoints",
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async presets(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/ai-gateway/provider-endpoints/presets",
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async create(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/ai-gateway/provider-endpoints",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async update(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/ai-gateway/provider-endpoints/${id}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async delete(id, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/ai-gateway/provider-endpoints/${id}`,
+      signal: opts.signal
+    });
+  }
+  async test(id, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/ai-gateway/provider-endpoints/${id}/test`,
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/realtime.ts
+var enc3 = encodeURIComponent;
+var RECONNECT_MIN_MS = 1e3;
+var RECONNECT_MAX_MS = 3e4;
+var RealtimeApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /** Send an ephemeral message to a channel's current subscribers. */
+  async broadcast(channel, message, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/realtime/${enc3(channel)}/broadcast`,
+      body: { message },
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Record/refresh the caller's presence on a channel (TTL heartbeat). */
+  async heartbeat(channel, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/realtime/${enc3(channel)}/presence`,
+      body: { meta: opts.meta, ttl_seconds: opts.ttlSeconds },
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** List who is currently present on a channel. */
+  async presence(channel, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/realtime/${enc3(channel)}/presence`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Open an SSE stream for one or more channels' durable changes + ephemeral
+   * broadcasts. `onEvent` fires for every change/broadcast frame; heartbeat and
+   * transport-only signals are NOT surfaced (they keep the socket warm). Returns
+   * an unsubscribe function — call it (or abort `opts.signal`) to close.
+   *
+   * The stream auto-reconnects with capped exponential backoff and resumes from
+   * the last seen change id (so durable changes are not missed across a drop).
+   */
+  subscribe(channels, onEvent, opts = {}) {
+    if (channels.length === 0) {
+      throw new Error("realtime.subscribe requires at least one channel");
+    }
+    const controller = new AbortController();
+    if (opts.signal) {
+      if (opts.signal.aborted) controller.abort();
+      else opts.signal.addEventListener("abort", () => controller.abort());
+    }
+    let lastEventId = opts.lastEventId;
+    let backoff = RECONNECT_MIN_MS;
+    let closed = false;
+    const run = async () => {
+      while (!closed && !controller.signal.aborted) {
+        try {
+          const headers = {};
+          if (lastEventId) headers["Last-Event-ID"] = lastEventId;
+          const res = await requestRaw(this.ctx, {
+            method: "GET",
+            path: "/api/v1/realtime/subscribe",
+            query: { channels: channels.join(",") },
+            headers,
+            signal: controller.signal,
+            expectJson: false
+          });
+          backoff = RECONNECT_MIN_MS;
+          for await (const frame of parseSseStream(res, controller.signal)) {
+            if (frame.id) lastEventId = frame.id;
+            const event = toRealtimeEvent(frame);
+            if (event) onEvent(event);
+          }
+        } catch (err) {
+          if (controller.signal.aborted || closed) return;
+          opts.onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+        if (closed || controller.signal.aborted) return;
+        await delay(backoff, controller.signal);
+        backoff = Math.min(backoff * 2, RECONNECT_MAX_MS);
+      }
+    };
+    void run();
+    return () => {
+      closed = true;
+      controller.abort();
+    };
+  }
+  /**
+   * A per-channel handle bundling subscribe + broadcast + presence + heartbeat
+   * for one channel, so callers don't repeat the key:
+   *
+   *   const ch = client.realtime.channel("table:col_123");
+   *   const stop = ch.subscribe((e) => render(e));
+   *   await ch.broadcast({ cursor: { x, y } });
+   */
+  channel(key) {
+    return {
+      key,
+      subscribe: (onEvent, o) => this.subscribe([key], onEvent, o),
+      broadcast: (message, o) => this.broadcast(key, message, o),
+      presence: (o) => this.presence(key, o),
+      heartbeat: (o) => this.heartbeat(key, o)
+    };
+  }
+};
+async function* parseSseStream(response, signal) {
+  if (!response.body) return;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) return;
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
+      while (true) {
+        const boundary = buffer.indexOf("\n\n");
+        if (boundary === -1) break;
+        const block = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const parsed = parseSseBlock3(block);
+        if (parsed) yield parsed;
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function parseSseBlock3(block) {
+  let id;
+  let data = "";
+  let isHeartbeat = false;
+  for (const line of block.split("\n")) {
+    if (!line || line.startsWith(":")) continue;
+    if (line.startsWith("id:")) id = line.slice(3).trim();
+    else if (line.startsWith("event:")) {
+      if (line.slice(6).trim() === "heartbeat") isHeartbeat = true;
+    } else if (line.startsWith("data:")) data += line.slice(5).trimStart();
+  }
+  if (isHeartbeat) return null;
+  if (!data) return null;
+  return id ? { id, data } : { data };
+}
+function toRealtimeEvent(frame) {
+  let parsed;
+  try {
+    parsed = JSON.parse(frame.data);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const env = parsed;
+  if (typeof env.channel !== "string") return null;
+  const channel = env.channel;
+  if (channel === "rt:bcast") {
+    const inner = env.message;
+    if (inner && typeof inner === "object" && typeof inner.channel === "string") {
+      return { channel: inner.channel, type: "broadcast", data: inner.message };
+    }
+    return null;
+  }
+  if (channel === "events") {
+    const inner = env.message;
+    const sigChannel = inner && typeof inner.channel === "string" ? inner.channel : channel;
+    const type = inner?.message && typeof inner.message.type === "string" ? inner.message.type : "signal";
+    return { channel: sigChannel, type, data: null };
+  }
+  const msg = env.message;
+  if (msg && typeof msg === "object") {
+    return {
+      channel,
+      type: typeof msg.type === "string" ? msg.type : "change",
+      data: msg.data ?? null,
+      ...frame.id ? { id: frame.id } : {}
+    };
+  }
+  return null;
+}
+function delay(ms, signal) {
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+
+// ../sdk/src/api/search.ts
+var SearchApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async search(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/search",
+      query: {
+        q: input.q,
+        limit: input.limit,
+        cursor: input.cursor,
+        source: input.source,
+        type: input.type,
+        workspace_id: input.workspace_id,
+        chat_mode: input.chat_mode
+      },
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/secrets.ts
+var SecretsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async list(opts = {}) {
+    const query = opts.workspaceId ? `?workspace_id=${encodeURIComponent(opts.workspaceId)}` : "";
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/secrets${query}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async get(secretId, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/secrets/${secretId}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async create(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/secrets",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async update(secretId, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/secrets/${secretId}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async delete(secretId, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/secrets/${secretId}`,
+      signal: opts.signal
+    });
+  }
+  /**
+   * Reveal a secret's plaintext value. Session-authenticated callers only (not
+   * API keys), audited, and rate-limited. Returns the decrypted `value`.
+   */
+  async reveal(secretId, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/secrets/${secretId}/reveal`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/settings.ts
+var SettingsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async get(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/settings",
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async update(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: "/api/v1/settings",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/sharing.ts
+var SharingApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  // ---------------------------------------------------------------------------
+  //  /v1/shares — share rows on a single resource
+  // ---------------------------------------------------------------------------
+  async list(query, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/shares",
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async add(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/shares",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Update a share's permission. The keying triple
+   * (`resource_type`, `resource_id`, `grantee_actor_id`) goes on the QUERY
+   * string; the request BODY carries only `{ permission }`.
+   */
+  async update(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: "/api/v1/shares",
+      query: {
+        resource_type: input.resource_type,
+        resource_id: input.resource_id,
+        grantee_actor_id: input.grantee_actor_id
+      },
+      body: { permission: input.permission },
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Remove a share. The keying triple goes on the QUERY string; the
+   * request takes NO body. The response is the removed triple at the TOP
+   * LEVEL — `{ deleted, resource_type, resource_id, grantee_actor_id }` —
+   * not nested under `data` (a share has no standalone id).
+   */
+  async remove(input, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: "/api/v1/shares",
+      query: input,
+      signal: opts.signal
+    });
+  }
+  // ---------------------------------------------------------------------------
+  //  /v1/shared-with-me — inverse list
+  // ---------------------------------------------------------------------------
+  /**
+   * List resources others have shared with the caller. Omit `resource_type`
+   * for the unified view across chats / agents / files / workspaces.
+   */
+  async listSharedWithMe(query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/shared-with-me",
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/store.ts
+var StoreApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Search the hub. Open envelope — items are heterogeneous (skills carry
+   * version/license, agents carry icons/prompts, computer templates carry
+   * sizing) so we surface them as `StoreItem` with an open index signature.
+   */
+  async search(query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/store/search",
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Install a hub item into one of the caller's workspaces. Returns whatever
+   * the per-template installer produces (folder ids, agent ids, ...) —
+   * `StoreInstallResult` carries the common fields and leaves the rest
+   * open.
+   */
+  async install(resourceId, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/store/${resourceId}/install`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/subscription.ts
+var SubscriptionApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async get(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/subscription",
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/tables.ts
+var enc4 = encodeURIComponent;
+var TablesApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async list(opts = {}) {
+    const q = new URLSearchParams();
+    if (opts.workspaceId) q.set("workspace_id", opts.workspaceId);
+    if (opts.cursor) q.set("cursor", opts.cursor);
+    if (opts.limit) q.set("limit", String(opts.limit));
+    const qs = q.toString() ? `?${q.toString()}` : "";
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/tables${qs}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async get(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/tables/${enc4(id)}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async create(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/tables",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async update(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/tables/${enc4(id)}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async delete(id, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/tables/${enc4(id)}`,
+      signal: opts.signal
+    });
+  }
+  /** Query a collection's records with the filter/sort/paginate DSL. */
+  async query(id, query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/tables/${enc4(id)}/query`,
+      body: query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async createRecord(id, values, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/tables/${enc4(id)}/records`,
+      body: { values },
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async getRecord(id, recordId, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/tables/${enc4(id)}/records/${enc4(recordId)}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async updateRecord(id, recordId, values, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/tables/${enc4(id)}/records/${enc4(recordId)}`,
+      body: { values },
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async deleteRecord(id, recordId, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/tables/${enc4(id)}/records/${enc4(recordId)}`,
+      signal: opts.signal
+    });
+  }
+  /** Export a collection's records as a CSV string (header row = field keys). */
+  async exportCsv(id, opts = {}) {
+    const res = await requestRaw(this.ctx, {
+      method: "GET",
+      path: `/api/v1/tables/${enc4(id)}/export`,
+      signal: opts.signal,
+      expectJson: false
+    });
+    return res.text();
+  }
+  /** Import records into a collection from a CSV string. Returns the count. */
+  async importCsv(id, csv, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/tables/${enc4(id)}/import`,
+      body: { csv },
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/triggers.ts
+var TriggersApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  // ---------------------------------------------------------------------------
+  //  CRUD
+  // ---------------------------------------------------------------------------
+  async list(query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/triggers",
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Create a trigger. `workspace_id` is passed in the request BODY (alongside
+   * the flat trigger definition) — it is not a query param. The request
+   * body is flat: every scheduling field (`cron_expression`, …) and every
+   * action field (`agent_id`, `prompt_template`, `file_id`, …) sits at the
+   * top level — there are no nested `trigger_config` / `action_config`
+   * objects any more.
+   *
+   * For a `webhook` trigger the response additionally carries a one-time
+   * plaintext `secret` (use `TriggerWithSecret`); other trigger types
+   * resolve to a plain `Trigger`.
+   */
+  async create(workspaceId, input, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: "/api/v1/triggers",
+        body: { workspace_id: workspaceId, ...input },
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  async get(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/triggers/${id}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async update(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/triggers/${id}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async delete(id, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/triggers/${id}`,
+      signal: opts.signal
+    });
+  }
+  async archive(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/triggers/${id}/archive`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async unarchive(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/triggers/${id}/unarchive`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  // ---------------------------------------------------------------------------
+  //  Fire + rotate-secret + runs
+  // ---------------------------------------------------------------------------
+  /**
+   * Fire a trigger via its webhook secret. This endpoint does NOT use the
+   * client's `ap_` key — the bearer is the trigger's secret — so we build a
+   * one-off HttpContext for it rather than mutating the shared one.
+   *
+   * Responds HTTP 202. The response identifies the fired trigger via `id`
+   * only.
+   */
+  async fire(id, input, opts = {}) {
+    const localCtx = {
+      apiUrl: this.ctx.apiUrl,
+      key: input.secret,
+      fetch: this.ctx.fetch
+    };
+    const res = await request(localCtx, {
+      method: "POST",
+      path: `/api/v1/triggers/${id}/fire`,
+      body: input.body ?? {},
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Rotate the webhook secret. Returns the trigger with a fresh one-time
+   * plaintext `secret` populated (`TriggerWithSecret`). The old secret
+   * immediately stops working.
+   */
+  async rotateSecret(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/triggers/${id}/rotate-secret`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Recent fires + their success/error outcome. */
+  async listRuns(id, query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/triggers/${id}/runs`,
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async getCostStats(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/triggers/${id}/cost-stats`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async getCostStatsMap(query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/triggers/cost-stats",
+      query,
+      signal: opts.signal
+    });
+    return res.data.by_id;
+  }
+};
+
+// ../sdk/src/api/user.ts
+var UserApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /** Current authenticated user's profile. */
+  async me(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/me",
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Storage usage summary — bytes used / total, snapshot footprint.
+   * Corresponds to `GET /me/usage?view=summary` (the default).
+   */
+  async usage(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/me/usage",
+      query: { view: "summary" },
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Paginated history of LLM / image / audio calls + cost.
+   * Corresponds to `GET /me/usage?view=history`.
+   */
+  async usageHistory(query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/me/usage",
+      query: { view: "history", ...query },
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/web.ts
+var WebSearchApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async search(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/web/search",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+};
+
+// ../sdk/src/api/workspaces.ts
+var WorkspacesApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  // ---------------------------------------------------------------------------
+  //  CRUD
+  // ---------------------------------------------------------------------------
+  async list(query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/workspaces",
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async create(input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: "/api/v1/workspaces",
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async get(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/workspaces/${id}`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async update(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/workspaces/${id}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async delete(id, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/workspaces/${id}`,
+      signal: opts.signal
+    });
+  }
+  async archive(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/workspaces/${id}/archive`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async unarchive(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/workspaces/${id}/unarchive`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  // ---------------------------------------------------------------------------
+  //  Members
+  // ---------------------------------------------------------------------------
+  async listMembers(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/workspaces/${id}/members`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async addMember(id, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/workspaces/${id}/members`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async updateMember(id, memberId, input, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "PATCH",
+      path: `/api/v1/workspaces/${id}/members/${memberId}`,
+      body: input,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async removeMember(id, memberId, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/workspaces/${id}/members/${memberId}`,
+      signal: opts.signal
+    });
+  }
+  // ---------------------------------------------------------------------------
+  //  Invitations
+  // ---------------------------------------------------------------------------
+  async listInvitations(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/workspaces/${id}/invitations`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Invite an existing idapt user by their profile slug. Idempotent on
+   * the `(workspace_id, slug)` pair — reissue safely. Personal workspaces
+   * reject invitations.
+   */
+  async createInvitation(id, input, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/workspaces/${id}/invitations`,
+        body: { slug: input.slug, role: input.role ?? "viewer" },
+        signal: opts.signal
+      }
+    );
+    return res.data;
+  }
+  /**
+   * Revoke a pending invitation. The invitation is identified by the
+   * invitee's profile slug, passed as the `invitee_slug` query param —
+   * there is no invitation id. Returns `{ deleted: true, id }` where `id`
+   * is the workspace id (top-level, not enveloped under `data`).
+   */
+  async deleteInvitation(id, inviteeSlug, opts = {}) {
+    return request(this.ctx, {
+      method: "DELETE",
+      path: `/api/v1/workspaces/${id}/invitations`,
+      query: { invitee_slug: inviteeSlug },
+      signal: opts.signal
+    });
+  }
+};
+
+// src/api/app.ts
+var RemoteBundleReader = class {
+  constructor(ctx, id) {
+    this.ctx = ctx;
+    this.id = id;
+  }
+  list(opts = {}) {
+    return listFiles(this.ctx, { parent_id: this.id }, opts);
+  }
+  listFolder(parentId, opts = {}) {
+    return listFiles(this.ctx, { parent_id: parentId }, opts);
+  }
+  read(fileId, opts = {}) {
+    return getFileText(this.ctx, fileId, opts);
+  }
+  async readJSON(fileId, opts = {}) {
+    const text = await this.read(fileId, opts);
+    return JSON.parse(text);
+  }
+  readBlob(fileId, opts = {}) {
+    return getFileBlob(this.ctx, fileId, opts);
+  }
+};
+var AppFolder = class {
+  /**
+   * Two construction shapes:
+   *
+   *   - `new AppFolder(ctx, folderId)` — builds a {@link RemoteBundleReader}
+   *     internally. The normal path.
+   *   - `new AppFolder(reader)` — inject any {@link BundleReader} (e.g. a fake
+   *     in tests).
+   */
+  constructor(ctxOrReader, folderId) {
+    if (isBundleReader(ctxOrReader)) {
+      this.reader = ctxOrReader;
+    } else {
+      this.reader = new RemoteBundleReader(ctxOrReader, folderId ?? "");
+    }
+  }
+  /** The code folder's id. */
+  get id() {
+    return this.reader.id ?? "";
+  }
+  /** List files in the app folder. */
+  list(opts = {}) {
+    return this.reader.list(opts);
+  }
+  /** List a specific subfolder of the app folder. */
+  listFolder(parentId, opts = {}) {
+    return this.reader.listFolder(parentId, opts);
+  }
+  /**
+   * Read a file's text content (by Drive file id). UTF-8 decoded; use
+   * `readBlob` for binary.
+   */
+  read(fileId, opts = {}) {
+    return this.reader.read(fileId, opts);
+  }
+  /** Read + parse JSON in one call. */
+  readJSON(fileId, opts = {}) {
+    return this.reader.readJSON(fileId, opts);
+  }
+  /** Read a file's raw bytes as a Blob. Preserves the server's MIME type. */
+  readBlob(fileId, opts = {}) {
+    return this.reader.readBlob(fileId, opts);
+  }
+};
+function isBundleReader(x) {
+  return typeof x.read === "function" && typeof x.readBlob === "function";
+}
+
+// src/api/data-remote.ts
+var RemoteDataStore = class {
+  /**
+   * @param ctx  HTTP context (carries the app's `ap_` bearer + api origin).
+   * @param id   The app's **resource id** (the `{appResId}` path segment) — this
+   *             is the boot's `appResourceId`, NOT a Drive folder id.
+   */
+  constructor(ctx, id) {
+    this.ctx = ctx;
+    this.id = id;
+  }
+  /** Idapt origin this store talks to — surfaced by `DataFolder` for tooling. */
+  get apiUrl() {
+    return this.ctx.apiUrl;
+  }
+  /** URL-encode a single key segment for the `{...key}` catch-all route. */
+  keyPath(key) {
+    const encoded = key.split("/").map((seg) => encodeURIComponent(seg)).join("/");
+    return `/api/browser-app/data/${encodeURIComponent(this.id)}/${encoded}`;
+  }
+  /** List the principal's keys for this app → `File[]` with `id = name = key`. */
+  async list(opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      // Trailing slash → empty `[...key]` → the route's "list keys" branch.
+      path: `/api/browser-app/data/${encodeURIComponent(this.id)}/`,
+      signal: opts.signal
+    });
+    const keys = Array.isArray(res?.keys) ? res.keys : [];
+    return keys.map(keyToFile);
+  }
+  /**
+   * No KV analogue — the app-data KV is a flat per-principal namespace with no
+   * subfolders. Throws so apps that try to enumerate a folder get a clear error.
+   */
+  listFolder(_parentId, _opts = {}) {
+    return Promise.reject(unsupported("listFolder"));
+  }
+  /** Metadata for one key — GET it; 404 surfaces as `NotFoundError`. */
+  async getMetadata(key, opts = {}) {
+    await requestRaw(this.ctx, {
+      method: "GET",
+      path: this.keyPath(key),
+      signal: opts.signal
+    });
+    return keyToFile(key);
+  }
+  /** Read a key's stored string. Inline JSON → `{value}`; blob → raw text. */
+  async read(key, opts = {}) {
+    const res = await requestRaw(this.ctx, {
+      method: "GET",
+      path: this.keyPath(key),
+      signal: opts.signal
+    });
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json")) {
+      const body = await res.json();
+      return valueToString(body?.value);
+    }
+    return res.text();
+  }
+  /** Read a key's raw bytes as a Blob (handles blob-backed binary entries). */
+  async readBlob(key, opts = {}) {
+    const res = await requestRaw(this.ctx, {
+      method: "GET",
+      path: this.keyPath(key),
+      signal: opts.signal
+    });
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json")) {
+      const body = await res.json();
+      return new Blob([valueToString(body?.value)], { type: "text/plain" });
+    }
+    return res.blob();
+  }
+  /** Upsert a key's value. `content` is stored verbatim as `{value: content}`. */
+  async write(key, content, opts = {}) {
+    await request(this.ctx, {
+      method: "PUT",
+      path: this.keyPath(key),
+      body: { value: content },
+      signal: opts.signal
+    });
+    return keyToFile(key);
+  }
+  /** Delete a key (idempotent — DELETE on a missing key still resolves). */
+  async delete(key, opts = {}) {
+    await request(this.ctx, {
+      method: "DELETE",
+      path: this.keyPath(key),
+      signal: opts.signal
+    });
+    return { deleted: true, id: key };
+  }
+  /**
+   * Store a blob under `name` (the KV key). This is the create path behind
+   * `DataFolder.set()` / `setJSON()`, which always upload a `text/plain` blob —
+   * we read the blob as **text** and PUT it as the key's `{value}`. Binary
+   * blobs are stored as their UTF-8 text (the KV PUT route is JSON-only); use
+   * `set()`/`setJSON()` for structured data.
+   */
+  async upload(input, opts = {}) {
+    if (input.parent_id && input.parent_id !== this.id) {
+      throw unsupported("upload into a subfolder");
+    }
+    const name = input.name ?? (input.file instanceof globalThis.File ? input.file.name : void 0);
+    if (!name) {
+      throw new InvalidRequestError({
+        message: "upload requires a name (the KV key)",
+        status: 422,
+        body: null
+      });
+    }
+    const text = await input.file.text();
+    await request(this.ctx, {
+      method: "PUT",
+      path: this.keyPath(name),
+      body: { value: text },
+      signal: opts.signal
+    });
+    return { id: name, name };
+  }
+  /** No KV analogue — the namespace is flat. */
+  createFolder(_input, _opts = {}) {
+    return Promise.reject(unsupported("createFolder"));
+  }
+  /** No KV analogue — there are no folders to move between. */
+  move(_key, _parentId, _opts = {}) {
+    return Promise.reject(unsupported("move"));
+  }
+};
+function keyToFile(key) {
+  return { id: key, name: key };
+}
+function valueToString(value) {
+  if (typeof value === "string") return value;
+  if (value === null || value === void 0) return "";
+  return JSON.stringify(value);
+}
+function unsupported(surface) {
+  return new InvalidRequestError({
+    message: `\`${surface}\` is not supported by the browser-app data KV \u2014 it is a flat per-app key/value store with no folders. Use the name-based API (set/get/has/setJSON/getJSON/remove).`,
+    status: 422,
+    body: null
+  });
+}
+
+// src/api/data.ts
+var DataFolder = class {
+  /**
+   * Two construction shapes:
+   *
+   *   - `new DataFolder(ctx, appResourceId)` — builds a {@link RemoteDataStore}
+   *     internally, scoped by the app's RESOURCE id (the `{appResId}` segment of
+   *     the KV path), NOT a Drive folder id. The normal path.
+   *   - `new DataFolder(store)` — inject any {@link DataStore} (e.g. a fake in
+   *     tests).
+   */
+  constructor(ctxOrStore, appResourceId) {
+    /** name (lowercased) → fileId, populated lazily by list() / set(). */
+    this.nameCache = /* @__PURE__ */ new Map();
+    this.nameCacheLoaded = false;
+    if (isDataStore(ctxOrStore)) {
+      this.store = ctxOrStore;
+    } else {
+      this.store = new RemoteDataStore(ctxOrStore, appResourceId ?? "");
+    }
+  }
+  /** The data folder's id — useful for passing to other SDK calls. */
+  get id() {
+    return this.store.id;
+  }
+  // ---------------------------------------------------------------------------
+  //  Raw fileId-based API.
+  // ---------------------------------------------------------------------------
+  /** List every file in the data folder (top level only, excluding subfolders' contents). */
+  async list(opts = {}) {
+    const files = await this.store.list(opts);
+    this.rebuildNameCache(files);
+    return files;
+  }
+  /** List a specific subfolder within the data folder. */
+  listFolder(parentId, opts = {}) {
+    return this.store.listFolder(parentId, opts);
+  }
+  /** Read a file's raw text content by id. UTF-8 decoded. */
+  read(fileId, opts = {}) {
+    return this.store.read(fileId, opts);
+  }
+  /** Read and parse as JSON. */
+  async readJSON(fileId, opts = {}) {
+    const text = await this.read(fileId, opts);
+    return JSON.parse(text);
+  }
+  /** Read raw bytes as a Blob. Use for binary files stored in data folder. */
+  readBlob(fileId, opts = {}) {
+    return this.store.readBlob(fileId, opts);
+  }
+  /** PATCH content on an existing file id (optimistic concurrency via opts). */
+  write(fileId, content, opts = {}) {
+    return this.store.write(fileId, content, opts);
+  }
+  /** Stringify and PATCH. */
+  writeJSON(fileId, data, opts = {}) {
+    return this.write(fileId, JSON.stringify(data, null, 2), opts);
+  }
+  /** Move the file to trash. */
+  async delete(fileId, opts = {}) {
+    await this.store.delete(fileId, opts);
+    for (const [k, v] of this.nameCache) {
+      if (v === fileId) this.nameCache.delete(k);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  //  Upload / folder / move — scoped to the data folder.
+  // ---------------------------------------------------------------------------
+  /**
+   * Multipart upload a Blob or File into the data folder (or a subfolder of
+   * it). Returns the upload record. Use this for binary data; for text/JSON
+   * prefer the name-based `set()` / `setJSON()`.
+   */
+  upload(input, opts = {}) {
+    return this.store.upload(
+      {
+        file: input.file,
+        name: input.name,
+        parent_id: input.parent_id,
+        skip_if_exists: input.skip_if_exists
+      },
+      opts
+    );
+  }
+  /**
+   * Create (or get) a subfolder inside the data folder. Returns the folder
+   * record — store the `id` to use as `parent_id` for nested uploads /
+   * `createFolder` calls. Idempotent by name at the given parent.
+   */
+  createFolder(input, opts = {}) {
+    return this.store.createFolder(
+      {
+        name: input.name,
+        parent_id: input.parent_id,
+        icon: input.icon
+      },
+      opts
+    );
+  }
+  /**
+   * Move a file or subfolder within the data folder. Pass the data folder's
+   * own id (or omit `parentId`) to move it back to the data-folder root.
+   */
+  move(fileId, parentId, opts = {}) {
+    return this.store.move(
+      fileId,
+      parentId === void 0 ? this.store.id : parentId,
+      opts
+    );
+  }
+  // ---------------------------------------------------------------------------
+  //  Name-based convenience API.
+  // ---------------------------------------------------------------------------
+  /**
+   * Upsert a file by name. Creates it on first call, PATCHes it on
+   * subsequent calls. Returns the resolved file metadata.
+   */
+  async set(name, content, opts = {}) {
+    const existing = await this.resolve(name, opts);
+    if (existing) {
+      return this.write(existing.id, content, opts);
+    }
+    return this.createByName(name, content, opts);
+  }
+  /** Stringify-and-upsert. */
+  setJSON(name, data, opts = {}) {
+    return this.set(name, JSON.stringify(data, null, 2), opts);
+  }
+  /**
+   * Read a file by name. Returns `null` if the file doesn't exist (rather
+   * than throwing) — this is the common "first-run preferences" case.
+   */
+  async get(name, opts = {}) {
+    const ref = await this.resolve(name, opts);
+    if (!ref) return null;
+    try {
+      return await this.read(ref.id, opts);
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        this.nameCache.delete(name.toLowerCase());
+        const retry = await this.resolve(name, opts);
+        if (!retry) return null;
+        return this.read(retry.id, opts);
+      }
+      throw err;
+    }
+  }
+  /** Read + parse JSON, or null if the file doesn't exist. */
+  async getJSON(name, opts = {}) {
+    const text = await this.get(name, opts);
+    if (text === null) return null;
+    return JSON.parse(text);
+  }
+  /** Does a file with this name exist? */
+  async has(name, opts = {}) {
+    return await this.resolve(name, opts) !== null;
+  }
+  /**
+   * Delete a file by name. Returns `true` if something was deleted, `false`
+   * if the file didn't exist.
+   */
+  async remove(name, opts = {}) {
+    const ref = await this.resolve(name, opts);
+    if (!ref) return false;
+    await this.delete(ref.id, opts);
+    return true;
+  }
+  /**
+   * Find the file id for a given name, or null. Populates the name→id cache
+   * on first call.
+   */
+  async resolve(name, opts = {}) {
+    const normalized = name.toLowerCase();
+    if (!this.nameCacheLoaded) {
+      const files = await this.list(opts);
+      const hit = files.find(
+        (f) => (f.name ?? "").toLowerCase() === normalized
+      );
+      return hit ?? null;
+    }
+    const cachedId = this.nameCache.get(normalized);
+    if (!cachedId) return null;
+    try {
+      return await this.store.getMetadata(cachedId, opts);
+    } catch (err) {
+      if (err instanceof NotFoundError) {
+        this.nameCache.delete(normalized);
+        return null;
+      }
+      throw err;
+    }
+  }
+  /** Drop the name→id cache. Next call will re-list. */
+  invalidate() {
+    this.nameCache.clear();
+    this.nameCacheLoaded = false;
+  }
+  // ---------------------------------------------------------------------------
+  //  Internal helpers.
+  // ---------------------------------------------------------------------------
+  /**
+   * Create a new file at the data-folder root via multipart upload. The
+   * `skip_if_exists` flag hedges against concurrent creates; if another tab
+   * wins the race, we re-list and PATCH instead.
+   */
+  async createByName(name, content, opts) {
+    try {
+      const res = await this.store.upload(
+        {
+          file: new Blob([content], { type: "text/plain" }),
+          name,
+          parent_id: this.store.id,
+          skip_if_exists: true
+        },
+        opts
+      );
+      this.nameCache.set(name.toLowerCase(), res.id);
+      return res;
+    } catch (err) {
+      const normalized = name.toLowerCase();
+      const files = await this.list(opts);
+      const winner = files.find(
+        (f) => (f.name ?? "").toLowerCase() === normalized
+      );
+      if (winner) return this.write(winner.id, content, opts);
+      throw err;
+    }
+  }
+  rebuildNameCache(files) {
+    this.nameCache.clear();
+    for (const f of files) {
+      if (!f.name || !f.id) continue;
+      this.nameCache.set(f.name.toLowerCase(), f.id);
+    }
+    this.nameCacheLoaded = true;
+  }
+};
+function isDataStore(x) {
+  return typeof x.write === "function" && typeof x.upload === "function" && typeof x.getMetadata === "function";
+}
+
+// src/client.ts
+var IdaptClient2 = class {
+  constructor(deps) {
+    this.deps = deps;
+    const cred = deps.credential;
+    this.mode = "remote";
+    const auth = cred.auth ?? (cred.key ? "bearer" : "cookie");
+    const ctx = {
+      apiUrl: cred.apiUrl,
+      key: cred.key ?? "",
+      auth,
+      fetch: deps.fetch
+    };
+    this.ctx = ctx;
+    const dataCtx = ctx;
+    let v1Ctx = ctx;
+    if (auth === "cookie") {
+      const mintToken = this.makeAppTokenMinter(ctx.apiUrl, deps.fetch);
+      v1Ctx = {
+        ...ctx,
+        getToken: mintToken.get,
+        onUnauthorized: mintToken.invalidate
+      };
+    }
+    const appResourceId = deriveAppId(cred, deps.browserAppDomain);
+    this.app = new AppFolder(v1Ctx, cred.appFolderId);
+    this.data = new DataFolder(dataCtx, appResourceId);
+    this.user = new UserApi(v1Ctx);
+    this.files = new FilesApi(v1Ctx);
+    this.agents = new AgentsApi(v1Ctx);
+    this.chats = new ChatsApi(v1Ctx);
+    this.workspaces = new WorkspacesApi(v1Ctx);
+    this.triggers = new TriggersApi(v1Ctx);
+    this.computers = new ComputersApi(v1Ctx);
+    this.secrets = new SecretsApi(v1Ctx);
+    this.kv = new DatastoreApi(v1Ctx);
+    this.blobs = new BlobsApi(v1Ctx);
+    this.tables = new TablesApi(v1Ctx);
+    this.realtime = new RealtimeApi(v1Ctx);
+    this.apiKeys = new ApiKeysApi(v1Ctx);
+    this.notifications = new NotificationsApi(v1Ctx);
+    this.settings = new SettingsApi(v1Ctx);
+    this.subscription = new SubscriptionApi(v1Ctx);
+    this.sharing = new SharingApi(v1Ctx);
+    this.store = new StoreApi(v1Ctx);
+    this.models = new ModelsApi(v1Ctx);
+    this.providerEndpoints = new ProviderEndpointsApi(v1Ctx);
+    this.images = new ImagesApi(v1Ctx);
+    this.audio = new AudioApi(v1Ctx);
+    this.code = new CodeRunsApi(v1Ctx);
+    this.search = new SearchApi(v1Ctx);
+    this.web = new WebSearchApi(v1Ctx);
+    this.guide = new GuideApi(v1Ctx);
+    this.docs = new DocsApi(v1Ctx);
+    this.meta = {
+      appId: appResourceId,
+      apiUrl: cred.apiUrl,
+      appFolderId: cred.appFolderId,
+      dataFolderId: cred.dataFolderId,
+      mode: this.mode
+    };
+  }
+  /**
+   * The `ap_`/`uk_` key — use only for raw v1 calls the SDK doesn't wrap.
+   * In cookie mode there is no raw key — it lives only in the httpOnly app-key
+   * cookie the browser attaches automatically — so this throws; use the SDK
+   * surfaces (or `getAuthToken()` for ad-hoc bearer use) instead.
+   */
+  getApiKey() {
+    if (this.ctx.auth === "cookie" || !this.ctx.key) {
+      throw new Error(
+        "getApiKey() is unavailable in cookie mode \u2014 the app key lives only in the httpOnly cookie. Use the SDK surfaces or getAuthToken() instead."
+      );
+    }
+    return this.ctx.key;
+  }
+  /** API base URL the client targets. */
+  getApiUrl() {
+    return this.ctx.apiUrl;
+  }
+  /**
+   * Mint a short-lived JWT for ad-hoc Bearer use (custom fetch calls,
+   * third-party libraries, WebSocket protocols). Expires after ~15 min —
+   * cache in memory, never persist to localStorage.
+   *
+   * Two mint paths depending on auth mode:
+   *   - **bearer/library** — the raw `uk_`/`ap_` key authenticates better-auth's
+   *     `/api/auth/token` directly.
+   *   - **cookie** — the iframe carries only the httpOnly `__Secure-idapt_app_key`
+   *     cookie, which better-auth's session-based `/api/auth/token` can't see.
+   *     We mint via `/api/browser-app/token` instead (resolves the app principal
+   *     from that cookie). The request rides `credentials: "include"` and sends
+   *     NO empty `Bearer` header.
+   */
+  async getAuthToken() {
+    if (this.ctx.auth === "cookie") {
+      return (await this.fetchAppToken(this.ctx.apiUrl, this.deps.fetch)).token;
+    }
+    const doFetch = this.deps.fetch ?? globalThis.fetch;
+    if (!doFetch) throw new Error("No fetch implementation available");
+    const res = await doFetch(`${this.ctx.apiUrl}/api/auth/token`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.ctx.key}`,
+        "Sec-Fetch-Site": "same-origin"
+      }
+    });
+    if (!res.ok) throw new Error(`getAuthToken failed: ${res.status}`);
+    const body = await res.json();
+    if (!body.token) throw new Error("getAuthToken: missing token in response");
+    return body.token;
+  }
+  /**
+   * Low-level mint against `/api/browser-app/token` — exchanges the httpOnly
+   * app cookie for a short-lived `idapt-api` JWT. Used by the cookie-mode v1
+   * surfaces' token provider AND by `getAuthToken()` in cookie mode.
+   *
+   * Carries the app cookie via `credentials: "include"`; sends `Sec-Fetch-Site:
+   * same-origin` so the server's CSRF guard accepts it (the SDK only ever runs
+   * same-origin under the app subdomain in cookie mode).
+   */
+  async fetchAppToken(apiUrl, fetchImpl) {
+    const doFetch = fetchImpl ?? globalThis.fetch;
+    if (!doFetch) throw new Error("No fetch implementation available");
+    const res = await doFetch(`${apiUrl}/api/browser-app/token`, {
+      method: "GET",
+      headers: { "Sec-Fetch-Site": "same-origin" },
+      credentials: "include"
+    });
+    if (!res.ok) throw new Error(`app token mint failed: ${res.status}`);
+    const body = await res.json();
+    if (!body.token) throw new Error("app token mint: missing token");
+    const expiresAt = typeof body.expiresAt === "number" ? body.expiresAt : Date.now();
+    return { token: body.token, expiresAt };
+  }
+  /**
+   * Build a lazily-minting, self-refreshing app-token provider for the
+   * cookie-mode v1 contexts. Caches the JWT until ~30 s before its stated
+   * expiry; `invalidate()` (wired to the request layer's 401 hook) drops the
+   * cache so the next call re-mints.
+   */
+  makeAppTokenMinter(apiUrl, fetchImpl) {
+    const SKEW_MS = 3e4;
+    let cached = null;
+    let inflight = null;
+    const get = async () => {
+      if (cached && cached.expiresAt - SKEW_MS > Date.now()) {
+        return cached.token;
+      }
+      if (!inflight) {
+        inflight = this.fetchAppToken(apiUrl, fetchImpl).finally(() => {
+          inflight = null;
+        });
+      }
+      const minted = await inflight;
+      cached = minted;
+      return minted.token;
+    };
+    const invalidate = () => {
+      cached = null;
+    };
+    return { get, invalidate };
+  }
+  /**
+   * Request additional scopes at runtime. Navigates to the consent page;
+   * the returned promise never resolves because the page is navigating away.
+   *
+   * The credential doesn't change — principal.authorization is broadened
+   * server-side. When the user lands back in the app, the cached key now
+   * has the new scope.
+   */
+  escalate(permissions) {
+    const appId = this.meta.appId;
+    const url = `${this.ctx.apiUrl.replace(/\/+$/, "")}/apps/${encodeURIComponent(appId)}?standalone_return=1`;
+    this.navigate(url);
+    return new Promise(() => {
+    });
+  }
+  /**
+   * No-op in the cookie-based flow — the `__idapt_app_key` cookie is
+   * httpOnly + server-managed, so the SDK can't clear it from JS. To end a
+   * hosted session, revoke the credential from the main-app Connected Apps
+   * settings.
+   */
+  disconnect() {
+  }
+  navigate(url) {
+    if (this.deps.navigate) {
+      this.deps.navigate(url);
+      return;
+    }
+    if (typeof window !== "undefined") {
+      window.location.href = url;
+    }
+  }
+};
+function deriveAppId(cred, _browserAppDomain) {
+  if (cred.appResourceId) return cred.appResourceId;
+  if (typeof window === "undefined") return "";
+  try {
+    const host = window.location.hostname;
+    return host.split(".")[0]?.toLowerCase() ?? "";
+  } catch {
+    return cred.appFolderId;
+  }
+}
+
+// src/detect.ts
+function detectAppId(browserAppDomain, loc) {
+  const location = loc ?? safeWindowLocation();
+  if (!location) return "";
+  if (browserAppDomain && location.hostname.endsWith(`.${browserAppDomain}`)) {
+    const label = location.hostname.slice(
+      0,
+      location.hostname.length - browserAppDomain.length - 1
+    );
+    return label.toLowerCase();
+  }
+  const first = location.hostname.split(".")[0];
+  return first ? first.toLowerCase() : "";
+}
+function safeWindowLocation() {
+  if (typeof window === "undefined") return void 0;
+  return window.location;
+}
+
+// src/connect.ts
+var NOT_ON_IDAPT = "idapt SDK: not connected \u2014 this app must run on idapt";
+var LOOP_KEY = "idapt:reauth-at";
+var LOOP_WINDOW_MS = 3e4;
+function sessionStorageSafe() {
+  try {
+    if (typeof window === "undefined") return null;
+    return window.sessionStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+function readLoopMarker() {
+  const ss = sessionStorageSafe();
+  if (!ss) return 0;
+  try {
+    const raw = ss.getItem(LOOP_KEY);
+    if (!raw) return 0;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+function writeLoopMarker(ts) {
+  const ss = sessionStorageSafe();
+  if (!ss) return;
+  try {
+    ss.setItem(LOOP_KEY, String(ts));
+  } catch {
+  }
+}
+function clearLoopMarker() {
+  const ss = sessionStorageSafe();
+  if (!ss) return;
+  try {
+    ss.removeItem(LOOP_KEY);
+  } catch {
+  }
+}
+function makeConnect(defaults) {
+  return async function connect3(options = {}) {
+    const apiUrl = options.apiUrl || defaults.apiUrl;
+    const browserAppDomain = options.browserAppDomain !== void 0 ? options.browserAppDomain : defaults.browserAppDomain;
+    const location = resolveLocation(options);
+    if (options.key) {
+      if (!apiUrl) {
+        return Promise.reject(new Error("connect({ key }) requires `apiUrl`"));
+      }
+      return new IdaptClient2({
+        credential: {
+          key: options.key,
+          apiUrl,
+          appResourceId: detectAppId(browserAppDomain, location) || void 0,
+          appFolderId: "",
+          dataFolderId: "",
+          mode: "remote"
+        },
+        browserAppDomain,
+        fetch: options.fetch
+      });
+    }
+    const boot = await readBootstrap(options);
+    if (boot.credential) {
+      clearLoopMarker();
+      return new IdaptClient2({
+        credential: boot.credential,
+        browserAppDomain,
+        fetch: options.fetch
+      });
+    }
+    if (typeof window === "undefined") {
+      return Promise.reject(
+        new Error("connect() requires a browser environment")
+      );
+    }
+    if (!boot.reachable && !boot.authorizeUrl) {
+      return Promise.reject(new Error(NOT_ON_IDAPT));
+    }
+    const lastAttempt = readLoopMarker();
+    if (lastAttempt && Date.now() - lastAttempt < LOOP_WINDOW_MS) {
+      clearLoopMarker();
+      return Promise.reject(
+        new Error(
+          "idapt: connection failed after authorization. The app-key cookie was not delivered back to the server \u2014 this usually means third-party cookies are blocked, an extension is stripping the request, or a CDN is filtering the cookie. Open the app directly in a new tab, or disable third-party cookie blocking for this site."
+        )
+      );
+    }
+    const isEmbedded = (() => {
+      try {
+        return !!window.parent && window.parent !== window;
+      } catch {
+        return false;
+      }
+    })();
+    if (isEmbedded) {
+      try {
+        window.parent.postMessage({ type: "idapt:reauth-needed" }, "*");
+      } catch {
+      }
+      const err2 = new Error(
+        "idapt: bootstrap 401 inside iframe \u2014 waiting for parent to re-provision"
+      );
+      err2.__redirecting = true;
+      return Promise.reject(err2);
+    }
+    const target = buildAuthorizeUrl({
+      serverHint: boot.authorizeUrl,
+      apiUrl,
+      browserAppDomain,
+      location
+    });
+    writeLoopMarker(Date.now());
+    window.location.href = target;
+    const err = new Error(
+      "idapt: redirecting to authorize"
+    );
+    err.__redirecting = true;
+    return Promise.reject(err);
+  };
+}
+async function readBootstrap(options) {
+  const empty = {
+    credential: null,
+    authorizeUrl: null,
+    reachable: false
+  };
+  if (typeof window === "undefined") return empty;
+  const fetcher = options.fetch ?? globalThis.fetch;
+  if (typeof fetcher !== "function") return empty;
+  try {
+    const res = await fetcher("/__idapt__/bootstrap", {
+      credentials: "include"
+    });
+    if (!res.ok) {
+      if (res.status === 401) {
+        const hdr = typeof res.headers?.get === "function" ? res.headers.get("x-idapt-authorize-url") : null;
+        return { credential: null, authorizeUrl: hdr, reachable: true };
+      }
+      return empty;
+    }
+    const body = await res.json().catch(() => null);
+    const appResourceId = typeof body?.appResourceId === "string" ? body.appResourceId : null;
+    if (!appResourceId) {
+      return { credential: null, authorizeUrl: null, reachable: true };
+    }
+    return {
+      credential: {
+        key: null,
+        apiUrl: window.location.origin,
+        appResourceId,
+        appFolderId: "",
+        dataFolderId: "",
+        mode: "remote",
+        auth: "cookie"
+      },
+      authorizeUrl: null,
+      reachable: true
+    };
+  } catch {
+    return empty;
+  }
+}
+function buildAuthorizeUrl(params) {
+  const { serverHint, apiUrl, browserAppDomain, location } = params;
+  if (serverHint && /^https?:\/\//i.test(serverHint)) {
+    return serverHint;
+  }
+  if (serverHint?.startsWith("/")) {
+    const base2 = apiUrl.replace(/\/+$/, "");
+    const url = new URL(serverHint, base2);
+    url.searchParams.set("standalone_return", "1");
+    return url.toString();
+  }
+  const appId = detectAppId(browserAppDomain, location);
+  const base = apiUrl.replace(/\/+$/, "");
+  return `${base}/apps/${encodeURIComponent(appId)}?standalone_return=1`;
+}
+function resolveLocation(options) {
+  if (options.location) return options.location;
+  if (typeof window !== "undefined") return window.location;
+  return {
+    hostname: "",
+    pathname: "",
+    origin: "",
+    href: "",
+    search: ""
+  };
+}
+
+// src/index.ts
+function connect2(options = {}) {
+  return makeConnect({
+    apiUrl: options.apiUrl ?? "",
+    browserAppDomain: options.browserAppDomain ?? ""
+  })(options);
+}
+var IdaptContext = react.createContext({ client: null, error: null });
+function IdaptProvider({
+  children,
+  options,
+  client: injected
+}) {
+  const [state, setState] = react.useState(() => ({
+    client: injected ?? null,
+    error: null
+  }));
+  const optsRef = react.useRef(options);
+  optsRef.current = options;
+  react.useEffect(() => {
+    if (injected) return;
+    let cancelled = false;
+    connect2(optsRef.current ?? {}).then((c) => {
+      if (cancelled) return;
+      setState({ client: c, error: null });
+    }).catch((err) => {
+      if (cancelled) return;
+      setState({
+        client: null,
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [injected]);
+  return /* @__PURE__ */ jsxRuntime.jsx(IdaptContext.Provider, { value: state, children });
+}
+function useIdapt() {
+  return react.useContext(IdaptContext).client;
+}
+function useIdaptError() {
+  return react.useContext(IdaptContext).error;
+}
+function useAppFile(fileId, options = {}) {
+  const client = useIdapt();
+  const { json = false } = options;
+  const [data, setData] = react.useState(null);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const mounted = react.useRef(true);
+  react.useEffect(
+    () => () => {
+      mounted.current = false;
+    },
+    []
+  );
+  const load = react.useCallback(
+    async (signal) => {
+      if (!client || !fileId) {
+        setLoading(false);
+        return;
+      }
+      setLoading(true);
+      setError(null);
+      try {
+        const value = json ? await client.app.readJSON(fileId, { signal }) : await client.app.read(fileId, { signal });
+        if (!mounted.current || signal?.aborted) return;
+        setData(value);
+      } catch (err) {
+        if (!mounted.current || signal?.aborted) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (mounted.current && !signal?.aborted) setLoading(false);
+      }
+    },
+    [client, fileId, json]
+  );
+  react.useEffect(() => {
+    const controller = new AbortController();
+    load(controller.signal);
+    return () => controller.abort();
+  }, [load]);
+  return { data, loading, error, refresh: load };
+}
+function useChannel(key, onEvent) {
+  const client = useIdapt();
+  const [error, setError] = react.useState(null);
+  const onEventRef = react.useRef(onEvent);
+  onEventRef.current = onEvent;
+  react.useEffect(() => {
+    if (!client || !key) return;
+    setError(null);
+    const unsubscribe = client.realtime.subscribe(
+      [key],
+      (event) => onEventRef.current(event),
+      { onError: (err) => setError(err) }
+    );
+    return unsubscribe;
+  }, [client, key]);
+  return { error };
+}
+function useDataFile(name, options = {}) {
+  const client = useIdapt();
+  const { json = true, initial = null, onChange } = options;
+  const [data, setData] = react.useState(initial);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const mounted = react.useRef(true);
+  react.useEffect(
+    () => () => {
+      mounted.current = false;
+    },
+    []
+  );
+  const load = react.useCallback(
+    async (signal) => {
+      if (!client) return;
+      setLoading(true);
+      setError(null);
+      try {
+        const value = json ? await client.data.getJSON(name, { signal }) : await client.data.get(name, { signal });
+        if (!mounted.current || signal?.aborted) return;
+        setData(value);
+        onChange?.(value);
+      } catch (err) {
+        if (!mounted.current || signal?.aborted) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (mounted.current && !signal?.aborted) setLoading(false);
+      }
+    },
+    [client, name, json, onChange]
+  );
+  react.useEffect(() => {
+    const controller = new AbortController();
+    load(controller.signal);
+    return () => controller.abort();
+  }, [load]);
+  const save = react.useCallback(
+    async (value) => {
+      if (!client) throw new Error("Idapt client not connected");
+      if (json) {
+        await client.data.setJSON(name, value);
+      } else {
+        await client.data.set(name, value);
+      }
+      if (!mounted.current) return;
+      setData(value);
+      onChange?.(value);
+    },
+    [client, name, json, onChange]
+  );
+  const remove = react.useCallback(async () => {
+    if (!client) throw new Error("Idapt client not connected");
+    await client.data.remove(name);
+    if (!mounted.current) return;
+    setData(null);
+    onChange?.(null);
+  }, [client, name, onChange]);
+  const refresh = react.useCallback(async () => {
+    if (!client) return;
+    client.data.invalidate();
+    await load();
+  }, [client, load]);
+  return { data, loading, error, save, refresh, remove };
+}
+function useLiveQuery(collectionResId, dsl = {}) {
+  const client = useIdapt();
+  const [records, setRecords] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const dslKey = JSON.stringify(dsl);
+  const dslRef = react.useRef(dsl);
+  dslRef.current = dsl;
+  const [nonce, setNonce] = react.useState(0);
+  react.useEffect(() => {
+    if (!client || !collectionResId) return;
+    let active = true;
+    let inflight = false;
+    let queued = false;
+    const runQuery = async () => {
+      if (inflight) {
+        queued = true;
+        return;
+      }
+      inflight = true;
+      try {
+        const rows = await client.tables.query(collectionResId, dslRef.current);
+        if (!active) return;
+        setRecords(rows);
+        setError(null);
+      } catch (err) {
+        if (!active) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        inflight = false;
+        if (active) setLoading(false);
+        if (active && queued) {
+          queued = false;
+          void runQuery();
+        }
+      }
+    };
+    setLoading(true);
+    void runQuery();
+    const unsubscribe = client.realtime.subscribe(
+      [`table:${collectionResId}`],
+      (event) => {
+        if (event.type !== "broadcast") void runQuery();
+      },
+      { onError: (err) => active && setError(err) }
+    );
+    return () => {
+      active = false;
+      unsubscribe();
+    };
+  }, [client, collectionResId, dslKey, nonce]);
+  return {
+    records,
+    loading,
+    error,
+    refresh: () => setNonce((n) => n + 1)
+  };
+}
+var DEFAULT_INTERVAL_MS = 1e4;
+function usePresence(key, options = {}) {
+  const client = useIdapt();
+  const { meta, intervalMs = DEFAULT_INTERVAL_MS } = options;
+  const [entries, setEntries] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const metaRef = react.useRef(meta);
+  metaRef.current = meta;
+  const metaKey = meta ? JSON.stringify(meta) : "";
+  react.useEffect(() => {
+    if (!client || !key) return;
+    let active = true;
+    setLoading(true);
+    const tick = async () => {
+      try {
+        if (metaRef.current) {
+          await client.realtime.heartbeat(key, { meta: metaRef.current });
+        }
+        const list = await client.realtime.presence(key);
+        if (!active) return;
+        setEntries(list);
+        setError(null);
+      } catch (err) {
+        if (!active) return;
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        if (active) setLoading(false);
+      }
+    };
+    void tick();
+    const timer = setInterval(tick, intervalMs);
+    return () => {
+      active = false;
+      clearInterval(timer);
+    };
+  }, [client, key, intervalMs, metaKey]);
+  return { entries, loading, error };
+}
+
+exports.IdaptProvider = IdaptProvider;
+exports.useAppFile = useAppFile;
+exports.useChannel = useChannel;
+exports.useDataFile = useDataFile;
+exports.useIdapt = useIdapt;
+exports.useIdaptError = useIdaptError;
+exports.useLiveQuery = useLiveQuery;
+exports.usePresence = usePresence;
+//# sourceMappingURL=react.cjs.map
+//# sourceMappingURL=react.cjs.map