@frostpillar/frostpillar-storage-engine 0.0.1

package/dist/drivers/localStorage.cjs

@@ -0,0 +1,668 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/drivers/localStorage.ts
+var localStorage_exports = {};
+__export(localStorage_exports, {
+  localStorageDriver: () => localStorageDriver
+});
+module.exports = __toCommonJS(localStorage_exports);
+
+// src/errors/index.ts
+var FrostpillarError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = new.target.name;
+    if (options !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+var ConfigurationError = class extends FrostpillarError {
+};
+var UnsupportedBackendError = class extends FrostpillarError {
+};
+var StorageEngineError = class extends FrostpillarError {
+};
+var PageCorruptionError = class extends StorageEngineError {
+};
+var QuotaExceededError = class extends FrostpillarError {
+};
+var toErrorInstance = (error, fallbackMessage) => {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(fallbackMessage, { cause: error });
+};
+
+// src/storage/backend/asyncDurableAutoCommitController.ts
+var AsyncDurableAutoCommitController = class {
+  constructor(autoCommit, onAutoCommitError) {
+    this.autoCommit = autoCommit;
+    this.onAutoCommitError = onAutoCommitError;
+    this.pendingAutoCommitBytes = 0;
+    this.dirtyFromClear = false;
+    this.autoCommitTimer = null;
+    this.commitInFlight = null;
+    this.pendingForegroundCommitRequest = false;
+    this.pendingBackgroundCommitRequest = false;
+    this.closed = false;
+    this.startAutoCommitSchedule();
+  }
+  handleRecordAppended(encodedBytes) {
+    if (this.autoCommit.frequency === "immediate") {
+      return this.commitNow();
+    }
+    this.pendingAutoCommitBytes += encodedBytes;
+    if (this.autoCommit.maxPendingBytes !== null && this.pendingAutoCommitBytes >= this.autoCommit.maxPendingBytes) {
+      return this.queueCommitRequest("foreground");
+    }
+    return Promise.resolve();
+  }
+  handleCleared() {
+    this.dirtyFromClear = true;
+    if (this.autoCommit.frequency === "immediate") {
+      return this.commitNow();
+    }
+    return this.queueCommitRequest("background");
+  }
+  commitNow() {
+    return this.queueCommitRequest("foreground");
+  }
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.stopAutoCommitSchedule();
+    await this.waitForCommitSettlement();
+    let flushError = null;
+    if (this.pendingAutoCommitBytes > 0 || this.dirtyFromClear) {
+      try {
+        await this.executeSingleCommit();
+        this.pendingAutoCommitBytes = 0;
+        this.dirtyFromClear = false;
+      } catch (error) {
+        flushError = toErrorInstance(
+          error,
+          "Final close-time flush commit failed with a non-Error value."
+        );
+      }
+    }
+    let drainError = null;
+    try {
+      await this.onCloseAfterDrain();
+    } catch (error) {
+      drainError = toErrorInstance(
+        error,
+        "onCloseAfterDrain failed with a non-Error value."
+      );
+    }
+    if (flushError !== null && drainError !== null) {
+      throw createCloseAggregateError(flushError, drainError);
+    }
+    if (flushError !== null) {
+      throw flushError;
+    }
+    if (drainError !== null) {
+      throw drainError;
+    }
+  }
+  getPendingAutoCommitBytes() {
+    return this.pendingAutoCommitBytes;
+  }
+  onCloseAfterDrain() {
+    return Promise.resolve();
+  }
+  waitForCommitSettlement() {
+    if (this.commitInFlight === null) {
+      return Promise.resolve();
+    }
+    return this.commitInFlight.then(() => void 0).catch(() => void 0);
+  }
+  queueCommitRequest(requestType) {
+    if (requestType === "foreground") {
+      this.pendingForegroundCommitRequest = true;
+    } else {
+      this.pendingBackgroundCommitRequest = true;
+    }
+    if (this.commitInFlight === null) {
+      this.commitInFlight = this.runCommitLoop().finally(() => {
+        this.commitInFlight = null;
+      });
+    }
+    if (requestType === "background") {
+      return Promise.resolve();
+    }
+    return this.commitInFlight;
+  }
+  async runCommitLoop() {
+    let shouldContinue = true;
+    while (shouldContinue) {
+      const runForeground = this.pendingForegroundCommitRequest;
+      const runBackground = this.pendingBackgroundCommitRequest;
+      const runClear = this.dirtyFromClear;
+      this.pendingForegroundCommitRequest = false;
+      this.pendingBackgroundCommitRequest = false;
+      this.dirtyFromClear = false;
+      const shouldRunCommit = runForeground || runBackground && (this.pendingAutoCommitBytes > 0 || runClear);
+      if (!shouldRunCommit) {
+        shouldContinue = false;
+        continue;
+      }
+      try {
+        const committedPendingBytes = this.pendingAutoCommitBytes;
+        await this.executeSingleCommit();
+        this.pendingAutoCommitBytes = Math.max(
+          0,
+          this.pendingAutoCommitBytes - committedPendingBytes
+        );
+      } catch (error) {
+        if (runClear) {
+          this.dirtyFromClear = true;
+        }
+        if (runForeground) {
+          throw toErrorInstance(
+            error,
+            "Foreground auto-commit failed with a non-Error value."
+          );
+        }
+        this.onAutoCommitError(error);
+      }
+      if (!this.pendingForegroundCommitRequest && !this.pendingBackgroundCommitRequest) {
+        shouldContinue = false;
+      }
+    }
+  }
+  startAutoCommitSchedule() {
+    if (this.autoCommit.frequency !== "scheduled" || this.autoCommit.intervalMs === null) {
+      return;
+    }
+    this.autoCommitTimer = setInterval(() => {
+      this.handleAutoCommitTick();
+    }, this.autoCommit.intervalMs);
+    if (typeof this.autoCommitTimer === "object" && this.autoCommitTimer !== null && "unref" in this.autoCommitTimer) {
+      this.autoCommitTimer.unref();
+    }
+  }
+  stopAutoCommitSchedule() {
+    if (this.autoCommitTimer === null) {
+      return;
+    }
+    clearInterval(this.autoCommitTimer);
+    this.autoCommitTimer = null;
+  }
+  handleAutoCommitTick() {
+    if (this.closed) {
+      return;
+    }
+    if (this.pendingAutoCommitBytes <= 0 && !this.dirtyFromClear) {
+      return;
+    }
+    void this.queueCommitRequest("background");
+  }
+};
+var readAggregateErrorConstructor = () => {
+  const candidate = globalThis.AggregateError;
+  if (typeof candidate !== "function") {
+    return null;
+  }
+  return candidate;
+};
+var createCloseAggregateError = (flushError, drainError) => {
+  const aggregateErrorConstructor = readAggregateErrorConstructor();
+  if (aggregateErrorConstructor !== null) {
+    return new aggregateErrorConstructor(
+      [flushError, drainError],
+      "Close failed: both final flush and drain produced errors."
+    );
+  }
+  const fallbackError = new Error(
+    "Close failed: both final flush and drain produced errors."
+  );
+  fallbackError.errors = [flushError, drainError];
+  return fallbackError;
+};
+
+// src/storage/config/config.shared.ts
+var BYTE_SIZE_MULTIPLIER = {
+  B: 1,
+  KB: 1024,
+  MB: 1024 * 1024,
+  GB: 1024 * 1024 * 1024
+};
+var FREQUENCY_REGEX = /^(\d+)(ms|s|m|h)$/;
+var FREQUENCY_MULTIPLIER = {
+  ms: 1,
+  s: 1e3,
+  m: 60 * 1e3,
+  h: 60 * 60 * 1e3
+};
+var parseFrequencyString = (frequency) => {
+  const matched = FREQUENCY_REGEX.exec(frequency);
+  if (matched === null) {
+    throw new ConfigurationError(
+      "autoCommit.frequency string must be one of: <positive>ms, <positive>s, <positive>m, <positive>h."
+    );
+  }
+  const amount = Number(matched[1]);
+  if (!Number.isSafeInteger(amount) || amount <= 0) {
+    throw new ConfigurationError(
+      "autoCommit.frequency string amount must be a positive safe integer."
+    );
+  }
+  const unit = matched[2];
+  const multiplier = FREQUENCY_MULTIPLIER[unit];
+  const intervalMs = amount * multiplier;
+  if (!Number.isSafeInteger(intervalMs) || intervalMs <= 0) {
+    throw new ConfigurationError(
+      "autoCommit.frequency exceeds safe integer range."
+    );
+  }
+  return intervalMs;
+};
+var parseAutoCommitConfig = (autoCommit) => {
+  if (autoCommit?.maxPendingBytes !== void 0) {
+    if (!Number.isSafeInteger(autoCommit.maxPendingBytes) || autoCommit.maxPendingBytes <= 0) {
+      throw new ConfigurationError(
+        "autoCommit.maxPendingBytes must be a positive safe integer."
+      );
+    }
+  }
+  const maxPendingBytes = autoCommit?.maxPendingBytes ?? null;
+  const frequency = autoCommit?.frequency;
+  if (frequency === void 0 || frequency === "immediate") {
+    return { frequency: "immediate", intervalMs: null, maxPendingBytes };
+  }
+  if (typeof frequency === "number") {
+    if (!Number.isSafeInteger(frequency) || frequency <= 0) {
+      throw new ConfigurationError(
+        "autoCommit.frequency number must be a positive safe integer."
+      );
+    }
+    return { frequency: "scheduled", intervalMs: frequency, maxPendingBytes };
+  }
+  const intervalMs = parseFrequencyString(frequency);
+  return { frequency: "scheduled", intervalMs, maxPendingBytes };
+};
+
+// src/storage/drivers/localStorage/localStorageConfig.ts
+var DEFAULT_LOCAL_STORAGE_MAX_CHUNK_CHARS = 32768;
+var DEFAULT_LOCAL_STORAGE_MAX_CHUNKS = 64;
+var parseLocalStorageConfig = (config) => {
+  const keyPrefix = config?.keyPrefix ?? "frostpillar";
+  const databaseKey = config?.databaseKey ?? "default";
+  const maxChunkChars = config?.maxChunkChars ?? DEFAULT_LOCAL_STORAGE_MAX_CHUNK_CHARS;
+  const maxChunks = config?.maxChunks ?? DEFAULT_LOCAL_STORAGE_MAX_CHUNKS;
+  if (!Number.isSafeInteger(maxChunkChars) || maxChunkChars <= 0) {
+    throw new ConfigurationError(
+      "localStorage.maxChunkChars must be a positive safe integer."
+    );
+  }
+  if (!Number.isSafeInteger(maxChunks) || maxChunks <= 0) {
+    throw new ConfigurationError(
+      "localStorage.maxChunks must be a positive safe integer."
+    );
+  }
+  return { keyPrefix, databaseKey, maxChunkChars, maxChunks };
+};
+
+// src/validation/metadata.ts
+var parseNonNegativeSafeInteger = (value, fieldName, backendName) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new StorageEngineError(
+      `${backendName} ${fieldName} must be a non-negative safe integer.`
+    );
+  }
+  return value;
+};
+
+// src/storage/drivers/localStorage/localStorageLayout.ts
+var manifestKey = (keyPrefix, databaseKey) => `${keyPrefix}:ls:${databaseKey}:manifest`;
+var chunkKey = (keyPrefix, databaseKey, generation, index) => `${keyPrefix}:ls:${databaseKey}:g:${generation}:chunk:${index}`;
+var cleanupGenerationChunks = (state, generation, knownChunkCount) => {
+  if (knownChunkCount !== null) {
+    if (knownChunkCount <= 0) {
+      return;
+    }
+    for (let i = 0; i < knownChunkCount; i += 1) {
+      state.adapter.removeItem(
+        chunkKey(state.keyPrefix, state.databaseKey, generation, i)
+      );
+    }
+    return;
+  }
+  if (state.maxChunks <= 0) {
+    return;
+  }
+  for (let i = 0; i < state.maxChunks; i += 1) {
+    const key = chunkKey(state.keyPrefix, state.databaseKey, generation, i);
+    if (state.adapter.getItem(key) !== null) {
+      state.adapter.removeItem(key);
+    }
+  }
+};
+var isQuotaBrowserError = (error) => {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.name === "QuotaExceededError" || error.name === "NS_ERROR_DOM_QUOTA_REACHED";
+};
+
+// src/storage/backend/encoding.ts
+var computeUtf8ByteLengthJs = (value) => {
+  let bytes = 0;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code <= 127) {
+      bytes += 1;
+    } else if (code <= 2047) {
+      bytes += 2;
+    } else if (code >= 55296 && code <= 56319) {
+      const next = i + 1 < value.length ? value.charCodeAt(i + 1) : 0;
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i++;
+      } else {
+        bytes += 3;
+      }
+    } else if (code >= 56320 && code <= 57343) {
+      bytes += 3;
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+};
+var hasBuffer = typeof Buffer !== "undefined" && typeof Buffer.byteLength === "function";
+var computeUtf8ByteLength = hasBuffer ? (value) => Buffer.byteLength(value, "utf8") : computeUtf8ByteLengthJs;
+
+// src/storage/drivers/localStorage/localStorageBackend.ts
+var LS_MAGIC = "FPLS_META";
+var LS_VERSION = 2;
+var detectGlobalLocalStorage = () => {
+  try {
+    const g = globalThis;
+    const ls = g.localStorage;
+    if (ls === null || ls === void 0) {
+      return null;
+    }
+    return ls;
+  } catch {
+    return null;
+  }
+};
+var createLocalStorageBackendState = (adapter, keyPrefix, databaseKey, maxChunkChars, maxChunks) => ({
+  adapter,
+  keyPrefix,
+  databaseKey,
+  maxChunkChars,
+  maxChunks,
+  activeGeneration: 0,
+  commitId: 0,
+  activeChunkCount: 0
+});
+var parseLocalStorageManifest = (manifestRaw, maxChunks) => {
+  let manifest;
+  try {
+    manifest = JSON.parse(manifestRaw);
+  } catch {
+    throw new StorageEngineError("localStorage manifest JSON is malformed.");
+  }
+  if (manifest.magic !== LS_MAGIC || manifest.version !== LS_VERSION) {
+    throw new StorageEngineError(
+      "localStorage manifest magic/version mismatch."
+    );
+  }
+  const chunkCount = parseNonNegativeSafeInteger(
+    manifest.chunkCount,
+    "manifest.chunkCount",
+    "localStorage"
+  );
+  if (chunkCount > maxChunks) {
+    throw new StorageEngineError(
+      `localStorage snapshot requires ${chunkCount} chunks but maxChunks is ${maxChunks}.`
+    );
+  }
+  return manifest;
+};
+var loadLocalStorageChunks = (state, activeGeneration, chunkCount) => {
+  const chunks = [];
+  for (let i = 0; i < chunkCount; i += 1) {
+    const cKey = chunkKey(
+      state.keyPrefix,
+      state.databaseKey,
+      activeGeneration,
+      i
+    );
+    const chunkValue = state.adapter.getItem(cKey);
+    if (typeof chunkValue !== "string") {
+      throw new StorageEngineError(
+        `localStorage chunk "${cKey}" is missing or not a string.`
+      );
+    }
+    chunks.push(chunkValue);
+  }
+  const treeJson = chunks.join("");
+  let parsedTreeJSON;
+  try {
+    parsedTreeJSON = JSON.parse(treeJson);
+  } catch {
+    throw new StorageEngineError("localStorage chunk data JSON is malformed.");
+  }
+  if (typeof parsedTreeJSON !== "object" || parsedTreeJSON === null || Array.isArray(parsedTreeJSON)) {
+    throw new PageCorruptionError("treeJSON must be a non-null plain object.");
+  }
+  return {
+    treeJSON: parsedTreeJSON,
+    rawJsonLength: computeUtf8ByteLength(treeJson)
+  };
+};
+var loadLocalStorageSnapshot = (state) => {
+  const mKey = manifestKey(state.keyPrefix, state.databaseKey);
+  const manifestRaw = state.adapter.getItem(mKey);
+  if (manifestRaw === null) {
+    return { treeJSON: null, currentSizeBytes: 0 };
+  }
+  const manifest = parseLocalStorageManifest(manifestRaw, state.maxChunks);
+  const activeGeneration = parseNonNegativeSafeInteger(
+    manifest.activeGeneration,
+    "manifest.activeGeneration",
+    "localStorage"
+  );
+  const commitId = parseNonNegativeSafeInteger(
+    manifest.commitId,
+    "manifest.commitId",
+    "localStorage"
+  );
+  const chunkCount = parseNonNegativeSafeInteger(
+    manifest.chunkCount,
+    "manifest.chunkCount",
+    "localStorage"
+  );
+  const { treeJSON, rawJsonLength } = loadLocalStorageChunks(state, activeGeneration, chunkCount);
+  const currentSizeBytes = rawJsonLength;
+  state.activeGeneration = activeGeneration;
+  state.commitId = commitId;
+  state.activeChunkCount = chunkCount;
+  return { treeJSON, currentSizeBytes };
+};
+var splitTreeJSONIntoChunks = (treeJSON, maxChunkChars, maxChunks, driverName) => {
+  const dataJson = JSON.stringify(treeJSON);
+  const chunks = [];
+  for (let i = 0; i < dataJson.length; i += maxChunkChars) {
+    chunks.push(dataJson.slice(i, i + maxChunkChars));
+  }
+  if (chunks.length > maxChunks) {
+    throw new QuotaExceededError(
+      `${driverName} snapshot requires ${chunks.length} chunks but maxChunks is ${maxChunks}.`
+    );
+  }
+  return chunks;
+};
+var ensureCommitCountersSafe = (state) => {
+  if (state.commitId >= Number.MAX_SAFE_INTEGER) {
+    throw new StorageEngineError(
+      "localStorage commitId has reached Number.MAX_SAFE_INTEGER."
+    );
+  }
+  if (state.activeGeneration >= Number.MAX_SAFE_INTEGER) {
+    throw new StorageEngineError(
+      "localStorage activeGeneration has reached Number.MAX_SAFE_INTEGER."
+    );
+  }
+};
+var prepareLocalStorageCommit = (state, treeJSON) => {
+  const nextCommitId = state.commitId + 1;
+  const nextGeneration = state.activeGeneration + 1;
+  const chunks = splitTreeJSONIntoChunks(
+    treeJSON,
+    state.maxChunkChars,
+    state.maxChunks,
+    "localStorage"
+  );
+  const newManifest = {
+    magic: LS_MAGIC,
+    version: LS_VERSION,
+    activeGeneration: nextGeneration,
+    commitId: nextCommitId,
+    chunkCount: chunks.length
+  };
+  return {
+    nextCommitId,
+    nextGeneration,
+    chunks,
+    manifestJson: JSON.stringify(newManifest)
+  };
+};
+var writeLocalStorageCommit = (state, preparedCommit) => {
+  try {
+    cleanupGenerationChunks(state, preparedCommit.nextGeneration, null);
+    for (let i = 0; i < preparedCommit.chunks.length; i += 1) {
+      state.adapter.setItem(
+        chunkKey(
+          state.keyPrefix,
+          state.databaseKey,
+          preparedCommit.nextGeneration,
+          i
+        ),
+        preparedCommit.chunks[i]
+      );
+    }
+    state.adapter.setItem(
+      manifestKey(state.keyPrefix, state.databaseKey),
+      preparedCommit.manifestJson
+    );
+  } catch (error) {
+    if (isQuotaBrowserError(error) || error instanceof QuotaExceededError) {
+      throw new QuotaExceededError(
+        "localStorage quota exceeded during commit."
+      );
+    }
+    throw new StorageEngineError("localStorage write failed during commit.");
+  }
+};
+var commitLocalStorageSnapshot = (state, treeJSON) => {
+  ensureCommitCountersSafe(state);
+  const preparedCommit = prepareLocalStorageCommit(state, treeJSON);
+  writeLocalStorageCommit(state, preparedCommit);
+  const previousGeneration = state.activeGeneration;
+  const previousChunkCount = state.activeChunkCount;
+  state.activeGeneration = preparedCommit.nextGeneration;
+  state.commitId = preparedCommit.nextCommitId;
+  state.activeChunkCount = preparedCommit.chunks.length;
+  cleanupGenerationChunks(
+    state,
+    previousGeneration,
+    previousChunkCount
+  );
+};
+
+// src/storage/drivers/localStorage/localStorageBackendController.ts
+var LocalStorageBackendController = class _LocalStorageBackendController extends AsyncDurableAutoCommitController {
+  constructor(backend, autoCommit, getSnapshot, onAutoCommitError) {
+    super(autoCommit, onAutoCommitError);
+    this.backend = backend;
+    this.getSnapshot = getSnapshot;
+  }
+  static create(options) {
+    const adapter = detectGlobalLocalStorage();
+    if (adapter === null) {
+      throw new UnsupportedBackendError(
+        "localStorage is not available in the current runtime environment."
+      );
+    }
+    const lsConfig = parseLocalStorageConfig(options.config);
+    const autoCommit = parseAutoCommitConfig(options.autoCommit);
+    const backend = createLocalStorageBackendState(
+      adapter,
+      lsConfig.keyPrefix,
+      lsConfig.databaseKey,
+      lsConfig.maxChunkChars,
+      lsConfig.maxChunks
+    );
+    const loaded = loadLocalStorageSnapshot(backend);
+    const controller = new _LocalStorageBackendController(
+      backend,
+      autoCommit,
+      options.getSnapshot,
+      options.onAutoCommitError
+    );
+    return {
+      controller,
+      initialTreeJSON: loaded.treeJSON,
+      initialCurrentSizeBytes: loaded.currentSizeBytes
+    };
+  }
+  executeSingleCommit() {
+    const snapshot = this.getSnapshot();
+    commitLocalStorageSnapshot(
+      this.backend,
+      snapshot.treeJSON
+    );
+    return Promise.resolve();
+  }
+};
+
+// src/drivers/localStorage.ts
+var localStorageDriver = (options = {}) => {
+  return {
+    init: (callbacks) => {
+      const result = LocalStorageBackendController.create({
+        config: options,
+        autoCommit: callbacks.autoCommit,
+        getSnapshot: callbacks.getSnapshot,
+        onAutoCommitError: callbacks.onAutoCommitError
+      });
+      return {
+        controller: result.controller,
+        initialTreeJSON: result.initialTreeJSON,
+        initialCurrentSizeBytes: result.initialCurrentSizeBytes
+      };
+    },
+    resolveBackendLimitBytes: () => {
+      const { maxChunkChars, maxChunks } = parseLocalStorageConfig(options);
+      return maxChunkChars * maxChunks;
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  localStorageDriver
+});

package/dist/drivers/localStorage.d.ts

@@ -0,0 +1,3 @@
+import type { DatastoreDriver, LocalStorageConfig } from '../types.js';
+export type LocalStorageDriverOptions = LocalStorageConfig;
+export declare const localStorageDriver: (options?: LocalStorageDriverOptions) => DatastoreDriver;

package/dist/drivers/localStorage.js

@@ -0,0 +1,23 @@
+import { LocalStorageBackendController, } from '../storage/drivers/localStorage/localStorageBackendController.js';
+import { parseLocalStorageConfig, } from '../storage/drivers/localStorage/localStorageConfig.js';
+export const localStorageDriver = (options = {}) => {
+    return {
+        init: (callbacks) => {
+            const result = LocalStorageBackendController.create({
+                config: options,
+                autoCommit: callbacks.autoCommit,
+                getSnapshot: callbacks.getSnapshot,
+                onAutoCommitError: callbacks.onAutoCommitError,
+            });
+            return {
+                controller: result.controller,
+                initialTreeJSON: result.initialTreeJSON,
+                initialCurrentSizeBytes: result.initialCurrentSizeBytes,
+            };
+        },
+        resolveBackendLimitBytes: () => {
+            const { maxChunkChars, maxChunks } = parseLocalStorageConfig(options);
+            return maxChunkChars * maxChunks;
+        },
+    };
+};