@motherduck/wasm-client 0.6.5 → 0.7.0

package/types/{motherduck/duckdb-values/DuckDBTimestampSeconds.d.ts → @duckdb/data-values/DuckDBTimestampSecondsValue.d.ts}

@@ -1,7 +1,9 @@
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBTimestampSeconds extends SpecialDuckDBValue {
+export declare class DuckDBTimestampSecondsValue extends SpecialDuckDBValue {
     readonly seconds: bigint;
     constructor(seconds: bigint);
     toDuckDBString(): string;
-    toJS(): string;
+    toSql(): string;
+    toJson(): Json;
 }

package/types/@duckdb/data-values/DuckDBTimestampTZValue.d.ts

@@ -0,0 +1,10 @@
+import { DuckDBToStringOptions } from './DuckDBToStringOptions.js';
+import { Json } from './Json.js';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
+export declare class DuckDBTimestampTZValue extends SpecialDuckDBValue {
+    readonly microseconds: bigint;
+    constructor(microseconds: bigint);
+    toDuckDBString(toStringOptions?: DuckDBToStringOptions): string;
+    toSql(): string;
+    toJson(): Json;
+}

package/types/@duckdb/data-values/DuckDBToStringOptions.d.ts

@@ -0,0 +1,3 @@
+export interface DuckDBToStringOptions {
+    timezoneOffsetInMinutes?: number;
+}

package/types/@duckdb/data-values/DuckDBUUIDValue.d.ts

@@ -0,0 +1,17 @@
+import { Json } from './Json.js';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
+export declare class DuckDBUUIDValue extends SpecialDuckDBValue {
+    readonly bytes: Uint8Array;
+    constructor(bytes: Uint8Array);
+    toDuckDBString(): string;
+    toSql(): string;
+    toJson(): Json;
+    /**
+     * Create a DuckDBUUIDValue value from a HUGEINT as stored by DuckDB.
+     *
+     * UUID values are stored with their MSB flipped so their numeric ordering matches their string ordering.
+     */
+    static fromStoredHugeint(hugeint: bigint): DuckDBUUIDValue;
+    /** Create a DuckDBUUIDValue value from an unsigned 128-bit integer in a JS BigInt. */
+    static fromUint128(uint128: bigint): DuckDBUUIDValue;
+}

package/types/{motherduck/duckdb-values → @duckdb/data-values}/DuckDBValue.d.ts

@@ -1,3 +1,2 @@
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export type DuckDBValue = null | boolean | number | string | bigint | SpecialDuckDBValue;
-export declare function duckDBValueToJS(value: DuckDBValue): any;

package/types/@duckdb/data-values/Json.d.ts

@@ -0,0 +1,3 @@
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};

package/types/@duckdb/data-values/SpecialDuckDBValue.d.ts

@@ -0,0 +1,8 @@
+import { DuckDBToStringOptions } from './DuckDBToStringOptions.js';
+import { Json } from './Json.js';
+export declare abstract class SpecialDuckDBValue {
+    abstract toDuckDBString(toStringOptions?: DuckDBToStringOptions): string;
+    abstract toSql(): string;
+    toString(): string;
+    abstract toJson(): Json;
+}

package/types/{motherduck/duckdb-values → @duckdb/data-values}/conversion/dateTimeStringConversion.d.ts

@@ -1,12 +1,16 @@
 export declare function getDuckDBDateStringFromYearMonthDay(year: number, month: number, dayOfMonth: number): string;
 export declare function getDuckDBDateStringFromDays(days: number): string;
+export declare function getTimezoneOffsetString(timezoneOffsetInMinutes?: number): string | undefined;
+export declare function getAbsoluteOffsetStringFromParts(hoursPart: number, minutesPart: number, secondsPart: number): string;
+export declare function getOffsetStringFromAbsoluteSeconds(absoluteOffsetInSeconds: number): string;
+export declare function getOffsetStringFromSeconds(offsetInSeconds: number): string;
 export declare function getDuckDBTimeStringFromParts(hoursPart: bigint, minutesPart: bigint, secondsPart: bigint, microsecondsPart: bigint): string;
 export declare function getDuckDBTimeStringFromPositiveMicroseconds(positiveMicroseconds: bigint): string;
 export declare function getDuckDBTimeStringFromMicrosecondsInDay(microsecondsInDay: bigint): string;
 export declare function getDuckDBTimeStringFromMicroseconds(microseconds: bigint): string;
-export declare function getDuckDBTimestampStringFromDaysAndMicroseconds(days: bigint, microsecondsInDay: bigint, timezone?: string | null): string;
-export declare function getDuckDBTimestampStringFromMicroseconds(microseconds: bigint, timezone?: string | null): string;
-export declare function getDuckDBTimestampStringFromSeconds(seconds: bigint, timezone?: string | null): string;
-export declare function getDuckDBTimestampStringFromMilliseconds(milliseconds: bigint, timezone?: string | null): string;
-export declare function getDuckDBTimestampStringFromNanoseconds(nanoseconds: bigint, timezone?: string | null): string;
+export declare function getDuckDBTimestampStringFromDaysAndMicroseconds(days: bigint, microsecondsInDay: bigint, timezonePart?: string): string;
+export declare function getDuckDBTimestampStringFromMicroseconds(microseconds: bigint, timezoneOffsetInMinutes?: number): string;
+export declare function getDuckDBTimestampStringFromSeconds(seconds: bigint): string;
+export declare function getDuckDBTimestampStringFromMilliseconds(milliseconds: bigint): string;
+export declare function getDuckDBTimestampStringFromNanoseconds(nanoseconds: bigint): string;
 export declare function getDuckDBIntervalString(months: number, days: number, microseconds: bigint): string;

package/types/@duckdb/data-values/conversion/duckDBValueToSql.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBValue } from '../DuckDBValue.js';
+/** Converts a DuckDBValue to a valid SQL string. */
+export declare function duckDBValueToSql(value: DuckDBValue): string;

package/types/@duckdb/data-values/conversion/getVarIntFromBytes.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns the JS bigint value represented by the byte array a VARINT in DuckDB's internal format.
+ *
+ * DuckDB stores VARINTs as an array of bytes consisting of a three-byte header followed by a variable number of bytes
+ * (at least one). The header specifies the number of bytes after the header, and whether the number is positive or
+ * negative. The bytes after the header specify the absolute value of the number, in big endian format.
+ *
+ * The sign of the number is determined by the MSB of the header, which is 1 for positive and 0 for negative. Negative
+ * numbers also have all bytes of both the header and value inverted. (For negative numbers, the MSB is 0 after this
+ * inversion. Put another way: the MSB of the header is always 1, but it's inverted for negative numbers.)
+ */
+export declare function getVarIntFromBytes(bytes: Uint8Array): bigint;

package/types/@duckdb/data-values/conversion/jsonFromDuckDBValue.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBValue } from '../DuckDBValue.js';
+import { Json } from '../Json.js';
+export declare function jsonFromDuckDBValue(value: DuckDBValue): Json;

package/types/@duckdb/data-values/index.d.ts

@@ -0,0 +1,26 @@
+export { duckDBValueToSql } from './conversion/duckDBValueToSql.js';
+export { getVarIntFromBytes } from './conversion/getVarIntFromBytes.js';
+export { jsonFromDuckDBValue } from './conversion/jsonFromDuckDBValue.js';
+export { DuckDBArrayValue } from './DuckDBArrayValue.js';
+export { DuckDBBitValue } from './DuckDBBitValue.js';
+export { DuckDBBlobValue } from './DuckDBBlobValue.js';
+export { DuckDBDateValue } from './DuckDBDateValue.js';
+export { DuckDBDecimalValue } from './DuckDBDecimalValue.js';
+export { DuckDBIntervalValue } from './DuckDBIntervalValue.js';
+export { DuckDBListValue } from './DuckDBListValue.js';
+export { DuckDBMapEntry } from './DuckDBMapEntry.js';
+export { DuckDBMapValue } from './DuckDBMapValue.js';
+export { DuckDBStructEntry } from './DuckDBStructEntry.js';
+export { DuckDBStructValue } from './DuckDBStructValue.js';
+export { DuckDBTimestampMicrosecondsValue } from './DuckDBTimestampMicrosecondsValue.js';
+export { DuckDBTimestampMillisecondsValue } from './DuckDBTimestampMillisecondsValue.js';
+export { DuckDBTimestampNanosecondsValue } from './DuckDBTimestampNanosecondsValue.js';
+export { DuckDBTimestampSecondsValue } from './DuckDBTimestampSecondsValue.js';
+export { DuckDBTimestampTZValue } from './DuckDBTimestampTZValue.js';
+export { DuckDBTimeTZValue } from './DuckDBTimeTZValue.js';
+export { DuckDBTimeValue } from './DuckDBTimeValue.js';
+export { DuckDBToStringOptions } from './DuckDBToStringOptions.js';
+export { DuckDBUUIDValue } from './DuckDBUUIDValue.js';
+export { DuckDBValue } from './DuckDBValue.js';
+export { Json } from './Json.js';
+export { SpecialDuckDBValue } from './SpecialDuckDBValue.js';

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/bindings/bindings_base.d.ts

@@ -70,13 +70,13 @@ export declare abstract class DuckDBBindingsBase implements DuckDBBindings {
      *  On null, the query has to be executed using `pollPendingQuery` until that returns != null.
      *  Results can then be fetched using `fetchQueryResults`
      */
-    startPendingQuery(conn: number, text: string): Uint8Array | null;
+    startPendingQuery(conn: number, text: string, allowStreamResult?: boolean): Uint8Array | null;
     /** Poll a pending query */
     pollPendingQuery(conn: number): Uint8Array | null;
     /** Cancel a pending query */
     cancelPendingQuery(conn: number): boolean;
     /** Fetch query results */
-    fetchQueryResults(conn: number): Uint8Array;
+    fetchQueryResults(conn: number): Uint8Array | null;
     /** Get table names */
     getTableNames(conn: number, text: string): string[];
     /** Create a scalar function */
@@ -103,12 +103,19 @@ export declare abstract class DuckDBBindingsBase implements DuckDBBindings {
     registerFileText(name: string, text: string): void;
     /** Register a file buffer */
     registerFileBuffer(name: string, buffer: Uint8Array): void;
+    prepareFileHandle(fileName: string, protocol: DuckDBDataProtocol): Promise<void>;
+    /** Prepare a file handle that could only be acquired aschronously */
+    prepareDBFileHandle(path: string, protocol: DuckDBDataProtocol): Promise<void>;
+    /** Prepare a file object URL */
+    prepareFileHandleAsync<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): Promise<HandleType>;
+    /** Register a file object URL async */
+    registerFileHandleAsync<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): Promise<void>;
     /** Register a file object URL */
     registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): void;
     /** Drop file */
     dropFile(name: string): void;
     /** Drop files */
-    dropFiles(): void;
+    dropFiles(names?: string[]): void;
     /** Flush all files */
     flushFiles(): void;
     /** Write a file to a path */
@@ -116,6 +123,7 @@ export declare abstract class DuckDBBindingsBase implements DuckDBBindings {
     /** Write a file to a buffer */
     copyFileToBuffer(name: string): Uint8Array;
     /** Enable tracking of file statistics */
+    registerOPFSFileName(file: string): Promise<void>;
     collectFileStatistics(file: string, enable: boolean): void;
     /** Export file statistics */
     exportFileStatistics(file: string): FileStatistics;

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/bindings/bindings_interface.d.ts

@@ -13,10 +13,10 @@ export interface DuckDBBindings {
     connect(): DuckDBConnection;
     disconnect(conn: number): void;
     runQuery(conn: number, text: string): Uint8Array;
-    startPendingQuery(conn: number, text: string): Uint8Array | null;
+    startPendingQuery(conn: number, text: string, allowStreamResult: boolean): Uint8Array | null;
     pollPendingQuery(conn: number): Uint8Array | null;
     cancelPendingQuery(conn: number): boolean;
-    fetchQueryResults(conn: number): Uint8Array;
+    fetchQueryResults(conn: number): Uint8Array | null;
     getTableNames(conn: number, text: string): string[];
     createPrepared(conn: number, text: string): number;
     closePrepared(conn: number, statement: number): void;
@@ -30,12 +30,17 @@ export interface DuckDBBindings {
     registerFileText(name: string, text: string): void;
     registerFileBuffer(name: string, buffer: Uint8Array): void;
     registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): void;
+    registerFileHandleAsync<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): Promise<void>;
+    prepareFileHandleAsync<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): Promise<HandleType>;
+    prepareFileHandle(path: string, protocol: DuckDBDataProtocol): Promise<void>;
+    prepareDBFileHandle(path: string, protocol: DuckDBDataProtocol): Promise<void>;
     globFiles(path: string): WebFile[];
     dropFile(name: string): void;
-    dropFiles(): void;
+    dropFiles(names?: string[]): void;
     flushFiles(): void;
     copyFileToPath(name: string, path: string): void;
     copyFileToBuffer(name: string): Uint8Array;
+    registerOPFSFileName(file: string): Promise<void>;
     collectFileStatistics(file: string, enable: boolean): void;
     exportFileStatistics(file: string): FileStatistics;
 }

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/bindings/config.d.ts

@@ -21,11 +21,23 @@ export interface DuckDBQueryConfig {
     castDecimalToDouble?: boolean;
 }
 export interface DuckDBFilesystemConfig {
+    reliableHeadRequests?: boolean;
     /**
      * Allow falling back to full HTTP reads if the server does not support range requests.
      */
-    reliableHeadRequests?: boolean;
     allowFullHTTPReads?: boolean;
+    /**
+     * Force use of full HTTP reads, suppressing range requests.
+     */
+    forceFullHTTPReads?: boolean;
+}
+export interface DuckDBOPFSConfig {
+    /**
+     * Defines how `opfs://` files are handled during SQL execution.
+     * - "auto": Automatically register `opfs://` files and drop them after execution.
+     * - "manual": Files must be manually registered and dropped.
+     */
+    fileHandling?: "auto" | "manual";
 }
 export declare enum DuckDBAccessMode {
     UNDEFINED = 0,
@@ -47,6 +59,10 @@ export interface DuckDBConfig {
      * Note that this will only work with cross-origin isolated sites since it requires SharedArrayBuffers.
      */
     maximumThreads?: number;
+    /**
+     * The direct io flag
+     */
+    useDirectIO?: boolean;
     /**
      * The query config
      */
@@ -59,8 +75,16 @@ export interface DuckDBConfig {
      * Whether to allow unsigned extensions
      */
     allowUnsignedExtensions?: boolean;
+    /**
+     * Whether to use alternate Arrow conversion that preserves full range and precision of data.
+     */
+    arrowLosslessConversion?: boolean;
     /**
      * Custom user agent string
      */
     customUserAgent?: string;
+    /**
+     * opfs string
+     */
+    opfs?: DuckDBOPFSConfig;
 }

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/bindings/connection.d.ts

@@ -20,7 +20,7 @@ export declare class DuckDBConnection {
     /** Send a query */
     send<T extends {
         [key: string]: arrow.DataType;
-    } = any>(text: string): Promise<arrow.RecordBatchStreamReader<T>>;
+    } = any>(text: string, allowStreamResult?: boolean): Promise<arrow.RecordBatchStreamReader<T>>;
     /** Cancel a query that was sent earlier */
     cancelSent(): boolean;
     /** Get table names */

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/bindings/duckdb_module.d.ts

@@ -7,6 +7,8 @@ export interface DuckDBModule extends EmscriptenModule {
     stackSave: typeof stackSave;
     stackAlloc: typeof stackAlloc;
     stackRestore: typeof stackRestore;
+    lengthBytesUTF8: typeof lengthBytesUTF8;
+    stringToUTF8: typeof stringToUTF8;
     ccall: typeof ccall;
     PThread: PThread;
 }

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/bindings/runtime.d.ts

@@ -25,7 +25,12 @@ export declare enum FileFlags {
     FILE_FLAGS_DIRECT_IO = 4,
     FILE_FLAGS_FILE_CREATE = 8,
     FILE_FLAGS_FILE_CREATE_NEW = 16,
-    FILE_FLAGS_APPEND = 32
+    FILE_FLAGS_APPEND = 32,
+    FILE_FLAGS_PRIVATE = 64,
+    FILE_FLAGS_NULL_IF_NOT_EXISTS = 128,
+    FILE_FLAGS_PARALLEL_ACCESS = 256,
+    FILE_FLAGS_EXCLUSIVE_CREATE = 512,
+    FILE_FLAGS_NULL_IF_EXISTS = 1024
 }
 /** Configuration for the AWS S3 Filesystem */
 export interface S3Config {
@@ -44,6 +49,7 @@ export interface DuckDBFileInfo {
     dataUrl: string | null;
     reliableHeadRequests?: boolean;
     allowFullHttpReads?: boolean;
+    forceFullHttpReads?: boolean;
     s3Config?: S3Config;
 }
 /** Global info for all files registered with DuckDB */
@@ -51,8 +57,14 @@ export interface DuckDBGlobalFileInfo {
     cacheEpoch: number;
     reliableHeadRequests?: boolean;
     allowFullHttpReads?: boolean;
+    forceFullHttpReads?: boolean;
     s3Config?: S3Config;
 }
+export interface PreparedDBFileHandle {
+    path: string;
+    handle: any;
+    fromCached: boolean;
+}
 /** Call a function with packed response buffer */
 export declare function callSRet(mod: DuckDBModule, funcName: string, argTypes: Array<Emscripten.JSType>, args: Array<any>): [number, number, number];
 /** Drop response buffers */
@@ -66,6 +78,7 @@ export interface DuckDBRuntime {
     openFile(mod: DuckDBModule, fileId: number, flags: FileFlags): void;
     syncFile(mod: DuckDBModule, fileId: number): void;
     closeFile(mod: DuckDBModule, fileId: number): void;
+    dropFile(mod: DuckDBModule, fileNamePtr: number, fileNameLen: number): void;
     getLastFileModificationTime(mod: DuckDBModule, fileId: number): number;
     truncateFile(mod: DuckDBModule, fileId: number, newSize: number): void;
     readFile(mod: DuckDBModule, fileId: number, buffer: number, bytes: number, location: number): number;
@@ -78,6 +91,10 @@ export interface DuckDBRuntime {
     moveFile(mod: DuckDBModule, fromPtr: number, fromLen: number, toPtr: number, toLen: number): void;
     checkFile(mod: DuckDBModule, pathPtr: number, pathLen: number): boolean;
     removeFile(mod: DuckDBModule, pathPtr: number, pathLen: number): void;
+    prepareFileHandle?: (path: string, protocol: DuckDBDataProtocol) => Promise<PreparedDBFileHandle[]>;
+    prepareFileHandles?: (path: string[], protocol: DuckDBDataProtocol) => Promise<PreparedDBFileHandle[]>;
+    prepareDBFileHandle?: (path: string, protocol: DuckDBDataProtocol) => Promise<PreparedDBFileHandle[]>;
+    progressUpdate(final: number, percentage: number, iteration: number): void;
     callScalarUDF(mod: DuckDBModule, response: number, funcId: number, descPtr: number, descSize: number, ptrsPtr: number, ptrsSize: number): void;
 }
 export declare const DEFAULT_RUNTIME: DuckDBRuntime;

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/bindings/runtime_browser.d.ts

@@ -1,9 +1,13 @@
 import { DuckDBFileInfo, DuckDBGlobalFileInfo, DuckDBRuntime } from './runtime';
 import { DuckDBModule } from './duckdb_module';
 export declare const BROWSER_RUNTIME: DuckDBRuntime & {
+    _files: Map<string, any>;
     _fileInfoCache: Map<number, DuckDBFileInfo>;
     _globalFileInfo: DuckDBGlobalFileInfo | null;
+    _preparedHandles: Record<string, FileSystemSyncAccessHandle>;
+    _opfsRoot: FileSystemDirectoryHandle | null;
     getFileInfo(mod: DuckDBModule, fileId: number): DuckDBFileInfo | null;
     getGlobalFileInfo(mod: DuckDBModule): DuckDBGlobalFileInfo | null;
+    assignOPFSRoot(): Promise<void>;
 };
 export default BROWSER_RUNTIME;

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/log.d.ts

@@ -36,6 +36,13 @@ export type LogEntry<O, T, E, V> = {
     readonly event: E;
     readonly value: V;
 };
+export type ProgressEntry = {
+    readonly status: string;
+    readonly percentage: string;
+    readonly repetitions: string;
+};
+/** An execution progress handler */
+export type ExecutionProgressHandler = (p: ProgressEntry) => void;
 export type LogEntryVariant = LogEntry<LogOrigin.BINDINGS, LogTopic.INSTANTIATE, LogEvent.ERROR, string> | LogEntry<LogOrigin.BINDINGS, LogTopic.QUERY, LogEvent.START, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.QUERY, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.QUERY, LogEvent.ERROR, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.CONNECT, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.CONNECT, LogEvent.ERROR, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.DISCONNECT, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.DISCONNECT, LogEvent.ERROR, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.OPEN, LogEvent.START, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.OPEN, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.OPEN, LogEvent.ERROR, void> | LogEntry<LogOrigin.ASYNC_DUCKDB, LogTopic.QUERY, LogEvent.RUN, string>;
 export interface Logger {
     log(entry: LogEntryVariant): void;

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/parallel/async_bindings.d.ts

@@ -9,6 +9,7 @@ import { DuckDBConfig } from '../bindings/config';
 import { InstantiationProgress } from '../bindings/progress';
 import { WebFile } from '../bindings/web_file';
 import { DuckDBDataProtocol } from '../bindings';
+import { ProgressEntry } from '../log';
 export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     /** The message handler */
     protected readonly _onMessageHandler: (event: MessageEvent) => void;
@@ -18,6 +19,8 @@ export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     protected readonly _onCloseHandler: () => void;
     /** Instantiate the module */
     protected _onInstantiationProgress: ((p: InstantiationProgress) => void)[];
+    /** Progress callbacks */
+    protected _onExecutionProgress: ((p: ProgressEntry) => void)[];
     /** The logger */
     protected readonly _logger: Logger;
     /** The worker */
@@ -30,9 +33,13 @@ export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     protected _nextMessageId: number;
     /** The pending requests */
     protected _pendingRequests: Map<number, WorkerTaskVariant>;
+    /** The DuckDBConfig */
+    protected _config: DuckDBConfig;
     constructor(logger: Logger, worker?: Worker | null);
     /** Get the logger */
     get logger(): Logger;
+    /** Get the logger */
+    get config(): DuckDBConfig;
     /** Attach to worker */
     protected attach(worker: Worker): void;
     /** Detach from worker */
@@ -47,6 +54,8 @@ export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     protected onError(event: ErrorEvent): void;
     /** The worker was closed */
     protected onClose(): void;
+    /** Is in detached state, no worker defined */
+    isDetached(): boolean;
     /** Reset the duckdb */
     reset(): Promise<null>;
     /** Ping the worker thread */
@@ -54,7 +63,7 @@ export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     /** Try to drop a file */
     dropFile(name: string): Promise<null>;
     /** Try to drop files */
-    dropFiles(): Promise<null>;
+    dropFiles(names?: string[]): Promise<null>;
     /** Flush all files */
     flushFiles(): Promise<null>;
     /** Open the database */
@@ -75,14 +84,16 @@ export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     disconnect(conn: ConnectionID): Promise<void>;
     /** Run a query */
     runQuery(conn: ConnectionID, text: string): Promise<Uint8Array>;
+    private _runQueryAsync;
     /** Start a pending query */
-    startPendingQuery(conn: ConnectionID, text: string): Promise<Uint8Array | null>;
+    startPendingQuery(conn: ConnectionID, text: string, allowStreamResult?: boolean): Promise<Uint8Array | null>;
+    private _startPendingQueryAsync;
     /** Poll a pending query */
     pollPendingQuery(conn: ConnectionID): Promise<Uint8Array | null>;
     /** Cancel a pending query */
     cancelPendingQuery(conn: ConnectionID): Promise<boolean>;
     /** Fetch query results */
-    fetchQueryResults(conn: ConnectionID): Promise<Uint8Array>;
+    fetchQueryResults(conn: ConnectionID): Promise<Uint8Array | null>;
     /** Get table names */
     getTableNames(conn: number, text: string): Promise<string[]>;
     /** Prepare a statement and return its identifier */
@@ -106,6 +117,8 @@ export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     /** Register a file handle. */
     registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): Promise<void>;
     /** Enable file statistics */
+    registerOPFSFileName(name: string): Promise<void>;
+    /** Enable file statistics */
     collectFileStatistics(name: string, enable: boolean): Promise<void>;
     /** Export file statistics */
     exportFileStatistics(name: string): Promise<FileStatistics>;
@@ -119,4 +132,6 @@ export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     insertCSVFromPath(conn: ConnectionID, path: string, options: CSVInsertOptions): Promise<void>;
     /** Insert a json file */
     insertJSONFromPath(conn: ConnectionID, path: string, options: JSONInsertOptions): Promise<void>;
+    private shouldOPFSFileHandling;
+    private registerOPFSFileFromSQL;
 }

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/parallel/async_bindings_interface.d.ts

@@ -11,10 +11,10 @@ export interface AsyncDuckDBBindings {
     copyFileToBuffer(name: string): Promise<Uint8Array>;
     disconnect(conn: number): Promise<void>;
     runQuery(conn: number, text: string): Promise<Uint8Array>;
-    startPendingQuery(conn: number, text: string): Promise<Uint8Array | null>;
+    startPendingQuery(conn: number, text: string, allowStreamResult: boolean): Promise<Uint8Array | null>;
     pollPendingQuery(conn: number): Promise<Uint8Array | null>;
     cancelPendingQuery(conn: number): Promise<boolean>;
-    fetchQueryResults(conn: number): Promise<Uint8Array>;
+    fetchQueryResults(conn: number): Promise<Uint8Array | null>;
     createPrepared(conn: number, text: string): Promise<number>;
     closePrepared(conn: number, statement: number): Promise<void>;
     runPrepared(conn: number, statement: number, params: any[]): Promise<Uint8Array>;
@@ -22,4 +22,6 @@ export interface AsyncDuckDBBindings {
     insertArrowFromIPCStream(conn: number, buffer: Uint8Array, options?: CSVInsertOptions): Promise<void>;
     insertCSVFromPath(conn: number, path: string, options: CSVInsertOptions): Promise<void>;
     insertJSONFromPath(conn: number, path: string, options: JSONInsertOptions): Promise<void>;
+    dropFile(name: string): Promise<null>;
+    dropFiles(names?: string[]): Promise<null>;
 }

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/parallel/async_connection.d.ts

@@ -21,7 +21,7 @@ export declare class AsyncDuckDBConnection {
     /** Send a query */
     send<T extends {
         [key: string]: arrow.DataType;
-    } = any>(text: string): Promise<arrow.AsyncRecordBatchStreamReader<T>>;
+    } = any>(text: string, allowStreamResult?: boolean): Promise<arrow.AsyncRecordBatchStreamReader<T>>;
     /** Cancel a query that was sent earlier */
     cancelSent(): Promise<boolean>;
     /** Get table names */
@@ -29,7 +29,7 @@ export declare class AsyncDuckDBConnection {
     /** Create a prepared statement */
     prepare<T extends {
         [key: string]: arrow.DataType;
-    } = any>(text: string): Promise<AsyncPreparedStatement>;
+    } = any>(text: string): Promise<AsyncPreparedStatement<T>>;
     /** Insert an arrow table */
     insertArrowTable(table: arrow.Table, options: ArrowInsertOptions): Promise<void>;
     /** Insert an arrow table from an ipc stream */
@@ -49,7 +49,7 @@ export declare class AsyncResultStreamIterator implements AsyncIterable<Uint8Arr
     /** Reached end of stream? */
     protected _depleted: boolean;
     /** In-flight */
-    protected _inFlight: Promise<Uint8Array> | null;
+    protected _inFlight: Promise<Uint8Array | null> | null;
     constructor(db: AsyncDuckDB, conn: number, header: Uint8Array);
     next(): Promise<IteratorResult<Uint8Array>>;
     [Symbol.asyncIterator](): this;

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/parallel/worker_request.d.ts

@@ -1,5 +1,5 @@
 import { CSVInsertOptions, JSONInsertOptions, ArrowInsertOptions } from '../bindings/insert_options';
-import { LogEntryVariant } from '../log';
+import { LogEntryVariant, ProgressEntry } from '../log';
 import { ScriptTokens } from '../bindings/tokens';
 import { FileStatistics } from '../bindings/file_stats';
 import { DuckDBConfig } from '../bindings/config';
@@ -12,6 +12,7 @@ export declare enum WorkerRequestType {
     CANCEL_PENDING_QUERY = "CANCEL_PENDING_QUERY",
     CLOSE_PREPARED = "CLOSE_PREPARED",
     COLLECT_FILE_STATISTICS = "COLLECT_FILE_STATISTICS",
+    REGISTER_OPFS_FILE_NAME = "REGISTER_OPFS_FILE_NAME",
     CONNECT = "CONNECT",
     COPY_FILE_TO_BUFFER = "COPY_FILE_TO_BUFFER",
     COPY_FILE_TO_PATH = "COPY_FILE_TO_PATH",
@@ -53,6 +54,7 @@ export declare enum WorkerResponseType {
     FILE_STATISTICS = "FILE_STATISTICS",
     INSTANTIATE_PROGRESS = "INSTANTIATE_PROGRESS",
     LOG = "LOG",
+    PROGRESS_UPDATE = "PROGRESS_UPDATE",
     OK = "OK",
     PREPARED_STATEMENT_ID = "PREPARED_STATEMENT_ID",
     QUERY_PLAN = "QUERY_PLAN",
@@ -86,14 +88,14 @@ export declare class WorkerTask<T, D, P> {
     promiseRejecter: (value: any) => void;
     constructor(type: T, data: D);
 }
-export type WorkerRequestVariant = WorkerRequest<WorkerRequestType.CLOSE_PREPARED, [ConnectionID, StatementID]> | WorkerRequest<WorkerRequestType.CANCEL_PENDING_QUERY, number> | WorkerRequest<WorkerRequestType.COLLECT_FILE_STATISTICS, [string, boolean]> | WorkerRequest<WorkerRequestType.CONNECT, null> | WorkerRequest<WorkerRequestType.COPY_FILE_TO_BUFFER, string> | WorkerRequest<WorkerRequestType.COPY_FILE_TO_PATH, [string, string]> | WorkerRequest<WorkerRequestType.CREATE_PREPARED, [ConnectionID, string]> | WorkerRequest<WorkerRequestType.DISCONNECT, number> | WorkerRequest<WorkerRequestType.DROP_FILE, string> | WorkerRequest<WorkerRequestType.DROP_FILES, null> | WorkerRequest<WorkerRequestType.EXPORT_FILE_STATISTICS, string> | WorkerRequest<WorkerRequestType.FETCH_QUERY_RESULTS, number> | WorkerRequest<WorkerRequestType.FLUSH_FILES, null> | WorkerRequest<WorkerRequestType.GET_FEATURE_FLAGS, null> | WorkerRequest<WorkerRequestType.GET_TABLE_NAMES, [number, string]> | WorkerRequest<WorkerRequestType.GET_VERSION, null> | WorkerRequest<WorkerRequestType.GLOB_FILE_INFOS, string> | WorkerRequest<WorkerRequestType.INSERT_ARROW_FROM_IPC_STREAM, [
+export type WorkerRequestVariant = WorkerRequest<WorkerRequestType.CLOSE_PREPARED, [ConnectionID, StatementID]> | WorkerRequest<WorkerRequestType.CANCEL_PENDING_QUERY, number> | WorkerRequest<WorkerRequestType.COLLECT_FILE_STATISTICS, [string, boolean]> | WorkerRequest<WorkerRequestType.REGISTER_OPFS_FILE_NAME, [string]> | WorkerRequest<WorkerRequestType.CONNECT, null> | WorkerRequest<WorkerRequestType.COPY_FILE_TO_BUFFER, string> | WorkerRequest<WorkerRequestType.COPY_FILE_TO_PATH, [string, string]> | WorkerRequest<WorkerRequestType.CREATE_PREPARED, [ConnectionID, string]> | WorkerRequest<WorkerRequestType.DISCONNECT, number> | WorkerRequest<WorkerRequestType.DROP_FILE, string> | WorkerRequest<WorkerRequestType.DROP_FILES, string[] | undefined> | WorkerRequest<WorkerRequestType.EXPORT_FILE_STATISTICS, string> | WorkerRequest<WorkerRequestType.FETCH_QUERY_RESULTS, number> | WorkerRequest<WorkerRequestType.FLUSH_FILES, null> | WorkerRequest<WorkerRequestType.GET_FEATURE_FLAGS, null> | WorkerRequest<WorkerRequestType.GET_TABLE_NAMES, [number, string]> | WorkerRequest<WorkerRequestType.GET_VERSION, null> | WorkerRequest<WorkerRequestType.GLOB_FILE_INFOS, string> | WorkerRequest<WorkerRequestType.INSERT_ARROW_FROM_IPC_STREAM, [
     number,
     Uint8Array,
     ArrowInsertOptions | undefined
-]> | WorkerRequest<WorkerRequestType.INSERT_CSV_FROM_PATH, [number, string, CSVInsertOptions]> | WorkerRequest<WorkerRequestType.INSERT_JSON_FROM_PATH, [number, string, JSONInsertOptions]> | WorkerRequest<WorkerRequestType.INSTANTIATE, [string, string | null]> | WorkerRequest<WorkerRequestType.OPEN, DuckDBConfig> | WorkerRequest<WorkerRequestType.PING, null> | WorkerRequest<WorkerRequestType.POLL_PENDING_QUERY, number> | WorkerRequest<WorkerRequestType.REGISTER_FILE_BUFFER, [string, Uint8Array]> | WorkerRequest<WorkerRequestType.REGISTER_FILE_HANDLE, [string, any, DuckDBDataProtocol, boolean]> | WorkerRequest<WorkerRequestType.REGISTER_FILE_URL, [string, string, DuckDBDataProtocol, boolean]> | WorkerRequest<WorkerRequestType.RESET, null> | WorkerRequest<WorkerRequestType.RUN_PREPARED, [number, number, any[]]> | WorkerRequest<WorkerRequestType.RUN_QUERY, [number, string]> | WorkerRequest<WorkerRequestType.SEND_PREPARED, [number, number, any[]]> | WorkerRequest<WorkerRequestType.START_PENDING_QUERY, [number, string]> | WorkerRequest<WorkerRequestType.TOKENIZE, string>;
-export type WorkerResponseVariant = WorkerResponse<WorkerResponseType.CONNECTION_INFO, number> | WorkerResponse<WorkerResponseType.ERROR, any> | WorkerResponse<WorkerResponseType.FEATURE_FLAGS, number> | WorkerResponse<WorkerResponseType.FILE_BUFFER, Uint8Array> | WorkerResponse<WorkerResponseType.FILE_INFOS, WebFile[]> | WorkerResponse<WorkerResponseType.FILE_SIZE, number> | WorkerResponse<WorkerResponseType.FILE_STATISTICS, FileStatistics> | WorkerResponse<WorkerResponseType.INSTANTIATE_PROGRESS, InstantiationProgress> | WorkerResponse<WorkerResponseType.LOG, LogEntryVariant> | WorkerResponse<WorkerResponseType.OK, null> | WorkerResponse<WorkerResponseType.PREPARED_STATEMENT_ID, number> | WorkerResponse<WorkerResponseType.QUERY_PLAN, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT_CHUNK, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT_HEADER, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT_HEADER_OR_NULL, Uint8Array | null> | WorkerResponse<WorkerResponseType.SCRIPT_TOKENS, ScriptTokens> | WorkerResponse<WorkerResponseType.SUCCESS, boolean> | WorkerResponse<WorkerResponseType.TABLE_NAMES, string[]> | WorkerResponse<WorkerResponseType.VERSION_STRING, string>;
-export type WorkerTaskVariant = WorkerTask<WorkerRequestType.COLLECT_FILE_STATISTICS, [string, boolean], null> | WorkerTask<WorkerRequestType.CLOSE_PREPARED, [number, number], null> | WorkerTask<WorkerRequestType.CONNECT, null, ConnectionID> | WorkerTask<WorkerRequestType.COPY_FILE_TO_BUFFER, string, Uint8Array> | WorkerTask<WorkerRequestType.COPY_FILE_TO_PATH, [string, string], null> | WorkerTask<WorkerRequestType.CREATE_PREPARED, [number, string], number> | WorkerTask<WorkerRequestType.DISCONNECT, ConnectionID, null> | WorkerTask<WorkerRequestType.DROP_FILE, string, null> | WorkerTask<WorkerRequestType.DROP_FILES, null, null> | WorkerTask<WorkerRequestType.EXPORT_FILE_STATISTICS, string, FileStatistics> | WorkerTask<WorkerRequestType.FETCH_QUERY_RESULTS, ConnectionID, Uint8Array> | WorkerTask<WorkerRequestType.FLUSH_FILES, null, null> | WorkerTask<WorkerRequestType.GET_FEATURE_FLAGS, null, number> | WorkerTask<WorkerRequestType.GET_TABLE_NAMES, [number, string], string[]> | WorkerTask<WorkerRequestType.GET_VERSION, null, string> | WorkerTask<WorkerRequestType.INSERT_ARROW_FROM_IPC_STREAM, [
+]> | WorkerRequest<WorkerRequestType.INSERT_CSV_FROM_PATH, [number, string, CSVInsertOptions]> | WorkerRequest<WorkerRequestType.INSERT_JSON_FROM_PATH, [number, string, JSONInsertOptions]> | WorkerRequest<WorkerRequestType.INSTANTIATE, [string, string | null]> | WorkerRequest<WorkerRequestType.OPEN, DuckDBConfig> | WorkerRequest<WorkerRequestType.PING, null> | WorkerRequest<WorkerRequestType.POLL_PENDING_QUERY, number> | WorkerRequest<WorkerRequestType.REGISTER_FILE_BUFFER, [string, Uint8Array]> | WorkerRequest<WorkerRequestType.REGISTER_FILE_HANDLE, [string, any, DuckDBDataProtocol, boolean]> | WorkerRequest<WorkerRequestType.REGISTER_FILE_URL, [string, string, DuckDBDataProtocol, boolean]> | WorkerRequest<WorkerRequestType.RESET, null> | WorkerRequest<WorkerRequestType.RUN_PREPARED, [number, number, any[]]> | WorkerRequest<WorkerRequestType.RUN_QUERY, [number, string]> | WorkerRequest<WorkerRequestType.SEND_PREPARED, [number, number, any[]]> | WorkerRequest<WorkerRequestType.START_PENDING_QUERY, [number, string, boolean]> | WorkerRequest<WorkerRequestType.TOKENIZE, string>;
+export type WorkerResponseVariant = WorkerResponse<WorkerResponseType.CONNECTION_INFO, number> | WorkerResponse<WorkerResponseType.ERROR, any> | WorkerResponse<WorkerResponseType.FEATURE_FLAGS, number> | WorkerResponse<WorkerResponseType.FILE_BUFFER, Uint8Array> | WorkerResponse<WorkerResponseType.FILE_INFOS, WebFile[]> | WorkerResponse<WorkerResponseType.FILE_SIZE, number> | WorkerResponse<WorkerResponseType.FILE_STATISTICS, FileStatistics> | WorkerResponse<WorkerResponseType.INSTANTIATE_PROGRESS, InstantiationProgress> | WorkerResponse<WorkerResponseType.LOG, LogEntryVariant> | WorkerResponse<WorkerResponseType.PROGRESS_UPDATE, ProgressEntry> | WorkerResponse<WorkerResponseType.OK, null> | WorkerResponse<WorkerResponseType.PREPARED_STATEMENT_ID, number> | WorkerResponse<WorkerResponseType.QUERY_PLAN, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT_CHUNK, Uint8Array | null> | WorkerResponse<WorkerResponseType.QUERY_RESULT_HEADER, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT_HEADER_OR_NULL, Uint8Array | null> | WorkerResponse<WorkerResponseType.SCRIPT_TOKENS, ScriptTokens> | WorkerResponse<WorkerResponseType.SUCCESS, boolean> | WorkerResponse<WorkerResponseType.TABLE_NAMES, string[]> | WorkerResponse<WorkerResponseType.VERSION_STRING, string>;
+export type WorkerTaskVariant = WorkerTask<WorkerRequestType.COLLECT_FILE_STATISTICS, [string, boolean], null> | WorkerTask<WorkerRequestType.REGISTER_OPFS_FILE_NAME, [string], null> | WorkerTask<WorkerRequestType.CLOSE_PREPARED, [number, number], null> | WorkerTask<WorkerRequestType.CONNECT, null, ConnectionID> | WorkerTask<WorkerRequestType.COPY_FILE_TO_BUFFER, string, Uint8Array> | WorkerTask<WorkerRequestType.COPY_FILE_TO_PATH, [string, string], null> | WorkerTask<WorkerRequestType.CREATE_PREPARED, [number, string], number> | WorkerTask<WorkerRequestType.DISCONNECT, ConnectionID, null> | WorkerTask<WorkerRequestType.DROP_FILE, string, null> | WorkerTask<WorkerRequestType.DROP_FILES, string[] | undefined, null> | WorkerTask<WorkerRequestType.EXPORT_FILE_STATISTICS, string, FileStatistics> | WorkerTask<WorkerRequestType.FETCH_QUERY_RESULTS, ConnectionID, Uint8Array | null> | WorkerTask<WorkerRequestType.FLUSH_FILES, null, null> | WorkerTask<WorkerRequestType.GET_FEATURE_FLAGS, null, number> | WorkerTask<WorkerRequestType.GET_TABLE_NAMES, [number, string], string[]> | WorkerTask<WorkerRequestType.GET_VERSION, null, string> | WorkerTask<WorkerRequestType.INSERT_ARROW_FROM_IPC_STREAM, [
     number,
     Uint8Array,
     ArrowInsertOptions | undefined
-], null> | WorkerTask<WorkerRequestType.INSERT_CSV_FROM_PATH, [number, string, CSVInsertOptions], null> | WorkerTask<WorkerRequestType.INSERT_JSON_FROM_PATH, [number, string, JSONInsertOptions], null> | WorkerTask<WorkerRequestType.INSTANTIATE, [string, string | null], null> | WorkerTask<WorkerRequestType.OPEN, DuckDBConfig, null> | WorkerTask<WorkerRequestType.PING, null, null> | WorkerTask<WorkerRequestType.REGISTER_FILE_BUFFER, [string, Uint8Array], null> | WorkerTask<WorkerRequestType.REGISTER_FILE_HANDLE, [string, any, DuckDBDataProtocol, boolean], null> | WorkerTask<WorkerRequestType.REGISTER_FILE_URL, [string, string, DuckDBDataProtocol, boolean], null> | WorkerTask<WorkerRequestType.GLOB_FILE_INFOS, string, WebFile[]> | WorkerTask<WorkerRequestType.RESET, null, null> | WorkerTask<WorkerRequestType.RUN_PREPARED, [number, number, any[]], Uint8Array> | WorkerTask<WorkerRequestType.RUN_QUERY, [ConnectionID, string], Uint8Array> | WorkerTask<WorkerRequestType.SEND_PREPARED, [number, number, any[]], Uint8Array> | WorkerTask<WorkerRequestType.START_PENDING_QUERY, [ConnectionID, string], Uint8Array | null> | WorkerTask<WorkerRequestType.POLL_PENDING_QUERY, ConnectionID, Uint8Array | null> | WorkerTask<WorkerRequestType.CANCEL_PENDING_QUERY, ConnectionID, boolean> | WorkerTask<WorkerRequestType.TOKENIZE, string, ScriptTokens>;
+], null> | WorkerTask<WorkerRequestType.INSERT_CSV_FROM_PATH, [number, string, CSVInsertOptions], null> | WorkerTask<WorkerRequestType.INSERT_JSON_FROM_PATH, [number, string, JSONInsertOptions], null> | WorkerTask<WorkerRequestType.INSTANTIATE, [string, string | null], null> | WorkerTask<WorkerRequestType.OPEN, DuckDBConfig, null> | WorkerTask<WorkerRequestType.PING, null, null> | WorkerTask<WorkerRequestType.REGISTER_FILE_BUFFER, [string, Uint8Array], null> | WorkerTask<WorkerRequestType.REGISTER_FILE_HANDLE, [string, any, DuckDBDataProtocol, boolean], null> | WorkerTask<WorkerRequestType.REGISTER_FILE_URL, [string, string, DuckDBDataProtocol, boolean], null> | WorkerTask<WorkerRequestType.GLOB_FILE_INFOS, string, WebFile[]> | WorkerTask<WorkerRequestType.RESET, null, null> | WorkerTask<WorkerRequestType.RUN_PREPARED, [number, number, any[]], Uint8Array> | WorkerTask<WorkerRequestType.RUN_QUERY, [ConnectionID, string], Uint8Array> | WorkerTask<WorkerRequestType.SEND_PREPARED, [number, number, any[]], Uint8Array> | WorkerTask<WorkerRequestType.START_PENDING_QUERY, [ConnectionID, string, boolean], Uint8Array | null> | WorkerTask<WorkerRequestType.POLL_PENDING_QUERY, ConnectionID, Uint8Array | null> | WorkerTask<WorkerRequestType.CANCEL_PENDING_QUERY, ConnectionID, boolean> | WorkerTask<WorkerRequestType.TOKENIZE, string, ScriptTokens>;

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/platform.d.ts

@@ -2,10 +2,10 @@ export declare const isNode: () => boolean;
 export declare const isFirefox: () => boolean;
 export declare const isSafari: () => boolean;
 /** Bundles have different characteristics:
-  * - MVP: minimum viable product (uses features from first stable version of WebAssembly standard)
-  * - EH: exception handling
-  * - COI: cross origin isolation
-  */
+ * - MVP: minimum viable product (uses features from first stable version of WebAssembly standard)
+ * - EH: exception handling
+ * - COI: cross origin isolation
+ */
 export interface DuckDBBundles {
     mvp: {
         mainModule: string;

package/types/@duckdb/duckdb-wasm/status.d.ts

@@ -0,0 +1,7 @@
+export declare enum StatusCode {
+    SUCCESS = 0,
+    MAX_ARROW_ERROR = 255,
+    DUCKDB_WASM_RETRY = 256
+}
+export declare function IsArrowBuffer(status: StatusCode): boolean;
+export declare function IsDuckDBWasmRetry(status: StatusCode): boolean;

package/types/@duckdb/duckdb-wasm/utils/opfs_util.d.ts

@@ -0,0 +1,4 @@
+export declare const REGEX_OPFS_FILE: RegExp;
+export declare const REGEX_OPFS_PROTOCOL: RegExp;
+export declare function isOPFSProtocol(path: string): boolean;
+export declare function searchOPFSFiles(text: string): string[];

package/types/{duckdb-wasm → @duckdb/duckdb-wasm}/utils/s3_helper.d.ts

@@ -1,4 +1,4 @@
-import { S3Config } from "../bindings";
+import { S3Config } from '../bindings';
 export interface S3Params {
     url: string;
     query: string;

package/types/{motherduck → @motherduck}/duckdb-arrow/AsyncDuckDBRecordBatchIterator.d.ts

@@ -1,5 +1,5 @@
 import { RecordBatch } from 'apache-arrow';
-import { AsyncDuckDBDataBatchIterator, DuckDBData, DuckDBDataBatchIteratorResult } from '../../motherduck/duckdb-data';
+import { AsyncDuckDBDataBatchIterator, DuckDBData, DuckDBDataBatchIteratorResult } from '../../@duckdb/data-reader';
 import { TypedTypeMap } from './TypedTypeMap.js';
 export type AsyncRecordBatchIterator = AsyncIterator<RecordBatch<TypedTypeMap>, RecordBatch<TypedTypeMap> | undefined>;
 export declare class AsyncDuckDBRecordBatchIterator implements AsyncDuckDBDataBatchIterator {