@fileway/supabase 0.0.0-stage → 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Azubuike Golden
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,79 @@
-# Temporary Holding Version
+# @fileway/supabase
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/@fileway/supabase?style=flat-square)](https://www.npmjs.com/package/@fileway/supabase)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/@fileway/supabase?style=flat-square)](https://bundlephobia.com/package/@fileway/supabase)
+
+**Supabase Storage driver for [Fileway](https://github.com/Goldenhub/fileway).**
+
+Implemented with `fetch` against the Storage REST and TUS APIs: no `supabase-js` required, so it runs on Node.js, Bun, Deno, and edge runtimes.
+
+```bash
+npm install @fileway/supabase
+```
+
+## Usage
+
+```ts
+import { FilewayClient } from "@fileway/core";
+import { SupabaseDriver } from "@fileway/supabase";
+
+// Server side, with a secret (service role) key: full access, bypasses RLS.
+const driver = new SupabaseDriver({
+  url: "https://<project-ref>.supabase.co",
+  key: process.env.SUPABASE_SECRET_KEY,
+  bucket: "avatars",
+});
+
+const client = new FilewayClient({ driver });
+
+const result = await client.upload(stream, {
+  filename: "photo.jpg",
+  metadata: { userId: "42" }, // stored as the object's user metadata
+});
+```
+
+To act as a signed-in user so the bucket's RLS policies apply, pass the anon or publishable key plus the user's access token:
+
+```ts
+new SupabaseDriver({
+  url: "https://<project-ref>.supabase.co",
+  key: process.env.SUPABASE_PUBLISHABLE_KEY,
+  accessToken: session.access_token,
+  bucket: "avatars",
+});
+```
+
+## Config
+
+| Option         | Type     | Description |
+| -------------- | -------- | ----------- |
+| `url`          | `string` | Project URL (required). `https://<ref>.storage.supabase.co` is faster for large uploads |
+| `key`          | `string` | API key (required): secret / service role, or anon / publishable with `accessToken` |
+| `accessToken`  | `string` | A user's JWT, so RLS policies apply |
+| `bucket`       | `string` | Bucket name (required) |
+| `baseUrl`      | `string` | Public base URL for `getUrl` (default: the bucket's public object URL) |
+| `cacheControl` | `number` | `Cache-Control` max-age in seconds (default `3600`) |
+| `maxSizeBytes` | `number` | Reject larger uploads with a `size-exceeded` error |
+
+## Upload strategy
+
+Uploads always overwrite (`x-upsert`) and memory stays bounded whatever the file size:
+
+- **Up to 6 MiB**: one standard upload request.
+- **Known size above 6 MiB**: a resumable TUS upload in 6 MiB chunks (the size Supabase requires). A failed or cancelled upload is terminated.
+- **Unknown size above 6 MiB**: the stream is sent as the body of one standard upload, without buffering it. Supabase limits standard uploads to 5 GB, so pass `size` for larger files.
+
+If the stream ends before or after a declared `size`, the upload throws a validation error and nothing is stored.
+
+## URLs
+
+`getUrl()` returns the public object URL, which only works for public buckets. For private buckets use `getPresignedUrl()` (a Supabase signed URL) or `get()`.
+
+## Upload status
+
+`pathFor` and `head` are implemented, so `client.getUploadStatus()` reports `complete` or `missing`, and lost upload responses are recovered without uploading twice.
+
+## Resources
+
+- [Documentation](https://www.usefileway.dev/docs/drivers/supabase)
+- [License: MIT](https://github.com/Goldenhub/fileway/blob/main/LICENSE)

package/dist/index.cjs

@@ -0,0 +1,486 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SupabaseDriver: () => SupabaseDriver
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+function classifySupabaseError(status, body) {
+  let parsed = {};
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+  }
+  const text = `${parsed.error ?? ""} ${parsed.message ?? ""} ${parsed.error === void 0 ? body : ""}`.toLowerCase();
+  const code = Number(parsed.statusCode ?? status);
+  if (text.includes("bucket not found")) return "bucket-not-found";
+  if (code === 409 || text.includes("already exists") || text.includes("duplicate")) return "conflict";
+  if (text.includes("not found") || text.includes("not_found") || text.includes("no such")) return "not-found";
+  if (text.includes("exceeded the maximum allowed size") || text.includes("payload too large") || code === 413) {
+    return "size-exceeded";
+  }
+  if (code === 401 || code === 403 || text.includes("jwt") || text.includes("unauthorized") || text.includes("row-level security")) {
+    return "auth-failed";
+  }
+  if (code === 429 || text.includes("too many requests")) return "rate-limited";
+  if (code === 404) return "not-found";
+  return "provider-error";
+}
+
+// src/index.ts
+var import_core = require("@fileway/core");
+var randomUUID = () => globalThis.crypto.randomUUID();
+var PROVIDER = "supabase";
+var TUS_CHUNK_SIZE = 6 * 1024 * 1024;
+var TUS_VERSION = "1.0.0";
+var PRESIGN_DEFAULT_EXPIRY = 3600;
+var TOKEN_KEY = "fileway-upload-token";
+var MAX_CHUNK_RESENDS = 3;
+var SupabaseDriver = class {
+  name = "supabase";
+  api;
+  bucket;
+  baseUrl;
+  headers;
+  maxSizeBytes;
+  cacheControl;
+  constructor(config) {
+    if (!config.url || !config.key || !config.bucket) {
+      throw new import_core.StorageError("config", "SupabaseDriver requires url, key and bucket", { provider: PROVIDER });
+    }
+    this.api = `${config.url.replace(/\/+$/, "")}/storage/v1`;
+    this.bucket = config.bucket;
+    this.baseUrl = (config.baseUrl ?? `${this.api}/object/public/${config.bucket}`).replace(/\/+$/, "");
+    const bearer = config.accessToken ?? (config.key.startsWith("eyJ") ? config.key : void 0);
+    this.headers = { apikey: config.key, ...bearer ? { authorization: `Bearer ${bearer}` } : {} };
+    this.maxSizeBytes = config.maxSizeBytes;
+    this.cacheControl = `max-age=${config.cacheControl ?? 3600}`;
+  }
+  async upload(stream, options, context) {
+    (0, import_core.validateUploadOptions)(options);
+    if (this.maxSizeBytes !== void 0 && options.size !== void 0 && options.size > this.maxSizeBytes) {
+      throw new import_core.StorageError("size-exceeded", `file size ${options.size} exceeds maxSizeBytes ${this.maxSizeBytes}`, { provider: PROVIDER });
+    }
+    const id = options.id ?? randomUUID();
+    const path = this.pathFor({ ...options, id });
+    const contentType = options.mimeType ?? "application/octet-stream";
+    const metadata = { ...options.metadata, ...context?.uploadToken ? { [TOKEN_KEY]: context.uploadToken } : {} };
+    const signal = options.signal;
+    const reader = stream.getReader();
+    let aborted = signal?.aborted ?? false;
+    const onAbort = () => {
+      aborted = true;
+      reader.cancel().catch(() => {
+      });
+    };
+    if (signal && !aborted) signal.addEventListener("abort", onAbort, { once: true });
+    let totalBytes = 0;
+    const read = async () => {
+      const { done, value } = await reader.read();
+      if (aborted) throw (0, import_core.abortError)("upload aborted");
+      if (done) return void 0;
+      totalBytes += value.byteLength;
+      if (this.maxSizeBytes !== void 0 && totalBytes > this.maxSizeBytes) {
+        throw new import_core.StorageError("size-exceeded", `upload exceeds maxSizeBytes ${this.maxSizeBytes}`, { provider: PROVIDER });
+      }
+      return value;
+    };
+    const checkSize = () => {
+      if (options.size !== void 0 && totalBytes !== options.size) {
+        throw new import_core.ValidationError(`stream delivered ${totalBytes} bytes, expected ${options.size}`);
+      }
+    };
+    let tusUrl;
+    try {
+      let etag;
+      if (options.size !== void 0 && options.size > TUS_CHUNK_SIZE) {
+        tusUrl = await this.createTusUpload(path, options.size, contentType, metadata, signal);
+        let buffer = [];
+        let bufferedLen = 0;
+        let offset = 0;
+        while (true) {
+          const value = await read();
+          if (totalBytes > options.size) checkSize();
+          if (value) {
+            buffer.push(value);
+            bufferedLen += value.byteLength;
+          }
+          while (bufferedLen >= TUS_CHUNK_SIZE || !value && bufferedLen > 0) {
+            if (!value) checkSize();
+            const merged = concatBytes(buffer, bufferedLen);
+            const take = Math.min(TUS_CHUNK_SIZE, bufferedLen);
+            offset = await this.patchTus(tusUrl, merged.subarray(0, take), offset, signal);
+            const rest = merged.subarray(take);
+            buffer = [rest];
+            bufferedLen = rest.byteLength;
+          }
+          if (!value) break;
+        }
+        checkSize();
+      } else {
+        const first = [];
+        let firstLen = 0;
+        let ended = false;
+        while (firstLen <= TUS_CHUNK_SIZE) {
+          const value = await read();
+          if (!value) {
+            ended = true;
+            break;
+          }
+          first.push(value);
+          firstLen += value.byteLength;
+        }
+        const head = concatBytes(first, firstLen);
+        if (ended) {
+          checkSize();
+          etag = await this.standardUpload(path, head, contentType, metadata, signal);
+        } else {
+          checkSize();
+          const bodyError = {};
+          const body = new ReadableStream({
+            start(controller) {
+              controller.enqueue(head);
+            },
+            async pull(controller) {
+              try {
+                const value = await read();
+                if (value) controller.enqueue(value);
+                else controller.close();
+              } catch (err) {
+                bodyError.current = err;
+                controller.error(err);
+              }
+            },
+            cancel(reason) {
+              return reader.cancel(reason);
+            }
+          });
+          try {
+            etag = await this.standardUpload(path, body, contentType, metadata, signal);
+          } catch (err) {
+            if (bodyError.current) throw bodyError.current;
+            throw err;
+          }
+          checkSize();
+        }
+      }
+      return {
+        id,
+        url: `${this.baseUrl}/${(0, import_core.urlEncodePath)(path)}`,
+        path,
+        size: totalBytes,
+        meta: { bucket: this.bucket, ...etag ? { etag } : {} }
+      };
+    } catch (err) {
+      reader.cancel().catch(() => {
+      });
+      if (tusUrl) {
+        await fetch(tusUrl, { method: "DELETE", headers: { ...this.headers, "tus-resumable": TUS_VERSION } }).catch(() => {
+        });
+      }
+      throw err;
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  /** `POST /object/{bucket}/{path}`, overwriting any existing object. */
+  async standardUpload(path, body, contentType, metadata, signal) {
+    const res = await fetchWithAbort(this.objectUrl("object", path), {
+      method: "POST",
+      headers: {
+        ...this.headers,
+        "content-type": contentType,
+        "cache-control": this.cacheControl,
+        "x-upsert": "true",
+        "x-metadata": base64(JSON.stringify(metadata))
+      },
+      body,
+      // Node's fetch (undici) requires `duplex: "half"` for stream bodies;
+      // other runtimes ignore it.
+      duplex: "half",
+      signal: signal ?? null
+    });
+    if (!res.ok) throw await supabaseError("Supabase upload failed", res);
+    return res.headers.get("etag") ?? void 0;
+  }
+  /** Creates a TUS upload and returns its URL. */
+  async createTusUpload(path, size, contentType, metadata, signal) {
+    const endpoint = `${this.api}/upload/resumable`;
+    const uploadMetadata = {
+      bucketName: this.bucket,
+      objectName: path,
+      contentType,
+      cacheControl: this.cacheControl.replace("max-age=", ""),
+      metadata: JSON.stringify(metadata)
+    };
+    const res = await fetchWithAbort(endpoint, {
+      method: "POST",
+      headers: {
+        ...this.headers,
+        "tus-resumable": TUS_VERSION,
+        "upload-length": String(size),
+        "upload-metadata": Object.entries(uploadMetadata).map(([k, v]) => `${k} ${base64(v)}`).join(","),
+        "x-upsert": "true"
+      },
+      signal: signal ?? null
+    });
+    if (!res.ok) throw await supabaseError("Supabase resumable upload create failed", res);
+    const location = res.headers.get("location");
+    if (!location) {
+      throw new import_core.StorageError("provider-error", "Supabase resumable upload returned no Location header", { provider: PROVIDER });
+    }
+    return new URL(location, endpoint).href;
+  }
+  /** PATCHes `bytes` at `offset`, resending whatever the server did not store.
+   * Returns the new offset. */
+  async patchTus(url, bytes, offset, signal) {
+    const end = offset + bytes.byteLength;
+    let current = offset;
+    for (let attempt = 0; attempt <= MAX_CHUNK_RESENDS && current < end; attempt++) {
+      const res = await fetchWithAbort(url, {
+        method: "PATCH",
+        headers: {
+          ...this.headers,
+          "tus-resumable": TUS_VERSION,
+          "upload-offset": String(current),
+          "content-type": "application/offset+octet-stream"
+        },
+        body: bytes.subarray(current - offset),
+        signal: signal ?? null
+      });
+      if (!res.ok) throw await supabaseError("Supabase resumable upload chunk failed", res);
+      const next = Number(res.headers.get("upload-offset") ?? end);
+      if (next < current) break;
+      current = next;
+    }
+    if (current < end) {
+      throw new import_core.StorageError("provider-error", "Supabase did not store the uploaded chunk", { provider: PROVIDER });
+    }
+    return current;
+  }
+  /** Deletes the object; a missing object is not an error. */
+  async delete(path, options) {
+    const res = await fetchWithAbort(`${this.api}/object/${encodeURIComponent(this.bucket)}`, {
+      method: "DELETE",
+      headers: { ...this.headers, "content-type": "application/json" },
+      body: JSON.stringify({ prefixes: [path] }),
+      signal: options?.signal ?? null
+    });
+    if (!res.ok) throw await supabaseError("Supabase delete failed", res);
+  }
+  async getUrl(path, _options) {
+    return `${this.baseUrl}/${(0, import_core.urlEncodePath)(path)}`;
+  }
+  /** Streams the object. `options.signal` also cancels reading the body. */
+  async get(path, options) {
+    const res = await fetchWithAbort(this.objectUrl("object/authenticated", path), {
+      headers: this.headers,
+      signal: options?.signal ?? null
+    });
+    if (!res.ok) throw await supabaseError("Supabase get failed", res);
+    if (!res.body) {
+      throw new import_core.StorageError("provider-error", "Supabase get returned no response body", { provider: PROVIDER });
+    }
+    return res.body;
+  }
+  /** A signed download URL for `path`, valid for `expiresIn` seconds (positive integer, default 3600). */
+  async getPresignedUrl(path, options) {
+    const expiresIn = options?.expiresIn ?? PRESIGN_DEFAULT_EXPIRY;
+    if (!Number.isInteger(expiresIn) || expiresIn < 1) {
+      throw new import_core.ValidationError("expiresIn must be a positive integer number of seconds");
+    }
+    const res = await fetchWithAbort(this.objectUrl("object/sign", path), {
+      method: "POST",
+      headers: { ...this.headers, "content-type": "application/json" },
+      body: JSON.stringify({ expiresIn }),
+      signal: options?.signal ?? null
+    });
+    if (!res.ok) throw await supabaseError("Supabase sign failed", res);
+    const { signedURL } = await res.json();
+    if (!signedURL) {
+      throw new import_core.StorageError("provider-error", "Supabase sign returned no signedURL", { provider: PROVIDER });
+    }
+    return `${this.api}${signedURL.startsWith("/") ? "" : "/"}${signedURL}`;
+  }
+  /** The object name an upload with `options.id` is stored under: `<path>/<id>.<ext>`. */
+  pathFor(options) {
+    const ext = options.filename.includes(".") ? options.filename.split(".").pop() : "";
+    const filename = ext ? `${options.id}.${ext}` : options.id;
+    return options.path ? `${options.path}/${filename}` : filename;
+  }
+  /** The object at `path` (`GET /object/info`), or `null` if it does not exist. */
+  async head(path, options) {
+    const res = await fetchWithAbort(this.objectUrl("object/info", path), {
+      headers: this.headers,
+      signal: options?.signal ?? null
+    });
+    if (!res.ok) {
+      const error = await supabaseError("Supabase info failed", res);
+      if (error.code === "not-found") return null;
+      throw error;
+    }
+    const info = await res.json();
+    const name = path.split("/").pop() ?? path;
+    const token = info.metadata?.[TOKEN_KEY];
+    return {
+      id: name.includes(".") ? name.slice(0, name.lastIndexOf(".")) : name,
+      url: `${this.baseUrl}/${(0, import_core.urlEncodePath)(path)}`,
+      path,
+      size: Number(info.size ?? 0),
+      meta: { bucket: this.bucket, ...info.etag ? { etag: info.etag } : {} },
+      ...token ? { uploadToken: token } : {},
+      ...info.last_modified ? { lastModified: new Date(info.last_modified) } : {},
+      ...info.content_type ? { contentType: info.content_type } : {}
+    };
+  }
+  /**
+   * One page of the objects under `options.prefix`. Supabase lists one folder
+   * at a time, so `recursive: true` walks folders in turn: results come folder
+   * by folder rather than in one global sort order.
+   */
+  async list(options) {
+    const prefix = options?.prefix ?? "";
+    const limit = options?.limit ?? 100;
+    const cut = prefix.lastIndexOf("/") + 1;
+    const top = prefix.slice(0, cut);
+    const namePart = prefix.slice(cut);
+    const state = options?.cursor !== void 0 ? (0, import_core.decodeCursor)(options.cursor) : { queue: [top], offset: 0 };
+    const objects = [];
+    const folders = [];
+    while (state.queue.length > 0 && objects.length + folders.length < limit) {
+      const folder = state.queue[0];
+      const want = limit - objects.length - folders.length;
+      const search = folder === top ? namePart : "";
+      const items = await this.listFolder(folder, state.offset, want, search, options?.signal);
+      for (const item of items) {
+        if (!item.name.startsWith(search)) continue;
+        if (item.id === null) {
+          if (options?.recursive) state.queue.push(`${folder}${item.name}/`);
+          else folders.push(`${folder}${item.name}/`);
+          continue;
+        }
+        const modified = item.metadata?.lastModified ?? item.updated_at;
+        const etag = item.metadata?.eTag;
+        const type = item.metadata?.mimetype;
+        objects.push({
+          path: `${folder}${item.name}`,
+          size: Number(item.metadata?.size ?? 0),
+          ...modified ? { lastModified: new Date(modified) } : {},
+          ...etag ? { etag } : {},
+          ...type ? { contentType: type } : {}
+        });
+      }
+      if (items.length < want) {
+        state.queue.shift();
+        state.offset = 0;
+        if (!options?.recursive) break;
+      } else {
+        state.offset += items.length;
+      }
+    }
+    return { objects, folders, ...state.queue.length > 0 ? { cursor: (0, import_core.encodeCursor)(state) } : {} };
+  }
+  /**
+   * Copies an object in this bucket. With `overwrite: false` the destination is
+   * checked first, which is not atomic; with `overwrite: true` an existing
+   * destination is replaced.
+   */
+  async copy(from, to, options) {
+    await this.transfer("copy", from, to, options);
+  }
+  /** Moves (renames) an object in this bucket, with the same overwrite rules as `copy`. */
+  async move(from, to, options) {
+    await this.transfer("move", from, to, options);
+  }
+  async transfer(op, from, to, options) {
+    if (from === to) throw new import_core.ValidationError("from and to must be different paths");
+    const signal = options?.signal;
+    const exists = await this.head(to, signal ? { signal } : void 0);
+    if (exists && !options?.overwrite) {
+      throw new import_core.StorageError("conflict", `Supabase ${op} failed: ${to} already exists`, { provider: PROVIDER });
+    }
+    if (exists) await this.delete(to, signal ? { signal } : void 0);
+    const res = await fetchWithAbort(`${this.api}/object/${op}`, {
+      method: "POST",
+      headers: { ...this.headers, "content-type": "application/json" },
+      body: JSON.stringify({ bucketId: this.bucket, sourceKey: from, destinationKey: to }),
+      signal: signal ?? null
+    });
+    if (!res.ok) throw await supabaseError(`Supabase ${op} failed`, res);
+  }
+  async listFolder(folder, offset, limit, search, signal) {
+    const res = await fetchWithAbort(`${this.api}/object/list/${encodeURIComponent(this.bucket)}`, {
+      method: "POST",
+      headers: { ...this.headers, "content-type": "application/json" },
+      body: JSON.stringify({
+        prefix: folder.replace(/\/$/, ""),
+        limit,
+        offset,
+        sortBy: { column: "name", order: "asc" },
+        ...search ? { search } : {}
+      }),
+      signal: signal ?? null
+    });
+    if (!res.ok) throw await supabaseError("Supabase list failed", res);
+    return await res.json();
+  }
+  objectUrl(route, path) {
+    return `${this.api}/${route}/${encodeURIComponent(this.bucket)}/${(0, import_core.urlEncodePath)(path)}`;
+  }
+};
+async function fetchWithAbort(url, init) {
+  try {
+    return await fetch(url, init);
+  } catch (err) {
+    if ((0, import_core.isAbortError)(err)) throw err;
+    const cause = err instanceof Error ? err : new Error(String(err));
+    throw new import_core.StorageError("network", `${PROVIDER} network error: ${cause.message}`, { provider: PROVIDER, cause });
+  }
+}
+async function supabaseError(prefix, res) {
+  const body = await res.text().catch(() => "");
+  return new import_core.StorageError(
+    classifySupabaseError(res.status, body),
+    `${prefix}: ${res.status} ${res.statusText}${body ? `: ${body}` : ""}`,
+    { statusCode: res.status, provider: PROVIDER }
+  );
+}
+function base64(value) {
+  let binary = "";
+  for (const byte of new TextEncoder().encode(value)) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function concatBytes(chunks, total) {
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SupabaseDriver
+});
+//# sourceMappingURL=index.cjs.map