hyperdb-wasm 0.0.26284-dev.wasm.gf1f9d795 → 0.0.26298-dev.wasm.gd63c7938

package/dist/api.d.ts

@@ -7,12 +7,20 @@ export interface HyperDBClient {
     ready(): Promise<void>;
     connect(): Promise<WasmResult>;
     disconnect(connection: number): Promise<WasmResult>;
+    createDatabase(databaseName: string, persistent: boolean): Promise<WasmResult>;
+    openDatabase(databaseName: string): Promise<WasmResult>;
+    checkpointDatabase(databaseName: string): Promise<WasmResult>;
+    dropDatabase(databaseName: string): Promise<WasmResult>;
+    attachDatabase(connection: number, databaseName: string, alias: string): Promise<WasmResult>;
+    detachDatabase(connection: number, alias: string): Promise<WasmResult>;
     startQuery(connection: number, sql: string): Promise<WasmResult>;
-    appendArrowIPC(connection: number, chunk: Uint8Array): Promise<WasmResult>;
-    finishArrowIPC(connection: number, name: string, schema: string | null, create: boolean): Promise<WasmResult>;
+    insertArrowIPCFromPath(connection: number, path: string, name: string, schema: string | null, create: boolean, internal?: boolean): Promise<WasmResult>;
+    createTemporaryFile(bytes: Uint8Array): Promise<WasmResult>;
+    removeFile(path: string): Promise<WasmResult>;
     pollQuery(query: number): Promise<WasmResult>;
     cancelQuery(query: number): Promise<WasmResult>;
     releaseQuery(query: number): Promise<WasmResult>;
+    shutdown(): Promise<WasmResult>;
     terminate(): Promise<void>;
 }
 export interface ArrowInsertOptions {
@@ -20,17 +28,26 @@ export interface ArrowInsertOptions {
     readonly schema?: string;
     readonly create?: boolean;
 }
+export interface DatabaseCreateOptions {
+    readonly storage?: 'memory' | 'persistent';
+}
 export declare class HyperDB {
     private readonly client;
     private terminated;
     private termination;
+    private activeDatabaseOperations;
     private readonly connections;
     constructor(client: HyperDBClient);
     static create(options?: BrowserClientOptions): Promise<HyperDB>;
     ready(): Promise<void>;
     connect(): Promise<HyperDBConnection>;
+    createDatabase(databaseName: string, options?: DatabaseCreateOptions): Promise<void>;
+    openDatabase(databaseName: string): Promise<void>;
+    checkpointDatabase(databaseName: string): Promise<void>;
+    dropDatabase(databaseName: string): Promise<void>;
     terminate(): Promise<void>;
     private ensureRunning;
+    private runDatabaseOperation;
 }
 export declare class HyperDBConnection {
     private readonly client;
@@ -38,11 +55,11 @@ export declare class HyperDBConnection {
     private readonly onClose;
     private closed;
     private active;
-    private arrowInsertOptions;
-    private appendingArrow;
     private closing;
     constructor(client: HyperDBClient, connection: number, onClose?: () => void);
     close(): Promise<void>;
+    attachDatabase(databaseName: string, alias?: string): Promise<void>;
+    detachDatabase(alias: string): Promise<void>;
     sendIPC(sql: string): AsyncIterable<Uint8Array>;
     queryIPC(sql: string): Promise<Uint8Array>;
     send<T extends TypeMap = {
@@ -52,8 +69,8 @@ export declare class HyperDBConnection {
         [key: string]: DataType;
     }>(sql: string): Promise<Table<T>>;
     insertArrowTable(table: Table, options: ArrowInsertOptions): Promise<void>;
-    insertArrowFromIPCStream(chunk: Uint8Array, options: ArrowInsertOptions): Promise<void>;
-    finishArrowIPCStream(options?: ArrowInsertOptions): Promise<void>;
+    insertArrowIPCFromPath(path: string, options: ArrowInsertOptions): Promise<void>;
+    private insertArrowIPCFromPathInternal;
     private ensureAvailable;
     private release;
     closeForTermination(): Promise<void>;

package/dist/browser.js

@@ -95,15 +95,39 @@ var init_client = __esm({
       disconnect(connection) {
         return this.request({ id: this.nextId++, type: "disconnect", connection });
       }
+      createDatabase(databaseName, persistent) {
+        return this.request({ id: this.nextId++, type: "createDatabase", databaseName, persistent });
+      }
+      openDatabase(databaseName) {
+        return this.request({ id: this.nextId++, type: "openDatabase", databaseName });
+      }
+      checkpointDatabase(databaseName) {
+        return this.request({ id: this.nextId++, type: "checkpointDatabase", databaseName });
+      }
+      dropDatabase(databaseName) {
+        return this.request({ id: this.nextId++, type: "dropDatabase", databaseName });
+      }
+      attachDatabase(connection, databaseName, alias) {
+        return this.request({ id: this.nextId++, type: "attachDatabase", connection, databaseName, alias });
+      }
+      detachDatabase(connection, alias) {
+        return this.request({ id: this.nextId++, type: "detachDatabase", connection, alias });
+      }
+      shutdown() {
+        return this.request({ id: this.nextId++, type: "shutdown" });
+      }
       startQuery(connection, sql) {
         return this.request({ id: this.nextId++, type: "startQuery", connection, sql });
       }
-      appendArrowIPC(connection, chunk) {
-        const payload = chunk.slice();
-        return this.request({ id: this.nextId++, type: "appendArrowIPC", connection, chunk: payload }, [payload.buffer]);
+      insertArrowIPCFromPath(connection, path, name, schema, create, internal = false) {
+        return this.request({ id: this.nextId++, type: "insertArrowIPCFromPath", connection, path, name, schema, create, internal });
       }
-      finishArrowIPC(connection, name, schema, create) {
-        return this.request({ id: this.nextId++, type: "finishArrowIPC", connection, name, schema, create });
+      createTemporaryFile(bytes) {
+        const payload = bytes.slice();
+        return this.request({ id: this.nextId++, type: "createTemporaryFile", bytes: payload }, [payload.buffer]);
+      }
+      removeFile(path) {
+        return this.request({ id: this.nextId++, type: "removeFile", path });
       }
       pollQuery(query) {
         return this.request({ id: this.nextId++, type: "pollQuery", query });
@@ -12054,8 +12078,13 @@ function normalizeArrowInsertOptions(options) {
   if (!options.name) throw new Error("Arrow insert table name must not be empty");
   return { name: options.name, schema: options.schema ?? null, create: options.create ?? true };
 }
-function equalArrowInsertOptions(left, right) {
-  return left.name === right.name && left.schema === right.schema && left.create === right.create;
+function validateDatabaseName(databaseName) {
+  if (!databaseName) throw new Error("Database name must not be empty");
+  if (databaseName.includes("\0")) throw new Error("Database name must not contain NUL");
+}
+function validateDatabaseAlias(alias) {
+  if (!alias) throw new Error("Database alias must not be empty");
+  if (alias.includes("\0")) throw new Error("Database alias must not contain NUL");
 }
 function materializeDictionaryColumns(table) {
   const dictionaryColumns = table.schema.fields.map((field, index) => DataType.isDictionary(field.type) ? index : -1).filter((index) => index !== -1);
@@ -12097,6 +12126,7 @@ var HyperDB = class _HyperDB {
   client;
   terminated = false;
   termination;
+  activeDatabaseOperations = 0;
   connections = /* @__PURE__ */ new Set();
   static async create(options = {}) {
     const { createBrowserClient: createBrowserClient2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
@@ -12115,8 +12145,36 @@ var HyperDB = class _HyperDB {
     this.connections.add(result);
     return result;
   }
+  async createDatabase(databaseName, options = {}) {
+    validateDatabaseName(databaseName);
+    if (options.storage !== void 0 && options.storage !== "memory" && options.storage !== "persistent") {
+      throw new Error(`Unsupported database storage: ${String(options.storage)}`);
+    }
+    await this.runDatabaseOperation(async () => {
+      expectOk(await this.client.createDatabase(databaseName, options.storage === "persistent"), "create database");
+    });
+  }
+  async openDatabase(databaseName) {
+    validateDatabaseName(databaseName);
+    await this.runDatabaseOperation(async () => {
+      expectOk(await this.client.openDatabase(databaseName), "open database");
+    });
+  }
+  async checkpointDatabase(databaseName) {
+    validateDatabaseName(databaseName);
+    await this.runDatabaseOperation(async () => {
+      expectOk(await this.client.checkpointDatabase(databaseName), "checkpoint database");
+    });
+  }
+  async dropDatabase(databaseName) {
+    validateDatabaseName(databaseName);
+    await this.runDatabaseOperation(async () => {
+      expectOk(await this.client.dropDatabase(databaseName), "drop database");
+    });
+  }
   async terminate() {
     if (this.terminated) return;
+    if (this.activeDatabaseOperations !== 0) throw new Error("database has an active operation");
     if (!this.termination) {
       this.termination = (async () => {
         try {
@@ -12125,6 +12183,12 @@ var HyperDB = class _HyperDB {
           this.termination = void 0;
           throw error;
         }
+        try {
+          expectOk(await this.client.shutdown(), "shutdown");
+        } catch (error) {
+          this.termination = void 0;
+          throw error;
+        }
         this.terminated = true;
         await this.client.terminate();
       })();
@@ -12133,6 +12197,16 @@ var HyperDB = class _HyperDB {
   }
   ensureRunning() {
     if (this.terminated) throw new Error("database is terminated");
+    if (this.termination) throw new Error("database is terminating");
+  }
+  async runDatabaseOperation(operation) {
+    this.ensureRunning();
+    ++this.activeDatabaseOperations;
+    try {
+      await operation();
+    } finally {
+      --this.activeDatabaseOperations;
+    }
   }
 };
 var HyperDBConnection = class {
@@ -12146,13 +12220,10 @@ var HyperDBConnection = class {
   onClose;
   closed = false;
   active = false;
-  arrowInsertOptions;
-  appendingArrow = false;
   closing;
   async close() {
     if (this.closed) return;
-    if (this.active) throw new Error("connection has an active query");
-    if (this.arrowInsertOptions) throw new Error("connection has an unfinished Arrow IPC stream");
+    if (this.active) throw new Error("connection has an active operation");
     if (!this.closing) {
       this.closing = (async () => {
         try {
@@ -12167,6 +12238,25 @@ var HyperDBConnection = class {
     }
     await this.closing;
   }
+  async attachDatabase(databaseName, alias = databaseName) {
+    validateDatabaseName(databaseName);
+    validateDatabaseAlias(alias);
+    this.ensureAvailable();
+    try {
+      expectOk(await this.client.attachDatabase(this.connection, databaseName, alias), "attach database");
+    } finally {
+      this.active = false;
+    }
+  }
+  async detachDatabase(alias) {
+    validateDatabaseAlias(alias);
+    this.ensureAvailable();
+    try {
+      expectOk(await this.client.detachDatabase(this.connection, alias), "detach database");
+    } finally {
+      this.active = false;
+    }
+  }
   sendIPC(sql) {
     const connection = this;
     return {
@@ -12254,41 +12344,31 @@ var HyperDBConnection = class {
     return new Table(reader.schema, batches);
   }
   async insertArrowTable(table, options) {
-    await this.insertArrowFromIPCStream(tableToIPC(materializeDictionaryColumns(table), "stream"), options);
-    await this.finishArrowIPCStream();
-  }
-  async insertArrowFromIPCStream(chunk, options) {
-    if (this.closed) throw new Error("connection is closed");
-    if (this.closing) throw new Error("connection is closing");
-    if (this.active) throw new Error("connection has an active query");
-    if (this.appendingArrow) throw new Error("connection is appending Arrow IPC");
-    const normalized = normalizeArrowInsertOptions(options);
-    if (this.arrowInsertOptions && !equalArrowInsertOptions(this.arrowInsertOptions, normalized)) {
-      throw new Error("Arrow insert options must match the pending stream");
-    }
-    this.appendingArrow = true;
+    this.ensureAvailable();
+    let path;
     try {
-      expectOk(await this.client.appendArrowIPC(this.connection, chunk), "append Arrow IPC");
-      this.arrowInsertOptions = normalized;
+      const result = await this.client.createTemporaryFile(tableToIPC(materializeDictionaryColumns(table), "stream"));
+      expectOk(result, "create temporary Arrow IPC file");
+      path = new TextDecoder().decode(result.payload);
+      await this.insertArrowIPCFromPathInternal(path, options, true, false);
     } finally {
-      this.appendingArrow = false;
+      try {
+        if (path !== void 0) expectOk(await this.client.removeFile(path), "remove temporary Arrow IPC file");
+      } finally {
+        this.active = false;
+      }
     }
   }
-  async finishArrowIPCStream(options) {
-    if (this.closed) throw new Error("connection is closed");
-    if (this.closing) throw new Error("connection is closing");
-    if (this.active) throw new Error("connection has an active query");
-    if (this.appendingArrow) throw new Error("connection is appending Arrow IPC");
-    const normalized = options ? normalizeArrowInsertOptions(options) : this.arrowInsertOptions;
-    if (!normalized) throw new Error("connection has no Arrow IPC input");
-    if (this.arrowInsertOptions && !equalArrowInsertOptions(this.arrowInsertOptions, normalized)) {
-      throw new Error("Arrow insert options must match the pending stream");
-    }
-    this.active = true;
+  async insertArrowIPCFromPath(path, options) {
+    await this.insertArrowIPCFromPathInternal(path, options, false);
+  }
+  async insertArrowIPCFromPathInternal(path, options, internal, acquire = true) {
+    if (!path) throw new Error("Arrow IPC input path must not be empty");
+    const normalized = normalizeArrowInsertOptions(options);
+    if (acquire) this.ensureAvailable();
     let query;
     try {
-      query = readHandleFromResult(await this.client.finishArrowIPC(this.connection, normalized.name, normalized.schema, normalized.create), "finish Arrow IPC");
-      this.arrowInsertOptions = void 0;
+      query = readHandleFromResult(await this.client.insertArrowIPCFromPath(this.connection, path, normalized.name, normalized.schema, normalized.create, internal), "insert Arrow IPC from path");
       for (; ; ) {
         let result = await this.client.pollQuery(query);
         while (result.state === "pending") {
@@ -12297,13 +12377,13 @@ var HyperDBConnection = class {
         }
         if (result.state === "done") return;
         if (result.state === "chunk") continue;
-        throw readErrorFromResult(result, "finish Arrow IPC");
+        throw readErrorFromResult(result, "insert Arrow IPC from path");
       }
     } finally {
       try {
         if (query !== void 0) await this.release(query);
       } finally {
-        this.active = false;
+        if (acquire) this.active = false;
       }
     }
   }
@@ -12311,7 +12391,7 @@ var HyperDBConnection = class {
     if (this.closed) throw new Error("connection is closed");
     if (this.closing) throw new Error("connection is closing");
     if (this.active) {
-      throw new Error("connection has an active query");
+      throw new Error("connection has an active operation");
     }
     this.active = true;
   }
@@ -12326,8 +12406,7 @@ var HyperDBConnection = class {
     }
   }
   async closeForTermination() {
-    if (this.active) throw new Error("cannot terminate while a connection has an active query");
-    if (this.arrowInsertOptions) throw new Error("cannot terminate while a connection has an unfinished Arrow IPC stream");
+    if (this.active) throw new Error("cannot terminate while a connection has an active operation");
     await this.close();
   }
 };

package/dist/browser_worker.js

@@ -7,26 +7,43 @@
     if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 0) throw new Error(`${name} must be a nonnegative safe integer`);
     return number;
   }
+  function validateCString(value, name) {
+    if (!value) throw new Error(`${name} must not be empty`);
+    if (value.includes("\0")) throw new Error(`${name} must not contain NUL`);
+  }
   var HyperDBBindings = class {
     module;
     connect;
     disconnect;
+    createDatabase;
+    openDatabase;
+    checkpointDatabase;
+    dropDatabase;
+    shutdown;
+    attachDatabase;
+    detachDatabase;
     startQuery;
-    appendArrowIPC;
-    finishArrowIPC;
+    insertArrowIPCFromPath;
     pollQuery;
     cancelQuery;
     releaseQuery;
     resultState;
     resultPayloadLength;
     free;
+    nextTemporaryFile = 1;
     constructor(module) {
       this.module = module;
       this.connect = module.cwrap("hyperdb_wasm_connect", "pointer", []);
       this.disconnect = module.cwrap("hyperdb_wasm_disconnect", "pointer", ["number"]);
+      this.createDatabase = module.cwrap("hyperdb_wasm_create_database", "pointer", ["string", "number"]);
+      this.openDatabase = module.cwrap("hyperdb_wasm_open_database", "pointer", ["string"]);
+      this.checkpointDatabase = module.cwrap("hyperdb_wasm_checkpoint_database", "pointer", ["string"]);
+      this.dropDatabase = module.cwrap("hyperdb_wasm_drop_database", "pointer", ["string"]);
+      this.shutdown = module.cwrap("hyperdb_wasm_shutdown", "pointer", []);
+      this.attachDatabase = module.cwrap("hyperdb_wasm_attach_database", "pointer", ["number", "string", "string"]);
+      this.detachDatabase = module.cwrap("hyperdb_wasm_detach_database", "pointer", ["number", "string"]);
       this.startQuery = module.cwrap("hyperdb_wasm_query_start", "pointer", ["number", "string"]);
-      this.appendArrowIPC = module.cwrap("hyperdb_wasm_arrow_insert_append", "pointer", ["number", "number", "number"]);
-      this.finishArrowIPC = module.cwrap("hyperdb_wasm_arrow_insert_finish", "pointer", ["number", "string", "string", "number"]);
+      this.insertArrowIPCFromPath = module.cwrap("hyperdb_wasm_arrow_insert_from_path", "pointer", ["number", "string", "string", "string", "number"]);
       this.pollQuery = module.cwrap("hyperdb_wasm_query_poll", "pointer", ["number"]);
       this.cancelQuery = module.cwrap("hyperdb_wasm_query_cancel", "pointer", ["number"]);
       this.releaseQuery = module.cwrap("hyperdb_wasm_query_release", "pointer", ["number"]);
@@ -35,6 +52,16 @@
       this.free = module.cwrap("hyperdb_wasm_free", null, ["pointer"]);
     }
     handle(request) {
+      if (request.type === "createTemporaryFile") {
+        const path = `/tmp/hyperdb/arrow-${this.nextTemporaryFile++}.arrows`;
+        this.module.FS.mkdirTree("/tmp/hyperdb");
+        this.module.FS.writeFile(path, request.bytes);
+        return { response: { id: request.id, type: "response", result: { state: "ok", payload: new TextEncoder().encode(path) } }, transfer: [] };
+      }
+      if (request.type === "removeFile") {
+        this.module.FS.unlink(request.path);
+        return { response: { id: request.id, type: "response", result: { state: "ok", payload: new Uint8Array() } }, transfer: [] };
+      }
       const pointer = safeInteger(this.invoke(request), "result pointer");
       const result = this.decodeResult(pointer);
       const response = { id: request.id, type: "response", result };
@@ -46,21 +73,33 @@
           return this.connect();
         case "disconnect":
           return this.disconnect(request.connection);
+        case "createDatabase":
+          validateCString(request.databaseName, "database name");
+          return this.createDatabase(request.databaseName, Number(request.persistent));
+        case "openDatabase":
+          validateCString(request.databaseName, "database name");
+          return this.openDatabase(request.databaseName);
+        case "checkpointDatabase":
+          validateCString(request.databaseName, "database name");
+          return this.checkpointDatabase(request.databaseName);
+        case "dropDatabase":
+          validateCString(request.databaseName, "database name");
+          return this.dropDatabase(request.databaseName);
+        case "attachDatabase":
+          validateCString(request.databaseName, "database name");
+          validateCString(request.alias, "database alias");
+          return this.attachDatabase(request.connection, request.databaseName, request.alias);
+        case "detachDatabase":
+          validateCString(request.alias, "database alias");
+          return this.detachDatabase(request.connection, request.alias);
+        case "shutdown":
+          return this.shutdown();
         case "startQuery":
           return this.startQuery(request.connection, request.sql);
-        case "appendArrowIPC": {
-          const pointer = safeInteger(this.module._malloc(request.chunk.byteLength || 1), "allocation pointer");
-          if (pointer === 0) throw new Error("wasm allocation failed");
-          try {
-            if (pointer + request.chunk.byteLength > this.module.HEAPU8.byteLength) throw new Error("allocation exceeds the wasm heap");
-            this.module.HEAPU8.set(request.chunk, pointer);
-            return this.appendArrowIPC(request.connection, pointer, request.chunk.byteLength);
-          } finally {
-            this.free(pointer);
-          }
+        case "insertArrowIPCFromPath": {
+          const path = request.internal ? request.path : this.module.resolveHyperDBPath?.(request.path) ?? request.path;
+          return this.insertArrowIPCFromPath(request.connection, path, request.name, request.schema ?? "", Number(request.create));
         }
-        case "finishArrowIPC":
-          return this.finishArrowIPC(request.connection, request.name, request.schema ?? "", Number(request.create));
         case "pollQuery":
           return this.pollQuery(request.query);
         case "cancelQuery":
@@ -117,12 +156,26 @@
         return hasKeys(value, ["id", "type"]);
       case "disconnect":
         return hasKeys(value, ["id", "type", "connection"]) && Number.isSafeInteger(value.connection);
+      case "createDatabase":
+        return hasKeys(value, ["id", "type", "databaseName", "persistent"]) && typeof value.databaseName === "string" && typeof value.persistent === "boolean";
+      case "openDatabase":
+      case "checkpointDatabase":
+      case "dropDatabase":
+        return hasKeys(value, ["id", "type", "databaseName"]) && typeof value.databaseName === "string";
+      case "shutdown":
+        return hasKeys(value, ["id", "type"]);
+      case "attachDatabase":
+        return hasKeys(value, ["id", "type", "connection", "databaseName", "alias"]) && Number.isSafeInteger(value.connection) && typeof value.databaseName === "string" && typeof value.alias === "string";
+      case "detachDatabase":
+        return hasKeys(value, ["id", "type", "connection", "alias"]) && Number.isSafeInteger(value.connection) && typeof value.alias === "string";
       case "startQuery":
         return hasKeys(value, ["id", "type", "connection", "sql"]) && Number.isSafeInteger(value.connection) && typeof value.sql === "string";
-      case "appendArrowIPC":
-        return hasKeys(value, ["id", "type", "connection", "chunk"]) && Number.isSafeInteger(value.connection) && value.chunk instanceof Uint8Array;
-      case "finishArrowIPC":
-        return hasKeys(value, ["id", "type", "connection", "name", "schema", "create"]) && Number.isSafeInteger(value.connection) && typeof value.name === "string" && (typeof value.schema === "string" || value.schema === null) && typeof value.create === "boolean";
+      case "insertArrowIPCFromPath":
+        return hasKeys(value, ["id", "type", "connection", "path", "name", "schema", "create", "internal"]) && Number.isSafeInteger(value.connection) && typeof value.path === "string" && typeof value.name === "string" && (typeof value.schema === "string" || value.schema === null) && typeof value.create === "boolean" && typeof value.internal === "boolean";
+      case "createTemporaryFile":
+        return hasKeys(value, ["id", "type", "bytes"]) && value.bytes instanceof Uint8Array;
+      case "removeFile":
+        return hasKeys(value, ["id", "type", "path"]) && typeof value.path === "string";
       case "pollQuery":
       case "cancelQuery":
       case "releaseQuery":
@@ -192,7 +245,7 @@
       });
     };
   }
-  function configureWorker(module, transport) {
+  function configureWorker(module, transport, configureFilesystem = () => void 0) {
     const queuedRequests = [];
     let bindings;
     const handle = (request) => {
@@ -214,10 +267,15 @@
     module.print = (text) => transport.postMessage({ type: "log", text });
     module.printErr = (text) => transport.postMessage({ type: "log", text });
     module.onRuntimeInitialized = () => {
-      installHttpRuntime(module, transport);
-      bindings = new HyperDBBindings(module);
-      transport.postMessage({ type: "ready" });
-      for (const request of queuedRequests.splice(0)) handle(request);
+      try {
+        configureFilesystem(module);
+        installHttpRuntime(module, transport);
+        bindings = new HyperDBBindings(module);
+        transport.postMessage({ type: "ready" });
+        for (const request of queuedRequests.splice(0)) handle(request);
+      } catch (error) {
+        transport.postMessage({ type: "fatal", error: `engine initialization failed: ${errorText(error)}` });
+      }
     };
     module.onAbort = (reason) => transport.postMessage({ type: "fatal", error: `engine aborted: ${String(reason)}` });
   }
@@ -241,7 +299,27 @@
       postMessage: (message, transfer = []) => self.postMessage(message, [...transfer]),
       onMessage: (listener) => self.addEventListener("message", (event) => listener(event.data))
     };
-    configureWorker(module, transport);
+    configureWorker(module, transport, (runtime) => {
+      if (!runtime.OPFS) throw new Error("OPFS backend is unavailable");
+      runtime.FS.mkdirTree("/opfs");
+      runtime.FS.mount(runtime.OPFS, {}, "/opfs");
+      runtime.FS.mkdirTree("/hyperdb-persistent");
+      runtime.FS.mount(runtime.OPFS, {}, "/hyperdb-persistent");
+      runtime.FS.mkdirTree("/hyperdb-persistent/hyperdb");
+      runtime.resolveHyperDBPath = (path) => {
+        const parts = [];
+        for (const part of path.replace(/^\/+/, "").split("/")) {
+          if (!part || part === ".") continue;
+          if (part === "..") {
+            if (parts.length === 0) throw new Error(`Arrow IPC path is outside the OPFS root: ${path}`);
+            parts.pop();
+          } else {
+            parts.push(part);
+          }
+        }
+        return `/opfs/${parts.join("/")}`;
+      };
+    });
     self.importScripts(resolvedEngineUrl.href);
   }
 })();

package/dist/client.d.ts

@@ -12,9 +12,17 @@ export declare class HyperDBEngineClient {
     ready(): Promise<void>;
     connect(): Promise<WasmResult>;
     disconnect(connection: number): Promise<WasmResult>;
+    createDatabase(databaseName: string, persistent: boolean): Promise<WasmResult>;
+    openDatabase(databaseName: string): Promise<WasmResult>;
+    checkpointDatabase(databaseName: string): Promise<WasmResult>;
+    dropDatabase(databaseName: string): Promise<WasmResult>;
+    attachDatabase(connection: number, databaseName: string, alias: string): Promise<WasmResult>;
+    detachDatabase(connection: number, alias: string): Promise<WasmResult>;
+    shutdown(): Promise<WasmResult>;
     startQuery(connection: number, sql: string): Promise<WasmResult>;
-    appendArrowIPC(connection: number, chunk: Uint8Array): Promise<WasmResult>;
-    finishArrowIPC(connection: number, name: string, schema: string | null, create: boolean): Promise<WasmResult>;
+    insertArrowIPCFromPath(connection: number, path: string, name: string, schema: string | null, create: boolean, internal?: boolean): Promise<WasmResult>;
+    createTemporaryFile(bytes: Uint8Array): Promise<WasmResult>;
+    removeFile(path: string): Promise<WasmResult>;
     pollQuery(query: number): Promise<WasmResult>;
     cancelQuery(query: number): Promise<WasmResult>;
     releaseQuery(query: number): Promise<WasmResult>;