diff --git a/package-fireproof-core.json b/package-fireproof-core.json
index 92bbb862..150b3a31 100644
--- a/package-fireproof-core.json
+++ b/package-fireproof-core.json
@@ -30,5 +30,11 @@
     "url": "https://github.com/fireproof-storage/fireproof/issues"
   },
   "devDependencies": {},
-  "dependencies": {}
+  "dependencies": {
+    "@adviser/cement": "from-package-json",
+    "charwise": "from-package-json",
+    "prolly-trees": "from-package-json",
+    "ipfs-unixfs-exporter": "from-package-json",
+    "uuidv7": "from-package-json"
+  }
 }
diff --git a/package.json b/package.json
index 4abd5a01..b1966c99 100644
--- a/package.json
+++ b/package.json
@@ -72,7 +72,7 @@
   },
   "homepage": "https://github.com/fireproof-storage/fireproof#readme",
   "dependencies": {
-    "@adviser/cement": "^0.1.19",
+    "@adviser/cement": "^0.1.20",
     "@ipld/car": "^5.3.2",
     "@ipld/dag-cbor": "^9.2.1",
     "@ipld/dag-json": "^10.2.2",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b81496d6..99edf324 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -9,8 +9,8 @@ importers:
   .:
     dependencies:
       '@adviser/cement':
-        specifier: ^0.1.19
-        version: 0.1.19
+        specifier: ^0.1.20
+        version: 0.1.20
       '@ipld/car':
         specifier: ^5.3.2
         version: 5.3.2
@@ -139,8 +139,8 @@ packages:
     resolution: {integrity: sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==}
     engines: {node: '>=0.10.0'}
 
-  '@adviser/cement@0.1.19':
-    resolution: {integrity: sha512-LRnb2dU5cvNYLvfL+Gnd28hOM48U+wn/oLD+1a/0t1ygPkmxFuJW9nEEke5uJvOO2DVaJXNzJkAcvQ/C9Y57Xg==}
+  '@adviser/cement@0.1.20':
+    resolution: {integrity: sha512-6Pi0d+a4+cgE1XlBi5Ot6v6DOcKJxdGaqJ9qt4jktvlkBFtgJsvwC5saFNYjerVAdVO6eoZUEUmZlPCXlE8Lrw==}
     engines: {node: '>=16'}
 
   '@babel/code-frame@7.24.7':
@@ -2877,7 +2877,7 @@ snapshots:
 
   '@aashutoshrathi/word-wrap@1.2.6': {}
 
-  '@adviser/cement@0.1.19': {}
+  '@adviser/cement@0.1.20': {}
 
   '@babel/code-frame@7.24.7':
     dependencies:
diff --git a/smoke/react/src/routes/Todo.tsx b/smoke/react/src/routes/Todo.tsx
index 8310441f..96db1a24 100644
--- a/smoke/react/src/routes/Todo.tsx
+++ b/smoke/react/src/routes/Todo.tsx
@@ -32,18 +32,18 @@ export default function TodoList() {
         />
         <button
           onClick={() => {
-            console.log(`saving todo-0: ${todo.text}`)
+            console.log(`saving todo-0: ${todo.text}`);
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             delete (todo as any)._id;
-            console.log(`saving todo-1: ${todo.text}`)
+            console.log(`saving todo-1: ${todo.text}`);
             // console.log("saving todo", todo, saveTodo.toString());
             saveTodo()
               .then(() => {
-                console.log(`saving todo-2: ${todo.text}`)
+                console.log(`saving todo-2: ${todo.text}`);
                 // console.log("saved todo", todo.text);
                 setTodo({ text: "", _id: undefined });
               })
-              .catch((e) => console.error('Add-Todo Error:', e));
+              .catch((e) => console.error("Add-Todo Error:", e));
           }}
         >
           Add Todo
diff --git a/smoke/react/src/routes/todo-list.test.tsx b/smoke/react/src/routes/todo-list.test.tsx
index e9c349a5..84addb7e 100644
--- a/smoke/react/src/routes/todo-list.test.tsx
+++ b/smoke/react/src/routes/todo-list.test.tsx
@@ -6,22 +6,22 @@ import { expect, describe, it } from "vitest";
 import { Database, fireproof } from "use-fireproof";
 
 describe("<TodoList />", () => {
-  let fp: Database
+  let fp: Database;
   afterEach(async () => {
-    console.log("ae-pre-destroy")
+    console.log("ae-pre-destroy");
     await fp.destroy();
-    console.log("ae-post-destroy")
+    console.log("ae-post-destroy");
   });
   beforeEach(async () => {
-    console.log("be-pre-create")
+    console.log("be-pre-create");
     fp = fireproof("TodoDB");
     const all = await fp.allDocs();
     for (const doc of all.rows) {
       await fp.del(doc.key);
     }
-    console.log("be-post-create")
+    console.log("be-post-create");
   });
-  it.skip("it will render an text input and a button", async() => {
+  it.skip("it will render an text input and a button", async () => {
     render(<TodoList />);
     expect(await screen.findByPlaceholderText("new todo here")).not.toBeNull();
     expect(await screen.findByText("Add Todo")).not.toBeNull();
@@ -30,7 +30,7 @@ describe("<TodoList />", () => {
 
   it("it will add a new todo", async () => {
     render(<TodoList />);
-    const input = await screen.findByPlaceholderText("new todo here") as HTMLInputElement;
+    const input = (await screen.findByPlaceholderText("new todo here")) as HTMLInputElement;
     const button = await screen.findByText("Add Todo");
 
     const values = Array(10)
@@ -47,40 +47,40 @@ describe("<TodoList />", () => {
   });
 
   it("it will mark a todo as completed", async () => {
-    console.log("pre-last")
+    console.log("pre-last");
     render(<TodoList />);
-    console.log("pre-0")
+    console.log("pre-0");
     // add todo
     const input = await screen.findByPlaceholderText("new todo here");
     const button = await screen.findByText("Add Todo");
     const value = `ToComplete(${Math.random()})`;
     await fireEvent.change(input, { target: { value } });
     await fireEvent.click(button);
-    console.log("pre-1")
+    console.log("pre-1");
 
     // open editor
     const item = await screen.findByText(value);
-    console.log("pre-1.0")
+    console.log("pre-1.0");
     expect(item).not.toBeNull();
-    console.log("pre-1.1")
+    console.log("pre-1.1");
     const radio = item.parentNode?.querySelector("input[type=radio]") as HTMLInputElement;
-    console.log("pre-1.2")
+    console.log("pre-1.2");
     await fireEvent.click(radio);
-    console.log("pre-2")
+    console.log("pre-2");
 
     // check off todo
     const textInput = (await screen.findByDisplayValue(value)) as HTMLInputElement;
     const checkBox = textInput.parentNode?.querySelector("input[type=checkbox]") as HTMLInputElement;
     expect(checkBox.checked).toBe(false);
     await fireEvent.click(checkBox);
-    console.log("pre-3")
+    console.log("pre-3");
 
     await waitFor(() => {
       expect(checkBox.checked).toBe(true);
     });
-    console.log("pre-4")
+    console.log("pre-4");
     expect(item.attributeStyleMap.get("text-decoration")?.toString()).toBe("line-through");
-    console.log("post-last")
+    console.log("post-last");
     // await new Promise((r) => setTimeout(r, 2000));
   });
 });
diff --git a/src/blockstore/index.ts b/src/blockstore/index.ts
index 5bed1830..edd4ce70 100644
--- a/src/blockstore/index.ts
+++ b/src/blockstore/index.ts
@@ -11,6 +11,7 @@ export type {
   DbMeta,
   CommitOpts,
   CryptoOpts,
+  StoreFactory,
   StoreOpts,
   StoreRuntime,
   TransactionMeta,
@@ -26,7 +27,7 @@ export { ConnectREST, CarClockHead, Connectable, DbMetaEventBlock };
 
 export { EncryptedBlockstore, BaseBlockstore, CompactionFetcher, type BlockFetcher, CarTransaction } from "./transaction.js";
 export { Loader, Loadable } from "./loader.js";
-export { DataStore, MetaStore } from "./store.js";
+export { DataStore, DataSaveOpts, MetaStore } from "./store.js";
 export { RemoteWAL, type WALState } from "./remote-wal.js";
 export { parseCarFile } from "./loader-helpers.js";
 export { ConnectionBase } from "./connection-base.js";
diff --git a/src/blockstore/loader.ts b/src/blockstore/loader.ts
index c81254e3..40d3549f 100644
--- a/src/blockstore/loader.ts
+++ b/src/blockstore/loader.ts
@@ -69,6 +69,25 @@ export abstract class Loadable {
   abstract handleDbMetasFromStore(metas: DbMeta[]): Promise<void>;
 }
 
+interface Startable {
+  start(): Promise<void>;
+}
+
+class EnsureStart<T extends Startable> {
+  readonly oncePerStore = new ResolveOnce<T>();
+
+  reset() {
+    this.oncePerStore.reset();
+  }
+  once(fn: () => Promise<T>) {
+    return this.oncePerStore.once(async () => {
+      const ret = await fn();
+      await ret.start();
+      return ret;
+    });
+  }
+}
+
 export class Loader implements Loadable {
   readonly name: string;
   readonly ebOpts: BlockstoreRuntime;
@@ -91,19 +110,31 @@ export class Loader implements Loadable {
 
   // readonly id = uuidv4();
 
+  readonly ensureCarStore = new EnsureStart<DataStore>();
   async carStore(): Promise<DataStore> {
-    return this.ebOpts.store.makeDataStore(this);
+    return this.ensureCarStore.once(() => {
+      return this.ebOpts.store.makeDataStore(this);
+    });
   }
 
+  readonly ensureFileStore = new EnsureStart<DataStore>();
   async fileStore(): Promise<DataStore> {
-    return this.ebOpts.store.makeDataStore(this);
+    return this.ensureFileStore.once(() => {
+      return this.ebOpts.store.makeDataStore(this);
+    });
   }
+  readonly ensureRemoteFileStore = new EnsureStart<RemoteWAL>();
   async remoteWAL(): Promise<RemoteWAL> {
-    return this.ebOpts.store.makeRemoteWAL(this);
+    return this.ensureRemoteFileStore.once(() => {
+      return this.ebOpts.store.makeRemoteWAL(this);
+    });
   }
 
+  readonly ensureMetaStore = new EnsureStart<MetaStore>();
   async metaStore(): Promise<MetaStore> {
-    return this.ebOpts.store.makeMetaStore(this);
+    return this.ensureMetaStore.once(() => {
+      return this.ebOpts.store.makeMetaStore(this);
+    });
   }
 
   readonly onceReady = new ResolveOnce<void>();
@@ -118,7 +149,15 @@ export class Loader implements Loadable {
 
   async close() {
     const toClose = await Promise.all([this.carStore(), this.metaStore(), this.fileStore(), this.remoteWAL()]);
-    await Promise.all(toClose.map((store) => store.close()));
+    await Promise.all(
+      toClose.map((store) => {
+        store.close();
+      }),
+    );
+    this.ensureCarStore.reset();
+    this.ensureFileStore.reset();
+    this.ensureRemoteFileStore.reset();
+    this.ensureMetaStore.reset();
   }
 
   async destroy() {
@@ -331,9 +370,9 @@ export class Loader implements Loadable {
     t: CarTransaction,
   ): Promise<{ cid: AnyLink; bytes: Uint8Array }> {
     try {
-    return theKey && this.ebOpts.crypto
-      ? await encryptedEncodeCarFile(this.logger, this.ebOpts.crypto, theKey, cid, t)
-      : await encodeCarFile([cid], t);
+      return theKey && this.ebOpts.crypto
+        ? await encryptedEncodeCarFile(this.logger, this.ebOpts.crypto, theKey, cid, t)
+        : await encodeCarFile([cid], t);
     } catch (e) {
       console.error("error creating car file", e);
       throw e;
diff --git a/src/blockstore/remote-wal.ts b/src/blockstore/remote-wal.ts
index f0997cec..f257d6ba 100644
--- a/src/blockstore/remote-wal.ts
+++ b/src/blockstore/remote-wal.ts
@@ -23,7 +23,7 @@ export abstract class RemoteWAL {
 
   readonly _ready = new ResolveOnce<void>();
 
-  async ready() {
+  private async ready() {
     return this._ready.once(async () => {
       const walState = await this._load().catch((e) => {
         this.logger.Error().Any("error", e).Msg("error loading wal");
@@ -47,10 +47,10 @@ export abstract class RemoteWAL {
 
   readonly logger: Logger;
 
-  constructor(loader: Loadable, url: URL) {
+  constructor(loader: Loadable, url: URL, logger: Logger) {
+    this.logger = logger;
     this.loader = loader;
     this.url = url;
-    this.logger = loader.logger;
   }
 
   async enqueue(dbMeta: DbMeta, opts: CommitOpts) {
@@ -165,6 +165,8 @@ export abstract class RemoteWAL {
     await rmlp;
   }
 
+  abstract start(): Promise<void>;
+
   async load(): Promise<WALState | Falsy> {
     await this.ready();
     return await this._load();
diff --git a/src/blockstore/store-factory.ts b/src/blockstore/store-factory.ts
index 1ecbf2a6..c2373354 100644
--- a/src/blockstore/store-factory.ts
+++ b/src/blockstore/store-factory.ts
@@ -8,9 +8,9 @@ import { DataStore, MetaStore } from "./store.js";
 import { StoreOpts, StoreRuntime, TestStore } from "./types.js";
 import { ensureLogger } from "../utils.js";
 
-function ensureIsIndex(url: URL, isIndex?: boolean): URL {
+function ensureIsIndex(url: URL, isIndex?: string): URL {
   if (isIndex) {
-    url.searchParams.set("index", "idx");
+    url.searchParams.set("index", isIndex);
     return url;
   } else {
     url.searchParams.delete("index");
@@ -18,7 +18,7 @@ function ensureIsIndex(url: URL, isIndex?: boolean): URL {
   }
 }
 
-export function toURL(pathOrUrl: string | URL, isIndex?: boolean): URL {
+export function toURL(pathOrUrl: string | URL, isIndex?: string): URL {
   if (pathOrUrl instanceof URL) return ensureIsIndex(pathOrUrl, isIndex);
   try {
     const url = new URL(pathOrUrl);
@@ -164,22 +164,31 @@ export async function testStoreFactory(url: URL, ilogger?: Logger): Promise<Test
 export function toStoreRuntime(name: string | undefined = undefined, opts: StoreOpts = {}): StoreRuntime {
   return {
     makeMetaStore: (loader: Loadable) => {
-      return cacheStore(toURL(opts.stores?.meta || dataDir(name || loader.name, opts.stores?.base), opts.isIndex), loader, {
-        meta: metaStoreFactory,
-      });
+      return (
+        opts.makeMetaStore?.(loader) ||
+        cacheStore(toURL(opts.stores?.meta || dataDir(name || loader.name, opts.stores?.base), opts.isIndex), loader, {
+          meta: metaStoreFactory,
+        })
+      );
     },
     makeDataStore: (loader: Loadable) => {
-      return cacheStore(toURL(opts.stores?.data || dataDir(name || loader.name, opts.stores?.base), opts.isIndex), loader, {
-        data: dataStoreFactory,
-      });
+      return (
+        opts.makeDataStore?.(loader) ||
+        cacheStore(toURL(opts.stores?.data || dataDir(name || loader.name, opts.stores?.base), opts.isIndex), loader, {
+          data: dataStoreFactory,
+        })
+      );
     },
     makeRemoteWAL: (loader: Loadable) => {
-      return cacheStore(toURL(opts.stores?.remoteWAL || dataDir(name || loader.name, opts.stores?.base), opts.isIndex), loader, {
-        remoteWAL: remoteWalFactory,
-      });
+      return (
+        opts.makeRemoteWAL?.(loader) ||
+        cacheStore(toURL(opts.stores?.remoteWAL || dataDir(name || loader.name, opts.stores?.base), opts.isIndex), loader, {
+          remoteWAL: remoteWalFactory,
+        })
+      );
     },
 
-    encodeFile,
-    decodeFile,
+    encodeFile: opts.encodeFile || encodeFile,
+    decodeFile: opts.decodeFile || decodeFile,
   };
 }
diff --git a/src/blockstore/store-memory.ts b/src/blockstore/store-memory.ts
index 8e418583..3c54c687 100644
--- a/src/blockstore/store-memory.ts
+++ b/src/blockstore/store-memory.ts
@@ -8,10 +8,8 @@ export class MemoryDataStore extends DataStore {
   readonly tag: string = "car-mem";
   readonly store = new Map<string, Uint8Array>();
 
-  readonly logger: Logger;
   constructor(name: string, url: URL, logger: Logger) {
-    super(name, url);
-    this.logger = ensureLogger(logger, "MemoryDataStore", { name, url });
+    super(name, url, ensureLogger(logger, "MemoryDataStore", { name, url }));
   }
 
   async load(cid: AnyLink): Promise<AnyBlock> {
@@ -33,6 +31,9 @@ export class MemoryDataStore extends DataStore {
   async destroy() {
     // no-op
   }
+  async start() {
+    // no-op
+  }
 }
 
 export class MemoryMetaStore extends MetaStore {
@@ -73,6 +74,9 @@ export class MemoryMetaStore extends MetaStore {
   async destroy() {
     // no-op
   }
+  async start() {
+    // no-op
+  }
 }
 
 //
@@ -108,4 +112,7 @@ export class MemoryRemoteWAL extends RemoteWAL {
   async _destroy() {
     // no-op
   }
+  async start() {
+    // no-op
+  }
 }
diff --git a/src/blockstore/store-remote.ts b/src/blockstore/store-remote.ts
index 102a9d7e..c04e45d4 100644
--- a/src/blockstore/store-remote.ts
+++ b/src/blockstore/store-remote.ts
@@ -55,18 +55,20 @@ export class RemoteDataStore extends DataStore {
   readonly connection: Connection;
   readonly type: FnParamTypes;
 
-  readonly logger: Logger;
   constructor(url: URL, name: string, connection: Connection, logger: Logger, type: FnParamTypes = "data") {
-    super(name, url);
+    super(name, url, ensureLogger(logger, "RemoteDataStore", { name, url }));
     this.connection = connection;
     this.type = type;
-    this.logger = ensureLogger(logger, "RemoteDataStore", { name, url });
   }
 
   prefix() {
     return `fp.${this.name}`;
   }
 
+  async start() {
+    // no-op
+  }
+
   async load(carCid: AnyLink): Promise<AnyBlock> {
     const params = {
       type: this.type,
@@ -113,6 +115,10 @@ export class RemoteMetaStore extends MetaStore {
     this.connection = connection;
   }
 
+  async start(): Promise<void> {
+    // no-op
+  }
+
   onLoad(branch: string, loadHandler: LoadHandler): () => void {
     const subscribers = this.subscribers.get(branch) || [];
     subscribers.push(loadHandler);
@@ -177,7 +183,7 @@ export class RemoteWALStore extends RemoteWAL {
   readonly store: Map<string, string>;
 
   constructor(url: URL, loader: Loadable) {
-    super(loader, url);
+    super(loader, url, ensureLogger(loader.logger, "RemoteWALStore", { name: loader.name }));
     this.store = new Map<string, string>();
   }
 
@@ -185,6 +191,10 @@ export class RemoteWALStore extends RemoteWAL {
     return `fp.wal.${this.loader.name}.${branch}`;
   }
 
+  async start(): Promise<void> {
+    // no-op
+  }
+
   async _load(branch = "main"): Promise<WALState | null> {
     const bytesString = this.store.get(this.headerKey(branch));
     if (!bytesString) return null;
diff --git a/src/blockstore/store.ts b/src/blockstore/store.ts
index e7fdd014..d509a66a 100644
--- a/src/blockstore/store.ts
+++ b/src/blockstore/store.ts
@@ -21,6 +21,8 @@ abstract class VersionedStore {
     if (!sv) throw this.logger.Error().Str("url", url.toString()).Msg(`version not found`);
     this.STORAGE_VERSION = sv;
   }
+
+  abstract start(): Promise<void>;
 }
 
 export abstract class MetaStore extends VersionedStore {
@@ -43,20 +45,20 @@ export abstract class MetaStore extends VersionedStore {
   abstract destroy(): Promise<void>;
 }
 
-interface DataSaveOpts {
+export interface DataSaveOpts {
   readonly public: boolean;
 }
 
-export abstract class DataStore {
+export abstract class DataStore extends VersionedStore {
   readonly tag: string = "car-base";
 
   // readonly STORAGE_VERSION: string = STORAGE_VERSION;
-  readonly name: string;
-  readonly url: URL;
-  constructor(name: string, url: URL) {
-    this.name = name;
-    this.url = url;
-  }
+  // readonly name: string;
+  // readonly url: URL;
+  // constructor(name: string, url: URL) {
+  //   this.name = name;
+  //   this.url = url;
+  // }
 
   abstract load(cid: AnyLink): Promise<AnyBlock>;
   abstract save(car: AnyBlock, opts?: DataSaveOpts): Promise</*AnyLink | */ void>;
diff --git a/src/blockstore/types.ts b/src/blockstore/types.ts
index c4604c61..8485e1fd 100644
--- a/src/blockstore/types.ts
+++ b/src/blockstore/types.ts
@@ -115,8 +115,17 @@ export interface BlobLike {
   stream: () => ReadableStream;
 }
 
-export interface StoreOpts {
-  readonly isIndex?: boolean;
+export interface StoreFactory {
+  makeMetaStore?: (loader: Loadable) => Promise<MetaStore>;
+  makeDataStore?: (loader: Loadable) => Promise<DataStore>;
+  makeRemoteWAL?: (loader: Loadable) => Promise<RemoteWAL>;
+
+  encodeFile?: (blob: BlobLike) => Promise<{ cid: AnyLink; blocks: AnyBlock[] }>;
+  decodeFile?: (blocks: unknown, cid: AnyLink, meta: DocFileMeta) => Promise<File>;
+}
+
+export interface StoreOpts extends StoreFactory {
+  readonly isIndex?: string; // index prefix
   readonly stores?: {
     // string means local storage
     // URL means schema selects the storeType
@@ -127,12 +136,6 @@ export interface StoreOpts {
     readonly index?: string | URL;
     readonly remoteWAL?: string | URL;
   };
-  makeMetaStore?: (loader: Loadable) => Promise<MetaStore>;
-  makeDataStore?: (loader: Loadable) => Promise<DataStore>;
-  makeRemoteWAL?: (loader: Loadable) => Promise<RemoteWAL>;
-
-  encodeFile?: (blob: BlobLike) => Promise<{ cid: AnyLink; blocks: AnyBlock[] }>;
-  decodeFile?: (blocks: unknown, cid: AnyLink, meta: DocFileMeta) => Promise<File>;
 }
 
 export interface TestStore {
diff --git a/src/crdt.ts b/src/crdt.ts
index d222d905..cf4dcca0 100644
--- a/src/crdt.ts
+++ b/src/crdt.ts
@@ -79,7 +79,7 @@ export class CRDT<T extends DocTypes> {
       },
       autoCompact: this.opts.autoCompact || 100,
       crypto: this.opts.crypto,
-      store: { ...this.opts.store, isIndex: false },
+      store: { ...this.opts.store, isIndex: undefined },
       public: this.opts.public,
       meta: this.opts.meta,
       threshold: this.opts.threshold,
@@ -94,7 +94,7 @@ export class CRDT<T extends DocTypes> {
         }
       },
       crypto: this.opts.crypto,
-      store: { ...this.opts.store, isIndex: true },
+      store: { ...this.opts.store, isIndex: this.opts.store?.isIndex || "idx" },
       public: this.opts.public,
     });
     this.clock = new CRDTClock<T>(this.blockstore);
diff --git a/src/index.ts b/src/index.ts
index c6556671..ef1e8842 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -10,4 +10,6 @@ export * as blockstore from "./blockstore/index.js";
 export * as bs from "./blockstore/index.js";
 export * as rt from "./runtime/index.js";
 
+export * from "./utils.js";
+
 export * from "./version.js";
diff --git a/src/indexer.ts b/src/indexer.ts
index 3da9fbe5..d9b0d5c4 100644
--- a/src/indexer.ts
+++ b/src/indexer.ts
@@ -229,7 +229,7 @@ export class Index<K extends IndexKeyType, T extends DocTypes, R extends DocFrag
     }
     if (result.length === 0) {
       this.indexHead = head;
-      console.log("_updateIndex: no changes")
+      console.log("_updateIndex: no changes");
       // return { byId: this.byId, byKey: this.byKey } as IndexTransactionMeta;
     }
     let staleKeyIndexEntries: IndexUpdate<K>[] = [];
diff --git a/src/react/useFireproof.ts b/src/react/useFireproof.ts
index 12e4c0f7..efb49de1 100644
--- a/src/react/useFireproof.ts
+++ b/src/react/useFireproof.ts
@@ -143,7 +143,7 @@ export function useFireproof(name: string | Database = "useFireproof", config: C
 
     const saveDoc: StoreDocFn<T> = useCallback(
       async (existingDoc) => {
-        console.log("saveDoc", existingDoc, doc)
+        console.log("saveDoc", existingDoc, doc);
         const res = await database.put(existingDoc ?? doc);
         // If the document was created, then we need to update the local state with the new `_id`
         if (!existingDoc && !doc._id) setDoc((d) => ({ ...d, _id: res.id }));
diff --git a/src/runtime/store-file.ts b/src/runtime/store-file.ts
index be977410..d1cf6e58 100644
--- a/src/runtime/store-file.ts
+++ b/src/runtime/store-file.ts
@@ -80,7 +80,7 @@ function ensureIndexName(url: URL, name: string): string {
 
 export class FileRemoteWAL extends RemoteWAL {
   constructor(url: URL, loader: Loadable) {
-    super(loader, ensureVersion(url));
+    super(loader, ensureVersion(url), ensureLogger(loader.logger, "FileRemoteWAL", { url }));
   }
 
   readonly branches = new Set<string>();
@@ -89,6 +89,10 @@ export class FileRemoteWAL extends RemoteWAL {
     return SysContainer.join(await getPath(this.url, this.logger), ensureIndexName(this.url, "wal"), branch + ".json");
   }
 
+  async start() {
+    await SysContainer.start();
+  }
+
   async _load(branch = "main"): Promise<WALState | Falsy> {
     this.branches.add(branch);
     const filepath = await this.filePathForBranch(branch);
@@ -128,13 +132,16 @@ export class FileMetaStore extends MetaStore {
     super(name, ensureVersion(url), ensureLogger(logger, "FileMetaStore", { name, url }));
   }
 
+  async start() {
+    await SysContainer.start();
+  }
+
   async filePathForBranch(branch: string): Promise<string> {
     return SysContainer.join(await getPath(this.url, this.logger), ensureIndexName(this.url, "meta"), branch + ".json");
   }
 
   async load(branch = "main"): Promise<DbMeta[] | Falsy> {
     this.branches.add(branch);
-    await SysContainer.start();
     const filepath = await this.filePathForBranch(branch);
     const bytes = await SysContainer.readfile(filepath).catch((e: Error & { code: string }) => {
       if (e.code === "ENOENT") return undefined;
@@ -168,10 +175,12 @@ export class FileMetaStore extends MetaStore {
 export class FileDataStore extends DataStore {
   readonly tag: string = "car-node-fs";
 
-  readonly logger: Logger;
   constructor(url: URL, name: string, logger: Logger) {
-    super(name, ensureVersion(url));
-    this.logger = ensureLogger(logger, "FileDataStore", { name, url });
+    super(name, ensureVersion(url), ensureLogger(logger, "FileDataStore", { name, url }));
+  }
+
+  async start() {
+    await SysContainer.start();
   }
 
   private async cidPath(cid: AnyLink): Promise<string> {
@@ -179,14 +188,12 @@ export class FileDataStore extends DataStore {
   }
 
   async save(car: AnyBlock): Promise<void> {
-    await SysContainer.start();
     const filepath = await this.cidPath(car.cid);
     // console.log("save->", filepath);
     await writePathFile(filepath, car.bytes);
   }
 
   async load(cid: AnyLink): Promise<AnyBlock> {
-    await SysContainer.start();
     const filepath = await this.cidPath(cid);
     const bytes = await SysContainer.readfile(filepath);
     return { cid, bytes: new Uint8Array(bytes) };
diff --git a/src/runtime/store-indexdb.ts b/src/runtime/store-indexdb.ts
index 026645a0..a5eab302 100644
--- a/src/runtime/store-indexdb.ts
+++ b/src/runtime/store-indexdb.ts
@@ -212,17 +212,22 @@ export class IndexDBDataStore extends DataStoreBase {
 
   readonly ensureDB: EnsureDB;
 
-  readonly logger: Logger;
-
   constructor(name: string, url: URL, logger: Logger) {
-    super(name, ensureVersion(url));
-    this.logger = ensureLogger(logger, "IndexDBDataStore", {
+    super(
       name,
-      url,
-    });
+      ensureVersion(url),
+      ensureLogger(logger, "IndexDBDataStore", {
+        name,
+        url,
+      }),
+    );
     this.ensureDB = new EnsureDB(this.url, this.logger);
   }
 
+  async start(): Promise<void> {
+    // no-op
+  }
+
   async load(cid: AnyLink): Promise<AnyBlock> {
     return await this.ensureDB.get(async (db) => {
       console.log("IndexDBDataStore:load", db.type, cid.toString());
@@ -239,7 +244,7 @@ export class IndexDBDataStore extends DataStoreBase {
 
   async save(car: AnyBlock): Promise<void> {
     return await this.ensureDB.get(async (db: SimpleDb) => {
-    console.log("IndexDBDataStore:save", db.type, car.cid.toString());
+      console.log("IndexDBDataStore:save", db.type, car.cid.toString());
       // await db.idb().put(getStore(this.url), car.bytes, car.cid.toString());
       // await db.put(car.bytes, [car.cid.toString()]);
       const tx = db.idb().transaction(getStore(this.url, this.logger), "readwrite");
@@ -251,7 +256,7 @@ export class IndexDBDataStore extends DataStoreBase {
 
   async remove(cid: AnyLink): Promise<void> {
     return await this.ensureDB.get(async (db: SimpleDb) => {
-    console.log("IndexDBDataStore:remove", db.type, cid.toString());
+      console.log("IndexDBDataStore:remove", db.type, cid.toString());
       // const tx = db.transaction([dbName.type], "readwrite");
       // await tx.objectStore(dbName.type).delete(cid.toString());
       // await tx.done
@@ -266,7 +271,7 @@ export class IndexDBDataStore extends DataStoreBase {
   async destroy() {
     // return deleteDB(getIndexDBName(this.url).fullDb);
     await this.ensureDB.get(async (db) => {
-      const type = db.type
+      const type = db.type;
       // console.log("IndexDBDataStore:destroy", type);
       const idb = db.idb();
       const trans = idb.transaction(type, "readwrite");
@@ -288,18 +293,23 @@ export class IndexDBRemoteWAL extends RemoteWALBase {
 
   readonly ensureDB: EnsureDB;
 
-  readonly logger: Logger;
   readonly branches = new Set<string>();
 
   constructor(loader: Loadable, url: URL) {
-    super(loader, ensureVersion(url));
-    this.logger = ensureLogger(loader.logger, "IndexDBRemoteWAL", {
-      url,
-      name: loader.name,
-    });
+    super(
+      loader,
+      ensureVersion(url),
+      ensureLogger(loader.logger, "IndexDBRemoteWAL", {
+        url,
+        name: loader.name,
+      }),
+    );
     this.ensureDB = new EnsureDB(this.url, this.logger);
   }
 
+  async start() {
+    // no-op
+  }
 
   headerKey(branch: string) {
     // return `fp.${this.STORAGE_VERSION}.wal.${this.loader.name}.${branch}`;
@@ -343,7 +353,7 @@ export class IndexDBRemoteWAL extends RemoteWALBase {
   }
   async _destroy() {
     await this.ensureDB.get(async (db) => {
-      const type = db.type
+      const type = db.type;
       // console.log("IndexDBRemoteWAL:destroy", type);
       const idb = db.idb();
       const trans = idb.transaction(type, "readwrite");
@@ -375,6 +385,10 @@ export class IndexDBMetaStore extends MetaStoreBase {
     this.ensureDB = new EnsureDB(this.url, this.logger);
   }
 
+  async start() {
+    // no-op
+  }
+
   readonly branches = new Set<string>();
   headerKey(branch: string) {
     // return `fp.${this.STORAGE_VERSION}.meta.${this.name}.${branch}`;
@@ -407,9 +421,9 @@ export class IndexDBMetaStore extends MetaStoreBase {
       console.log("IndexDBMeta:save", db.type, branch);
       try {
         const headerKey = this.headerKey(branch);
-        console.log(`xxxx->1`)
+        console.log(`xxxx->1`);
         const bytes = this.makeHeader(meta);
-        console.log(`xxxx->2`, bytes, headerKey)
+        console.log(`xxxx->2`, bytes, headerKey);
         await db.put(bytes, [headerKey]);
         // const tx = db.transaction([dbName.type], "readwrite");
         // await tx.objectStore(dbName.type).put(bytes, headerKey);
@@ -428,7 +442,7 @@ export class IndexDBMetaStore extends MetaStoreBase {
   }
   async destroy() {
     await this.ensureDB.get(async (db) => {
-      const type = db.type
+      const type = db.type;
       // console.log("IndexDBMeta:destroy", this.id, type);
       const idb = db.idb();
       const trans = idb.transaction(type, "readwrite");
diff --git a/src/runtime/store-sql/store-sql.ts b/src/runtime/store-sql/store-sql.ts
index 2f6e99f3..8e7d1275 100644
--- a/src/runtime/store-sql/store-sql.ts
+++ b/src/runtime/store-sql/store-sql.ts
@@ -14,12 +14,16 @@ import { ensureLogger } from "../../utils.js";
 
 export class SQLRemoteWAL extends RemoteWAL {
   constructor(url: URL, loader: Loadable) {
-    super(loader, ensureSQLVersion(url, loader.logger));
+    const logger = ensureLogger(loader.logger, "SQLRemoteWAL", { url });
+    super(loader, ensureSQLVersion(url, logger), logger);
+  }
+
+  async start(): Promise<void> {
+    await SysContainer.start();
   }
 
   readonly onceWalStore = new ResolveOnce<WalSQLStore>();
   async ensureStore() {
-    await SysContainer.start();
     return this.onceWalStore.once(async () => {
       const conn = SQLConnectionFactory(this.url);
       const ws = await WalStoreFactory(conn);
@@ -67,9 +71,12 @@ export class SQLMetaStore extends MetaStore {
     super(name, ensureSQLVersion(url, logger), logger);
   }
 
+  async start() {
+    await SysContainer.start();
+  }
+
   readonly onceMetaStore = new ResolveOnce<MetaSQLStore>();
   async ensureStore() {
-    await SysContainer.start();
     const conn = SQLConnectionFactory(this.url);
     return this.onceMetaStore.once(async () => {
       const ws = await MetaStoreFactory(conn);
@@ -115,11 +122,13 @@ export class SQLMetaStore extends MetaStore {
 export class SQLDataStore extends DataStore {
   readonly tag: string = "car-sql";
 
-  readonly logger: Logger;
   constructor(url: URL, name: string, ilogger: Logger) {
     const logger = ensureLogger(ilogger, "SQLDataStore", { name, url });
-    super(name, ensureSQLVersion(url, logger));
-    this.logger = logger;
+    super(name, ensureSQLVersion(url, logger), logger);
+  }
+
+  async start() {
+    await SysContainer.start();
   }
 
   readonly onceDataStore = new ResolveOnce<DataSQLStore>();
diff --git a/src/utils.ts b/src/utils.ts
index 827ff649..d0ffaac3 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -1,5 +1,7 @@
 import { Logger, LoggerImpl, IsLogger } from "@adviser/cement";
 
+export type { Logger };
+
 const globalLogger: Logger = new LoggerImpl();
 
 export interface LoggerOpts {
diff --git a/tests/fireproof/are-stores-started.test.ts b/tests/fireproof/are-stores-started.test.ts
new file mode 100644
index 00000000..618ecd7b
--- /dev/null
+++ b/tests/fireproof/are-stores-started.test.ts
@@ -0,0 +1,37 @@
+import { fireproof, bs } from "@fireproof/core";
+import { vi } from "vitest";
+
+class MockaStartableStore {
+  start = vi.fn();
+  save = vi.fn();
+  load = vi.fn();
+  enqueue = vi.fn();
+}
+describe("areStoresStarted", () => {
+  it("started data - meta - wal", async () => {
+    const dataStore = new MockaStartableStore();
+    const metaStore = new MockaStartableStore();
+    const walStore = new MockaStartableStore();
+    const db = fireproof("datastore-started", {
+      store: {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        makeDataStore: async (loader: bs.Loadable): Promise<bs.DataStore> => {
+          return dataStore as unknown as bs.DataStore;
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        makeMetaStore: async (loader: bs.Loadable): Promise<bs.MetaStore> => {
+          return metaStore as unknown as bs.MetaStore;
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        makeRemoteWAL: async (loader: bs.Loadable): Promise<bs.RemoteWAL> => {
+          return walStore as unknown as bs.RemoteWAL;
+        },
+      },
+    });
+    await db.put({ key: "foo", value: "bar" });
+
+    expect(dataStore.start).toHaveBeenCalled();
+    expect(metaStore.start).toHaveBeenCalled();
+    expect(walStore.start).toHaveBeenCalled();
+  });
+});
diff --git a/tests/fireproof/config.test.ts b/tests/fireproof/config.test.ts
index 5da004f3..d600746b 100644
--- a/tests/fireproof/config.test.ts
+++ b/tests/fireproof/config.test.ts
@@ -18,6 +18,7 @@ describe("fireproof/config", () => {
       expect(fileStore?.url.toString()).toMatch(new RegExp(`indexdb://fp\\?name=my-app&store=data&version=${rt.INDEXDB_VERSION}`));
       const metaStore = await db.blockstore.loader?.metaStore();
       expect(metaStore?.url.toString()).toMatch(new RegExp(`indexdb://fp\\?name=my-app&store=meta&version=${rt.INDEXDB_VERSION}`));
+      db.close();
     });
     return;
   }
@@ -55,6 +56,7 @@ describe("fireproof/config", () => {
     );
     expect((await SysContainer.stat(SysContainer.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
     process.env.FP_STORAGE_URL = old;
+    db.close();
   });
 
   it("set by env", async () => {
@@ -88,6 +90,7 @@ describe("fireproof/config", () => {
     );
     expect((await SysContainer.stat(SysContainer.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
     process.env.FP_STORAGE_URL = old;
+    db.close();
   });
 
   it("file path", async () => {
@@ -121,6 +124,7 @@ describe("fireproof/config", () => {
       new RegExp(`file://.\\/dist\\/data\\?name=my-app&store=meta&version=${rt.FILESTORE_VERSION}`),
     );
     expect((await SysContainer.stat(SysContainer.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    db.close();
   });
 
   it("sqlite path", async () => {
@@ -153,6 +157,7 @@ describe("fireproof/config", () => {
     expect(metaStore?.url.toString()).toMatch(
       new RegExp(`sqlite://./dist/sqlite\\?name=my-app&store=meta&version=${rt.SQLITE_VERSION}`),
     );
+    db.close();
   });
 
   it("full config path", async () => {
@@ -182,5 +187,6 @@ describe("fireproof/config", () => {
     expect(fileStore?.url.toString()).toMatch(new RegExp(`sqlite://./dist/sqlite/data\\?store=data&version=${rt.SQLITE_VERSION}`));
     const metaStore = await db.blockstore.loader?.metaStore();
     expect(metaStore?.url.toString()).toMatch(new RegExp(`sqlite://./dist/sqlite/meta\\?store=meta&version=${rt.SQLITE_VERSION}`));
+    db.close();
   });
 });
diff --git a/version-copy-package.ts b/version-copy-package.ts
index 5aa51738..427f9a5b 100644
--- a/version-copy-package.ts
+++ b/version-copy-package.ts
@@ -3,15 +3,24 @@ import process from "process";
 import path from "path";
 
 async function main() {
-  const version = JSON.parse(fs.readFileSync("package.json", "utf8")).version;
+  const mainPackageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
   const files = process.argv.slice(2);
   for (const file of files) {
     const destPath = path.join(path.dirname(file), "package.json");
     fs.copyFileSync(path.basename(file), destPath);
     const destPackageJson = JSON.parse(fs.readFileSync(path.basename(file), "utf8"));
-    destPackageJson.version = version;
+
+    // copy version from package.json
+    for (const destDeps of Object.keys(destPackageJson.dependencies)) {
+      if (!mainPackageJson.dependencies[destDeps]) {
+        console.error(`Dependency ${destDeps} not found in main package.json`);
+      } else {
+        destPackageJson.dependencies[destDeps] = mainPackageJson.dependencies[destDeps];
+      }
+    }
+    destPackageJson.version = mainPackageJson.version;
     fs.writeFileSync(destPath, JSON.stringify(destPackageJson, null, 2));
-    console.log(`Copied ${file} to ${destPath} with version ${version}`);
+    console.log(`Copied ${file} to ${destPath} with version ${destPackageJson.version}`);
   }
 }