hyperdb-wasm 0.0.26312-dev.wasm.g913ac019 → 0.0.26314-dev.wasm.g698c9427

package/dist/browser.d.ts

@@ -13,6 +13,20 @@ export interface BrowserClientOptions {
     readonly wasmUrl?: string | URL;
     readonly onSetupProgress?: (progress: SetupProgress) => void;
 }
+type BrowserEnvironment = {
+    readonly WebAssembly?: typeof WebAssembly;
+    readonly Worker?: unknown;
+    readonly SharedArrayBuffer?: unknown;
+    readonly Atomics?: unknown;
+    readonly BigInt?: unknown;
+    readonly crossOriginIsolated?: boolean;
+    readonly navigator?: {
+        readonly storage?: {
+            readonly getDirectory?: unknown;
+        };
+    };
+};
+export declare function assertBrowserSupport(environment?: BrowserEnvironment): void;
 export declare class BrowserWorker implements WorkerTransport {
     private readonly worker;
     constructor(worker: BrowserWorkerLike);

package/dist/browser.js

@@ -200,9 +200,36 @@ var init_client = __esm({
 var browser_exports = {};
 __export(browser_exports, {
   BrowserWorker: () => BrowserWorker,
+  assertBrowserSupport: () => assertBrowserSupport,
   createBrowserClient: () => createBrowserClient,
   resolveBrowserWorkerUrl: () => resolveBrowserWorkerUrl
 });
+function assertBrowserSupport(environment = globalThis) {
+  if (typeof environment.WebAssembly?.validate !== "function") {
+    throw new Error("HyperDB cannot initialize because this browser does not support WebAssembly");
+  }
+  if (!environment.WebAssembly.validate(memory64Probe)) {
+    throw new Error("HyperDB cannot initialize because this browser does not yet support WebAssembly memory64. Support for platforms such as iOS is coming soon.");
+  }
+  if (typeof environment.BigInt !== "function") {
+    throw new Error("HyperDB cannot initialize because this browser does not support WebAssembly BigInt integration");
+  }
+  if (!environment.WebAssembly.validate(threadsProbe) || typeof environment.SharedArrayBuffer !== "function" || typeof environment.Atomics !== "object") {
+    throw new Error("HyperDB cannot initialize because this browser does not support WebAssembly threads");
+  }
+  if (!environment.WebAssembly.validate(exceptionsProbe)) {
+    throw new Error("HyperDB cannot initialize because this browser does not support WebAssembly exception handling");
+  }
+  if (typeof environment.Worker !== "function") {
+    throw new Error("HyperDB cannot initialize because this browser does not support Web Workers");
+  }
+  if (environment.crossOriginIsolated !== true) {
+    throw new Error("HyperDB cannot initialize because this page is not cross-origin isolated");
+  }
+  if (typeof environment.navigator?.storage?.getDirectory !== "function") {
+    throw new Error("HyperDB cannot initialize because this browser does not support the origin-private file system");
+  }
+}
 function resolveBrowserWorkerUrl(workerUrl, engineUrl, wasmUrl) {
   const resolved = new URL(workerUrl);
   resolved.searchParams.set("engineUrl", new URL(engineUrl).href);
@@ -210,6 +237,7 @@ function resolveBrowserWorkerUrl(workerUrl, engineUrl, wasmUrl) {
   return resolved;
 }
 function createBrowserClient(options = {}) {
+  assertBrowserSupport();
   const workerUrl = options.workerUrl ?? new URL("./browser_worker.js", import.meta.url);
   const engineUrl = options.engineUrl ?? new URL("./hyperdb-wasm.js", import.meta.url);
   return new HyperDBEngineClient(
@@ -217,11 +245,14 @@ function createBrowserClient(options = {}) {
     options.onSetupProgress
   );
 }
-var BrowserWorker;
+var memory64Probe, threadsProbe, exceptionsProbe, BrowserWorker;
 var init_browser = __esm({
   "src/browser.ts"() {
     "use strict";
     init_client();
+    memory64Probe = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 4, 1]);
+    threadsProbe = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 5, 4, 1, 3, 1, 1]);
+    exceptionsProbe = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 13, 3, 1, 0, 0]);
     BrowserWorker = class {
       constructor(worker) {
         this.worker = worker;
@@ -12092,6 +12123,7 @@ RecordBatchFileWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
 RecordBatchStreamWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
 
 // src/api.ts
+var maxPersistentDatabaseNameLength = 200;
 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 };
@@ -12100,6 +12132,18 @@ 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 validatePersistentDatabaseName(databaseName) {
+  validateDatabaseName(databaseName);
+  if (databaseName.length > maxPersistentDatabaseNameLength) {
+    throw new Error(`Persistent database name must be at most ${maxPersistentDatabaseNameLength} characters`);
+  }
+  if (!/^[a-z0-9][a-z0-9_-]*$/.test(databaseName)) {
+    throw new Error("Persistent database name must start with a lowercase ASCII letter or digit and contain only lowercase ASCII letters, digits, hyphens, and underscores");
+  }
+  if (/^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/.test(databaseName)) {
+    throw new Error("Persistent database name is reserved by Windows");
+  }
+}
 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");
@@ -12212,12 +12256,13 @@ var HyperDB = class _HyperDB {
     if (options.storage !== void 0 && options.storage !== "memory" && options.storage !== "persistent") {
       throw new Error(`Unsupported database storage: ${String(options.storage)}`);
     }
+    if (options.storage === "persistent") validatePersistentDatabaseName(databaseName);
     await this.runDatabaseOperation(async () => {
       expectOk(await this.client.createDatabase(databaseName, options.storage === "persistent"), "create database");
     });
   }
   async openDatabase(databaseName) {
-    validateDatabaseName(databaseName);
+    validatePersistentDatabaseName(databaseName);
     await this.runDatabaseOperation(async () => {
       expectOk(await this.client.openDatabase(databaseName), "open database");
     });