@noy-db/in-nuxt 0.1.0-pre.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vLannaAi
+
+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,141 @@
+# @noy-db/in-nuxt
+
+> Nuxt 4 module for [noy-db](https://github.com/vLannaAi/noy-db) — auto-imports, SSR-safe runtime plugin, and the `@noy-db/in-pinia` bridge.
+
+**Nuxt 4+ exclusive.** For Nuxt 3, use `@noy-db/in-vue` and `@noy-db/in-pinia` directly with a hand-written plugin.
+
+```bash
+pnpm add @noy-db/in-nuxt @noy-db/hub @noy-db/in-pinia @noy-db/in-vue
+# pick an adapter for your environment:
+pnpm add @noy-db/to-browser-idb    # localStorage / IndexedDB
+pnpm add @noy-db/to-file       # local disk / USB (Node only)
+pnpm add @noy-db/to-aws-dynamo     # AWS DynamoDB
+```
+
+## Quick start
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['@noy-db/in-nuxt'],
+
+  noydb: {
+    adapter: 'browser',
+    pinia: true,
+    sync: { adapter: 'dynamo', table: 'noydb-prod', region: 'ap-southeast-1' },
+    auth: { mode: 'biometric', sessionTimeout: '15m' },
+  },
+})
+```
+
+After installing the module, every component in your app gets these auto-imported:
+
+| From `@noy-db/in-vue`         | From `@noy-db/in-pinia` (when `pinia: true`, default) |
+|-----------------------------|----------------------------------------------------|
+| `useNoydb()`                | `defineNoydbStore()`                               |
+| `useCollection<T>()`        | `createNoydbPiniaPlugin()`                         |
+| `useSync()`                 | `setActiveNoydb()`                                  |
+|                             | `getActiveNoydb()`                                  |
+
+## Bootstrap
+
+The module exposes your typed config through `useRuntimeConfig().public.noydb` but it does **not** auto-instantiate the Noydb instance. You decide when and how to construct it — typically in a custom Nuxt plugin or your first protected page:
+
+```ts
+// plugins/noydb.client.ts
+import { createNoydb } from '@noy-db/hub'
+import { browserIdbStore } from '@noy-db/to-browser-idb'
+import { setActiveNoydb } from '@noy-db/in-pinia'
+
+export default defineNuxtPlugin(async () => {
+  const config = useRuntimeConfig().public.noydb
+
+  const db = await createNoydb({
+    adapter: browser({ prefix: 'my-app' }),
+    user: 'owner',
+    secret: () => promptUserForPassphrase(),
+  })
+
+  setActiveNoydb(db)
+})
+```
+
+The reason it's not automatic: `createNoydb` requires a passphrase callback that can't be serialized through Nuxt's runtime config. Eager auto-instantiation is a future enhancement, gated on a real consumer signing off on the bootstrap UX.
+
+## Use it in a component
+
+Once `setActiveNoydb` has been called, every Pinia store can transparently use NOYDB:
+
+```ts
+// stores/invoices.ts
+export const useInvoices = defineNoydbStore<Invoice>('invoices', {
+  compartment: 'C101',
+})
+```
+
+```vue
+<!-- pages/invoices.vue -->
+<script setup lang="ts">
+const invoices = useInvoices()
+await invoices.$ready
+
+const open = computed(() =>
+  invoices.query()
+    .where('status', '==', 'open')
+    .orderBy('dueDate')
+    .toArray()
+)
+</script>
+
+<template>
+  <ul>
+    <li v-for="inv in open" :key="inv.id">
+      {{ inv.client }} — {{ inv.amount }}
+    </li>
+  </ul>
+</template>
+```
+
+`defineNoydbStore`, `useInvoices`, `computed`, etc. are all auto-imported — no `import` lines needed.
+
+## SSR safety
+
+The module's runtime plugin is registered with `mode: 'client'`. Nuxt **never** loads it on the server, so your server bundle never imports any code that touches `crypto.subtle`. During SSR:
+
+- `useCollection()` returns an empty reactive ref (templates render skeleton state)
+- `defineNoydbStore` stores hydrate to their initial state
+- No keys, no decryption, no crypto API calls reach the server
+
+A planned CI bundle assertion will verify this property automatically by grepping the built nitro output for forbidden symbols.
+
+## Module options
+
+| Option       | Type                                                | Default       | Description |
+|--------------|-----------------------------------------------------|---------------|-------------|
+| `adapter`    | `'browser' \| 'memory' \| 'file' \| 'dynamo' \| 's3'` | —             | Hint for which built-in adapter to use. Just metadata — your bootstrap code constructs the actual adapter. |
+| `pinia`      | `boolean`                                           | `true`        | Auto-import the `@noy-db/in-pinia` helpers. Set to `false` if you don't use Pinia. |
+| `sync`       | `{ adapter, table, region, bucket, mode }`          | —             | Optional sync configuration metadata, exposed via `runtimeConfig.public.noydb.sync`. |
+| `auth`       | `{ mode, sessionTimeout }`                          | —             | Optional auth metadata. The actual passphrase callback lives in your bootstrap code. |
+| `devtools`   | `boolean`                                           | `true`        | Enable the (planned) devtools tab. Currently a passthrough — the tab itself is a future enhancement. |
+
+Every field is fully typed. Open `nuxt.config.ts` in your IDE and you'll get autocomplete on `noydb:`.
+
+## What's NOT yet included
+
+The following features are tracked as future follow-ups:
+
+- **Devtools tab via `@nuxt/devtools-kit`** — compartment tree, sync status, ledger tail, query playground
+- **Optional Nitro server proxy** at `/api/_noydb/[...]` for behind-the-scenes auth gating
+- **Optional Nitro scheduled backup task** for encrypted off-site backups
+- **`nuxi noydb <cmd>` CLI extension**
+- **Eager Noydb instantiation** — once a real consumer signs off on the bootstrap UX
+
+The module ships the foundation: typed options, auto-imports, and the SSR-safe client plugin. That's the load-bearing infrastructure; everything above can be added incrementally without breaking existing apps.
+
+## Status
+
+See [ROADMAP.md](../../ROADMAP.md) for the forward plan.
+
+## License
+
+MIT © vLannaAi

package/dist/index.d.ts

@@ -0,0 +1,149 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+/**
+ * Nuxt 4 module for noy-db.
+ *
+ * Built with `@nuxt/kit`'s `defineNuxtModule`. Targets Nuxt 4+ exclusively
+ * (no Nuxt 3 compatibility shim — Nuxt 3 users should consume `@noy-db/vue`
+ * and `@noy-db/pinia` directly with a hand-written plugin).
+ *
+ * Module responsibilities:
+ *
+ *   1. Auto-import the @noy-db/in-vue composables (`useNoydb`, `useCollection`,
+ *      `useSync`) and, when `pinia: true` (default), the @noy-db/in-pinia
+ *      helpers (`defineNoydbStore`, `createNoydbPiniaPlugin`, `setActiveNoydb`).
+ *
+ *   2. Expose the user's `noydb:` config through `runtimeConfig.public.noydb`
+ *      so the runtime plugin and downstream composables can read it
+ *      without re-parsing nuxt.config.ts.
+ *
+ *   3. Register a CLIENT-ONLY runtime plugin (`runtime/plugin.client.ts`)
+ *      that sets up the noydb context. The server bundle is never touched —
+ *      this is the load-bearing SSR-safety property.
+ *
+ * Deferred to follow-up issues:
+ *   - Devtools tab via @nuxt/devtools-kit
+ *   - Optional Nitro server proxy (`/api/_noydb/...`)
+ *   - Optional Nitro scheduled backup task
+ *   - `nuxi noydb` CLI extension
+ *   - Eager Noydb instantiation (requires the user's passphrase callback,
+ *     which can't be serialized through runtime config — better to let
+ *     users call setActiveNoydb from their own setup file)
+ */
+/**
+ * Configuration shape for the `noydb:` key in `nuxt.config.ts`.
+ *
+ * Every field is optional. The defaults give a reasonable bootstrap for
+ * a typical Vue/Nuxt app — Pinia helpers auto-imported, `to-browser-idb`
+ * as the default store. Users override by passing the relevant fields.
+ */
+interface ModuleOptions {
+    /**
+     * Which built-in store package to prefer. The runtime plugin reads this
+     * and picks the matching store. Defaults to `'to-browser-idb'` because
+     * Nuxt apps run in the browser at runtime.
+     *
+     * Note: this is just a HINT. Users can always construct their own
+     * store and pass it to `createNoydb()` directly — this option exists
+     * to keep simple cases simple.
+     */
+    store?: 'to-browser-idb' | 'to-browser-local' | 'to-memory' | 'to-file' | 'to-aws-dynamo' | 'to-aws-s3';
+    /**
+     * Auto-import the @noy-db/pinia helpers (`defineNoydbStore`,
+     * `createNoydbPiniaPlugin`, `setActiveNoydb`). Defaults to `true`
+     * because Pinia is the recommended state layer for.
+     *
+     * Set to `false` if you only want the bare @noy-db/vue composables
+     * (saves ~3 KB from the auto-import metadata).
+     */
+    pinia?: boolean;
+    /**
+     * Optional sync configuration. Currently a passthrough — the runtime
+     * plugin reads it from `runtimeConfig.public.noydb.sync` and the user
+     * is responsible for wiring it into their `createNoydb()` call.
+     */
+    sync?: {
+        store?: 'to-aws-dynamo' | 'to-aws-s3';
+        table?: string;
+        region?: string;
+        bucket?: string;
+        mode?: 'auto' | 'manual' | 'off';
+    };
+    /**
+     * Optional auth configuration metadata. Same passthrough pattern as
+     * `sync`. The user provides the actual passphrase / biometric callback
+     * in their own setup file.
+     */
+    auth?: {
+        mode?: 'passphrase' | 'biometric' | 'session';
+        sessionTimeout?: string;
+    };
+    /**
+     * Whether to enable the (planned) devtools tab in `nuxi dev`. Currently
+     * a passthrough — the devtools tab itself ships in a follow-up.
+     */
+    devtools?: boolean;
+    /**
+     * Optional REST API integration. When `enabled: true`, mounts a catch-all
+     * Nitro server handler at `basePath/**` using `@noy-db/in-rest`.
+     *
+     * The handler is scaffold-level: it reads `event.context.noydbStore` which
+     * a separate Nitro plugin must populate. spec follow-up for the store
+     * wiring. The module simply registers the route here.
+     */
+    rest?: {
+        /** Enable the REST API server handler. Default: false. */
+        enabled?: boolean;
+        /** Base path for all REST routes. Default: '/api/noydb'. */
+        basePath?: string;
+        /** User ID forwarded to createRestHandler. */
+        user?: string;
+        /** Session TTL in seconds. Default: 900. */
+        ttlSeconds?: number;
+    };
+}
+/**
+ * The exported Nuxt module factory.
+ *
+ * Test-friendly: `defineNuxtModule` returns a NuxtModule object whose
+ * `.meta`, `.getOptions`, and `.setup` fields can be inspected without a
+ * full Nuxt build. Unit tests use those introspection points instead of
+ * spinning up `@nuxt/test-utils`.
+ */
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+/**
+ * Module augmentation so the `noydb:` config key in `nuxt.config.ts`
+ * is fully typed and autocompleted in the IDE.
+ *
+ * The augmentation is a side-effect of importing the module — once a
+ * project adds `'@noy-db/in-nuxt'` to its `modules` array, TypeScript picks
+ * up the typed `noydb` option without requiring an explicit import.
+ */
+declare module '@nuxt/schema' {
+    interface NuxtConfig {
+        noydb?: ModuleOptions;
+    }
+    interface NuxtOptions {
+        noydb?: ModuleOptions;
+    }
+    interface PublicRuntimeConfig {
+        noydb?: ModuleOptions;
+    }
+}
+
+/**
+ * @noy-db/nuxt — Nuxt 4 module for noy-db.
+ *
+ * Public API:
+ *   - default export: the Nuxt module factory
+ *   - `ModuleOptions` type: shape of the `noydb:` key in `nuxt.config.ts`
+ *
+ * The module auto-imports the @noy-db/vue and (optionally) @noy-db/pinia
+ * composables, exposes the user's options through Nuxt's runtime config,
+ * and registers a CLIENT-ONLY runtime plugin so the SSR bundle never
+ * touches `crypto.subtle`. Eager Noydb instantiation is intentionally
+ * left to user code — see the README "Bootstrap" section.
+ */
+
+export { type ModuleOptions, _default as default };

package/dist/index.js

@@ -0,0 +1,59 @@
+// src/module.ts
+import { defineNuxtModule, addImports, addPlugin, addServerHandler, createResolver } from "@nuxt/kit";
+var module_default = defineNuxtModule({
+  meta: {
+    name: "@noy-db/in-nuxt",
+    configKey: "noydb",
+    compatibility: {
+      // Nuxt 4 only — see the module-level docstring for the rationale.
+      nuxt: "^4.0.0"
+    }
+  },
+  defaults: {
+    store: "to-browser-idb",
+    pinia: true,
+    devtools: true
+  },
+  setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.runtimeConfig.public.noydb = {
+      // The cast is necessary because Nuxt's runtimeConfig type is
+      // structurally `Record<string, any>` — modules are expected to
+      // own their own typing via module augmentation (which we do
+      // below).
+      ...nuxt.options.runtimeConfig.public.noydb ?? {},
+      ...options
+    };
+    addImports([
+      { name: "useNoydb", from: "@noy-db/in-vue" },
+      { name: "useCollection", from: "@noy-db/in-vue" },
+      { name: "useSync", from: "@noy-db/in-vue" }
+    ]);
+    if (options.pinia !== false) {
+      addImports([
+        { name: "defineNoydbStore", from: "@noy-db/in-pinia" },
+        { name: "createNoydbPiniaPlugin", from: "@noy-db/in-pinia" },
+        { name: "setActiveNoydb", from: "@noy-db/in-pinia" },
+        { name: "getActiveNoydb", from: "@noy-db/in-pinia" }
+      ]);
+    }
+    addPlugin({
+      src: resolver.resolve("./runtime/plugin.client.js"),
+      mode: "client"
+    });
+    if (options.rest?.enabled) {
+      const basePath = options.rest.basePath ?? "/api/noydb";
+      addServerHandler({
+        route: `${basePath}/**`,
+        handler: resolver.resolve("./runtime/rest")
+      });
+    }
+  }
+});
+
+// src/index.ts
+var index_default = module_default;
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/module.ts","../src/index.ts"],"sourcesContent":["/**\n * Nuxt 4 module for noy-db.\n *\n * Built with `@nuxt/kit`'s `defineNuxtModule`. Targets Nuxt 4+ exclusively\n * (no Nuxt 3 compatibility shim — Nuxt 3 users should consume `@noy-db/vue`\n * and `@noy-db/pinia` directly with a hand-written plugin).\n *\n * Module responsibilities:\n *\n *   1. Auto-import the @noy-db/in-vue composables (`useNoydb`, `useCollection`,\n *      `useSync`) and, when `pinia: true` (default), the @noy-db/in-pinia\n *      helpers (`defineNoydbStore`, `createNoydbPiniaPlugin`, `setActiveNoydb`).\n *\n *   2. Expose the user's `noydb:` config through `runtimeConfig.public.noydb`\n *      so the runtime plugin and downstream composables can read it\n *      without re-parsing nuxt.config.ts.\n *\n *   3. Register a CLIENT-ONLY runtime plugin (`runtime/plugin.client.ts`)\n *      that sets up the noydb context. The server bundle is never touched —\n *      this is the load-bearing SSR-safety property.\n *\n * Deferred to follow-up issues:\n *   - Devtools tab via @nuxt/devtools-kit\n *   - Optional Nitro server proxy (`/api/_noydb/...`)\n *   - Optional Nitro scheduled backup task\n *   - `nuxi noydb` CLI extension\n *   - Eager Noydb instantiation (requires the user's passphrase callback,\n *     which can't be serialized through runtime config — better to let\n *     users call setActiveNoydb from their own setup file)\n */\n\nimport { defineNuxtModule, addImports, addPlugin, addServerHandler, createResolver } from '@nuxt/kit'\n\n/**\n * Configuration shape for the `noydb:` key in `nuxt.config.ts`.\n *\n * Every field is optional. The defaults give a reasonable bootstrap for\n * a typical Vue/Nuxt app — Pinia helpers auto-imported, `to-browser-idb`\n * as the default store. Users override by passing the relevant fields.\n */\nexport interface ModuleOptions {\n  /**\n   * Which built-in store package to prefer. The runtime plugin reads this\n   * and picks the matching store. Defaults to `'to-browser-idb'` because\n   * Nuxt apps run in the browser at runtime.\n   *\n   * Note: this is just a HINT. Users can always construct their own\n   * store and pass it to `createNoydb()` directly — this option exists\n   * to keep simple cases simple.\n   */\n  store?: 'to-browser-idb' | 'to-browser-local' | 'to-memory' | 'to-file' | 'to-aws-dynamo' | 'to-aws-s3'\n\n  /**\n   * Auto-import the @noy-db/pinia helpers (`defineNoydbStore`,\n   * `createNoydbPiniaPlugin`, `setActiveNoydb`). Defaults to `true`\n   * because Pinia is the recommended state layer for.\n   *\n   * Set to `false` if you only want the bare @noy-db/vue composables\n   * (saves ~3 KB from the auto-import metadata).\n   */\n  pinia?: boolean\n\n  /**\n   * Optional sync configuration. Currently a passthrough — the runtime\n   * plugin reads it from `runtimeConfig.public.noydb.sync` and the user\n   * is responsible for wiring it into their `createNoydb()` call.\n   */\n  sync?: {\n    store?: 'to-aws-dynamo' | 'to-aws-s3'\n    table?: string\n    region?: string\n    bucket?: string\n    mode?: 'auto' | 'manual' | 'off'\n  }\n\n  /**\n   * Optional auth configuration metadata. Same passthrough pattern as\n   * `sync`. The user provides the actual passphrase / biometric callback\n   * in their own setup file.\n   */\n  auth?: {\n    mode?: 'passphrase' | 'biometric' | 'session'\n    sessionTimeout?: string\n  }\n\n  /**\n   * Whether to enable the (planned) devtools tab in `nuxi dev`. Currently\n   * a passthrough — the devtools tab itself ships in a follow-up.\n   */\n  devtools?: boolean\n\n  /**\n   * Optional REST API integration. When `enabled: true`, mounts a catch-all\n   * Nitro server handler at `basePath/**` using `@noy-db/in-rest`.\n   *\n   * The handler is scaffold-level: it reads `event.context.noydbStore` which\n   * a separate Nitro plugin must populate. spec follow-up for the store\n   * wiring. The module simply registers the route here.\n   */\n  rest?: {\n    /** Enable the REST API server handler. Default: false. */\n    enabled?: boolean\n    /** Base path for all REST routes. Default: '/api/noydb'. */\n    basePath?: string\n    /** User ID forwarded to createRestHandler. */\n    user?: string\n    /** Session TTL in seconds. Default: 900. */\n    ttlSeconds?: number\n  }\n}\n\n/**\n * The exported Nuxt module factory.\n *\n * Test-friendly: `defineNuxtModule` returns a NuxtModule object whose\n * `.meta`, `.getOptions`, and `.setup` fields can be inspected without a\n * full Nuxt build. Unit tests use those introspection points instead of\n * spinning up `@nuxt/test-utils`.\n */\nexport default defineNuxtModule<ModuleOptions>({\n  meta: {\n    name: '@noy-db/in-nuxt',\n    configKey: 'noydb',\n    compatibility: {\n      // Nuxt 4 only — see the module-level docstring for the rationale.\n      nuxt: '^4.0.0',\n    },\n  },\n\n  defaults: {\n    store: 'to-browser-idb',\n    pinia: true,\n    devtools: true,\n  },\n\n  setup(options, nuxt) {\n    const resolver = createResolver(import.meta.url)\n\n    // ─── 1. Expose the user's options to runtime via runtimeConfig ───\n    //\n    // We stash the typed options under `runtimeConfig.public.noydb` so\n    // the client plugin (and any downstream composable) can read them\n    // without re-parsing nuxt.config.ts. `public` is required so the\n    // values reach the browser bundle — but EVERY field is metadata\n    // (store name, table name, etc.), NEVER a secret. Passphrases\n    // and tokens are still provided at runtime via user callbacks.\n    nuxt.options.runtimeConfig.public.noydb = {\n      // The cast is necessary because Nuxt's runtimeConfig type is\n      // structurally `Record<string, any>` — modules are expected to\n      // own their own typing via module augmentation (which we do\n      // below).\n      ...(nuxt.options.runtimeConfig.public.noydb ?? {}),\n      ...options,\n    }\n\n    // ─── 2. Auto-imports for @noy-db/vue composables ────────────────\n    //\n    // These are the composables shipped by @noy-db/vue. Importing\n    // them automatically removes one line of boilerplate per component.\n    addImports([\n      { name: 'useNoydb', from: '@noy-db/in-vue' },\n      { name: 'useCollection', from: '@noy-db/in-vue' },\n      { name: 'useSync', from: '@noy-db/in-vue' },\n    ])\n\n    // ─── 3. Auto-imports for @noy-db/pinia (opt-out) ────────────────\n    //\n    // Most users want the Pinia helpers — `defineNoydbStore` is the\n    // headline API. We default to enabling them and let users\n    // opt out via `pinia: false` if they're not using Pinia at all.\n    if (options.pinia !== false) {\n      addImports([\n        { name: 'defineNoydbStore', from: '@noy-db/in-pinia' },\n        { name: 'createNoydbPiniaPlugin', from: '@noy-db/in-pinia' },\n        { name: 'setActiveNoydb', from: '@noy-db/in-pinia' },\n        { name: 'getActiveNoydb', from: '@noy-db/in-pinia' },\n      ])\n    }\n\n    // ─── 4. Register the client-only runtime plugin ─────────────────\n    //\n    // mode: 'client' is the LOAD-BEARING SSR-safety guarantee. Nuxt\n    // skips this plugin entirely on the server, so the server bundle\n    // never imports any code that touches `crypto.subtle`. The CI\n    // bundle assertion (planned for a follow-up) verifies this by\n    // grepping the built nitro output for forbidden symbols.\n    //\n    // The path resolves to the COMPILED runtime file in `dist/runtime/`.\n    // tsup builds this as a separate entry alongside the module index.\n    addPlugin({\n      src: resolver.resolve('./runtime/plugin.client.js'),\n      mode: 'client',\n    })\n\n    // ─── 5. REST API server handler (opt-in) ────────────────────────\n    //\n    // When `rest.enabled: true`, mount a catch-all Nitro server handler\n    // at `basePath/**`. The handler delegates to `@noy-db/in-rest` via\n    // the nitroAdapter. Store wiring (populating event.context.noydbStore)\n    // is a follow-up concern tracked in #273.\n    if (options.rest?.enabled) {\n      const basePath = options.rest.basePath ?? '/api/noydb'\n      addServerHandler({\n        route: `${basePath}/**`,\n        handler: resolver.resolve('./runtime/rest'),\n      })\n    }\n  },\n})\n\n/**\n * Module augmentation so the `noydb:` config key in `nuxt.config.ts`\n * is fully typed and autocompleted in the IDE.\n *\n * The augmentation is a side-effect of importing the module — once a\n * project adds `'@noy-db/in-nuxt'` to its `modules` array, TypeScript picks\n * up the typed `noydb` option without requiring an explicit import.\n */\ndeclare module '@nuxt/schema' {\n  interface NuxtConfig {\n    noydb?: ModuleOptions\n  }\n  interface NuxtOptions {\n    noydb?: ModuleOptions\n  }\n  interface PublicRuntimeConfig {\n    noydb?: ModuleOptions\n  }\n}\n","/**\n * @noy-db/nuxt — Nuxt 4 module for noy-db.\n *\n * Public API:\n *   - default export: the Nuxt module factory\n *   - `ModuleOptions` type: shape of the `noydb:` key in `nuxt.config.ts`\n *\n * The module auto-imports the @noy-db/vue and (optionally) @noy-db/pinia\n * composables, exposes the user's options through Nuxt's runtime config,\n * and registers a CLIENT-ONLY runtime plugin so the SSR bundle never\n * touches `crypto.subtle`. Eager Noydb instantiation is intentionally\n * left to user code — see the README \"Bootstrap\" section.\n */\n\nimport noydbModule, { type ModuleOptions } from './module.js'\n\nexport default noydbModule\nexport type { ModuleOptions }\n"],"mappings":";AA+BA,SAAS,kBAAkB,YAAY,WAAW,kBAAkB,sBAAsB;AAwF1F,IAAO,iBAAQ,iBAAgC;AAAA,EAC7C,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,WAAW;AAAA,IACX,eAAe;AAAA;AAAA,MAEb,MAAM;AAAA,IACR;AAAA,EACF;AAAA,EAEA,UAAU;AAAA,IACR,OAAO;AAAA,IACP,OAAO;AAAA,IACP,UAAU;AAAA,EACZ;AAAA,EAEA,MAAM,SAAS,MAAM;AACnB,UAAM,WAAW,eAAe,YAAY,GAAG;AAU/C,SAAK,QAAQ,cAAc,OAAO,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA,MAKxC,GAAI,KAAK,QAAQ,cAAc,OAAO,SAAS,CAAC;AAAA,MAChD,GAAG;AAAA,IACL;AAMA,eAAW;AAAA,MACT,EAAE,MAAM,YAAY,MAAM,iBAAiB;AAAA,MAC3C,EAAE,MAAM,iBAAiB,MAAM,iBAAiB;AAAA,MAChD,EAAE,MAAM,WAAW,MAAM,iBAAiB;AAAA,IAC5C,CAAC;AAOD,QAAI,QAAQ,UAAU,OAAO;AAC3B,iBAAW;AAAA,QACT,EAAE,MAAM,oBAAoB,MAAM,mBAAmB;AAAA,QACrD,EAAE,MAAM,0BAA0B,MAAM,mBAAmB;AAAA,QAC3D,EAAE,MAAM,kBAAkB,MAAM,mBAAmB;AAAA,QACnD,EAAE,MAAM,kBAAkB,MAAM,mBAAmB;AAAA,MACrD,CAAC;AAAA,IACH;AAYA,cAAU;AAAA,MACR,KAAK,SAAS,QAAQ,4BAA4B;AAAA,MAClD,MAAM;AAAA,IACR,CAAC;AAQD,QAAI,QAAQ,MAAM,SAAS;AACzB,YAAM,WAAW,QAAQ,KAAK,YAAY;AAC1C,uBAAiB;AAAA,QACf,OAAO,GAAG,QAAQ;AAAA,QAClB,SAAS,SAAS,QAAQ,gBAAgB;AAAA,MAC5C,CAAC;AAAA,IACH;AAAA,EACF;AACF,CAAC;;;AChMD,IAAO,gBAAQ;","names":[]}

package/dist/runtime/plugin.client.d.ts

@@ -0,0 +1,29 @@
+import * as nuxt_app from 'nuxt/app';
+
+/**
+ * Client-only runtime plugin for the @noy-db/nuxt module.
+ *
+ * This file is registered with `mode: 'client'` so Nuxt NEVER imports it
+ * into the server bundle. Every line below assumes a browser context.
+ *
+ * The plugin's job today:
+ *
+ *   1. Read the user's noydb config from `useRuntimeConfig().public.noydb`
+ *      and stash it on the Nuxt app context for later access via the
+ *      auto-imported `useRuntimeConfig()` composable.
+ *
+ *   2. NOT auto-instantiate Noydb. The library requires a passphrase
+ *      callback to derive keys, and that callback can't be serialized
+ *      through runtime config. Users call `setActiveNoydb(instance)`
+ *      themselves from their app's setup file (the README documents
+ *      the recommended pattern).
+ *
+ * Future work:
+ *   - Read a user-supplied `bootstrap` callback from a Nuxt provide()
+ *     and call it here to construct Noydb automatically when possible
+ *   - Wire the devtools tab via @nuxt/devtools-kit
+ *   - Surface ledger / sync status on the Nuxt app context
+ */
+declare const _default: nuxt_app.Plugin<Record<string, unknown>> & nuxt_app.ObjectPlugin<Record<string, unknown>>;
+
+export { _default as default };

package/dist/runtime/plugin.client.js

@@ -0,0 +1,17 @@
+// src/runtime/plugin.client.ts
+import { defineNuxtPlugin, useRuntimeConfig } from "nuxt/app";
+var plugin_client_default = defineNuxtPlugin({
+  name: "noy-db:client",
+  enforce: "pre",
+  setup(_nuxtApp) {
+    const config = useRuntimeConfig().public.noydb;
+    if (config) {
+      ;
+      globalThis.__NOYDB_NUXT_CONFIG__ = config;
+    }
+  }
+});
+export {
+  plugin_client_default as default
+};
+//# sourceMappingURL=plugin.client.js.map

package/dist/runtime/plugin.client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/runtime/plugin.client.ts"],"sourcesContent":["/**\n * Client-only runtime plugin for the @noy-db/nuxt module.\n *\n * This file is registered with `mode: 'client'` so Nuxt NEVER imports it\n * into the server bundle. Every line below assumes a browser context.\n *\n * The plugin's job today:\n *\n *   1. Read the user's noydb config from `useRuntimeConfig().public.noydb`\n *      and stash it on the Nuxt app context for later access via the\n *      auto-imported `useRuntimeConfig()` composable.\n *\n *   2. NOT auto-instantiate Noydb. The library requires a passphrase\n *      callback to derive keys, and that callback can't be serialized\n *      through runtime config. Users call `setActiveNoydb(instance)`\n *      themselves from their app's setup file (the README documents\n *      the recommended pattern).\n *\n * Future work:\n *   - Read a user-supplied `bootstrap` callback from a Nuxt provide()\n *     and call it here to construct Noydb automatically when possible\n *   - Wire the devtools tab via @nuxt/devtools-kit\n *   - Surface ledger / sync status on the Nuxt app context\n */\n\nimport { defineNuxtPlugin, useRuntimeConfig } from 'nuxt/app'\n\nexport default defineNuxtPlugin({\n  name: 'noy-db:client',\n  enforce: 'pre',\n  setup(_nuxtApp) {\n    // Read the typed module options the user passed in nuxt.config.ts.\n    // The cast is safe because @noy-db/nuxt's module file augments\n    // PublicRuntimeConfig with the noydb shape (see module.ts).\n    const config = useRuntimeConfig().public.noydb\n\n    // Surface the config on `globalThis` so non-Vue contexts (e.g.,\n    // a custom error reporter or a Web Worker) can read it. This is\n    // intentionally on `globalThis` rather than the Nuxt provide()\n    // map so the helper packages stay framework-agnostic.\n    if (config) {\n      ;(globalThis as { __NOYDB_NUXT_CONFIG__?: unknown }).__NOYDB_NUXT_CONFIG__ = config\n    }\n\n    // No return value — the plugin's only side effect is the global\n    // assignment above. Future versions will return `provide` keys\n    // for first-class composable access.\n  },\n})\n"],"mappings":";AAyBA,SAAS,kBAAkB,wBAAwB;AAEnD,IAAO,wBAAQ,iBAAiB;AAAA,EAC9B,MAAM;AAAA,EACN,SAAS;AAAA,EACT,MAAM,UAAU;AAId,UAAM,SAAS,iBAAiB,EAAE,OAAO;AAMzC,QAAI,QAAQ;AACV;AAAC,MAAC,WAAmD,wBAAwB;AAAA,IAC/E;AAAA,EAKF;AACF,CAAC;","names":[]}

package/dist/runtime/rest.d.ts

@@ -0,0 +1,21 @@
+import * as h3 from 'h3';
+
+/**
+ * Nitro catch-all server handler for the opt-in REST API integration.
+ *
+ * This file is registered as a server handler entry point by the module when
+ * `rest.enabled: true`. It bridges Nitro's H3 event model to
+ * `@noy-db/in-rest`'s `NoydbRestHandler` via the `nitroAdapter`.
+ *
+ * **Store wiring (scaffold note):**
+ * The handler reads the noydb store from `event.context.noydbStore`. A
+ * separate Nitro server plugin must populate this before requests reach this
+ * handler. That wiring is deferred to the  follow-up PR.
+ *
+ * The handler is intentionally stateless at module scope — the lazy `_handler`
+ * singleton is reset on each cold-start (Nitro worker restart), which matches
+ * the expected lifecycle.
+ */
+declare const _default: h3.EventHandler<h3.EventHandlerRequest, Promise<Response>>;
+
+export { _default as default };

package/dist/runtime/rest.js

@@ -0,0 +1,52 @@
+// src/runtime/rest.ts
+import { defineEventHandler, getRequestURL, readBody } from "h3";
+import { createRestHandler } from "@noy-db/in-rest";
+import { nitroAdapter } from "@noy-db/in-rest/nitro";
+var _handler = null;
+function getHandler(store, user, ttlSeconds, basePath) {
+  if (!_handler) {
+    _handler = createRestHandler({ store, user, ttlSeconds, basePath });
+  }
+  return _handler;
+}
+var rest_default = defineEventHandler(async (event) => {
+  const ctx = event.context;
+  const config = ctx.nitro?.runtimeConfig?.public?.noydb?.rest ?? ctx.runtimeConfig?.public?.noydb?.rest ?? {};
+  const store = ctx.noydbStore;
+  if (!store) {
+    return new Response(
+      JSON.stringify({ error: "noydb_store_not_configured" }),
+      { status: 500, headers: { "content-type": "application/json" } }
+    );
+  }
+  const restConfig = config;
+  const handler = getHandler(
+    store,
+    restConfig.user ?? "api",
+    restConfig.ttlSeconds ?? 900,
+    restConfig.basePath ?? "/api/noydb"
+  );
+  const url = getRequestURL(event);
+  const method = (event.method ?? "GET").toUpperCase();
+  let body = null;
+  if (method !== "GET" && method !== "HEAD" && method !== "DELETE") {
+    try {
+      body = await readBody(event);
+    } catch {
+      body = null;
+    }
+  }
+  const h3Adapter = nitroAdapter(handler);
+  return h3Adapter({
+    method,
+    path: url.pathname + url.search,
+    // nitroAdapter's H3Event accepts Headers | Record<string,string> — pass
+    // the Headers instance directly to avoid lossy serialization.
+    headers: event.headers,
+    _body: body
+  });
+});
+export {
+  rest_default as default
+};
+//# sourceMappingURL=rest.js.map

package/dist/runtime/rest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/runtime/rest.ts"],"sourcesContent":["/**\n * Nitro catch-all server handler for the opt-in REST API integration.\n *\n * This file is registered as a server handler entry point by the module when\n * `rest.enabled: true`. It bridges Nitro's H3 event model to\n * `@noy-db/in-rest`'s `NoydbRestHandler` via the `nitroAdapter`.\n *\n * **Store wiring (scaffold note):**\n * The handler reads the noydb store from `event.context.noydbStore`. A\n * separate Nitro server plugin must populate this before requests reach this\n * handler. That wiring is deferred to the  follow-up PR.\n *\n * The handler is intentionally stateless at module scope — the lazy `_handler`\n * singleton is reset on each cold-start (Nitro worker restart), which matches\n * the expected lifecycle.\n */\n\nimport { defineEventHandler, getRequestURL, readBody } from 'h3'\nimport type { H3Event } from 'h3'\nimport { createRestHandler } from '@noy-db/in-rest'\nimport { nitroAdapter } from '@noy-db/in-rest/nitro'\nimport type { NoydbRestHandler } from '@noy-db/in-rest'\nimport type { NoydbStore } from '@noy-db/hub'\n\nlet _handler: NoydbRestHandler | null = null\n\nfunction getHandler(\n  store: NoydbStore,\n  user: string,\n  ttlSeconds: number,\n  basePath: string,\n): NoydbRestHandler {\n  if (!_handler) {\n    _handler = createRestHandler({ store, user, ttlSeconds, basePath })\n  }\n  return _handler\n}\n\nexport default defineEventHandler(async (event: H3Event) => {\n  // Read REST config from Nitro's public runtime config. Nitro stores it at\n  // `event.context.nitro.runtimeConfig` (the canonical location — confirmed\n  // by reading nitropack's config.mjs). The fallback on\n  // `event.context.runtimeConfig` covers bespoke setups that might inject\n  // config at that alternate key.\n  const ctx = event.context as {\n    nitro?: { runtimeConfig?: { public?: { noydb?: { rest?: Record<string, unknown> } } } }\n    runtimeConfig?: { public?: { noydb?: { rest?: Record<string, unknown> } } }\n    noydbStore?: NoydbStore\n  }\n  const config =\n    ctx.nitro?.runtimeConfig?.public?.noydb?.rest ??\n    ctx.runtimeConfig?.public?.noydb?.rest ??\n    {}\n\n  // The store must be provided by a separate Nitro server plugin that\n  // creates and populates `event.context.noydbStore` before this handler\n  // runs. See module docstring above.\n  const store = ctx.noydbStore\n\n  if (!store) {\n    return new Response(\n      JSON.stringify({ error: 'noydb_store_not_configured' }),\n      { status: 500, headers: { 'content-type': 'application/json' } },\n    )\n  }\n\n  const restConfig = config as {\n    user?: string\n    ttlSeconds?: number\n    basePath?: string\n  }\n  const handler = getHandler(\n    store,\n    restConfig.user ?? 'api',\n    restConfig.ttlSeconds ?? 900,\n    restConfig.basePath ?? '/api/noydb',\n  )\n\n  // Build the adapter-friendly event shape. We pass event.headers directly\n  // because `nitroAdapter` already handles both `Headers` instances and\n  // plain `Record<string, string>` objects.\n  const url = getRequestURL(event)\n  const method = (event.method ?? 'GET').toUpperCase()\n\n  let body: unknown = null\n  if (method !== 'GET' && method !== 'HEAD' && method !== 'DELETE') {\n    try { body = await readBody(event) } catch { body = null }\n  }\n\n  const h3Adapter = nitroAdapter(handler)\n  return h3Adapter({\n    method,\n    path: url.pathname + url.search,\n    // nitroAdapter's H3Event accepts Headers | Record<string,string> — pass\n    // the Headers instance directly to avoid lossy serialization.\n    headers: event.headers,\n    _body: body,\n  })\n})\n"],"mappings":";AAiBA,SAAS,oBAAoB,eAAe,gBAAgB;AAE5D,SAAS,yBAAyB;AAClC,SAAS,oBAAoB;AAI7B,IAAI,WAAoC;AAExC,SAAS,WACP,OACA,MACA,YACA,UACkB;AAClB,MAAI,CAAC,UAAU;AACb,eAAW,kBAAkB,EAAE,OAAO,MAAM,YAAY,SAAS,CAAC;AAAA,EACpE;AACA,SAAO;AACT;AAEA,IAAO,eAAQ,mBAAmB,OAAO,UAAmB;AAM1D,QAAM,MAAM,MAAM;AAKlB,QAAM,SACJ,IAAI,OAAO,eAAe,QAAQ,OAAO,QACzC,IAAI,eAAe,QAAQ,OAAO,QAClC,CAAC;AAKH,QAAM,QAAQ,IAAI;AAElB,MAAI,CAAC,OAAO;AACV,WAAO,IAAI;AAAA,MACT,KAAK,UAAU,EAAE,OAAO,6BAA6B,CAAC;AAAA,MACtD,EAAE,QAAQ,KAAK,SAAS,EAAE,gBAAgB,mBAAmB,EAAE;AAAA,IACjE;AAAA,EACF;AAEA,QAAM,aAAa;AAKnB,QAAM,UAAU;AAAA,IACd;AAAA,IACA,WAAW,QAAQ;AAAA,IACnB,WAAW,cAAc;AAAA,IACzB,WAAW,YAAY;AAAA,EACzB;AAKA,QAAM,MAAM,cAAc,KAAK;AAC/B,QAAM,UAAU,MAAM,UAAU,OAAO,YAAY;AAEnD,MAAI,OAAgB;AACpB,MAAI,WAAW,SAAS,WAAW,UAAU,WAAW,UAAU;AAChE,QAAI;AAAE,aAAO,MAAM,SAAS,KAAK;AAAA,IAAE,QAAQ;AAAE,aAAO;AAAA,IAAK;AAAA,EAC3D;AAEA,QAAM,YAAY,aAAa,OAAO;AACtC,SAAO,UAAU;AAAA,IACf;AAAA,IACA,MAAM,IAAI,WAAW,IAAI;AAAA;AAAA;AAAA,IAGzB,SAAS,MAAM;AAAA,IACf,OAAO;AAAA,EACT,CAAC;AACH,CAAC;","names":[]}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@noy-db/in-nuxt",
+  "version": "0.1.0-pre.10",
+  "description": "Nuxt 4 module for noy-db — auto-imports, SSR-safe runtime plugin, and the @noy-db/in-pinia bridge",
+  "license": "MIT",
+  "author": "vLannaAi <vicio@lanna.ai>",
+  "homepage": "https://github.com/vLannaAi/noy-db/tree/main/packages/in-nuxt#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vLannaAi/noy-db.git",
+    "directory": "packages/in-nuxt"
+  },
+  "bugs": {
+    "url": "https://github.com/vLannaAi/noy-db/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "nuxt": "^4.0.0",
+    "@noy-db/hub": "0.1.0-pre.10",
+    "@noy-db/in-rest": "0.1.0-pre.10",
+    "@noy-db/in-vue": "0.1.0-pre.10",
+    "@noy-db/in-pinia": "0.1.0-pre.10"
+  },
+  "peerDependenciesMeta": {
+    "@noy-db/in-rest": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@nuxt/kit": "^4.4.2",
+    "@nuxt/schema": "^4.4.2",
+    "h3": "^1.13.0",
+    "nuxt": "^4.4.2",
+    "@noy-db/in-pinia": "0.1.0-pre.10",
+    "@noy-db/hub": "0.1.0-pre.10",
+    "@noy-db/in-rest": "0.1.0-pre.10",
+    "@noy-db/in-vue": "0.1.0-pre.10"
+  },
+  "keywords": [
+    "noy-db",
+    "nuxt",
+    "nuxt4",
+    "module",
+    "encryption",
+    "zero-knowledge",
+    "offline-first",
+    "pinia",
+    "vue"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  }
+}