@fedify/pglite 2.4.0-dev.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024–2026 Hong Minhee
+
+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

@@ -0,0 +1,52 @@
+<!-- deno-fmt-ignore-file -->
+
+@fedify/pglite: PGlite driver for Fedify
+========================================
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+
+This package provides [`PgliteKvStore`], a PGlite-backed implementation of
+Fedify's [`KvStore`]:
+
+~~~~ typescript
+import { PGlite } from "@electric-sql/pglite";
+import { createFederation } from "@fedify/fedify";
+import { PgliteKvStore } from "@fedify/pglite";
+
+const pg = new PGlite("./data/fedify");
+const federation = createFederation({
+  kv: new PgliteKvStore(pg),
+});
+~~~~
+
+The caller owns the `PGlite` instance.  Close it during application shutdown,
+after every pending store operation has completed.  `PgliteKvStore` neither
+creates nor closes the instance.
+
+Use one PGlite instance per data directory and runtime isolate.  PGlite does
+not make writes visible to other processes, so the same data directory cannot
+back horizontally scaled workers.  This package does not provide a message
+queue because those constraints cannot preserve ordering or delivery during a
+rolling restart.  See [PGlite issue #489] and [PGlite pull request #892].
+
+[JSR badge]: https://jsr.io/badges/@fedify/pglite
+[JSR]: https://jsr.io/@fedify/pglite
+[npm badge]: https://img.shields.io/npm/v/@fedify/pglite?logo=npm
+[npm]: https://www.npmjs.com/package/@fedify/pglite
+[`PgliteKvStore`]: https://jsr.io/@fedify/pglite/doc/~/PgliteKvStore
+[`KvStore`]: https://jsr.io/@fedify/fedify/doc/federation/~/KvStore
+[PGlite issue #489]: https://github.com/electric-sql/pglite/issues/489#issuecomment-2587892190
+[PGlite pull request #892]: https://github.com/electric-sql/pglite/pull/892
+
+
+Installation
+------------
+
+~~~~ sh
+deno add jsr:@fedify/pglite npm:@electric-sql/pglite  # Deno
+npm  add     @fedify/pglite @electric-sql/pglite      # npm
+pnpm add     @fedify/pglite @electric-sql/pglite      # pnpm
+yarn add     @fedify/pglite @electric-sql/pglite      # Yarn
+bun  add     @fedify/pglite @electric-sql/pglite      # Bun
+~~~~

package/dist/kv.cjs

@@ -0,0 +1,217 @@
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_index = require("./node_modules/.pnpm/temporal-polyfill@1.0.1/node_modules/temporal-polyfill/index.cjs");
+let _logtape_logtape = require("@logtape/logtape");
+//#region src/kv.ts
+const Temporal = require_index.Temporal;
+const logger = (0, _logtape_logtape.getLogger)([
+	"fedify",
+	"pglite",
+	"kv"
+]);
+function quoteIdentifier(identifier) {
+	const parts = identifier.split(".");
+	if (parts.includes("")) throw new TypeError(`Invalid table name for the key–value store: ${JSON.stringify(identifier)}`);
+	return parts.map((part) => `"${part.replaceAll("\"", "\"\"")}"`).join(".");
+}
+function serializeJson(value) {
+	const serialized = JSON.stringify(value);
+	if (serialized == null) throw new TypeError("PGlite cannot store a value that is not valid JSON");
+	return serialized;
+}
+/**
+* A key–value store backed by an embedded PGlite database.
+*
+* The caller owns the PGlite instance and is responsible for closing it after
+* every operation using the store has completed.  Use only one PGlite instance
+* for a data directory within a runtime isolate.
+*
+* @example
+* ```ts ignore
+* import { PGlite } from "@electric-sql/pglite";
+* import { createFederation } from "@fedify/fedify";
+* import { PgliteKvStore } from "@fedify/pglite";
+*
+* const pg = new PGlite("./data/fedify");
+* const federation = createFederation({
+*   // ...
+*   kv: new PgliteKvStore(pg),
+* });
+*
+* // Close pg during application shutdown, after pending operations finish.
+* await pg.close();
+* ```
+* @since 2.4.0
+*/
+var PgliteKvStore = class {
+	#pg;
+	#tableName;
+	#quotedTableName;
+	#initialized;
+	#initializing;
+	/**
+	* Creates a new PGlite key–value store.
+	* @param pg The caller-owned PGlite instance to use.
+	* @param options The options for the key–value store.
+	*/
+	constructor(pg, options = {}) {
+		this.#pg = pg;
+		this.#tableName = options.tableName ?? "fedify_kv_v2";
+		this.#quotedTableName = quoteIdentifier(this.#tableName);
+		this.#initialized = options.initialized ?? false;
+	}
+	async #expire() {
+		await this.#pg.query(`
+      DELETE FROM ${this.#quotedTableName}
+      WHERE ttl IS NOT NULL AND created + ttl < CURRENT_TIMESTAMP;
+    `);
+	}
+	async get(key) {
+		await this.initialize();
+		return (await this.#pg.query(`
+      SELECT value
+      FROM ${this.#quotedTableName}
+      WHERE key = $1::text[]
+        AND (ttl IS NULL OR created + ttl > CURRENT_TIMESTAMP);
+    `, [key])).rows[0]?.value;
+	}
+	async set(key, value, options) {
+		await this.initialize();
+		const ttl = options?.ttl == null ? null : Temporal.Duration.from(options.ttl).toString();
+		await this.#pg.query(`
+      INSERT INTO ${this.#quotedTableName} (key, value, ttl)
+      VALUES ($1::text[], $2::text::jsonb, $3::text::interval)
+      ON CONFLICT (key)
+        DO UPDATE SET
+          value = EXCLUDED.value,
+          created = CURRENT_TIMESTAMP,
+          ttl = EXCLUDED.ttl;
+    `, [
+			key,
+			serializeJson(value),
+			ttl
+		]);
+		await this.#expire();
+	}
+	async delete(key) {
+		await this.initialize();
+		await this.#pg.query(`
+      DELETE FROM ${this.#quotedTableName}
+      WHERE key = $1::text[];
+    `, [key]);
+		await this.#expire();
+	}
+	/** {@inheritDoc KvStore.cas} */
+	async cas(key, expectedValue, newValue, options) {
+		await this.initialize();
+		const ttl = options?.ttl == null ? null : Temporal.Duration.from(options.ttl).toString();
+		if (expectedValue === void 0 && newValue === void 0) {
+			const matched = await this.get(key) === void 0;
+			await this.#expire();
+			return matched;
+		}
+		let rowCount;
+		if (expectedValue === void 0) rowCount = (await this.#pg.query(`
+        INSERT INTO ${this.#quotedTableName} AS existing
+          (key, value, created, ttl)
+        VALUES (
+          $1::text[],
+          $2::text::jsonb,
+          CURRENT_TIMESTAMP,
+          $3::text::interval
+        )
+        ON CONFLICT (key)
+          DO UPDATE SET
+            value = EXCLUDED.value,
+            created = EXCLUDED.created,
+            ttl = EXCLUDED.ttl
+          WHERE existing.ttl IS NOT NULL
+            AND existing.created + existing.ttl <= CURRENT_TIMESTAMP
+        RETURNING key;
+      `, [
+			key,
+			serializeJson(newValue),
+			ttl
+		])).rows.length;
+		else if (newValue === void 0) rowCount = (await this.#pg.query(`
+        DELETE FROM ${this.#quotedTableName}
+        WHERE key = $1::text[]
+          AND (ttl IS NULL OR created + ttl > CURRENT_TIMESTAMP)
+          AND value = $2::text::jsonb
+        RETURNING key;
+      `, [key, serializeJson(expectedValue)])).rows.length;
+		else rowCount = (await this.#pg.query(`
+        UPDATE ${this.#quotedTableName}
+        SET
+          value = $3::text::jsonb,
+          created = CURRENT_TIMESTAMP,
+          ttl = $4::text::interval
+        WHERE key = $1::text[]
+          AND (ttl IS NULL OR created + ttl > CURRENT_TIMESTAMP)
+          AND value = $2::text::jsonb
+        RETURNING key;
+      `, [
+			key,
+			serializeJson(expectedValue),
+			serializeJson(newValue),
+			ttl
+		])).rows.length;
+		await this.#expire();
+		return rowCount > 0;
+	}
+	/** {@inheritDoc KvStore.list} */
+	async *list(prefix) {
+		await this.initialize();
+		const result = prefix == null || prefix.length === 0 ? await this.#pg.query(`
+        SELECT key, value
+        FROM ${this.#quotedTableName}
+        WHERE ttl IS NULL OR created + ttl > CURRENT_TIMESTAMP
+        ORDER BY key;
+      `) : await this.#pg.query(`
+        SELECT key, value
+        FROM ${this.#quotedTableName}
+        WHERE array_length(key, 1) >= $1
+          AND key[1:$1] = $2::text[]
+          AND (ttl IS NULL OR created + ttl > CURRENT_TIMESTAMP)
+        ORDER BY key;
+      `, [prefix.length, prefix]);
+		for (const row of result.rows) yield row;
+	}
+	/**
+	* Creates the table used by the store if it does not already exist.
+	*/
+	async initialize() {
+		await this.#pg.waitReady;
+		if (this.#initialized) return;
+		this.#initializing ??= (async () => {
+			logger.debug("Initializing the key–value store table {tableName}...", { tableName: this.#tableName });
+			await this.#pg.query(`
+        CREATE TABLE IF NOT EXISTS ${this.#quotedTableName} (
+          key text[] PRIMARY KEY,
+          value jsonb NOT NULL,
+          created timestamp with time zone DEFAULT CURRENT_TIMESTAMP,
+          ttl interval
+        );
+      `);
+			this.#initialized = true;
+			logger.debug("Initialized the key–value store table {tableName}.", { tableName: this.#tableName });
+		})();
+		try {
+			await this.#initializing;
+		} catch (error) {
+			this.#initializing = void 0;
+			throw error;
+		}
+	}
+	/**
+	* Drops the table used by the store.  Does nothing if it does not exist.
+	*/
+	async drop() {
+		await this.#pg.waitReady;
+		await this.#pg.query(`DROP TABLE IF EXISTS ${this.#quotedTableName};`);
+		this.#initialized = false;
+		this.#initializing = void 0;
+	}
+};
+//#endregion
+exports.PgliteKvStore = PgliteKvStore;

package/dist/kv.d.cts

@@ -0,0 +1,74 @@
+/// <reference types="emscripten" />
+/// <reference lib="esnext.temporal" />
+import { PGliteInterface } from "@electric-sql/pglite";
+import { KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions } from "@fedify/fedify";
+
+//#region src/kv.d.ts
+/**
+* Options for the PGlite key–value store.
+*/
+interface PgliteKvStoreOptions {
+  /**
+  * The table name to use for the key–value store.
+  * A `.` separates the schema from the table name, so neither the whole
+  * name nor any segment between dots can be empty.
+  * `"fedify_kv_v2"` by default.
+  * @default `"fedify_kv_v2"`
+  */
+  readonly tableName?: string;
+  /**
+  * Whether the table has already been initialized.  `false` by default.
+  * @default `false`
+  */
+  readonly initialized?: boolean;
+}
+/**
+* A key–value store backed by an embedded PGlite database.
+*
+* The caller owns the PGlite instance and is responsible for closing it after
+* every operation using the store has completed.  Use only one PGlite instance
+* for a data directory within a runtime isolate.
+*
+* @example
+* ```ts ignore
+* import { PGlite } from "@electric-sql/pglite";
+* import { createFederation } from "@fedify/fedify";
+* import { PgliteKvStore } from "@fedify/pglite";
+*
+* const pg = new PGlite("./data/fedify");
+* const federation = createFederation({
+*   // ...
+*   kv: new PgliteKvStore(pg),
+* });
+*
+* // Close pg during application shutdown, after pending operations finish.
+* await pg.close();
+* ```
+* @since 2.4.0
+*/
+declare class PgliteKvStore implements KvStore {
+  #private;
+  /**
+  * Creates a new PGlite key–value store.
+  * @param pg The caller-owned PGlite instance to use.
+  * @param options The options for the key–value store.
+  */
+  constructor(pg: PGliteInterface, options?: PgliteKvStoreOptions);
+  get<T = unknown>(key: KvKey): Promise<T | undefined>;
+  set(key: KvKey, value: unknown, options?: KvStoreSetOptions): Promise<void>;
+  delete(key: KvKey): Promise<void>;
+  /** {@inheritDoc KvStore.cas} */
+  cas(key: KvKey, expectedValue: unknown, newValue: unknown, options?: KvStoreSetOptions): Promise<boolean>;
+  /** {@inheritDoc KvStore.list} */
+  list(prefix?: KvKey): AsyncIterable<KvStoreListEntry>;
+  /**
+  * Creates the table used by the store if it does not already exist.
+  */
+  initialize(): Promise<void>;
+  /**
+  * Drops the table used by the store.  Does nothing if it does not exist.
+  */
+  drop(): Promise<void>;
+}
+//#endregion
+export { PgliteKvStore, PgliteKvStoreOptions };

package/dist/kv.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="emscripten" />
+/// <reference lib="esnext.temporal" />
+import { PGliteInterface } from "@electric-sql/pglite";
+import { KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions } from "@fedify/fedify";
+
+//#region src/kv.d.ts
+/**
+* Options for the PGlite key–value store.
+*/
+interface PgliteKvStoreOptions {
+  /**
+  * The table name to use for the key–value store.
+  * A `.` separates the schema from the table name, so neither the whole
+  * name nor any segment between dots can be empty.
+  * `"fedify_kv_v2"` by default.
+  * @default `"fedify_kv_v2"`
+  */
+  readonly tableName?: string;
+  /**
+  * Whether the table has already been initialized.  `false` by default.
+  * @default `false`
+  */
+  readonly initialized?: boolean;
+}
+/**
+* A key–value store backed by an embedded PGlite database.
+*
+* The caller owns the PGlite instance and is responsible for closing it after
+* every operation using the store has completed.  Use only one PGlite instance
+* for a data directory within a runtime isolate.
+*
+* @example
+* ```ts ignore
+* import { PGlite } from "@electric-sql/pglite";
+* import { createFederation } from "@fedify/fedify";
+* import { PgliteKvStore } from "@fedify/pglite";
+*
+* const pg = new PGlite("./data/fedify");
+* const federation = createFederation({
+*   // ...
+*   kv: new PgliteKvStore(pg),
+* });
+*
+* // Close pg during application shutdown, after pending operations finish.
+* await pg.close();
+* ```
+* @since 2.4.0
+*/
+declare class PgliteKvStore implements KvStore {
+  #private;
+  /**
+  * Creates a new PGlite key–value store.
+  * @param pg The caller-owned PGlite instance to use.
+  * @param options The options for the key–value store.
+  */
+  constructor(pg: PGliteInterface, options?: PgliteKvStoreOptions);
+  get<T = unknown>(key: KvKey): Promise<T | undefined>;
+  set(key: KvKey, value: unknown, options?: KvStoreSetOptions): Promise<void>;
+  delete(key: KvKey): Promise<void>;
+  /** {@inheritDoc KvStore.cas} */
+  cas(key: KvKey, expectedValue: unknown, newValue: unknown, options?: KvStoreSetOptions): Promise<boolean>;
+  /** {@inheritDoc KvStore.list} */
+  list(prefix?: KvKey): AsyncIterable<KvStoreListEntry>;
+  /**
+  * Creates the table used by the store if it does not already exist.
+  */
+  initialize(): Promise<void>;
+  /**
+  * Drops the table used by the store.  Does nothing if it does not exist.
+  */
+  drop(): Promise<void>;
+}
+//#endregion
+export { PgliteKvStore, PgliteKvStoreOptions };

package/dist/kv.js

@@ -0,0 +1,214 @@
+import { Temporal } from "temporal-polyfill";
+import { getLogger } from "@logtape/logtape";
+//#region src/kv.ts
+const logger = getLogger([
+	"fedify",
+	"pglite",
+	"kv"
+]);
+function quoteIdentifier(identifier) {
+	const parts = identifier.split(".");
+	if (parts.includes("")) throw new TypeError(`Invalid table name for the key–value store: ${JSON.stringify(identifier)}`);
+	return parts.map((part) => `"${part.replaceAll("\"", "\"\"")}"`).join(".");
+}
+function serializeJson(value) {
+	const serialized = JSON.stringify(value);
+	if (serialized == null) throw new TypeError("PGlite cannot store a value that is not valid JSON");
+	return serialized;
+}
+/**
+* A key–value store backed by an embedded PGlite database.
+*
+* The caller owns the PGlite instance and is responsible for closing it after
+* every operation using the store has completed.  Use only one PGlite instance
+* for a data directory within a runtime isolate.
+*
+* @example
+* ```ts ignore
+* import { PGlite } from "@electric-sql/pglite";
+* import { createFederation } from "@fedify/fedify";
+* import { PgliteKvStore } from "@fedify/pglite";
+*
+* const pg = new PGlite("./data/fedify");
+* const federation = createFederation({
+*   // ...
+*   kv: new PgliteKvStore(pg),
+* });
+*
+* // Close pg during application shutdown, after pending operations finish.
+* await pg.close();
+* ```
+* @since 2.4.0
+*/
+var PgliteKvStore = class {
+	#pg;
+	#tableName;
+	#quotedTableName;
+	#initialized;
+	#initializing;
+	/**
+	* Creates a new PGlite key–value store.
+	* @param pg The caller-owned PGlite instance to use.
+	* @param options The options for the key–value store.
+	*/
+	constructor(pg, options = {}) {
+		this.#pg = pg;
+		this.#tableName = options.tableName ?? "fedify_kv_v2";
+		this.#quotedTableName = quoteIdentifier(this.#tableName);
+		this.#initialized = options.initialized ?? false;
+	}
+	async #expire() {
+		await this.#pg.query(`
+      DELETE FROM ${this.#quotedTableName}
+      WHERE ttl IS NOT NULL AND created + ttl < CURRENT_TIMESTAMP;
+    `);
+	}
+	async get(key) {
+		await this.initialize();
+		return (await this.#pg.query(`
+      SELECT value
+      FROM ${this.#quotedTableName}
+      WHERE key = $1::text[]
+        AND (ttl IS NULL OR created + ttl > CURRENT_TIMESTAMP);
+    `, [key])).rows[0]?.value;
+	}
+	async set(key, value, options) {
+		await this.initialize();
+		const ttl = options?.ttl == null ? null : Temporal.Duration.from(options.ttl).toString();
+		await this.#pg.query(`
+      INSERT INTO ${this.#quotedTableName} (key, value, ttl)
+      VALUES ($1::text[], $2::text::jsonb, $3::text::interval)
+      ON CONFLICT (key)
+        DO UPDATE SET
+          value = EXCLUDED.value,
+          created = CURRENT_TIMESTAMP,
+          ttl = EXCLUDED.ttl;
+    `, [
+			key,
+			serializeJson(value),
+			ttl
+		]);
+		await this.#expire();
+	}
+	async delete(key) {
+		await this.initialize();
+		await this.#pg.query(`
+      DELETE FROM ${this.#quotedTableName}
+      WHERE key = $1::text[];
+    `, [key]);
+		await this.#expire();
+	}
+	/** {@inheritDoc KvStore.cas} */
+	async cas(key, expectedValue, newValue, options) {
+		await this.initialize();
+		const ttl = options?.ttl == null ? null : Temporal.Duration.from(options.ttl).toString();
+		if (expectedValue === void 0 && newValue === void 0) {
+			const matched = await this.get(key) === void 0;
+			await this.#expire();
+			return matched;
+		}
+		let rowCount;
+		if (expectedValue === void 0) rowCount = (await this.#pg.query(`
+        INSERT INTO ${this.#quotedTableName} AS existing
+          (key, value, created, ttl)
+        VALUES (
+          $1::text[],
+          $2::text::jsonb,
+          CURRENT_TIMESTAMP,
+          $3::text::interval
+        )
+        ON CONFLICT (key)
+          DO UPDATE SET
+            value = EXCLUDED.value,
+            created = EXCLUDED.created,
+            ttl = EXCLUDED.ttl
+          WHERE existing.ttl IS NOT NULL
+            AND existing.created + existing.ttl <= CURRENT_TIMESTAMP
+        RETURNING key;
+      `, [
+			key,
+			serializeJson(newValue),
+			ttl
+		])).rows.length;
+		else if (newValue === void 0) rowCount = (await this.#pg.query(`
+        DELETE FROM ${this.#quotedTableName}
+        WHERE key = $1::text[]
+          AND (ttl IS NULL OR created + ttl > CURRENT_TIMESTAMP)
+          AND value = $2::text::jsonb
+        RETURNING key;
+      `, [key, serializeJson(expectedValue)])).rows.length;
+		else rowCount = (await this.#pg.query(`
+        UPDATE ${this.#quotedTableName}
+        SET
+          value = $3::text::jsonb,
+          created = CURRENT_TIMESTAMP,
+          ttl = $4::text::interval
+        WHERE key = $1::text[]
+          AND (ttl IS NULL OR created + ttl > CURRENT_TIMESTAMP)
+          AND value = $2::text::jsonb
+        RETURNING key;
+      `, [
+			key,
+			serializeJson(expectedValue),
+			serializeJson(newValue),
+			ttl
+		])).rows.length;
+		await this.#expire();
+		return rowCount > 0;
+	}
+	/** {@inheritDoc KvStore.list} */
+	async *list(prefix) {
+		await this.initialize();
+		const result = prefix == null || prefix.length === 0 ? await this.#pg.query(`
+        SELECT key, value
+        FROM ${this.#quotedTableName}
+        WHERE ttl IS NULL OR created + ttl > CURRENT_TIMESTAMP
+        ORDER BY key;
+      `) : await this.#pg.query(`
+        SELECT key, value
+        FROM ${this.#quotedTableName}
+        WHERE array_length(key, 1) >= $1
+          AND key[1:$1] = $2::text[]
+          AND (ttl IS NULL OR created + ttl > CURRENT_TIMESTAMP)
+        ORDER BY key;
+      `, [prefix.length, prefix]);
+		for (const row of result.rows) yield row;
+	}
+	/**
+	* Creates the table used by the store if it does not already exist.
+	*/
+	async initialize() {
+		await this.#pg.waitReady;
+		if (this.#initialized) return;
+		this.#initializing ??= (async () => {
+			logger.debug("Initializing the key–value store table {tableName}...", { tableName: this.#tableName });
+			await this.#pg.query(`
+        CREATE TABLE IF NOT EXISTS ${this.#quotedTableName} (
+          key text[] PRIMARY KEY,
+          value jsonb NOT NULL,
+          created timestamp with time zone DEFAULT CURRENT_TIMESTAMP,
+          ttl interval
+        );
+      `);
+			this.#initialized = true;
+			logger.debug("Initialized the key–value store table {tableName}.", { tableName: this.#tableName });
+		})();
+		try {
+			await this.#initializing;
+		} catch (error) {
+			this.#initializing = void 0;
+			throw error;
+		}
+	}
+	/**
+	* Drops the table used by the store.  Does nothing if it does not exist.
+	*/
+	async drop() {
+		await this.#pg.waitReady;
+		await this.#pg.query(`DROP TABLE IF EXISTS ${this.#quotedTableName};`);
+		this.#initialized = false;
+		this.#initializing = void 0;
+	}
+};
+//#endregion
+export { PgliteKvStore };

package/dist/mod.cjs

@@ -0,0 +1,4 @@
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_kv = require("./kv.cjs");
+exports.PgliteKvStore = require_kv.PgliteKvStore;

package/dist/mod.d.cts

@@ -0,0 +1,4 @@
+/// <reference types="emscripten" />
+/// <reference lib="esnext.temporal" />
+import { PgliteKvStore, PgliteKvStoreOptions } from "./kv.cjs";
+export { PgliteKvStore, PgliteKvStoreOptions };

package/dist/mod.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="emscripten" />
+/// <reference lib="esnext.temporal" />
+import { PgliteKvStore, PgliteKvStoreOptions } from "./kv.js";
+export { PgliteKvStore, PgliteKvStoreOptions };

package/dist/mod.js

@@ -0,0 +1,3 @@
+import { Temporal } from "temporal-polyfill";
+import { PgliteKvStore } from "./kv.js";
+export { PgliteKvStore };