konserve-r2 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,183 @@
+                                 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 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, as submitted to the 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 designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      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 the 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 any patent
+      claims licensable by such Contributor constitute 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, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, 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 in addition 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 license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of the
+      Derivative Works, as separate terms and conditions for use,
+      reproduction, or distribution of Your modifications, or for such
+      Derivative Works as a whole, if 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 reproducing 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 exemplary 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 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 wish 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 offer only
+      conditions that are consistent with this License.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Alexander Oloo
+
+   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/README.md

@@ -0,0 +1,161 @@
+# konserve-r2
+
+A key-value store for [Cloudflare R2](https://developers.cloudflare.com/r2/), with optional [Konserve](https://github.com/replikativ/konserve)/[Datahike](https://github.com/replikativ/datahike) integration for Datalog on the edge.
+
+## Overview
+
+konserve-r2 can be used in two ways:
+
+1. **Pure JS** — a simple, Promise-based KV store on R2. No dependencies beyond the R2 bucket binding.
+2. **Konserve/Datahike** — a full `PBackingStore`/`PBackingBlob` implementation that lets Datahike persist to R2 inside a Cloudflare Worker.
+
+## Features
+
+- Pure JavaScript KV API — `put`, `get`, `delete`, `keys`, `exists`
+- Binary value support via `putBinary` / `getBinary`
+- Prefix-based namespace isolation
+- Full Konserve `PBackingStore` / `PBackingBlob` protocol implementation
+- Datahike Datalog queries, joins, and aggregates on persistent R2 storage
+
+## Usage
+
+### Install
+
+```bash
+npm install konserve-r2
+```
+
+### KV Store
+
+```js
+import { connect } from 'konserve-r2';
+
+export default {
+  async fetch(request, env) {
+    const store = connect(env.R2_BUCKET, { prefix: 'my-app/' });
+
+    await store.put('user:alice', { name: 'Alice', age: 30 });
+    const alice = await store.get('user:alice');     // parsed JSON
+
+    await store.putBinary('avatar', avatarArrayBuffer);
+    const avatar = await store.getBinary('avatar');   // ArrayBuffer
+
+    const allKeys = await store.keys();               // string[]
+    const exists = await store.exists('user:alice');   // boolean
+    await store.delete('user:alice');
+    await store.destroy();                             // wipe all prefixed keys
+
+    return Response.json(alice);
+  },
+};
+```
+
+### With Datahike
+
+If [datahike](https://www.npmjs.com/package/datahike) is installed and imported **before** konserve-r2, the `:r2` konserve backend registers automatically — no extra setup.
+
+```bash
+npm install datahike
+```
+
+```js
+import 'datahike';
+import { registerBucket } from 'konserve-r2';  // auto-detects datahike
+
+registerBucket(STORE_ID, env.R2_BUCKET);
+
+const config = { store: { backend: ':r2', id: STORE_ID } };
+
+if (!(await d.databaseExists(config))) {
+  await d.createDatabase(config);
+}
+
+const conn = await d.connect(config);
+await d.transact(conn, [{ 'user/name': 'Alice' }]);
+const db = await d.db(conn);
+const results = await d.q('[:find ?name :where [?e :user/name ?name]]', db);
+await d.release(conn);
+```
+
+If you can't control the import order (e.g. datahike loads after konserve-r2), use `initKonserve()`:
+
+```js
+import { initKonserve, registerBucket } from 'konserve-r2';
+import 'datahike';
+
+await initKonserve(); // force-loads the konserve backend
+```
+
+To prevent the konserve backend from loading even when datahike is present, call `disableKonserve()`:
+
+```js
+import { disableKonserve, connect } from 'konserve-r2';
+disableKonserve(); // JS-only mode, skip konserve autodetection
+```
+
+## Development
+
+### Prerequisites
+
+- Node.js 18+
+- Cloudflare account with an R2 bucket (for deployment)
+
+### Install
+
+```bash
+npm install
+```
+
+### Build
+
+```bash
+npm run build
+```
+
+Compiles ClojureScript via Squint, then bundles everything with esbuild into `dist/worker.js`.
+
+### Test
+
+```bash
+npm test
+```
+
+Runs the full test suite (build + Vitest). Tests use Miniflare's programmatic API — no Cloudflare account needed.
+
+### Local dev
+
+```bash
+npm run dev
+```
+
+### Deploy
+
+```bash
+npm run deploy
+```
+
+## Project structure
+
+```
+src/
+  konserve_r2/
+    index.mjs       # Unified entry point (autodetects CLJS runtime)
+    js_store.mjs    # Pure JS KV store API (no CLJS required)
+    core.cljs       # Konserve backend registration & multimethod impl
+    bridge.mjs      # Promise ↔ core.async channel bridge
+    r2_blob.mjs     # PBackingBlob implementation
+    r2_store.mjs    # PBackingStore implementation
+  test_worker.cljs  # Example Worker using Datahike + konserve-r2
+test/
+  js_store.test.js  # Pure JS KV store tests
+  bridge.test.js    # Bridge layer tests
+  r2_blob.test.js   # PBackingBlob protocol tests
+  r2_store.test.js  # PBackingStore protocol tests
+  integration.test.js  # End-to-end Worker tests via Miniflare
+```
+
+## License
+
+Copyright 2026 Alexander Oloo
+
+Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for details.

package/konserve_r2/bridge.mjs

@@ -0,0 +1,227 @@
+// bridge.mjs — Promise ↔ core.async channel bridge
+//
+// Konserve's DefaultStore expects backing operations to return
+// core.async channels (in async mode). R2 binding API returns Promises.
+// This module bridges the two worlds by accessing compiled CLJS globals
+// from the datahike npm package.
+
+let _$CLJS = null;
+
+/**
+ * Lazily resolve the $CLJS global.
+ * This is set up by datahike or any CLJS runtime that exposes konserve
+ * on globalThis.$CLJS (e.g. a standalone konserve npm package).
+ */
+function getCLJS() {
+  if (_$CLJS) return _$CLJS;
+  if (typeof globalThis !== 'undefined' && globalThis.$CLJS) {
+    _$CLJS = globalThis.$CLJS;
+    return _$CLJS;
+  }
+  throw new Error(
+    'konserve-r2: $CLJS global not found. ' +
+    'Import datahike or a compatible konserve runtime before importing konserve-r2.'
+  );
+}
+
+/**
+ * Access a compiled CLJS keyword by name.
+ * Uses cljs.core.keyword() to ensure proper hashing and interning.
+ */
+export function keyword(name) {
+  const cljs = getCLJS().cljs;
+  return cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(name);
+}
+
+/**
+ * Build a CLJS PersistentArrayMap from a JS object.
+ */
+export function toClj(obj) {
+  const cljs = getCLJS().cljs;
+  const entries = [];
+  for (const [k, v] of Object.entries(obj)) {
+    entries.push(keyword(k));
+    entries.push(v);
+  }
+  return cljs.core.PersistentArrayMap.createAsIfByAssoc(entries);
+}
+
+/**
+ * Wrap a Promise result in a core.async channel (buffered 1).
+ * The channel will receive the resolved value or the rejection error.
+ */
+export function promiseToChan(promise) {
+  const cljs = getCLJS().cljs;
+  const ch = cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(1);
+  promise.then(
+    (val) => {
+      // null/undefined → use false as channel sentinel (channels drop nil)
+      const v = val == null ? false : val;
+      cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$2(ch, v);
+    },
+    (err) => {
+      // Put the error on the channel so superv.async can handle it
+      cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$2(ch, err);
+    }
+  );
+  return ch;
+}
+
+/**
+ * Create a channel that immediately yields a value.
+ */
+export function valueToChan(val) {
+  const cljs = getCLJS().cljs;
+  const ch = cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(1);
+  const v = val == null ? false : val;
+  cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$2(ch, v);
+  return ch;
+}
+
+/**
+ * Convert a core.async channel to a Promise.
+ * Takes a single value from the channel and resolves with it.
+ * This is the inverse of promiseToChan.
+ */
+export function chanToPromise(ch) {
+  const cljs = getCLJS().cljs;
+  // Check if ch is actually a channel
+  if (ch && ch['cljs$core$async$impl$protocols$Channel$']) {
+    return new Promise((resolve, reject) => {
+      cljs.core.async.take_BANG_.cljs$core$IFn$_invoke$arity$2(ch, (val) => {
+        if (val instanceof Error) {
+          reject(val);
+        } else {
+          resolve(val);
+        }
+      });
+    });
+  }
+  // If not a channel, just resolve with the value
+  return Promise.resolve(ch);
+}
+
+/**
+ * Access the konserve.store namespace multimethods.
+ */
+export function getStoreMultimethods() {
+  const $ = getCLJS();
+  const ks = $.konserve.store;
+  return {
+    connectStore: ks._connect_store,
+    createStore: ks._create_store,
+    storeExists: ks._store_exists_QMARK_,
+    deleteStore: ks._delete_store,
+    releaseStore: ks._release_store,
+  };
+}
+
+/**
+ * Access konserve.impl.defaults.connect_default_store
+ */
+export function getConnectDefaultStore() {
+  return getCLJS().konserve.impl.defaults.connect_default_store;
+}
+
+/**
+ * Access konserve compressor and encryptor defaults.
+ */
+export function getNullCompressor() {
+  return getCLJS().konserve.compressor.null_compressor;
+}
+
+export function getNullEncryptor() {
+  return getCLJS().konserve.encryptor.null_encryptor;
+}
+
+/**
+ * Get cljs.core.PROTOCOL_SENTINEL
+ */
+export function getProtocolSentinel() {
+  return getCLJS().cljs.core.PROTOCOL_SENTINEL;
+}
+
+/**
+ * Get cljs.core for general use
+ */
+export function getCljsCore() {
+  return getCLJS().cljs.core;
+}
+
+/**
+ * Register a method on a CLJS multimethod.
+ */
+export function addMethod(multimethod, dispatchVal, fn) {
+  multimethod.cljs$core$IMultiFn$_add_method$arity$3(null, dispatchVal, fn);
+}
+
+// ============================================================================
+// Force async mode for R2 backend
+// ============================================================================
+// Datahike defaults to {:sync? true} for connect/createDatabase/etc.
+// R2 operations are inherently async (Promises). We patch the datahike
+// connector functions to force {:sync? false} when the backend is :r2.
+// This patch is only applied when datahike is present.
+
+let _patchApplied = false;
+
+export function patchDatahikeForAsync() {
+  if (_patchApplied) return;
+  _patchApplied = true;
+
+  const $ = getCLJS();
+  const connector = $.datahike?.connector;
+  if (!connector) return; // datahike not loaded, nothing to patch
+  const cljs = $.cljs;
+  const syncKw = new cljs.core.Keyword(null, 'sync?', 'sync?', 630471618);
+  const backendKw = new cljs.core.Keyword(null, 'backend', 'backend', -847489124);
+  const storeKw = new cljs.core.Keyword(null, 'store', 'store', 1512230022);
+  const r2Kw = new cljs.core.Keyword(null, 'r2', 'r2', 0);
+
+  // Patch connect, create_database, delete_database, database_exists_QMARK_
+  const fnsToPath = ['connect', 'create_database', 'delete_database', 'database_exists_QMARK_'];
+
+  for (const fnName of fnsToPath) {
+    const original2 = connector[fnName]?.['cljs$core$IFn$_invoke$arity$2'];
+    if (original2) {
+      const origFn = connector[fnName];
+      connector[fnName]['cljs$core$IFn$_invoke$arity$2'] = function(config, opts) {
+        // Check if backend is :r2
+        const storeConfig = storeKw.cljs$core$IFn$_invoke$arity$1(config);
+        const backend = storeConfig ? backendKw.cljs$core$IFn$_invoke$arity$1(storeConfig) : null;
+        if (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(backend, r2Kw)) {
+          // Force async mode
+          opts = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(opts, syncKw, false);
+        }
+        return original2.call(origFn, config, opts);
+      };
+    }
+  }
+}
+
+// ============================================================================
+// R2 Bucket Registry
+// ============================================================================
+// The R2 bucket binding is a native Workers object that cannot be serialized
+// by CLJS. We store it in a JS-side registry keyed by store-id string.
+// The CLJS config only contains the store-id string, not the bucket object.
+
+const _bucketRegistry = new Map();
+
+/**
+ * Register an R2 bucket binding for a store-id.
+ */
+export function registerBucket(storeId, bucket) {
+  _bucketRegistry.set(storeId, bucket);
+}
+
+/**
+ * Retrieve the R2 bucket binding for a store-id.
+ */
+export function getBucket(storeId) {
+  const bucket = _bucketRegistry.get(storeId);
+  if (!bucket) {
+    throw new Error(`konserve-r2: No R2 bucket registered for store-id: ${storeId}. Call registerBucket first.`);
+  }
+  return bucket;
+}

package/konserve_r2/core.mjs

@@ -0,0 +1,112 @@
+import * as squint_core from 'squint-cljs/core.js';
+import * as bridge from './bridge.mjs';
+import * as r2_store from './r2_store.mjs';
+var cljs_core = bridge.getCljsCore();
+var kw = function (name) {
+return bridge.keyword(name);
+
+};
+var get_config_val = function (config, key_name) {
+const k1 = kw(key_name);
+return k1.cljs$core$IFn$_invoke$arity$1(config);
+
+};
+var registerBucket = bridge.registerBucket;
+var make_store_config = function (config) {
+const inner_config1 = get_config_val(config, "config");
+const merged_config2 = cljs_core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs_core.prim_seq.cljs$core$IFn$_invoke$arity$2([(new cljs_core.PersistentArrayMap(null, 3, [kw("sync-blob?"), true, kw("in-place?"), false, kw("lock-blob?"), false, kw("no-backup?"), true], null)), inner_config1], 0));
+return (new cljs_core.PersistentArrayMap(null, 8, [kw("default-serializer"), kw("FressianSerializer"), kw("compressor"), bridge.getNullCompressor(), kw("encryptor"), bridge.getNullEncryptor(), kw("read-handlers"), cljs_core.atom.cljs$core$IFn$_invoke$arity$1(cljs_core.PersistentArrayMap.EMPTY), kw("write-handlers"), cljs_core.atom.cljs$core$IFn$_invoke$arity$1(cljs_core.PersistentArrayMap.EMPTY), kw("buffer-size"), (1024 * 1024), kw("opts"), (new cljs_core.PersistentArrayMap(null, 1, [kw("sync?"), false], null)), kw("config"), merged_config2], null));
+
+};
+var connect_r2_store = function (config) {
+const store_id1 = `${get_config_val(config, "id")??''}`;
+const bucket2 = bridge.getBucket(store_id1);
+const backing3 = r2_store.createR2BackingStore(bucket2, store_id1);
+const store_config4 = make_store_config(config);
+const ch5 = bridge.getConnectDefaultStore()(backing3, store_config4);
+return bridge.chanToPromise(ch5);
+
+};
+var register_backend_BANG_ = function () {
+const multimethods1 = bridge.getStoreMultimethods();
+const r2_kw2 = kw("r2");
+bridge.addMethod(multimethods1.connectStore, r2_kw2, (function (config, opts) {
+const store_id3 = `${get_config_val(config, "id")??''}`;
+const bucket4 = bridge.getBucket(store_id3);
+const prefix5 = `${store_id3}_`;
+const marker6 = `${prefix5}konserve_store`;
+return bridge.promiseToChan(bucket4.head(marker6).then((function (obj) {
+if ((obj == null)) {
+throw (new Error(`${"R2 store does not exist for id: "}${store_id3}`))} else {
+return connect_r2_store(config)};
+
+})));
+
+}));
+bridge.addMethod(multimethods1.createStore, r2_kw2, (function (config, opts) {
+const store_id7 = `${get_config_val(config, "id")??''}`;
+const bucket8 = bridge.getBucket(store_id7);
+const prefix9 = `${store_id7}_`;
+const marker10 = `${prefix9}konserve_store`;
+return bridge.promiseToChan(bucket8.head(marker10).then((function (obj) {
+if (!(obj == null)) {
+throw (new Error(`${"R2 store already exists for id: "}${store_id7}`));
+};
+
+})).then((function (_) {
+return bucket8.put(marker10, "konserve-r2");
+
+})).then((function (_) {
+return connect_r2_store(config);
+
+})));
+
+}));
+bridge.addMethod(multimethods1.storeExists, r2_kw2, (function (config, opts) {
+const store_id11 = `${get_config_val(config, "id")??''}`;
+const bucket12 = bridge.getBucket(store_id11);
+const prefix13 = `${store_id11}_`;
+const marker14 = `${prefix13}konserve_store`;
+return bridge.promiseToChan(bucket12.head(marker14).then((function (obj) {
+return !(obj == null);
+
+})));
+
+}));
+bridge.addMethod(multimethods1.deleteStore, r2_kw2, (function (config, opts) {
+const store_id15 = `${get_config_val(config, "id")??''}`;
+const bucket16 = bridge.getBucket(store_id15);
+const prefix17 = `${store_id15}_`;
+return bridge.promiseToChan(Promise.resolve((function delete_all () {
+return bucket16.list(({"prefix": prefix17})).then((function (listing) {
+const keys18 = listing.objects.map((function (o) {
+return o.key;
+
+}));
+if ((keys18.length > 0)) {
+return bucket16.delete(keys18).then((function (_) {
+if (squint_core.truth_(listing.truncated)) {
+return delete_all()} else {
+return true};
+
+}))} else {
+return true};
+
+}));
+
+})()));
+
+}));
+return bridge.addMethod(multimethods1.releaseStore, r2_kw2, (function (_config, _store, opts) {
+const sync_QMARK_19 = get_config_val(opts, "sync?");
+if (squint_core.truth_(sync_QMARK_19)) {
+return null} else {
+return bridge.valueToChan(null)};
+
+}));
+
+};
+register_backend_BANG_();
+bridge.patchDatahikeForAsync();
+
+export { registerBucket }