@holo-js/adapter-nuxt 0.3.28 → 0.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Holo-JS contributors
+
+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/dist/.holo-build-fingerprint

@@ -0,0 +1 @@
+a3ee6a1d83162db89678b9cb4ef2211ad9a3369497da63f74b3b24c7fd4f739a

package/dist/module.d.mts

@@ -1,4 +1,4 @@
-import * as nuxt_schema from 'nuxt/schema';
+import { NuxtModule } from 'nuxt/schema';
 import { LoadedHoloConfig, HoloConfigMap } from '@holo-js/config';
 
 type ModuleOptions = Record<string, never>;
@@ -44,7 +44,6 @@ type HoloStorageRuntimeConfig = {
     disks: Record<string, RuntimeDiskConfig>;
 };
 type StorageModule = {
-    applyNitroStorageConfig(nitro: NuxtOptionsWithNitro, config: HoloStorageRuntimeConfig, s3Driver: string): void;
     hasPublicLocalDisk(config: HoloStorageRuntimeConfig): boolean;
     mergeModuleOptions(base: StorageModuleOptions | undefined, overrides: StorageModuleOptions | undefined): StorageModuleOptions;
     normalizeModuleOptions(options: StorageModuleOptions | undefined): HoloStorageRuntimeConfig;
@@ -65,7 +64,6 @@ type NuxtViteOptions = {
 };
 interface NuxtOptionsWithNitro {
     nitro: {
-        storage: Record<string, unknown>;
         moduleSideEffects?: string[];
         errorHandler?: string | string[];
         externals?: {
@@ -94,7 +92,6 @@ interface NuxtOptionsWithNitro {
             };
             [key: string]: unknown;
         };
-        holoStorage?: HoloStorageRuntimeConfig;
         [key: string]: unknown;
     };
     build: {
@@ -106,7 +103,6 @@ interface NuxtOptionsWithNitro {
     rootDir?: string;
     _holoStorageModuleOptions?: StorageModuleOptions;
     _holoStorageFinalizeRegistered?: boolean;
-    _holoStorageRuntimeRegistered?: boolean;
     _holoBroadcastAuthRouteRegistered?: boolean;
     _holoRealtimeRouteRegistered?: boolean;
     _holoClientTransformsRegistered?: boolean;
@@ -120,10 +116,11 @@ declare function isProjectPackageLinked(rootDir: string, packageRootName: string
 declare function addNitroRuntimeTraceIncludes(opts: NuxtOptionsWithNitro, rootDir: string, pluginPackages?: readonly string[], resolvePackage?: (rootDir: string, packageName: string) => string | undefined): void;
 declare function resolveClientOptimizeDeps(rootDir: string): string[];
 declare function addViteOptimizeDeps(opts: NuxtOptionsWithNitro, deps: readonly string[]): void;
-declare function isRealtimeDefinitionModule(_rootDir: string, id: string): boolean;
+declare function isRealtimeDefinitionModule(rootDir: string, id: string, directories?: readonly string[]): boolean;
 declare function resolveExistingRealtimeDefinitionFile(path: string): string | undefined;
 declare function existsFile(path: string): boolean;
 declare function resolveRealtimeDefinitionImport(source: string, importer: string | undefined): string | undefined;
+declare function renderRealtimeDefinitionsModule(rootDir: string): string;
 declare function createRealtimeDefinitionVitePlugin(rootDir: string): unknown;
 declare function addVitePlugin(vite: NuxtViteOptions, plugin: unknown): void;
 declare function addNitroErrorHandler(opts: NuxtOptionsWithNitro, handler: string): void;
@@ -136,9 +133,8 @@ declare function resolveStorageSetup(storageModule: StorageModule | undefined, l
 };
 declare function finalizeStorageSetup(storageModule: StorageModule, opts: NuxtOptionsWithNitro, resolver: {
     resolve(path: string): string;
-}, s3Driver: string): void;
-declare function applyStorageRuntimeConfig(runtimeConfig: Record<string, unknown>, normalized: HoloStorageRuntimeConfig | undefined): void;
-declare const _default: nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+}): void;
+declare const holoNuxtModule: NuxtModule<ModuleOptions>;
 
 declare const moduleInternals: {
     addViteOptimizeDeps: typeof addViteOptimizeDeps;
@@ -151,7 +147,6 @@ declare const moduleInternals: {
     hasModuleNotFoundCode: typeof hasModuleNotFoundCode;
     hasLoadedConfigFile: typeof hasLoadedConfigFile;
     importOptionalStorageS3Module: typeof importOptionalStorageS3Module;
-    applyStorageRuntimeConfig: typeof applyStorageRuntimeConfig;
     finalizeStorageSetup: typeof finalizeStorageSetup;
     resolveStorageSetup: typeof resolveStorageSetup;
     isModuleResolutionFailure: typeof isModuleResolutionFailure;
@@ -160,6 +155,7 @@ declare const moduleInternals: {
     isProjectPackageLinked: typeof isProjectPackageLinked;
     isRealtimeDefinitionModule: typeof isRealtimeDefinitionModule;
     resolveClientOptimizeDeps: typeof resolveClientOptimizeDeps;
+    renderRealtimeDefinitionsModule: typeof renderRealtimeDefinitionsModule;
     resolveExistingRealtimeDefinitionFile: typeof resolveExistingRealtimeDefinitionFile;
     resolveRealtimeDefinitionImport: typeof resolveRealtimeDefinitionImport;
 };
@@ -167,5 +163,5 @@ declare const adapterNuxtInternals: {
     toStorageModuleOptions: typeof toStorageModuleOptions;
 };
 
-export { adapterNuxtInternals, _default as default, moduleInternals };
+export { adapterNuxtInternals, holoNuxtModule as default, moduleInternals };
 export type { ModuleOptions };

package/dist/module.json

@@ -1,9 +1,9 @@
 {
   "name": "@holo-js/adapter-nuxt",
   "configKey": "@holo-js/adapter-nuxt",
-  "version": "0.3.28",
+  "version": "0.4.1",
   "builder": {
-    "@nuxt/module-builder": "1.0.2",
+    "@nuxt/module-builder": "1.0.3",
     "unbuild": "unknown"
   }
 }

package/dist/module.mjs

@@ -1,23 +1,25 @@
 import { createRealtimeClientDefinitionTransform as createRealtimeClientDefinitionTransform$1, createRealtimeClientDefinitionModule as createRealtimeClientDefinitionModule$1, compileBrowserValidation } from '@holo-js/adapter-shared/build';
-import { existsSync, lstatSync, readFileSync } from 'node:fs';
-import { writeFile, readdir, readFile, mkdir, access } from 'node:fs/promises';
+import { resolveRealtimeDefinitionDirectories, isInRealtimeDefinitionDirectory, assertRealtimeDefinitionTree } from '@holo-js/adapter-shared/realtime-directories';
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { readdir, readFile, mkdir, access } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { resolve, extname, relative, basename, dirname, isAbsolute } from 'node:path';
 import { defineNuxtModule, createResolver, addServerPlugin, addServerImportsDir, addServerHandler, addPlugin } from '@nuxt/kit';
 import { loadConfigDirectory } from '@holo-js/config';
 import '@holo-js/db/config';
 
-function createRealtimeClientDefinitionModule(source) {
-  return createRealtimeClientDefinitionModule$1(source, "@holo-js/adapter-nuxt/realtime");
+function createRealtimeClientDefinitionModule(source, filePath) {
+  return createRealtimeClientDefinitionModule$1({ source, importTarget: "@holo-js/adapter-nuxt/realtime", filePath });
 }
-function createRealtimeClientDefinitionTransform(source) {
-  return createRealtimeClientDefinitionTransform$1(source, "@holo-js/adapter-nuxt/realtime");
+function createRealtimeClientDefinitionTransform(source, filePath) {
+  return createRealtimeClientDefinitionTransform$1({ source, importTarget: "@holo-js/adapter-nuxt/realtime", filePath });
 }
 
 const MODEL_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
 const HOLO_PACKAGE_SCOPE = "@holo-js/";
 const realtimeClientDefinitionPrefix = "\0holo-realtime-client:";
-const VALIDATION_CLIENT_DEPENDENCIES = ["valibot", "file-type"];
+const realtimeDefinitionsModuleId = "#holo/realtime-definitions";
+const VALIDATION_CLIENT_DEPENDENCIES = ["valibot", "@holo-js/kernel > file-type"];
 const CLIENT_OPTIMIZE_DEPS = [
   {
     packageName: `${HOLO_PACKAGE_SCOPE}forms`,
@@ -174,8 +176,12 @@ function resolveProjectPackageTraceEntry(rootDir, packageName) {
   return resolveProjectPackageEntry(rootDir, packageName);
 }
 function isProjectPackageLinked(rootDir, packageRootName) {
-  const projectPackageRoot = resolve(rootDir, "node_modules", packageRootName);
-  return lstatSync(projectPackageRoot, { throwIfNoEntry: false })?.isSymbolicLink() === true;
+  const projectRequire = createRequire(resolve(rootDir, "package.json"));
+  for (const nodeModulesPath of projectRequire.resolve.paths(packageRootName) ?? []) {
+    const packageStats = lstatSync(resolve(nodeModulesPath, packageRootName), { throwIfNoEntry: false });
+    if (packageStats) return packageStats.isSymbolicLink();
+  }
+  return false;
 }
 function addNitroRuntimeTraceIncludes(opts, rootDir, pluginPackages = [], resolvePackage = resolveProjectPackageTraceEntry) {
   const externals = opts.nitro.externals ?? {};
@@ -230,10 +236,10 @@ function addViteOptimizeDeps(opts, deps) {
     ])
   ];
 }
-function isRealtimeDefinitionModule(_rootDir, id) {
+function isRealtimeDefinitionModule(rootDir, id, directories = resolveRealtimeDefinitionDirectories(rootDir)) {
   const [sourcePath = ""] = id.split("?");
   const normalizedId = sourcePath.replaceAll("\\", "/");
-  return normalizedId.includes("/server/realtime/") && MODEL_FILE_EXTENSIONS.has(extname(normalizedId));
+  return (normalizedId.includes("/server/realtime/") || isInRealtimeDefinitionDirectory(directories, normalizedId)) && MODEL_FILE_EXTENSIONS.has(extname(normalizedId));
 }
 function resolveExistingRealtimeDefinitionFile(path) {
   if (MODEL_FILE_EXTENSIONS.has(extname(path)) && existsFile(path)) {
@@ -261,10 +267,39 @@ function resolveRealtimeDefinitionImport(source, importer) {
   const basePath = source.startsWith(".") ? importer ? resolve(dirname(importer.split("?")[0]), source) : void 0 : resolve(source);
   return basePath ? resolveExistingRealtimeDefinitionFile(basePath) : void 0;
 }
+function collectRealtimeDefinitionFiles(rootDir) {
+  const realtimeRoot = resolve(rootDir, "server/realtime");
+  if (!existsSync(realtimeRoot)) {
+    return [];
+  }
+  return readdirSync(realtimeRoot, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile() && MODEL_FILE_EXTENSIONS.has(extname(entry.name))).map((entry) => resolve(entry.parentPath, entry.name)).sort((left, right) => left.localeCompare(right));
+}
+function renderRealtimeDefinitionsModule(rootDir) {
+  const files = collectRealtimeDefinitionFiles(rootDir);
+  const imports = files.map((filePath, index) => `import * as realtimeModule${index} from ${JSON.stringify(filePath)}`);
+  const values = files.map((_filePath, index) => `...Object.values(realtimeModule${index})`);
+  return [
+    ...imports,
+    "",
+    `export const realtimeDefinitions = [${values.join(", ")}]`,
+    ""
+  ].join("\n");
+}
 function createRealtimeDefinitionVitePlugin(rootDir) {
+  const directories = resolveRealtimeDefinitionDirectories(rootDir);
+  let realtimeTreeChanged = false;
+  const loadedDefinitionIds = /* @__PURE__ */ new Set();
   return {
     name: "holo-realtime-client-definitions",
     enforce: "pre",
+    buildStart() {
+      assertRealtimeDefinitionTree(rootDir);
+    },
+    configureServer(server) {
+      server.watcher.on("all", (_event, path) => {
+        if (isInRealtimeDefinitionDirectory(directories, path)) realtimeTreeChanged = true;
+      });
+    },
     resolveId(source, importer, options) {
       if (options?.ssr) {
         return null;
@@ -272,22 +307,32 @@ function createRealtimeDefinitionVitePlugin(rootDir) {
       const resolved = resolveRealtimeDefinitionImport(source, importer);
       return resolved ? `${realtimeClientDefinitionPrefix}${resolved}` : null;
     },
-    load(id) {
-      if (!id.startsWith(realtimeClientDefinitionPrefix)) {
+    load(id, options) {
+      if (!options?.ssr && realtimeTreeChanged) {
+        assertRealtimeDefinitionTree(rootDir);
+        realtimeTreeChanged = false;
+      }
+      if (id.startsWith(realtimeClientDefinitionPrefix)) {
+        const sourcePath2 = id.slice(realtimeClientDefinitionPrefix.length);
+        loadedDefinitionIds.add(id);
+        return createRealtimeClientDefinitionModule(readFileSync(sourcePath2, "utf8"), sourcePath2);
+      }
+      if (options?.ssr || !isRealtimeDefinitionModule(rootDir, id, directories)) {
         return null;
       }
-      const sourcePath = id.slice(realtimeClientDefinitionPrefix.length);
-      return createRealtimeClientDefinitionModule(readFileSync(sourcePath, "utf8"));
+      const sourcePath = id.split("?")[0];
+      loadedDefinitionIds.add(id);
+      return createRealtimeClientDefinitionModule(readFileSync(sourcePath, "utf8"), sourcePath);
     },
     transform(code, id, options) {
       if (!options?.ssr && !id.includes("node_modules") && /\.[cm]?[jt]sx?$/.test(id)) {
         const compiled = compileBrowserValidation(code, id);
         if (compiled) return { code: compiled, map: null };
       }
-      if (options?.ssr || !isRealtimeDefinitionModule(rootDir, id)) {
+      if (options?.ssr || loadedDefinitionIds.has(id) || !isRealtimeDefinitionModule(rootDir, id, directories)) {
         return null;
       }
-      return createRealtimeClientDefinitionTransform(code);
+      return createRealtimeClientDefinitionTransform(code, id.split("?")[0]);
     }
   };
 }
@@ -328,20 +373,28 @@ function hasLoadedConfigFile(loaded, configName) {
     return normalizedPath.endsWith(`/config/${configName}.ts`) || normalizedPath.endsWith(`/config/${configName}.mts`) || normalizedPath.endsWith(`/config/${configName}.js`) || normalizedPath.endsWith(`/config/${configName}.mjs`) || normalizedPath.endsWith(`/config/${configName}.cts`) || normalizedPath.endsWith(`/config/${configName}.cjs`);
   });
 }
+async function writeGeneratedFile(path, contents) {
+  const { atomicFileInternals } = await import('@holo-js/core');
+  await atomicFileInternals.writeTextFile(path, contents);
+}
 async function ensureModelRegistryTypesPlaceholder(path) {
   try {
     await access(path);
     return;
   } catch {
     await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, "// Generated by holo prepare. Do not edit.\n\nexport {}\n", "utf8");
+    await writeGeneratedFile(path, "// Generated by holo prepare. Do not edit.\n\nexport {}\n");
   }
 }
+const STORAGE_CREDENTIAL_KEYS = /* @__PURE__ */ new Set(["accessKeyId", "secretAccessKey", "sessionToken"]);
+function withoutStorageCredentials(disk) {
+  return Object.fromEntries(Object.entries(disk).filter(([key]) => !STORAGE_CREDENTIAL_KEYS.has(key)));
+}
 function toStorageModuleOptions(loaded) {
   return {
     defaultDisk: loaded.storage.defaultDisk,
     routePrefix: loaded.storage.routePrefix,
-    disks: { ...loaded.storage.disks }
+    disks: Object.fromEntries(Object.entries(loaded.storage.disks).map(([name, disk]) => [name, withoutStorageCredentials(disk)]))
   };
 }
 function resolveStorageSetup(storageModule, loaded) {
@@ -357,11 +410,8 @@ function resolveStorageSetup(storageModule, loaded) {
     normalized: storageModule.normalizeModuleOptions(options)
   };
 }
-function finalizeStorageSetup(storageModule, opts, resolver, s3Driver) {
+function finalizeStorageSetup(storageModule, opts, resolver) {
   const normalized = storageModule.normalizeModuleOptions(opts._holoStorageModuleOptions);
-  opts.runtimeConfig = opts.runtimeConfig || {};
-  opts.runtimeConfig.holoStorage = normalized;
-  storageModule.applyNitroStorageConfig(opts, normalized, s3Driver);
   if (storageModule.hasPublicLocalDisk(normalized)) {
     addServerHandler({
       route: `${normalized.routePrefix}/**`,
@@ -369,11 +419,6 @@ function finalizeStorageSetup(storageModule, opts, resolver, s3Driver) {
     });
   }
 }
-function applyStorageRuntimeConfig(runtimeConfig, normalized) {
-  if (normalized) {
-    runtimeConfig.holoStorage = normalized;
-  }
-}
 async function createServerModelImports(projectRoot, modelsRelativePath, generatedSchemaRelativePath) {
   const modelsDir = resolve(projectRoot, modelsRelativePath);
   const generatedSchemaPath = resolve(projectRoot, generatedSchemaRelativePath);
@@ -409,16 +454,16 @@ async function createServerModelImports(projectRoot, modelsRelativePath, generat
     "export default () => {}"
   ];
   await mkdir(modelImportDir, { recursive: true });
-  await writeFile(modelImportFile, `${lines.join("\n")}
-`, "utf8");
-  await writeFile(modelPluginFile, `${pluginLines.join("\n")}
-`, "utf8");
+  await writeGeneratedFile(modelImportFile, `${lines.join("\n")}
+`);
+  await writeGeneratedFile(modelPluginFile, `${pluginLines.join("\n")}
+`);
   return {
     importDir: modelImportDir,
     pluginFile: modelPluginFile
   };
 }
-const module$1 = defineNuxtModule({
+const holoNuxtModule = defineNuxtModule({
   meta: {
     name: "@holo-js/adapter-nuxt"
   },
@@ -434,7 +479,6 @@ const module$1 = defineNuxtModule({
     addViteOptimizeDeps(opts, resolveClientOptimizeDeps(rootDir));
     const storageModule = await importOptionalStorageModule();
     const loaded = await loadConfigDirectory(rootDir, {
-      preferCache: process.env.NODE_ENV === "production",
       processEnv: process.env
     });
     if ((loaded.app.plugins ?? []).includes("@holo-js/panels")) {
@@ -444,9 +488,7 @@ const module$1 = defineNuxtModule({
       }
     }
     const storageSetup = resolveStorageSetup(storageModule, loaded);
-    const s3Driver = resolver.resolve("./runtime/drivers/s3.js");
-    opts.nitro = opts.nitro || { storage: {} };
-    opts.nitro.storage = opts.nitro.storage || {};
+    opts.nitro = opts.nitro || {};
     if (isProjectPackageLinked(rootDir, "@holo-js/core")) {
       opts.nitro.rollupConfig = {
         ...opts.nitro.rollupConfig,
@@ -467,11 +509,8 @@ const module$1 = defineNuxtModule({
     };
     opts.runtimeConfig.holo = {
       appUrl: loaded.app.url,
-      appEnv: loaded.app.env,
-      appDebug: loaded.app.debug,
       projectRoot: rootDir
     };
-    opts.runtimeConfig.db = loaded.database;
     const mergedStorageOptions = storageSetup.options;
     const normalizedStorage = storageSetup.normalized;
     opts._holoStorageModuleOptions = mergedStorageOptions;
@@ -480,11 +519,10 @@ const module$1 = defineNuxtModule({
         throw new Error("[@holo-js/adapter-nuxt] S3 storage disks require @holo-js/storage-s3 to be installed.");
       }
     }
-    applyStorageRuntimeConfig(opts.runtimeConfig, normalizedStorage);
     if (!opts._holoCoreRuntimeRegistered) {
       if (existsSync(resolve(rootDir, ".holo-js/generated/definition-importer.ts"))) {
         const initPluginPath = resolve(rootDir, ".holo-js/generated/nuxt-init.ts");
-        await writeFile(initPluginPath, [
+        await writeGeneratedFile(initPluginPath, [
           `import init from ${JSON.stringify(resolver.resolve("./runtime/plugins/init"))}`,
           "import { installProjectDefinitionImporter } from './definition-importer'",
           "",
@@ -492,7 +530,7 @@ const module$1 = defineNuxtModule({
           "",
           "export default init",
           ""
-        ].join("\n"), "utf8");
+        ].join("\n"));
         addServerPlugin(initPluginPath);
       } else {
         addServerPlugin(resolver.resolve("./runtime/plugins/init"));
@@ -511,10 +549,6 @@ const module$1 = defineNuxtModule({
       }
       opts._holoCoreRuntimeRegistered = true;
     }
-    if (storageModule && !opts._holoStorageRuntimeRegistered) {
-      addServerPlugin(resolver.resolve("./runtime/plugins/storage"));
-      opts._holoStorageRuntimeRegistered = true;
-    }
     if (hasProjectPackage(rootDir, "@holo-js/broadcast") && !opts._holoBroadcastAuthRouteRegistered) {
       addServerHandler({
         route: "/broadcasting/config",
@@ -551,11 +585,12 @@ const module$1 = defineNuxtModule({
         route: "/holo/realtime/mutation",
         handler: resolver.resolve("./runtime/server/routes/realtime-mutation.post")
       });
+      opts.nitro.virtual = {
+        ...opts.nitro.virtual,
+        [realtimeDefinitionsModuleId]: () => renderRealtimeDefinitionsModule(rootDir)
+      };
       opts._holoRealtimeRouteRegistered = true;
     }
-    if (storageModule && normalizedStorage && (!opts.nitro.storage || Object.keys(opts.nitro.storage).every((key) => !key.startsWith("holo:")))) {
-      storageModule.applyNitroStorageConfig(opts, normalizedStorage, s3Driver);
-    }
     const runtimePath = resolver.resolve("./runtime");
     for (const packageName of [runtimePath, "@holo-js/auth"]) {
       if (!opts.build.transpile.includes(packageName)) {
@@ -565,7 +600,7 @@ const module$1 = defineNuxtModule({
     if (storageModule && !opts._holoStorageFinalizeRegistered) {
       opts._holoStorageFinalizeRegistered = true;
       nuxt.hook("modules:done", () => {
-        finalizeStorageSetup(storageModule, opts, resolver, s3Driver);
+        finalizeStorageSetup(storageModule, opts, resolver);
       });
     }
     if (!opts._holoTypesRegistered) {
@@ -573,12 +608,27 @@ const module$1 = defineNuxtModule({
       await ensureModelRegistryTypesPlaceholder(authTypesPath);
       await ensureModelRegistryTypesPlaceholder(authorizationTypesPath);
       await ensureModelRegistryTypesPlaceholder(modelRegistryTypesPath);
-      nuxt.hook("prepare:types", ({ references }) => {
-        references.push({ types: "@holo-js/adapter-nuxt" });
-        references.push({ path: authTypesPath });
-        references.push({ path: authorizationTypesPath });
-        references.push({ path: modelRegistryTypesPath });
-        for (const path of pluginTypesPaths) references.push({ path });
+      const serverTypeReferences = [authTypesPath, authorizationTypesPath, modelRegistryTypesPath, ...pluginTypesPaths].map((path) => ({ path }));
+      const serverTypeIncludes = [resolve(rootDir, "config/**/*")];
+      nuxt.hook("nitro:prepare:types", ({ references }) => {
+        references.push(...serverTypeReferences);
+      });
+      nuxt.hook("nitro:config", (nitroConfig) => {
+        nitroConfig.typescript ??= {};
+        nitroConfig.typescript.tsConfig ??= {};
+        nitroConfig.typescript.tsConfig.include = [...nitroConfig.typescript.tsConfig.include ?? [], ...serverTypeIncludes];
+      });
+      nuxt.hook("prepare:types", async ({ references, serverReferences, tsConfig, serverTsConfig }) => {
+        references.push({ types: "@holo-js/adapter-nuxt" }, ...serverTypeReferences);
+        serverReferences?.push(...serverTypeReferences);
+        if (serverTsConfig) serverTsConfig.include = [...serverTsConfig.include ?? [], ...serverTypeIncludes];
+        const options = nuxt.options;
+        const { projectTsconfigInternals } = await import('@holo-js/core');
+        await projectTsconfigInternals.writeNuxtTsconfigSnapshot(
+          rootDir,
+          options.typesDir || options.buildDir || resolve(rootDir, ".nuxt"),
+          { tsConfig, serverTsConfig }
+        );
       });
     }
   }
@@ -594,7 +644,6 @@ const moduleInternals = {
   hasModuleNotFoundCode,
   hasLoadedConfigFile,
   importOptionalStorageS3Module,
-  applyStorageRuntimeConfig,
   finalizeStorageSetup,
   resolveStorageSetup,
   isModuleResolutionFailure,
@@ -603,6 +652,7 @@ const moduleInternals = {
   isProjectPackageLinked,
   isRealtimeDefinitionModule,
   resolveClientOptimizeDeps,
+  renderRealtimeDefinitionsModule,
   resolveExistingRealtimeDefinitionFile,
   resolveRealtimeDefinitionImport
 };
@@ -610,4 +660,4 @@ const adapterNuxtInternals = {
   toStorageModuleOptions
 };
 
-export { adapterNuxtInternals, module$1 as default, moduleInternals };
+export { adapterNuxtInternals, holoNuxtModule as default, moduleInternals };

package/dist/runtime/authorization-error.js

@@ -1,4 +1,4 @@
-import { createError } from "h3";
+import { createError } from "#imports";
 export function createNuxtAuthorizationError(decision) {
   const status = decision.status === 404 ? 404 : 403;
   return createError({

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

@@ -1,5 +1,4 @@
 import type { HoloAdapterProjectAccessors } from '@holo-js/core'
-import type { RuntimeDatabaseConfig } from '@holo-js/db'
 
 export interface HoloRuntimeConnection {
   driver?: 'sqlite' | 'postgres' | 'mysql'
@@ -29,14 +28,19 @@ export interface HoloRuntimeDefaultConnection extends HoloRuntimeConnection {
 export declare const holo: HoloAdapterProjectAccessors
 export declare function configureHoloRuntimeConfig(config: {
   holo: {
-    appEnv: 'production' | 'development' | 'test'
-    appDebug: boolean
     appUrl?: string
     projectRoot?: string
   }
-  db?: RuntimeDatabaseConfig
 }): void
 export declare function resetHoloRuntimeConfig(): void
+export type NuxtRuntime = {
+  readonly useEvent: () => NuxtAuthRequestEvent | undefined
+  readonly createAuthorizationError: (decision: {
+    readonly message?: string
+    readonly status: 200 | 403 | 404
+  }) => Error
+}
+export declare function configureNuxtRuntime(runtime: NuxtRuntime): void
 export type NuxtAuthRequestEvent = {
   readonly headers?: Pick<Headers, 'get'>
   readonly request?: {
@@ -52,8 +56,10 @@ export type NuxtAuthRequestEvent = {
       readonly headers?: Readonly<Record<string, string | readonly string[] | undefined>>
     }
     readonly res?: {
+      statusCode: number
       getHeader(name: string): number | string | readonly string[] | undefined
       setHeader(name: string, value: number | string | readonly string[]): void
+      end(): void
     }
   }
 }

package/dist/runtime/composables/index.js

@@ -1,8 +1,12 @@
+import { resolveProjectAppEnvironmentSync } from "@holo-js/config";
 import {
   createHoloProjectAccessors,
+  getHolo,
   initializeHoloAdapterProject
 } from "@holo-js/core";
-import { createNuxtAuthorizationError } from "../authorization-error.js";
+import { createCookieWriteUnavailableError } from "@holo-js/kernel";
+import { getNuxtRuntime } from "../nitro-runtime.js";
+export { configureNuxtRuntime } from "../nitro-runtime.js";
 export function configureHoloRuntimeConfig(config) {
   const runtimeGlobals = globalThis;
   runtimeGlobals.__holoRuntimeConfig = config;
@@ -21,15 +25,9 @@ function getRuntimeConfig() {
   }
   return runtimeGlobals.useRuntimeConfig();
 }
-function resolveRuntimeEnvName(env) {
-  return env;
-}
 function resolveRuntimeProjectRoot(config) {
   return config.holo.projectRoot?.trim() || process.cwd();
 }
-async function loadNitroContextModule() {
-  return await import("nitropack/runtime/context");
-}
 export function createNuxtAuthRequestAccessors(requestEvent) {
   function safeDecode(value) {
     try {
@@ -39,7 +37,7 @@ export function createNuxtAuthRequestAccessors(requestEvent) {
     }
   }
   async function readHeader(name) {
-    const event = requestEvent ?? (await loadNitroContextModule()).useEvent();
+    const event = requestEvent ?? getNuxtRuntime().useEvent();
     if (!event) {
       return void 0;
     }
@@ -80,11 +78,14 @@ export function createNuxtAuthRequestAccessors(requestEvent) {
     }
     return void 0;
   }
+  async function resolveResponse() {
+    const event = requestEvent ?? getNuxtRuntime().useEvent();
+    return event?.node?.res;
+  }
   async function appendCookie(cookie) {
-    const event = requestEvent ?? (await loadNitroContextModule()).useEvent();
-    const response = event?.node?.res;
+    const response = await resolveResponse();
     if (!response) {
-      return;
+      throw createCookieWriteUnavailableError("Authentication cookies cannot be set outside an active Nitro request.");
     }
     const current = response.getHeader("set-cookie");
     if (Array.isArray(current)) {
@@ -103,20 +104,26 @@ export function createNuxtAuthRequestAccessors(requestEvent) {
   const getHeaderValue = async (name) => {
     return await readHeader(name);
   };
+  const canAppendResponseCookie = async () => {
+    return Boolean(await resolveResponse());
+  };
   const appendResponseCookie = async (cookie) => {
     await appendCookie(cookie);
   };
   const redirectResponse = async (url, status) => {
-    const event = requestEvent ?? (await loadNitroContextModule()).useEvent();
-    if (!event) {
+    const event = requestEvent ?? getNuxtRuntime().useEvent();
+    const response = event?.node?.res;
+    if (!response) {
       throw new TypeError("Holo Nuxt auth redirect requires an active Nitro event.");
     }
-    const { sendRedirect } = await import("h3");
-    await sendRedirect(event, url, status);
+    response.statusCode = status ?? 302;
+    response.setHeader("location", url);
+    response.end();
   };
   return {
     getCookie: getCookieValue,
     getHeader: getHeaderValue,
+    canAppendResponseCookie,
     appendResponseCookie,
     redirectResponse
   };
@@ -131,28 +138,21 @@ export const holo = createHoloProjectAccessors(async () => {
   const config = getRuntimeConfig();
   const authRequest = createNuxtAuthRequestAccessors();
   const project = await initializeHoloAdapterProject(resolveRuntimeProjectRoot(config), {
-    envName: resolveRuntimeEnvName(config.holo.appEnv),
-    preferCache: process.env.NODE_ENV === "production",
     processEnv: process.env,
     authRequest,
     authorizationError: {
-      createError: createNuxtAuthorizationError
+      createError: getNuxtRuntime().createAuthorizationError
     }
   });
   const runtimeGlobals = globalThis;
   runtimeGlobals.__holoNuxtAuthRequestRunner = (accessors, callback) => project.runtime.runWithAuthRequestAccessors(accessors, callback);
   return project;
-}, { cache: process.env.NODE_ENV === "production" });
-function resolveDefaultConnectionName(group) {
-  if (group.defaultConnection) {
-    return group.defaultConnection;
-  }
-  const connectionNames = Object.keys(group.connections);
-  if (connectionNames.includes("default")) {
-    return "default";
-  }
-  return connectionNames[0] ?? "default";
-}
+}, {
+  cache: () => resolveProjectAppEnvironmentSync({
+    cwd: resolveRuntimeProjectRoot(getRuntimeConfig()),
+    processEnv: process.env
+  }) === "production"
+});
 function normalizeConnection(connection) {
   const driver = connection.driver ?? (connection.filename ? "sqlite" : void 0);
   const database = connection.database ?? connection.filename;
@@ -171,14 +171,10 @@ function normalizeConnection(connection) {
   };
 }
 export function useHoloDb() {
-  const config = getRuntimeConfig();
-  const group = config.db ?? { connections: {} };
+  const group = getHolo().loadedConfig.database;
   const connections = group.connections ?? {};
   return {
-    defaultConnection: resolveDefaultConnectionName({
-      defaultConnection: group.defaultConnection,
-      connections
-    }),
+    defaultConnection: group.defaultConnection ?? "default",
     connections: Object.fromEntries(
       Object.entries(connections).map(([name, connection]) => {
         if (typeof connection === "string") {
@@ -190,10 +186,8 @@ export function useHoloDb() {
   };
 }
 export function useHoloEnv() {
-  const config = getRuntimeConfig();
-  return resolveRuntimeEnvName(config.holo.appEnv);
+  return getHolo().loadedConfig.environment.name;
 }
 export function useHoloDebug() {
-  const config = getRuntimeConfig();
-  return config.holo.appDebug;
+  return getHolo().loadedConfig.app.debug;
 }

package/dist/runtime/nitro-runtime.js

@@ -0,0 +1,9 @@
+export function configureNuxtRuntime(runtime) {
+  const globals = globalThis;
+  globals.__holoNuxtRuntime = runtime;
+}
+export function getNuxtRuntime() {
+  const runtime = globalThis.__holoNuxtRuntime;
+  if (!runtime) throw new TypeError("Holo Nuxt runtime is not configured.");
+  return runtime;
+}

package/dist/runtime/plugins/forms.js

@@ -1,4 +1,4 @@
-import { defineNitroPlugin } from "nitropack/runtime/plugin";
+import { defineNitroPlugin } from "#imports";
 import {
   applyFormFailureRedirect,
   getFormFailurePayload,

package/dist/runtime/plugins/init.js

@@ -1,33 +1,51 @@
 import {
   createNuxtAuthRequestAccessors,
-  configureHoloRuntimeConfig
+  configureHoloRuntimeConfig,
+  configureNuxtRuntime
 } from "../composables/index.js";
 import { createNuxtAuthorizationError } from "../authorization-error.js";
+import { connectionAddress } from "../server/connection-address.js";
 import { initializeHoloAdapterProject } from "@holo-js/core";
-import { useRuntimeConfig } from "nitropack/runtime/config";
-import { defineNitroPlugin } from "nitropack/runtime/plugin";
+import { requestUrlInternals } from "@holo-js/kernel";
+import { captureErrorReporter } from "@holo-js/kernel/error-reporting";
+import { defineNitroPlugin, useEvent, useRuntimeConfig } from "#imports";
 export default defineNitroPlugin((nitroApp) => {
   const config = useRuntimeConfig();
+  configureNuxtRuntime({ useEvent, createAuthorizationError: createNuxtAuthorizationError });
   configureHoloRuntimeConfig(config);
+  requestUrlInternals.provideConnectionAddress(() => connectionAddress(useEvent().node.req.socket));
   const project = initializeHoloAdapterProject(config.holo.projectRoot?.trim() || process.cwd(), {
-    envName: config.holo.appEnv,
-    preferCache: process.env.NODE_ENV === "production",
     processEnv: process.env,
     authRequest: createNuxtAuthRequestAccessors(),
     authorizationError: {
       createError: createNuxtAuthorizationError
     }
   });
+  let projectPending = true;
+  const markProjectSettled = () => {
+    projectPending = false;
+  };
+  const projectSettled = project.then(markProjectSettled, markProjectSettled);
   const onRequest = nitroApp.h3App.options.onRequest;
   nitroApp.h3App.options.onRequest = async (event) => {
     await project;
     return await onRequest?.(event);
   };
-  nitroApp.hooks.hook("close", async () => {
+  const shutdownProject = async () => {
+    let report;
     try {
-      await (await project).runtime.shutdown();
-    } catch {
+      const { runtime } = await project;
+      report = captureErrorReporter();
+      await runtime.shutdown();
+    } catch (error) {
+      (report ?? captureErrorReporter())(error, { capability: "nuxt", operation: "shutdown" });
+    }
+  };
+  nitroApp.hooks.hook("close", async () => {
+    if (projectPending) {
+      void projectSettled.then(shutdownProject);
       return;
     }
+    await shutdownProject();
   });
 });

package/dist/runtime/server/connection-address.js

@@ -0,0 +1,7 @@
+function isUnixSocket(socket) {
+  return !socket.destroyed && Object.keys(socket.address()).length === 0;
+}
+export function connectionAddress(socket) {
+  if (socket.remoteAddress) return socket.remoteAddress;
+  return isUnixSocket(socket) ? "127.0.0.1" : void 0;
+}

package/dist/runtime/server/error.js

@@ -1,26 +1,17 @@
-import { send, setHeader, setResponseStatus } from "h3";
-import { isValidationException } from "@holo-js/validation";
-import { serializeRateLimitError } from "@holo-js/adapter-shared/server-errors";
+import { send, setHeader, setResponseStatus } from "#imports";
+import { serializeValidationException } from "@holo-js/validation";
+import { serializeRateLimitError, serializeRequestBodyTooLargeError } from "@holo-js/adapter-shared/server-errors";
 import {
   applyFormFailureRedirect,
   shouldRedirectFormFailure
 } from "./form-failure.js";
-function findValidationException(error) {
-  if (isValidationException(error)) {
-    return error;
-  }
-  if (!error || typeof error !== "object" || !("cause" in error)) {
-    return void 0;
-  }
-  return findValidationException(error.cause);
-}
 export default async function handleValidationError(error, event) {
-  const validationError = findValidationException(error);
-  const payload = validationError?.toJSON() ?? serializeRateLimitError(error);
+  const bodyTooLarge = serializeRequestBodyTooLargeError(error);
+  const payload = bodyTooLarge ?? serializeValidationException(error) ?? serializeRateLimitError(error);
   if (!payload) {
     return;
   }
-  if (shouldRedirectFormFailure(event)) {
+  if (!bodyTooLarge && shouldRedirectFormFailure(event)) {
     const failure = { ...payload };
     const response = {};
     applyFormFailureRedirect(event, response, failure);

package/dist/runtime/server/form-failure.js

@@ -1,3 +1,4 @@
+import { resolveRequestUrl, sameOriginRedirectPath } from "@holo-js/kernel";
 const FORM_FAILURE_COOKIE = "holo_form_failure";
 function getHeader(event, name) {
   const value = event.node?.req?.headers?.[name.toLowerCase()];
@@ -42,12 +43,12 @@ function getRedirectLocation(event) {
     try {
       const url = new URL(referer);
       if (url.host === host) {
-        return `${url.pathname}${url.search}`;
+        return sameOriginRedirectPath(`${url.pathname}${url.search}`);
       }
     } catch {
     }
   }
-  return event.path ?? event.node?.req?.url ?? "/";
+  return sameOriginRedirectPath(event.path ?? event.node?.req?.url);
 }
 function appendSetCookie(event, response, cookie) {
   const responseCookie = event.node?.res?.getHeader?.("set-cookie");
@@ -79,9 +80,21 @@ function setHeader(event, response, name, value) {
   response.headers ??= {};
   response.headers[name] = value;
 }
-function serializeFormFailureCookie(payload) {
-  const encoded = encodeURIComponent(JSON.stringify(payload));
-  return `${FORM_FAILURE_COOKIE}=${encoded}; Path=/; Max-Age=60; SameSite=Lax`;
+function isSecureRequest(event) {
+  const request = event.node?.req;
+  const socket = request?.socket;
+  const protocol = socket && "encrypted" in socket && socket.encrypted === true ? "https" : "http";
+  try {
+    return resolveRequestUrl({ url: `${protocol}://localhost/`, headers: request?.headers }).protocol === "https:";
+  } catch {
+    return protocol === "https";
+  }
+}
+function serializeFormFailureCookie(event, payload) {
+  const { values: _values, ...failure } = payload;
+  const encoded = encodeURIComponent(JSON.stringify(failure));
+  const secure = isSecureRequest(event) ? "; Secure" : "";
+  return `${FORM_FAILURE_COOKIE}=${encoded}; Path=/; Max-Age=60; SameSite=Lax${secure}`;
 }
 export function shouldRedirectFormFailure(event) {
   return isUnsafeMethod(event) && acceptsHtml(event) && !isApiRequest(event);
@@ -96,7 +109,7 @@ export function applyFormFailureRedirect(event, response, failure) {
   response.body = "";
   setHeader(event, response, "location", getRedirectLocation(event));
   setHeader(event, response, "content-type", "text/html; charset=utf-8");
-  appendSetCookie(event, response, serializeFormFailureCookie(failure));
+  appendSetCookie(event, response, serializeFormFailureCookie(event, failure));
 }
 export const formFailureInternals = {
   appendSetCookie

package/dist/runtime/server/route-request.js

@@ -0,0 +1,39 @@
+import { createError, getHeaders, getRequestHeader, getRequestURL } from "#imports";
+import { HoloRequestBodyTooLargeError, readBoundedBufferedBody, readBoundedNodeRequestBody, requestBodyLimitFor } from "@holo-js/kernel";
+async function readBoundedEventBody(event) {
+  const limit = requestBodyLimitFor(getRequestHeader(event, "content-type"));
+  try {
+    const node = event.node.req;
+    const buffered = await readBoundedBufferedBody(
+      event._requestBody || event.web?.request?.body || node[Symbol.for("h3RawBody")] || node.rawBody || node.body,
+      limit
+    );
+    if (buffered) return buffered;
+    const bytes = await readBoundedNodeRequestBody(event.node.req, limit, getRequestHeader(event, "content-length"));
+    event._requestBody = bytes;
+    Object.assign(event.node.req, { [Symbol.for("h3RawBody")]: bytes });
+    return { bytes };
+  } catch (error) {
+    if (error instanceof HoloRequestBodyTooLargeError) {
+      throw createError({ statusCode: error.status, statusMessage: "Payload Too Large", cause: error });
+    }
+    throw error;
+  }
+}
+export async function createWebRequest(event) {
+  const buffered = await readBoundedEventBody(event);
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(getHeaders(event))) {
+    if (typeof value === "string") {
+      headers.set(key, value);
+    }
+  }
+  if (buffered.contentType) {
+    headers.set("content-type", buffered.contentType);
+  }
+  return new Request(getRequestURL(event, { xForwardedProto: false }), {
+    body: buffered.bytes,
+    headers,
+    method: event.method
+  });
+}

package/dist/runtime/server/routes/broadcast-auth.post.js

@@ -1,6 +1,7 @@
-import { defineEventHandler, getHeaders, getRequestURL, readRawBody } from "h3";
+import { defineEventHandler } from "#imports";
 import { renderBroadcastAuthResponse } from "@holo-js/broadcast/auth";
 import { holo } from "../../composables/index.js";
+import { createWebRequest } from "../route-request.js";
 function resolveBroadcastSigning(connection) {
   if (!connection || typeof connection !== "object") {
     return {};
@@ -20,18 +21,7 @@ export default defineEventHandler(async (event) => {
   const broadcast = app.config?.broadcast;
   const connection = broadcast ? broadcast.connections[broadcast.default] : void 0;
   const signing = resolveBroadcastSigning(connection);
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(getHeaders(event))) {
-    if (typeof value === "string") {
-      headers.set(key, value);
-    }
-  }
-  const request = new Request(getRequestURL(event), {
-    method: event.method,
-    headers,
-    body: await readRawBody(event)
-  });
-  return await renderBroadcastAuthResponse(request, {
+  return await renderBroadcastAuthResponse(await createWebRequest(event), {
     ...signing,
     resolveUser: async (_request, context) => {
       const guardAuth = context.guard ? auth?.guard(context.guard) : void 0;

package/dist/runtime/server/routes/broadcast-config.get.js

@@ -1,4 +1,4 @@
-import { defineEventHandler } from "h3";
+import { defineEventHandler } from "#imports";
 import { renderBroadcastClientConfigResponse } from "@holo-js/broadcast/client-config";
 import { holo } from "../../composables/index.js";
 export default defineEventHandler(async () => {

package/dist/runtime/server/routes/realtime-mutation.post.js

@@ -1,9 +1,10 @@
-import { defineEventHandler } from "h3";
-import { useRuntimeConfig } from "#imports";
+import { defineEventHandler, useRuntimeConfig } from "#imports";
 import { handleRealtimeMutationRequest } from "@holo-js/realtime/server";
-import { createRealtimeRequest } from "./realtime-request.js";
+import { realtimeDefinitions } from "#holo/realtime-definitions";
+import { createWebRequest } from "../route-request.js";
 export default defineEventHandler(async (event) => {
-  return await handleRealtimeMutationRequest(await createRealtimeRequest(event), {
-    projectRoot: useRuntimeConfig().holo.projectRoot ?? process.cwd()
+  return await handleRealtimeMutationRequest(await createWebRequest(event), {
+    projectRoot: useRuntimeConfig().holo.projectRoot ?? process.cwd(),
+    definitions: realtimeDefinitions
   });
 });

package/dist/runtime/server/routes/realtime-query.post.js

@@ -1,9 +1,10 @@
-import { defineEventHandler } from "h3";
-import { useRuntimeConfig } from "#imports";
+import { defineEventHandler, useRuntimeConfig } from "#imports";
 import { handleRealtimeQueryRequest } from "@holo-js/realtime/server";
-import { createRealtimeRequest } from "./realtime-request.js";
+import { realtimeDefinitions } from "#holo/realtime-definitions";
+import { createWebRequest } from "../route-request.js";
 export default defineEventHandler(async (event) => {
-  return await handleRealtimeQueryRequest(await createRealtimeRequest(event), {
-    projectRoot: useRuntimeConfig().holo.projectRoot ?? process.cwd()
+  return await handleRealtimeQueryRequest(await createWebRequest(event), {
+    projectRoot: useRuntimeConfig().holo.projectRoot ?? process.cwd(),
+    definitions: realtimeDefinitions
   });
 });

package/dist/runtime/server/routes/storage.js

@@ -1,8 +1,14 @@
 import { createPublicStorageResponse } from "@holo-js/storage";
-import { defineEventHandler, sendWebResponse, toWebRequest } from "h3";
+import { defineEventHandler, getRequestURL, sendWebResponse } from "#imports";
 import { holo } from "../../composables/index.js";
+function createStorageRequest(event) {
+  return event.web?.request ?? new Request(getRequestURL(event, { xForwardedProto: false }), {
+    method: event.method,
+    headers: event.headers
+  });
+}
 export default defineEventHandler(async (event) => {
   const app = await holo.getApp();
-  const response = await createPublicStorageResponse(app.projectRoot, app.config.storage, toWebRequest(event), app.config.app.key);
+  const response = await createPublicStorageResponse(app.projectRoot, app.config.storage, createStorageRequest(event), app.config.app.key);
   return sendWebResponse(event, response);
 });

package/dist/runtime/shims.d.ts

@@ -1,45 +1,12 @@
-import type { RuntimeConfigInput, RuntimeConnectionConfig, RuntimeDatabaseConfig } from '@holo-js/db'
-
-type HoloConnectionRuntimeConfig = RuntimeConnectionConfig
-type HoloDatabaseRuntimeConfig = RuntimeDatabaseConfig
-
-interface StorageRuntimeDriverShim {
-  name: string
-  driver: 'local' | 'public' | 's3'
-  visibility: 'private' | 'public'
-  root?: string
-  url?: string
-  bucket?: string
-  region?: string
-  endpoint?: string
-  accessKeyId?: string
-  secretAccessKey?: string
-  sessionToken?: string
-  forcePathStyleEndpoint?: boolean
-}
+import type { RuntimeConfigInput } from '@holo-js/db'
 
 interface HoloRuntimeConfig extends RuntimeConfigInput {
   holo: NonNullable<RuntimeConfigInput['holo']> & {
-    appEnv: 'production' | 'development' | 'test'
-    appDebug: boolean
     appUrl?: string
     projectRoot?: string
   }
-  db?: HoloDatabaseRuntimeConfig
-  holoStorage: {
-    defaultDisk: string | undefined
-    diskNames: string[]
-    routePrefix: string
-    disks: Record<string, StorageRuntimeDriverShim>
-  }
 }
 
-/**
- * Minimal Nuxt runtime shims for adapter typechecking.
- *
- * Keep these declarations limited to the fields consumed by adapter runtime code:
- * runtime config, storage access, and Nitro route/plugin globals.
- */
 declare module '#app' {
   export function defineNuxtPlugin<T>(plugin: T): T
   export function useRuntimeConfig(): HoloRuntimeConfig
@@ -48,23 +15,9 @@ declare module '#app' {
 
 declare module '#imports' {
   export function useRuntimeConfig(): HoloRuntimeConfig
-  export function useStorage(base: string): unknown
-}
-
-declare module 'nitropack/runtime/config' {
-  export function useRuntimeConfig(): HoloRuntimeConfig
-}
-
-declare module 'nitropack/runtime/context' {
-  export function useEvent(): unknown
-}
-
-declare module 'nitropack/runtime/plugin' {
+  export function useEvent(): import('h3').H3Event
   export function defineNitroPlugin<T>(plugin: T): T
-}
-
-declare module 'nitropack/runtime/storage' {
-  export function useStorage(base: string): unknown
+  export * from 'h3'
 }
 
 declare global {

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@holo-js/adapter-nuxt",
-  "version": "0.3.28",
+  "version": "0.4.1",
   "description": "Holo-JS Framework - Nuxt adapter",
   "type": "module",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cobraprojects/holo-js.git",
+    "directory": "packages/adapter-nuxt"
+  },
   "exports": {
     ".": {
       "types": "./dist/types.d.mts",
@@ -29,7 +34,8 @@
   "main": "./dist/module.mjs",
   "types": "./dist/types.d.mts",
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
   "scripts": {
     "build": "nuxt-module-build build",
@@ -38,22 +44,22 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/adapter-shared": "^0.3.28",
-    "@nuxt/kit": "^4.4.4",
-    "@holo-js/config": "^0.3.28",
-    "@holo-js/core": "^0.3.28",
-    "@holo-js/db": "^0.3.28",
-    "@holo-js/validation": "^0.3.28",
-    "h3": "^1.15.11",
-    "nitropack": "^2.13.4"
+    "@holo-js/adapter-shared": "^0.4.1",
+    "@nuxt/kit": "^4.6.2",
+    "@holo-js/config": "^0.4.1",
+    "@holo-js/core": "^0.4.1",
+    "@holo-js/db": "^0.4.1",
+    "@holo-js/kernel": "^0.4.1",
+    "@holo-js/validation": "^0.4.1"
   },
   "peerDependencies": {
+    "nuxt": "^4.6.2",
     "vue": "^3.5.13",
-    "@holo-js/broadcast": "^0.3.28",
-    "@holo-js/forms": "^0.3.28",
-    "@holo-js/realtime": "^0.3.28",
-    "@holo-js/storage": "^0.3.28",
-    "@holo-js/storage-s3": "^0.3.28"
+    "@holo-js/broadcast": "^0.4.1",
+    "@holo-js/forms": "^0.4.1",
+    "@holo-js/realtime": "^0.4.1",
+    "@holo-js/storage": "^0.4.1",
+    "@holo-js/storage-s3": "^0.4.1"
   },
   "peerDependenciesMeta": {
     "@holo-js/broadcast": {
@@ -74,17 +80,18 @@
   },
   "devDependencies": {
     "vue": "^3.5.13",
-    "@holo-js/broadcast": "^0.3.28",
-    "@holo-js/realtime": "^0.3.28",
-    "@holo-js/storage-s3": "^0.3.28",
+    "@holo-js/broadcast": "^0.4.1",
+    "@holo-js/realtime": "^0.4.1",
+    "@holo-js/storage-s3": "^0.4.1",
     "@nuxt/module-builder": "^1.0.2",
-    "@types/node": "^22.10.2",
-    "nuxt": "^4.4.4",
-    "typescript": "^5.7.2",
-    "vitest": "^4.1.5",
-    "@nuxt/nitro-server": "^4.4.4"
+    "@types/node": "^22.20.5",
+    "nuxt": "^4.6.2",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.5",
+    "@nuxt/nitro-server": "^4.6.2",
+    "h3": "^1.15.11"
   },
   "engines": {
-    "node": "^22.12.0 || ^24.0.0 || ^26.0.0"
+    "node": "^22.18.0 || ^24.0.0 || ^26.0.0"
   }
 }

package/dist/runtime/drivers/s3.js

@@ -1 +0,0 @@
-export { default } from "@holo-js/storage-s3";

package/dist/runtime/plugins/storage.js

@@ -1,10 +0,0 @@
-import { configureStorageRuntime } from "@holo-js/storage/runtime";
-import { useRuntimeConfig } from "nitropack/runtime/config";
-import { defineNitroPlugin } from "nitropack/runtime/plugin";
-import { useStorage as useNitroStorage } from "nitropack/runtime/storage";
-export default defineNitroPlugin(() => {
-  configureStorageRuntime({
-    getRuntimeConfig: () => useRuntimeConfig(),
-    getStorage: (base) => useNitroStorage(base)
-  });
-});

package/dist/runtime/server/routes/realtime-request.js

@@ -1,14 +0,0 @@
-import { getHeaders, getRequestURL, readRawBody } from "h3";
-export async function createRealtimeRequest(event) {
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(getHeaders(event))) {
-    if (typeof value === "string") {
-      headers.set(key, value);
-    }
-  }
-  return new Request(getRequestURL(event), {
-    body: await readRawBody(event),
-    headers,
-    method: event.method
-  });
-}