@holo-js/adapter-nuxt 0.1.0

package/dist/module.d.mts

@@ -0,0 +1,19 @@
+import { LoadedHoloConfig, HoloConfigMap } from '@holo-js/config';
+import { ModuleOptions as ModuleOptions$1 } from '@holo-js/storage';
+
+type ModuleOptions = Record<string, never>;
+declare function toStorageModuleOptions(loaded: LoadedHoloConfig<HoloConfigMap>): ModuleOptions$1;
+declare const _default: {
+    meta?: {
+        name?: string;
+    };
+    defaults?: Partial<ModuleOptions> | undefined;
+    setup: (options: ModuleOptions, nuxt: unknown) => void | Promise<void>;
+};
+
+declare const adapterNuxtInternals: {
+    toStorageModuleOptions: typeof toStorageModuleOptions;
+};
+
+export { adapterNuxtInternals, _default as default };
+export type { ModuleOptions };

package/dist/module.json

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

package/dist/module.mjs

@@ -0,0 +1,95 @@
+import { resolve } from 'node:path';
+import { defineNuxtModule, createResolver, addServerPlugin, addImports, addServerImportsDir, addServerHandler } from '@nuxt/kit';
+import { loadConfigDirectory } from '@holo-js/config';
+import { mergeModuleOptions, normalizeModuleOptions, applyNitroStorageConfig, hasPublicLocalDisk } from '@holo-js/storage';
+
+function toStorageModuleOptions(loaded) {
+  return {
+    defaultDisk: loaded.storage.defaultDisk,
+    routePrefix: loaded.storage.routePrefix,
+    disks: { ...loaded.storage.disks }
+  };
+}
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@holo-js/adapter-nuxt"
+  },
+  async setup(_options, rawNuxt) {
+    const nuxt = rawNuxt;
+    const resolver = createResolver(import.meta.url);
+    const opts = nuxt.options;
+    const rootDir = opts.rootDir ?? opts.srcDir ?? process.cwd();
+    const sourceDir = opts.srcDir ?? rootDir;
+    const loaded = await loadConfigDirectory(rootDir, {
+      preferCache: process.env.NODE_ENV === "production",
+      processEnv: process.env
+    });
+    const loadedStorageOptions = toStorageModuleOptions(loaded);
+    const s3Driver = resolver.resolve("./runtime/drivers/s3.js");
+    opts.nitro = opts.nitro || { storage: {} };
+    opts.nitro.storage = opts.nitro.storage || {};
+    opts.runtimeConfig = opts.runtimeConfig || {};
+    opts.runtimeConfig.holo = {
+      appUrl: loaded.app.url,
+      appEnv: loaded.app.env,
+      appDebug: loaded.app.debug,
+      projectRoot: rootDir
+    };
+    opts.runtimeConfig.db = loaded.database;
+    const mergedStorageOptions = mergeModuleOptions(void 0, loadedStorageOptions);
+    const normalizedStorage = normalizeModuleOptions(mergedStorageOptions);
+    opts._holoStorageModuleOptions = mergedStorageOptions;
+    opts.runtimeConfig.holoStorage = normalizedStorage;
+    if (!opts._holoCoreRuntimeRegistered) {
+      addServerPlugin(resolver.resolve("./runtime/plugins/init"));
+      addImports([
+        { 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") },
+        { name: "useStorage", as: "useStorage", from: resolver.resolve("./runtime/composables") },
+        { name: "Storage", as: "Storage", from: resolver.resolve("./runtime/composables") }
+      ]);
+      addServerImportsDir(resolver.resolve("./runtime/server/imports"));
+      addServerImportsDir(resolve(sourceDir, "server/models"));
+      opts._holoCoreRuntimeRegistered = true;
+    }
+    if (!opts._holoStorageRuntimeRegistered) {
+      addServerPlugin(resolver.resolve("./runtime/plugins/storage"));
+      opts._holoStorageRuntimeRegistered = true;
+    }
+    if (!opts.nitro.storage || Object.keys(opts.nitro.storage).every((key) => !key.startsWith("holo:"))) {
+      applyNitroStorageConfig(opts, normalizedStorage, s3Driver);
+    }
+    const runtimePath = resolver.resolve("./runtime");
+    if (!opts.build.transpile.includes(runtimePath)) {
+      opts.build.transpile.push(runtimePath);
+    }
+    if (!opts._holoStorageFinalizeRegistered) {
+      opts._holoStorageFinalizeRegistered = true;
+      nuxt.hook("modules:done", () => {
+        const finalNormalized = normalizeModuleOptions(opts._holoStorageModuleOptions);
+        opts.runtimeConfig = opts.runtimeConfig || {};
+        opts.runtimeConfig.holoStorage = finalNormalized;
+        applyNitroStorageConfig(opts, finalNormalized, s3Driver);
+        if (hasPublicLocalDisk(finalNormalized)) {
+          addServerHandler({
+            route: `${finalNormalized.routePrefix}/**`,
+            handler: resolver.resolve("./runtime/server/routes/storage.get")
+          });
+        }
+      });
+    }
+    if (!opts._holoTypesRegistered) {
+      opts._holoTypesRegistered = true;
+      nuxt.hook("prepare:types", ({ references }) => {
+        references.push({ types: "@holo-js/adapter-nuxt" });
+      });
+    }
+  }
+});
+const adapterNuxtInternals = {
+  toStorageModuleOptions
+};
+
+export { adapterNuxtInternals, module$1 as default };

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

@@ -0,0 +1,11 @@
+export type {
+  ClientSubmitContext,
+  ClientSubmitResult,
+  FormFieldState,
+  FormFieldTree,
+  UseFormOptions,
+  UseFormResult,
+  ValidateOnMode,
+} from '@holo-js/forms/client'
+
+export declare const useForm: typeof import('@holo-js/forms/client').useForm

package/dist/runtime/composables/forms.js

@@ -0,0 +1,69 @@
+import { onScopeDispose, shallowRef, watchEffect } from "vue";
+import {
+  useForm as createForm
+} from "@holo-js/forms/client";
+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);
+  if (cached) {
+    return cached;
+  }
+  const proxy = new Proxy({}, {
+    get(_shell, key) {
+      void version.value;
+      const currentTarget = targetRef.value;
+      const value = Reflect.get(currentTarget, key);
+      if (typeof value === "function") {
+        return value.bind(currentTarget);
+      }
+      if (isPlainObject(value)) {
+        return createReactiveView({ value }, version, cache);
+      }
+      return value;
+    },
+    set(_shell, key, value) {
+      const updated = Reflect.set(targetRef.value, key, value);
+      version.value += 1;
+      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;
+      }
+      return {
+        ...descriptor,
+        configurable: true
+      };
+    },
+    has(_shell, key) {
+      void version.value;
+      return Reflect.has(targetRef.value, key);
+    }
+  });
+  cache.set(target, proxy);
+  return proxy;
+}
+export function useForm(schemaDefinition, options = {}) {
+  const form = shallowRef(createForm(schemaDefinition, options));
+  const version = shallowRef(0);
+  const cache = /* @__PURE__ */ new WeakMap();
+  const stopWatching = watchEffect((onCleanup) => {
+    form.value = createForm(schemaDefinition, options);
+    version.value += 1;
+    const unsubscribe = form.value.subscribe(() => {
+      version.value += 1;
+    });
+    onCleanup(unsubscribe);
+  });
+  onScopeDispose(stopWatching);
+  return createReactiveView(form, version, cache);
+}

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

@@ -0,0 +1,41 @@
+export {
+  Storage,
+  configureStorageRuntime,
+  resetStorageRuntime,
+  useStorage,
+  type StorageBackend,
+  type StorageContent,
+  type StorageDisk,
+  type StorageInstance,
+  type StorageRuntimeBindings,
+  type TemporaryUrlOptions,
+} from '@holo-js/storage/runtime'
+
+export interface HoloRuntimeConnection {
+  driver?: 'sqlite' | 'postgres' | 'mysql'
+  url?: string
+  host?: string
+  port?: number | string
+  username?: string
+  password?: string
+  database?: string
+  schema?: string
+  ssl?: boolean | Record<string, unknown>
+  logging: boolean
+}
+
+export interface HoloRuntimeDatabaseGroup {
+  defaultConnection: string
+  connections: Record<string, { url?: string } | HoloRuntimeConnection>
+}
+
+export interface HoloRuntimeDefaultConnection extends HoloRuntimeConnection {
+  defaultConnection: 'default'
+  connections: {
+    default: HoloRuntimeConnection
+  }
+}
+
+export declare function useHoloDb(): HoloRuntimeDatabaseGroup | HoloRuntimeDefaultConnection
+export declare function useHoloEnv(): 'production' | 'development' | 'test'
+export declare function useHoloDebug(): boolean

package/dist/runtime/composables/index.js

@@ -0,0 +1,96 @@
+export {
+  Storage,
+  configureStorageRuntime,
+  resetStorageRuntime,
+  useStorage
+} from "@holo-js/storage/runtime";
+import {
+  createHoloProjectAccessors,
+  initializeHoloAdapterProject
+} from "@holo-js/core";
+export function configureHoloRuntimeConfig(config) {
+  const runtimeGlobals = globalThis;
+  runtimeGlobals.__holoRuntimeConfig = config;
+}
+export function resetHoloRuntimeConfig() {
+  const runtimeGlobals = globalThis;
+  delete runtimeGlobals.__holoRuntimeConfig;
+}
+function getRuntimeConfig() {
+  const runtimeGlobals = globalThis;
+  if (runtimeGlobals.__holoRuntimeConfig) {
+    return runtimeGlobals.__holoRuntimeConfig;
+  }
+  if (typeof runtimeGlobals.useRuntimeConfig !== "function") {
+    throw new TypeError("Holo runtime config is not configured.");
+  }
+  return runtimeGlobals.useRuntimeConfig();
+}
+function resolveRuntimeEnvName(env) {
+  return env;
+}
+function resolveRuntimeProjectRoot(config) {
+  return config.holo.projectRoot?.trim() || process.cwd();
+}
+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
+  });
+});
+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";
+}
+function normalizeConnection(connection) {
+  const driver = connection.driver ?? (connection.filename ? "sqlite" : void 0);
+  const database = connection.database ?? connection.filename;
+  const url = connection.url ?? (driver === "sqlite" ? database : void 0);
+  return {
+    driver,
+    url,
+    host: connection.host,
+    port: connection.port,
+    username: connection.username,
+    password: connection.password,
+    database,
+    schema: connection.schema,
+    ssl: connection.ssl,
+    logging: connection.logging ?? false
+  };
+}
+export function useHoloDb() {
+  const config = getRuntimeConfig();
+  const group = config.db ?? { connections: {} };
+  const connections = group.connections ?? {};
+  return {
+    defaultConnection: resolveDefaultConnectionName({
+      defaultConnection: group.defaultConnection,
+      connections
+    }),
+    connections: Object.fromEntries(
+      Object.entries(connections).map(([name, connection]) => {
+        if (typeof connection === "string") {
+          return [name, { url: connection }];
+        }
+        return [name, normalizeConnection(connection)];
+      })
+    )
+  };
+}
+export function useHoloEnv() {
+  const config = getRuntimeConfig();
+  return resolveRuntimeEnvName(config.holo.appEnv);
+}
+export function useHoloDebug() {
+  const config = getRuntimeConfig();
+  return config.holo.appDebug;
+}

package/dist/runtime/drivers/s3.js

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

package/dist/runtime/plugins/init.js

@@ -0,0 +1,21 @@
+import {
+  configureHoloRuntimeConfig
+} from "../composables/index.js";
+import { initializeHoloAdapterProject } from "@holo-js/core";
+export default defineNitroPlugin(async (nitroApp) => {
+  const config = useRuntimeConfig();
+  configureHoloRuntimeConfig(config);
+  const project = await initializeHoloAdapterProject(config.holo.projectRoot?.trim() || process.cwd(), {
+    envName: config.holo.appEnv,
+    preferCache: process.env.NODE_ENV === "production",
+    processEnv: process.env
+  });
+  const driver = project.runtime.manager.connection().getDriver();
+  console.log(`\u2705 Holo DB connected (${driver})`);
+  nitroApp.hooks.hook("close", async () => {
+    try {
+      await project.runtime.shutdown();
+    } catch {
+    }
+  });
+});

package/dist/runtime/plugins/storage.js

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

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

@@ -0,0 +1,6 @@
+export {
+  holo,
+  useHoloDb,
+  useHoloDebug,
+  useHoloEnv
+} from "../../composables/index.js";

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

@@ -0,0 +1,192 @@
+import { readFile, realpath } from "node:fs/promises";
+import { extname, resolve, sep } from "node:path";
+import { useRuntimeConfig } from "#imports";
+const NAMED_PUBLIC_DISK_ROUTE_SEGMENT = "__holo";
+function normalizeRequestPath(value) {
+  return value.split("/").map((segment) => {
+    const trimmed = segment.trim();
+    if (!trimmed) {
+      return trimmed;
+    }
+    try {
+      return decodeURIComponent(trimmed);
+    } catch {
+      return trimmed;
+    }
+  }).filter(Boolean);
+}
+function isPublicLocalDisk(disk) {
+  return Boolean(disk && disk.visibility === "public" && disk.driver !== "s3" && typeof disk.root === "string");
+}
+function isMissingFileError(error) {
+  const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+  return Boolean(
+    error && typeof error === "object" && (code === "ENOENT" || code === "EISDIR" || code === "ENOTDIR")
+  );
+}
+function resolveAbsolutePath(disk, fileSegments) {
+  const root = resolve(disk.root);
+  const absolutePath = resolve(root, ...fileSegments);
+  if (absolutePath !== root && !absolutePath.startsWith(`${root}${sep}`)) {
+    return null;
+  }
+  return absolutePath;
+}
+function resolveContentType(absolutePath) {
+  switch (extname(absolutePath).toLowerCase()) {
+    case ".avif":
+      return "image/avif";
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".gif":
+      return "image/gif";
+    case ".html":
+      return "text/html; charset=utf-8";
+    case ".jpeg":
+    case ".jpg":
+      return "image/jpeg";
+    case ".js":
+    case ".mjs":
+      return "text/javascript; charset=utf-8";
+    case ".json":
+      return "application/json; charset=utf-8";
+    case ".mp3":
+      return "audio/mpeg";
+    case ".pdf":
+      return "application/pdf";
+    case ".png":
+      return "image/png";
+    case ".svg":
+      return "image/svg+xml";
+    case ".txt":
+      return "text/plain; charset=utf-8";
+    case ".webp":
+      return "image/webp";
+    case ".woff":
+      return "font/woff";
+    case ".woff2":
+      return "font/woff2";
+    default:
+      return "application/octet-stream";
+  }
+}
+function createMissingFileError(message) {
+  const error = new Error(message);
+  error.code = "ENOENT";
+  return error;
+}
+function isPathWithinRoot(root, absolutePath) {
+  return absolutePath === root || absolutePath.startsWith(`${root}${sep}`);
+}
+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 contents = await readFile(absolutePath);
+  setResponseHeader(event, "content-type", resolveContentType(absolutePath));
+  return contents;
+}
+function resolveRouteSegments(routePath) {
+  const segments = normalizeRequestPath(routePath);
+  if (segments.length === 0 || segments.includes("..")) {
+    return null;
+  }
+  return segments;
+}
+function resolveDefaultPublicStorageRequest(config, segments) {
+  const disk = isPublicLocalDisk(config.disks.public) ? config.disks.public : void 0;
+  if (!disk) {
+    return null;
+  }
+  const absolutePath = resolveAbsolutePath(disk, segments);
+  if (!absolutePath) {
+    return null;
+  }
+  return { disk, absolutePath };
+}
+function usesReservedNamedDiskNamespace(segments) {
+  return segments[0] === NAMED_PUBLIC_DISK_ROUTE_SEGMENT;
+}
+function resolveNamedPublicStorageRequest(config, segments) {
+  const namedPublicDisks = Object.values(config.disks).filter((disk2) => {
+    return isPublicLocalDisk(disk2) && disk2.name !== "public";
+  });
+  const usesReservedNamespace = segments[0] === NAMED_PUBLIC_DISK_ROUTE_SEGMENT;
+  const diskName = usesReservedNamespace ? segments[1] : segments[0];
+  const disk = diskName ? namedPublicDisks.find((candidate) => candidate.name === diskName) : void 0;
+  if (!disk) {
+    return null;
+  }
+  const fileSegments = usesReservedNamespace ? segments.slice(2) : segments.slice(1);
+  if (fileSegments.length === 0) {
+    return null;
+  }
+  const absolutePath = resolveAbsolutePath(disk, fileSegments);
+  if (!absolutePath) {
+    return null;
+  }
+  return { disk, absolutePath };
+}
+export function resolvePublicStorageRequest(config, routePath) {
+  const segments = resolveRouteSegments(routePath);
+  if (!segments) {
+    return null;
+  }
+  if (usesReservedNamedDiskNamespace(segments)) {
+    return resolveNamedPublicStorageRequest(config, segments) ?? resolveDefaultPublicStorageRequest(config, segments);
+  }
+  return resolveDefaultPublicStorageRequest(config, segments) ?? resolveNamedPublicStorageRequest(config, segments);
+}
+function resolveFallbackPublicStorageRequest(config, segments, attemptedDiskName) {
+  if (usesReservedNamedDiskNamespace(segments)) {
+    return null;
+  }
+  const candidates = [
+    resolveDefaultPublicStorageRequest(config, segments),
+    resolveNamedPublicStorageRequest(config, segments)
+  ];
+  return candidates.find((candidate) => candidate && candidate.disk.name !== attemptedDiskName) ?? null;
+}
+export default defineEventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig();
+  const { holoStorage } = runtimeConfig;
+  const pathname = getRequestURL(event).pathname;
+  const routePath = pathname.startsWith(holoStorage.routePrefix) ? pathname.slice(holoStorage.routePrefix.length) : pathname;
+  const segments = resolveRouteSegments(routePath);
+  if (!segments) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Storage file not found."
+    });
+  }
+  const resolved = resolvePublicStorageRequest(holoStorage, routePath);
+  if (!resolved) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Storage file not found."
+    });
+  }
+  try {
+    return await readPublicFile(event, resolved.disk, resolved.absolutePath);
+  } catch (error) {
+    if (!isMissingFileError(error)) {
+      throw error;
+    }
+    const fallback = resolveFallbackPublicStorageRequest(holoStorage, segments, resolved.disk.name);
+    if (fallback) {
+      try {
+        return await readPublicFile(event, fallback.disk, fallback.absolutePath);
+      } catch (fallbackError) {
+        if (!isMissingFileError(fallbackError)) {
+          throw fallbackError;
+        }
+      }
+    }
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Storage file not found."
+    });
+  }
+});

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

@@ -0,0 +1 @@
+export { Storage, useStorage } from "@holo-js/storage/runtime";

package/dist/runtime/shims.d.ts

@@ -0,0 +1,57 @@
+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
+}
+
+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>
+  }
+}
+
+declare module '#app' {
+  export function useRuntimeConfig(): HoloRuntimeConfig
+}
+
+declare module '#imports' {
+  export function useRuntimeConfig(): HoloRuntimeConfig
+  export function useStorage(base: string): unknown
+}
+
+declare global {
+  function createError(input: { statusCode: number, statusMessage: string }): Error
+  function defineNitroPlugin<T>(plugin: T): T
+  function defineEventHandler<T>(
+    handler: (event: unknown) => T | Promise<T>,
+  ): (event: unknown) => T | Promise<T>
+  function getRequestURL(event: unknown): URL
+  function setResponseHeader(event: unknown, name: string, value: string): void
+  function useRuntimeConfig(): HoloRuntimeConfig
+}
+
+export {}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { type adapterNuxtInternals, default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@holo-js/adapter-nuxt",
+  "version": "0.1.0",
+  "description": "Holo-JS Framework - Nuxt adapter",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    },
+    "./client": {
+      "types": "./dist/runtime/composables/forms.d.ts",
+      "import": "./dist/runtime/composables/forms.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/composables/index.d.ts",
+      "import": "./dist/runtime/composables/index.js"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "types": "./dist/types.d.mts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "nuxt-module-build build",
+    "stub": "nuxt-module-build build",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest --run"
+  },
+  "dependencies": {
+    "@nuxt/kit": "catalog:",
+    "@holo-js/config": "workspace:*",
+    "@holo-js/core": "workspace:*",
+    "@holo-js/db": "workspace:*",
+    "@holo-js/forms": "workspace:*",
+    "@holo-js/storage": "workspace:*"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "catalog:",
+    "@types/node": "catalog:",
+    "nuxt": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  }
+}