@@ -117,6 +117,38 @@ const client = newReplicaClientFromURL('file:///data/replica');
 const replica = new Replica('/data/app.db', client);
 ```
 
+### Continuous sync
+
+For ongoing replication, `replica.run()` syncs immediately and then repeats on an
+interval until the supplied `AbortSignal` is aborted. Sync errors are logged and the
+loop keeps going, so a transient failure doesn't stop replication:
+
+```ts
+import { Replica, FileReplicaClient } from 'sqlite-js-stream';
+
+const replica = new Replica('/data/app.db', new FileReplicaClient('/data/replica'));
+const ac = new AbortController();
+
+// Run continuously (sync now, then every 1s); resolves when aborted.
+const runP = replica.run({ intervalMs: 1000, signal: ac.signal });
+
+// ... later, to stop:
+ac.abort();
+await runP;
+```
+
+If you want to keep replicating in the background without awaiting, call `run()` and
+`catch` its promise (it resolves on abort):
+
+```ts
+replica.run({ intervalMs: 1000, signal: ac.signal }).catch((err) => {
+  console.error('continuous sync stopped', err);
+});
+```
+
+`Store` also exposes `syncAll()`/`snapshotAll()` for one-shot operations; a continuous
+loop can be driven by calling `replica.run()` per database, or via your own scheduler.
+
 ---
 
 ## How it works
 
@@ -66,11 +66,13 @@ prevents the WAL from being checkpointed past our position.
 Writes a **level-9** full snapshot LTX file (`MinTXID = 1`, `MaxTXID = current position`) containing
 every committed page. Combined with incremental level-0 files this gives point-in-time restore.
 
-### Replica.sync()
+### Replica.run()
 
-Uploads every local level-0 LTX file from `replicaPos + 1` to `dbPos` to the client, advancing the
-replicated position as it goes. The replica position is the max `MaxTXID` among level-0 files on the
-client.
+`Replica.sync()` writes a local level-0 LTX file and then uploads every pending L0 file from
+`replicaPos + 1` to `dbPos`, advancing the replicated position (which is the max `MaxTXID` among
+level-0 files on the client). `Replica.run({ intervalMs, signal })` loops this continuously until
+the `AbortSignal` is aborted: it syncs immediately, waits `intervalMs`, then repeats. A transient
+sync error is logged and the loop keeps going.
 
 ### Replica.restore()
 
 
@@ -18,6 +18,7 @@
 
 import { access, mkdir, rename, writeFile } from 'node:fs/promises';
 import nodePath from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
 
 import {
   BufferSink,
@@ -44,6 +45,13 @@ export interface SyncStatus {
   inSync: boolean;
 }
 
+export interface ReplicaRunOptions {
+  /** Milliseconds between syncs. Defaults to 1000. */
+  intervalMs?: number;
+  /** Abort to stop continuous syncing. */
+  signal?: AbortSignal;
+}
+
 function chunks(data: Uint8Array, size = 256 * 1024): AsyncIterable<Uint8Array> {
   return (async function* () {
     for (let i = 0; i < data.length; i += size) {
@@ -120,6 +128,29 @@ export class Replica {
     await this.sync();
   }
 
+  /**
+   * Run continuously syncs the replica until `signal` is aborted. It syncs
+   * immediately, then waits `intervalMs` and repeats. Errors during a sync are
+   * logged and the loop keeps going, so a transient failure does not stop
+   * replication. Resolves once the signal is aborted.
+   */
+  async run(opt: ReplicaRunOptions = {}): Promise<void> {
+    const { intervalMs = 1000, signal } = opt;
+    while (!signal?.aborted) {
+      try {
+        await this.sync();
+      } catch (err) {
+        this.logger.error('replica sync error', err);
+      }
+      if (signal?.aborted) break;
+      try {
+        await sleep(intervalMs, undefined, { signal });
+      } catch {
+        break; // aborted during the sleep
+      }
+    }
+  }
+
   /** Snapshot writes and uploads a level-9 full-database LTX file. */
   async snapshot(): Promise<void> {
     const info = await (await this.localDb()).snapshot();
 
@@ -0,0 +1,133 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { DatabaseSync } from 'node:sqlite';
+import type { Readable } from 'node:stream';
+import { join } from 'node:path';
+
+import {
+  Replica,
+  FileReplicaClient,
+  type ReplicaClient,
+  type FileInfo,
+  type LTXFilesOptions,
+  type OpenLTXFileOptions,
+  type WriteLTXFileOptions,
+} from '../../src/index.ts';
+import type { Logger } from '../../src/util/logger.ts';
+import { createWALDB, makeTempDir } from '../helpers/make-db.ts';
+
+async function waitUntil(fn: () => Promise<boolean>, timeoutMs = 8000): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await fn()) return;
+    await new Promise((r) => setTimeout(r, 5));
+  }
+  throw new Error('timed out waiting for condition');
+}
+
+/** A ReplicaClient that fails the first write, then delegates. */
+class FlakyOnceClient implements ReplicaClient {
+  private inner: FileReplicaClient;
+  private failed = false;
+  constructor(inner: FileReplicaClient) {
+    this.inner = inner;
+  }
+  type(): string {
+    return this.inner.type();
+  }
+  init(): Promise<void> {
+    return this.inner.init();
+  }
+  ltxFiles(opts: LTXFilesOptions): AsyncIterable<FileInfo> {
+    return this.inner.ltxFiles(opts);
+  }
+  openLtxFile(opts: OpenLTXFileOptions): Promise<Readable> {
+    return this.inner.openLtxFile(opts);
+  }
+  async writeLtxFile(
+    opts: WriteLTXFileOptions,
+    body: AsyncIterable<Uint8Array | string>,
+  ): Promise<FileInfo> {
+    if (!this.failed) {
+      this.failed = true;
+      throw new Error('transient write failure');
+    }
+    return this.inner.writeLtxFile(opts, body);
+  }
+  deleteLtxFiles(infos: FileInfo[]): Promise<void> {
+    return this.inner.deleteLtxFiles(infos);
+  }
+  deleteAll(): Promise<void> {
+    return this.inner.deleteAll();
+  }
+  setLogger(logger: Logger): void {
+    this.inner.setLogger(logger);
+  }
+}
+
+test('run() continuously syncs new writes until aborted', async () => {
+  const t = createWALDB(['a', 'b', 'c']);
+  const client = new FileReplicaClient(makeTempDir('repl-'));
+  const replica = new Replica(t.path, client);
+  const ac = new AbortController();
+
+  const runP = replica.run({ intervalMs: 25, signal: ac.signal });
+  try {
+    // Let the first sync run, then add more data.
+    await new Promise((r) => setTimeout(r, 30));
+    t.db.exec("INSERT INTO t (name) VALUES ('d'), ('e'), ('f')");
+
+    // The continuous loop should pick up the new rows on a later iteration.
+    await waitUntil(async () => (await replica.syncStatus()).localTXID >= 2n);
+
+    ac.abort();
+    await runP;
+
+    const out = join(makeTempDir('restore-'), 'db.db');
+    await replica.restore({ outputPath: out });
+    const r = new DatabaseSync(out);
+    const count = r.prepare('SELECT count(*) AS n FROM t').get() as { n: number };
+    assert.equal(count.n, 6);
+    const ic = r.prepare('PRAGMA integrity_check').get() as { integrity_check: string };
+    assert.equal(ic.integrity_check, 'ok');
+    r.close();
+  } finally {
+    ac.abort();
+    replica.close();
+    t.close();
+  }
+});
+
+test('run() keeps replicating after a transient write failure', async () => {
+  const t = createWALDB(['a', 'b']);
+  const client = new FlakyOnceClient(new FileReplicaClient(makeTempDir('repl-')));
+  const replica = new Replica(t.path, client);
+  const ac = new AbortController();
+
+  const runP = replica.run({ intervalMs: 25, signal: ac.signal });
+  try {
+    // Add data; the first upload will fail, but the loop retries and recovers.
+    await new Promise((r) => setTimeout(r, 30));
+    t.db.exec("INSERT INTO t (name) VALUES ('c'), ('d')");
+
+    // localTXID advances on the local write; remoteTXID >= 2 means the retry
+    // eventually uploaded everything despite the transient failure.
+    await waitUntil(async () => (await replica.syncStatus()).remoteTXID >= 2n);
+
+    ac.abort();
+    await runP;
+
+    const out = join(makeTempDir('restore-'), 'db.db');
+    await replica.restore({ outputPath: out });
+    const r = new DatabaseSync(out);
+    const count = r.prepare('SELECT count(*) AS n FROM t').get() as { n: number };
+    assert.equal(count.n, 4);
+    const ic = r.prepare('PRAGMA integrity_check').get() as { integrity_check: string };
+    assert.equal(ic.integrity_check, 'ok');
+    r.close();
+  } finally {
+    ac.abort();
+    replica.close();
+    t.close();
+  }
+});