@delali/sirannon-sqlite 0.0.0-stage → 0.3.5-next.72

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Delali (https://sondelali.com)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,61 @@
+sirannon-db
+Copyright 2026 Delali (https://sondelali.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+This product includes code from these projects:
+
+- workerd (https://github.com/cloudflare/workerd), licensed under the Apache
+  License, Version 2.0. native/sqlite/patches/sqlite/0001-row-counts.patch
+  starts from workerd's patches/sqlite/0001-row-counts-plain.patch, without
+  its comments and its shell hunk, and its header lists the changes that
+  Sirannon made to it.
+- libSQL (https://github.com/tursodatabase/libsql), Copyright 2022 the libSQL
+  authors, licensed under the MIT License. workerd's row-count patch contains
+  libSQL's row-counting code.
+- node-gyp (https://github.com/nodejs/node-gyp), Copyright (c) 2012 Nathan
+  Rajlich, licensed under the MIT License. native/sqlite/win-delay-load-hook.cc
+  follows node-gyp's src/win_delay_load_hook.cc.
+- better-sqlite3 (https://github.com/WiseLibs/better-sqlite3), Copyright (c)
+  2017 Joshua Wise, licensed under the MIT License.
+  The patches in native/sqlite/patches/better-sqlite3 change better-sqlite3's
+  source.
+  The lib directory of the @delali/sirannon-sqlite package contains
+  better-sqlite3's JavaScript unchanged, and each
+  @delali/sirannon-sqlite-<platform> package contains better-sqlite3's native
+  module compiled from that changed source.
+- node-addon-api (https://github.com/nodejs/node-addon-api), Copyright (c)
+  2017 Node.js API collaborators, licensed under the MIT License. Each
+  @delali/sirannon-sqlite-<platform> package contains code compiled from
+  node-addon-api's headers.
+
+The MIT License grants the following permission for libSQL, node-gyp,
+better-sqlite3, and node-addon-api:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,36 @@
-# Temporary Holding Version
+# @delali/sirannon-sqlite
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm](https://img.shields.io/npm/v/@delali/sirannon-sqlite)](https://www.npmjs.com/package/@delali/sirannon-sqlite)
+[![license](https://img.shields.io/npm/l/@delali/sirannon-sqlite)](https://github.com/assetcorp/sirannon-db/blob/main/LICENSE)
+
+This package contains better-sqlite3 13.0.2, built against Sirannon's own build of SQLite, which counts the rows that each statement reads and writes. When you pass `rowCounts: true`, Sirannon's better-sqlite3 driver loads this package and reports both counts for every statement through `onQueryComplete`, so that a host that puts many tenants on one machine can bill each of them.
+
+## Install
+
+Install it with the library:
+
+```bash
+pnpm add -E @delali/sirannon-db @delali/sirannon-sqlite
+```
+
+```ts
+import { Sirannon } from '@delali/sirannon-db'
+import { betterSqlite3 } from '@delali/sirannon-db/driver/better-sqlite3'
+
+const sirannon = new Sirannon({
+  driver: betterSqlite3({ rowCounts: true }),
+  metrics: { onQueryComplete: m => console.log(m.databaseId, m.rowsRead, m.rowsWritten) },
+})
+```
+
+This package lists six platform packages as optional dependencies, so npm installs only the one whose `os` and `cpu` match your host. The release workflow publishes all seven packages at the library's version, and this package requires exactly that version of each platform package.
+
+## What it contains
+
+The `lib` directory contains better-sqlite3's JavaScript, unchanged. Sirannon compiles the native module from better-sqlite3's C++ source and the SQLite amalgamation, after it applies each patch in the repository's `native/sqlite/patches` directory. The first SQLite patch is Cloudflare's row-counting patch, which Sirannon changed to widen both counters to 64 bits and to leave the work of its own change-capture triggers out of both counts, and the first better-sqlite3 patch adds the `takeRowCounts` method that reads them. The counting rules are in the [core engine guide](https://github.com/assetcorp/sirannon-db/blob/main/docs/core.md#rows-read-and-rows-written).
+
+On a platform without a published build, the driver throws `ROW_COUNTS_UNSUPPORTED` when it opens a database. Compile a build with `native/sqlite/build.mjs` from the repository, and pass its path to the driver as `sqliteBindingPath`.
+
+## Licence
+
+The Apache-2.0 and MIT licences cover this package. Each project whose code is in this package has its name and licence in the package's `NOTICE` file, and the patches, the build script, and the tests are in [assetcorp/sirannon-db](https://github.com/assetcorp/sirannon-db).

package/index.d.ts

@@ -0,0 +1,7 @@
+import BetterSqlite3 = require('better-sqlite3')
+
+declare const Database: typeof BetterSqlite3 & {
+  bindingPath(): string | null
+}
+
+export = Database

package/index.js

@@ -0,0 +1,59 @@
+const { existsSync } = require('node:fs')
+const { dirname, join, resolve } = require('node:path')
+const createDatabase = require('./lib/database')
+const SqliteError = require('./lib/sqlite-error')
+
+const ADDON_FILE_NAME = 'better_sqlite3.node'
+const MUSL_DIRECTORY = 'musl'
+const PUBLISHED_TARGETS = new Set([
+  'darwin-arm64',
+  'darwin-x64',
+  'linux-arm64',
+  'linux-x64',
+  'win32-arm64',
+  'win32-x64',
+])
+
+let muslLibc
+
+function usesMuslLibc() {
+  if (process.platform !== 'linux') return false
+  if (muslLibc === undefined) {
+    try {
+      muslLibc = !process.report.getReport().header.glibcVersionRuntime
+    } catch {
+      muslLibc = false
+    }
+  }
+  return muslLibc
+}
+
+function bindingPath() {
+  const target = `${process.platform}-${process.arch}`
+  if (!PUBLISHED_TARGETS.has(target)) return null
+  let packageDirectory
+  try {
+    packageDirectory = dirname(require.resolve(`@delali/sirannon-sqlite-${target}/package.json`))
+  } catch {
+    return null
+  }
+  const segments = usesMuslLibc() ? [MUSL_DIRECTORY, ADDON_FILE_NAME] : [ADDON_FILE_NAME]
+  const addon = join(packageDirectory, ...segments)
+  return existsSync(addon) ? addon : null
+}
+
+function loadAddon(nativeBinding) {
+  if (typeof nativeBinding === 'object' && nativeBinding !== null) return nativeBinding
+  const path = typeof nativeBinding === 'string' ? resolve(nativeBinding) : bindingPath()
+  if (path === null) {
+    const target = `${process.platform}-${process.arch}`
+    throw new Error(
+      `@delali/sirannon-sqlite found no native build for ${target}. Install @delali/sirannon-sqlite-${target}, or pass the path of a build that you compiled as the nativeBinding option.`,
+    )
+  }
+  return require(path)
+}
+
+module.exports = createDatabase(loadAddon, true)
+module.exports.SqliteError = SqliteError
+module.exports.bindingPath = bindingPath

package/lib/binding.js

@@ -0,0 +1,62 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const PREBUILD_PLATFORMS = ['linux', 'darwin', 'win32'];
+const PREBUILD_ARCHS = ['x64', 'arm64'];
+let DEFAULT_ADDON;
+
+function getBinding(nativeBinding) {
+	// If a path was provided, load the binding from the filesystem.
+	if (typeof nativeBinding === 'string') {
+		// See <https://webpack.js.org/api/module-variables/#__non_webpack_require__-webpack-specific>
+		const requireFunc = typeof __non_webpack_require__ === 'function' ? __non_webpack_require__ : require;
+		return requireFunc(path.resolve(nativeBinding).replace(/(\.node)?$/, '.node'));
+	}
+
+	// If an object was provided, use it as the binding directly.
+	if (typeof nativeBinding === 'object' && nativeBinding !== null) {
+		return nativeBinding;
+	}
+
+	// If we're using the default binding and it already exists, just return it.
+	if (DEFAULT_ADDON) {
+		return DEFAULT_ADDON;
+	}
+
+	// Otherwise, try to find the binding as a prebuilt binary.
+	let filename = getPrebuildPath();
+	if (filename) {
+		return DEFAULT_ADDON = require(filename);
+	}
+
+	// If no prebuilt binary was found, try the default node-gyp locations.
+	filename = path.join(__dirname, '..', 'build', 'Debug', 'better_sqlite3.node');
+	if (!fs.existsSync(filename)) {
+		filename = path.join(__dirname, '..', 'build', 'Release', 'better_sqlite3.node');
+	}
+	return DEFAULT_ADDON = require(filename);
+}
+
+function getPrebuildPath() {
+	if (PREBUILD_PLATFORMS.includes(process.platform) && PREBUILD_ARCHS.includes(process.arch)) {
+		const target = `${isLinuxMusl() ? 'linuxmusl' : process.platform}-${process.arch}`;
+		const filename = path.join(__dirname, '..', 'prebuilds', `${target}.node`);
+		if (fs.existsSync(filename)) {
+			return filename;
+		}
+	}
+	return null;
+}
+
+function isLinuxMusl() {
+	return process.platform === 'linux' && !process.report.getReport().header.glibcVersionRuntime;
+}
+
+exports.getBinding = getBinding;
+exports.getPrebuildPath = getPrebuildPath;
+
+// This script is executed directly by binding.gyp to detect prebuilt binaries.
+if (require.main === module) {
+	process.stdout.write(getPrebuildPath() ? '1' : '0');
+}

package/lib/darwin-arm64.js

@@ -0,0 +1,3 @@
+'use strict';
+module.exports = require('./database')(() => require('../prebuilds/darwin-arm64.node'), false);
+module.exports.SqliteError = require('./sqlite-error');

package/lib/darwin-x64.js

@@ -0,0 +1,3 @@
+'use strict';
+module.exports = require('./database')(() => require('../prebuilds/darwin-x64.node'), false);
+module.exports.SqliteError = require('./sqlite-error');

package/lib/database.js

@@ -0,0 +1,109 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const util = require('./util');
+const SqliteError = require('./sqlite-error');
+
+module.exports = function createDatabase(getAddon, allowNativeBinding) {
+	function Database(filenameGiven, options) {
+		if (new.target == null) {
+			return new Database(filenameGiven, options);
+		}
+
+		// Apply defaults
+		let buffer;
+		if (Buffer.isBuffer(filenameGiven)) {
+			buffer = filenameGiven;
+			filenameGiven = ':memory:';
+		}
+		if (filenameGiven == null) filenameGiven = '';
+		if (options == null) options = {};
+
+		// Validate arguments
+		if (typeof filenameGiven !== 'string') throw new TypeError('Expected first argument to be a string');
+		if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
+		if ('readOnly' in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+		if ('memory' in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+
+		// Interpret options
+		const filename = filenameGiven.trim();
+		const anonymous = filename === '' || filename === ':memory:';
+		const readonly = util.getBooleanOption(options, 'readonly');
+		const fileMustExist = util.getBooleanOption(options, 'fileMustExist');
+		const timeout = 'timeout' in options ? options.timeout : 5000;
+		const verbose = 'verbose' in options ? options.verbose : null;
+		const nativeBinding = 'nativeBinding' in options ? options.nativeBinding : null;
+
+		// Validate interpreted options
+		if (readonly && anonymous && !buffer) throw new TypeError('In-memory/temporary databases cannot be readonly');
+		if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
+		if (timeout > 0x7fffffff) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+		if (verbose != null && typeof verbose !== 'function') throw new TypeError('Expected the "verbose" option to be a function');
+		if (!allowNativeBinding && 'nativeBinding' in options) throw new TypeError('The "nativeBinding" option is only supported by the default better-sqlite3 entrypoint');
+		if (allowNativeBinding && nativeBinding != null && typeof nativeBinding !== 'string' && typeof nativeBinding !== 'object') throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+
+		// Load the native addon
+		const addon = getAddon(nativeBinding);
+		if (!addon.isInitialized) {
+			addon.initialize(SqliteError, arrayFactory, arrayAppender, rowFactory, recordFactory);
+			addon.isInitialized = true;
+		}
+
+		// Make sure the specified directory exists
+		if (!anonymous && !filename.startsWith('file:') && !fs.existsSync(path.dirname(filename))) {
+			throw new TypeError('Cannot open database because the directory does not exist');
+		}
+
+		Object.defineProperties(this, {
+			[util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
+			...wrappers.getters,
+		});
+	}
+
+	const wrappers = require('./methods/wrappers');
+	Database.prototype.prepare = wrappers.prepare;
+	Database.prototype.transaction = require('./methods/transaction');
+	Database.prototype.pragma = require('./methods/pragma');
+	Database.prototype.explain = require('./methods/explain');
+	Database.prototype.backup = require('./methods/backup');
+	Database.prototype.serialize = require('./methods/serialize');
+	Database.prototype.function = require('./methods/function');
+	Database.prototype.aggregate = require('./methods/aggregate');
+	Database.prototype.table = require('./methods/table');
+	Database.prototype.loadExtension = wrappers.loadExtension;
+	Database.prototype.exec = wrappers.exec;
+	Database.prototype.close = wrappers.close;
+	Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+	Database.prototype.unsafeMode = wrappers.unsafeMode;
+	Database.prototype[util.inspect] = require('./methods/inspect');
+
+	return Database;
+};
+
+function arrayFactory(...values) {
+	return values;
+}
+
+function arrayAppender(array, ...values) {
+	const offset = array.length;
+	for (let i = 0; i < values.length; ++i) {
+		array[offset + i] = values[i];
+	}
+}
+
+function rowFactory(...keys) {
+	if (!keys.includes('__proto__')) {
+		const parameters = keys.map((_, index) => `v${index}`).join(',');
+		const properties = keys.map((key, index) => `${JSON.stringify(key)}:v${index}`).join(',');
+		return Function(`return (${parameters}) => ({${properties}})`)();
+	}
+	return (...values) => {
+		const row = {};
+		for (let i = 0; i < keys.length; ++i) row[keys[i]] = values[i];
+		return row;
+	};
+}
+
+function recordFactory(value) {
+	return { value, done: false };
+}

package/lib/index.js

@@ -0,0 +1,3 @@
+'use strict';
+module.exports = require('./database')(require('./binding').getBinding, true);
+module.exports.SqliteError = require('./sqlite-error');

package/lib/linux-arm64.js

@@ -0,0 +1,3 @@
+'use strict';
+module.exports = require('./database')(() => require('../prebuilds/linux-arm64.node'), false);
+module.exports.SqliteError = require('./sqlite-error');

package/lib/linux-x64.js

@@ -0,0 +1,3 @@
+'use strict';
+module.exports = require('./database')(() => require('../prebuilds/linux-x64.node'), false);
+module.exports.SqliteError = require('./sqlite-error');

package/lib/linuxmusl-arm64.js

@@ -0,0 +1,4 @@
+'use strict';
+const Database = require('./database')(() => require('../prebuilds/linuxmusl-arm64.node'), false);
+Database.SqliteError = require('./sqlite-error');
+module.exports = Database;

package/lib/linuxmusl-x64.js

@@ -0,0 +1,4 @@
+'use strict';
+const Database = require('./database')(() => require('../prebuilds/linuxmusl-x64.node'), false);
+Database.SqliteError = require('./sqlite-error');
+module.exports = Database;

package/lib/methods/aggregate.js

@@ -0,0 +1,43 @@
+'use strict';
+const { getBooleanOption, cppdb } = require('../util');
+
+module.exports = function defineAggregate(name, options) {
+	// Validate arguments
+	if (typeof name !== 'string') throw new TypeError('Expected first argument to be a string');
+	if (typeof options !== 'object' || options === null) throw new TypeError('Expected second argument to be an options object');
+	if (!name) throw new TypeError('User-defined function name cannot be an empty string');
+
+	// Interpret options
+	const start = 'start' in options ? options.start : null;
+	const step = getFunctionOption(options, 'step', true);
+	const inverse = getFunctionOption(options, 'inverse', false);
+	const result = getFunctionOption(options, 'result', false);
+	const safeIntegers = 'safeIntegers' in options ? +getBooleanOption(options, 'safeIntegers') : 2;
+	const deterministic = getBooleanOption(options, 'deterministic');
+	const directOnly = getBooleanOption(options, 'directOnly');
+	const varargs = getBooleanOption(options, 'varargs');
+	let argCount = -1;
+
+	// Determine argument count
+	if (!varargs) {
+		argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+		if (argCount > 0) argCount -= 1;
+		if (argCount > 100) throw new RangeError('User-defined functions cannot have more than 100 arguments');
+	}
+
+	this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+	return this;
+};
+
+const getFunctionOption = (options, key, required) => {
+	const value = key in options ? options[key] : null;
+	if (typeof value === 'function') return value;
+	if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
+	if (required) throw new TypeError(`Missing required option "${key}"`);
+	return null;
+};
+
+const getLength = ({ length }) => {
+	if (Number.isInteger(length) && length >= 0) return length;
+	throw new TypeError('Expected function.length to be a positive integer');
+};

package/lib/methods/backup.js

@@ -0,0 +1,67 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { promisify } = require('util');
+const { cppdb } = require('../util');
+const fsAccess = promisify(fs.access);
+
+module.exports = async function backup(filename, options) {
+	if (options == null) options = {};
+
+	// Validate arguments
+	if (typeof filename !== 'string') throw new TypeError('Expected first argument to be a string');
+	if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
+
+	// Interpret options
+	filename = filename.trim();
+	const attachedName = 'attached' in options ? options.attached : 'main';
+	const handler = 'progress' in options ? options.progress : null;
+
+	// Validate interpreted options
+	if (!filename) throw new TypeError('Backup filename cannot be an empty string');
+	if (filename === ':memory:') throw new TypeError('Invalid backup filename ":memory:"');
+	if (typeof attachedName !== 'string') throw new TypeError('Expected the "attached" option to be a string');
+	if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+	if (handler != null && typeof handler !== 'function') throw new TypeError('Expected the "progress" option to be a function');
+
+	// Make sure the specified directory exists
+	await fsAccess(path.dirname(filename)).catch(() => {
+		throw new TypeError('Cannot save backup because the directory does not exist');
+	});
+
+	const isNewFile = await fsAccess(filename).then(() => false, () => true);
+	return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
+};
+
+const runBackup = (backup, handler) => {
+	let rate = 0;
+	let useDefault = true;
+
+	return new Promise((resolve, reject) => {
+		setImmediate(function step() {
+			try {
+				const progress = backup.transfer(rate);
+				if (!progress.remainingPages) {
+					backup.close();
+					resolve(progress);
+					return;
+				}
+				if (useDefault) {
+					useDefault = false;
+					rate = 100;
+				}
+				if (handler) {
+					const ret = handler(progress);
+					if (ret !== undefined) {
+						if (typeof ret === 'number' && ret === ret) rate = Math.max(0, Math.min(0x7fffffff, Math.round(ret)));
+						else throw new TypeError('Expected progress callback to return a number or undefined');
+					}
+				}
+				setImmediate(step);
+			} catch (err) {
+				backup.close();
+				reject(err);
+			}
+		});
+	});
+};

package/lib/methods/explain.js

@@ -0,0 +1,9 @@
+'use strict';
+const { cppdb } = require('../util');
+
+module.exports = function explain(source) {
+	if (typeof source !== 'string') throw new TypeError('Expected first argument to be a string');
+
+	const stmt = this[cppdb].prepare(`EXPLAIN ${source}`, this, false, true);
+	return stmt.all();
+};

package/lib/methods/function.js

@@ -0,0 +1,31 @@
+'use strict';
+const { getBooleanOption, cppdb } = require('../util');
+
+module.exports = function defineFunction(name, options, fn) {
+	// Apply defaults
+	if (options == null) options = {};
+	if (typeof options === 'function') { fn = options; options = {}; }
+
+	// Validate arguments
+	if (typeof name !== 'string') throw new TypeError('Expected first argument to be a string');
+	if (typeof fn !== 'function') throw new TypeError('Expected last argument to be a function');
+	if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
+	if (!name) throw new TypeError('User-defined function name cannot be an empty string');
+
+	// Interpret options
+	const safeIntegers = 'safeIntegers' in options ? +getBooleanOption(options, 'safeIntegers') : 2;
+	const deterministic = getBooleanOption(options, 'deterministic');
+	const directOnly = getBooleanOption(options, 'directOnly');
+	const varargs = getBooleanOption(options, 'varargs');
+	let argCount = -1;
+
+	// Determine argument count
+	if (!varargs) {
+		argCount = fn.length;
+		if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError('Expected function.length to be a positive integer');
+		if (argCount > 100) throw new RangeError('User-defined functions cannot have more than 100 arguments');
+	}
+
+	this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+	return this;
+};

package/lib/methods/inspect.js

@@ -0,0 +1,7 @@
+'use strict';
+const DatabaseInspection = function Database() {};
+
+module.exports = function inspect(depth, opts) {
+	return Object.assign(new DatabaseInspection(), this);
+};
+

package/lib/methods/pragma.js

@@ -0,0 +1,12 @@
+'use strict';
+const { getBooleanOption, cppdb } = require('../util');
+
+module.exports = function pragma(source, options) {
+	if (options == null) options = {};
+	if (typeof source !== 'string') throw new TypeError('Expected first argument to be a string');
+	if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
+	const simple = getBooleanOption(options, 'simple');
+
+	const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true, false);
+	return simple ? stmt.pluck().get() : stmt.all();
+};

package/lib/methods/serialize.js

@@ -0,0 +1,16 @@
+'use strict';
+const { cppdb } = require('../util');
+
+module.exports = function serialize(options) {
+	if (options == null) options = {};
+
+	// Validate arguments
+	if (typeof options !== 'object') throw new TypeError('Expected first argument to be an options object');
+
+	// Interpret and validate options
+	const attachedName = 'attached' in options ? options.attached : 'main';
+	if (typeof attachedName !== 'string') throw new TypeError('Expected the "attached" option to be a string');
+	if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+
+	return this[cppdb].serialize(attachedName);
+};

package/lib/methods/table.js

@@ -0,0 +1,195 @@
+'use strict';
+const { cppdb } = require('../util');
+
+module.exports = function defineTable(name, factory) {
+	// Validate arguments
+	if (typeof name !== 'string') throw new TypeError('Expected first argument to be a string');
+	if (!name) throw new TypeError('Virtual table module name cannot be an empty string');
+
+	// Determine whether the module is eponymous-only or not
+	let eponymous = false;
+	if (typeof factory === 'object' && factory !== null) {
+		eponymous = true;
+		factory = defer(parseTableDefinition(factory, 'used', name));
+	} else {
+		if (typeof factory !== 'function') throw new TypeError('Expected second argument to be a function or a table definition object');
+		factory = wrapFactory(factory);
+	}
+
+	this[cppdb].table(factory, name, eponymous);
+	return this;
+};
+
+function wrapFactory(factory) {
+	return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+		const thisObject = {
+			module: moduleName,
+			database: databaseName,
+			table: tableName,
+		};
+
+		// Generate a new table definition by invoking the factory
+		const def = apply.call(factory, thisObject, args);
+		if (typeof def !== 'object' || def === null) {
+			throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+		}
+
+		return parseTableDefinition(def, 'returned', moduleName);
+	};
+}
+
+function parseTableDefinition(def, verb, moduleName) {
+	// Validate required properties
+	if (!hasOwnProperty.call(def, 'rows')) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+	}
+	if (!hasOwnProperty.call(def, 'columns')) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+	}
+
+	// Validate "rows" property
+	const rows = def.rows;
+	if (typeof rows !== 'function' || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+	}
+
+	// Validate "columns" property
+	let columns = def.columns;
+	if (!Array.isArray(columns) || !isStringArray(columns = [...columns])) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+	}
+	if (columns.length !== new Set(columns).size) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+	}
+	if (!columns.length) {
+		throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+	}
+
+	// Validate "parameters" property
+	let parameters;
+	if (hasOwnProperty.call(def, 'parameters')) {
+		parameters = def.parameters;
+		if (!Array.isArray(parameters) || !isStringArray(parameters = [...parameters])) {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+		}
+	} else {
+		parameters = inferParameters(rows);
+	}
+	if (parameters.length !== new Set(parameters).size) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+	}
+	if (parameters.length > 32) {
+		throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+	}
+	for (const parameter of parameters) {
+		if (columns.includes(parameter)) {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+		}
+	}
+
+	// Validate "safeIntegers" option
+	let safeIntegers = 2;
+	if (hasOwnProperty.call(def, 'safeIntegers')) {
+		const bool = def.safeIntegers;
+		if (typeof bool !== 'boolean') {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+		}
+		safeIntegers = +bool;
+	}
+
+	// Validate "directOnly" option
+	let directOnly = false;
+	if (hasOwnProperty.call(def, 'directOnly')) {
+		directOnly = def.directOnly;
+		if (typeof directOnly !== 'boolean') {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+		}
+	}
+
+	// Generate SQL for the virtual table definition
+	const columnDefinitions = [
+		...parameters.map(identifier).map(str => `${str} HIDDEN`),
+		...columns.map(identifier),
+	];
+	return [
+		`CREATE TABLE x(${columnDefinitions.join(', ')});`,
+		wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+		parameters,
+		safeIntegers,
+		directOnly,
+	];
+}
+
+function wrapGenerator(generator, columnMap, moduleName) {
+	return function* virtualTable(...args) {
+		/*
+			We must defensively clone any buffers in the arguments, because
+			otherwise the generator could mutate one of them, which would cause
+			us to return incorrect values for hidden columns, potentially
+			corrupting the database.
+		 */
+		const output = args.map(x => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+		for (let i = 0; i < columnMap.size; ++i) {
+			output.push(null); // Fill with nulls to prevent gaps in array (v8 optimization)
+		}
+		for (const row of generator(...args)) {
+			if (Array.isArray(row)) {
+				extractRowArray(row, output, columnMap.size, moduleName);
+				yield output;
+			} else if (typeof row === 'object' && row !== null) {
+				extractRowObject(row, output, columnMap, moduleName);
+				yield output;
+			} else {
+				throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+			}
+		}
+	};
+}
+
+function extractRowArray(row, output, columnCount, moduleName) {
+	if (row.length !== columnCount) {
+		throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+	}
+	const offset = output.length - columnCount;
+	for (let i = 0; i < columnCount; ++i) {
+		output[i + offset] = row[i];
+	}
+}
+
+function extractRowObject(row, output, columnMap, moduleName) {
+	let count = 0;
+	for (const key of Object.keys(row)) {
+		const index = columnMap.get(key);
+		if (index === undefined) {
+			throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+		}
+		output[index] = row[key];
+		count += 1;
+	}
+	if (count !== columnMap.size) {
+		throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+	}
+}
+
+function inferParameters({ length }) {
+	if (!Number.isInteger(length) || length < 0) {
+		throw new TypeError('Expected function.length to be a positive integer');
+	}
+	const params = [];
+	for (let i = 0; i < length; ++i) {
+		params.push(`$${i + 1}`);
+	}
+	return params;
+}
+
+const { hasOwnProperty } = Object.prototype;
+const { apply } = Function.prototype;
+const GeneratorFunctionPrototype = Object.getPrototypeOf(function*(){});
+const identifier = str => `"${str.replace(/"/g, '""')}"`;
+const defer = x => () => x;
+const isStringArray = (arr) => {
+	for (let i = 0; i < arr.length; ++i) {
+		if (typeof arr[i] !== 'string') return false;
+	}
+	return true;
+};

package/lib/methods/transaction.js

@@ -0,0 +1,78 @@
+'use strict';
+const { cppdb } = require('../util');
+const controllers = new WeakMap();
+
+module.exports = function transaction(fn) {
+	if (typeof fn !== 'function') throw new TypeError('Expected first argument to be a function');
+
+	const db = this[cppdb];
+	const controller = getController(db, this);
+	const { apply } = Function.prototype;
+
+	// Each version of the transaction function has these same properties
+	const properties = {
+		default: { value: wrapTransaction(apply, fn, db, controller.default) },
+		deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+		immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+		exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+		database: { value: this, enumerable: true },
+	};
+
+	Object.defineProperties(properties.default.value, properties);
+	Object.defineProperties(properties.deferred.value, properties);
+	Object.defineProperties(properties.immediate.value, properties);
+	Object.defineProperties(properties.exclusive.value, properties);
+
+	// Return the default version of the transaction function
+	return properties.default.value;
+};
+
+// Return the database's cached transaction controller, or create a new one
+const getController = (db, self) => {
+	let controller = controllers.get(db);
+	if (!controller) {
+		const shared = {
+			commit: db.prepare('COMMIT', self, false, false),
+			rollback: db.prepare('ROLLBACK', self, false, false),
+			savepoint: db.prepare('SAVEPOINT `\t_bs3.\t`', self, false, false),
+			release: db.prepare('RELEASE `\t_bs3.\t`', self, false, false),
+			rollbackTo: db.prepare('ROLLBACK TO `\t_bs3.\t`', self, false, false),
+		};
+		controllers.set(db, controller = {
+			default: Object.assign({ begin: db.prepare('BEGIN', self, false, false) }, shared),
+			deferred: Object.assign({ begin: db.prepare('BEGIN DEFERRED', self, false, false) }, shared),
+			immediate: Object.assign({ begin: db.prepare('BEGIN IMMEDIATE', self, false, false) }, shared),
+			exclusive: Object.assign({ begin: db.prepare('BEGIN EXCLUSIVE', self, false, false) }, shared),
+		});
+	}
+	return controller;
+};
+
+// Return a new transaction function by wrapping the given function
+const wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+	let before, after, undo;
+	if (db.inTransaction) {
+		before = savepoint;
+		after = release;
+		undo = rollbackTo;
+	} else {
+		before = begin;
+		after = commit;
+		undo = rollback;
+	}
+	before.run();
+	try {
+		const result = apply.call(fn, this, arguments);
+		if (result && typeof result.then === 'function') {
+			throw new TypeError('Transaction function cannot return a promise');
+		}
+		after.run();
+		return result;
+	} catch (ex) {
+		if (db.inTransaction) {
+			undo.run();
+			if (undo !== rollback) after.run();
+		}
+		throw ex;
+	}
+};

package/lib/methods/wrappers.js

@@ -0,0 +1,54 @@
+'use strict';
+const { cppdb } = require('../util');
+
+exports.prepare = function prepare(sql) {
+	return this[cppdb].prepare(sql, this, false, false);
+};
+
+exports.exec = function exec(sql) {
+	this[cppdb].exec(sql);
+	return this;
+};
+
+exports.close = function close() {
+	this[cppdb].close();
+	return this;
+};
+
+exports.loadExtension = function loadExtension(...args) {
+	this[cppdb].loadExtension(...args);
+	return this;
+};
+
+exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+	this[cppdb].defaultSafeIntegers(...args);
+	return this;
+};
+
+exports.unsafeMode = function unsafeMode(...args) {
+	this[cppdb].unsafeMode(...args);
+	return this;
+};
+
+exports.getters = {
+	name: {
+		get: function name() { return this[cppdb].name; },
+		enumerable: true,
+	},
+	open: {
+		get: function open() { return this[cppdb].open; },
+		enumerable: true,
+	},
+	inTransaction: {
+		get: function inTransaction() { return this[cppdb].inTransaction; },
+		enumerable: true,
+	},
+	readonly: {
+		get: function readonly() { return this[cppdb].readonly; },
+		enumerable: true,
+	},
+	memory: {
+		get: function memory() { return this[cppdb].memory; },
+		enumerable: true,
+	},
+};

package/lib/sqlite-error.js

@@ -0,0 +1,25 @@
+'use strict';
+
+class SqliteError extends Error {
+	constructor(message, code) {
+		if (typeof code !== 'string') {
+			throw new TypeError('Expected second argument to be a string');
+		}
+
+		super('' + message);
+		this.code = code;
+
+		if (typeof Error.captureStackTrace === 'function') {
+			Error.captureStackTrace(this, SqliteError);
+		}
+	}
+}
+
+Object.defineProperty(SqliteError.prototype, 'name', {
+	value: 'SqliteError',
+	writable: true,
+	enumerable: false,
+	configurable: true,
+});
+
+module.exports = SqliteError;

package/lib/util.js

@@ -0,0 +1,12 @@
+'use strict';
+
+exports.getBooleanOption = (options, key) => {
+	let value = false;
+	if (key in options && typeof (value = options[key]) !== 'boolean') {
+		throw new TypeError(`Expected the "${key}" option to be a boolean`);
+	}
+	return value;
+};
+
+exports.cppdb = Symbol();
+exports.inspect = Symbol.for('nodejs.util.inspect.custom');

package/lib/win32-arm64.js

@@ -0,0 +1,3 @@
+'use strict';
+module.exports = require('./database')(() => require('../prebuilds/win32-arm64.node'), false);
+module.exports.SqliteError = require('./sqlite-error');

package/lib/win32-x64.js

@@ -0,0 +1,3 @@
+'use strict';
+module.exports = require('./database')(() => require('../prebuilds/win32-x64.node'), false);
+module.exports.SqliteError = require('./sqlite-error');

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@delali/sirannon-sqlite",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.5-next.72",
+  "description": "better-sqlite3 built against Sirannon's build of SQLite, which counts the rows that each statement reads and writes so that Sirannon can report them for per-tenant metering.",
+  "license": "Apache-2.0 AND MIT",
+  "author": "Delali (https://sondelali.com)",
+  "homepage": "https://github.com/assetcorp/sirannon-db",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/assetcorp/sirannon-db.git",
+    "directory": "native/sqlite/npm/sirannon-sqlite"
+  },
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "lib",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@types/better-sqlite3": "7.6.13"
+  },
+  "optionalDependencies": {
+    "@delali/sirannon-sqlite-darwin-arm64": "0.3.5-next.72",
+    "@delali/sirannon-sqlite-darwin-x64": "0.3.5-next.72",
+    "@delali/sirannon-sqlite-linux-arm64": "0.3.5-next.72",
+    "@delali/sirannon-sqlite-linux-x64": "0.3.5-next.72",
+    "@delali/sirannon-sqlite-win32-arm64": "0.3.5-next.72",
+    "@delali/sirannon-sqlite-win32-x64": "0.3.5-next.72"
+  }
+}