@adukiorg/anza 0.2.0

package/src/core/offline/clock.js

@@ -0,0 +1,100 @@
+/**
+ * src/core/offline/clock.js
+ *
+ * Logical Lamport Clock Engine.
+ * Manages persistent client actor UUIDs and monotonic logical counters
+ * for conflict-free write replication.
+ *
+ * Source: doc 13 — Offline and Background §4
+ */
+
+import { storage } from '../storage/index.js';
+import { uuid } from '../security/index.js';
+
+let currentClock = 0;
+let currentActor = '';
+let initialized = false;
+let initPromise = null;
+
+/**
+ * Initializes the logical clock engine.
+ */
+export async function init() {
+  if (initialized) return;
+  if (initPromise) return initPromise;
+
+  initPromise = (async () => {
+    try {
+      let actorVal = await storage.get('offline:actor', 'idb');
+      if (!actorVal) {
+        actorVal = uuid();
+        await storage.set('offline:actor', actorVal, 'idb');
+      }
+      currentActor = actorVal;
+
+      const clockVal = await storage.get('offline:clock', 'idb');
+      if (typeof clockVal === 'number') {
+        currentClock = clockVal;
+      } else {
+        currentClock = 0;
+        await storage.set('offline:clock', 0, 'idb');
+      }
+      initialized = true;
+    } catch (err) {
+      console.error('Failed to initialize logical clock:', err);
+      if (!currentActor) currentActor = uuid();
+    } finally {
+      initPromise = null;
+    }
+  })();
+
+  return initPromise;
+}
+
+// Auto-boot init
+if (typeof window !== 'undefined') {
+  Promise.resolve().then(() => init().catch(console.error));
+}
+
+/**
+ * Returns the persistent actor UUID for this client.
+ */
+export async function actor() {
+  await init();
+  return currentActor;
+}
+
+/**
+ * Increments and returns the logical clock count.
+ */
+export async function tick() {
+  await init();
+  currentClock++;
+  storage.set('offline:clock', currentClock, 'idb').catch((err) => {
+    console.warn('Failed to persist logical clock:', err);
+  });
+  return currentClock;
+}
+
+/**
+ * Synchronizes the local clock against a remote clock.
+ */
+export async function sync(remoteTime) {
+  await init();
+  if (remoteTime > currentClock) {
+    currentClock = remoteTime + 1;
+    storage.set('offline:clock', currentClock, 'idb').catch((err) => {
+      console.warn('Failed to persist synchronized logical clock:', err);
+    });
+  }
+  return currentClock;
+}
+
+/**
+ * Generates a logical clock stamp.
+ */
+export async function stamp() {
+  const act = await actor();
+  const clk = await tick();
+  return { actor: act, clock: clk };
+}

package/src/core/offline/connectivity.js

@@ -0,0 +1,116 @@
+/**
+ * src/core/offline/connectivity.js
+ *
+ * Resilient Connectivity Monitor.
+ * Extends the unreliable navigator.onLine by performing debounced, rate-limited
+ * HTTP HEAD probes to verify genuine external internet access.
+ *
+ * Source: doc 13 — Offline and Background §4
+ */
+
+import { state } from './state.js';
+import { bus } from '../events/bus.js';
+import { names } from '../events/types/index.js';
+
+let lastCheck = 0;
+let isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
+let inFlightProbe = null;
+
+const listeners = new Set();
+
+/**
+ * Triggers a network connectivity check. Shares in-flight requests and throttles checks
+ * to no more than once per 10 seconds.
+ */
+export async function check(force = false) {
+  if (typeof window === 'undefined') return true;
+
+  const now = Date.now();
+  // Return cached state if requested within the 10-second limit and not forced
+  if (!force && now - lastCheck < 10000) {
+    return isOnline;
+  }
+
+  if (inFlightProbe) return inFlightProbe;
+
+  inFlightProbe = (async () => {
+    lastCheck = now;
+    try {
+      // Dispatch HEAD request with cache-busting parameter to verify external access
+      await fetch('/favicon.ico?_probe=' + now, {
+        method: 'HEAD',
+        cache: 'no-store',
+        mode: 'no-cors' // Prevents CORS blockages
+      });
+      isOnline = true;
+    } catch (err) {
+      // Network failures or offline state trigger failure
+      isOnline = false;
+    } finally {
+      inFlightProbe = null;
+      // Sync reactive state
+      state.set('online', isOnline);
+      state.set('status', isOnline ? 'online' : 'offline');
+
+      // Emit standardized connectivity event on the global bus
+      bus.emit(isOnline ? names.connectivity.online : names.connectivity.offline, { online: isOnline });
+
+      // Broadcast state to all active subscribers
+      for (const listener of listeners) {
+        try {
+          listener(isOnline);
+        } catch (err) {
+          console.error('Error in connectivity listener:', err);
+        }
+      }
+    }
+    return isOnline;
+  })();
+
+  return inFlightProbe;
+}
+
+/**
+ * Subscribes to connectivity changes.
+ */
+export function subscribe(fn, signal) {
+  if (signal?.aborted) return () => {};
+
+  listeners.add(fn);
+
+  // Eagerly feed current status to the subscriber
+  fn(isOnline);
+
+  const dispose = () => {
+    listeners.delete(fn);
+    if (signal) {
+      signal.removeEventListener('abort', dispose);
+    }
+  };
+
+  if (signal) {
+    signal.addEventListener('abort', dispose, { once: true });
+  }
+
+  return dispose;
+}
+
+// Bind native browser listeners to trigger immediate HEAD probe checks
+if (typeof window !== 'undefined') {
+  window.addEventListener('online', () => check(true));
+  window.addEventListener('offline', () => {
+    isOnline = false;
+    state.set('online', false);
+    state.set('status', 'offline');
+    bus.emit(names.connectivity.offline, { online: false });
+    for (const listener of listeners) {
+      try {
+        listener(false);
+      } catch (err) {
+        console.error('Error in connectivity offline listener:', err);
+      }
+    }
+  });
+}
+export { isOnline };
+

package/src/core/offline/index.js

@@ -0,0 +1,41 @@
+/**
+ * src/core/offline/index.js
+ *
+ * Public offline base entry point.
+ * Combines Service Worker messaging, IndexedDB task queuing, Background Sync execution,
+ * and reliable HEAD-probe connectivity monitors.
+ *
+ * Source: doc 13 — Offline and Background §1, §3
+ */
+
+import { check, subscribe } from './connectivity.js';
+import { queue } from './queue.js';
+import { sync } from './sync.js';
+import { bridge } from './bridge.js';
+import { state } from './state.js';
+import { actor, tick, sync as clockSync, stamp } from './clock.js';
+
+export const clock = {
+  actor,
+  tick,
+  sync: clockSync,
+  stamp
+};
+
+export const offline = {
+  check,
+  subscribe,
+  queue,
+  sync,
+  state,
+  clock,
+  /**
+   * Shorthand to send messages directly to the active Service Worker bridge.
+   */
+  send(task, payload) {
+    return bridge.send(task, payload);
+  }
+};
+
+export { check, subscribe, queue, sync, bridge, state };
+

package/src/core/offline/missing.md

@@ -0,0 +1,89 @@
+# Offline Missing Support
+
+This document tracks remaining support, runtime gaps, concurrency constraints, serialization enhancements, and state/storage synchronization work for `src/core/offline`. Implemented behavior belongs in `usage.md` (or core documentation); unsupported, under-tested, or performance-gated behavior belongs here until it is built and verified.
+
+---
+
+## 0. Toolchain and Naming Rules
+
+Heavy compilation, static analysis, and code generation belong in `tools/`, not in browser runtime modules.
+
+Current toolchain offline support requirements:
+
+- Statically parse and validate serialized HTTP request bodies.
+- Enforce idempotency key annotations on form submissions at build time.
+
+Naming rules for offline support:
+
+- Prefer one-word files: `connectivity.js`, `queue.js`, `sync.js`, `bridge.js`, `clock.js`, `state.js`, `index.js`.
+- Plural folders: `tests/`, `migrations/`.
+- Single-word methods: `check`, `subscribe`, `push`, `list`, `update`, `delete`, `clear`, `register`, `send`, `tick`.
+- Single-word properties in state: `online`, `status`, `pending`, `actor`, `clock`.
+- Avoid compound names where single words carry full meaning in context.
+
+---
+
+## 1. State and Storage Synchronization Gaps
+
+### 1.1. Reactive State Integration
+
+- **Status**: Runtime gap.
+- **Files**:
+  - `src/core/offline/connectivity.js`
+  - `src/core/offline/queue.js`
+  - `src/core/offline/state.js` [NEW]
+  - `src/core/offline/index.js`
+- **Problem**:
+  The connectivity monitor evaluates the network state via HEAD probes but does not expose it reactively using the `core.state` system. The offline queue manages deferred tasks inside IndexedDB but does not publish queue metrics (such as the number of pending tasks). Callers cannot bind UI elements (like sync indicators or queue counters) directly to the reactive state layer.
+- **Expected Support**:
+  - Introduce `src/core/offline/state.js` exposing a reactive `state` store containing:
+    - `online`: boolean indicating connectivity.
+    - `status`: `'online' | 'offline' | 'unknown'` representing current reachability.
+    - `pending`: number of elements currently in the sync queue.
+  - Automatically update `online` and `status` in the state store whenever connectivity changes.
+  - Automatically update `pending` in the state store whenever items are pushed, updated, deleted, or cleared in the queue.
+
+### 1.2. Write-Ahead Journaling and Storage Durability
+
+- **Status**: Durability gap.
+- **Files**:
+  - `src/core/offline/queue.js`
+- **Problem**:
+  The offline queue writes directly to a raw IndexedDB connection (`new Database(...)` from `../storage/idb.js`). It bypasses the crash-durable journaling and quota warnings implemented in the unified `storage` gateway. Under sudden tab closure or power failure, queued tasks may fail to commit or corrupt database state.
+- **Expected Support**:
+  - Integrate `OfflineQueue` with `localStorage`-based write-ahead journaling for queue writes.
+  - Automatically recover/replay uncommitted journal records during offline engine initialization.
+  - Listen to `onQuotaWarning` subscriptions to prevent queue pushes and trigger warning events when client storage usage exceeds 80%.
+
+---
+
+## 2. Concurrency and Fallback Coordination Gaps
+
+### 2.1. Web Locks for Cross-Tab Fallback Coordination
+
+- **Status**: Concurrency gap.
+- **Files**:
+  - `src/core/offline/sync.js`
+- **Problem**:
+  On browsers without native Background Sync support (Firefox, Safari), the manual fallback listens for `online` transitions and triggers queue replay via custom event dispatch. In a multi-tab session, all open tabs will simultaneously receive the event and execute `replayQueue()`. This causes redundant HTTP requests, database write conflicts, and out-of-order network replay.
+- **Expected Support**:
+  - Coordinate manual sync replay across tabs using an exclusive Web Lock (`navigator.locks.request`) named `"offline:sync"`.
+  - Only the tab that successfully acquires the lock executes the replay loop, preventing concurrent replay attempts.
+
+---
+
+## 3. Logical Clocks and Conflict Resolution Gaps
+
+### 3.1. Lamport Logical Clocks Engine
+
+- **Status**: Architectural gap.
+- **Files**:
+  - `src/core/offline/clock.js` [NEW]
+  - `src/core/offline/index.js`
+- **Problem**:
+  To support reliable offline write replication, every queued operation must be stamped with a tuple of `(actor_id, lamport_timestamp, sequence_number)`. This ensures Last-Write-Wins (LWW) and CRDT merges resolve deterministically regardless of wall-clock drift. Currently, there is no implementation of actor registration or Lamport clock management.
+- **Expected Support**:
+  - Implement a logical Lamport clock engine in `clock.js` exporting:
+    - `actor`: a persistent UUID identifying the current client, stored in unified storage.
+    - `tick()`: increments and returns the local logical clock count.
+    - `sync(remoteTime)`: advances the local logical clock count to be greater than any incoming server/peer clock.

package/src/core/offline/plan.md

@@ -0,0 +1,143 @@
+# Offline & Background Capabilities Architecture Plan
+
+This document outlines the design, implementation, and optimization specifications for the resilient Offline and Background Capabilities engine under `core.offline` and the Service Worker runtime in the `@adukiorg/anza` library.
+
+---
+
+## 1. Architectural Strategy & Core Requirements
+
+Our offline-first architecture rests on the principle that **network absence is a normal mode of operation, not an error state**. The architecture decouples the initiation of an operation from its network execution, guaranteeing consistency, durability, and a highly responsive user experience under any connectivity condition.
+
+### Key Pillars
+
+1. **HEAD-Probe Connectivity Monitor (`connectivity.js`):** Resilient monitoring extending browser `navigator.onLine` with debounced, throttled (10s) HEAD probes using cache-busting headers. Support for memory-safe `subscribe` patterns utilizing the dual-cleanup pattern for `AbortSignal` listeners.
+2. **IndexedDB Tasks Journal (`queue.js`):** Chronicled persistent queue leveraging IndexedDB to buffer and serialize background tasks when offline. We will enhance the deserialization module to gracefully stringify plain object payloads when `Content-Type: application/json` is specified, resolving a critical integration mismatch.
+3. **Background Sync & Fallback (`sync.js`):** Native `SyncManager` registrations for Chromium-based browsers, paired with immediate event-driven fallbacks on `online` and custom triggers for Firefox and Safari. Memory-safe `onSyncFallback` listener registrations.
+4. **Service Worker Message Bridge (`bridge.js`):** High-concurrency message corridors utilizing native `MessageChannel` for direct request/response dispatching to the active Service Worker controller.
+5. **FIFO Replay Loop & Dead-Letter Management (`src/sw/sync.js`):** Chronological, sequential task processing with transaction safety, automatic retry limits (max 5), Dead-Letter Queue (DLQ) transitions, and tab-wide success/failure broadcasts.
+6. **Conflict Resolution Architecture:** Standardized conflict resolution guidelines using logical Lamport timestamps `(actor_id, lamport_timestamp, sequence_number)` instead of physical wall clocks, supporting Last-Write-Wins (LWW) registers and Grow-Only (G-Set) or Observed-Remove (OR-Set) CRDT configurations.
+
+---
+
+## 2. Component Blueprint & Files Layout
+
+All files inside the offline module strictly adhere to the `RULE[user_global]` lowercase, single-word naming structure:
+
+```
+src/core/offline/
+├── index.js          # Public offline entry point & unified facade
+├── connectivity.js   # Resilient connectivity check and listener subscriptions
+├── queue.js          # Persistent IndexedDB offline task journal
+├── sync.js           # Chromium Background Sync manager & Safari/Firefox online listeners
+├── bridge.js         # Bidirectional MessageChannel Service Worker corridor
+└── plan.md           # This planning document
+```
+
+---
+
+## 3. Detailed Component Designs
+
+### 3.1. Resilient Connectivity Prober (`connectivity.js`)
+
+* **HEAD Probe with Cache-Busting:** Performs a rate-limited `fetch` request using the `HEAD` method to the local favicon or a health-check path (`/favicon.ico?_probe=Date.now()`) with `mode: 'no-cors'` and `cache: 'no-store'`.
+* **Shared In-Flight Promise:** Share single active in-flight check promise to prevent redundant parallel network requests.
+* **Leak-Free Dual Abort Cleanup:**
+
+  ```javascript
+  export function subscribe(fn, signal) {
+    if (signal?.aborted) return () => {};
+    listeners.add(fn);
+    fn(isOnline);
+
+    const dispose = () => {
+      listeners.delete(fn);
+      if (signal) {
+        signal.removeEventListener('abort', dispose);
+      }
+    };
+
+    if (signal) {
+      signal.addEventListener('abort', dispose, { once: true });
+    }
+
+    return dispose;
+  }
+  ```
+
+### 3.2. Idempotent Offline Queue (`queue.js`)
+
+* **IndexedDB-Backed Buffer:** Uses the `Database` client from `../storage/idb.js` under the store `tasks` inside `platform-offline-queue`.
+* **JSON Body Deserialization Fix:** In `src/sw/queue.js` (used during SW replay), if the serialized request `body` is not a string, Blob, or ArrayBuffer (e.g. is a plain object written by `ui-form`), it must be stringified if the header is `application/json`.
+
+  ```javascript
+  export function deserializeRequest(serialized) {
+    const options = {
+      method: serialized.method,
+      headers: new Headers(serialized.headers)
+    };
+
+    if (serialized.body) {
+      const isJson = options.headers.get('content-type')?.includes('application/json');
+      if (isJson && typeof serialized.body === 'object' && !(serialized.body instanceof ArrayBuffer) && !(serialized.body instanceof Blob)) {
+        options.body = JSON.stringify(serialized.body);
+      } else {
+        options.body = serialized.body;
+      }
+    }
+
+    return new Request(serialized.url, options);
+  }
+  ```
+
+### 3.3. Background Sync & Fallback Coordinator (`sync.js`)
+
+* **Sync API Registration:** Enqueues a sync tag (e.g., `'pending'`) with the browser's Background Sync API if supported.
+* **Browser-Safe Event Fallbacks:** Hooks into the window's `online` state on Safari/Firefox and dispatches a custom event (`core:sync-fallback`) detailed with the pending tag.
+* **Leak-Free `onSyncFallback`:** Applies the dual-cleanup unsubscription pattern for the `core:sync-fallback` abort listener to prevent memory accumulation in long-lived client tabs.
+
+### 3.4. Service Worker Messaging Corridor (`bridge.js`)
+
+* **Response Channel Routing:** Utilizes transferable `MessageChannel` ports to match worker-side responses back to origin promises, avoiding race conditions in concurrent request dispatching.
+* **State Check:** Gracefully rejects with informative errors if the browser does not support Service Workers or if `navigator.serviceWorker.controller` is absent.
+
+---
+
+## 4. Conflict Resolution & Idempotency Guidelines
+
+To resolve concurrent offline edits reliably:
+
+1. **Logical Clocks (Lamport):** Every offline operation writes a tuple `(actor_id, lamport_timestamp, sequence_number)`.
+   * `actor_id`: Persisted UUID of the current device.
+   * `lamport_timestamp`: Monotonically increasing logical count that advances locally and synchronizes on remote data delivery.
+2. **Merge Semantics:**
+   * **LWW-Register:** Scalar fields use Last-Write-Wins based on Lamport comparisons (lexicographical actor ID as a final tiebreaker).
+   * **G-Set & OR-Set:** Collections (e.g. logs, attachment list mutations) use CRDT merge rules to ensure complete commutative, associative, and idempotent finality.
+3. **Idempotency Keys:** Every queued task has an `idempotencyKey` UUID. The replay engine re-submits this key to the server which returns cached responses for duplicates, securing absolute safety across multiple retries.
+
+---
+
+## 5. Verification & Testing Strategy
+
+### 5.1. Automated Unit Testing (`tests/core/offline/`)
+
+We will create a comprehensive suite of unit tests validating the offline capabilities:
+
+1. **`connectivity.test.js`**:
+   * Verify rate-limiting and cached status returns within the 10-second window.
+   * Assert `subscribe` triggers immediate callback feed.
+   * Assert that manual disposal and signal abort both clean up correctly without memory leaks.
+2. **`queue.test.js`**:
+   * Assert FIFO ordering on `list()`.
+   * Assert push and delete operations execute successfully on IndexedDB.
+   * Verify that `deserializeRequest` successfully stringifies plain object JSON payloads.
+3. **`sync.test.js`**:
+   * Verify Background Sync registers successfully if supported.
+   * Assert that Safari/Firefox manual online trigger successfully dispatches the `core:sync-fallback` custom event.
+   * Assert `onSyncFallback` correctly registers listeners and cleans up its abort hooks seamlessly.
+4. **`bridge.test.js`**:
+   * Assert that bridge messages throw when controller is absent.
+
+### 5.2. Manual & Network Validation
+
+* Simulating offline states via DevTools and verifying that submissions to `<ui-form>` with the `offline` attribute are correctly buffered inside the IndexedDB queue.
+* Verifying that as soon as the network state recovers, the replayer is triggered and sequentially processes tasks, broadcasting `sync-success` events back to the UI element.

package/src/core/offline/queue.js

@@ -0,0 +1,168 @@
+/**
+ * src/core/offline/queue.js
+ *
+ * Offline Operations Journal.
+ * Manages an IndexedDB-backed task queue to serialize, buffer, and track background
+ * tasks when offline, enforcing idempotency keys and retry limits.
+ *
+ * Source: doc 13 — Offline and Background §5
+ */
+
+import { Database } from '../storage/idb.js';
+import { state } from './state.js';
+import { quota } from '../storage/quota.js';
+import { uuid } from '../security/index.js';
+
+const db = new Database('platform-offline-queue', 1, [
+  (dbInstance) => {
+    dbInstance.createObjectStore('tasks');
+  }
+]);
+
+// Replay uncommitted tasks from localStorage journal
+async function replayJournal() {
+  if (typeof localStorage === 'undefined') return;
+  const keysToRemove = [];
+  for (let i = 0; i < localStorage.length; i++) {
+    const k = localStorage.key(i);
+    if (k && k.startsWith('offline:journal:')) {
+      try {
+        const raw = localStorage.getItem(k);
+        if (raw) {
+          const item = JSON.parse(raw);
+          console.log(`Replaying offline queue journal task: ${item.id}`);
+          await db.set('tasks', item.id, item);
+        }
+      } catch (err) {
+        console.error(`Failed to replay offline journal entry ${k}:`, err);
+      }
+      keysToRemove.push(k);
+    }
+  }
+  for (const k of keysToRemove) {
+    localStorage.removeItem(k);
+  }
+}
+
+// Update the reactive state pending task count
+async function syncPending() {
+  try {
+    const list = await db.getAll('tasks');
+    state.set('pending', list.length);
+  } catch (err) {
+    console.error('Failed to sync pending queue count:', err);
+  }
+}
+
+// Boot setup
+if (typeof window !== 'undefined') {
+  Promise.resolve().then(async () => {
+    try {
+      await db.open();
+      await replayJournal();
+      await syncPending();
+    } catch (err) {
+      console.error('Failed to initialize offline queue boot setup:', err);
+    }
+  });
+}
+
+export class OfflineQueue {
+  /**
+   * Enqueues an offline task with idempotency controls.
+   */
+  async push(taskName, payload = null, options = {}) {
+    // Proactive quota check; usage > 80% blocks enqueuing
+    const isExceeded = await quota.check();
+    if (isExceeded) {
+      throw new DOMException('Storage quota limit exceeded (usage > 80%)', 'QuotaExceededError');
+    }
+
+    await db.open();
+    const id = options.idempotencyKey || uuid();
+
+    const item = {
+      id,
+      task: taskName,
+      payload,
+      timestamp: Date.now(),
+      retries: 0,
+      maxRetries: options.maxRetries ?? 5
+    };
+
+    const journalKey = `offline:journal:${id}`;
+    if (typeof localStorage !== 'undefined') {
+      try {
+        localStorage.setItem(journalKey, JSON.stringify(item));
+      } catch (err) {
+        console.warn('Failed to write offline journal:', err);
+      }
+    }
+
+    try {
+      await db.set('tasks', id, item);
+      await syncPending();
+    } finally {
+      if (typeof localStorage !== 'undefined') {
+        localStorage.removeItem(journalKey);
+      }
+    }
+
+    return id;
+  }
+
+  /**
+   * Retrieves all items currently stored in the queue.
+   */
+  async list() {
+    await db.open();
+    const list = await db.getAll('tasks');
+    // Sort oldest tasks first for chronological processing
+    return list.sort((a, b) => a.timestamp - b.timestamp);
+  }
+
+  /**
+   * Updates a task state in the queue.
+   */
+  async update(task) {
+    await db.open();
+    const journalKey = `offline:journal:${task.id}`;
+    if (typeof localStorage !== 'undefined') {
+      try {
+        localStorage.setItem(journalKey, JSON.stringify(task));
+      } catch (err) {
+        console.warn('Failed to write offline journal on update:', err);
+      }
+    }
+
+    try {
+      await db.set('tasks', task.id, task);
+      await syncPending();
+    } finally {
+      if (typeof localStorage !== 'undefined') {
+        localStorage.removeItem(journalKey);
+      }
+    }
+  }
+
+  /**
+   * Evicts a resolved task from the queue.
+   */
+  async delete(id) {
+    await db.open();
+    await db.delete('tasks', id);
+    await syncPending();
+  }
+
+  /**
+   * Fully clears the queue.
+   */
+  async clear() {
+    await db.open();
+    await db.clear('tasks');
+    await syncPending();
+  }
+}
+
+export const queue = new OfflineQueue();
+

package/src/core/offline/state.js

@@ -0,0 +1,18 @@
+/**
+ * src/core/offline/state.js
+ *
+ * Reactive state store for connectivity and queue metrics.
+ *
+ * Source: doc 08 — State Management, doc 13 — Offline and Background
+ */
+
+import { ReactiveStore } from '../state/store.js';
+
+const isBrowser = typeof navigator !== 'undefined';
+const initOnline = isBrowser ? navigator.onLine : true;
+
+export const state = new ReactiveStore({
+  online: initOnline,
+  status: initOnline ? 'online' : 'offline',
+  pending: 0
+});