@xnetjs/sqlite 0.0.2 → 0.0.3

package/dist/browser-support.d.ts

@@ -16,6 +16,30 @@ interface BrowserSupport {
     /** Warning message for soft failures (app can still work with fallback) */
     warning?: string;
 }
+interface PersistentStorageStatus {
+    /** Browser exposes persistence APIs. */
+    supported: boolean;
+    /** Whether the site is currently persisted. */
+    persisted: boolean | null;
+    /** Whether the explicit persistence request was granted. */
+    granted: boolean | null;
+    /** Whether this status was produced by an explicit persistence request. */
+    requested: boolean;
+    /** Whether the app can present a user action to request persistence. */
+    requestable: boolean;
+    /** Durable-storage state for UI and diagnostics. */
+    state: 'granted' | 'not-granted' | 'unsupported' | 'error';
+    /** User-facing explanation of the result. */
+    message: string;
+    /** Optional usage estimate in bytes. */
+    usageBytes?: number;
+    /** Optional quota estimate in bytes. */
+    quotaBytes?: number;
+}
+interface PersistentStorageRequestOptions {
+    /** Request persistent mode instead of only checking current state. */
+    request?: boolean;
+}
 /**
  * Check if the current browser supports SQLite-WASM with OPFS.
  *
@@ -46,6 +70,37 @@ interface BrowserSupport {
  * ```
  */
 declare function checkBrowserSupport(): Promise<BrowserSupport>;
+/**
+ * Check whether persistent storage is already enabled without prompting or
+ * spending a browser heuristic-based permission request during startup.
+ */
+declare function checkPersistentStorage(): Promise<PersistentStorageStatus>;
+/**
+ * Whether `navigator.storage.persist()` can be called without showing the
+ * user a permission prompt.
+ *
+ * Chromium and WebKit decide the request silently from heuristics (install,
+ * notification permission, engagement) and re-evaluate it fresh on every
+ * call, so requesting at startup is free. Gecko (desktop Firefox) shows a
+ * modal doorhanger, so requests there must stay behind a user gesture.
+ * Firefox on iOS (FxiOS) runs WebKit, but we treat anything Firefox-branded
+ * as prompt-capable — the worst case is skipping a free request.
+ */
+declare function isSilentPersistRequestSafe(): boolean;
+/**
+ * Watch the `persistent-storage` permission for changes (e.g. a grant that
+ * lands mid-session after the user enables notifications or installs the
+ * app). Querying is free — it never spends or triggers a request.
+ *
+ * Calls `onChange` with the new state whenever the browser reports a
+ * change. No-op on browsers without the Permissions API or the
+ * `persistent-storage` permission name. Returns an unsubscribe function.
+ */
+declare function watchPersistentStoragePermission(onChange: (state: PermissionState) => void): () => void;
+/**
+ * Request persistent storage where supported and summarize the result.
+ */
+declare function requestPersistentStorage(options?: PersistentStorageRequestOptions): Promise<PersistentStorageStatus>;
 /**
  * Show an unsupported browser message to the user.
  *
@@ -64,4 +119,4 @@ declare function checkBrowserSupport(): Promise<BrowserSupport>;
  */
 declare function showUnsupportedBrowserMessage(reason: string): void;
 
-export { type BrowserSupport, checkBrowserSupport, showUnsupportedBrowserMessage };
+export { type BrowserSupport, type PersistentStorageRequestOptions, type PersistentStorageStatus, checkBrowserSupport, checkPersistentStorage, isSilentPersistRequestSafe, requestPersistentStorage, showUnsupportedBrowserMessage, watchPersistentStoragePermission };

package/dist/browser-support.js

@@ -1,8 +1,16 @@
 import {
   checkBrowserSupport,
-  showUnsupportedBrowserMessage
-} from "./chunk-ZRR5D2OD.js";
+  checkPersistentStorage,
+  isSilentPersistRequestSafe,
+  requestPersistentStorage,
+  showUnsupportedBrowserMessage,
+  watchPersistentStoragePermission
+} from "./chunk-2OK46ZBU.js";
 export {
   checkBrowserSupport,
-  showUnsupportedBrowserMessage
+  checkPersistentStorage,
+  isSilentPersistRequestSafe,
+  requestPersistentStorage,
+  showUnsupportedBrowserMessage,
+  watchPersistentStoragePermission
 };

package/dist/{chunk-ZRR5D2OD.js → chunk-2OK46ZBU.js}

@@ -55,6 +55,120 @@ async function checkBrowserSupport() {
   }
   return result;
 }
+async function readStorageEstimate() {
+  const estimate = await navigator.storage.estimate?.().catch(() => void 0);
+  return {
+    usageBytes: estimate?.usage,
+    quotaBytes: estimate?.quota
+  };
+}
+function getPersistenceMessage(input) {
+  const { persisted, requested, granted } = input;
+  if (persisted) {
+    return "Durable local storage is enabled. This browser agreed to keep your xNet workspace unless you explicitly clear site data.";
+  }
+  if (!requested) {
+    return "Durable storage is not enabled yet. xNet can request stronger local-storage protection when you choose to enable it.";
+  }
+  if (granted === false) {
+    return "This browser declined durable storage for now. xNet keeps working, and browsers re-evaluate the request as install, notification, and usage signals change.";
+  }
+  return "This browser did not confirm durable storage. xNet will keep working, but local data may be evicted under storage pressure or aggressive cleanup.";
+}
+async function checkPersistentStorage() {
+  return requestPersistentStorage({ request: false });
+}
+function isSilentPersistRequestSafe() {
+  if (typeof navigator === "undefined") return false;
+  return !/Firefox|FxiOS/i.test(navigator.userAgent);
+}
+function watchPersistentStoragePermission(onChange) {
+  let active = true;
+  let detach = null;
+  void (async () => {
+    try {
+      const status = await navigator.permissions.query({
+        name: "persistent-storage"
+      });
+      if (!active) return;
+      const listener = () => onChange(status.state);
+      status.addEventListener("change", listener);
+      detach = () => status.removeEventListener("change", listener);
+    } catch {
+    }
+  })();
+  return () => {
+    active = false;
+    detach?.();
+    detach = null;
+  };
+}
+async function requestPersistentStorage(options = { request: true }) {
+  const requested = options.request ?? true;
+  if (typeof navigator === "undefined" || !navigator.storage) {
+    return {
+      supported: false,
+      persisted: null,
+      granted: null,
+      requested,
+      requestable: false,
+      state: "unsupported",
+      message: "This browser does not expose storage persistence APIs. Local data can still work, but the browser may evict it under storage pressure."
+    };
+  }
+  const estimate = await readStorageEstimate();
+  if (!navigator.storage.persist || !navigator.storage.persisted) {
+    return {
+      supported: false,
+      persisted: null,
+      granted: null,
+      requested,
+      requestable: false,
+      state: "unsupported",
+      message: "This browser cannot explicitly request durable storage. Local data can still work, but the browser may evict it under storage pressure.",
+      ...estimate
+    };
+  }
+  try {
+    const alreadyPersisted = await navigator.storage.persisted();
+    const granted = alreadyPersisted ? true : requested ? await navigator.storage.persist() : null;
+    const persisted = granted ? true : await navigator.storage.persisted();
+    if (persisted) {
+      return {
+        supported: true,
+        persisted,
+        granted,
+        requested,
+        requestable: false,
+        state: "granted",
+        message: getPersistenceMessage({ persisted, requested, granted }),
+        ...estimate
+      };
+    }
+    return {
+      supported: true,
+      persisted,
+      granted,
+      requested,
+      requestable: true,
+      state: "not-granted",
+      message: getPersistenceMessage({ persisted, requested, granted }),
+      ...estimate
+    };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return {
+      supported: true,
+      persisted: null,
+      granted: null,
+      requested,
+      requestable: true,
+      state: "error",
+      message: `xNet could not confirm durable storage (${reason}). Local data may still work, but persistence guarantees are unclear.`,
+      ...estimate
+    };
+  }
+}
 function showUnsupportedBrowserMessage(reason) {
   const container = document.getElementById("app") ?? document.body;
   container.innerHTML = `
@@ -136,5 +250,9 @@ function escapeHtml(text) {
 
 export {
   checkBrowserSupport,
+  checkPersistentStorage,
+  isSilentPersistRequestSafe,
+  watchPersistentStoragePermission,
+  requestPersistentStorage,
   showUnsupportedBrowserMessage
 };

package/dist/chunk-CBU263LI.js

@@ -0,0 +1,30 @@
+// src/errors.ts
+var SQLITE_CORRUPT_RESULT_CODE = 11;
+var SQLITE_NOTADB_RESULT_CODE = 26;
+function toErrorLike(error) {
+  if (!error || typeof error !== "object") {
+    return null;
+  }
+  return error;
+}
+function isSQLiteCorruptionError(error) {
+  return isSQLiteCorruptionErrorInternal(error, /* @__PURE__ */ new Set());
+}
+function isSQLiteCorruptionErrorInternal(error, seen) {
+  const current = toErrorLike(error);
+  if (!current) {
+    return false;
+  }
+  if (seen.has(error)) {
+    return false;
+  }
+  seen.add(error);
+  const message = typeof current.message === "string" ? current.message.toLowerCase() : String(current.message);
+  const code = typeof current.code === "string" ? current.code.toUpperCase() : "";
+  const resultCode = typeof current.resultCode === "number" ? current.resultCode : null;
+  return resultCode === SQLITE_CORRUPT_RESULT_CODE || resultCode === SQLITE_NOTADB_RESULT_CODE || code === "SQLITE_CORRUPT" || code === "SQLITE_NOTADB" || message.includes("sqlite_corrupt") || message.includes("sqlite_notadb") || message.includes("database disk image is malformed") || message.includes("file is not a database") || isSQLiteCorruptionErrorInternal(current.cause, seen);
+}
+
+export {
+  isSQLiteCorruptionError
+};