@firtoz/drizzle-sqlite-wasm 1.0.5 → 1.1.2

package/dist/hooks/useDrizzleSqliteDb.d.ts

@@ -0,0 +1,24 @@
+import * as drizzle_orm_sqlite_proxy from 'drizzle-orm/sqlite-proxy';
+import { DurableSqliteMigrationConfig } from '../migration/migrator.js';
+import { ISqliteWorkerClient } from '../worker/manager.js';
+import { SQLInterceptor } from '@firtoz/drizzle-utils';
+import { SqliteWasmWorkerOpenOptions } from '../worker/sqlite-open-options.js';
+import 'drizzle-orm/durable-sqlite/migrator';
+import '@firtoz/worker-helper/WorkerClient';
+import '../worker/schema.js';
+import 'zod';
+
+declare const useDrizzleSqliteDb: <TSchema extends Record<string, unknown>>(WorkerConstructor: new () => Worker, dbName: string, schema: TSchema, migrations: DurableSqliteMigrationConfig, debug?: boolean, 
+/** Optional interceptor to log ALL SQL queries (including direct Drizzle queries) */
+interceptor?: SQLInterceptor, 
+/**
+ * Pragmas applied when the worker first opens this `dbName` in the session.
+ * Ignored if that database was already started (same global worker + dbName).
+ */
+workerOpenOptions?: SqliteWasmWorkerOpenOptions) => {
+    drizzle: drizzle_orm_sqlite_proxy.SqliteRemoteDatabase<TSchema>;
+    readyPromise: Promise<void>;
+    sqliteClient: ISqliteWorkerClient | null;
+};
+
+export { useDrizzleSqliteDb };

package/dist/hooks/useDrizzleSqliteDb.js

@@ -0,0 +1,9 @@
+export { useDrizzleSqliteDb } from '../chunk-WFFFP6DB.js';
+import '../chunk-NSPVPJKE.js';
+import '../chunk-FIVEPVOM.js';
+import '../chunk-AGMKOHXO.js';
+import '../chunk-GVUNHU6J.js';
+import '../chunk-6LNYKOKR.js';
+import '../chunk-FRONXNEA.js';
+//# sourceMappingURL=useDrizzleSqliteDb.js.map
+//# sourceMappingURL=useDrizzleSqliteDb.js.map

package/dist/hooks/useDrizzleSqliteDb.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"useDrizzleSqliteDb.js"}

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+export { drizzleSqliteWasm } from './drizzle/direct.js';
+export { SqliteCollectionConfig, sqliteCollectionOptions as drizzleCollectionOptions } from './collections/sqlite-collection.js';
+export { createSyncedSqliteCollection } from './collections/synced-sqlite-collection.js';
+export { Branded, IdOf, InsertSchema, SQLInterceptor, SQLOperation, SelectSchema, TableId, makeId, syncableTable } from '@firtoz/drizzle-utils';
+export { useDrizzleSqliteDb } from './hooks/useDrizzleSqliteDb.js';
+export { DrizzleSqliteContext, DrizzleSqliteContextValue, DrizzleSqliteProvider, useSqliteCollection } from './context/DrizzleSqliteProvider.js';
+export { UseDrizzleSqliteReturn, useDrizzleSqlite } from './context/useDrizzleSqlite.js';
+export { getSqliteWorkerManager, initializeSqliteWorker, isSqliteWorkerInitialized, resetSqliteWorkerManager } from './worker/global-manager.js';
+export { DbInstance, ISqliteWorkerClient, SqliteWorkerManager } from './worker/manager.js';
+export { SqliteWasmJournalMode, SqliteWasmJournalModeSchema, SqliteWasmSynchronousMode, SqliteWasmSynchronousModeSchema, SqliteWasmWorkerOpenOptions, SqliteWasmWorkerOpenOptionsSchema } from './worker/sqlite-open-options.js';
+export { DurableSqliteMigrationConfig, customSqliteMigrate } from './migration/migrator.js';
+import 'drizzle-orm/sqlite-proxy';
+import './types.js';
+import '@sqlite.org/sqlite-wasm';
+import 'drizzle-orm';
+import '@tanstack/db';
+import 'drizzle-orm/sqlite-core';
+import '@firtoz/db-helpers';
+import '@firtoz/collection-sync';
+import 'react/jsx-runtime';
+import 'react';
+import '@firtoz/worker-helper/WorkerClient';
+import './worker/schema.js';
+import 'zod';
+import 'drizzle-orm/durable-sqlite/migrator';

package/dist/index.js

@@ -0,0 +1,16 @@
+export { createSyncedSqliteCollection } from './chunk-7JJHY44Q.js';
+export { useDrizzleSqlite } from './chunk-H2F2HZ2A.js';
+export { DrizzleSqliteContext, DrizzleSqliteProvider, useSqliteCollection } from './chunk-AEYHRJVN.js';
+export { useDrizzleSqliteDb } from './chunk-WFFFP6DB.js';
+export { customSqliteMigrate } from './chunk-NSPVPJKE.js';
+export { getSqliteWorkerManager, initializeSqliteWorker, isSqliteWorkerInitialized, resetSqliteWorkerManager } from './chunk-FIVEPVOM.js';
+export { DbInstance, SqliteWorkerManager } from './chunk-AGMKOHXO.js';
+import './chunk-GVUNHU6J.js';
+export { SqliteWasmJournalModeSchema, SqliteWasmSynchronousModeSchema, SqliteWasmWorkerOpenOptionsSchema } from './chunk-6LNYKOKR.js';
+export { sqliteCollectionOptions as drizzleCollectionOptions } from './chunk-BZVMUTJ7.js';
+export { drizzleSqliteWasm } from './chunk-TZP4AIBR.js';
+import './chunk-BJDPMGFF.js';
+import './chunk-FRONXNEA.js';
+export { makeId, syncableTable } from '@firtoz/drizzle-utils';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js","sourcesContent":[]}

package/dist/migration/migrator.d.ts

@@ -0,0 +1,7 @@
+import { SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
+import { migrate } from 'drizzle-orm/durable-sqlite/migrator';
+
+type DurableSqliteMigrationConfig = Parameters<typeof migrate>[1];
+declare function customSqliteMigrate<TSchema extends Record<string, unknown>>(db: SqliteRemoteDatabase<TSchema>, config: DurableSqliteMigrationConfig, debug?: boolean): Promise<void>;
+
+export { type DurableSqliteMigrationConfig, customSqliteMigrate };

package/dist/migration/migrator.js

@@ -0,0 +1,3 @@
+export { customSqliteMigrate } from '../chunk-NSPVPJKE.js';
+//# sourceMappingURL=migrator.js.map
+//# sourceMappingURL=migrator.js.map

package/dist/migration/migrator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"migrator.js"}

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+import init from '@sqlite.org/sqlite-wasm';
+
+type Sqlite3Static = Awaited<ReturnType<typeof init>>;
+type Database = InstanceType<Sqlite3Static["oo1"]["DB"]>;
+
+export type { Database, Sqlite3Static };

package/dist/types.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}

package/dist/worker/client.d.ts

@@ -0,0 +1,12 @@
+import { SqliteWorkerRemoteCallbackClientMessage } from './schema.js';
+import 'zod';
+
+interface ISqliteWorkerClient {
+    performRemoteCallback: (data: Omit<SqliteWorkerRemoteCallbackClientMessage, "type" | "id" | "dbId">, resolve: (value: {
+        rows: unknown[];
+    }) => void, reject: (error: Error) => void) => void;
+    onStarted: (callback: () => void) => void;
+    terminate: () => void;
+}
+
+export type { ISqliteWorkerClient };

package/dist/worker/client.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map

package/dist/worker/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"client.js"}

package/dist/worker/global-manager.d.ts

@@ -0,0 +1,36 @@
+import { SqliteWorkerManager } from './manager.js';
+import '@firtoz/worker-helper/WorkerClient';
+import './sqlite-open-options.js';
+import 'zod';
+import './schema.js';
+
+/**
+ * Initialize the global SQLite worker manager.
+ * Should be called once, early in your app (e.g., in entry.client.tsx).
+ * Subsequent calls return the same manager instance.
+ *
+ * @example
+ * ```typescript
+ * // In entry.client.tsx
+ * import { initializeSqliteWorker } from "@firtoz/drizzle-sqlite-wasm";
+ * import SqliteWorker from "@firtoz/drizzle-sqlite-wasm/worker/sqlite.worker?worker";
+ *
+ * initializeSqliteWorker(SqliteWorker);
+ * ```
+ */
+declare function initializeSqliteWorker(WorkerConstructor: new () => Worker, debug?: boolean): Promise<SqliteWorkerManager>;
+/**
+ * Get the global SQLite worker manager.
+ * Throws an error if not initialized.
+ */
+declare function getSqliteWorkerManager(): SqliteWorkerManager;
+/**
+ * Check if the global manager has been initialized
+ */
+declare function isSqliteWorkerInitialized(): boolean;
+/**
+ * Reset the global manager (mainly for testing)
+ */
+declare function resetSqliteWorkerManager(): void;
+
+export { getSqliteWorkerManager, initializeSqliteWorker, isSqliteWorkerInitialized, resetSqliteWorkerManager };

package/dist/worker/global-manager.js

@@ -0,0 +1,6 @@
+export { getSqliteWorkerManager, initializeSqliteWorker, isSqliteWorkerInitialized, resetSqliteWorkerManager } from '../chunk-FIVEPVOM.js';
+import '../chunk-AGMKOHXO.js';
+import '../chunk-GVUNHU6J.js';
+import '../chunk-6LNYKOKR.js';
+//# sourceMappingURL=global-manager.js.map
+//# sourceMappingURL=global-manager.js.map

package/dist/worker/global-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"global-manager.js"}

package/dist/worker/manager.d.ts

@@ -0,0 +1,71 @@
+import { WorkerClient } from '@firtoz/worker-helper/WorkerClient';
+import { SqliteWasmWorkerOpenOptions } from './sqlite-open-options.js';
+import { SqliteWorkerRemoteCallbackClientMessage, SqliteWorkerClientMessage, SqliteWorkerServerMessage, DbId } from './schema.js';
+import 'zod';
+
+interface ISqliteWorkerClient {
+    performRemoteCallback: (data: Omit<SqliteWorkerRemoteCallbackClientMessage, "type" | "id" | "dbId">, resolve: (value: {
+        rows: unknown[];
+    }) => void, reject: (error: Error) => void) => void;
+    checkpoint: () => Promise<void>;
+    onStarted: (callback: () => void) => void;
+    terminate: () => void;
+}
+/**
+ * Per-database instance that can perform operations on a specific database
+ */
+declare class DbInstance implements ISqliteWorkerClient {
+    private readonly manager;
+    readonly dbName: string;
+    private readonly debug;
+    private dbId;
+    private startedCallbacks;
+    private isStarted;
+    constructor(manager: SqliteWorkerManager, dbName: string, debug?: boolean);
+    /**
+     * Internal method called by manager when database is started
+     */
+    _setStarted(dbId: DbId): void;
+    performRemoteCallback(data: Omit<SqliteWorkerRemoteCallbackClientMessage, "type" | "id" | "dbId">, resolve: (value: {
+        rows: unknown[];
+    }) => void, reject: (error: Error) => void): void;
+    checkpoint(): Promise<void>;
+    onStarted(callback: () => void): void;
+    terminate(): void;
+}
+/**
+ * Main worker manager that can create multiple database instances
+ */
+declare class SqliteWorkerManager extends WorkerClient<SqliteWorkerClientMessage, SqliteWorkerServerMessage> {
+    private readonly debug;
+    private readonly remoteCallbacks;
+    private readonly checkpointCallbacks;
+    private readyResolve?;
+    private readyReject?;
+    private readonly readyPromise;
+    private isReady;
+    private readonly dbInstances;
+    private readonly pendingStarts;
+    constructor(worker: Worker, debug?: boolean);
+    /**
+     * Promise that resolves when the worker sends its first Ready message
+     */
+    get ready(): Promise<void>;
+    private onMessage;
+    /**
+     * Get or create a database instance
+     */
+    getDbInstance(dbName: string, openOptions?: SqliteWasmWorkerOpenOptions): Promise<DbInstance>;
+    /**
+     * Internal method for db instances to perform remote callbacks
+     */
+    performRemoteCallback(dbId: DbId, data: Omit<SqliteWorkerRemoteCallbackClientMessage, "type" | "id" | "dbId">, resolve: (value: {
+        rows: unknown[];
+    }) => void, reject: (error: Error) => void): void;
+    /**
+     * Internal method for db instances to checkpoint the database
+     */
+    checkpoint(dbId: DbId, resolve: () => void, reject: (error: Error) => void): void;
+}
+
+export { DbInstance, type ISqliteWorkerClient, SqliteWorkerManager };

package/dist/worker/manager.js

@@ -0,0 +1,5 @@
+export { DbInstance, SqliteWorkerManager } from '../chunk-AGMKOHXO.js';
+import '../chunk-GVUNHU6J.js';
+import '../chunk-6LNYKOKR.js';
+//# sourceMappingURL=manager.js.map
+//# sourceMappingURL=manager.js.map

package/dist/worker/manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"manager.js"}

package/dist/worker/schema.d.ts

@@ -0,0 +1,125 @@
+import z from 'zod';
+
+declare const RemoteCallbackIdSchema: z.core.$ZodBranded<z.ZodString, "remote-callback-id", "out">;
+type RemoteCallbackId = z.infer<typeof RemoteCallbackIdSchema>;
+declare const DbIdSchema: z.core.$ZodBranded<z.ZodString, "db-id", "out">;
+type DbId = z.infer<typeof DbIdSchema>;
+declare const StartRequestIdSchema: z.core.$ZodBranded<z.ZodString, "start-request-id", "out">;
+type StartRequestId = z.infer<typeof StartRequestIdSchema>;
+declare const CheckpointIdSchema: z.core.$ZodBranded<z.ZodString, "checkpoint-id", "out">;
+type CheckpointId = z.infer<typeof CheckpointIdSchema>;
+declare enum SqliteWorkerClientMessageType {
+    Start = "start",
+    RemoteCallbackRequest = "remote-callback-request",
+    Checkpoint = "checkpoint"
+}
+declare enum SqliteWorkerServerMessageType {
+    Ready = "ready",
+    Started = "started",
+    RemoteCallbackResponse = "remote-callback-response",
+    RemoteCallbackError = "remote-callback-error",
+    CheckpointComplete = "checkpoint-complete",
+    CheckpointError = "checkpoint-error"
+}
+declare const RemoteCallbackRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerClientMessageType.RemoteCallbackRequest>;
+    id: z.core.$ZodBranded<z.ZodString, "remote-callback-id", "out">;
+    dbId: z.core.$ZodBranded<z.ZodString, "db-id", "out">;
+    sql: z.ZodString;
+    params: z.ZodArray<z.ZodAny>;
+    method: z.ZodEnum<{
+        run: "run";
+        all: "all";
+        values: "values";
+        get: "get";
+    }>;
+}, z.core.$strip>;
+type SqliteWorkerRemoteCallbackClientMessage = z.infer<typeof RemoteCallbackRequestSchema>;
+declare const CheckpointRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerClientMessageType.Checkpoint>;
+    id: z.core.$ZodBranded<z.ZodString, "checkpoint-id", "out">;
+    dbId: z.core.$ZodBranded<z.ZodString, "db-id", "out">;
+}, z.core.$strip>;
+type CheckpointRequest = z.infer<typeof CheckpointRequestSchema>;
+declare const SqliteWorkerClientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerClientMessageType.Start>;
+    requestId: z.core.$ZodBranded<z.ZodString, "start-request-id", "out">;
+    dbName: z.ZodString;
+    openOptions: z.ZodOptional<z.ZodObject<{
+        synchronous: z.ZodOptional<z.ZodEnum<{
+            OFF: "OFF";
+            NORMAL: "NORMAL";
+            FULL: "FULL";
+            EXTRA: "EXTRA";
+        }>>;
+        journalMode: z.ZodOptional<z.ZodEnum<{
+            OFF: "OFF";
+            WAL: "WAL";
+            DELETE: "DELETE";
+            TRUNCATE: "TRUNCATE";
+            MEMORY: "MEMORY";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerClientMessageType.RemoteCallbackRequest>;
+    id: z.core.$ZodBranded<z.ZodString, "remote-callback-id", "out">;
+    dbId: z.core.$ZodBranded<z.ZodString, "db-id", "out">;
+    sql: z.ZodString;
+    params: z.ZodArray<z.ZodAny>;
+    method: z.ZodEnum<{
+        run: "run";
+        all: "all";
+        values: "values";
+        get: "get";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerClientMessageType.Checkpoint>;
+    id: z.core.$ZodBranded<z.ZodString, "checkpoint-id", "out">;
+    dbId: z.core.$ZodBranded<z.ZodString, "db-id", "out">;
+}, z.core.$strip>], "type">;
+declare const RemoteCallbackResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerServerMessageType.RemoteCallbackResponse>;
+    id: z.core.$ZodBranded<z.ZodString, "remote-callback-id", "out">;
+    rows: z.ZodArray<z.ZodAny>;
+}, z.core.$strip>;
+declare const RemoteCallbackErrorServerMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerServerMessageType.RemoteCallbackError>;
+    id: z.core.$ZodBranded<z.ZodString, "remote-callback-id", "out">;
+    error: z.ZodString;
+}, z.core.$strip>;
+declare const CheckpointCompleteSchema: z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerServerMessageType.CheckpointComplete>;
+    id: z.core.$ZodBranded<z.ZodString, "checkpoint-id", "out">;
+}, z.core.$strip>;
+declare const CheckpointErrorSchema: z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerServerMessageType.CheckpointError>;
+    id: z.core.$ZodBranded<z.ZodString, "checkpoint-id", "out">;
+    error: z.ZodString;
+}, z.core.$strip>;
+declare const sqliteWorkerServerMessage: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerServerMessageType.Ready>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerServerMessageType.Started>;
+    requestId: z.core.$ZodBranded<z.ZodString, "start-request-id", "out">;
+    dbId: z.core.$ZodBranded<z.ZodString, "db-id", "out">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerServerMessageType.RemoteCallbackResponse>;
+    id: z.core.$ZodBranded<z.ZodString, "remote-callback-id", "out">;
+    rows: z.ZodArray<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerServerMessageType.RemoteCallbackError>;
+    id: z.core.$ZodBranded<z.ZodString, "remote-callback-id", "out">;
+    error: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerServerMessageType.CheckpointComplete>;
+    id: z.core.$ZodBranded<z.ZodString, "checkpoint-id", "out">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<SqliteWorkerServerMessageType.CheckpointError>;
+    id: z.core.$ZodBranded<z.ZodString, "checkpoint-id", "out">;
+    error: z.ZodString;
+}, z.core.$strip>], "type">;
+type SqliteWorkerClientMessage = z.infer<typeof SqliteWorkerClientMessageSchema>;
+type SqliteWorkerServerMessage = z.infer<typeof sqliteWorkerServerMessage>;
+type SqliteClientRemoteCallbackServerMessage = z.infer<typeof RemoteCallbackResponseSchema>;
+
+export { CheckpointCompleteSchema, CheckpointErrorSchema, type CheckpointId, CheckpointIdSchema, type CheckpointRequest, CheckpointRequestSchema, type DbId, DbIdSchema, RemoteCallbackErrorServerMessageSchema, type RemoteCallbackId, RemoteCallbackIdSchema, RemoteCallbackRequestSchema, RemoteCallbackResponseSchema, type SqliteClientRemoteCallbackServerMessage, type SqliteWorkerClientMessage, SqliteWorkerClientMessageSchema, SqliteWorkerClientMessageType, type SqliteWorkerRemoteCallbackClientMessage, type SqliteWorkerServerMessage, SqliteWorkerServerMessageType, type StartRequestId, StartRequestIdSchema, sqliteWorkerServerMessage };

package/dist/worker/schema.js

@@ -0,0 +1,4 @@
+export { CheckpointCompleteSchema, CheckpointErrorSchema, CheckpointIdSchema, CheckpointRequestSchema, DbIdSchema, RemoteCallbackErrorServerMessageSchema, RemoteCallbackIdSchema, RemoteCallbackRequestSchema, RemoteCallbackResponseSchema, SqliteWorkerClientMessageSchema, SqliteWorkerClientMessageType, SqliteWorkerServerMessageType, StartRequestIdSchema, sqliteWorkerServerMessage } from '../chunk-GVUNHU6J.js';
+import '../chunk-6LNYKOKR.js';
+//# sourceMappingURL=schema.js.map
+//# sourceMappingURL=schema.js.map

package/dist/worker/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"schema.js"}

package/dist/worker/sqlite-open-options.d.ts

@@ -0,0 +1,45 @@
+import z from 'zod';
+
+/**
+ * SQLite `PRAGMA synchronous` levels (see SQLite docs). Default worker behavior
+ * remains `FULL` for maximum durability with OPFS; `NORMAL` is often much faster
+ * for interactive UIs at the cost of a narrower crash window.
+ */
+declare const SqliteWasmSynchronousModeSchema: z.ZodEnum<{
+    OFF: "OFF";
+    NORMAL: "NORMAL";
+    FULL: "FULL";
+    EXTRA: "EXTRA";
+}>;
+type SqliteWasmSynchronousMode = z.infer<typeof SqliteWasmSynchronousModeSchema>;
+/**
+ * SQLite `PRAGMA journal_mode` values the worker will pass through as
+ * `PRAGMA journal_mode=<value>;` (uppercase).
+ */
+declare const SqliteWasmJournalModeSchema: z.ZodEnum<{
+    OFF: "OFF";
+    WAL: "WAL";
+    DELETE: "DELETE";
+    TRUNCATE: "TRUNCATE";
+    MEMORY: "MEMORY";
+}>;
+type SqliteWasmJournalMode = z.infer<typeof SqliteWasmJournalModeSchema>;
+/** Options applied once when the worker opens a database file (OPFS or transient). */
+declare const SqliteWasmWorkerOpenOptionsSchema: z.ZodObject<{
+    synchronous: z.ZodOptional<z.ZodEnum<{
+        OFF: "OFF";
+        NORMAL: "NORMAL";
+        FULL: "FULL";
+        EXTRA: "EXTRA";
+    }>>;
+    journalMode: z.ZodOptional<z.ZodEnum<{
+        OFF: "OFF";
+        WAL: "WAL";
+        DELETE: "DELETE";
+        TRUNCATE: "TRUNCATE";
+        MEMORY: "MEMORY";
+    }>>;
+}, z.core.$strict>;
+type SqliteWasmWorkerOpenOptions = z.infer<typeof SqliteWasmWorkerOpenOptionsSchema>;
+
+export { type SqliteWasmJournalMode, SqliteWasmJournalModeSchema, type SqliteWasmSynchronousMode, SqliteWasmSynchronousModeSchema, type SqliteWasmWorkerOpenOptions, SqliteWasmWorkerOpenOptionsSchema };

package/dist/worker/sqlite-open-options.js

@@ -0,0 +1,3 @@
+export { SqliteWasmJournalModeSchema, SqliteWasmSynchronousModeSchema, SqliteWasmWorkerOpenOptionsSchema } from '../chunk-6LNYKOKR.js';
+//# sourceMappingURL=sqlite-open-options.js.map
+//# sourceMappingURL=sqlite-open-options.js.map

package/dist/worker/sqlite-open-options.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"sqlite-open-options.js"}

package/dist/worker/sqlite.worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }