@romedb/node 0.2.13 → 0.2.14

package/README.md

@@ -23,7 +23,7 @@ version, 0.2.12, differs from its asset only in `package.json` and this README.
 project can also depend on the asset of a GitHub release by URL:
 
 ```sh
-pnpm add https://github.com/romedb/romedb/releases/download/romedb-v0.2.13/romedb-node-0.2.13.tgz
+pnpm add https://github.com/romedb/romedb/releases/download/romedb-v0.2.14/romedb-node-0.2.14.tgz
 ```
 
 ## A first database
@@ -125,7 +125,7 @@ own connection.
 | `boolean`, `null`, `string` | The same type |
 | Array, plain object | Array, object |
 | `Buffer`, `Uint8Array` | Binary |
-| `Record(table, key)` | A record ID. The key is a string or a `bigint`. |
+| `Record(table, key)` | A record ID. The key is a string or a `bigint`. `String(record)` gives `table:key`, and `record.equals(other)` compares the table and the key. |
 | `Vector` | A vector of validated native-format bytes. See [typed vectors](#typed-vectors). |
 
 RomeDB never makes a reference from a string. Unsupported JavaScript types,
@@ -702,8 +702,30 @@ it. Exports have no deadline unless you pass `timeoutMs`. `signal`, `timeoutMs`
 `close()` cancel a running export. It then rejects with `RDB_CANCELLED`, unless it
 finished first.
 
-The URL client has the streaming form, `rql.exportFile({ signal, timeoutMs })`, for
-`romedb serve` and `serve --directory`. Cloud URLs do not support it yet. See
+#### Leaving data out of a copy
+
+A whole copy holds everything, including sessions and tokens. Use `emptyTables` when
+someone else gets the file:
+
+```js
+await rql.exportFile('site.romedb', { emptyTables: ['cms_auth_sessions', 'cms_cache'] });
+```
+
+- The named tables keep their schema and indexes, but no rows.
+- Their rows are never read, so they cannot reach the file. They are not in freed
+  pages, a log or a receipt.
+- A name that is not a table fails with `RDB_VALIDATION`.
+- An edge table must be emptied together with the tables it connects.
+- Rows in other tables keep their references to the emptied rows.
+- The copy also gets a new identity, because a receipt can hold row data.
+
+Use `newIdentity: true` to copy every row into a new database, for example to
+duplicate a site. The copy leaves out the database ID, the sequence and the receipts.
+Its sequence starts at 0, and it gets a new ID the first time it opens.
+
+The URL client has the streaming form, `rql.exportFile({ signal, timeoutMs, emptyTables,
+newIdentity })`, for `romedb serve`, `serve --directory` and Cloud. On Cloud, set
+`timeoutMs` high enough for the size of the database: a job builds the file first. See
 [database files](https://github.com/romedb/romedb/blob/main/romedb/docs/service-protocol.md#database-files) for how the copy is
 made.
 

package/THIRD_PARTY_CRATE_NOTICES.md

@@ -4,7 +4,7 @@ Generated from the pinned Cargo dependency inventory and checksummed source arch
 
 This is a partial notice collection. It supplements LICENSE.md and THIRD_PARTY_NOTICES.md. Inline attributions, unconventional filenames and other bundled components require further review before a complete distribution-notice claim.
 
-Target: `x86_64-unknown-linux-gnu`. Cargo.lock SHA-256: `092e973bbc52cf5defe48c0c1c1cf5bc8755b603f5a6ef47927c31bfa5276aa3`.
+Target: `x86_64-unknown-linux-gnu`. Cargo.lock SHA-256: `1bceceb035554db77bd940502707e4fea905a961d66b28cdbb2ca9b7206c5964`.
 
 ## Packages without collected archive or supplemental texts
 
@@ -703,13 +703,13 @@ Target: `x86_64-unknown-linux-gnu`. Cargo.lock SHA-256: `092e973bbc52cf5defe48c0
 - `LICENSE-APACHE`: [source text a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2](#text-a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2)
 - `LICENSE-MIT`: [source text 42d3bf7e7d4d49d72c0555d14ed99c3ee7ce9ce3cbffbc38bbafe8c103f50969](#text-42d3bf7e7d4d49d72c0555d14ed99c3ee7ce9ce3cbffbc38bbafe8c103f50969)
 
-### romedb-node 0.2.13
+### romedb-node 0.2.14
 - Workspace `LICENSE.md`: [source text b646f9ee8bcaf87e8de75153b9df7a2861c7ac445c87e741768b3c2bccf47bc5](#text-b646f9ee8bcaf87e8de75153b9df7a2861c7ac445c87e741768b3c2bccf47bc5)
 
-### romedb 0.2.13
+### romedb 0.2.14
 - Workspace `LICENSE.md`: [source text b646f9ee8bcaf87e8de75153b9df7a2861c7ac445c87e741768b3c2bccf47bc5](#text-b646f9ee8bcaf87e8de75153b9df7a2861c7ac445c87e741768b3c2bccf47bc5)
 
-### romeql-parser 0.2.13
+### romeql-parser 0.2.14
 - Workspace `LICENSE.md`: [source text b646f9ee8bcaf87e8de75153b9df7a2861c7ac445c87e741768b3c2bccf47bc5](#text-b646f9ee8bcaf87e8de75153b9df7a2861c7ac445c87e741768b3c2bccf47bc5)
 
 ### rquickjs-core 0.13.0

package/client.cjs

@@ -1,6 +1,6 @@
 'use strict';
 // Web APIs only: this file also runs in Workers and browsers through client.mjs.
-const { Float64, Record, Vector, encodeValue, decodeValue, plainObject, text } = require('./values.cjs');
+const { Float64, Record, Vector, encodeValue, decodeValue, plainObject, text, checkCopyOptions } = require('./values.cjs');
 
 const MAX_REQUEST = 65_536;
 const MAX_CLOUD_REQUEST = 1_048_576;
@@ -161,8 +161,8 @@ class RemoteDatabase {
   async exportFile(options = {}) {
     this.#assertOpen();
     if (this.#transport) throw new ClientError('RDB_UNSUPPORTED', 'Export embedded databases through EmbeddedDatabase.exportFile', 'not-sent');
-    if (this.#cloud) throw new ClientError('RDB_UNSUPPORTED', 'Cloud databases do not export database files yet', 'not-sent');
-    if (!plainObject(options) || Object.keys(options).some(key => !['signal', 'timeoutMs'].includes(key))) throw new TypeError('export options take signal and timeoutMs');
+    if (!plainObject(options) || Object.keys(options).some(key => !['signal', 'timeoutMs', 'emptyTables', 'newIdentity'].includes(key))) throw new TypeError('export options take signal, timeoutMs, emptyTables and newIdentity');
+    checkCopyOptions(options);
     const duration = timeout(options.timeoutMs ?? this.#timeout);
     if (options.signal !== undefined && !(options.signal instanceof AbortSignal)) throw new TypeError('signal must be an AbortSignal');
     if (options.signal?.aborted) throw new ClientError('RDB_CANCELLED', 'Request cancelled before dispatch', 'not-sent');
@@ -183,7 +183,7 @@ class RemoteDatabase {
     const credential = this.#token;
     let status;
     try {
-      const response = await this.#fetch(this.#url + '/file', {
+      const response = await this.#fetch(this.#url + '/file' + fileQuery(options), {
         method: 'GET',
         headers: { authorization: `Bearer ${credential}`, accept: `${DATABASE_FILE_TYPE}, application/json`, ...(this.#id === undefined ? {} : { 'x-romedb-database-id': this.#id }) },
         redirect: 'manual', signal: controller.signal,
@@ -473,6 +473,12 @@ function pause(ms, signal) {
     signal.addEventListener('abort', stop, { once: true });
   });
 }
+function fileQuery({ emptyTables, newIdentity }) {
+  const parts = [];
+  if (emptyTables?.length) parts.push(`empty=${emptyTables.map(encodeURIComponent).join(',')}`);
+  if (newIdentity) parts.push('identity=new');
+  return parts.length ? `?${parts.join('&')}` : '';
+}
 function httpCode(status) { return status === 401 ? 'RDB_AUTH' : status === 403 ? 'RDB_FORBIDDEN' : status === 409 ? 'RDB_CONFLICT' : status === 429 || status === 413 ? 'RDB_LIMIT' : 'RDB_REMOTE'; }
 function redactMessage(message, token) { return (token ? message.replaceAll(token, '[redacted]') : message).slice(0, 2048); }
 function safeMessage(reply, token) { return redactMessage(typeof reply?.error === 'string' ? reply.error : typeof reply?.error?.message === 'string' ? reply.error.message : 'Database request was rejected', token); }

package/client.d.ts

@@ -2,6 +2,18 @@ import type { Value } from './values';
 export { Float64, Record, Vector, Value, PortableValue, encodeValue, decodeValue } from './values';
 export interface Statement { sql: string; params?: { [key: string]: Value }; }
 export interface RequestOptions { signal?: AbortSignal; timeoutMs?: number; }
+/** What a copy of the database leaves out. */
+export interface CopyOptions {
+  /**
+   * These tables keep their schema and indexes but no rows. Their rows are never read, so
+   * they cannot reach the file. Unknown names fail with RDB_VALIDATION. The copy also gets
+   * a new identity, because a receipt can hold row data.
+   */
+  emptyTables?: readonly string[];
+  /** Leave out the database ID, the sequence and the receipts: the copy is a new database. */
+  newIdentity?: boolean;
+}
+export interface FileExportOptions extends RequestOptions, CopyOptions {}
 export interface WorkLimits { rowsRead?: number; rowMutations?: number; vmSteps?: number; }
 export interface ReadOptions extends RequestOptions { afterSequence?: number; workLimits?: WorkLimits; }
 export interface WriteOptions extends ReadOptions { requestId?: string; ifSequence?: number; }
@@ -73,7 +85,7 @@ export class RemoteDatabase implements Client {
    * Download the database as a .romedb file (romedb serve and serve --directory; not Cloud yet).
    * timeoutMs covers building the copy, until the file starts arriving; signal also stops the download.
    */
-  exportFile(options?: RequestOptions): Promise<DatabaseFile>;
+  exportFile(options?: FileExportOptions): Promise<DatabaseFile>;
   readonly sequence: number;
   readonly databaseId: string;
   info(options?: RequestOptions): Promise<DatabaseInfo>;

package/client.mjs

@@ -5,7 +5,7 @@ const commonjs = { exports: {} };
 (function (module, exports, require) {
 'use strict';
 // Web APIs only: this file also runs in Workers and browsers through client.mjs.
-const { Float64, Record, Vector, encodeValue, decodeValue, plainObject, text } = require('./values.cjs');
+const { Float64, Record, Vector, encodeValue, decodeValue, plainObject, text, checkCopyOptions } = require('./values.cjs');
 
 const MAX_REQUEST = 65_536;
 const MAX_CLOUD_REQUEST = 1_048_576;
@@ -166,8 +166,8 @@ class RemoteDatabase {
   async exportFile(options = {}) {
     this.#assertOpen();
     if (this.#transport) throw new ClientError('RDB_UNSUPPORTED', 'Export embedded databases through EmbeddedDatabase.exportFile', 'not-sent');
-    if (this.#cloud) throw new ClientError('RDB_UNSUPPORTED', 'Cloud databases do not export database files yet', 'not-sent');
-    if (!plainObject(options) || Object.keys(options).some(key => !['signal', 'timeoutMs'].includes(key))) throw new TypeError('export options take signal and timeoutMs');
+    if (!plainObject(options) || Object.keys(options).some(key => !['signal', 'timeoutMs', 'emptyTables', 'newIdentity'].includes(key))) throw new TypeError('export options take signal, timeoutMs, emptyTables and newIdentity');
+    checkCopyOptions(options);
     const duration = timeout(options.timeoutMs ?? this.#timeout);
     if (options.signal !== undefined && !(options.signal instanceof AbortSignal)) throw new TypeError('signal must be an AbortSignal');
     if (options.signal?.aborted) throw new ClientError('RDB_CANCELLED', 'Request cancelled before dispatch', 'not-sent');
@@ -188,7 +188,7 @@ class RemoteDatabase {
     const credential = this.#token;
     let status;
     try {
-      const response = await this.#fetch(this.#url + '/file', {
+      const response = await this.#fetch(this.#url + '/file' + fileQuery(options), {
         method: 'GET',
         headers: { authorization: `Bearer ${credential}`, accept: `${DATABASE_FILE_TYPE}, application/json`, ...(this.#id === undefined ? {} : { 'x-romedb-database-id': this.#id }) },
         redirect: 'manual', signal: controller.signal,
@@ -478,6 +478,12 @@ function pause(ms, signal) {
     signal.addEventListener('abort', stop, { once: true });
   });
 }
+function fileQuery({ emptyTables, newIdentity }) {
+  const parts = [];
+  if (emptyTables?.length) parts.push(`empty=${emptyTables.map(encodeURIComponent).join(',')}`);
+  if (newIdentity) parts.push('identity=new');
+  return parts.length ? `?${parts.join('&')}` : '';
+}
 function httpCode(status) { return status === 401 ? 'RDB_AUTH' : status === 403 ? 'RDB_FORBIDDEN' : status === 409 ? 'RDB_CONFLICT' : status === 429 || status === 413 ? 'RDB_LIMIT' : 'RDB_REMOTE'; }
 function redactMessage(message, token) { return (token ? message.replaceAll(token, '[redacted]') : message).slice(0, 2048); }
 function safeMessage(reply, token) { return redactMessage(typeof reply?.error === 'string' ? reply.error : typeof reply?.error?.message === 'string' ? reply.error.message : 'Database request was rejected', token); }

package/embedded-client.cjs

@@ -7,7 +7,7 @@ const path = require('node:path');
 const { pathToFileURL } = require('node:url');
 const common = require('./client.cjs');
 const { connect, RemoteDatabase, ClientError, Float64, Record, Vector, encodeValue, decodeValue, normalizeUrl, validatePrepared, saveRequest, loadRequest } = common;
-const { plainObject } = require('./values.cjs');
+const { plainObject, checkCopyOptions } = require('./values.cjs');
 const { createEmbeddedClient } = require('./client-internal.cjs');
 const native = require('./native.cjs');
 const sessions = new Map();
@@ -73,7 +73,8 @@ async function openEmbeddedFile(options) {
 }
 
 function checkExportOptions(options) {
-  if (!plainObject(options) || Object.keys(options).some(key => !['signal', 'timeoutMs'].includes(key))) throw new TypeError('export options take signal and timeoutMs');
+  if (!plainObject(options) || Object.keys(options).some(key => !['signal', 'timeoutMs', 'emptyTables', 'newIdentity'].includes(key))) throw new TypeError('export options take signal, timeoutMs, emptyTables and newIdentity');
+  checkCopyOptions(options);
   if (options.signal !== undefined && !(options.signal instanceof AbortSignal)) throw new TypeError('signal must be an AbortSignal');
   if (options.timeoutMs !== undefined && (!Number.isInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 4294967295)) throw new RangeError('timeoutMs must be 1..4294967295');
 }
@@ -131,7 +132,7 @@ class EmbeddedDatabase {
   async #exportTo(destination, options) {
     checkExportOptions(options);
     if (!destination || destination.length > 4096 || destination.includes('\0')) throw new TypeError('exportFile requires a bounded destination path');
-    const { sequence, bytes } = await this.#session.request('export', JSON.stringify({ destination: path.resolve(destination) }), options.signal, options.timeoutMs);
+    const { sequence, bytes } = await this.#session.request('export', JSON.stringify({ destination: path.resolve(destination), emptyTables: options.emptyTables, newIdentity: options.newIdentity }), options.signal, options.timeoutMs);
     return { sequence, bytes };
   }
   async #exportStream(options) {

package/embedded-client.d.ts

@@ -1,7 +1,7 @@
 export * from './client';
-import type { Client, DatabaseInfo, Statement, RequestOptions, ReadOptions, WriteOptions, BatchResult, PreparedWrite, DatabaseFile } from './client';
+import type { Client, DatabaseInfo, Statement, RequestOptions, ReadOptions, WriteOptions, BatchResult, PreparedWrite, DatabaseFile, FileExportOptions } from './client';
 /** timeoutMs has no default for exports: without it, an export runs until it finishes or signal aborts it. */
-export interface ExportOptions { signal?: AbortSignal; timeoutMs?: number; }
+export interface ExportOptions extends FileExportOptions {}
 export interface ExportedFile { sequence: number; bytes: number; }
 export interface EmbeddedOptions { path: string; create?: boolean; timeoutMs?: number; maxOpen?: number; }
 export class EmbeddedDatabase implements Client {

package/embedded-worker.cjs

@@ -35,7 +35,8 @@ if (database) parentPort.on('message', ({ id, operation, body, cancellationKey }
     if (fenced) fail('RDB_STORAGE', 'Embedded outcome is uncertain; close and reconcile the database', 'unknown');
     if (operation === 'export') {
       // Writes run on this thread, so none commits between the start of the copy's snapshot and reading the sequence.
-      const pending = database.startFileExport(JSON.parse(body).destination, cancellationKey);
+      const copy = JSON.parse(body);
+      const pending = database.startFileExport(copy.destination, cancellationKey, copy.emptyTables, copy.newIdentity);
       const snapshot = sequence;
       const finished = pending.finish().then(
         bytes => parentPort.postMessage({ id, result: { sequence: snapshot, bytes: Number(bytes) } }),

package/index.cjs

@@ -1,4 +1,5 @@
 'use strict';
+const { checkCopyOptions } = require('./values.cjs');
 const { NativeDatabase, interruptConnection, createCancellationToken, cancelOperation, releaseCancellationToken, vectorFromComponents, vectorFromSparseEntries } = require('./native.cjs');
 class Record {
   constructor(table, key) {
@@ -6,6 +7,8 @@ class Record {
     this.table = table; this.key = key;
     Object.freeze(this);
   }
+  toString() { return `${this.table}:${this.key}`; }
+  equals(other) { return other instanceof Record && other.table === this.table && other.key === this.key; }
 }
 class Vector {
   static float32(values) { return constructVector('float32', values); }
@@ -414,7 +417,9 @@ class AsyncDatabase {
   }
   async exportFile(destination, options = {}) {
     if (typeof destination !== 'string' || !destination || destination.length > 4096 || destination.includes('\0')) throw new TypeError('exportFile requires a bounded destination path');
-    try { return await this.#request('exportFile', [require('node:path').resolve(destination)], false, options.signal, options.timeoutMs); }
+    checkCopyOptions(options);
+    const copy = JSON.stringify({ emptyTables: options.emptyTables, newIdentity: options.newIdentity });
+    try { return await this.#request('exportFile', [require('node:path').resolve(destination), copy], false, options.signal, options.timeoutMs); }
     catch (error) {
       const coded = /^(RDB_[A-Z0-9_]+): (.*)$/s.exec(error.message);
       if (!coded) throw error;

package/index.d.ts

@@ -67,6 +67,12 @@ export class Database {
 
 export interface ExecuteOptions { signal?: AbortSignal; timeoutMs?: number; }
 export interface FileExport { bytes: number; }
+export interface FileExportOptions extends ExecuteOptions {
+  /** These tables keep their schema and indexes but no rows, and the copy gets a new identity. */
+  emptyTables?: readonly string[];
+  /** Leave out the database ID, the sequence and the receipts: the copy is a new database. */
+  newIdentity?: boolean;
+}
 export class AsyncDatabase {
   collection<T extends object = Document>(name: string): AsyncCollection<T>;
   private constructor();
@@ -77,7 +83,7 @@ export class AsyncDatabase {
   exportDocuments(table: string, format?: TransferFormat, options?: ExecuteOptions): Promise<string>;
   importDocuments(table: string, input: string, format?: TransferFormat, options?: ExecuteOptions): Promise<ImportReport>;
   /** Copy an MVCC database into a new private file while queries continue; the destination and its log files must not exist. */
-  exportFile(destination: string, options?: ExecuteOptions): Promise<FileExport>;
+  exportFile(destination: string, options?: FileExportOptions): Promise<FileExport>;
   execute(sql: string, parameters?: Parameters, options?: ExecuteOptions): Promise<QueryResult>;
   profileSelect(sql: string, parameters?: Parameters, options?: ExecuteOptions): Promise<ProfiledQuery>;
   /** Checks write results atomically; does not bound engine or logical materialization memory. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@romedb/node",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "RomeDB for Node.js: the embedded database (Linux x64 native addon) and a Web-API client for romedb serve and RomeDB Cloud",
   "main": "index.cjs",
   "types": "index.d.ts",

package/romedb.node

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/romedb.node
-size: 41428704 bytes
-sha256: 3baeea0d26a9eb94d1cad57563330062c82226e3ecd7de6ce1394f96c6f893a8
+size: 41464424 bytes
+sha256: d98971746cedc29b00b8333f763433c47db42f65306b933966e636e0221aac3c

package/values.cjs

@@ -18,6 +18,8 @@ class Record {
     this.key = key;
     Object.freeze(this);
   }
+  toString() { return `${this.table}:${this.key}`; }
+  equals(other) { return other instanceof Record && other.table === this.table && other.key === this.key; }
 }
 
 class Vector {
@@ -204,8 +206,16 @@ function checkDepth(depth) {
   if (depth > 64) throw new RangeError('value nesting exceeds 64');
 }
 
+function checkCopyOptions(options) {
+  const { emptyTables, newIdentity } = options;
+  if (emptyTables !== undefined && (!Array.isArray(emptyTables) || emptyTables.length > 256 || emptyTables.some(name => typeof name !== 'string' || !name || name.length > 255 || /[,\0]/.test(name)))) {
+    throw new TypeError('emptyTables takes up to 256 table names without commas');
+  }
+  if (newIdentity !== undefined && typeof newIdentity !== 'boolean') throw new TypeError('newIdentity must be a boolean');
+}
+
 function plainObject(value) {
   return value !== null && typeof value === 'object' && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
 }
 
-module.exports = { Float64, Record, Vector, encodeValue, decodeValue, plainObject, text };
+module.exports = { Float64, Record, Vector, encodeValue, decodeValue, plainObject, text, checkCopyOptions };

package/values.d.ts

@@ -1,5 +1,5 @@
 export class Float64 { constructor(value: number); readonly value: number; }
-export class Record { constructor(table: string, key: string | bigint); readonly table: string; readonly key: string | bigint; }
+export class Record { constructor(table: string, key: string | bigint); readonly table: string; readonly key: string | bigint; /** `table:key`. */ toString(): string; /** The same table and key, including the key's type. */ equals(other: unknown): boolean; }
 export class Vector {
   constructor(bytes: Uint8Array);
   /** A copy of the encoded bytes. */

package/values.mjs

@@ -22,6 +22,8 @@ class Record {
     this.key = key;
     Object.freeze(this);
   }
+  toString() { return `${this.table}:${this.key}`; }
+  equals(other) { return other instanceof Record && other.table === this.table && other.key === this.key; }
 }
 
 class Vector {
@@ -208,13 +210,21 @@ function checkDepth(depth) {
   if (depth > 64) throw new RangeError('value nesting exceeds 64');
 }
 
+function checkCopyOptions(options) {
+  const { emptyTables, newIdentity } = options;
+  if (emptyTables !== undefined && (!Array.isArray(emptyTables) || emptyTables.length > 256 || emptyTables.some(name => typeof name !== 'string' || !name || name.length > 255 || /[,\0]/.test(name)))) {
+    throw new TypeError('emptyTables takes up to 256 table names without commas');
+  }
+  if (newIdentity !== undefined && typeof newIdentity !== 'boolean') throw new TypeError('newIdentity must be a boolean');
+}
+
 function plainObject(value) {
   return value !== null && typeof value === 'object' && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
 }
 
-module.exports = { Float64, Record, Vector, encodeValue, decodeValue, plainObject, text };
+module.exports = { Float64, Record, Vector, encodeValue, decodeValue, plainObject, text, checkCopyOptions };
 })(commonjs, commonjs.exports, specifier => {
   throw new TypeError(`Cannot load ${specifier}`);
 });
 
-export const { Float64, Record, Vector, encodeValue, decodeValue, plainObject, text } = commonjs.exports;
+export const { Float64, Record, Vector, encodeValue, decodeValue, plainObject, text, checkCopyOptions } = commonjs.exports;

package/worker.cjs

@@ -10,7 +10,7 @@ parentPort.on('message', ({ id, method, args, cancellationKey }) => {
     if (method === 'exportFile') {
       const key = cancellationKey ?? createCancellationToken();
       const finished = Promise.resolve()
-        .then(() => db.startFileExport(args[0], key).finish())
+        .then(() => { const copy = JSON.parse(args[1]); return db.startFileExport(args[0], key, copy.emptyTables, copy.newIdentity).finish(); })
         .then(bytes => parentPort.postMessage({ id, result: { bytes: Number(bytes) } }), error => parentPort.postMessage({ id, error: { message: error.message } }))
         .finally(() => { copies.delete(key); if (cancellationKey === undefined) releaseCancellationToken(key); });
       copies.set(key, finished);