@idapt/browser-app-sdk 0.1.0

package/dist/testing.cjs

@@ -0,0 +1,862 @@
+'use strict';
+
+// ../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
+  });
+}
+
+// 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/testing.ts
+function byteLength(s) {
+  return new TextEncoder().encode(s).length;
+}
+var InMemoryDataStore = class {
+  constructor(id, seed) {
+    this.id = id;
+    this.apiUrl = null;
+    /** key (== id == name) → content. */
+    this.entries = /* @__PURE__ */ new Map();
+    if (seed) {
+      for (const [k, v] of Object.entries(seed)) this.entries.set(k, v);
+    }
+  }
+  /** Snapshot of the current KV contents — handy for assertions. */
+  snapshot() {
+    return Object.fromEntries(this.entries);
+  }
+  toFile(key) {
+    return {
+      id: key,
+      name: key,
+      mime_type: "text/plain",
+      file_size: byteLength(this.entries.get(key) ?? "")
+    };
+  }
+  async list() {
+    return [...this.entries.keys()].map((k) => this.toFile(k));
+  }
+  async listFolder() {
+    return [];
+  }
+  async getMetadata(fileId) {
+    if (!this.entries.has(fileId)) {
+      throw new NotFoundError({ message: `No such data file: ${fileId}` });
+    }
+    return this.toFile(fileId);
+  }
+  async read(fileId) {
+    const v = this.entries.get(fileId);
+    if (v === void 0) {
+      throw new NotFoundError({ message: `No such data file: ${fileId}` });
+    }
+    return v;
+  }
+  async readBlob(fileId) {
+    return new Blob([await this.read(fileId)], { type: "text/plain" });
+  }
+  async write(fileId, content) {
+    this.entries.set(fileId, content);
+    return this.toFile(fileId);
+  }
+  async delete(fileId) {
+    this.entries.delete(fileId);
+    return { deleted: true, id: fileId };
+  }
+  async upload(input) {
+    const name = input.name ?? "untitled.txt";
+    const content = typeof input.file.text === "function" ? await input.file.text() : "";
+    this.entries.set(name, content);
+    return {
+      id: name,
+      name,
+      mime_type: "text/plain",
+      file_size: byteLength(content)
+    };
+  }
+  async createFolder(_input) {
+    throw new Error("the mock data KV is flat \u2014 folders are not supported");
+  }
+  async move() {
+    throw new Error("the mock data KV is flat \u2014 folders are not supported");
+  }
+};
+var InMemoryBundleReader = class {
+  constructor(files) {
+    this.id = "mock-app-folder";
+    this.files = new Map(Object.entries(files ?? {}));
+  }
+  toFile(path) {
+    return {
+      id: path,
+      name: path,
+      mime_type: "text/plain",
+      file_size: byteLength(this.files.get(path) ?? "")
+    };
+  }
+  async list() {
+    return [...this.files.keys()].map((p) => this.toFile(p));
+  }
+  async listFolder() {
+    return [];
+  }
+  async read(fileId, _opts) {
+    const v = this.files.get(fileId);
+    if (v === void 0) {
+      throw new NotFoundError({ message: `No such bundle file: ${fileId}` });
+    }
+    return v;
+  }
+  async readJSON(fileId) {
+    return JSON.parse(await this.read(fileId));
+  }
+  async readBlob(fileId) {
+    return new Blob([await this.read(fileId)], { type: "text/plain" });
+  }
+};
+function createMockIdapt(options = {}) {
+  const appId = options.appId ?? "mock-app";
+  const apiUrl = options.apiUrl ?? "https://mock.idapt.app";
+  const dataStore = new InMemoryDataStore(appId, options.data);
+  const bundleReader = new InMemoryBundleReader(options.files);
+  return {
+    data: new DataFolder(dataStore),
+    app: new AppFolder(bundleReader),
+    meta: { appId, apiUrl, mode: "mock" },
+    mode: "mock",
+    _stores: { data: dataStore, bundle: bundleReader }
+  };
+}
+
+exports.InMemoryBundleReader = InMemoryBundleReader;
+exports.InMemoryDataStore = InMemoryDataStore;
+exports.createMockIdapt = createMockIdapt;
+//# sourceMappingURL=testing.cjs.map
+//# sourceMappingURL=testing.cjs.map