@holo-js/adapter-nuxt 0.1.4 → 0.1.6

package/dist/module.d.mts

@@ -22,10 +22,74 @@ type StorageModuleOptions = {
     routePrefix?: string;
     disks?: Record<string, StorageDiskConfig>;
 };
+type RuntimeDiskConfig = {
+    name: string;
+    driver: StorageDriver;
+    visibility: StorageVisibility;
+    root?: string;
+    url?: string;
+    bucket?: string;
+    region?: string;
+    endpoint?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+    forcePathStyleEndpoint?: boolean;
+};
+type HoloStorageRuntimeConfig = {
+    defaultDisk: string | undefined;
+    diskNames: string[];
+    routePrefix: string;
+    disks: Record<string, RuntimeDiskConfig>;
+};
 type StorageS3Module = {
     default: unknown;
 };
 declare function hasModuleNotFoundCode(error: unknown, expectedSpecifier: string): boolean;
+declare function isModuleResolutionFailure(error: unknown): boolean;
+type ViteOptimizeDepsOptions = {
+    include?: string[];
+    [key: string]: unknown;
+};
+type NuxtViteOptions = {
+    optimizeDeps?: ViteOptimizeDepsOptions;
+    [key: string]: unknown;
+};
+interface NuxtOptionsWithNitro {
+    nitro: {
+        storage: Record<string, unknown>;
+        errorHandler?: string | string[];
+        experimental?: {
+            asyncContext?: boolean;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+    runtimeConfig: {
+        public?: {
+            holo?: {
+                appName?: string;
+                [key: string]: unknown;
+            };
+            [key: string]: unknown;
+        };
+        holoStorage?: HoloStorageRuntimeConfig;
+        [key: string]: unknown;
+    };
+    build: {
+        transpile: string[];
+    };
+    vite?: NuxtViteOptions;
+    srcDir: string;
+    rootDir?: string;
+    _holoStorageModuleOptions?: StorageModuleOptions;
+    _holoStorageFinalizeRegistered?: boolean;
+    _holoStorageRuntimeRegistered?: boolean;
+    _holoCoreRuntimeRegistered?: boolean;
+    _holoTypesRegistered?: boolean;
+}
+declare function resolveClientOptimizeDeps(rootDir: string): string[];
+declare function addViteOptimizeDeps(opts: NuxtOptionsWithNitro, deps: readonly string[]): void;
 declare function importOptionalStorageS3Module(): Promise<StorageS3Module | undefined>;
 declare function hasLoadedConfigFile(loaded: LoadedHoloConfig<HoloConfigMap>, configName: string): boolean;
 declare function toStorageModuleOptions(loaded: LoadedHoloConfig<HoloConfigMap>): StorageModuleOptions;
@@ -38,9 +102,12 @@ declare const _default: {
 };
 
 declare const moduleInternals: {
+    addViteOptimizeDeps: typeof addViteOptimizeDeps;
     hasModuleNotFoundCode: typeof hasModuleNotFoundCode;
     hasLoadedConfigFile: typeof hasLoadedConfigFile;
     importOptionalStorageS3Module: typeof importOptionalStorageS3Module;
+    isModuleResolutionFailure: typeof isModuleResolutionFailure;
+    resolveClientOptimizeDeps: typeof resolveClientOptimizeDeps;
 };
 declare const adapterNuxtInternals: {
     toStorageModuleOptions: typeof toStorageModuleOptions;

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@holo-js/adapter-nuxt",
   "configKey": "@holo-js/adapter-nuxt",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,9 +1,21 @@
-import { readdir, mkdir, writeFile } from 'node:fs/promises';
-import { resolve, extname, basename, relative } from 'node:path';
-import { defineNuxtModule, createResolver, addServerPlugin, addImports, addServerImportsDir, addServerHandler } from '@nuxt/kit';
+import { readdir, mkdir, writeFile, access } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { resolve, extname, relative, basename, dirname } from 'node:path';
+import { defineNuxtModule, createResolver, addServerPlugin, addServerImportsDir, addServerHandler } from '@nuxt/kit';
 import { loadConfigDirectory } from '@holo-js/config';
 
 const MODEL_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"]);
+const HOLO_PACKAGE_SCOPE = "@holo-js/";
+const CLIENT_OPTIMIZE_DEPS = [
+  {
+    packageName: `${HOLO_PACKAGE_SCOPE}forms`,
+    include: `${HOLO_PACKAGE_SCOPE}forms > ${HOLO_PACKAGE_SCOPE}validation > valibot`
+  },
+  {
+    packageName: `${HOLO_PACKAGE_SCOPE}validation`,
+    include: `${HOLO_PACKAGE_SCOPE}validation > valibot`
+  }
+];
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -28,6 +40,47 @@ function hasModuleNotFoundCode(error, expectedSpecifier) {
   }
   return false;
 }
+function isModuleResolutionFailure(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  return "code" in error && (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_MODULE_NOT_FOUND");
+}
+function resolveClientOptimizeDeps(rootDir) {
+  const projectRequire = createRequire(resolve(rootDir, "package.json"));
+  const deps = [];
+  for (const { packageName, include } of CLIENT_OPTIMIZE_DEPS) {
+    try {
+      projectRequire.resolve(packageName);
+      deps.push(include);
+    } catch (error) {
+      if (!isModuleResolutionFailure(error)) {
+        throw error;
+      }
+    }
+  }
+  return deps;
+}
+function addViteOptimizeDeps(opts, deps) {
+  if (deps.length === 0) {
+    return;
+  }
+  opts.vite = opts.vite || {};
+  opts.vite.optimizeDeps = opts.vite.optimizeDeps || {};
+  opts.vite.optimizeDeps.include = [
+    .../* @__PURE__ */ new Set([
+      ...opts.vite.optimizeDeps.include || [],
+      ...deps
+    ])
+  ];
+}
+function addNitroErrorHandler(opts, handler) {
+  const current = opts.nitro.errorHandler;
+  const handlers = Array.isArray(current) ? current : typeof current === "string" ? [current] : [];
+  if (!handlers.includes(handler)) {
+    opts.nitro.errorHandler = [...handlers, handler];
+  }
+}
 async function importOptionalStorageModule() {
   try {
     return await import('@holo-js/storage');
@@ -55,6 +108,15 @@ 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 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");
+  }
+}
 function toStorageModuleOptions(loaded) {
   return {
     defaultDisk: loaded.storage.defaultDisk,
@@ -62,10 +124,12 @@ function toStorageModuleOptions(loaded) {
     disks: { ...loaded.storage.disks }
   };
 }
-async function createServerModelImports(sourceDir) {
-  const modelsDir = resolve(sourceDir, "server/models");
+async function createServerModelImports(sourceDir, modelsRelativePath, generatedSchemaRelativePath) {
+  const modelsDir = resolve(sourceDir, modelsRelativePath);
+  const generatedSchemaPath = resolve(sourceDir, generatedSchemaRelativePath);
   const modelImportDir = resolve(sourceDir, ".holo-js/generated/nuxt-server-imports");
   const modelImportFile = resolve(modelImportDir, "models.ts");
+  const modelPluginFile = resolve(modelImportDir, "plugin.ts");
   let modelFiles;
   try {
     modelFiles = (await readdir(modelsDir)).filter((fileName) => MODEL_FILE_EXTENSIONS.has(extname(fileName))).sort((left, right) => left.localeCompare(right));
@@ -75,17 +139,34 @@ async function createServerModelImports(sourceDir) {
   if (modelFiles.length === 0) {
     return null;
   }
-  const lines = modelFiles.map((fileName) => {
-    const modelName = basename(fileName, extname(fileName));
-    const importPath = relative(modelImportDir, resolve(modelsDir, fileName)).replaceAll("\\", "/");
-    const normalizedImportPath = importPath.replace(/^(?!\.)/, "./");
-    const extension = extname(normalizedImportPath);
-    return `export { default as ${modelName} } from '${normalizedImportPath.slice(0, -extension.length)}'`;
-  });
+  const generatedSchemaImportPath = relative(modelImportDir, generatedSchemaPath).replaceAll("\\", "/");
+  const normalizedGeneratedSchemaImportPath = generatedSchemaImportPath.replace(/^(?!\.)/, "./");
+  const lines = [
+    `import '${normalizedGeneratedSchemaImportPath.slice(0, -extname(normalizedGeneratedSchemaImportPath).length)}'`,
+    "",
+    ...modelFiles.map((fileName) => {
+      const modelName = basename(fileName, extname(fileName));
+      const importPath = relative(modelImportDir, resolve(modelsDir, fileName)).replaceAll("\\", "/");
+      const normalizedImportPath = importPath.replace(/^(?!\.)/, "./");
+      const extension = extname(normalizedImportPath);
+      return `export { default as ${modelName} } from '${normalizedImportPath.slice(0, -extension.length)}'`;
+    })
+  ];
+  const pluginLines = [
+    `import '${normalizedGeneratedSchemaImportPath.slice(0, -extname(normalizedGeneratedSchemaImportPath).length)}'`,
+    "import './models'",
+    "",
+    "export default () => {}"
+  ];
   await mkdir(modelImportDir, { recursive: true });
   await writeFile(modelImportFile, `${lines.join("\n")}
 `, "utf8");
-  return modelImportDir;
+  await writeFile(modelPluginFile, `${pluginLines.join("\n")}
+`, "utf8");
+  return {
+    importDir: modelImportDir,
+    pluginFile: modelPluginFile
+  };
 }
 const module$1 = defineNuxtModule({
   meta: {
@@ -97,6 +178,10 @@ const module$1 = defineNuxtModule({
     const opts = nuxt.options;
     const rootDir = opts.rootDir ?? opts.srcDir ?? process.cwd();
     const sourceDir = opts.srcDir ?? rootDir;
+    const authTypesPath = resolve(rootDir, ".holo-js/generated/auth.d.ts");
+    const authorizationTypesPath = resolve(rootDir, ".holo-js/generated/authorization/types.d.ts");
+    const modelRegistryTypesPath = resolve(rootDir, ".holo-js/generated/model-registry.d.ts");
+    addViteOptimizeDeps(opts, resolveClientOptimizeDeps(rootDir));
     const loaded = await loadConfigDirectory(rootDir, {
       preferCache: process.env.NODE_ENV === "production",
       processEnv: process.env
@@ -106,7 +191,17 @@ const module$1 = defineNuxtModule({
     const s3Driver = resolver.resolve("./runtime/drivers/s3.js");
     opts.nitro = opts.nitro || { storage: {} };
     opts.nitro.storage = opts.nitro.storage || {};
+    addNitroErrorHandler(opts, resolver.resolve("./runtime/server/error"));
+    opts.nitro.experimental = {
+      ...opts.nitro.experimental || {},
+      asyncContext: true
+    };
     opts.runtimeConfig = opts.runtimeConfig || {};
+    opts.runtimeConfig.public = opts.runtimeConfig.public || {};
+    opts.runtimeConfig.public.holo = {
+      ...opts.runtimeConfig.public.holo || {},
+      appName: loaded.app.name
+    };
     opts.runtimeConfig.holo = {
       appUrl: loaded.app.url,
       appEnv: loaded.app.env,
@@ -130,24 +225,17 @@ const module$1 = defineNuxtModule({
       opts.runtimeConfig.holoStorage = normalizedStorage;
     }
     if (!opts._holoCoreRuntimeRegistered) {
-      const imports = [
-        { name: "holo", as: "holo", from: resolver.resolve("./runtime/composables") },
-        { name: "useHoloDb", as: "useHoloDb", from: resolver.resolve("./runtime/composables") },
-        { name: "useHoloEnv", as: "useHoloEnv", from: resolver.resolve("./runtime/composables") },
-        { name: "useHoloDebug", as: "useHoloDebug", from: resolver.resolve("./runtime/composables") }
-      ];
-      if (storageModule) {
-        imports.push(
-          { name: "useStorage", as: "useStorage", from: resolver.resolve("./runtime/composables/storage") },
-          { name: "Storage", as: "Storage", from: resolver.resolve("./runtime/composables/storage") }
-        );
-      }
       addServerPlugin(resolver.resolve("./runtime/plugins/init"));
-      addImports(imports);
-      addServerImportsDir(resolver.resolve("./runtime/server/imports"));
-      const serverModelImports = await createServerModelImports(sourceDir);
+      addServerPlugin(resolver.resolve("./runtime/plugins/forms"));
+      addServerImportsDir(resolver.resolve("./runtime/server/auto-imports"));
+      const serverModelImports = await createServerModelImports(
+        sourceDir,
+        loaded.app.paths.models,
+        loaded.app.paths.generatedSchema
+      );
       if (serverModelImports) {
-        addServerImportsDir(serverModelImports);
+        addServerImportsDir(serverModelImports.importDir);
+        addServerPlugin(serverModelImports.pluginFile);
       }
       opts._holoCoreRuntimeRegistered = true;
     }
@@ -179,16 +267,25 @@ const module$1 = defineNuxtModule({
     }
     if (!opts._holoTypesRegistered) {
       opts._holoTypesRegistered = true;
+      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 });
       });
     }
   }
 });
 const moduleInternals = {
+  addViteOptimizeDeps,
   hasModuleNotFoundCode,
   hasLoadedConfigFile,
-  importOptionalStorageS3Module
+  importOptionalStorageS3Module,
+  isModuleResolutionFailure,
+  resolveClientOptimizeDeps
 };
 const adapterNuxtInternals = {
   toStorageModuleOptions

package/dist/runtime/authorization-error.js

@@ -0,0 +1,8 @@
+import { createError } from "h3";
+export function createNuxtAuthorizationError(decision) {
+  const status = decision.status === 404 ? 404 : 403;
+  return createError({
+    statusCode: status,
+    statusMessage: decision.message ?? "You are not authorized to perform this action."
+  });
+}

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

@@ -1,11 +1,27 @@
+import type { FormSchema, InferFormData } from '@holo-js/forms'
+import type { ValidationErrorBag } from '@holo-js/forms'
+import type {
+  InferFormFieldTree,
+  UseFormOptions,
+  UseFormResult,
+} from '@holo-js/forms/internal/client'
+
 export type {
   ClientSubmitContext,
   ClientSubmitResult,
   FormFieldState,
   FormFieldTree,
+  InferFormFieldTree,
   UseFormOptions,
   UseFormResult,
   ValidateOnMode,
-} from '@holo-js/forms/client'
+} from '@holo-js/forms/internal/client'
+
+export declare function useForm<TSchema extends FormSchema, TSuccess = unknown>(
+  schemaDefinition: TSchema,
+  options?: UseFormOptions<InferFormData<TSchema>, TSuccess>,
+): UseFormResult<InferFormData<TSchema>, TSuccess, InferFormFieldTree<TSchema>>
 
-export declare const useForm: typeof import('@holo-js/forms/client').useForm
+export declare function useValidationErrors<TData = Record<string, unknown>>(
+  bag?: string,
+): ValidationErrorBag<TData>

package/dist/runtime/composables/forms.js

@@ -1,69 +1,287 @@
-import { onScopeDispose, shallowRef, watchEffect } from "vue";
+import { onScopeDispose, reactive, shallowRef, watchEffect } from "vue";
+import { useCookie } from "#app";
+import { DEFAULT_VALIDATION_BAG, createErrorBag } from "@holo-js/validation";
 import {
-  useForm as createForm
-} from "@holo-js/forms/client";
+  createFormClient
+} from "@holo-js/forms/internal/client";
+const FORM_FAILURE_COOKIE = "holo_form_failure";
+const ARRAY_MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "copyWithin",
+  "fill",
+  "pop",
+  "push",
+  "reverse",
+  "shift",
+  "sort",
+  "splice",
+  "unshift"
+]);
 function isPlainObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Blob);
 }
-function createReactiveView(targetRef, version, cache) {
-  const target = targetRef.value;
-  const cached = cache.get(target);
+function isLeafValue(value) {
+  return value instanceof Date || value instanceof Blob || !Array.isArray(value) && !isPlainObject(value);
+}
+function readBrowserCookie(name) {
+  const cookie = globalThis.document?.cookie;
+  if (!cookie) {
+    return void 0;
+  }
+  for (const segment of cookie.split(";")) {
+    const trimmed = segment.trim();
+    const separator = trimmed.indexOf("=");
+    if (separator <= 0) {
+      continue;
+    }
+    if (trimmed.slice(0, separator) === name) {
+      return trimmed.slice(separator + 1);
+    }
+  }
+  return void 0;
+}
+function readCookie(name) {
+  try {
+    const cookie = useCookie(name);
+    if (typeof cookie.value === "string" || isPlainObject(cookie.value)) {
+      return cookie.value;
+    }
+  } catch {
+    return readBrowserCookie(name);
+  }
+  return readBrowserCookie(name);
+}
+function parseFlashedValidationPayload() {
+  const value = readCookie(FORM_FAILURE_COOKIE);
+  if (!value) {
+    return void 0;
+  }
+  try {
+    const decoded = typeof value === "string" ? JSON.parse(decodeURIComponent(value)) : value;
+    if (!isPlainObject(decoded) || !isPlainObject(decoded.errors)) {
+      return void 0;
+    }
+    return {
+      bag: typeof decoded.bag === "string" ? decoded.bag : DEFAULT_VALIDATION_BAG,
+      errors: decoded.errors
+    };
+  } catch {
+    return void 0;
+  }
+}
+export function useValidationErrors(bag = DEFAULT_VALIDATION_BAG) {
+  const payload = parseFlashedValidationPayload();
+  if (!payload || (payload.bag ?? DEFAULT_VALIDATION_BAG) !== bag) {
+    return createErrorBag();
+  }
+  return createErrorBag(payload.errors ?? {});
+}
+function getValueAtPath(root, path) {
+  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
+  let cursor = root;
+  for (const part of parts) {
+    if (!isPlainObject(cursor) && !Array.isArray(cursor)) {
+      return void 0;
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function createArrayMutationView(source, path, getForm, version, cache) {
+  const cached = cache.get(source);
   if (cached) {
     return cached;
   }
-  const proxy = new Proxy({}, {
-    get(_shell, key) {
+  const proxy = new Proxy([], {
+    get(_target, key) {
       void version.value;
-      const currentTarget = targetRef.value;
-      const value = Reflect.get(currentTarget, key);
-      if (typeof value === "function") {
-        return value.bind(currentTarget);
+      const current = getValueAtPath(getForm().values, path);
+      if (!Array.isArray(current)) {
+        return void 0;
       }
-      if (isPlainObject(value)) {
-        return createReactiveView({ value }, version, cache);
+      const value = Reflect.get(current, key, current);
+      if (typeof value !== "function") {
+        return value;
       }
-      return value;
+      if (typeof key === "string" && ARRAY_MUTATION_METHODS.has(key)) {
+        return (...args) => {
+          const latest = getValueAtPath(getForm().values, path);
+          if (!Array.isArray(latest)) {
+            return void 0;
+          }
+          const next = latest.slice();
+          const result = Reflect.get(next, key, next).apply(next, args);
+          void getForm().setValue(path, next);
+          return result;
+        };
+      }
+      return value.bind(current);
     },
-    set(_shell, key, value) {
-      const updated = Reflect.set(targetRef.value, key, value);
-      version.value += 1;
+    set(_target, key, value) {
+      const current = getValueAtPath(getForm().values, path);
+      if (!Array.isArray(current)) {
+        return false;
+      }
+      const next = current.slice();
+      const updated = Reflect.set(next, key, value);
+      if (updated) {
+        void getForm().setValue(path, next);
+      }
       return updated;
     },
-    ownKeys() {
-      void version.value;
-      return Reflect.ownKeys(targetRef.value);
-    },
-    getOwnPropertyDescriptor(_shell, key) {
-      void version.value;
-      const descriptor = Reflect.getOwnPropertyDescriptor(targetRef.value, key);
-      if (!descriptor) {
-        return void 0;
+    deleteProperty(_target, key) {
+      const current = getValueAtPath(getForm().values, path);
+      if (!Array.isArray(current)) {
+        return false;
       }
-      return {
-        ...descriptor,
-        configurable: true
-      };
-    },
-    has(_shell, key) {
-      void version.value;
-      return Reflect.has(targetRef.value, key);
+      const next = current.slice();
+      const deleted = Reflect.deleteProperty(next, key);
+      if (deleted) {
+        void getForm().setValue(path, next);
+      }
+      return deleted;
     }
   });
-  cache.set(target, proxy);
+  cache.set(source, proxy);
   return proxy;
 }
+function defineLeafAccessor(target, key, path, getForm, version, arrayCache) {
+  const descriptor = Object.getOwnPropertyDescriptor(target, key);
+  if (descriptor?.get && descriptor?.set) {
+    return;
+  }
+  Object.defineProperty(target, key, {
+    enumerable: true,
+    configurable: true,
+    get() {
+      void version.value;
+      const value = getValueAtPath(getForm().values, path);
+      return Array.isArray(value) ? createArrayMutationView(value, path, getForm, version, arrayCache) : value;
+    },
+    set(nextValue) {
+      void getForm().setValue(path, nextValue);
+    }
+  });
+}
+function syncValuesView(target, source, getForm, version, arrayCache, prefix = "") {
+  if (!isPlainObject(source)) {
+    for (const key of Object.keys(target)) {
+      delete target[key];
+    }
+    return;
+  }
+  for (const key of Object.keys(target)) {
+    if (!(key in source)) {
+      delete target[key];
+    }
+  }
+  for (const [key, item] of Object.entries(source)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    const current = target[key];
+    if (Array.isArray(item)) {
+      if (isPlainObject(current)) {
+        delete target[key];
+      }
+      defineLeafAccessor(target, key, path, getForm, version, arrayCache);
+      continue;
+    }
+    if (isLeafValue(item)) {
+      if (isPlainObject(current)) {
+        delete target[key];
+      }
+      defineLeafAccessor(target, key, path, getForm, version, arrayCache);
+      continue;
+    }
+    if (!isPlainObject(current)) {
+      target[key] = {};
+    }
+    syncValuesView(target[key], item, getForm, version, arrayCache, path);
+  }
+}
 export function useForm(schemaDefinition, options = {}) {
-  const form = shallowRef(createForm(schemaDefinition, options));
+  const form = shallowRef(void 0);
   const version = shallowRef(0);
-  const cache = /* @__PURE__ */ new WeakMap();
+  let versionCounter = 0;
+  const rawValues = {};
+  const values = reactive(rawValues);
+  const arrayCache = /* @__PURE__ */ new WeakMap();
+  let activeForm;
+  const getActiveForm = () => {
+    if (!activeForm) {
+      throw new TypeError("Expected form to be initialized.");
+    }
+    return activeForm;
+  };
+  const currentForm = () => {
+    const current = form.value;
+    if (!current) {
+      throw new TypeError("Expected form to be initialized.");
+    }
+    return current;
+  };
+  const syncValuesFromForm = (localForm) => {
+    activeForm = localForm;
+    syncValuesView(
+      rawValues,
+      localForm.values,
+      getActiveForm,
+      version,
+      arrayCache
+    );
+  };
   const stopWatching = watchEffect((onCleanup) => {
-    form.value = createForm(schemaDefinition, options);
-    version.value += 1;
-    const unsubscribe = form.value.subscribe(() => {
-      version.value += 1;
+    const localForm = createFormClient(schemaDefinition, options);
+    syncValuesFromForm(localForm);
+    form.value = localForm;
+    version.value = ++versionCounter;
+    const unsubscribe = localForm.subscribe(() => {
+      syncValuesFromForm(localForm);
+      version.value = ++versionCounter;
     });
     onCleanup(unsubscribe);
   });
   onScopeDispose(stopWatching);
-  return createReactiveView(form, version, cache);
+  return reactive({
+    get fields() {
+      void version.value;
+      return currentForm().fields;
+    },
+    values,
+    get errors() {
+      void version.value;
+      return currentForm().errors;
+    },
+    get submitting() {
+      void version.value;
+      return currentForm().submitting;
+    },
+    get valid() {
+      void version.value;
+      return currentForm().valid;
+    },
+    get lastSubmission() {
+      void version.value;
+      return currentForm().lastSubmission;
+    },
+    subscribe(listener) {
+      return currentForm().subscribe(listener);
+    },
+    async validate() {
+      return await currentForm().validate();
+    },
+    async validateField(path) {
+      return await currentForm().validateField(path);
+    },
+    async submit() {
+      return await currentForm().submit();
+    },
+    reset(nextValues) {
+      currentForm().reset(nextValues);
+    },
+    async setValue(path, value) {
+      await currentForm().setValue(path, value);
+    },
+    applyServerState(result) {
+      return currentForm().applyServerState(result);
+    }
+  });
 }

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

@@ -1,3 +1,5 @@
+import type { HoloAdapterProjectAccessors } from '@holo-js/core'
+
 export interface HoloRuntimeConnection {
   driver?: 'sqlite' | 'postgres' | 'mysql'
   url?: string
@@ -23,6 +25,7 @@ export interface HoloRuntimeDefaultConnection extends HoloRuntimeConnection {
   }
 }
 
+export declare const holo: HoloAdapterProjectAccessors
 export declare function useHoloDb(): HoloRuntimeDatabaseGroup | HoloRuntimeDefaultConnection
 export declare function useHoloEnv(): 'production' | 'development' | 'test'
 export declare function useHoloDebug(): boolean

package/dist/runtime/composables/index.js

@@ -2,6 +2,7 @@ import {
   createHoloProjectAccessors,
   initializeHoloAdapterProject
 } from "@holo-js/core";
+import { createNuxtAuthorizationError } from "../authorization-error.js";
 export function configureHoloRuntimeConfig(config) {
   const runtimeGlobals = globalThis;
   runtimeGlobals.__holoRuntimeConfig = config;
@@ -26,12 +27,115 @@ function resolveRuntimeEnvName(env) {
 function resolveRuntimeProjectRoot(config) {
   return config.holo.projectRoot?.trim() || process.cwd();
 }
+async function loadNitroContextModule() {
+  return await import("nitropack/runtime/context");
+}
+export function createNuxtAuthRequestAccessors() {
+  function safeDecode(value) {
+    try {
+      return decodeURIComponent(value);
+    } catch {
+      return void 0;
+    }
+  }
+  async function readHeader(name) {
+    const nitroContext = await loadNitroContextModule();
+    const event = nitroContext.useEvent();
+    if (!event) {
+      return void 0;
+    }
+    const normalizedName = name.toLowerCase();
+    if (event.headers instanceof Headers) {
+      return event.headers.get(name) ?? void 0;
+    }
+    if (event.request?.headers instanceof Headers) {
+      return event.request.headers.get(name) ?? void 0;
+    }
+    const value = event.node?.req?.headers?.[normalizedName];
+    if (Array.isArray(value)) {
+      return value[0];
+    }
+    return typeof value === "string" ? value : void 0;
+  }
+  async function readCookie(name) {
+    const header = await readHeader("cookie");
+    if (!header) {
+      return void 0;
+    }
+    for (const segment of header.split(";")) {
+      const trimmed = segment.trim();
+      const separator = trimmed.indexOf("=");
+      if (separator <= 0) {
+        continue;
+      }
+      const key = safeDecode(trimmed.slice(0, separator));
+      if (typeof key === "undefined") {
+        continue;
+      }
+      if (key !== name) {
+        continue;
+      }
+      const value = safeDecode(trimmed.slice(separator + 1));
+      if (typeof value === "undefined") {
+        continue;
+      }
+      return value;
+    }
+    return void 0;
+  }
+  async function appendCookie(cookie) {
+    const nitroContext = await loadNitroContextModule();
+    const event = nitroContext.useEvent();
+    const response = event?.node?.res;
+    if (!response) {
+      return;
+    }
+    const current = response.getHeader("set-cookie");
+    if (Array.isArray(current)) {
+      response.setHeader("set-cookie", [...current, cookie]);
+      return;
+    }
+    if (typeof current === "string") {
+      response.setHeader("set-cookie", [current, cookie]);
+      return;
+    }
+    response.setHeader("set-cookie", [cookie]);
+  }
+  const getCookieValue = async (name) => {
+    return await readCookie(name);
+  };
+  const getHeaderValue = async (name) => {
+    return await readHeader(name);
+  };
+  const appendResponseCookie = async (cookie) => {
+    await appendCookie(cookie);
+  };
+  const redirectResponse = async (url, status) => {
+    const nitroContext = await loadNitroContextModule();
+    const event = nitroContext.useEvent();
+    if (!event) {
+      throw new TypeError("Holo Nuxt auth redirect requires an active Nitro event.");
+    }
+    const { sendRedirect } = await import("h3");
+    await sendRedirect(event, url, status);
+  };
+  return {
+    getCookie: getCookieValue,
+    getHeader: getHeaderValue,
+    appendResponseCookie,
+    redirectResponse
+  };
+}
 export const holo = createHoloProjectAccessors(async () => {
   const config = getRuntimeConfig();
   return initializeHoloAdapterProject(resolveRuntimeProjectRoot(config), {
     envName: resolveRuntimeEnvName(config.holo.appEnv),
     preferCache: process.env.NODE_ENV === "production",
-    processEnv: process.env
+    processEnv: process.env,
+    authRequest: createNuxtAuthRequestAccessors(),
+    authorizationError: {
+      createError: createNuxtAuthorizationError
+    }
   });
 });
 function resolveDefaultConnectionName(group) {

package/dist/runtime/plugins/forms.js

@@ -0,0 +1,18 @@
+import { defineNitroPlugin } from "nitropack/runtime/plugin";
+import {
+  applyFormFailureRedirect,
+  getFormFailurePayload,
+  shouldRedirectFormFailure
+} from "../server/form-failure.js";
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook("beforeResponse", (event, response) => {
+    if (!shouldRedirectFormFailure(event)) {
+      return;
+    }
+    const failure = getFormFailurePayload(response.body);
+    if (!failure) {
+      return;
+    }
+    applyFormFailureRedirect(event, response, failure);
+  });
+});

package/dist/runtime/plugins/init.js

@@ -1,6 +1,8 @@
 import {
+  createNuxtAuthRequestAccessors,
   configureHoloRuntimeConfig
 } from "../composables/index.js";
+import { createNuxtAuthorizationError } from "../authorization-error.js";
 import { initializeHoloAdapterProject } from "@holo-js/core";
 import { useRuntimeConfig } from "nitropack/runtime/config";
 import { defineNitroPlugin } from "nitropack/runtime/plugin";
@@ -10,7 +12,11 @@ export default defineNitroPlugin(async (nitroApp) => {
   const project = await initializeHoloAdapterProject(config.holo.projectRoot?.trim() || process.cwd(), {
     envName: config.holo.appEnv,
     preferCache: process.env.NODE_ENV === "production",
-    processEnv: process.env
+    processEnv: process.env,
+    authRequest: createNuxtAuthRequestAccessors(),
+    authorizationError: {
+      createError: createNuxtAuthorizationError
+    }
   });
   const driver = project.runtime.manager.connection().getDriver();
   console.log(`\u2705 Holo DB connected (${driver})`);

package/dist/runtime/server/auto-imports/holo.js

@@ -0,0 +1,10 @@
+import {
+  holo as baseHolo,
+  useHoloDb as baseUseHoloDb,
+  useHoloDebug as baseUseHoloDebug,
+  useHoloEnv as baseUseHoloEnv
+} from "../../composables/index.js";
+export const holo = baseHolo;
+export const useHoloDb = baseUseHoloDb;
+export const useHoloDebug = baseUseHoloDebug;
+export const useHoloEnv = baseUseHoloEnv;

package/dist/runtime/server/error.js

@@ -0,0 +1,32 @@
+import { send, setHeader, setResponseStatus } from "h3";
+import { isValidationException } from "@holo-js/validation";
+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 defineNitroErrorHandler(async (error, event) => {
+  const validationError = findValidationException(error);
+  if (!validationError) {
+    return;
+  }
+  const payload = validationError.toJSON();
+  if (shouldRedirectFormFailure(event)) {
+    const failure = { ...payload };
+    const response = {};
+    applyFormFailureRedirect(event, response, failure);
+    await send(event, "", "text/html");
+    return;
+  }
+  setResponseStatus(event, payload.status);
+  setHeader(event, "content-type", "application/json; charset=utf-8");
+  await send(event, JSON.stringify(payload), "application/json");
+});

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

@@ -0,0 +1,100 @@
+const FORM_FAILURE_COOKIE = "holo_form_failure";
+function getHeader(event, name) {
+  const value = event.node?.req?.headers?.[name.toLowerCase()];
+  return Array.isArray(value) ? value[0] : value;
+}
+function isFormFailurePayload(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const payload = value;
+  return payload.ok === false && payload.valid === false && typeof payload.status === "number" && !!payload.errors && typeof payload.errors === "object";
+}
+export function getFormFailurePayload(value) {
+  if (isFormFailurePayload(value)) {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return isFormFailurePayload(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function acceptsHtml(event) {
+  return getHeader(event, "accept")?.toLowerCase().includes("text/html") === true;
+}
+function isUnsafeMethod(event) {
+  const method = event.node?.req?.method?.toUpperCase();
+  return method !== "GET" && method !== "HEAD";
+}
+function isApiRequest(event) {
+  const path = event.path ?? event.node?.req?.url ?? "";
+  return path.startsWith("/api/");
+}
+function getRedirectLocation(event) {
+  const referer = getHeader(event, "referer");
+  const host = getHeader(event, "host") ?? "localhost";
+  if (referer) {
+    try {
+      const url = new URL(referer);
+      if (url.host === host) {
+        return `${url.pathname}${url.search}`;
+      }
+    } catch {
+    }
+  }
+  return event.path ?? event.node?.req?.url ?? "/";
+}
+function appendSetCookie(event, response, cookie) {
+  const responseCookie = event.node?.res?.getHeader?.("set-cookie");
+  if (Array.isArray(responseCookie)) {
+    event.node?.res?.setHeader?.("set-cookie", [...responseCookie, cookie]);
+  } else if (responseCookie) {
+    event.node?.res?.setHeader?.("set-cookie", [String(responseCookie), cookie]);
+  } else {
+    event.node?.res?.setHeader?.("set-cookie", cookie);
+  }
+  if (response.headers instanceof Headers) {
+    response.headers.append("set-cookie", cookie);
+  } else {
+    response.headers ??= {};
+    const current = response.headers["set-cookie"];
+    if (Array.isArray(current)) {
+      response.headers["set-cookie"] = [...current.map(String), cookie];
+      return;
+    }
+    response.headers["set-cookie"] = current ? [String(current), cookie] : cookie;
+  }
+}
+function setHeader(event, response, name, value) {
+  event.node?.res?.setHeader?.(name, value);
+  if (response.headers instanceof Headers) {
+    response.headers.set(name, value);
+    return;
+  }
+  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`;
+}
+export function shouldRedirectFormFailure(event) {
+  return isUnsafeMethod(event) && acceptsHtml(event) && !isApiRequest(event);
+}
+export function applyFormFailureRedirect(event, response, failure) {
+  if (event.node?.res) {
+    event.node.res.statusCode = 303;
+    event.node.res.statusMessage = "See Other";
+  }
+  response.statusCode = 303;
+  response.statusMessage = "See Other";
+  response.body = "";
+  setHeader(event, response, "location", getRedirectLocation(event));
+  setHeader(event, response, "content-type", "text/html; charset=utf-8");
+  appendSetCookie(event, response, serializeFormFailureCookie(failure));
+}

package/dist/runtime/server/imports/holo.d.ts

@@ -0,0 +1 @@
+export { holo, useHoloDb, useHoloDebug, useHoloEnv } from '../../composables'

package/dist/runtime/server/imports/holo.js

@@ -1,6 +1,10 @@
-export {
-  holo,
-  useHoloDb,
-  useHoloDebug,
-  useHoloEnv
+import {
+  holo as baseHolo,
+  useHoloDb as baseUseHoloDb,
+  useHoloDebug as baseUseHoloDebug,
+  useHoloEnv as baseUseHoloEnv
 } from "../../composables/index.js";
+export const holo = baseHolo;
+export const useHoloDb = baseUseHoloDb;
+export const useHoloDebug = baseUseHoloDebug;
+export const useHoloEnv = baseUseHoloEnv;

package/dist/runtime/server/imports/storage.d.ts

@@ -0,0 +1 @@
+export { Storage, useStorage } from '../utils/storage'

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

@@ -0,0 +1,4 @@
+export {
+  Storage,
+  useStorage
+} from "../utils/storage.js";

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

@@ -1,4 +1,4 @@
-import { readFile, realpath } from "node:fs/promises";
+import { open, realpath, stat } from "node:fs/promises";
 import { extname, resolve, sep } from "node:path";
 import { useRuntimeConfig } from "#imports";
 const NAMED_PUBLIC_DISK_ROUTE_SEGMENT = "__holo";
@@ -70,6 +70,27 @@ function resolveContentType(absolutePath) {
       return "application/octet-stream";
   }
 }
+function isActiveContentPath(absolutePath) {
+  switch (extname(absolutePath).toLowerCase()) {
+    case ".html":
+    case ".js":
+    case ".mjs":
+    case ".svg":
+      return true;
+    default:
+      return false;
+  }
+}
+function setStorageResponseHeaders(event, absolutePath) {
+  if (isActiveContentPath(absolutePath)) {
+    setResponseHeader(event, "content-disposition", "attachment");
+    setResponseHeader(event, "content-type", "application/octet-stream");
+    setResponseHeader(event, "x-content-type-options", "nosniff");
+    return;
+  }
+  setResponseHeader(event, "content-type", resolveContentType(absolutePath));
+  setResponseHeader(event, "x-content-type-options", "nosniff");
+}
 function createMissingFileError(message) {
   const error = new Error(message);
   error.code = "ENOENT";
@@ -78,15 +99,28 @@ function createMissingFileError(message) {
 function isPathWithinRoot(root, absolutePath) {
   return absolutePath === root || absolutePath.startsWith(`${root}${sep}`);
 }
+function isSameFile(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
 async function readPublicFile(event, disk, absolutePath) {
   const resolvedRoot = await realpath(resolve(disk.root));
-  const resolvedPath = await realpath(absolutePath);
-  if (!isPathWithinRoot(resolvedRoot, resolvedPath)) {
-    throw createMissingFileError("Storage file not found.");
+  const file = await open(absolutePath, "r");
+  try {
+    const openedFile = await file.stat();
+    const resolvedPath = await realpath(absolutePath);
+    if (!isPathWithinRoot(resolvedRoot, resolvedPath)) {
+      throw createMissingFileError("Storage file not found.");
+    }
+    const resolvedFile = await stat(resolvedPath);
+    if (!isSameFile(openedFile, resolvedFile)) {
+      throw createMissingFileError("Storage file not found.");
+    }
+    const contents = await file.readFile();
+    setStorageResponseHeaders(event, absolutePath);
+    return contents;
+  } finally {
+    await file.close();
   }
-  const contents = await readFile(absolutePath);
-  setResponseHeader(event, "content-type", resolveContentType(absolutePath));
-  return contents;
 }
 function resolveRouteSegments(routePath) {
   const segments = normalizeRequestPath(routePath);

package/dist/runtime/shims.d.ts

@@ -34,8 +34,15 @@ interface HoloRuntimeConfig extends RuntimeConfigInput {
   }
 }
 
+/**
+ * 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 useRuntimeConfig(): HoloRuntimeConfig
+  export function useCookie<T = string | null>(name: string): { value: T | null | undefined }
 }
 
 declare module '#imports' {
@@ -47,6 +54,10 @@ 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 defineNitroPlugin<T>(plugin: T): T
 }
@@ -57,6 +68,7 @@ declare module 'nitropack/runtime/storage' {
 
 declare global {
   function createError(input: { statusCode: number, statusMessage: string }): Error
+  function defineNitroErrorHandler<T>(handler: T): T
   function defineNitroPlugin<T>(plugin: T): T
   function defineEventHandler<T>(
     handler: (event: unknown) => T | Promise<T>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/adapter-nuxt",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Holo-JS Framework - Nuxt adapter",
   "type": "module",
   "license": "MIT",
@@ -34,15 +34,17 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@nuxt/kit": "^4.0.0",
-    "@holo-js/config": "^0.1.4",
-    "@holo-js/core": "^0.1.4",
-    "@holo-js/db": "^0.1.4"
+    "@nuxt/kit": "^4.4.4",
+    "@holo-js/config": "^0.1.6",
+    "@holo-js/core": "^0.1.6",
+    "@holo-js/db": "^0.1.6",
+    "@holo-js/validation": "^0.1.6",
+    "h3": "^1.15.11"
   },
   "peerDependencies": {
-    "@holo-js/forms": "^0.1.4",
-    "@holo-js/storage": "^0.1.4",
-    "@holo-js/storage-s3": "^0.1.4"
+    "@holo-js/forms": "^0.1.6",
+    "@holo-js/storage": "^0.1.6",
+    "@holo-js/storage-s3": "^0.1.6"
   },
   "peerDependenciesMeta": {
     "@holo-js/forms": {
@@ -56,11 +58,11 @@
     }
   },
   "devDependencies": {
-    "@holo-js/storage-s3": "workspace:*",
+    "@holo-js/storage-s3": "^0.1.6",
     "@nuxt/module-builder": "^1.0.2",
     "@types/node": "^22.10.2",
-    "nuxt": "^4.0.0",
+    "nuxt": "^4.4.4",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.5"
   }
 }