vue-write-behind 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ozgur Seyidoglu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,199 @@
+# vue-write-behind
+
+**The write never comes back.** Local state stays authoritative and the network is a background
+chore. Edit a cell ten times and one request goes out carrying the tenth value. The server's reply
+is *discarded on purpose* — it can never overwrite the cell the user is still typing in. A failed
+save rolls nothing back; the key stays dirty and goes out again next tick, carrying whatever has
+been typed since.
+
+It is a **state outbox, not an operation log**: keys are independent and last-write-wins.
+
+```bash
+npm install vue-write-behind
+```
+
+```vue
+<script setup lang="ts">
+import { reactive } from 'vue'
+import { useWriteBehind } from 'vue-write-behind'
+
+const cells = reactive<Record<string, string>>({ A1: 'foo' })
+const outbox = useWriteBehind(cells, (value, key) => api.put(`/cell/${key}`, value))
+
+cells.A1 = 'bar' // that is the whole API
+</script>
+
+<template>
+  <input v-model="cells.A1" />
+  <span v-if="outbox.isSyncing">saving…</span>
+  <span v-else-if="outbox.pending.length">{{ outbox.pending.length }} unsaved</span>
+</template>
+```
+
+No wrapper component, no query client, no schema. The record is yours; the composable watches it.
+
+## What the defaults do
+
+The bare form above is the configuration this library recommends — options exist to opt *out*.
+
+| | Default | Why |
+|---|---|---|
+| Cadence | flush every **1000 ms**, and the timer only runs while something is queued | a burst of keystrokes is one request; an idle app holds no timer |
+| Coalescing | last-write-wins per key | the pending map is bounded by the number of keys, not edits |
+| Parallelism | `Promise.allSettled` over the due keys | keys are independent, so one slow key never holds up another |
+| The response | **ignored** — there is no opt-in | applying it is the "cell jumps while you type" bug |
+| Failure | retry forever, per-key backoff 1 → 2 → 4 → 8 → 16 → 30 s (capped), always re-sending the **current** value | silently dropping a user's edit is the one unacceptable outcome |
+| Batch size | unlimited | |
+| Leaving the page | flush on `visibilitychange → hidden` | best-effort — see below |
+| Lifetime | stops on scope dispose, never starts on the server | |
+
+## The store it returns
+
+Reactive and already assembled — read it straight in a template.
+
+| | |
+|---|---|
+| `pending` | every key with an unsaved change, in-flight ones included. The "you have unsaved work" number |
+| `inFlight` | the subset currently on the wire |
+| `failed` | `{ key, error, attempts, retryAt }` per failing key — latest error only |
+| `isSyncing` | `true` while anything is in flight |
+| `set(key, value)` | write local state **and** queue it, unconditionally |
+| `flush()` | send everything pending now, ignoring the debounce and backoff clocks |
+| `retry(key?)` | clear the backoff and the recorded failure for one key, or all |
+| `discard(key)` | drop a pending write. **The only operation here that loses one** |
+
+## Options
+
+Every one is an opt-out. Pass them instead of the bare writer:
+
+```ts
+const outbox = useWriteBehind(cells, {
+  write: (value, key) => api.put(`/cell/${key}`, value),
+  interval: 1000,
+  debounce: 0,
+  retry: { initialDelay: 1000, maxDelay: 30000, factor: 2 }, // or `false`
+  flushOnHidden: true,
+  keys: ['A1', 'A2'],          // or (key) => key.startsWith('draft:')
+  equals: (a, b) => a === b,
+})
+```
+
+- **`interval`** — flush cadence in ms. It is a fixed window, not a debounce: it never restarts
+  under a fast typist.
+- **`debounce`** — per-key quiet period before a key becomes eligible. Off by default because the
+  interval already coalesces a burst. An edit never *shortens* an active backoff.
+- **`retry: false`** — stop retrying after a failure. The key is **not** dropped: it stays in
+  `pending`, stays listed in `failed` with `retryAt: undefined`, and goes out again on the next edit
+  or on `retry(key)`.
+- **`keys`** — narrows what the source watcher picks up. `set()` is explicit and ignores it.
+- **`equals`** — change detection, `Object.is` by default. See the precondition below.
+
+### A batch endpoint
+
+The other shape worth first-class support. One call per tick, every due key in it:
+
+```ts
+useWriteBehind(cells, {
+  flush: (entries) => api.patch('/cells', Object.fromEntries(entries)),
+})
+```
+
+Throw or reject and the **whole batch** stays pending. Resolve with `{ failed: ['A1'] }` to fail
+part of it — everything else in the batch is treated as written. The version guard is applied per
+key inside the batch, exactly as it is per request.
+
+## The rules that matter
+
+**A key edited while its own write is in flight.** This is the case a boolean dirty flag gets
+wrong: the response clears a flag a newer edit set, and that edit is gone — silently, with a
+correct-looking value still on screen. Here each key carries a monotonic version, a write records
+the version it was sent at, and a success clears the key **only if** the version has not moved.
+Otherwise the key stays dirty and the newer value goes out next tick.
+
+**A retry sends the current value, not the one that failed.** The value is read out of the map at
+send time, never captured when the edit happened. So a save that failed at 09:00 and retries at
+09:01 carries what is on screen at 09:01.
+
+**One request per key at a time.** A key already in flight is skipped even when it is dirty, so two
+requests for one cell can never race and land out of order.
+
+**Failure never rolls back.** Not local state, not the queue. `discard(key)` is the only way to
+lose a write, and you have to call it.
+
+## Preconditions — read these, they are not assumptions
+
+- **Keys must be independent.** Writes go out in parallel, in no particular order, last-write-wins
+  per key. If key `b` is only valid once key `a` has landed, this is the wrong tool.
+- **`equals` defaults to `Object.is`, so an object value mutated *in place* is not an edit.**
+  Replace the object (`cells.A1 = { ...cells.A1, text }`), pass your own `equals`, or call
+  `outbox.set('A1', value)` — which always queues.
+- **The flush on tab-hidden is best-effort.** `visibilitychange → hidden` is used rather than
+  `beforeunload`, which mobile browsers routinely skip — but the page can still be frozen before
+  the request leaves. `pending` is exposed so your app can *warn* instead of failing silently.
+- **A key deleted from the source keeps its queued write.** Losing it silently is exactly what this
+  library refuses to do. Call `discard(key)` if you mean it.
+- **Outside an effect scope there is no cleanup.** Called in `setup()` (or any `effectScope`) the
+  timer and the listener are released on dispose. Called at module top level, they are not.
+
+## What it will not do
+
+Each of these is a step towards RxDB / Replicache / TanStack DB, where a single small package loses
+on day one:
+
+- **No persistence / IndexedDB.** Hook `pending` yourself:
+  ```ts
+  watch(() => outbox.pending, (keys) => {
+    localStorage.setItem('drafts', JSON.stringify(Object.fromEntries(keys.map((k) => [k, cells[k]]))))
+  })
+  ```
+- **No offline detection.** Offline is not a special case, it is a failing flush — the retry
+  behaviour already covers it.
+- **No conflict resolution or merge.** That needs a CRDT.
+- **No reading.** It is write-only; nothing here fetches, caches or invalidates.
+- **No ordered operation log and no cross-key transactions.**
+- **No HTTP client, transport or `sendBeacon`.** You pass a function; what it does is your business.
+- **No schema and no collections.**
+
+## Types
+
+Everything is exported by name — nothing to recreate:
+
+```ts
+import type {
+  WriteBehind,
+  WriteBehindBaseOptions,
+  WriteBehindBatchOutcome,
+  WriteBehindBatchWriter,
+  WriteBehindFailure,
+  WriteBehindKey,
+  WriteBehindOptions,
+  WriteBehindRetryOptions,
+  WriteBehindSource,
+  WriteBehindWriter,
+} from 'vue-write-behind'
+```
+
+`T` is inferred from the record, so `useWriteBehind(reactive<Record<string, number>>({}), write)`
+gives you a `write` whose value is a `number`.
+
+## Development
+
+```bash
+npm test               # vitest: the state machine, the clock, the adapters, the composable
+                       # (jsdom on Vue 3.5 and 3.3, plus an SSR project in node)
+npm run typecheck      # tsc over source and tests
+npm run build          # tsup → dist/*.min.js + .cjs + .d.ts
+npm run check:dist     # drive the BUILT artifact on real timers — dist goes stale silently
+npm run check:browser  # headless Chrome: type into a real input while a slow server answers,
+                       # and read the value back out of the live DOM
+```
+
+`playground.html` is that browser check's page — serve the package directory and open it to try the
+three cards by hand (`npm run check:browser` builds, serves and drives it for you). The claim it
+exists to prove is the one no unit test can make: **the cell does not jump.**
+
+`ARCHITECTURE.md` has the module map and the one invariant the split protects.
+
+## License
+
+MIT © Ozgur Seyidoglu

package/dist/vueWriteBehind.d.ts

@@ -0,0 +1,172 @@
+import { Ref } from 'vue';
+
+/**
+ * Public types.
+ *
+ * Leaf module: imports nothing at runtime (the single `import type { Ref }`
+ * is erased at compile time), so it can be copied on its own.
+ */
+
+/** Outbox keys are plain strings — the keys of the reactive record you pass in. */
+type WriteBehindKey = string;
+/**
+ * The record whose keys are written back. Either a `reactive()` object or a
+ * `ref()` holding a plain object.
+ *
+ * **Precondition — keys are independent.** Everything in this library relies on
+ * it: writes go out in parallel, in no particular order, last-write-wins per
+ * key. If key `b` is only valid once key `a` has landed, this is the wrong tool
+ * (that needs an ordered operation log — see the README's refuse list).
+ */
+type WriteBehindSource<T> = Record<WriteBehindKey, T> | Ref<Record<WriteBehindKey, T>>;
+/**
+ * Per-key writer — the common form.
+ *
+ * Called with the value read out of the outbox **at send time**, never a value
+ * captured when the edit happened. Reject (or throw) to fail the key; the
+ * return value is otherwise ignored on purpose — the server's reply never
+ * touches local state.
+ */
+type WriteBehindWriter<T> = (value: T, key: WriteBehindKey) => unknown;
+/** What a batch writer may resolve to in order to fail part of the batch. */
+interface WriteBehindBatchOutcome {
+    /** Keys the server did not accept. Everything else in the batch is treated as written. */
+    failed?: readonly WriteBehindKey[];
+}
+/**
+ * Batch writer — one call for every due key.
+ *
+ * Throw/reject and the **whole batch** stays pending. Resolve with
+ * `{ failed: [...] }` to fail part of it. Resolve with anything else (including
+ * `undefined`) and the whole batch is treated as written.
+ */
+type WriteBehindBatchWriter<T> = (entries: [WriteBehindKey, T][]) => WriteBehindBatchOutcome | void | Promise<WriteBehindBatchOutcome | void>;
+/** Per-key exponential backoff. Defaults produce 1s → 2 → 4 → 8 → 16 → 30s, capped. */
+interface WriteBehindRetryOptions {
+    /** Delay after the first failure, in ms. Default `1000`. */
+    initialDelay?: number;
+    /** Ceiling for the delay, in ms. Default `30000`. */
+    maxDelay?: number;
+    /** Multiplier applied per consecutive failure. Default `2`. */
+    factor?: number;
+}
+/** One key's latest failure. Only the newest error per key is kept. */
+interface WriteBehindFailure {
+    key: WriteBehindKey;
+    /** Whatever the writer rejected with. */
+    error: unknown;
+    /** Consecutive failures — resets on success, on `retry()`, and on `discard()`. */
+    attempts: number;
+    /**
+     * Epoch ms of the next automatic attempt, or `undefined` when no automatic
+     * attempt is scheduled (`retry: false`) — that key needs an edit or an
+     * explicit `retry(key)`.
+     */
+    retryAt: number | undefined;
+}
+/** Options shared by both writer shapes. Every one of them is an opt-*out*. */
+interface WriteBehindBaseOptions<T> {
+    /** Flush cadence in ms. Default `1000`. The timer only runs while work is queued. */
+    interval?: number;
+    /**
+     * Per-key quiet period in ms before a key becomes eligible. Default `0`
+     * (the `interval` already coalesces a burst of edits into one write).
+     * An edit never *shortens* an active backoff.
+     */
+    debounce?: number;
+    /**
+     * Retry policy, or `false` to stop retrying a key after a failure. Retrying
+     * is the default because dropping a user's edit is the one unacceptable
+     * outcome. With `false` the key stays pending and listed in `failed` — it is
+     * never discarded — until the next edit or an explicit `retry(key)`.
+     */
+    retry?: WriteBehindRetryOptions | false;
+    /**
+     * Flush when the tab is hidden (`visibilitychange`). Default `true`.
+     * Best-effort only: the browser may kill the page before the request leaves.
+     */
+    flushOnHidden?: boolean;
+    /**
+     * Narrows what the source watcher picks up. An allow-list or a predicate.
+     * Default: every key. `set()` is explicit and ignores this filter.
+     */
+    keys?: readonly WriteBehindKey[] | ((key: WriteBehindKey) => boolean);
+    /**
+     * Change detection for a key's value. Default `Object.is`.
+     *
+     * With the default, mutating an object value **in place** is not an edit —
+     * replace the object, or call `set(key, value)`.
+     */
+    equals?: (a: T, b: T) => boolean;
+}
+/**
+ * Options for `useWriteBehind`. Exactly one writer: `write` (per key) or
+ * `flush` (batched).
+ */
+type WriteBehindOptions<T> = WriteBehindBaseOptions<T> & ({
+    write: WriteBehindWriter<T>;
+    flush?: undefined;
+} | {
+    write?: undefined;
+    flush: WriteBehindBatchWriter<T>;
+});
+/**
+ * The reactive store `useWriteBehind` returns. Read the fields straight in a
+ * template; they are recomputed on every state change.
+ */
+interface WriteBehind<T> {
+    /**
+     * Every key with an unsaved change, **including** the ones currently on the
+     * wire. This is the "you have unsaved work" number.
+     */
+    readonly pending: readonly WriteBehindKey[];
+    /** The subset of `pending` currently in flight. */
+    readonly inFlight: readonly WriteBehindKey[];
+    /** Latest failure per failing key. */
+    readonly failed: readonly WriteBehindFailure[];
+    /** `true` while anything is in flight. */
+    readonly isSyncing: boolean;
+    /**
+     * Write a value into the source **and** queue it. Always queues, even when
+     * the value is unchanged — the escape hatch for values `equals` cannot see
+     * (an object mutated in place) and for keys excluded by `keys`.
+     */
+    set: (key: WriteBehindKey, value: T) => void;
+    /**
+     * Send every pending key that is not already in flight, ignoring the
+     * `debounce` and backoff clocks. Resolves when the requests it started have
+     * settled — keys edited *during* that flight are still pending afterwards.
+     */
+    flush: () => Promise<void>;
+    /**
+     * Clear the backoff (and the recorded failure) for one key, or all of them,
+     * so they go out on the next tick. The only way to revive a key that failed
+     * under `retry: false`.
+     */
+    retry: (key?: WriteBehindKey) => void;
+    /**
+     * Drop a key's pending write. **The only operation in this library that
+     * loses a write** — nothing else ever discards one.
+     */
+    discard: (key: WriteBehindKey) => void;
+}
+
+/**
+ * Write-behind cache for a reactive record. Local state stays authoritative;
+ * the writer's result is discarded on purpose.
+ *
+ * @example
+ * ```ts
+ * const cells = reactive<Record<string, string>>({ A1: 'foo' })
+ * const outbox = useWriteBehind(cells, (value, key) => api.put(`/cell/${key}`, value))
+ * cells.A1 = 'bar' // that is the whole API
+ * ```
+ *
+ * @param source A `reactive()` record (or a `ref()` holding one). Its keys must
+ *   be independent of each other — writes go out in parallel, last-write-wins.
+ * @param writerOrOptions The per-key writer, or an options object carrying
+ *   either `write` (per key) or `flush` (batched).
+ */
+declare function useWriteBehind<T>(source: WriteBehindSource<T>, writerOrOptions: WriteBehindWriter<T> | WriteBehindOptions<T>): WriteBehind<T>;
+
+export { type WriteBehind, type WriteBehindBaseOptions, type WriteBehindBatchOutcome, type WriteBehindBatchWriter, type WriteBehindFailure, type WriteBehindKey, type WriteBehindOptions, type WriteBehindRetryOptions, type WriteBehindSource, type WriteBehindWriter, useWriteBehind };

package/dist/vueWriteBehind.min.cjs

@@ -0,0 +1,2 @@
+"use strict";var g=Object.defineProperty;var R=Object.getOwnPropertyDescriptor;var I=Object.getOwnPropertyNames;var C=Object.prototype.hasOwnProperty;var _=(n,r)=>{for(var e in r)g(n,e,{get:r[e],enumerable:!0})},M=(n,r,e,f)=>{if(r&&typeof r=="object"||typeof r=="function")for(let s of I(r))!C.call(n,s)&&s!==e&&g(n,s,{get:()=>r[s],enumerable:!(f=R(r,s))||f.enumerable});return n};var P=n=>M(g({},"__esModule",{value:!0}),n);var Y={};_(Y,{useWriteBehind:()=>A});module.exports=P(Y);var b=require("vue");var U=n=>n?n.failed??[]:[];function E({outbox:n,writer:r,now:e}){let f=new Set,s=l=>{f.add(l),l.then(()=>f.delete(l))},B=async(l,o)=>{try{await l(o.value,o.key),n.settle(o.key,o.sentVersion)}catch(p){n.fail(o.key,o.sentVersion,p,e())}},T=async(l,o)=>{let p=o.map(h=>[h.key,h.value]);try{let h=new Set(U(await l(p)));for(let a of o)h.has(a.key)?n.fail(a.key,a.sentVersion,new Error(`vue-write-behind: batch flush reported "${a.key}" as failed`),e()):n.settle(a.key,a.sentVersion)}catch(h){for(let a of o)n.fail(a.key,a.sentVersion,h,e())}},W=(l=!1)=>{let o=n.take(l?Number.POSITIVE_INFINITY:e());if(o.length!==0)if(r.flush)s(T(r.flush,o));else for(let p of o)s(B(r.write,p))};return{dispatch:W,flush:async()=>{W(!0),await Promise.all([...f])}}}var x=require("vue"),K=()=>typeof window>"u"||typeof document>"u";function S(n){if(K())return()=>{};let r=()=>{document.visibilityState==="hidden"&&n()};return document.addEventListener("visibilitychange",r),()=>document.removeEventListener("visibilitychange",r)}function w(n){(0,x.getCurrentScope)()&&(0,x.onScopeDispose)(n)}function D({retryDelay:n,onChange:r}){let e=new Map,f=0,s=()=>r?.();return{set:(i,d,t=0)=>{f+=1;let u=e.get(i);u?(u.value=d,u.version=f,u.blocked=!1,u.dueAt=Math.max(u.dueAt,t)):e.set(i,{value:d,version:f,sentVersion:void 0,attempts:0,error:void 0,dueAt:t,blocked:!1}),s()},take:i=>{let d=[];for(let[t,u]of e)u.sentVersion===void 0&&(u.blocked||u.dueAt>i||(u.sentVersion=u.version,d.push({key:t,value:u.value,sentVersion:u.version})));return d.length>0&&s(),d},settle:(i,d)=>{let t=e.get(i);!t||t.sentVersion!==d||(t.version===d?e.delete(i):(t.sentVersion=void 0,t.attempts=0,t.error=void 0,t.dueAt=0,t.blocked=!1),s())},fail:(i,d,t,u)=>{let y=e.get(i);if(!y||y.sentVersion!==d)return;y.sentVersion=void 0,y.attempts+=1,y.error=t;let k=n(y.attempts);k===void 0?y.blocked=!0:y.dueAt=u+k,s()},discard:i=>{e.delete(i)&&s()},clearBackoff:i=>{let d=i===void 0?e.values():[e.get(i)];for(let t of d)t&&(t.attempts=0,t.error=void 0,t.dueAt=0,t.blocked=!1);s()},pendingKeys:()=>[...e.keys()],inFlightKeys:()=>[...e].filter(([,i])=>i.sentVersion!==void 0).map(([i])=>i),failures:()=>{let i=[];for(let[d,t]of e)t.attempts!==0&&i.push({key:d,error:t.error,attempts:t.attempts,retryAt:t.blocked?void 0:t.dueAt});return i},isEmpty:()=>e.size===0,hasScheduledWork:()=>{for(let i of e.values())if(i.sentVersion===void 0&&!i.blocked)return!0;return!1}}}function V(n){if(n===!1)return()=>{};let{initialDelay:r=1e3,maxDelay:e=3e4,factor:f=2}=n??{};return s=>Math.min(r*f**(s-1),e)}function L({interval:n,onTick:r}){let e;return{start:()=>{e===void 0&&(e=setInterval(r,n))},stop:()=>{e!==void 0&&(clearInterval(e),e=void 0)},isRunning:()=>e!==void 0}}var N=1e3;function A(n,r){let e=typeof r=="function"?{write:r}:r,f=e.flush?{flush:e.flush}:{write:e.write},s=e.interval??N,B=e.debounce??0,T=e.equals??Object.is,W=e.keys,l=W===void 0?()=>!0:typeof W=="function"?W:c=>W.includes(c),o=D({retryDelay:V(e.retry),onChange:()=>y()}),p=E({outbox:o,writer:f,now:Date.now}),h=L({interval:s,onTick:()=>p.dispatch()}),a=()=>(0,b.isRef)(n)?n.value:n,i=new Map;for(let[c,m]of Object.entries(a()))l(c)&&i.set(c,{value:m});let d=()=>{let c=a(),m=B>0?Date.now()+B:0;for(let[v,O]of Object.entries(c)){if(!l(v))continue;let F=i.get(v);F&&T(F.value,O)||(i.set(v,{value:O}),o.set(v,O,m))}for(let v of i.keys())v in c||i.delete(v)},t=(0,b.shallowReactive)({pending:[],inFlight:[],failed:[],isSyncing:!1,set:(c,m)=>{a()[c]=m,i.set(c,{value:m}),o.set(c,m,B>0?Date.now()+B:0)},flush:()=>(d(),p.flush()),retry:c=>o.clearBackoff(c),discard:c=>o.discard(c)}),u=()=>{let c=o.inFlightKeys();t.pending=o.pendingKeys(),t.inFlight=c,t.failed=o.failures(),t.isSyncing=c.length>0};function y(){u(),!K()&&(o.hasScheduledWork()?h.start():h.stop())}(0,b.watch)(a,d,{deep:!0});let k=e.flushOnHidden===!1?()=>{}:S(()=>{t.flush()});return w(()=>{h.stop(),k()}),t}0&&(module.exports={useWriteBehind});
+//# sourceMappingURL=vueWriteBehind.min.cjs.map

package/dist/vueWriteBehind.min.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../vueWriteBehind.ts","../src/useWriteBehind.ts","../src/flush.ts","../src/lifecycle.ts","../src/outbox.ts","../src/scheduler.ts"],"sourcesContent":["/**\n * Build entry point — re-exports the public surface from `src/`.\n *\n * The split keeps each concern in a single-purpose module (types / outbox /\n * scheduler / flush / lifecycle / the composable) without changing the bundle:\n * tsup follows this entry and emits the same minified files. See\n * ARCHITECTURE.md for the module map and the invariant it protects.\n */\nexport { useWriteBehind } from './src'\nexport type {\n  WriteBehind,\n  WriteBehindBaseOptions,\n  WriteBehindBatchOutcome,\n  WriteBehindBatchWriter,\n  WriteBehindFailure,\n  WriteBehindKey,\n  WriteBehindOptions,\n  WriteBehindRetryOptions,\n  WriteBehindSource,\n  WriteBehindWriter,\n} from './src'\n","/**\n * The Vue surface — watches the source record, mirrors the outbox into a\n * reactive store, and owns when the clock runs.\n *\n * It reads local state and never writes it back: nothing here applies a server\n * response to the source, because the whole point is that the cell the user is\n * typing in cannot be overwritten from the network.\n */\nimport { isRef, shallowReactive, watch } from 'vue'\nimport { createFlusher, type ResolvedWriter } from './flush'\nimport { isServer, onDispose, onTabHidden } from './lifecycle'\nimport { createOutbox } from './outbox'\nimport { createBackoff, createScheduler } from './scheduler'\nimport type {\n  WriteBehind,\n  WriteBehindKey,\n  WriteBehindOptions,\n  WriteBehindSource,\n  WriteBehindWriter,\n} from './types'\n\nconst DEFAULT_INTERVAL = 1000\n\n/** The store as this module holds it: same shape, writable. */\ntype MutableWriteBehind<T> = { -readonly [K in keyof WriteBehind<T>]: WriteBehind<T>[K] }\n\n/**\n * Write-behind cache for a reactive record. Local state stays authoritative;\n * the writer's result is discarded on purpose.\n *\n * @example\n * ```ts\n * const cells = reactive<Record<string, string>>({ A1: 'foo' })\n * const outbox = useWriteBehind(cells, (value, key) => api.put(`/cell/${key}`, value))\n * cells.A1 = 'bar' // that is the whole API\n * ```\n *\n * @param source A `reactive()` record (or a `ref()` holding one). Its keys must\n *   be independent of each other — writes go out in parallel, last-write-wins.\n * @param writerOrOptions The per-key writer, or an options object carrying\n *   either `write` (per key) or `flush` (batched).\n */\nexport function useWriteBehind<T>(\n  source: WriteBehindSource<T>,\n  writerOrOptions: WriteBehindWriter<T> | WriteBehindOptions<T>,\n): WriteBehind<T> {\n  const options: WriteBehindOptions<T> =\n    typeof writerOrOptions === 'function' ? { write: writerOrOptions } : writerOrOptions\n\n  const writer: ResolvedWriter<T> = options.flush\n    ? { flush: options.flush }\n    : { write: options.write }\n\n  const interval = options.interval ?? DEFAULT_INTERVAL\n  const debounce = options.debounce ?? 0\n  const equals = options.equals ?? Object.is\n  const keys = options.keys\n  const tracked: (key: WriteBehindKey) => boolean =\n    keys === undefined\n      ? () => true\n      : typeof keys === 'function'\n        ? keys\n        : (key) => keys.includes(key)\n\n  const outbox = createOutbox<T>({\n    retryDelay: createBackoff(options.retry),\n    onChange: () => onOutboxChange(),\n  })\n  const flusher = createFlusher<T>({ outbox, writer, now: Date.now })\n  const scheduler = createScheduler({ interval, onTick: () => flusher.dispatch() })\n\n  const readSource = (): Record<WriteBehindKey, T> => (isRef(source) ? source.value : source)\n\n  // Last value seen per key. Boxed so `T` may legitimately be `undefined`\n  // without `has`/`get` disagreeing.\n  const shadow = new Map<WriteBehindKey, { value: T }>()\n  for (const [key, value] of Object.entries(readSource())) {\n    if (!tracked(key)) continue\n    // Seeded, NOT queued: whatever the record starts with came from the server.\n    shadow.set(key, { value })\n  }\n\n  const syncFromSource = (): void => {\n    const current = readSource()\n    const dueAt = debounce > 0 ? Date.now() + debounce : 0\n    for (const [key, value] of Object.entries(current)) {\n      if (!tracked(key)) continue\n      const seen = shadow.get(key)\n      if (seen && equals(seen.value, value)) continue\n      shadow.set(key, { value })\n      outbox.set(key, value, dueAt)\n    }\n    // A key deleted from the source stops being watched, but its queued write\n    // survives — losing it silently is the one outcome this library refuses.\n    // `discard(key)` is how a consumer drops it on purpose.\n    for (const key of shadow.keys()) {\n      if (!(key in current)) shadow.delete(key)\n    }\n  }\n\n  const store = shallowReactive<MutableWriteBehind<T>>({\n    pending: [],\n    inFlight: [],\n    failed: [],\n    isSyncing: false,\n    set: (key, value) => {\n      readSource()[key] = value\n      shadow.set(key, { value })\n      // Unconditional: `set` is the escape hatch for a change `equals` cannot\n      // see (an object mutated in place) and for keys `keys` filters out.\n      outbox.set(key, value, debounce > 0 ? Date.now() + debounce : 0)\n    },\n    flush: () => {\n      // The source watcher is a `pre` watcher, so an edit made in this tick has\n      // not been picked up yet — read it now or a save button next to an input\n      // would miss the last keystroke.\n      syncFromSource()\n      return flusher.flush()\n    },\n    retry: (key) => outbox.clearBackoff(key),\n    discard: (key) => outbox.discard(key),\n  })\n\n  const syncStore = (): void => {\n    const inFlight = outbox.inFlightKeys()\n    store.pending = outbox.pendingKeys()\n    store.inFlight = inFlight\n    store.failed = outbox.failures()\n    store.isSyncing = inFlight.length > 0\n  }\n\n  function onOutboxChange(): void {\n    syncStore()\n    // Never start a timer on the server, and never leave one running with\n    // nothing to send — an idle app must not hold the event loop open.\n    if (isServer()) return\n    if (outbox.hasScheduledWork()) scheduler.start()\n    else scheduler.stop()\n  }\n\n  watch(readSource, syncFromSource, { deep: true })\n\n  const stopHiddenListener =\n    options.flushOnHidden === false ? () => {} : onTabHidden(() => void store.flush())\n\n  onDispose(() => {\n    scheduler.stop()\n    stopHiddenListener()\n  })\n\n  return store\n}\n","/**\n * The writer adapters — the only place a request is made.\n *\n * Two shapes, one rule: whatever the network does, the outcome is reported back\n * to the outbox and nothing else. This module never clears a key itself, never\n * looks at what a writer resolved with, and never touches local state. The\n * server's reply is discarded on purpose.\n *\n * Per-key writes are independent, so they run in parallel and each key settles\n * the moment its own request returns (`Promise.allSettled` semantics — one\n * rejection can neither block nor fail a sibling). That is safe only because\n * key independence is a stated precondition of the library.\n */\nimport type { Outbox, OutboxEntry } from './outbox'\nimport type {\n  WriteBehindBatchOutcome,\n  WriteBehindBatchWriter,\n  WriteBehindKey,\n  WriteBehindWriter,\n} from './types'\n\n/** Exactly one writer, already narrowed from the options. */\nexport type ResolvedWriter<T> =\n  | { write: WriteBehindWriter<T>; flush?: undefined }\n  | { write?: undefined; flush: WriteBehindBatchWriter<T> }\n\nexport interface FlusherConfig<T> {\n  outbox: Outbox<T>\n  writer: ResolvedWriter<T>\n  /** Injected so the flusher owns no clock of its own. */\n  now: () => number\n}\n\nexport interface Flusher {\n  /** Send everything due. `force` ignores the debounce and backoff clocks. */\n  dispatch: (force?: boolean) => void\n  /** Force a dispatch and wait for every request currently in the air. */\n  flush: () => Promise<void>\n}\n\nconst failedKeysOf = (outcome: WriteBehindBatchOutcome | void): readonly WriteBehindKey[] => {\n  if (!outcome) return []\n  return outcome.failed ?? []\n}\n\nexport function createFlusher<T>({ outbox, writer, now }: FlusherConfig<T>): Flusher {\n  const inAir = new Set<Promise<void>>()\n\n  const track = (flight: Promise<void>): void => {\n    inAir.add(flight)\n    void flight.then(() => inAir.delete(flight))\n  }\n\n  const runPerKey = async (write: WriteBehindWriter<T>, entry: OutboxEntry<T>): Promise<void> => {\n    try {\n      await write(entry.value, entry.key)\n      outbox.settle(entry.key, entry.sentVersion)\n    } catch (error) {\n      outbox.fail(entry.key, entry.sentVersion, error, now())\n    }\n  }\n\n  const runBatch = async (\n    flushAll: WriteBehindBatchWriter<T>,\n    batch: OutboxEntry<T>[],\n  ): Promise<void> => {\n    const entries = batch.map((entry): [WriteBehindKey, T] => [entry.key, entry.value])\n    try {\n      const failed = new Set(failedKeysOf(await flushAll(entries)))\n      for (const entry of batch) {\n        if (failed.has(entry.key)) {\n          outbox.fail(\n            entry.key,\n            entry.sentVersion,\n            new Error(`vue-write-behind: batch flush reported \"${entry.key}\" as failed`),\n            now(),\n          )\n        } else {\n          outbox.settle(entry.key, entry.sentVersion)\n        }\n      }\n    } catch (error) {\n      // One rejection means the transport failed, so nothing in the batch is\n      // known to have landed — every key stays pending.\n      for (const entry of batch) outbox.fail(entry.key, entry.sentVersion, error, now())\n    }\n  }\n\n  const dispatch = (force = false): void => {\n    const batch = outbox.take(force ? Number.POSITIVE_INFINITY : now())\n    if (batch.length === 0) return\n    // The union guarantees exactly one of the two is present.\n    if (writer.flush) track(runBatch(writer.flush, batch))\n    else for (const entry of batch) track(runPerKey(writer.write, entry))\n  }\n\n  return {\n    dispatch,\n    flush: async () => {\n      dispatch(true)\n      await Promise.all([...inAir])\n    },\n  }\n}\n","/**\n * Everything with a lifetime outside the outbox: the environment check, the\n * tab-hidden hook and scope disposal.\n *\n * `visibilitychange` rather than `beforeunload`: mobile browsers routinely\n * discard a page without ever firing `beforeunload`, and Safari fires\n * `pagehide` instead. `visibilitychange → hidden` is the one signal that fires\n * on every platform — and it is still only best-effort, because the page can be\n * frozen before the request leaves. `pending` is exposed so an app can warn.\n */\nimport { getCurrentScope, onScopeDispose } from 'vue'\n\n/** True when there is no DOM — SSR, or a worker. */\nexport const isServer = (): boolean =>\n  typeof window === 'undefined' || typeof document === 'undefined'\n\n/** Subscribe to the tab going hidden. Returns the unsubscribe; a no-op on the server. */\nexport function onTabHidden(handler: () => void): () => void {\n  if (isServer()) return () => {}\n  const listener = (): void => {\n    if (document.visibilityState === 'hidden') handler()\n  }\n  document.addEventListener('visibilitychange', listener)\n  return () => document.removeEventListener('visibilitychange', listener)\n}\n\n/**\n * Register cleanup with the surrounding effect scope, if there is one. Called\n * outside `setup()` (imperative code, tests) there is nothing to hook, and Vue\n * would warn — so guard rather than warn. `getCurrentScope()` exists in 3.0;\n * `onScopeDispose`'s `failSilently` argument only arrived in 3.5.\n */\nexport function onDispose(cleanup: () => void): void {\n  if (getCurrentScope()) onScopeDispose(cleanup)\n}\n","/**\n * The outbox: the pure key/version/dirty state machine.\n *\n * No Vue, no timers, no I/O — every clock reading arrives as an argument. This\n * is where the whole library's correctness lives, which is why it is testable\n * without mounting anything.\n *\n * **Invariant: this module is the only place a dirty key is ever cleared.**\n * Everything else (scheduler, flush, the composable) can only ask.\n *\n * The rule that makes it correct: a key carries a **monotonic version**, and a\n * write records the version it was sent at. A success clears the key only when\n * the version has not moved since. A boolean dirty flag cannot express that —\n * the response would clear a flag a newer edit had set, and that edit would be\n * gone with nothing on screen to say so.\n */\nimport type { WriteBehindFailure, WriteBehindKey } from './types'\n\n/** One entry handed to a writer. `value` is read out of the map at take time. */\nexport interface OutboxEntry<T> {\n  key: WriteBehindKey\n  value: T\n  /**\n   * The version this send is for. Hand it back to `settle`/`fail` — it is the\n   * flight's identity, so a response from a superseded flight (the key was\n   * discarded and re-queued, or `retry()` re-armed it) is ignored instead of\n   * clearing the wrong write.\n   */\n  sentVersion: number\n}\n\ninterface Entry<T> {\n  value: T\n  /** Bumped on every edit. Unique across the whole outbox, never reused. */\n  version: number\n  /** The version currently on the wire, or `undefined` when nothing is. */\n  sentVersion: number | undefined\n  /** Consecutive failures. */\n  attempts: number\n  error: unknown\n  /** Epoch ms before which the key is not eligible. `0` = eligible now. */\n  dueAt: number\n  /** Failed with retries disabled: needs a fresh edit or an explicit retry. */\n  blocked: boolean\n}\n\nexport interface OutboxConfig {\n  /**\n   * Backoff for the n-th consecutive failure, in ms. Returning `undefined`\n   * blocks the key instead of scheduling an attempt (`retry: false`).\n   */\n  retryDelay: (attempts: number) => number | undefined\n  /** Called after every state transition. */\n  onChange?: () => void\n}\n\nexport interface Outbox<T> {\n  /**\n   * Queue a value. `dueAt` (epoch ms) holds the key back — used for `debounce`.\n   * It can only ever push the key further out, never pull an active backoff in.\n   */\n  set: (key: WriteBehindKey, value: T, dueAt?: number) => void\n  /**\n   * Claim every key that is due at `now`, not in flight and not blocked,\n   * marking each in flight. Pass `Infinity` to ignore the clocks (`flush()`).\n   */\n  take: (now: number) => OutboxEntry<T>[]\n  /** The write landed. Clears the key **only if** its version has not moved. */\n  settle: (key: WriteBehindKey, sentVersion: number) => void\n  /** The write failed. Never clears the key. */\n  fail: (key: WriteBehindKey, sentVersion: number, error: unknown, now: number) => void\n  /** Forget a key's pending write entirely — the one operation that loses one. */\n  discard: (key: WriteBehindKey) => void\n  /** Make a key (or all of them) eligible again and forget its failure. */\n  clearBackoff: (key?: WriteBehindKey) => void\n  /** Every unconfirmed key, in-flight ones included. */\n  pendingKeys: () => WriteBehindKey[]\n  inFlightKeys: () => WriteBehindKey[]\n  failures: () => WriteBehindFailure[]\n  isEmpty: () => boolean\n  /** True while some key could still become eligible — i.e. the clock is worth running. */\n  hasScheduledWork: () => boolean\n}\n\nexport function createOutbox<T>({ retryDelay, onChange }: OutboxConfig): Outbox<T> {\n  const entries = new Map<WriteBehindKey, Entry<T>>()\n  // One counter for the whole outbox rather than one per key: versions are then\n  // never reused, so a response from a discarded flight can never be mistaken\n  // for the current one on a key that was queued again in the meantime.\n  let version = 0\n\n  const notify = () => onChange?.()\n\n  const set = (key: WriteBehindKey, value: T, dueAt = 0): void => {\n    version += 1\n    const entry = entries.get(key)\n    if (entry) {\n      entry.value = value\n      entry.version = version\n      // A new value is a new write, not a retry — it re-arms a blocked key…\n      entry.blocked = false\n      // …but it must not shorten an active backoff, or a user typing into a\n      // failing endpoint would fire one request per keystroke.\n      entry.dueAt = Math.max(entry.dueAt, dueAt)\n    } else {\n      entries.set(key, {\n        value,\n        version,\n        sentVersion: undefined,\n        attempts: 0,\n        error: undefined,\n        dueAt,\n        blocked: false,\n      })\n    }\n    notify()\n  }\n\n  const take = (now: number): OutboxEntry<T>[] => {\n    const batch: OutboxEntry<T>[] = []\n    for (const [key, entry] of entries) {\n      if (entry.sentVersion !== undefined) continue // already on the wire (H5)\n      if (entry.blocked) continue\n      if (entry.dueAt > now) continue\n      entry.sentVersion = entry.version\n      batch.push({ key, value: entry.value, sentVersion: entry.version })\n    }\n    if (batch.length > 0) notify()\n    return batch\n  }\n\n  const settle = (key: WriteBehindKey, sentVersion: number): void => {\n    const entry = entries.get(key)\n    if (!entry || entry.sentVersion !== sentVersion) return\n    if (entry.version === sentVersion) {\n      // Nothing was typed while this was in flight: the key is saved.\n      entries.delete(key)\n    } else {\n      // It was. Keep it dirty and send the newer value next tick; the server is\n      // evidently healthy, so drop the backoff.\n      entry.sentVersion = undefined\n      entry.attempts = 0\n      entry.error = undefined\n      entry.dueAt = 0\n      entry.blocked = false\n    }\n    notify()\n  }\n\n  const fail = (key: WriteBehindKey, sentVersion: number, error: unknown, now: number): void => {\n    const entry = entries.get(key)\n    if (!entry || entry.sentVersion !== sentVersion) return\n    entry.sentVersion = undefined\n    entry.attempts += 1\n    entry.error = error\n    const delay = retryDelay(entry.attempts)\n    if (delay === undefined) entry.blocked = true\n    else entry.dueAt = now + delay\n    notify()\n  }\n\n  const discard = (key: WriteBehindKey): void => {\n    if (!entries.delete(key)) return\n    notify()\n  }\n\n  const clearBackoff = (key?: WriteBehindKey): void => {\n    const targets = key === undefined ? entries.values() : [entries.get(key)]\n    for (const entry of targets) {\n      if (!entry) continue\n      entry.attempts = 0\n      entry.error = undefined\n      entry.dueAt = 0\n      entry.blocked = false\n    }\n    notify()\n  }\n\n  const failures = (): WriteBehindFailure[] => {\n    const list: WriteBehindFailure[] = []\n    for (const [key, entry] of entries) {\n      if (entry.attempts === 0) continue\n      list.push({\n        key,\n        error: entry.error,\n        attempts: entry.attempts,\n        retryAt: entry.blocked ? undefined : entry.dueAt,\n      })\n    }\n    return list\n  }\n\n  const hasScheduledWork = (): boolean => {\n    for (const entry of entries.values()) {\n      if (entry.sentVersion === undefined && !entry.blocked) return true\n    }\n    return false\n  }\n\n  return {\n    set,\n    take,\n    settle,\n    fail,\n    discard,\n    clearBackoff,\n    pendingKeys: () => [...entries.keys()],\n    inFlightKeys: () =>\n      [...entries].filter(([, entry]) => entry.sentVersion !== undefined).map(([key]) => key),\n    failures,\n    isEmpty: () => entries.size === 0,\n    hasScheduledWork,\n  }\n}\n","/**\n * The clock — the flush interval and the per-key backoff curve.\n *\n * Deliberately ignorant of writes and keys: it only knows \"call this every N\n * ms\" and \"how long after the n-th failure\". The decision to run at all belongs\n * to `useWriteBehind`, which starts it when work is queued and stops it when\n * there is none — an idle app must not hold a timer open.\n */\nimport type { WriteBehindRetryOptions } from './types'\n\nconst DEFAULT_INITIAL_DELAY = 1000\nconst DEFAULT_MAX_DELAY = 30000\nconst DEFAULT_FACTOR = 2\n\n/**\n * Backoff for the n-th consecutive failure (1-based), in ms — or `undefined`\n * when retries are off, which parks the key until it is edited or retried.\n *\n * The cap matters: `factor ** attempts` reaches Infinity within a couple of\n * dozen failures, and a key parked at `Infinity` would never be retried, which\n * is exactly the silent write loss this library exists to prevent.\n */\nexport function createBackoff(\n  retry: WriteBehindRetryOptions | false | undefined,\n): (attempts: number) => number | undefined {\n  if (retry === false) return () => undefined\n  const {\n    initialDelay = DEFAULT_INITIAL_DELAY,\n    maxDelay = DEFAULT_MAX_DELAY,\n    factor = DEFAULT_FACTOR,\n  } = retry ?? {}\n  return (attempts) => Math.min(initialDelay * factor ** (attempts - 1), maxDelay)\n}\n\nexport interface SchedulerConfig {\n  interval: number\n  onTick: () => void\n}\n\nexport interface Scheduler {\n  /** Idempotent: calling it while running keeps the current phase. */\n  start: () => void\n  stop: () => void\n  isRunning: () => boolean\n}\n\nexport function createScheduler({ interval, onTick }: SchedulerConfig): Scheduler {\n  let timer: ReturnType<typeof setInterval> | undefined\n\n  return {\n    start: () => {\n      // Restarting would reset the phase, so a fast typist could push the flush\n      // out indefinitely — the interval has to be a fixed window, not a debounce.\n      if (timer !== undefined) return\n      timer = setInterval(onTick, interval)\n    },\n    stop: () => {\n      if (timer === undefined) return\n      clearInterval(timer)\n      timer = undefined\n    },\n    isRunning: () => timer !== undefined,\n  }\n}\n"],"mappings":"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","names":["vueWriteBehind_exports","__export","useWriteBehind","__toCommonJS","import_vue","failedKeysOf","outcome","createFlusher","outbox","writer","now","inAir","track","flight","runPerKey","write","entry","error","runBatch","flushAll","batch","entries","failed","dispatch","force","import_vue","isServer","onTabHidden","handler","listener","onDispose","cleanup","createOutbox","retryDelay","onChange","entries","version","notify","key","value","dueAt","entry","now","batch","sentVersion","error","delay","targets","list","createBackoff","retry","initialDelay","maxDelay","factor","attempts","createScheduler","interval","onTick","timer","DEFAULT_INTERVAL","useWriteBehind","source","writerOrOptions","options","writer","interval","debounce","equals","keys","tracked","key","outbox","createOutbox","createBackoff","onOutboxChange","flusher","createFlusher","scheduler","createScheduler","readSource","shadow","value","syncFromSource","current","dueAt","seen","store","syncStore","inFlight","isServer","stopHiddenListener","onTabHidden","onDispose"]}

package/dist/vueWriteBehind.min.d.cts

@@ -0,0 +1,172 @@
+import { Ref } from 'vue';
+
+/**
+ * Public types.
+ *
+ * Leaf module: imports nothing at runtime (the single `import type { Ref }`
+ * is erased at compile time), so it can be copied on its own.
+ */
+
+/** Outbox keys are plain strings — the keys of the reactive record you pass in. */
+type WriteBehindKey = string;
+/**
+ * The record whose keys are written back. Either a `reactive()` object or a
+ * `ref()` holding a plain object.
+ *
+ * **Precondition — keys are independent.** Everything in this library relies on
+ * it: writes go out in parallel, in no particular order, last-write-wins per
+ * key. If key `b` is only valid once key `a` has landed, this is the wrong tool
+ * (that needs an ordered operation log — see the README's refuse list).
+ */
+type WriteBehindSource<T> = Record<WriteBehindKey, T> | Ref<Record<WriteBehindKey, T>>;
+/**
+ * Per-key writer — the common form.
+ *
+ * Called with the value read out of the outbox **at send time**, never a value
+ * captured when the edit happened. Reject (or throw) to fail the key; the
+ * return value is otherwise ignored on purpose — the server's reply never
+ * touches local state.
+ */
+type WriteBehindWriter<T> = (value: T, key: WriteBehindKey) => unknown;
+/** What a batch writer may resolve to in order to fail part of the batch. */
+interface WriteBehindBatchOutcome {
+    /** Keys the server did not accept. Everything else in the batch is treated as written. */
+    failed?: readonly WriteBehindKey[];
+}
+/**
+ * Batch writer — one call for every due key.
+ *
+ * Throw/reject and the **whole batch** stays pending. Resolve with
+ * `{ failed: [...] }` to fail part of it. Resolve with anything else (including
+ * `undefined`) and the whole batch is treated as written.
+ */
+type WriteBehindBatchWriter<T> = (entries: [WriteBehindKey, T][]) => WriteBehindBatchOutcome | void | Promise<WriteBehindBatchOutcome | void>;
+/** Per-key exponential backoff. Defaults produce 1s → 2 → 4 → 8 → 16 → 30s, capped. */
+interface WriteBehindRetryOptions {
+    /** Delay after the first failure, in ms. Default `1000`. */
+    initialDelay?: number;
+    /** Ceiling for the delay, in ms. Default `30000`. */
+    maxDelay?: number;
+    /** Multiplier applied per consecutive failure. Default `2`. */
+    factor?: number;
+}
+/** One key's latest failure. Only the newest error per key is kept. */
+interface WriteBehindFailure {
+    key: WriteBehindKey;
+    /** Whatever the writer rejected with. */
+    error: unknown;
+    /** Consecutive failures — resets on success, on `retry()`, and on `discard()`. */
+    attempts: number;
+    /**
+     * Epoch ms of the next automatic attempt, or `undefined` when no automatic
+     * attempt is scheduled (`retry: false`) — that key needs an edit or an
+     * explicit `retry(key)`.
+     */
+    retryAt: number | undefined;
+}
+/** Options shared by both writer shapes. Every one of them is an opt-*out*. */
+interface WriteBehindBaseOptions<T> {
+    /** Flush cadence in ms. Default `1000`. The timer only runs while work is queued. */
+    interval?: number;
+    /**
+     * Per-key quiet period in ms before a key becomes eligible. Default `0`
+     * (the `interval` already coalesces a burst of edits into one write).
+     * An edit never *shortens* an active backoff.
+     */
+    debounce?: number;
+    /**
+     * Retry policy, or `false` to stop retrying a key after a failure. Retrying
+     * is the default because dropping a user's edit is the one unacceptable
+     * outcome. With `false` the key stays pending and listed in `failed` — it is
+     * never discarded — until the next edit or an explicit `retry(key)`.
+     */
+    retry?: WriteBehindRetryOptions | false;
+    /**
+     * Flush when the tab is hidden (`visibilitychange`). Default `true`.
+     * Best-effort only: the browser may kill the page before the request leaves.
+     */
+    flushOnHidden?: boolean;
+    /**
+     * Narrows what the source watcher picks up. An allow-list or a predicate.
+     * Default: every key. `set()` is explicit and ignores this filter.
+     */
+    keys?: readonly WriteBehindKey[] | ((key: WriteBehindKey) => boolean);
+    /**
+     * Change detection for a key's value. Default `Object.is`.
+     *
+     * With the default, mutating an object value **in place** is not an edit —
+     * replace the object, or call `set(key, value)`.
+     */
+    equals?: (a: T, b: T) => boolean;
+}
+/**
+ * Options for `useWriteBehind`. Exactly one writer: `write` (per key) or
+ * `flush` (batched).
+ */
+type WriteBehindOptions<T> = WriteBehindBaseOptions<T> & ({
+    write: WriteBehindWriter<T>;
+    flush?: undefined;
+} | {
+    write?: undefined;
+    flush: WriteBehindBatchWriter<T>;
+});
+/**
+ * The reactive store `useWriteBehind` returns. Read the fields straight in a
+ * template; they are recomputed on every state change.
+ */
+interface WriteBehind<T> {
+    /**
+     * Every key with an unsaved change, **including** the ones currently on the
+     * wire. This is the "you have unsaved work" number.
+     */
+    readonly pending: readonly WriteBehindKey[];
+    /** The subset of `pending` currently in flight. */
+    readonly inFlight: readonly WriteBehindKey[];
+    /** Latest failure per failing key. */
+    readonly failed: readonly WriteBehindFailure[];
+    /** `true` while anything is in flight. */
+    readonly isSyncing: boolean;
+    /**
+     * Write a value into the source **and** queue it. Always queues, even when
+     * the value is unchanged — the escape hatch for values `equals` cannot see
+     * (an object mutated in place) and for keys excluded by `keys`.
+     */
+    set: (key: WriteBehindKey, value: T) => void;
+    /**
+     * Send every pending key that is not already in flight, ignoring the
+     * `debounce` and backoff clocks. Resolves when the requests it started have
+     * settled — keys edited *during* that flight are still pending afterwards.
+     */
+    flush: () => Promise<void>;
+    /**
+     * Clear the backoff (and the recorded failure) for one key, or all of them,
+     * so they go out on the next tick. The only way to revive a key that failed
+     * under `retry: false`.
+     */
+    retry: (key?: WriteBehindKey) => void;
+    /**
+     * Drop a key's pending write. **The only operation in this library that
+     * loses a write** — nothing else ever discards one.
+     */
+    discard: (key: WriteBehindKey) => void;
+}
+
+/**
+ * Write-behind cache for a reactive record. Local state stays authoritative;
+ * the writer's result is discarded on purpose.
+ *
+ * @example
+ * ```ts
+ * const cells = reactive<Record<string, string>>({ A1: 'foo' })
+ * const outbox = useWriteBehind(cells, (value, key) => api.put(`/cell/${key}`, value))
+ * cells.A1 = 'bar' // that is the whole API
+ * ```
+ *
+ * @param source A `reactive()` record (or a `ref()` holding one). Its keys must
+ *   be independent of each other — writes go out in parallel, last-write-wins.
+ * @param writerOrOptions The per-key writer, or an options object carrying
+ *   either `write` (per key) or `flush` (batched).
+ */
+declare function useWriteBehind<T>(source: WriteBehindSource<T>, writerOrOptions: WriteBehindWriter<T> | WriteBehindOptions<T>): WriteBehind<T>;
+
+export { type WriteBehind, type WriteBehindBaseOptions, type WriteBehindBatchOutcome, type WriteBehindBatchWriter, type WriteBehindFailure, type WriteBehindKey, type WriteBehindOptions, type WriteBehindRetryOptions, type WriteBehindSource, type WriteBehindWriter, useWriteBehind };

package/dist/vueWriteBehind.min.js

@@ -0,0 +1,2 @@
+import{isRef as R,shallowReactive as I,watch as C}from"vue";var D=r=>r?r.failed??[]:[];function g({outbox:r,writer:u,now:e}){let l=new Set,a=f=>{l.add(f),f.then(()=>l.delete(f))},B=async(f,i)=>{try{await f(i.value,i.key),r.settle(i.key,i.sentVersion)}catch(p){r.fail(i.key,i.sentVersion,p,e())}},b=async(f,i)=>{let p=i.map(h=>[h.key,h.value]);try{let h=new Set(D(await f(p)));for(let c of i)h.has(c.key)?r.fail(c.key,c.sentVersion,new Error(`vue-write-behind: batch flush reported "${c.key}" as failed`),e()):r.settle(c.key,c.sentVersion)}catch(h){for(let c of i)r.fail(c.key,c.sentVersion,h,e())}},W=(f=!1)=>{let i=r.take(f?Number.POSITIVE_INFINITY:e());if(i.length!==0)if(u.flush)a(b(u.flush,i));else for(let p of i)a(B(u.write,p))};return{dispatch:W,flush:async()=>{W(!0),await Promise.all([...l])}}}import{getCurrentScope as V,onScopeDispose as L}from"vue";var x=()=>typeof window>"u"||typeof document>"u";function K(r){if(x())return()=>{};let u=()=>{document.visibilityState==="hidden"&&r()};return document.addEventListener("visibilitychange",u),()=>document.removeEventListener("visibilitychange",u)}function A(r){V()&&L(r)}function F({retryDelay:r,onChange:u}){let e=new Map,l=0,a=()=>u?.();return{set:(n,o,t=0)=>{l+=1;let s=e.get(n);s?(s.value=o,s.version=l,s.blocked=!1,s.dueAt=Math.max(s.dueAt,t)):e.set(n,{value:o,version:l,sentVersion:void 0,attempts:0,error:void 0,dueAt:t,blocked:!1}),a()},take:n=>{let o=[];for(let[t,s]of e)s.sentVersion===void 0&&(s.blocked||s.dueAt>n||(s.sentVersion=s.version,o.push({key:t,value:s.value,sentVersion:s.version})));return o.length>0&&a(),o},settle:(n,o)=>{let t=e.get(n);!t||t.sentVersion!==o||(t.version===o?e.delete(n):(t.sentVersion=void 0,t.attempts=0,t.error=void 0,t.dueAt=0,t.blocked=!1),a())},fail:(n,o,t,s)=>{let y=e.get(n);if(!y||y.sentVersion!==o)return;y.sentVersion=void 0,y.attempts+=1,y.error=t;let T=r(y.attempts);T===void 0?y.blocked=!0:y.dueAt=s+T,a()},discard:n=>{e.delete(n)&&a()},clearBackoff:n=>{let o=n===void 0?e.values():[e.get(n)];for(let t of o)t&&(t.attempts=0,t.error=void 0,t.dueAt=0,t.blocked=!1);a()},pendingKeys:()=>[...e.keys()],inFlightKeys:()=>[...e].filter(([,n])=>n.sentVersion!==void 0).map(([n])=>n),failures:()=>{let n=[];for(let[o,t]of e)t.attempts!==0&&n.push({key:o,error:t.error,attempts:t.attempts,retryAt:t.blocked?void 0:t.dueAt});return n},isEmpty:()=>e.size===0,hasScheduledWork:()=>{for(let n of e.values())if(n.sentVersion===void 0&&!n.blocked)return!0;return!1}}}function E(r){if(r===!1)return()=>{};let{initialDelay:u=1e3,maxDelay:e=3e4,factor:l=2}=r??{};return a=>Math.min(u*l**(a-1),e)}function S({interval:r,onTick:u}){let e;return{start:()=>{e===void 0&&(e=setInterval(u,r))},stop:()=>{e!==void 0&&(clearInterval(e),e=void 0)},isRunning:()=>e!==void 0}}var _=1e3;function w(r,u){let e=typeof u=="function"?{write:u}:u,l=e.flush?{flush:e.flush}:{write:e.write},a=e.interval??_,B=e.debounce??0,b=e.equals??Object.is,W=e.keys,f=W===void 0?()=>!0:typeof W=="function"?W:d=>W.includes(d),i=F({retryDelay:E(e.retry),onChange:()=>y()}),p=g({outbox:i,writer:l,now:Date.now}),h=S({interval:a,onTick:()=>p.dispatch()}),c=()=>R(r)?r.value:r,n=new Map;for(let[d,m]of Object.entries(c()))f(d)&&n.set(d,{value:m});let o=()=>{let d=c(),m=B>0?Date.now()+B:0;for(let[v,k]of Object.entries(d)){if(!f(v))continue;let O=n.get(v);O&&b(O.value,k)||(n.set(v,{value:k}),i.set(v,k,m))}for(let v of n.keys())v in d||n.delete(v)},t=I({pending:[],inFlight:[],failed:[],isSyncing:!1,set:(d,m)=>{c()[d]=m,n.set(d,{value:m}),i.set(d,m,B>0?Date.now()+B:0)},flush:()=>(o(),p.flush()),retry:d=>i.clearBackoff(d),discard:d=>i.discard(d)}),s=()=>{let d=i.inFlightKeys();t.pending=i.pendingKeys(),t.inFlight=d,t.failed=i.failures(),t.isSyncing=d.length>0};function y(){s(),!x()&&(i.hasScheduledWork()?h.start():h.stop())}C(c,o,{deep:!0});let T=e.flushOnHidden===!1?()=>{}:K(()=>{t.flush()});return A(()=>{h.stop(),T()}),t}export{w as useWriteBehind};
+//# sourceMappingURL=vueWriteBehind.min.js.map

package/dist/vueWriteBehind.min.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/useWriteBehind.ts","../src/flush.ts","../src/lifecycle.ts","../src/outbox.ts","../src/scheduler.ts"],"sourcesContent":["/**\n * The Vue surface — watches the source record, mirrors the outbox into a\n * reactive store, and owns when the clock runs.\n *\n * It reads local state and never writes it back: nothing here applies a server\n * response to the source, because the whole point is that the cell the user is\n * typing in cannot be overwritten from the network.\n */\nimport { isRef, shallowReactive, watch } from 'vue'\nimport { createFlusher, type ResolvedWriter } from './flush'\nimport { isServer, onDispose, onTabHidden } from './lifecycle'\nimport { createOutbox } from './outbox'\nimport { createBackoff, createScheduler } from './scheduler'\nimport type {\n  WriteBehind,\n  WriteBehindKey,\n  WriteBehindOptions,\n  WriteBehindSource,\n  WriteBehindWriter,\n} from './types'\n\nconst DEFAULT_INTERVAL = 1000\n\n/** The store as this module holds it: same shape, writable. */\ntype MutableWriteBehind<T> = { -readonly [K in keyof WriteBehind<T>]: WriteBehind<T>[K] }\n\n/**\n * Write-behind cache for a reactive record. Local state stays authoritative;\n * the writer's result is discarded on purpose.\n *\n * @example\n * ```ts\n * const cells = reactive<Record<string, string>>({ A1: 'foo' })\n * const outbox = useWriteBehind(cells, (value, key) => api.put(`/cell/${key}`, value))\n * cells.A1 = 'bar' // that is the whole API\n * ```\n *\n * @param source A `reactive()` record (or a `ref()` holding one). Its keys must\n *   be independent of each other — writes go out in parallel, last-write-wins.\n * @param writerOrOptions The per-key writer, or an options object carrying\n *   either `write` (per key) or `flush` (batched).\n */\nexport function useWriteBehind<T>(\n  source: WriteBehindSource<T>,\n  writerOrOptions: WriteBehindWriter<T> | WriteBehindOptions<T>,\n): WriteBehind<T> {\n  const options: WriteBehindOptions<T> =\n    typeof writerOrOptions === 'function' ? { write: writerOrOptions } : writerOrOptions\n\n  const writer: ResolvedWriter<T> = options.flush\n    ? { flush: options.flush }\n    : { write: options.write }\n\n  const interval = options.interval ?? DEFAULT_INTERVAL\n  const debounce = options.debounce ?? 0\n  const equals = options.equals ?? Object.is\n  const keys = options.keys\n  const tracked: (key: WriteBehindKey) => boolean =\n    keys === undefined\n      ? () => true\n      : typeof keys === 'function'\n        ? keys\n        : (key) => keys.includes(key)\n\n  const outbox = createOutbox<T>({\n    retryDelay: createBackoff(options.retry),\n    onChange: () => onOutboxChange(),\n  })\n  const flusher = createFlusher<T>({ outbox, writer, now: Date.now })\n  const scheduler = createScheduler({ interval, onTick: () => flusher.dispatch() })\n\n  const readSource = (): Record<WriteBehindKey, T> => (isRef(source) ? source.value : source)\n\n  // Last value seen per key. Boxed so `T` may legitimately be `undefined`\n  // without `has`/`get` disagreeing.\n  const shadow = new Map<WriteBehindKey, { value: T }>()\n  for (const [key, value] of Object.entries(readSource())) {\n    if (!tracked(key)) continue\n    // Seeded, NOT queued: whatever the record starts with came from the server.\n    shadow.set(key, { value })\n  }\n\n  const syncFromSource = (): void => {\n    const current = readSource()\n    const dueAt = debounce > 0 ? Date.now() + debounce : 0\n    for (const [key, value] of Object.entries(current)) {\n      if (!tracked(key)) continue\n      const seen = shadow.get(key)\n      if (seen && equals(seen.value, value)) continue\n      shadow.set(key, { value })\n      outbox.set(key, value, dueAt)\n    }\n    // A key deleted from the source stops being watched, but its queued write\n    // survives — losing it silently is the one outcome this library refuses.\n    // `discard(key)` is how a consumer drops it on purpose.\n    for (const key of shadow.keys()) {\n      if (!(key in current)) shadow.delete(key)\n    }\n  }\n\n  const store = shallowReactive<MutableWriteBehind<T>>({\n    pending: [],\n    inFlight: [],\n    failed: [],\n    isSyncing: false,\n    set: (key, value) => {\n      readSource()[key] = value\n      shadow.set(key, { value })\n      // Unconditional: `set` is the escape hatch for a change `equals` cannot\n      // see (an object mutated in place) and for keys `keys` filters out.\n      outbox.set(key, value, debounce > 0 ? Date.now() + debounce : 0)\n    },\n    flush: () => {\n      // The source watcher is a `pre` watcher, so an edit made in this tick has\n      // not been picked up yet — read it now or a save button next to an input\n      // would miss the last keystroke.\n      syncFromSource()\n      return flusher.flush()\n    },\n    retry: (key) => outbox.clearBackoff(key),\n    discard: (key) => outbox.discard(key),\n  })\n\n  const syncStore = (): void => {\n    const inFlight = outbox.inFlightKeys()\n    store.pending = outbox.pendingKeys()\n    store.inFlight = inFlight\n    store.failed = outbox.failures()\n    store.isSyncing = inFlight.length > 0\n  }\n\n  function onOutboxChange(): void {\n    syncStore()\n    // Never start a timer on the server, and never leave one running with\n    // nothing to send — an idle app must not hold the event loop open.\n    if (isServer()) return\n    if (outbox.hasScheduledWork()) scheduler.start()\n    else scheduler.stop()\n  }\n\n  watch(readSource, syncFromSource, { deep: true })\n\n  const stopHiddenListener =\n    options.flushOnHidden === false ? () => {} : onTabHidden(() => void store.flush())\n\n  onDispose(() => {\n    scheduler.stop()\n    stopHiddenListener()\n  })\n\n  return store\n}\n","/**\n * The writer adapters — the only place a request is made.\n *\n * Two shapes, one rule: whatever the network does, the outcome is reported back\n * to the outbox and nothing else. This module never clears a key itself, never\n * looks at what a writer resolved with, and never touches local state. The\n * server's reply is discarded on purpose.\n *\n * Per-key writes are independent, so they run in parallel and each key settles\n * the moment its own request returns (`Promise.allSettled` semantics — one\n * rejection can neither block nor fail a sibling). That is safe only because\n * key independence is a stated precondition of the library.\n */\nimport type { Outbox, OutboxEntry } from './outbox'\nimport type {\n  WriteBehindBatchOutcome,\n  WriteBehindBatchWriter,\n  WriteBehindKey,\n  WriteBehindWriter,\n} from './types'\n\n/** Exactly one writer, already narrowed from the options. */\nexport type ResolvedWriter<T> =\n  | { write: WriteBehindWriter<T>; flush?: undefined }\n  | { write?: undefined; flush: WriteBehindBatchWriter<T> }\n\nexport interface FlusherConfig<T> {\n  outbox: Outbox<T>\n  writer: ResolvedWriter<T>\n  /** Injected so the flusher owns no clock of its own. */\n  now: () => number\n}\n\nexport interface Flusher {\n  /** Send everything due. `force` ignores the debounce and backoff clocks. */\n  dispatch: (force?: boolean) => void\n  /** Force a dispatch and wait for every request currently in the air. */\n  flush: () => Promise<void>\n}\n\nconst failedKeysOf = (outcome: WriteBehindBatchOutcome | void): readonly WriteBehindKey[] => {\n  if (!outcome) return []\n  return outcome.failed ?? []\n}\n\nexport function createFlusher<T>({ outbox, writer, now }: FlusherConfig<T>): Flusher {\n  const inAir = new Set<Promise<void>>()\n\n  const track = (flight: Promise<void>): void => {\n    inAir.add(flight)\n    void flight.then(() => inAir.delete(flight))\n  }\n\n  const runPerKey = async (write: WriteBehindWriter<T>, entry: OutboxEntry<T>): Promise<void> => {\n    try {\n      await write(entry.value, entry.key)\n      outbox.settle(entry.key, entry.sentVersion)\n    } catch (error) {\n      outbox.fail(entry.key, entry.sentVersion, error, now())\n    }\n  }\n\n  const runBatch = async (\n    flushAll: WriteBehindBatchWriter<T>,\n    batch: OutboxEntry<T>[],\n  ): Promise<void> => {\n    const entries = batch.map((entry): [WriteBehindKey, T] => [entry.key, entry.value])\n    try {\n      const failed = new Set(failedKeysOf(await flushAll(entries)))\n      for (const entry of batch) {\n        if (failed.has(entry.key)) {\n          outbox.fail(\n            entry.key,\n            entry.sentVersion,\n            new Error(`vue-write-behind: batch flush reported \"${entry.key}\" as failed`),\n            now(),\n          )\n        } else {\n          outbox.settle(entry.key, entry.sentVersion)\n        }\n      }\n    } catch (error) {\n      // One rejection means the transport failed, so nothing in the batch is\n      // known to have landed — every key stays pending.\n      for (const entry of batch) outbox.fail(entry.key, entry.sentVersion, error, now())\n    }\n  }\n\n  const dispatch = (force = false): void => {\n    const batch = outbox.take(force ? Number.POSITIVE_INFINITY : now())\n    if (batch.length === 0) return\n    // The union guarantees exactly one of the two is present.\n    if (writer.flush) track(runBatch(writer.flush, batch))\n    else for (const entry of batch) track(runPerKey(writer.write, entry))\n  }\n\n  return {\n    dispatch,\n    flush: async () => {\n      dispatch(true)\n      await Promise.all([...inAir])\n    },\n  }\n}\n","/**\n * Everything with a lifetime outside the outbox: the environment check, the\n * tab-hidden hook and scope disposal.\n *\n * `visibilitychange` rather than `beforeunload`: mobile browsers routinely\n * discard a page without ever firing `beforeunload`, and Safari fires\n * `pagehide` instead. `visibilitychange → hidden` is the one signal that fires\n * on every platform — and it is still only best-effort, because the page can be\n * frozen before the request leaves. `pending` is exposed so an app can warn.\n */\nimport { getCurrentScope, onScopeDispose } from 'vue'\n\n/** True when there is no DOM — SSR, or a worker. */\nexport const isServer = (): boolean =>\n  typeof window === 'undefined' || typeof document === 'undefined'\n\n/** Subscribe to the tab going hidden. Returns the unsubscribe; a no-op on the server. */\nexport function onTabHidden(handler: () => void): () => void {\n  if (isServer()) return () => {}\n  const listener = (): void => {\n    if (document.visibilityState === 'hidden') handler()\n  }\n  document.addEventListener('visibilitychange', listener)\n  return () => document.removeEventListener('visibilitychange', listener)\n}\n\n/**\n * Register cleanup with the surrounding effect scope, if there is one. Called\n * outside `setup()` (imperative code, tests) there is nothing to hook, and Vue\n * would warn — so guard rather than warn. `getCurrentScope()` exists in 3.0;\n * `onScopeDispose`'s `failSilently` argument only arrived in 3.5.\n */\nexport function onDispose(cleanup: () => void): void {\n  if (getCurrentScope()) onScopeDispose(cleanup)\n}\n","/**\n * The outbox: the pure key/version/dirty state machine.\n *\n * No Vue, no timers, no I/O — every clock reading arrives as an argument. This\n * is where the whole library's correctness lives, which is why it is testable\n * without mounting anything.\n *\n * **Invariant: this module is the only place a dirty key is ever cleared.**\n * Everything else (scheduler, flush, the composable) can only ask.\n *\n * The rule that makes it correct: a key carries a **monotonic version**, and a\n * write records the version it was sent at. A success clears the key only when\n * the version has not moved since. A boolean dirty flag cannot express that —\n * the response would clear a flag a newer edit had set, and that edit would be\n * gone with nothing on screen to say so.\n */\nimport type { WriteBehindFailure, WriteBehindKey } from './types'\n\n/** One entry handed to a writer. `value` is read out of the map at take time. */\nexport interface OutboxEntry<T> {\n  key: WriteBehindKey\n  value: T\n  /**\n   * The version this send is for. Hand it back to `settle`/`fail` — it is the\n   * flight's identity, so a response from a superseded flight (the key was\n   * discarded and re-queued, or `retry()` re-armed it) is ignored instead of\n   * clearing the wrong write.\n   */\n  sentVersion: number\n}\n\ninterface Entry<T> {\n  value: T\n  /** Bumped on every edit. Unique across the whole outbox, never reused. */\n  version: number\n  /** The version currently on the wire, or `undefined` when nothing is. */\n  sentVersion: number | undefined\n  /** Consecutive failures. */\n  attempts: number\n  error: unknown\n  /** Epoch ms before which the key is not eligible. `0` = eligible now. */\n  dueAt: number\n  /** Failed with retries disabled: needs a fresh edit or an explicit retry. */\n  blocked: boolean\n}\n\nexport interface OutboxConfig {\n  /**\n   * Backoff for the n-th consecutive failure, in ms. Returning `undefined`\n   * blocks the key instead of scheduling an attempt (`retry: false`).\n   */\n  retryDelay: (attempts: number) => number | undefined\n  /** Called after every state transition. */\n  onChange?: () => void\n}\n\nexport interface Outbox<T> {\n  /**\n   * Queue a value. `dueAt` (epoch ms) holds the key back — used for `debounce`.\n   * It can only ever push the key further out, never pull an active backoff in.\n   */\n  set: (key: WriteBehindKey, value: T, dueAt?: number) => void\n  /**\n   * Claim every key that is due at `now`, not in flight and not blocked,\n   * marking each in flight. Pass `Infinity` to ignore the clocks (`flush()`).\n   */\n  take: (now: number) => OutboxEntry<T>[]\n  /** The write landed. Clears the key **only if** its version has not moved. */\n  settle: (key: WriteBehindKey, sentVersion: number) => void\n  /** The write failed. Never clears the key. */\n  fail: (key: WriteBehindKey, sentVersion: number, error: unknown, now: number) => void\n  /** Forget a key's pending write entirely — the one operation that loses one. */\n  discard: (key: WriteBehindKey) => void\n  /** Make a key (or all of them) eligible again and forget its failure. */\n  clearBackoff: (key?: WriteBehindKey) => void\n  /** Every unconfirmed key, in-flight ones included. */\n  pendingKeys: () => WriteBehindKey[]\n  inFlightKeys: () => WriteBehindKey[]\n  failures: () => WriteBehindFailure[]\n  isEmpty: () => boolean\n  /** True while some key could still become eligible — i.e. the clock is worth running. */\n  hasScheduledWork: () => boolean\n}\n\nexport function createOutbox<T>({ retryDelay, onChange }: OutboxConfig): Outbox<T> {\n  const entries = new Map<WriteBehindKey, Entry<T>>()\n  // One counter for the whole outbox rather than one per key: versions are then\n  // never reused, so a response from a discarded flight can never be mistaken\n  // for the current one on a key that was queued again in the meantime.\n  let version = 0\n\n  const notify = () => onChange?.()\n\n  const set = (key: WriteBehindKey, value: T, dueAt = 0): void => {\n    version += 1\n    const entry = entries.get(key)\n    if (entry) {\n      entry.value = value\n      entry.version = version\n      // A new value is a new write, not a retry — it re-arms a blocked key…\n      entry.blocked = false\n      // …but it must not shorten an active backoff, or a user typing into a\n      // failing endpoint would fire one request per keystroke.\n      entry.dueAt = Math.max(entry.dueAt, dueAt)\n    } else {\n      entries.set(key, {\n        value,\n        version,\n        sentVersion: undefined,\n        attempts: 0,\n        error: undefined,\n        dueAt,\n        blocked: false,\n      })\n    }\n    notify()\n  }\n\n  const take = (now: number): OutboxEntry<T>[] => {\n    const batch: OutboxEntry<T>[] = []\n    for (const [key, entry] of entries) {\n      if (entry.sentVersion !== undefined) continue // already on the wire (H5)\n      if (entry.blocked) continue\n      if (entry.dueAt > now) continue\n      entry.sentVersion = entry.version\n      batch.push({ key, value: entry.value, sentVersion: entry.version })\n    }\n    if (batch.length > 0) notify()\n    return batch\n  }\n\n  const settle = (key: WriteBehindKey, sentVersion: number): void => {\n    const entry = entries.get(key)\n    if (!entry || entry.sentVersion !== sentVersion) return\n    if (entry.version === sentVersion) {\n      // Nothing was typed while this was in flight: the key is saved.\n      entries.delete(key)\n    } else {\n      // It was. Keep it dirty and send the newer value next tick; the server is\n      // evidently healthy, so drop the backoff.\n      entry.sentVersion = undefined\n      entry.attempts = 0\n      entry.error = undefined\n      entry.dueAt = 0\n      entry.blocked = false\n    }\n    notify()\n  }\n\n  const fail = (key: WriteBehindKey, sentVersion: number, error: unknown, now: number): void => {\n    const entry = entries.get(key)\n    if (!entry || entry.sentVersion !== sentVersion) return\n    entry.sentVersion = undefined\n    entry.attempts += 1\n    entry.error = error\n    const delay = retryDelay(entry.attempts)\n    if (delay === undefined) entry.blocked = true\n    else entry.dueAt = now + delay\n    notify()\n  }\n\n  const discard = (key: WriteBehindKey): void => {\n    if (!entries.delete(key)) return\n    notify()\n  }\n\n  const clearBackoff = (key?: WriteBehindKey): void => {\n    const targets = key === undefined ? entries.values() : [entries.get(key)]\n    for (const entry of targets) {\n      if (!entry) continue\n      entry.attempts = 0\n      entry.error = undefined\n      entry.dueAt = 0\n      entry.blocked = false\n    }\n    notify()\n  }\n\n  const failures = (): WriteBehindFailure[] => {\n    const list: WriteBehindFailure[] = []\n    for (const [key, entry] of entries) {\n      if (entry.attempts === 0) continue\n      list.push({\n        key,\n        error: entry.error,\n        attempts: entry.attempts,\n        retryAt: entry.blocked ? undefined : entry.dueAt,\n      })\n    }\n    return list\n  }\n\n  const hasScheduledWork = (): boolean => {\n    for (const entry of entries.values()) {\n      if (entry.sentVersion === undefined && !entry.blocked) return true\n    }\n    return false\n  }\n\n  return {\n    set,\n    take,\n    settle,\n    fail,\n    discard,\n    clearBackoff,\n    pendingKeys: () => [...entries.keys()],\n    inFlightKeys: () =>\n      [...entries].filter(([, entry]) => entry.sentVersion !== undefined).map(([key]) => key),\n    failures,\n    isEmpty: () => entries.size === 0,\n    hasScheduledWork,\n  }\n}\n","/**\n * The clock — the flush interval and the per-key backoff curve.\n *\n * Deliberately ignorant of writes and keys: it only knows \"call this every N\n * ms\" and \"how long after the n-th failure\". The decision to run at all belongs\n * to `useWriteBehind`, which starts it when work is queued and stops it when\n * there is none — an idle app must not hold a timer open.\n */\nimport type { WriteBehindRetryOptions } from './types'\n\nconst DEFAULT_INITIAL_DELAY = 1000\nconst DEFAULT_MAX_DELAY = 30000\nconst DEFAULT_FACTOR = 2\n\n/**\n * Backoff for the n-th consecutive failure (1-based), in ms — or `undefined`\n * when retries are off, which parks the key until it is edited or retried.\n *\n * The cap matters: `factor ** attempts` reaches Infinity within a couple of\n * dozen failures, and a key parked at `Infinity` would never be retried, which\n * is exactly the silent write loss this library exists to prevent.\n */\nexport function createBackoff(\n  retry: WriteBehindRetryOptions | false | undefined,\n): (attempts: number) => number | undefined {\n  if (retry === false) return () => undefined\n  const {\n    initialDelay = DEFAULT_INITIAL_DELAY,\n    maxDelay = DEFAULT_MAX_DELAY,\n    factor = DEFAULT_FACTOR,\n  } = retry ?? {}\n  return (attempts) => Math.min(initialDelay * factor ** (attempts - 1), maxDelay)\n}\n\nexport interface SchedulerConfig {\n  interval: number\n  onTick: () => void\n}\n\nexport interface Scheduler {\n  /** Idempotent: calling it while running keeps the current phase. */\n  start: () => void\n  stop: () => void\n  isRunning: () => boolean\n}\n\nexport function createScheduler({ interval, onTick }: SchedulerConfig): Scheduler {\n  let timer: ReturnType<typeof setInterval> | undefined\n\n  return {\n    start: () => {\n      // Restarting would reset the phase, so a fast typist could push the flush\n      // out indefinitely — the interval has to be a fixed window, not a debounce.\n      if (timer !== undefined) return\n      timer = setInterval(onTick, interval)\n    },\n    stop: () => {\n      if (timer === undefined) return\n      clearInterval(timer)\n      timer = undefined\n    },\n    isRunning: () => timer !== undefined,\n  }\n}\n"],"mappings":"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","names":["isRef","shallowReactive","watch","failedKeysOf","outcome","createFlusher","outbox","writer","now","inAir","track","flight","runPerKey","write","entry","error","runBatch","flushAll","batch","entries","failed","dispatch","force","getCurrentScope","onScopeDispose","isServer","onTabHidden","handler","listener","onDispose","cleanup","createOutbox","retryDelay","onChange","entries","version","notify","key","value","dueAt","entry","now","batch","sentVersion","error","delay","targets","list","createBackoff","retry","initialDelay","maxDelay","factor","attempts","createScheduler","interval","onTick","timer","DEFAULT_INTERVAL","useWriteBehind","source","writerOrOptions","options","writer","interval","debounce","equals","keys","tracked","key","outbox","createOutbox","createBackoff","onOutboxChange","flusher","createFlusher","scheduler","createScheduler","readSource","isRef","shadow","value","syncFromSource","current","dueAt","seen","store","shallowReactive","syncStore","inFlight","isServer","watch","stopHiddenListener","onTabHidden","onDispose"]}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "vue-write-behind",
+  "version": "0.1.0",
+  "description": "Write-behind cache for Vue 3 \u2014 local state stays authoritative, the server's reply is discarded on purpose, and a failed save never rolls back or drops what the user typed",
+  "author": "Ozgur Seyidoglu",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ozJSey/vue-write-behind.git"
+  },
+  "homepage": "https://github.com/ozJSey/vue-write-behind#readme",
+  "bugs": {
+    "url": "https://github.com/ozJSey/vue-write-behind/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/vueWriteBehind.min.cjs",
+  "module": "dist/vueWriteBehind.min.js",
+  "types": "dist/vueWriteBehind.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/vueWriteBehind.d.ts",
+        "default": "./dist/vueWriteBehind.min.js"
+      },
+      "require": {
+        "types": "./dist/vueWriteBehind.min.d.cts",
+        "default": "./dist/vueWriteBehind.min.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup vueWriteBehind.ts --format esm,cjs --minify --sourcemap --dts --out-dir dist --clean && mv dist/vueWriteBehind.js dist/vueWriteBehind.min.js && mv dist/vueWriteBehind.js.map dist/vueWriteBehind.min.js.map && mv dist/vueWriteBehind.cjs dist/vueWriteBehind.min.cjs && mv dist/vueWriteBehind.cjs.map dist/vueWriteBehind.min.cjs.map && mv dist/vueWriteBehind.d.cts dist/vueWriteBehind.min.d.cts && node -e \"const fs=require('fs');for(const f of ['vueWriteBehind.min.js','vueWriteBehind.min.cjs']){const p='dist/'+f;let s=fs.readFileSync(p,'utf8');s=s.replace(/\\/\\/# sourceMappingURL=vueWriteBehind\\.(js|cjs)\\.map/, '//# sourceMappingURL='+f+'.map');fs.writeFileSync(p,s);}\"",
+    "test": "vitest run",
+    "check:dist": "npm run build && node dist-check.mjs",
+    "check:browser": "npm run build && node scripts/browser-check.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "vue",
+    "vue3",
+    "write-behind",
+    "write-back",
+    "outbox",
+    "debounce-save",
+    "autosave",
+    "auto-save",
+    "batch-save",
+    "offline",
+    "retry",
+    "optimistic",
+    "local-first",
+    "composable",
+    "dirty-tracking",
+    "sync"
+  ],
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "devDependencies": {
+    "jsdom": "^25.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0",
+    "vue": "^3.5.0",
+    "vue3_3": "npm:vue@3.3.13"
+  }
+}