@sweidos/eidos 1.1.0 → 2.0.0

package/dist/action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":[],"sources":["../src/action.ts"],"sourcesContent":["import { useEidosStore } from './store';\nimport { getSwRegistration } from './sw-bridge';\nimport { idbQueueStorage } from './idb';\nimport { _getQueueStorage } from './queue-storage';\nimport { broadcastQueueSync } from './queue-sync';\nimport type { QueueStorage } from './queue-storage';\nimport { CURRENT_QUEUE_SCHEMA_VERSION } from './types';\nimport type {\n  ActionConfig,\n  ActionContext,\n  ActionHandle,\n  ActionFn,\n  ActionQueueItem,\n  ConflictConfig,\n  ConflictContext,\n  ConflictResolution,\n  QueuedResult,\n  ReplayResult,\n} from './types';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst _actionRegistry = new Map<string, ActionFn<any[], any>>();\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst _rollbackRegistry = new Map<string, (...args: any[]) => void>();\nconst _conflictConfigRegistry = new Map<string, ConflictConfig>();\nconst _configRegistry = new Map<string, ActionConfig>();\n\n// In-flight AbortControllers for `cancellable` actions, keyed by idempotencyKey.\n// Populated for direct calls and replays alike; removed once the call settles.\nconst _inflightControllers = new Map<string, AbortController>();\n\nfunction qs(): QueueStorage {\n  // idbQueueStorage is the default browser fallback when no custom storage is set.\n  return _getQueueStorage() ?? idbQueueStorage;\n}\n\nfunction uid() {\n  return crypto.randomUUID();\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction callWithContext<TArgs extends any[], TReturn>(\n  fn: ActionFn<TArgs, TReturn>,\n  args: TArgs,\n  ctx: ActionContext,\n): Promise<TReturn> {\n  return fn(...args, ctx);\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function action<TArgs extends any[], TReturn>(\n  fn: ActionFn<TArgs, TReturn>,\n  config: ActionConfig<TArgs>,\n): ActionHandle<TArgs, TReturn> {\n  // || not ?? — fn.name can be '' (anonymous arrow fn) which ?? treats as a\n  // valid value, causing all anonymous actions to share actionId ''.\n  const baseId = config.name || fn.name || uid();\n  const actionId = config.namespace ? `${config.namespace}::${baseId}` : baseId;\n\n  if (import.meta.env.DEV && config.reliability === 'neverLose' && !config.name && !fn.name) {\n    console.warn(\n      `[eidos] action() registered with neverLose but no stable name was found (fn.name=\"${fn.name}\"). Pass config.name so queued items survive a page reload and can be replayed.`,\n    );\n  }\n\n  if (_actionRegistry.has(actionId)) {\n    throw new Error(\n      `[eidos] duplicate action id \"${actionId}\" — an action with this id is already registered. Pass a unique config.name or config.namespace.`,\n    );\n  }\n\n  // Registering here means the function is available for replay after\n  // the user refreshes the page (actions are defined at module scope).\n  _actionRegistry.set(actionId, fn as ActionFn<unknown[], unknown>);\n  _configRegistry.set(actionId, config as ActionConfig);\n\n  if (config.onRollback) {\n    _rollbackRegistry.set(actionId, config.onRollback);\n  }\n\n  if (config.conflict) {\n    if (\n      import.meta.env.DEV &&\n      (config.conflict.strategy === 'merge' || config.conflict.strategy === 'custom') &&\n      !config.conflict.resolve\n    ) {\n      console.error(\n        `[eidos] action \"${actionId}\" has conflict.strategy \"${config.conflict.strategy}\" but no resolve() — items will retry indefinitely on 4xx.`,\n      );\n    }\n    _conflictConfigRegistry.set(actionId, config.conflict);\n  }\n\n  const wrapped = async (...args: TArgs): Promise<TReturn | QueuedResult> => {\n    const { isOnline } = useEidosStore.getState();\n\n    // Generated for every invocation — reused across every retry/replay of a\n    // neverLose item, and used to key handle.cancel() for in-flight cancellable calls.\n    const idempotencyKey = uid();\n\n    let signal: AbortSignal | undefined;\n    if (config.cancellable) {\n      const controller = new AbortController();\n      _inflightControllers.set(idempotencyKey, controller);\n      signal = controller.signal;\n    }\n\n    const ctx: ActionContext = { idempotencyKey, attempt: 0, signal };\n\n    config.onOptimistic?.(...args, ctx);\n\n    try {\n      if (config.reliability === 'neverLose') {\n        if (!isOnline) {\n          return persistAndQueue(actionId, actionId, args, config, idempotencyKey);\n        }\n        // Online + neverLose: execute, queue on failure\n        try {\n          return await callWithContext(fn, args, ctx);\n        } catch (err) {\n          if (isAbortError(err)) throw err;\n          return persistAndQueue(actionId, actionId, args, config, idempotencyKey);\n        }\n      }\n\n      // best-effort: execute directly, rollback on failure\n      try {\n        return await callWithContext(fn, args, ctx);\n      } catch (err) {\n        config.onRollback?.(...args, ctx);\n        throw err;\n      }\n    } finally {\n      if (config.cancellable) _inflightControllers.delete(idempotencyKey);\n    }\n  };\n\n  const cancel = async (idempotencyKey: string): Promise<boolean> => {\n    const controller = _inflightControllers.get(idempotencyKey);\n    if (controller) {\n      controller.abort();\n      return true;\n    }\n\n    // Not in flight — check for a not-yet-replayed queued item with this key.\n    const items = await qs().getAll();\n    const item = items.find((i) => i.idempotencyKey === idempotencyKey && i.status === 'pending');\n    if (!item) return false;\n\n    useEidosStore.getState().removeQueueItem(item.id);\n    broadcastQueueSync({ type: 'remove', id: item.id });\n    await qs().remove(item.id);\n    return true;\n  };\n\n  Object.defineProperty(wrapped, 'id', { value: actionId, writable: false });\n  Object.defineProperty(wrapped, 'config', { value: config, writable: false });\n  Object.defineProperty(wrapped, 'cancel', { value: cancel, writable: false });\n\n  return wrapped as unknown as ActionHandle<TArgs, TReturn>;\n}\n\nfunction isJsonSerializable(value: unknown): boolean {\n  try {\n    JSON.stringify(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nasync function persistAndQueue<TArgs extends any[]>(\n  actionId: string,\n  actionName: string,\n  args: TArgs,\n  config: ActionConfig<TArgs>,\n  idempotencyKey: string,\n): Promise<QueuedResult> {\n  if (import.meta.env.DEV && !isJsonSerializable(args)) {\n    console.warn(\n      `[eidos] action \"${actionName}\" queued with non-JSON-serializable args. These args will be lost after a page reload. Use plain JSON values for neverLose actions.`,\n      args,\n    );\n  }\n\n  const id = uid();\n  const item: ActionQueueItem = {\n    schemaVersion: CURRENT_QUEUE_SCHEMA_VERSION,\n    id,\n    actionId,\n    actionName,\n    idempotencyKey,\n    args,\n    queuedAt: Date.now(),\n    retryCount: 0,\n    maxRetries: config.maxRetries ?? 3,\n    status: 'pending',\n    priority: config.priority ?? 'normal',\n  };\n\n  await qs().add(item);\n  useEidosStore.getState().addQueueItem(item);\n\n  // Register Background Sync tag so the browser can wake up open clients\n  // when connectivity returns, even if the user navigated away briefly.\n  // Graceful no-op when Background Sync is unsupported.\n  try {\n    const reg = getSwRegistration();\n    if (reg && 'sync' in reg) {\n      await (reg as unknown as { sync: { register(tag: string): Promise<void> } }).sync.register(\n        'eidos-queue-replay',\n      );\n    }\n  } catch {\n    // Background Sync not available — online-event replay remains the fallback\n  }\n\n  return {\n    queued: true,\n    id,\n    message: `\"${actionName}\" queued — will execute when online`,\n  };\n}\n\nfunction isAbortError(err: unknown): boolean {\n  return err instanceof DOMException && err.name === 'AbortError';\n}\n\nfunction isClientError(err: unknown): boolean {\n  if (err instanceof Response) return err.status >= 400 && err.status < 500;\n  if (typeof err === 'object' && err !== null) {\n    const s = (err as Record<string, unknown>).status;\n    if (typeof s === 'number') return s >= 400 && s < 500;\n  }\n  return false;\n}\n\n// Base delay 2s, doubles per retry, capped at 5 minutes, ±20% jitter\nfunction backoffMs(retryCount: number): number {\n  const base = Math.min(2000 * 2 ** retryCount, 300_000);\n  return base * (0.8 + Math.random() * 0.4);\n}\n\nfunction emptyReplayResult(): ReplayResult {\n  return {\n    attempted: 0,\n    succeeded: 0,\n    failed: 0,\n    retrying: 0,\n    skipped: 0,\n    conflicted: 0,\n    cancelled: 0,\n  };\n}\n\nlet _replaying = false;\nconst REPLAY_LOCK_NAME = 'eidos-queue-replay';\n\nexport async function replayQueue(): Promise<ReplayResult> {\n  const store = useEidosStore.getState();\n  if (!store.isOnline) return emptyReplayResult();\n\n  // Web Locks coordinate replay across tabs sharing the same IndexedDB queue —\n  // only the lock holder replays; other tabs no-op rather than re-executing\n  // the same queued actions in parallel.\n  if (typeof navigator !== 'undefined' && navigator.locks) {\n    return navigator.locks.request(REPLAY_LOCK_NAME, { ifAvailable: true }, async (lock) => {\n      if (!lock) return emptyReplayResult();\n      return _doReplayQueue(store);\n    });\n  }\n\n  // Fallback for environments without the Web Locks API (older Safari, React\n  // Native, test runners) — guards against concurrent replay within this tab only.\n  if (_replaying) return emptyReplayResult();\n  _replaying = true;\n  try {\n    return await _doReplayQueue(store);\n  } finally {\n    _replaying = false;\n  }\n}\n\ntype ItemOutcome = 'succeeded' | 'failed' | 'retrying' | 'skipped' | 'conflicted' | 'cancelled';\n\nasync function _markSucceeded(\n  item: ActionQueueItem,\n  store: ReturnType<typeof useEidosStore.getState>,\n): Promise<void> {\n  const completedAt = Date.now();\n  store.updateQueueItem(item.id, { status: 'succeeded', completedAt });\n  broadcastQueueSync({ type: 'update', id: item.id, update: { status: 'succeeded', completedAt } });\n  await qs().update(item.id, { status: 'succeeded', completedAt });\n\n  // Remove from queue after a short delay so UI can show the success state briefly\n  setTimeout(() => {\n    store.removeQueueItem(item.id);\n    broadcastQueueSync({ type: 'remove', id: item.id });\n    qs().remove(item.id);\n  }, 3000);\n}\n\n/**\n * Resolves a 4xx error against the action's conflict strategy.\n * Returns 'conflicted' if the item was dropped, undefined if normal\n * retry/fail logic should run (possibly with `item.args` rewritten by `merge`).\n */\nasync function _resolveConflict(\n  item: ActionQueueItem,\n  store: ReturnType<typeof useEidosStore.getState>,\n  err: unknown,\n): Promise<ItemOutcome | undefined> {\n  const conflictConfig = _conflictConfigRegistry.get(item.actionId);\n  let resolution: ConflictResolution | undefined;\n\n  if (conflictConfig) {\n    switch (conflictConfig.strategy) {\n      case 'serverWins':\n        resolution = 'skip';\n        break;\n      case 'clientWins':\n        resolution = 'retry';\n        break;\n      case 'merge':\n      case 'custom': {\n        const ctx: ConflictContext = {\n          error: err,\n          args: item.args as unknown[],\n          attempt: item.retryCount,\n          idempotencyKey: item.idempotencyKey,\n        };\n        resolution = conflictConfig.resolve?.(ctx) ?? 'retry';\n        break;\n      }\n    }\n  }\n\n  if (resolution === 'skip') {\n    store.removeQueueItem(item.id);\n    broadcastQueueSync({ type: 'remove', id: item.id });\n    await qs().remove(item.id);\n    return 'conflicted';\n  }\n  if (resolution && typeof resolution === 'object') {\n    item.args = resolution.resolved;\n    store.updateQueueItem(item.id, { args: resolution.resolved });\n    broadcastQueueSync({ type: 'update', id: item.id, update: { args: resolution.resolved } });\n    await qs().update(item.id, { args: resolution.resolved });\n  }\n  // 'retry' (or merged args) falls through to normal retry/fail logic\n  return undefined;\n}\n\nasync function _scheduleRetryOrFail(\n  item: ActionQueueItem,\n  store: ReturnType<typeof useEidosStore.getState>,\n  err: unknown,\n): Promise<ItemOutcome> {\n  const retryCount = item.retryCount + 1;\n  if (retryCount >= item.maxRetries) {\n    const update = { status: 'failed' as const, error: String(err), retryCount };\n    store.updateQueueItem(item.id, update);\n    broadcastQueueSync({ type: 'update', id: item.id, update });\n    await qs().update(item.id, update);\n    const ctx: ActionContext = { idempotencyKey: item.idempotencyKey, attempt: retryCount };\n    _rollbackRegistry.get(item.actionId)?.(...(item.args as unknown[]), ctx);\n    return 'failed';\n  }\n\n  const nextRetryAt = Date.now() + backoffMs(retryCount);\n  const update = { status: 'pending' as const, retryCount, nextRetryAt };\n  store.updateQueueItem(item.id, update);\n  broadcastQueueSync({ type: 'update', id: item.id, update });\n  await qs().update(item.id, update);\n  return 'retrying';\n}\n\nasync function _replayItem(\n  item: ActionQueueItem,\n  store: ReturnType<typeof useEidosStore.getState>,\n): Promise<ItemOutcome> {\n  const fn = _actionRegistry.get(item.actionId);\n  if (!fn) return 'skipped';\n\n  const cancellable = _configRegistry.get(item.actionId)?.cancellable;\n  let signal: AbortSignal | undefined;\n  if (cancellable) {\n    const controller = new AbortController();\n    _inflightControllers.set(item.idempotencyKey, controller);\n    signal = controller.signal;\n  }\n\n  const ctx: ActionContext = {\n    idempotencyKey: item.idempotencyKey,\n    attempt: item.retryCount,\n    signal,\n  };\n\n  try {\n    await callWithContext(fn, item.args as unknown[], ctx);\n    await _markSucceeded(item, store);\n    return 'succeeded';\n  } catch (err) {\n    // Cancelled via handle.cancel(idempotencyKey) — drop the item, no rollback/retry.\n    if (isAbortError(err)) {\n      store.removeQueueItem(item.id);\n      broadcastQueueSync({ type: 'remove', id: item.id });\n      await qs().remove(item.id);\n      return 'cancelled';\n    }\n\n    // 4xx: give the conflict strategy a chance to decide before normal retry/fail logic\n    if (isClientError(err)) {\n      const outcome = await _resolveConflict(item, store, err);\n      if (outcome) return outcome;\n    }\n\n    return _scheduleRetryOrFail(item, store, err);\n  } finally {\n    if (cancellable) _inflightControllers.delete(item.idempotencyKey);\n  }\n}\n\nasync function _replayTier(\n  items: ActionQueueItem[],\n  store: ReturnType<typeof useEidosStore.getState>,\n  result: ReplayResult,\n): Promise<void> {\n  if (items.length === 0) return;\n\n  // Batch 'replaying' status update — N items → 1 store notify.\n  // IDB write is fire-and-forget: on reload items stay 'pending', safe to re-replay.\n  const replayable = items.filter((item) => _actionRegistry.has(item.actionId));\n  result.skipped += items.length - replayable.length;\n\n  if (replayable.length > 0) {\n    const updates = replayable.map((item) => ({\n      id: item.id,\n      update: { status: 'replaying' as const },\n    }));\n    store.batchUpdateQueueItems(updates);\n    broadcastQueueSync({ type: 'batchUpdate', updates });\n    for (const item of replayable) {\n      qs().update(item.id, { status: 'replaying' });\n    }\n  }\n\n  const outcomes = await Promise.allSettled(replayable.map((item) => _replayItem(item, store)));\n\n  for (const o of outcomes) {\n    const outcome = o.status === 'fulfilled' ? o.value : 'failed';\n    if (outcome === 'skipped') {\n      result.skipped++;\n    } else if (outcome === 'conflicted') {\n      result.conflicted++;\n    } else if (outcome === 'cancelled') {\n      result.cancelled++;\n    } else {\n      result.attempted++;\n      result[outcome]++;\n    }\n  }\n}\n\nasync function _doReplayQueue(\n  store: ReturnType<typeof useEidosStore.getState>,\n): Promise<ReplayResult> {\n  const candidates = await qs().getPending();\n  const now = Date.now();\n  // getPending() includes 'failed' items (for UI/queue-stats visibility), but\n  // items that already exhausted maxRetries must not be auto-replayed again —\n  // otherwise every reconnect re-executes the action and re-fires onRollback.\n  // Those items stay 'failed' until the host app explicitly clears/re-queues them.\n  const pending = candidates.filter(\n    (item) => item.retryCount < item.maxRetries && (!item.nextRetryAt || item.nextRetryAt <= now),\n  );\n\n  const result: ReplayResult = emptyReplayResult();\n\n  // Process tiers sequentially: high items complete before normal, normal before low.\n  // Within each tier items run in parallel via Promise.allSettled.\n  for (const tier of ['high', 'normal', 'low'] as const) {\n    const tierItems = pending.filter((item) => (item.priority ?? 'normal') === tier);\n    await _replayTier(tierItems, store, result);\n  }\n\n  return result;\n}\n\n/** Remove all items from the action queue (storage + in-memory store). */\nexport async function clearQueue(): Promise<void> {\n  await qs().clear();\n  useEidosStore.getState().hydrateQueue([]);\n}\n"],"mappings":"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"}

package/dist/async-storage-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-storage-adapter.js","names":[],"sources":["../src/async-storage-adapter.ts"],"sourcesContent":["import type { ActionQueueItem } from './types';\nimport type { QueueStorage } from './queue-storage';\n\n/** Minimal subset of @react-native-async-storage/async-storage (or any compatible key-value store). */\nexport interface AsyncStorageLike {\n  getItem(key: string): Promise<string | null>;\n  setItem(key: string, value: string): Promise<void>;\n  removeItem(key: string): Promise<void>;\n}\n\nconst QUEUE_KEY = '@eidos:queue';\n\n/**\n * QueueStorage implementation backed by any AsyncStorage-compatible API.\n * Pass the AsyncStorage singleton from @react-native-async-storage/async-storage\n * (or MMKV, SQLite, or any store that satisfies AsyncStorageLike).\n */\nexport class AsyncStorageQueueStorage implements QueueStorage {\n  constructor(private readonly storage: AsyncStorageLike) {}\n\n  private async readAll(): Promise<ActionQueueItem[]> {\n    try {\n      const raw = await this.storage.getItem(QUEUE_KEY);\n      if (!raw) return [];\n      return JSON.parse(raw) as ActionQueueItem[];\n    } catch {\n      return [];\n    }\n  }\n\n  private async writeAll(items: ActionQueueItem[]): Promise<void> {\n    await this.storage.setItem(QUEUE_KEY, JSON.stringify(items));\n  }\n\n  async add(item: ActionQueueItem): Promise<void> {\n    const items = await this.readAll();\n    items.push(item);\n    await this.writeAll(items);\n  }\n\n  async getAll(): Promise<ActionQueueItem[]> {\n    return this.readAll();\n  }\n\n  async getPending(): Promise<ActionQueueItem[]> {\n    const items = await this.readAll();\n    return items.filter((i) => i.status === 'pending' || i.status === 'failed');\n  }\n\n  async update(id: string, patch: Partial<ActionQueueItem>): Promise<void> {\n    const items = await this.readAll();\n    const idx = items.findIndex((i) => i.id === id);\n    if (idx !== -1) items[idx] = { ...items[idx], ...patch };\n    await this.writeAll(items);\n  }\n\n  async remove(id: string): Promise<void> {\n    const items = await this.readAll();\n    await this.writeAll(items.filter((i) => i.id !== id));\n  }\n\n  async clear(): Promise<void> {\n    await this.storage.removeItem(QUEUE_KEY);\n  }\n}\n"],"mappings":"AAUA,IAAM,IAAY,gBAOL,IAAb,MAA8D;AAAA,EAC5D,YAAY,GAA4C;AAA3B,SAAA,UAAA;AAAA,EAA4B;AAAA,EAEzD,MAAc,UAAsC;AAClD,QAAI;AACF,YAAM,IAAM,MAAM,KAAK,QAAQ,QAAQ,CAAS;AAChD,aAAK,IACE,KAAK,MAAM,CAAG,IADJ,CAAC;AAAA,IAEpB,QAAQ;AACN,aAAO,CAAC;AAAA,IACV;AAAA,EACF;AAAA,EAEA,MAAc,SAAS,GAAyC;AAC9D,UAAM,KAAK,QAAQ,QAAQ,GAAW,KAAK,UAAU,CAAK,CAAC;AAAA,EAC7D;AAAA,EAEA,MAAM,IAAI,GAAsC;AAC9C,UAAM,IAAQ,MAAM,KAAK,QAAQ;AACjC,IAAA,EAAM,KAAK,CAAI,GACf,MAAM,KAAK,SAAS,CAAK;AAAA,EAC3B;AAAA,EAEA,MAAM,SAAqC;AACzC,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEA,MAAM,aAAyC;AAE7C,YAAO,MADa,KAAK,QAAQ,GACpB,OAAA,CAAQ,MAAM,EAAE,WAAW,aAAa,EAAE,WAAW,QAAQ;AAAA,EAC5E;AAAA,EAEA,MAAM,OAAO,GAAY,GAAgD;AACvE,UAAM,IAAQ,MAAM,KAAK,QAAQ,GAC3B,IAAM,EAAM,UAAA,CAAW,MAAM,EAAE,OAAO,CAAE;AAC9C,IAAI,MAAQ,OAAI,EAAM,CAAA,IAAO;AAAA,MAAE,GAAG,EAAM,CAAA;AAAA,MAAM,GAAG;AAAA,IAAM,IACvD,MAAM,KAAK,SAAS,CAAK;AAAA,EAC3B;AAAA,EAEA,MAAM,OAAO,GAA2B;AACtC,UAAM,IAAQ,MAAM,KAAK,QAAQ;AACjC,UAAM,KAAK,SAAS,EAAM,OAAA,CAAQ,MAAM,EAAE,OAAO,CAAE,CAAC;AAAA,EACtD;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,KAAK,QAAQ,WAAW,CAAS;AAAA,EACzC;AACF"}

package/dist/cli.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import { generateKeyPairSync } from "node:crypto";
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+//#region src/cli.ts
+var PUBLIC_KEY_NAME = "EIDOS_VAPID_PUBLIC_KEY";
+var PRIVATE_KEY_NAME = "EIDOS_VAPID_PRIVATE_KEY";
+function base64UrlFromBuffer(buf) {
+	return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlToBuffer(b64url) {
+	const b64 = (b64url + "=".repeat((4 - b64url.length % 4) % 4)).replace(/-/g, "+").replace(/_/g, "/");
+	return Buffer.from(b64, "base64");
+}
+/** Pads a base64url-encoded big-endian integer to `length` bytes (leading zeros). */
+function padTo(b64url, length) {
+	const buf = base64UrlToBuffer(b64url);
+	if (buf.length === length) return buf;
+	const padded = Buffer.alloc(length);
+	buf.copy(padded, length - buf.length);
+	return padded;
+}
+function generateVapidKeys() {
+	const { publicKey, privateKey } = generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+	const pubJwk = publicKey.export({ format: "jwk" });
+	const privJwk = privateKey.export({ format: "jwk" });
+	const x = padTo(pubJwk.x, 32);
+	const y = padTo(pubJwk.y, 32);
+	const point = Buffer.concat([
+		Buffer.from([4]),
+		x,
+		y
+	]);
+	const d = padTo(privJwk.d, 32);
+	return {
+		publicKey: base64UrlFromBuffer(point),
+		privateKey: base64UrlFromBuffer(d)
+	};
+}
+function detectEnvPrefix(cwd) {
+	if (existsSync(resolve(cwd, "next.config.js")) || existsSync(resolve(cwd, "next.config.ts"))) return "NEXT_PUBLIC_";
+	if (existsSync(resolve(cwd, "vite.config.ts")) || existsSync(resolve(cwd, "vite.config.js"))) return "VITE_";
+	if (existsSync(resolve(cwd, "svelte.config.js"))) return "PUBLIC_";
+	if (existsSync(resolve(cwd, "nuxt.config.ts")) || existsSync(resolve(cwd, "nuxt.config.js"))) return "NUXT_PUBLIC_";
+	return "";
+}
+function pickEnvFile(cwd) {
+	if (existsSync(resolve(cwd, ".env.local"))) return resolve(cwd, ".env.local");
+	if (existsSync(resolve(cwd, ".env"))) return resolve(cwd, ".env");
+	return resolve(cwd, ".env.local");
+}
+async function confirm(message) {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	const answer = await rl.question(`${message} (type "yes" to continue): `);
+	rl.close();
+	return answer.trim().toLowerCase() === "yes";
+}
+async function generateVapidKeysCommand() {
+	const cwd = process.cwd();
+	const publicKeyName = `${detectEnvPrefix(cwd)}${PUBLIC_KEY_NAME}`;
+	const force = process.argv.includes("--force");
+	const envFile = pickEnvFile(cwd);
+	const existing = existsSync(envFile) ? readFileSync(envFile, "utf8") : "";
+	const hasPublic = new RegExp(`^${publicKeyName}=`, "m").test(existing);
+	const hasPrivate = new RegExp(`^${PRIVATE_KEY_NAME}=`, "m").test(existing);
+	if (hasPublic && hasPrivate) {
+		if (!force) {
+			console.log(`VAPID keys already configured in ${envFile} — nothing to do.`);
+			console.log("Pass --force to regenerate (this invalidates ALL existing push subscriptions).");
+			return;
+		}
+		if (!await confirm(`⚠ Regenerating VAPID keys will invalidate ALL existing push subscriptions in ${envFile}. Continue?`)) {
+			console.log("Aborted.");
+			return;
+		}
+	}
+	const { publicKey, privateKey } = generateVapidKeys();
+	const lines = [`${publicKeyName}=${publicKey}`, `${PRIVATE_KEY_NAME}=${privateKey}`];
+	if (hasPublic && hasPrivate) writeFileSync(envFile, `${existing.split("\n").filter((line) => !line.startsWith(`${publicKeyName}=`) && !line.startsWith(`${PRIVATE_KEY_NAME}=`)).join("\n").replace(/\n+$/, "")}\n${lines.join("\n")}\n`);
+	else appendFileSync(envFile, `${existing.length > 0 && !existing.endsWith("\n") ? "\n" : ""}${lines.join("\n")}\n`);
+	console.log(`✓ VAPID keys written to ${envFile}`);
+	console.log("");
+	console.log(`  ${publicKeyName}=${publicKey}`);
+	console.log(`  ${PRIVATE_KEY_NAME}=${privateKey}`);
+	console.log("");
+	console.log(`Give ${PRIVATE_KEY_NAME} and ${publicKeyName} to your backend.`);
+	console.log("Backend needs a VAPID-capable web-push library (any language) to send notifications using subscription objects received via onSubscribe.");
+}
+var command = process.argv[2];
+switch (command) {
+	case "generate-vapid-keys":
+		await generateVapidKeysCommand();
+		break;
+	default:
+		console.log("Usage: eidos generate-vapid-keys [--force]");
+		process.exit(command ? 1 : 0);
+}
+//#endregion

package/dist/devtools.js

@@ -89,6 +89,21 @@ var useEidosStore = {
 	}
 };
 //#endregion
+//#region src/types.ts
+/** Single pass over the queue — avoids separate .filter() calls per status. */
+function countQueueByStatus(queue) {
+	let pending = 0, failed = 0, replaying = 0;
+	for (const q of queue) if (q.status === "pending") pending++;
+	else if (q.status === "failed") failed++;
+	else if (q.status === "replaying") replaying++;
+	return {
+		pending,
+		failed,
+		replaying,
+		total: queue.length
+	};
+}
+//#endregion
 //#region src/react/hooks.ts
 function useStore(selector) {
 	const fn = selector ?? ((s) => s);
@@ -121,11 +136,8 @@ function useEidosStatus() {
 */
 function useEidosQueueStats() {
 	const [p, f, r, t] = useStore((s) => {
-		let pending = 0, failed = 0, replaying = 0;
-		for (const q of s.queue) if (q.status === "pending") pending++;
-		else if (q.status === "failed") failed++;
-		else if (q.status === "replaying") replaying++;
-		return `${pending},${failed},${replaying},${s.queue.length}`;
+		const { pending, failed, replaying, total } = countQueueByStatus(s.queue);
+		return `${pending},${failed},${replaying},${total}`;
 	}).split(",");
 	return {
 		pending: +p,
@@ -262,13 +274,41 @@ function _getQueueStorage() {
 	return _storage;
 }
 //#endregion
+//#region src/queue-sync.ts
+var CHANNEL_NAME = "eidos-queue-sync";
+var _channel;
+function getChannel() {
+	if (_channel !== void 0) return _channel;
+	_channel = typeof BroadcastChannel === "undefined" ? null : new BroadcastChannel(CHANNEL_NAME);
+	return _channel;
+}
+/**
+* Broadcasts a queue-item status change to other tabs sharing the same
+* IndexedDB queue. The replay-lock holder (see `replayQueue` in action.ts)
+* is the only tab that mutates queue-item status, so non-leader tabs would
+* otherwise show stale status until their own store re-hydrates.
+*
+* No-ops in environments without BroadcastChannel (React Native, old Safari).
+*/
+function broadcastQueueSync(message) {
+	getChannel()?.postMessage(message);
+}
+//#endregion
 //#region src/action.ts
 var _actionRegistry = /* @__PURE__ */ new Map();
 var _rollbackRegistry = /* @__PURE__ */ new Map();
-var _conflictRegistry = /* @__PURE__ */ new Map();
+var _conflictConfigRegistry = /* @__PURE__ */ new Map();
+var _configRegistry = /* @__PURE__ */ new Map();
+var _inflightControllers = /* @__PURE__ */ new Map();
 function qs() {
 	return _getQueueStorage() ?? idbQueueStorage;
 }
+function callWithContext(fn, args, ctx) {
+	return fn(...args, ctx);
+}
+function isAbortError(err) {
+	return err instanceof DOMException && err.name === "AbortError";
+}
 function isClientError(err) {
 	if (err instanceof Response) return err.status >= 400 && err.status < 500;
 	if (typeof err === "object" && err !== null) {
@@ -280,17 +320,27 @@ function isClientError(err) {
 function backoffMs(retryCount) {
 	return Math.min(2e3 * 2 ** retryCount, 3e5) * (.8 + Math.random() * .4);
 }
-var _replaying = false;
-async function replayQueue() {
-	const store = useEidosStore.getState();
-	if (!store.isOnline || _replaying) return {
+function emptyReplayResult() {
+	return {
 		attempted: 0,
 		succeeded: 0,
 		failed: 0,
 		retrying: 0,
 		skipped: 0,
-		conflicted: 0
+		conflicted: 0,
+		cancelled: 0
 	};
+}
+var _replaying = false;
+var REPLAY_LOCK_NAME = "eidos-queue-replay";
+async function replayQueue() {
+	const store = useEidosStore.getState();
+	if (!store.isOnline) return emptyReplayResult();
+	if (typeof navigator !== "undefined" && navigator.locks) return navigator.locks.request(REPLAY_LOCK_NAME, { ifAvailable: true }, async (lock) => {
+		if (!lock) return emptyReplayResult();
+		return _doReplayQueue(store);
+	});
+	if (_replaying) return emptyReplayResult();
 	_replaying = true;
 	try {
 		return await _doReplayQueue(store);
@@ -298,64 +348,152 @@ async function replayQueue() {
 		_replaying = false;
 	}
 }
-async function _replayItem(item, store) {
-	const fn = _actionRegistry.get(item.actionId);
-	if (!fn) return "skipped";
-	try {
-		await fn(...item.args);
-		const completedAt = Date.now();
-		store.updateQueueItem(item.id, {
+async function _markSucceeded(item, store) {
+	const completedAt = Date.now();
+	store.updateQueueItem(item.id, {
+		status: "succeeded",
+		completedAt
+	});
+	broadcastQueueSync({
+		type: "update",
+		id: item.id,
+		update: {
 			status: "succeeded",
 			completedAt
+		}
+	});
+	await qs().update(item.id, {
+		status: "succeeded",
+		completedAt
+	});
+	setTimeout(() => {
+		store.removeQueueItem(item.id);
+		broadcastQueueSync({
+			type: "remove",
+			id: item.id
 		});
-		await qs().update(item.id, {
-			status: "succeeded",
-			completedAt
+		qs().remove(item.id);
+	}, 3e3);
+}
+/**
+* Resolves a 4xx error against the action's conflict strategy.
+* Returns 'conflicted' if the item was dropped, undefined if normal
+* retry/fail logic should run (possibly with `item.args` rewritten by `merge`).
+*/
+async function _resolveConflict(item, store, err) {
+	const conflictConfig = _conflictConfigRegistry.get(item.actionId);
+	let resolution;
+	if (conflictConfig) switch (conflictConfig.strategy) {
+		case "serverWins":
+			resolution = "skip";
+			break;
+		case "clientWins":
+			resolution = "retry";
+			break;
+		case "merge":
+		case "custom": {
+			const ctx = {
+				error: err,
+				args: item.args,
+				attempt: item.retryCount,
+				idempotencyKey: item.idempotencyKey
+			};
+			resolution = conflictConfig.resolve?.(ctx) ?? "retry";
+			break;
+		}
+	}
+	if (resolution === "skip") {
+		store.removeQueueItem(item.id);
+		broadcastQueueSync({
+			type: "remove",
+			id: item.id
 		});
-		setTimeout(() => {
-			store.removeQueueItem(item.id);
-			qs().remove(item.id);
-		}, 3e3);
+		await qs().remove(item.id);
+		return "conflicted";
+	}
+	if (resolution && typeof resolution === "object") {
+		item.args = resolution.resolved;
+		store.updateQueueItem(item.id, { args: resolution.resolved });
+		broadcastQueueSync({
+			type: "update",
+			id: item.id,
+			update: { args: resolution.resolved }
+		});
+		await qs().update(item.id, { args: resolution.resolved });
+	}
+}
+async function _scheduleRetryOrFail(item, store, err) {
+	const retryCount = item.retryCount + 1;
+	if (retryCount >= item.maxRetries) {
+		const update = {
+			status: "failed",
+			error: String(err),
+			retryCount
+		};
+		store.updateQueueItem(item.id, update);
+		broadcastQueueSync({
+			type: "update",
+			id: item.id,
+			update
+		});
+		await qs().update(item.id, update);
+		const ctx = {
+			idempotencyKey: item.idempotencyKey,
+			attempt: retryCount
+		};
+		_rollbackRegistry.get(item.actionId)?.(...item.args, ctx);
+		return "failed";
+	}
+	const update = {
+		status: "pending",
+		retryCount,
+		nextRetryAt: Date.now() + backoffMs(retryCount)
+	};
+	store.updateQueueItem(item.id, update);
+	broadcastQueueSync({
+		type: "update",
+		id: item.id,
+		update
+	});
+	await qs().update(item.id, update);
+	return "retrying";
+}
+async function _replayItem(item, store) {
+	const fn = _actionRegistry.get(item.actionId);
+	if (!fn) return "skipped";
+	const cancellable = _configRegistry.get(item.actionId)?.cancellable;
+	let signal;
+	if (cancellable) {
+		const controller = new AbortController();
+		_inflightControllers.set(item.idempotencyKey, controller);
+		signal = controller.signal;
+	}
+	const ctx = {
+		idempotencyKey: item.idempotencyKey,
+		attempt: item.retryCount,
+		signal
+	};
+	try {
+		await callWithContext(fn, item.args, ctx);
+		await _markSucceeded(item, store);
 		return "succeeded";
 	} catch (err) {
-		if (isClientError(err)) {
-			const onConflict = _conflictRegistry.get(item.actionId);
-			if (onConflict) {
-				if (onConflict(err, item.args) === "skip") {
-					store.removeQueueItem(item.id);
-					await qs().remove(item.id);
-					return "conflicted";
-				}
-			}
-		}
-		const retryCount = item.retryCount + 1;
-		if (retryCount >= item.maxRetries) {
-			store.updateQueueItem(item.id, {
-				status: "failed",
-				error: String(err),
-				retryCount
-			});
-			await qs().update(item.id, {
-				status: "failed",
-				error: String(err),
-				retryCount
-			});
-			_rollbackRegistry.get(item.actionId)?.(...item.args);
-			return "failed";
-		} else {
-			const nextRetryAt = Date.now() + backoffMs(retryCount);
-			store.updateQueueItem(item.id, {
-				status: "pending",
-				retryCount,
-				nextRetryAt
-			});
-			await qs().update(item.id, {
-				status: "pending",
-				retryCount,
-				nextRetryAt
+		if (isAbortError(err)) {
+			store.removeQueueItem(item.id);
+			broadcastQueueSync({
+				type: "remove",
+				id: item.id
 			});
-			return "retrying";
+			await qs().remove(item.id);
+			return "cancelled";
+		}
+		if (isClientError(err)) {
+			const outcome = await _resolveConflict(item, store, err);
+			if (outcome) return outcome;
 		}
+		return _scheduleRetryOrFail(item, store, err);
+	} finally {
+		if (cancellable) _inflightControllers.delete(item.idempotencyKey);
 	}
 }
 async function _replayTier(items, store, result) {
@@ -363,10 +501,15 @@ async function _replayTier(items, store, result) {
 	const replayable = items.filter((item) => _actionRegistry.has(item.actionId));
 	result.skipped += items.length - replayable.length;
 	if (replayable.length > 0) {
-		store.batchUpdateQueueItems(replayable.map((item) => ({
+		const updates = replayable.map((item) => ({
 			id: item.id,
 			update: { status: "replaying" }
-		})));
+		}));
+		store.batchUpdateQueueItems(updates);
+		broadcastQueueSync({
+			type: "batchUpdate",
+			updates
+		});
 		for (const item of replayable) qs().update(item.id, { status: "replaying" });
 	}
 	const outcomes = await Promise.allSettled(replayable.map((item) => _replayItem(item, store)));
@@ -374,6 +517,7 @@ async function _replayTier(items, store, result) {
 		const outcome = o.status === "fulfilled" ? o.value : "failed";
 		if (outcome === "skipped") result.skipped++;
 		else if (outcome === "conflicted") result.conflicted++;
+		else if (outcome === "cancelled") result.cancelled++;
 		else {
 			result.attempted++;
 			result[outcome]++;
@@ -384,14 +528,7 @@ async function _doReplayQueue(store) {
 	const candidates = await qs().getPending();
 	const now = Date.now();
 	const pending = candidates.filter((item) => item.retryCount < item.maxRetries && (!item.nextRetryAt || item.nextRetryAt <= now));
-	const result = {
-		attempted: 0,
-		succeeded: 0,
-		failed: 0,
-		retrying: 0,
-		skipped: 0,
-		conflicted: 0
-	};
+	const result = emptyReplayResult();
 	for (const tier of [
 		"high",
 		"normal",