@lenne.tech/nuxt-extensions 1.20.1 → 1.22.0

package/CLAUDE.md

@@ -40,11 +40,18 @@ src/
 | `useLtAi()` | One-shot `prompt()` + streaming `promptStream()` (POST `/ai/prompt` / `/ai/stream`) |
 | `useLtAiChat()` | Multi-turn chat: streaming, budget summary, confirmation gate, `stop()`/`clear()`, optional `maxMessages` cap, auto-stop on unmount |
 | `useLtAiConnections()` | User-facing list of available connections + `select()` |
+| `useLtAiSettings()` | The user's own AI settings: MCP confirmation switch (`GET/PUT /ai/settings`, `enforced` → show disabled) |
 | `useLtAiUsage()` | Full token/prompt usage breakdown (`GET /ai/usage`) |
 | `useLtAiPrompts()` | User-facing CRUD for re-usable prompt snippets ("Vorlagen", `scope: 'user'` / `'tenant'`) |
 | `useLtAiPlaceholders()` | Loads the backend's `{{placeholder}}` registry for editor sidebars |
 | `useLtAiAdmin()` | Admin CRUD: connections, preferences, budget limits, slots, prompt hints, interactions — server-gated |
 
+### Offline sync (nest-server sync module, opt-in)
+
+| Composable | Purpose |
+|-----------|---------|
+| `useLtOfflineSync(model, options?)` | Offline read/write of one model in IndexedDB; push/pull against `/sync`, hints, conflicts, tabs, owner check |
+
 ## Module Configuration
 
 Configure in `nuxt.config.ts` (top-level key is `ltExtensions`):
@@ -76,6 +83,10 @@ export default defineNuxtConfig({
       enabled: true,
       basePath: '/ai',               // Must match the nest-server AI controller
     },
+    sync: {
+      enabled: false,                // opt-in: useLtOfflineSync() + sign-out cleanup
+      basePath: '/sync',             // Must match the nest-server sync module
+    },
     formLabelAssociation: {
       enabled: true,                 // repair <label for> broken by an SSR/client useId() divergence
       maxRepairMs: 1500,             // how long to keep repairing deferred subtrees
@@ -112,6 +123,60 @@ The API base URL is resolved at runtime from `NUXT_PUBLIC_API_URL` (client + SSR
 - `useLtAiAdmin()` is exposed as a regular composable; admin gating is enforced server-side (`@Restricted(ADMIN)`). Render admin UI behind a frontend route guard for UX, but trust the backend for authorization.
 - The chat composable's `messages` ref is a shallow `Readonly<Ref<LtAiMessage[]>>` so child components can bind individual messages while preserving streaming reactivity.
 
+## Offline Sync
+
+`useLtOfflineSync()` is the client of the nest-server sync module (>= 12.2.0); the protocol is
+`docs/offline-sync-protocol.md` in nest-server. Both ends are opt-in: `ltExtensions.sync.enabled`
+here, a sync model (`@PersistedModel({ sync })` + `@SyncService`) on the API.
+
+**The local data belongs to the signed-in user, and only explicit sign-out deletes it:**
+
+- `useLtAuth().signOut()` sends what is unsent (at most 5 s), signs out, then deletes the whole
+  IndexedDB database `lt-offline-sync`. **A custom sign-out that bypasses it must call
+  `flushLtSyncBeforeSignOut(userId)` and `deleteLtSyncDatabase()` (from `/lib`) itself** — otherwise
+  the user's records stay on the device.
+- **The flush sends only the signing-out user's own changes.** After an expired session the outbox
+  of the PREVIOUS user is still there; pushed under the current session it would land in the
+  current user's account. `flushLtSyncBeforeSignOut` compares the stored owner with `userId`.
+- **An expired session deletes nothing.** The 401 interceptor calls `clearUser()`, not `signOut()`,
+  on purpose: the protocol promises that after signing in again the same changes go out without
+  duplicates. Never hook the sync cleanup into `clearUser()` — that would delete unsent work on
+  every expired session.
+- Another user wipes the data before anything is shown or pulled (`claimLtSyncOwner`, one
+  transaction); so does data WITHOUT an owner. Nobody signed in sees nothing.
+- **Every write of a sync run is fenced by the owner it started for** (`runLtSyncTx(…, { owner })`).
+  An answer arriving after sign-out deleted the database, or after another account claimed it,
+  would otherwise reopen the database and write the previous user's records for the next one.
+- Local data is kept per model AND tenant (`ltSyncScope`): the server stamps a create into the
+  tenant of its `X-Tenant-Id`, so one tenant's unsent change must never go out under another.
+
+**Rules that keep the engine correct (`src/runtime/lib/sync.ts`):**
+
+- A push carries at most ONE change per record, and the next one goes out only once the one before
+  it is `applied` or `merged`. Its `baseVersion` assumes exactly that; sent while the first is open
+  (`retry`) or after it was refused (`rejected`, `not_found`, `conflict`), it can meet another
+  writer's version with the same number and be applied on top of it. So it waits behind a `retry`
+  and is dropped after a refusal (protocol §11 since nest-server 12.3.0, which also guards this
+  server-side within one request).
+- An outbox item a push has carried (`attempted`) is never edited again; a later edit becomes a new
+  item. Read-and-mark happens in one IndexedDB transaction.
+- `onConflict` runs outside any IndexedDB transaction (an awaited hook would let the transaction
+  auto-commit). Nothing inside `runLtSyncTx()` may await anything but that transaction's requests.
+- Hints are read with `fetch`, not `EventSource` (no `Authorization` header in JWT mode). Every
+  reconnect pulls once: the server ends the stream on purpose and never replays the hint it missed.
+- ONE hint stream per tab and tenant (`subscribeLtSyncHints`), for every model in use. A stream per
+  composable call holds a connection each; over HTTP/1.1 six of them stall every API request.
+- A refused change (`rejected`) to a record the server has drops the cursor, so the pull right after
+  restores the server's state; otherwise the device would keep showing the refused value.
+
+**Tests:** `test/sync-engine.test.ts` runs the protocol's five client scenarios (offline
+create/change/delete, conflict, two tabs, expired session, cleared storage) against
+`test/fixtures/sync-server.ts` with `fake-indexeddb`. The browser E2E against a real nest-server
+lives in the nuxt-base-starter (DEV-3919).
+
+A service worker must never cache `/sync` or `/iam` responses (nest-server
+`src/core/modules/sync/SECURITY.md`).
+
 ## Testing Helpers
 
 Import from `@lenne.tech/nuxt-extensions/testing`:

package/README.md

@@ -79,6 +79,7 @@ overrides:
 - **Better-Auth Integration** - Login, 2FA, Passkey/WebAuthn support
 - **Cookie/JWT Dual-Mode** - Automatic fallback from cookies to JWT
 - **TUS File Upload** - Resumable uploads with pause/resume
+- **Offline Sync** - Read and write offline, reconcile with the nest-server sync module (opt-in)
 - **Transition Components** - Ready-to-use Vue transition wrappers
 - **i18n Support** - English and German translations (works without i18n too)
 - **Auto-imports** - All composables and components are auto-imported
@@ -196,6 +197,12 @@ export default defineNuxtConfig({
       enabled: true,                // Enable AI composables / auto-imports
       basePath: '/ai',              // Must match the nest-server AI controller
     },
+
+    // Offline sync (opt-in, see "Offline Sync" below)
+    sync: {
+      enabled: false,               // Enable useLtOfflineSync() and the sign-out cleanup
+      basePath: '/sync',            // Must match the nest-server sync module
+    },
   },
 });
 ```
@@ -702,6 +709,45 @@ await load();
 is private to the owner; `scope: 'tenant'` is shared across the owner's tenant. The list
 returned by `load()` is already server-filtered to what the user is allowed to see.
 
+### MCP confirmation switch
+
+Over MCP (Claude Desktop, Claude Code and other clients), nest-server 12.3.0 or later asks the
+user before a destructive tool runs, and before a mutating one if the server is configured that
+way. Each user may switch the question off for themselves, like a "bypass permissions" mode.
+`useLtAiSettings()` reads and changes that switch (`GET/PUT /ai/settings`):
+
+```vue
+<script setup lang="ts">
+const { enforced, load, settings, update } = useLtAiSettings();
+await load();
+
+async function toggle(value: boolean) {
+  try {
+    await update({ mcpConfirmation: value });
+  } catch {
+    // `error` holds the message; `settings` keeps the previous value, so the switch snaps back
+  }
+}
+</script>
+
+<template>
+  <USwitch
+    :model-value="settings?.mcpConfirmation"
+    :disabled="enforced || !settings"
+    label="Ask before destructive AI actions over MCP"
+    @update:model-value="toggle"
+  />
+</template>
+```
+
+- `settings` is always the value as it takes effect, never just the stored choice. `update()`
+  adopts the server's answer instead of the input.
+- `enforced` is true when the server fixed the value (`ai.mcp.confirmation.enforced`). Show the
+  switch disabled. A change is refused with 403 `#LTNS_0609`, which `update()` throws.
+- Switching it off lets an MCP client run destructive tools in this user's name without asking.
+  Say so next to the switch. The tool's own `authorize()` check and the admin's `deny` / `ask`
+  rules still apply, and other users and the in-app chat are not affected.
+
 ### Lower-level + supporting composables
 
 | Composable | Purpose |
@@ -709,6 +755,7 @@ returned by `load()` is already server-filtered to what the user is allowed to s
 | `useLtAi()` | One-shot `prompt(input)` and streaming `promptStream(input, handlers)` (POST `/ai/stream`) |
 | `useLtAiChat()` | Multi-turn chat state, streaming, budget, confirmation, `stop()`/`clear()`, optional `maxMessages` cap, auto-stop on component unmount |
 | `useLtAiConnections()` | User self-service: available connections + `select()` (`selected`/`locked`) |
+| `useLtAiSettings()` | The user's own AI settings: the MCP confirmation switch + `update()` (`enforced`) |
 | `useLtAiUsage()` | Full token/prompt usage breakdown (`GET /ai/usage`) |
 | `useLtAiPrompts()` | User-facing CRUD for re-usable prompt snippets ("Vorlagen", `scope: 'user'` / `'tenant'`) |
 | `useLtAiPlaceholders()` | Loads `{{placeholder}}` registry from the backend so slot / prompt editors render a dynamic helper sidebar |
@@ -722,6 +769,79 @@ All AI DTOs are exported as `LtAi*` types. The streaming endpoint is consumed vi
 > is enforced server-side (`@Restricted(ADMIN)`). Render admin UI behind a frontend
 > route guard for UX, but trust the backend for authorization.
 
+## Offline Sync
+
+Read and write while disconnected, reconcile when back. `useLtOfflineSync()` is the client of the
+`@lenne.tech/nest-server` **sync module** (12.2.0 or later); the protocol is
+`docs/offline-sync-protocol.md` in nest-server. It is opt-in, both here and on the server:
+
+```typescript
+// nuxt.config.ts
+ltExtensions: {
+  sync: { enabled: true, basePath: '/sync' }, // basePath must match the nest-server sync module
+}
+```
+
+The API needs a sync model too: `@PersistedModel({ sync })` on the model and `@SyncService` on its
+CrudService (nest-server `src/core/modules/sync/README.md`).
+
+```vue
+<script setup lang="ts">
+const { create, needsLogin, offline, pendingCount, records, remove } = useLtOfflineSync<{ title: string }>('note');
+
+// Works offline: the change shows at once and waits in the outbox until the next sync
+const add = (title: string) => create({ title });
+</script>
+
+<template>
+  <p v-if="offline">Offline — {{ pendingCount }} changes waiting</p>
+  <p v-if="needsLogin">Please sign in again; nothing is lost</p>
+  <ul>
+    <li v-for="note in records" :key="note.id">
+      {{ note.data?.title }} <button @click="remove(note.id)">Delete</button>
+    </li>
+  </ul>
+</template>
+```
+
+**What it does:**
+
+- Keeps records, cursors and unsent changes in IndexedDB. Each change carries a `mutationId` and
+  the `baseVersion` it is based on, so a repeated send never duplicates and a stale one conflicts.
+- Syncs at start, on `online`, on focus, shortly after a local change, and after a server hint
+  (`GET <basePath>/hints`, read with `fetch` so it signs in with a cookie and a JWT alike). Every
+  reconnect of the hint stream pulls once: the server ends the stream on purpose and does not
+  replay what it missed. All instances of a tab share one stream per tenant, and a hidden tab
+  keeps none open.
+- Handles every item status and HTTP status of the protocol: `401` keeps everything (sign in again,
+  the same changes go out without duplicates), `410` drops the local records and pulls everything
+  again while keeping unsent changes, `403` on a pull drops the model's records, `429`/`503` and
+  network errors back off. A refused change is dropped and the record returns to the server's state.
+- Tabs share the data: one syncs at a time (Web Locks), the others show the result
+  (BroadcastChannel).
+
+**Options:** `idFormat` (`'objectId'` default, `'uuidv7'` for models declared with it),
+`onConflict` (default: the server wins; return `{ data }` to send your answer again on top of the
+server's version), `tenantId` (`X-Tenant-Id`; records and unsent changes are kept per tenant, so a
+change made under one tenant never goes out under another), `pageLimit`, `hints: false`,
+`auto: false` (only `sync()` syncs).
+
+**Whose data it is.** The local data belongs to the signed-in user:
+
+| Event | Local data |
+|-------|-----------|
+| `useLtAuth().signOut()` | The user's own unsent changes are sent (at most 5 s), then the whole database is deleted |
+| Another user signs in | Deleted before anything is shown or pulled |
+| Session expired, same user signs in again | Kept; the outbox goes out without duplicates |
+| Nobody signed in | Nothing shown, changes refused |
+
+A sync answer that arrives after the sign-out or the account switch is discarded, not stored. A
+sign-out flow that bypasses `useLtAuth().signOut()` must do the same itself:
+`flushLtSyncBeforeSignOut(userId)` and `deleteLtSyncDatabase()` from
+`@lenne.tech/nuxt-extensions/lib`. The flush sends only when the local data belongs to `userId`.
+`pendingCount` lets the app warn before signing out. A service worker must never cache responses
+of `/sync` or `/iam` (nest-server `src/core/modules/sync/SECURITY.md`).
+
 ## i18n Support
 
 The package works **with or without** `@nuxtjs/i18n`:
@@ -749,10 +869,12 @@ The package works **with or without** `@nuxtjs/i18n`:
 | `useLtAi()` | One-shot `prompt()` + streaming `promptStream()` for the nest-server AI module |
 | `useLtAiChat()` | Multi-turn chat state, streaming, budget summary, confirmation gate, `maxMessages` cap |
 | `useLtAiConnections()` | User self-service connection list + `select()` |
+| `useLtAiSettings()` | The user's own AI settings (MCP confirmation switch, nest-server >= 12.3.0) |
 | `useLtAiUsage()` | Token/prompt usage breakdown per user / tenant |
 | `useLtAiPrompts()` | User-facing prompt snippet CRUD (`'user'` / `'tenant'` scope) |
 | `useLtAiPlaceholders()` | Loads the backend's `{{placeholder}}` registry |
 | `useLtAiAdmin()` | Admin CRUD for connections, preferences, budget limits, slots, prompt hints, interactions |
+| `useLtOfflineSync()` | Offline read/write of one model, synced with the nest-server sync module (opt-in) |
 
 ### Components
 

package/dist/module.d.mts

@@ -3,7 +3,7 @@ import { LtExtensionsModuleOptions } from '../dist/runtime/types/index.js';
 export * from '../dist/runtime/types/index.js';
 
 declare const name = "@lenne.tech/nuxt-extensions";
-declare const version = "1.20.1";
+declare const version = "1.22.0";
 declare const configKey = "ltExtensions";
 declare const DEFAULT_LT_AUTH_STATE_COOKIE = "lt-auth-state";
 declare const DEFAULT_LT_JWT_TOKEN_COOKIE = "lt-jwt-token";

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "configKey": "ltExtensions",
   "name": "@lenne.tech/nuxt-extensions",
-  "version": "1.20.1",
+  "version": "1.22.0",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -2,7 +2,7 @@ import { defineNuxtModule, createResolver, tryResolveModule, addImports, addComp
 import { pathToFileURL } from 'node:url';
 
 const name = "@lenne.tech/nuxt-extensions";
-const version = "1.20.1";
+const version = "1.22.0";
 const configKey = "ltExtensions";
 const DEFAULT_LT_AUTH_STATE_COOKIE = "lt-auth-state";
 const DEFAULT_LT_JWT_TOKEN_COOKIE = "lt-jwt-token";
@@ -46,6 +46,11 @@ const defaultOptions = {
   preHydrationInput: {
     enabled: true
   },
+  // Opt-in: an app without offline sync gets no auto-import and no sign-out cleanup
+  sync: {
+    basePath: "/sync",
+    enabled: false
+  },
   tus: {
     defaultChunkSize: 5 * 1024 * 1024,
     // 5MB
@@ -74,6 +79,7 @@ const module$1 = defineNuxtModule({
       formLabelAssociation: { ...defaultOptions.formLabelAssociation, ...options.formLabelAssociation },
       i18n: { ...defaultOptions.i18n, ...options.i18n },
       preHydrationInput: { ...defaultOptions.preHydrationInput, ...options.preHydrationInput },
+      sync: { ...defaultOptions.sync, ...options.sync },
       tus: { ...defaultOptions.tus, ...options.tus }
     };
     const passkeyAvailable = !!await tryResolveModule("@better-auth/passkey/client", [new URL(import.meta.url), pathToFileURL(`${nuxt.options.rootDir}/`)]);
@@ -146,6 +152,10 @@ const module$1 = defineNuxtModule({
         enabled: resolvedOptions.preHydrationInput?.enabled ?? true,
         maxRestoreMs: resolvedOptions.preHydrationInput?.maxRestoreMs ?? 1500
       },
+      sync: {
+        basePath: resolvedOptions.sync?.basePath || "/sync",
+        enabled: resolvedOptions.sync?.enabled ?? false
+      },
       tus: {
         defaultChunkSize: resolvedOptions.tus?.defaultChunkSize || 5 * 1024 * 1024,
         defaultEndpoint: resolvedOptions.tus?.defaultEndpoint || "/files/upload",
@@ -194,6 +204,7 @@ const module$1 = defineNuxtModule({
         { name: "useLtAi", from: resolve("./runtime/composables/use-lt-ai") },
         { name: "useLtAiChat", from: resolve("./runtime/composables/use-lt-ai-chat") },
         { name: "useLtAiConnections", from: resolve("./runtime/composables/use-lt-ai-connections") },
+        { name: "useLtAiSettings", from: resolve("./runtime/composables/use-lt-ai-settings") },
         { name: "useLtAiUsage", from: resolve("./runtime/composables/use-lt-ai-usage") },
         { name: "useLtAiPrompts", from: resolve("./runtime/composables/use-lt-ai-prompts") },
         { name: "useLtAiPlaceholders", from: resolve("./runtime/composables/use-lt-ai-placeholders") },
@@ -203,6 +214,9 @@ const module$1 = defineNuxtModule({
         { name: "parseLtAiSseStream", from: resolve("./runtime/lib/ai") }
       ]);
     }
+    if (resolvedOptions.sync?.enabled) {
+      addImports([{ name: "useLtOfflineSync", from: resolve("./runtime/composables/use-lt-offline-sync") }]);
+    }
     const transitionComponents = ["LtTransitionFade", "LtTransitionSlide", "LtTransitionSlideBottom", "LtTransitionSlideRevert", "LtTransitionFadeScale"];
     for (const componentName of transitionComponents) {
       addComponent({

package/dist/runtime/components/transition/LtTransitionFade.d.vue.ts

@@ -21,10 +21,12 @@ type __VLS_Props = {
     /** Duration in ms for the enter animation (default: 100) */
     startDuration?: `${number}` | number;
 };
-declare var __VLS_7: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
 };
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("@vue/runtime-core").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     leaveDuration: number | `${number}`;
     startDuration: number | `${number}`;

package/dist/runtime/components/transition/LtTransitionFade.vue.d.ts

@@ -21,10 +21,12 @@ type __VLS_Props = {
     /** Duration in ms for the enter animation (default: 100) */
     startDuration?: `${number}` | number;
 };
-declare var __VLS_7: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
 };
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("@vue/runtime-core").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     leaveDuration: number | `${number}`;
     startDuration: number | `${number}`;

package/dist/runtime/components/transition/LtTransitionFadeScale.d.vue.ts

@@ -24,10 +24,12 @@ type __VLS_Props = {
     /** Duration in ms for the enter animation (default: 100) */
     startDuration?: `${number}` | number;
 };
-declare var __VLS_7: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
 };
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("@vue/runtime-core").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     leaveDuration: number | `${number}`;
     startDuration: number | `${number}`;

package/dist/runtime/components/transition/LtTransitionFadeScale.vue.d.ts

@@ -24,10 +24,12 @@ type __VLS_Props = {
     /** Duration in ms for the enter animation (default: 100) */
     startDuration?: `${number}` | number;
 };
-declare var __VLS_7: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
 };
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("@vue/runtime-core").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     leaveDuration: number | `${number}`;
     startDuration: number | `${number}`;

package/dist/runtime/components/transition/LtTransitionSlide.d.vue.ts

@@ -1,7 +1,9 @@
-declare var __VLS_7: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
 };
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("@vue/runtime-core").DefineComponent<{}, {}, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/transition/LtTransitionSlide.vue.d.ts

@@ -1,7 +1,9 @@
-declare var __VLS_7: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
 };
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("@vue/runtime-core").DefineComponent<{}, {}, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/transition/LtTransitionSlideBottom.d.vue.ts

@@ -1,7 +1,9 @@
-declare var __VLS_7: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
 };
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("@vue/runtime-core").DefineComponent<{}, {}, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/transition/LtTransitionSlideBottom.vue.d.ts

@@ -1,7 +1,9 @@
-declare var __VLS_7: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
 };
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("@vue/runtime-core").DefineComponent<{}, {}, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/transition/LtTransitionSlideRevert.d.vue.ts

@@ -1,7 +1,9 @@
-declare var __VLS_7: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
 };
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("@vue/runtime-core").DefineComponent<{}, {}, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/transition/LtTransitionSlideRevert.vue.d.ts

@@ -1,7 +1,9 @@
-declare var __VLS_7: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
 };
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("@vue/runtime-core").DefineComponent<{}, {}, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/composables/auth/use-lt-auth.js

@@ -1,8 +1,17 @@
-import { useNuxtApp, useCookie, useState, useRequestHeaders, ref, computed, watch } from "#imports";
+import { useNuxtApp, useCookie, useState, useRequestHeaders, useRuntimeConfig, ref, computed, watch } from "#imports";
 import { ltArrayBufferToBase64Url, ltBase64UrlToUint8Array } from "../../utils/crypto.js";
 import { clearLtAuthCookies, getLtApiBase, getLtAuthCookieNames, resolveLtAuthState } from "../../lib/auth-state.js";
 import { useLtAuthClient } from "../use-lt-auth-client.js";
 const VALIDATE_SESSION_TIMEOUT_MS = 1e4;
+const LT_SYNC_SIGN_OUT_FLUSH_MS = 5e3;
+function isLtSyncEnabled() {
+  if (!import.meta.client) return false;
+  try {
+    return !!useRuntimeConfig().public.ltExtensions?.sync?.enabled;
+  } catch {
+    return false;
+  }
+}
 let staleJwtRefresh = null;
 function useTranslation() {
   const nuxtApp = useNuxtApp();
@@ -291,8 +300,14 @@ export function useLtAuth() {
   const signOut = async (options) => {
     isLoading.value = true;
     try {
+      const sync = isLtSyncEnabled() ? await import("../../lib/sync.js") : null;
+      await sync?.flushLtSyncBeforeSignOut(user.value?.id ? String(user.value.id) : void 0, LT_SYNC_SIGN_OUT_FLUSH_MS);
       const result = await authClient.signOut(options);
       clearUser();
+      if (sync) {
+        const { deleteLtSyncDatabase } = await import("../../lib/sync-store.js");
+        await deleteLtSyncDatabase().catch((error) => console.error("[LtAuth] Could not delete the local offline-sync data on sign-out:", error));
+      }
       return result;
     } finally {
       isLoading.value = false;

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

@@ -8,7 +8,9 @@ export { useLtErrorTranslation } from './use-lt-error-translation.js';
 export { useLtAi } from './use-lt-ai.js';
 export { useLtAiChat } from './use-lt-ai-chat.js';
 export { useLtAiConnections } from './use-lt-ai-connections.js';
+export { useLtAiSettings } from './use-lt-ai-settings.js';
 export { useLtAiUsage } from './use-lt-ai-usage.js';
 export { useLtAiAdmin } from './use-lt-ai-admin.js';
 export { useLtAiPrompts } from './use-lt-ai-prompts.js';
 export { useLtAiPlaceholders } from './use-lt-ai-placeholders.js';
+export { useLtOfflineSync } from './use-lt-offline-sync.js';

package/dist/runtime/composables/index.js

@@ -8,7 +8,9 @@ export { useLtErrorTranslation } from "./use-lt-error-translation.js";
 export { useLtAi } from "./use-lt-ai.js";
 export { useLtAiChat } from "./use-lt-ai-chat.js";
 export { useLtAiConnections } from "./use-lt-ai-connections.js";
+export { useLtAiSettings } from "./use-lt-ai-settings.js";
 export { useLtAiUsage } from "./use-lt-ai-usage.js";
 export { useLtAiAdmin } from "./use-lt-ai-admin.js";
 export { useLtAiPrompts } from "./use-lt-ai-prompts.js";
 export { useLtAiPlaceholders } from "./use-lt-ai-placeholders.js";
+export { useLtOfflineSync } from "./use-lt-offline-sync.js";

package/dist/runtime/composables/use-lt-ai-settings.d.ts

@@ -0,0 +1,12 @@
+/**
+ * User self-service for the current user's own AI settings, today whether MCP
+ * asks before a destructive or mutating tool runs (a "bypass permissions"
+ * switch). Backed by `GET /ai/settings` and `PUT /ai/settings`
+ * (nest-server >= 12.3.0).
+ *
+ * The answer is always the setting as it takes effect. When the server fixes
+ * it (`ai.mcp.confirmation.enforced`), `enforced` is true, the switch should be
+ * shown disabled, and `update()` is refused with 403 (`#LTNS_0609`).
+ */
+import type { UseLtAiSettingsReturn } from '../types/ai.js';
+export declare function useLtAiSettings(): UseLtAiSettingsReturn;

package/dist/runtime/composables/use-lt-ai-settings.js

@@ -0,0 +1,32 @@
+import { computed, readonly, ref } from "#imports";
+import { ltAiRequest } from "../lib/ai.js";
+export function useLtAiSettings() {
+  const settings = ref(null);
+  const loading = ref(false);
+  const error = ref(null);
+  const enforced = computed(() => settings.value?.mcpConfirmationEnforced === true);
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      settings.value = await ltAiRequest("GET", "/settings");
+    } catch (err) {
+      error.value = err.message;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function update(input) {
+    loading.value = true;
+    error.value = null;
+    try {
+      settings.value = await ltAiRequest("PUT", "/settings", input);
+    } catch (err) {
+      error.value = err.message;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return { enforced, error: readonly(error), load, loading: readonly(loading), settings: readonly(settings), update };
+}

package/dist/runtime/composables/use-lt-offline-sync.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Offline sync of one model with the nest-server sync module (>= 12.2.0).
+ *
+ * Records live in IndexedDB; changes made offline wait in an outbox and go out with the next sync.
+ * The composable syncs at start, on `online`, on focus and after a server hint, and pulls once on
+ * every reconnect of the hint stream (protocol §9). Tabs coordinate: one syncs at a time (Web Locks),
+ * the others pick up the result (BroadcastChannel); without either API it stays correct, only busier.
+ *
+ * The local data belongs to the signed-in user. A different user wipes it before anything is shown
+ * or pulled; `useLtAuth().signOut()` sends what is unsent and then deletes it. An expired session
+ * deletes nothing: after signing in again the outbox goes out without duplicates (protocol §4).
+ *
+ * @example
+ * ```ts
+ * const notes = useLtOfflineSync<{ title: string }>('note');
+ * await notes.create({ title: 'Einkaufen' });
+ * // notes.records.value, notes.pendingCount.value, notes.offline.value, notes.needsLogin.value
+ * ```
+ */
+import type { UseLtOfflineSyncOptions, UseLtOfflineSyncReturn } from '../types/sync.js';
+export declare function useLtOfflineSync<T extends Record<string, unknown> = Record<string, unknown>>(model: string, options?: UseLtOfflineSyncOptions<T>): UseLtOfflineSyncReturn<T>;