@lenne.tech/nuxt-extensions 1.20.0 → 1.21.0

package/dist/runtime/lib/sync-store.js

@@ -0,0 +1,149 @@
+export const LT_SYNC_DB_NAME = "lt-offline-sync";
+export const LT_SYNC_CHANNEL_NAME = "lt-offline-sync";
+const STORES = ["meta", "outbox", "records"];
+const done = (request) => new Promise((resolve, reject) => {
+  request.addEventListener("success", () => resolve(request.result));
+  request.addEventListener("error", () => reject(request.error));
+});
+let connection;
+let opening;
+function openDatabase() {
+  if (connection) return Promise.resolve(connection);
+  opening ??= (async () => {
+    const request = indexedDB.open(LT_SYNC_DB_NAME, 1);
+    request.addEventListener("upgradeneeded", () => {
+      const db = request.result;
+      db.createObjectStore("records", { keyPath: ["model", "id"] }).createIndex("model", "model");
+      const outbox = db.createObjectStore("outbox", { autoIncrement: true, keyPath: "seq" });
+      outbox.createIndex("mutationId", "mutationId", { unique: true });
+      outbox.createIndex("model", "model");
+      db.createObjectStore("meta", { keyPath: "key" });
+    });
+    try {
+      const db = await done(request);
+      db.addEventListener("versionchange", () => {
+        db.close();
+        if (connection === db) connection = void 0;
+      });
+      connection = db;
+      return db;
+    } finally {
+      opening = void 0;
+    }
+  })();
+  return opening;
+}
+export class LtSyncOwnerChangedError extends Error {
+  constructor() {
+    super("the local sync data changed owner");
+    this.name = "LtSyncOwnerChangedError";
+  }
+}
+export async function runLtSyncTx(model, fn, options = {}) {
+  const db = await openDatabase();
+  const transaction = db.transaction(STORES, "readwrite");
+  const finished = new Promise((resolve, reject) => {
+    transaction.addEventListener("complete", () => resolve());
+    transaction.addEventListener("abort", () => reject(transaction.error ?? new Error("transaction aborted")));
+    transaction.addEventListener("error", () => reject(transaction.error));
+  });
+  const store = (name) => transaction.objectStore(name);
+  const strip = (stored) => {
+    if (!stored) return void 0;
+    const { model: _model, ...record } = stored;
+    return record;
+  };
+  const tx = {
+    addOutbox: (item) => {
+      const { seq: _seq, ...rest } = item;
+      return done(store("outbox").add({ ...rest, model }));
+    },
+    clearRecords: async (keepIds) => {
+      const keys = await done(store("records").index("model").getAllKeys(model));
+      for (const key of keys) {
+        if (!keepIds.has(key[1])) await done(store("records").delete(key));
+      }
+    },
+    deleteMeta: (key) => done(store("meta").delete(key)),
+    deleteRecord: (id) => done(store("records").delete([model, id])),
+    getMeta: async (key) => (await done(store("meta").get(key)))?.value,
+    getRecord: async (id) => strip(await done(store("records").get([model, id]))),
+    listOutbox: async () => {
+      const items = await done(store("outbox").index("model").getAll(model));
+      return items.map(({ model: _model, ...item }) => item);
+    },
+    listRecords: async () => (await done(store("records").index("model").getAll(model))).map((record) => strip(record)),
+    putOutbox: (item) => done(store("outbox").put({ ...item, model })),
+    putRecord: (record) => done(store("records").put({ ...record, model })),
+    removeOutbox: async (mutationId) => {
+      const key = await done(store("outbox").index("mutationId").getKey(mutationId));
+      if (key !== void 0) await done(store("outbox").delete(key));
+    },
+    setMeta: (key, value) => done(store("meta").put({ key, value }))
+  };
+  let result;
+  try {
+    if (options.owner !== void 0 && await tx.getMeta("owner") !== options.owner) throw new LtSyncOwnerChangedError();
+    result = await fn(tx);
+  } catch (error) {
+    transaction.abort();
+    await finished.catch(() => void 0);
+    throw error;
+  }
+  await finished;
+  return result;
+}
+export async function listLtSyncPendingModels() {
+  const db = await openDatabase();
+  const transaction = db.transaction(["outbox"], "readonly");
+  const items = await done(transaction.objectStore("outbox").getAll());
+  return [...new Set(items.map((item) => item.model))];
+}
+export function getLtSyncOwner() {
+  return runLtSyncTx("", (tx) => tx.getMeta("owner"));
+}
+export async function claimLtSyncOwner(userId) {
+  const db = await openDatabase();
+  const transaction = db.transaction(STORES, "readwrite");
+  const finished = new Promise((resolve, reject) => {
+    transaction.addEventListener("complete", () => resolve());
+    transaction.addEventListener("abort", () => reject(transaction.error ?? new Error("transaction aborted")));
+    transaction.addEventListener("error", () => reject(transaction.error));
+  });
+  const meta = transaction.objectStore("meta");
+  const owner = (await done(meta.get("owner")))?.value;
+  let wiped = false;
+  if (owner !== userId) {
+    const held = await done(transaction.objectStore("records").count()) + await done(transaction.objectStore("outbox").count()) + await done(meta.count());
+    if (held > 0) {
+      for (const name of STORES) await done(transaction.objectStore(name).clear());
+      wiped = true;
+    }
+    await done(meta.put({ key: "owner", value: userId }));
+  }
+  await finished;
+  if (wiped) postLtSyncMessage({ type: "cleared" });
+  return wiped;
+}
+export async function deleteLtSyncDatabase() {
+  if (typeof indexedDB === "undefined") return;
+  await opening?.catch(() => void 0);
+  connection?.close();
+  connection = void 0;
+  await new Promise((resolve, reject) => {
+    const request = indexedDB.deleteDatabase(LT_SYNC_DB_NAME);
+    request.addEventListener("success", () => resolve());
+    request.addEventListener("error", () => reject(request.error));
+    request.addEventListener("blocked", () => void 0);
+  });
+  postLtSyncMessage({ type: "cleared" });
+}
+function postLtSyncMessage(message) {
+  if (typeof BroadcastChannel === "undefined") return;
+  const channel = new BroadcastChannel(LT_SYNC_CHANNEL_NAME);
+  try {
+    channel.postMessage(message);
+  } finally {
+    channel.close();
+  }
+}

package/dist/runtime/lib/sync.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Offline-sync client of the nest-server sync module (>= 12.2.0).
+ *
+ * The protocol is `docs/offline-sync-protocol.md` in @lenne.tech/nest-server; section numbers (§n)
+ * below point into it. This file is the protocol engine without Vue: local changes into the outbox,
+ * push, pull, conflicts, resync. `useLtOfflineSync()` adds reactivity, triggers and tab
+ * coordination on top. Ported from the nest-server's reference test client
+ * (`tests/clients/sync-client.mjs`), which passes the protocol's browser and Node scenarios.
+ *
+ * A local record is `{ id, version, updatedAt, deletedAt, data }`; `version` 0 means "created
+ * here, not on the server yet". The outbox holds the unsent changes in the order they were made.
+ * An item a push has carried (`attempted`) is never changed again: the server may have recorded it
+ * under its mutation id, and a repeat must carry the same change (§6.2, §6.5). A later edit
+ * becomes an item of its own.
+ */
+import type { LtSyncConflict, LtSyncConflictResolution, LtSyncIdFormat, LtSyncRecord, LtSyncResult } from '../types/sync.js';
+/** The request could not reach the server */
+export declare class LtSyncOfflineError extends Error {
+    constructor(cause: unknown);
+}
+/** The server answered 401: the session ended. Nothing was applied, nothing is discarded (§4) */
+export declare class LtSyncUnauthorizedError extends Error {
+    constructor();
+}
+/** The server asked to slow down: 429 with `Retry-After`, or 503 (§10) */
+export declare class LtSyncBackoffError extends Error {
+    readonly status: number;
+    readonly retryAfterMs: number | undefined;
+    constructor(status: number, retryAfterMs: number | undefined);
+}
+/**
+ * An ObjectId-hex id with the random tail §3 requires: 4 timestamp bytes plus 8 bytes from a secure
+ * source, fresh for every id. A driver's default ObjectId would make the next id predictable.
+ */
+export declare function ltSyncObjectId(): string;
+/** A uuidv7: 48 bits of milliseconds, version 7, the variant, the rest random (`crypto.randomUUID()` is v4) */
+export declare function ltSyncUuidV7(): string;
+/** The sync base path from runtime config (default `/sync`) */
+export declare function getLtSyncBasePath(): string;
+/** A full URL for a sync path, e.g. `/note?limit=200` or `/hints?models=note` */
+export declare function buildLtSyncUrl(path: string): string;
+/** Options of the protocol engine */
+export interface LtSyncEngineOptions<T> {
+    /** `fetch` for the requests (default: `ltAuthFetch`, cookie or JWT like every other request) */
+    fetch?: (input: string, init: RequestInit) => Promise<Response>;
+    idFormat?: LtSyncIdFormat;
+    /** The model's name under the sync base path */
+    model: string;
+    onConflict?: (conflict: LtSyncConflict<T>) => LtSyncConflictResolution<T> | Promise<LtSyncConflictResolution<T>>;
+    pageLimit?: number;
+    tenantId?: string;
+}
+/** The protocol engine of one model */
+export interface LtSyncEngine<T> {
+    create: (data: T) => Promise<LtSyncRecord<T>>;
+    get: (id: string) => Promise<LtSyncRecord<T> | undefined>;
+    /** The live local records, sorted by id */
+    list: () => Promise<LtSyncRecord<T>[]>;
+    readonly model: string;
+    /** Where the engine keeps its data: the model, or the model and the tenant */
+    readonly scope: string;
+    pendingCount: () => Promise<number>;
+    /** Push the outbox only — the sign-out flush. Never throws */
+    pushPending: () => Promise<void>;
+    remove: (id: string) => Promise<void>;
+    /** Push the outbox, then pull until `hasMore` is false. Never throws for offline, 401 or a backoff */
+    sync: () => Promise<LtSyncResult>;
+    update: (id: string, data: Partial<T>) => Promise<LtSyncRecord<T>>;
+}
+/**
+ * Where a model's local data lives: per model, and per tenant when one is given. A change made
+ * under one tenant must never go out with another tenant's `X-Tenant-Id` — the server stamps a
+ * create into the tenant of the header — nor show in that tenant's list.
+ */
+export declare function ltSyncScope(model: string, tenantId?: string): string;
+/** Create the protocol engine of one model and register it for the sign-out flush */
+export declare function createLtSyncEngine<T extends Record<string, unknown> = Record<string, unknown>>(options: LtSyncEngineOptions<T>): LtSyncEngine<T>;
+/**
+ * Before sign-out: send what is still unsent, for at most `timeoutMs`, never failing. Whatever
+ * did not go out is deleted with the rest afterwards — after signing out it could not be pushed
+ * under this account anyway (nest-server `SECURITY.md`).
+ *
+ * Only when the local data belongs to `userId`, the user signing out. After an expired session
+ * the outbox of the PREVIOUS user is still on the device; sent now, it would be created and
+ * changed under the current user's session and account. It is deleted unsent instead.
+ */
+export declare function flushLtSyncBeforeSignOut(userId: string | undefined, timeoutMs?: number): Promise<void>;
+/** Forget the registered engines (tests) */
+export declare function resetLtSyncEngines(): void;

package/dist/runtime/lib/sync.js

@@ -0,0 +1,369 @@
+import { useRuntimeConfig } from "#imports";
+import { buildLtApiUrl, ltAuthFetch } from "./auth-state.js";
+import { getLtSyncOwner, listLtSyncPendingModels, LtSyncOwnerChangedError, runLtSyncTx } from "./sync-store.js";
+const PUSH_CHUNK = 100;
+const MAX_PUSH_ROUNDS = 50;
+export class LtSyncOfflineError extends Error {
+  constructor(cause) {
+    super(`offline: ${cause instanceof Error ? cause.message : String(cause)}`);
+    this.name = "LtSyncOfflineError";
+  }
+}
+export class LtSyncUnauthorizedError extends Error {
+  constructor() {
+    super("unauthorized");
+    this.name = "LtSyncUnauthorizedError";
+  }
+}
+export class LtSyncBackoffError extends Error {
+  constructor(status, retryAfterMs2) {
+    super(`server answered ${status}`);
+    this.status = status;
+    this.retryAfterMs = retryAfterMs2;
+    this.name = "LtSyncBackoffError";
+  }
+}
+const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+export function ltSyncObjectId() {
+  const random = new Uint8Array(8);
+  globalThis.crypto.getRandomValues(random);
+  return Math.floor(Date.now() / 1e3).toString(16).padStart(8, "0") + hex(random);
+}
+export function ltSyncUuidV7() {
+  const bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  let time = Date.now();
+  for (let index = 5; index >= 0; index--) {
+    bytes[index] = time % 256;
+    time = Math.floor(time / 256);
+  }
+  bytes[6] = 112 | bytes[6] & 15;
+  bytes[8] = 128 | bytes[8] & 63;
+  const value = hex(bytes);
+  return `${value.slice(0, 8)}-${value.slice(8, 12)}-${value.slice(12, 16)}-${value.slice(16, 20)}-${value.slice(20)}`;
+}
+export function getLtSyncBasePath() {
+  try {
+    const rc = useRuntimeConfig();
+    const ext = rc.public.ltExtensions;
+    return ext?.sync?.basePath || "/sync";
+  } catch {
+    return "/sync";
+  }
+}
+export function buildLtSyncUrl(path) {
+  return buildLtApiUrl(`${getLtSyncBasePath()}${path}`);
+}
+function retryAfterMs(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+const engines = /* @__PURE__ */ new Map();
+export function ltSyncScope(model, tenantId) {
+  return tenantId ? `${model}#${tenantId}` : model;
+}
+function parseLtSyncScope(scope) {
+  const at = scope.indexOf("#");
+  return at === -1 ? { model: scope } : { model: scope.slice(0, at), tenantId: scope.slice(at + 1) };
+}
+function localOf(item) {
+  return {
+    data: item.deletedAt ? void 0 : item.data,
+    deletedAt: item.deletedAt ?? null,
+    id: item.id,
+    updatedAt: item.updatedAt ?? null,
+    version: item.version
+  };
+}
+function lastPending(outbox, id) {
+  return outbox.filter((item) => item.id === id).at(-1);
+}
+function nextBase(record, pending) {
+  return pending ? (pending.baseVersion ?? 0) + 1 : record.version;
+}
+function pushItem(item) {
+  const { baseVersion, data, id, mutationId, op } = item;
+  return { ...baseVersion === void 0 ? {} : { baseVersion }, ...data === void 0 ? {} : { data }, id, mutationId, op };
+}
+function emptyResult() {
+  return { applied: 0, conflicts: [], forbidden: false, needsLogin: false, offline: false, rejected: [], resynced: false, retried: 0 };
+}
+export function createLtSyncEngine(options) {
+  const { idFormat = "objectId", model, onConflict, pageLimit = 200, tenantId } = options;
+  const fetchImpl = options.fetch ?? ((input, init) => ltAuthFetch(input, init));
+  const scope = ltSyncScope(model, tenantId);
+  const cursorKey = `cursor:${scope}`;
+  const run = (fn) => runLtSyncTx(scope, fn);
+  const runAs = (owner, fn) => runLtSyncTx(scope, fn, owner === void 0 ? {} : { owner });
+  const newId = () => idFormat === "uuidv7" ? ltSyncUuidV7() : ltSyncObjectId();
+  async function request(method, path, payload) {
+    const headers = { accept: "application/json" };
+    if (payload !== void 0) headers["content-type"] = "application/json";
+    if (tenantId) headers["x-tenant-id"] = tenantId;
+    let response;
+    try {
+      response = await fetchImpl(buildLtSyncUrl(path), { body: payload === void 0 ? void 0 : JSON.stringify(payload), headers, method });
+    } catch (error) {
+      throw new LtSyncOfflineError(error);
+    }
+    if (response.status === 401) throw new LtSyncUnauthorizedError();
+    if (response.status === 429 || response.status === 503) throw new LtSyncBackoffError(response.status, retryAfterMs(response.headers.get("retry-after")));
+    const text = await response.text();
+    let body;
+    try {
+      body = text ? JSON.parse(text) : void 0;
+    } catch {
+      body = void 0;
+    }
+    if (response.status === 410 || response.status === 403 && method === "GET") return { body, status: response.status };
+    if (!response.ok) {
+      const error = new Error(`${method} ${getLtSyncBasePath()}${path} answered ${response.status}: ${text.slice(0, 300)}`);
+      error.status = response.status;
+      throw error;
+    }
+    return { body, status: response.status };
+  }
+  async function settle(tx, item, outcome, result, resolution) {
+    const status = outcome?.status;
+    if (status === "retry" || !status) {
+      result.retried++;
+      return;
+    }
+    await tx.removeOutbox(item.mutationId);
+    const record = await tx.getRecord(item.id);
+    if (status === "applied") {
+      result.applied++;
+      if (item.op === "delete") {
+        await tx.deleteRecord(item.id);
+      } else if (record && (record.version ?? 0) < (outcome.version ?? 0)) {
+        await tx.putRecord({ ...record, version: outcome.version });
+      }
+      return;
+    }
+    const later = (await tx.listOutbox()).filter((entry) => entry.id === item.id);
+    if (status === "merged" && outcome.record) {
+      result.applied++;
+      const pendingData = later.filter((entry) => entry.op === "upsert").reduce((data, entry) => ({ ...data, ...entry.data }), {});
+      const merged = localOf(outcome.record);
+      await tx.putRecord(merged.deletedAt ? merged : { ...merged, data: { ...merged.data, ...pendingData } });
+      return;
+    }
+    if (status === "conflict") {
+      result.conflicts.push(outcome);
+      for (const entry of later) await tx.removeOutbox(entry.mutationId);
+      if (!outcome.record || outcome.record.deletedAt) {
+        await tx.deleteRecord(item.id);
+        return;
+      }
+      const server = localOf(outcome.record);
+      if (resolution === "server") {
+        await tx.putRecord(server);
+        return;
+      }
+      await tx.putRecord({ ...server, data: { ...server.data, ...resolution.data } });
+      await tx.addOutbox({ baseVersion: server.version, data: resolution.data, id: item.id, mutationId: ltSyncUuidV7(), op: "upsert" });
+      return;
+    }
+    for (const entry of later) await tx.removeOutbox(entry.mutationId);
+    if (status === "not_found") {
+      await tx.deleteRecord(item.id);
+      return;
+    }
+    result.rejected.push(outcome);
+    if (record && !record.version) {
+      await tx.deleteRecord(item.id);
+    } else if (record) {
+      await tx.deleteMeta(cursorKey);
+    }
+  }
+  async function resolveConflict(item, outcome) {
+    if (outcome?.status !== "conflict" || !onConflict || !outcome.record || outcome.record.deletedAt) return "server";
+    const local = await run((tx) => tx.getRecord(item.id));
+    const answer = await onConflict({ change: { data: item.data, op: item.op }, local, server: localOf(outcome.record) });
+    return answer === "server" || !answer?.data ? "server" : answer;
+  }
+  async function push(result, owner) {
+    const carried = /* @__PURE__ */ new Set();
+    for (let round = 0; round < MAX_PUSH_ROUNDS; round++) {
+      const chunk = await runAs(owner, async (tx) => {
+        const records = /* @__PURE__ */ new Set();
+        const items = [];
+        for (const item of await tx.listOutbox()) {
+          if (items.length === PUSH_CHUNK) break;
+          if (records.has(item.id)) continue;
+          records.add(item.id);
+          if (!carried.has(item.mutationId)) items.push(item);
+        }
+        for (const item of items) await tx.putOutbox({ ...item, attempted: true });
+        return items;
+      });
+      if (!chunk.length) return;
+      for (const item of chunk) carried.add(item.mutationId);
+      const response = await request("POST", `/${encodeURIComponent(model)}`, { items: chunk.map(pushItem) });
+      const results = response.body?.results ?? [];
+      for (let index = 0; index < chunk.length; index++) {
+        const item = chunk[index];
+        const resolution = await resolveConflict(item, results[index]);
+        await runAs(owner, (tx) => settle(tx, item, results[index], result, resolution));
+      }
+    }
+  }
+  async function pull(result, owner) {
+    let cursor = await run((tx) => tx.getMeta(cursorKey));
+    for (let page = 0; page < 1e4; page++) {
+      const query = new URLSearchParams({ limit: String(pageLimit) });
+      if (cursor) query.set("cursor", cursor);
+      const response = await request("GET", `/${encodeURIComponent(model)}?${query}`);
+      if (response.status === 403) {
+        result.forbidden = true;
+        await runAs(owner, async (tx) => {
+          await tx.clearRecords(new Set((await tx.listOutbox()).map((item) => item.id)));
+          await tx.deleteMeta(cursorKey);
+        });
+        return false;
+      }
+      if (response.status === 410) {
+        if (result.resynced) throw new Error(`resync loop: ${JSON.stringify(response.body)}`);
+        result.resynced = true;
+        await runAs(owner, async (tx) => {
+          await tx.clearRecords(new Set((await tx.listOutbox()).map((item) => item.id)));
+          await tx.deleteMeta(cursorKey);
+        });
+        cursor = void 0;
+        continue;
+      }
+      const body = response.body;
+      await runAs(owner, async (tx) => {
+        const pending = new Set((await tx.listOutbox()).map((item) => item.id));
+        for (const item of body.items ?? []) {
+          if (pending.has(item.id)) continue;
+          const local = await tx.getRecord(item.id);
+          if (local && local.version > item.version) continue;
+          if (item.deletedAt) await tx.deleteRecord(item.id);
+          else await tx.putRecord(localOf(item));
+        }
+        await tx.setMeta(cursorKey, body.cursor);
+      });
+      cursor = body.cursor;
+      if (!body.hasMore) return result.resynced;
+    }
+    throw new Error("pull did not end");
+  }
+  async function syncOnce() {
+    const result = emptyResult();
+    try {
+      const owner = await getLtSyncOwner();
+      await push(result, owner);
+      if (await pull(result, owner)) await push(result, owner);
+    } catch (error) {
+      if (error instanceof LtSyncOwnerChangedError) return result;
+      if (error instanceof LtSyncUnauthorizedError) result.needsLogin = true;
+      else if (error instanceof LtSyncOfflineError) result.offline = true;
+      else if (error instanceof LtSyncBackoffError) result.retryAfterMs = error.retryAfterMs ?? 0;
+      else throw error;
+    }
+    return result;
+  }
+  async function syncLocked() {
+    const locks = typeof navigator === "undefined" ? void 0 : navigator.locks;
+    if (!locks) return syncOnce();
+    return await locks.request(`lt-offline-sync:${scope}`, syncOnce);
+  }
+  let current = null;
+  let next = null;
+  function sync() {
+    if (!current) {
+      current = syncLocked().finally(() => {
+        current = null;
+      });
+      return current;
+    }
+    next ??= current.catch(() => void 0).then(() => {
+      next = null;
+      return sync();
+    });
+    return next;
+  }
+  const engine = {
+    async create(data) {
+      const record = { data, deletedAt: null, id: newId(), updatedAt: null, version: 0 };
+      await run(async (tx) => {
+        await tx.putRecord(record);
+        await tx.addOutbox({ data, id: record.id, mutationId: ltSyncUuidV7(), op: "upsert" });
+      });
+      return record;
+    },
+    get: (id) => run((tx) => tx.getRecord(id)),
+    async list() {
+      const records = await run((tx) => tx.listRecords());
+      return records.filter((record) => !record.deletedAt).sort((a, b) => a.id < b.id ? -1 : 1);
+    },
+    model,
+    pendingCount: () => run(async (tx) => (await tx.listOutbox()).length),
+    async pushPending() {
+      try {
+        await push(emptyResult(), await getLtSyncOwner());
+      } catch {
+      }
+    },
+    scope,
+    async remove(id) {
+      await run(async (tx) => {
+        const record = await tx.getRecord(id);
+        if (!record || record.deletedAt) return;
+        const pending = lastPending(await tx.listOutbox(), id);
+        if (pending && !pending.attempted) {
+          await tx.removeOutbox(pending.mutationId);
+          if (pending.baseVersion === void 0) {
+            await tx.deleteRecord(id);
+            return;
+          }
+        }
+        const baseVersion = pending && !pending.attempted ? pending.baseVersion : nextBase(record, pending);
+        await tx.addOutbox({ baseVersion, id, mutationId: ltSyncUuidV7(), op: "delete" });
+        await tx.putRecord({ ...record, data: void 0, deletedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      });
+    },
+    sync,
+    async update(id, data) {
+      return run(async (tx) => {
+        const record = await tx.getRecord(id);
+        if (!record || record.deletedAt) throw new Error(`no live local record ${id}`);
+        const pending = lastPending(await tx.listOutbox(), id);
+        if (pending && pending.op === "upsert" && !pending.attempted) {
+          await tx.putOutbox({ ...pending, data: { ...pending.data, ...data } });
+        } else {
+          await tx.addOutbox({ baseVersion: nextBase(record, pending), data, id, mutationId: ltSyncUuidV7(), op: "upsert" });
+        }
+        const changed = { ...record, data: { ...record.data, ...data } };
+        await tx.putRecord(changed);
+        return changed;
+      });
+    }
+  };
+  engines.set(scope, engine);
+  return engine;
+}
+export async function flushLtSyncBeforeSignOut(userId, timeoutMs = 5e3) {
+  if (typeof indexedDB === "undefined" || !userId) return;
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(resolve, timeoutMs);
+  });
+  const flush = (async () => {
+    if (await getLtSyncOwner().catch(() => void 0) !== userId) return;
+    const scopes = await listLtSyncPendingModels().catch(() => []);
+    await Promise.all(scopes.map((scope) => (engines.get(scope) ?? createLtSyncEngine(parseLtSyncScope(scope))).pushPending()));
+  })();
+  try {
+    await Promise.race([flush, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+export function resetLtSyncEngines() {
+  engines.clear();
+}

package/dist/runtime/plugins/form-label-association.client.d.ts

@@ -66,6 +66,7 @@
  *
  * Default on; opt out with `ltExtensions.formLabelAssociation.enabled: false`.
  */
+import type { ObjectPlugin, Plugin } from '#app';
 /**
  * Re-point every dangling field label at the control in its own field.
  *
@@ -123,5 +124,5 @@ export declare function repairFieldAssociations(root: Document | ParentNode): {
     groups: number;
     labels: number;
 };
-declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+declare const _default: Plugin & ObjectPlugin;
 export default _default;

package/dist/runtime/plugins/pre-hydration-input.client.d.ts

@@ -51,6 +51,7 @@
  * browsers do not raise the on-screen keyboard for it. Preserving the entry avoids all of
  * that, because the field is never anything other than a normal, editable field.
  */
+import type { ObjectPlugin, Plugin } from '#app';
 type EditableField = HTMLInputElement | HTMLTextAreaElement;
 /**
  * Collect fields the user edited before hydration.
@@ -67,5 +68,5 @@ export declare function collectEditedFields(root: ParentNode): Map<EditableField
  * @returns `true` when a value was actually restored.
  */
 export declare function restoreField(field: EditableField, value: string): boolean;
-declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+declare const _default: Plugin & ObjectPlugin;
 export default _default;

package/dist/runtime/types/index.d.ts

@@ -2,4 +2,5 @@ export type { LtAuthClientConfig, LtAuthMode, LtAuthResponse, LtAuthState, LtPas
 export type { LtFileInfo, LtUploadItem, LtUploadOptions, LtUploadProgress, LtUploadStatus, UseLtFileReturn, UseLtTusUploadReturn } from './upload.js';
 export type { LtAiModuleOptions, LtAuthCookieNamesOptions, LtAuthModuleOptions, LtErrorTranslationModuleOptions, LtExtensionsModuleOptions, LtExtensionsPublicRuntimeConfig, LtFormLabelAssociationOptions, LtI18nModuleOptions, LtPreHydrationInputOptions, LtSystemSetupModuleOptions, LtTusModuleOptions, } from './module.js';
 export type { LtErrorTranslationResponse, LtParsedError, UseLtErrorTranslationReturn } from './error.js';
+export type { LtSyncConflict, LtSyncConflictResolution, LtSyncIdFormat, LtSyncItemStatus, LtSyncModuleOptions, LtSyncPushResult, LtSyncRecord, LtSyncResult, UseLtOfflineSyncOptions, UseLtOfflineSyncReturn, } from './sync.js';
 export type { LtAiAction, LtAiAvailableConnection, LtAiBudgetLimit, LtAiBudgetSummary, LtAiConnection, LtAiConnectionInput, LtAiConnectionPreference, LtAiEffectiveSlot, LtAiInteraction, LtAiMessage, LtAiMode, LtAiPlaceholder, LtAiPrompt, LtAiPromptHint, LtAiPromptHintInput, LtAiPromptInput, LtAiPromptRunInput, LtAiResponse, LtAiSlot, LtAiSlotInput, LtAiStreamEvent, LtAiStreamHandlers, LtAiUsage, LtAiUsageInfo, LtAiUsageScope, UseLtAiAdminReturn, UseLtAiChatOptions, UseLtAiChatReturn, UseLtAiConnectionsReturn, UseLtAiPlaceholdersReturn, UseLtAiPromptsReturn, UseLtAiReturn, UseLtAiUsageReturn, } from './ai.js';

package/dist/runtime/types/module.d.ts

@@ -1,3 +1,4 @@
+import type { LtSyncModuleOptions } from './sync.js';
 /**
  * System setup module configuration options
  *
@@ -147,6 +148,8 @@ export interface LtExtensionsModuleOptions {
     i18n?: LtI18nModuleOptions;
     /** Pre-hydration input preservation configuration */
     preHydrationInput?: LtPreHydrationInputOptions;
+    /** Offline sync with the nest-server sync module (opt-in) */
+    sync?: LtSyncModuleOptions;
     /** TUS upload module configuration */
     tus?: LtTusModuleOptions;
 }
@@ -312,6 +315,10 @@ export interface LtExtensionsPublicRuntimeConfig {
             enabled: boolean;
             maxRestoreMs: number;
         };
+        sync: {
+            basePath: string;
+            enabled: boolean;
+        };
         tus: {
             defaultChunkSize: number;
             defaultEndpoint: string;