@holo-js/adapter-nuxt 0.1.9 → 0.2.1

package/dist/module.d.mts

@@ -53,12 +53,14 @@ type ViteOptimizeDepsOptions = {
 };
 type NuxtViteOptions = {
     optimizeDeps?: ViteOptimizeDepsOptions;
+    plugins?: unknown[];
     [key: string]: unknown;
 };
 interface NuxtOptionsWithNitro {
     nitro: {
         storage: Record<string, unknown>;
         errorHandler?: string | string[];
+        virtual?: Record<string, () => string>;
         experimental?: {
             asyncContext?: boolean;
             [key: string]: unknown;
@@ -85,6 +87,8 @@ interface NuxtOptionsWithNitro {
     _holoStorageModuleOptions?: StorageModuleOptions;
     _holoStorageFinalizeRegistered?: boolean;
     _holoStorageRuntimeRegistered?: boolean;
+    _holoBroadcastAuthRouteRegistered?: boolean;
+    _holoRealtimeRouteRegistered?: boolean;
     _holoCoreRuntimeRegistered?: boolean;
     _holoTypesRegistered?: boolean;
 }

package/dist/module.json

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

package/dist/module.mjs

@@ -1,11 +1,254 @@
+import { readFileSync } from 'node:fs';
 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 { defineNuxtModule, createResolver, addServerPlugin, addServerImportsDir, addServerHandler, addPlugin } from '@nuxt/kit';
 import { loadConfigDirectory } from '@holo-js/config';
 
-const MODEL_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"]);
+const serverOnlyRealtimeProperties = /* @__PURE__ */ new Set(["handler", "authorize"]);
+function isIdentifierBoundary(value) {
+  return !value || !/[$\w]/.test(value);
+}
+function skipString(source, index, quote) {
+  let cursor = index + 1;
+  while (cursor < source.length) {
+    const char = source[cursor];
+    if (char === "\\") {
+      cursor += 2;
+      continue;
+    }
+    if (char === quote) {
+      return cursor + 1;
+    }
+    cursor += 1;
+  }
+  return cursor;
+}
+function skipLineComment(source, index) {
+  const end = source.indexOf("\n", index + 2);
+  return end === -1 ? source.length : end + 1;
+}
+function skipBlockComment(source, index) {
+  const end = source.indexOf("*/", index + 2);
+  return end === -1 ? source.length : end + 2;
+}
+function skipSyntax(source, index) {
+  const char = source[index];
+  const next = source[index + 1];
+  if (char === '"' || char === "'" || char === "`") {
+    return skipString(source, index, char);
+  }
+  if (char === "/" && next === "/") {
+    return skipLineComment(source, index);
+  }
+  if (char === "/" && next === "*") {
+    return skipBlockComment(source, index);
+  }
+  return void 0;
+}
+function findRealtimePropertyValueEnd(source, index) {
+  let cursor = index;
+  let braceDepth = 0;
+  let bracketDepth = 0;
+  let parenDepth = 0;
+  while (cursor < source.length) {
+    const syntaxEnd = skipSyntax(source, cursor);
+    if (typeof syntaxEnd === "number") {
+      cursor = syntaxEnd;
+      continue;
+    }
+    const char = source[cursor];
+    if (char === "{") {
+      braceDepth += 1;
+    } else if (char === "}") {
+      if (braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
+        return cursor;
+      }
+      braceDepth -= 1;
+    } else if (char === "[") {
+      bracketDepth += 1;
+    } else if (char === "]") {
+      bracketDepth -= 1;
+    } else if (char === "(") {
+      parenDepth += 1;
+    } else if (char === ")") {
+      parenDepth -= 1;
+    } else if (char === "," && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
+      return cursor;
+    }
+    cursor += 1;
+  }
+  return source.length;
+}
+function findClosingBrace(source, index) {
+  let cursor = index;
+  let depth = 0;
+  while (cursor < source.length) {
+    const syntaxEnd = skipSyntax(source, cursor);
+    if (typeof syntaxEnd === "number") {
+      cursor = syntaxEnd;
+      continue;
+    }
+    const char = source[cursor];
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return cursor;
+      }
+    }
+    cursor += 1;
+  }
+  return -1;
+}
+function applyReplacements(source, replacements) {
+  if (replacements.length === 0) {
+    return source;
+  }
+  let output = "";
+  let cursor = 0;
+  const ordered = [...replacements].sort((left, right) => left.start - right.start);
+  for (const replacement of ordered) {
+    output += source.slice(cursor, replacement.start);
+    output += replacement.text;
+    cursor = replacement.end;
+  }
+  return output + source.slice(cursor);
+}
+function extractObjectPropertyValue(objectSource, propertyName) {
+  let cursor = 1;
+  while (cursor < objectSource.length - 1) {
+    const syntaxEnd = skipSyntax(objectSource, cursor);
+    if (typeof syntaxEnd === "number") {
+      cursor = syntaxEnd;
+      continue;
+    }
+    const match = objectSource.slice(cursor).match(/^[$A-Z_a-z][$\w]*/);
+    const name = match?.[0];
+    if (!name || name !== propertyName) {
+      cursor += 1;
+      continue;
+    }
+    const afterName = cursor + name.length;
+    if (!isIdentifierBoundary(objectSource[cursor - 1]) || !isIdentifierBoundary(objectSource[afterName])) {
+      cursor += name.length;
+      continue;
+    }
+    let colon = afterName;
+    while (/\s/.test(objectSource[colon] ?? "")) {
+      colon += 1;
+    }
+    if (objectSource[colon] !== ":") {
+      cursor += name.length;
+      continue;
+    }
+    const valueStart = colon + 1;
+    const valueEnd = findRealtimePropertyValueEnd(objectSource, valueStart);
+    return objectSource.slice(valueStart, valueEnd).trim();
+  }
+  return void 0;
+}
+function collectRealtimeDefinitionExports(source) {
+  const definitions = [];
+  let cursor = 0;
+  while (cursor < source.length) {
+    const syntaxEnd = skipSyntax(source, cursor);
+    if (typeof syntaxEnd === "number") {
+      cursor = syntaxEnd;
+      continue;
+    }
+    const match = source.slice(cursor).match(/^export\s+const\s+([$A-Z_a-z][$\w]*)\s*=\s*(query|mutation)\s*\(/);
+    const exportedName = match?.[1];
+    const factoryName = match?.[2];
+    if (!exportedName || !factoryName) {
+      cursor += 1;
+      continue;
+    }
+    let objectStart = cursor + match[0].length;
+    while (/\s/.test(source[objectStart] ?? "")) {
+      objectStart += 1;
+    }
+    if (source[objectStart] !== "{") {
+      cursor += match[0].length;
+      continue;
+    }
+    const objectEnd = findClosingBrace(source, objectStart);
+    if (objectEnd === -1) {
+      cursor += match[0].length;
+      continue;
+    }
+    const objectSource = source.slice(objectStart, objectEnd + 1);
+    definitions.push({
+      exportedName,
+      factoryName,
+      nameValue: extractObjectPropertyValue(objectSource, "name")
+    });
+    cursor = objectEnd + 1;
+  }
+  return definitions;
+}
+function createRealtimeClientDefinitionModule(source) {
+  const definitions = collectRealtimeDefinitionExports(source);
+  if (definitions.length === 0) {
+    return stripRealtimeServerHandlers(source);
+  }
+  const factories = [...new Set(definitions.map((definition) => definition.factoryName))];
+  return [
+    `import { ${factories.join(", ")} } from '@holo-js/adapter-nuxt/realtime'`,
+    "",
+    ...definitions.flatMap((definition) => [
+      `export const ${definition.exportedName} = ${definition.factoryName}({`,
+      ...definition.nameValue ? [`  name: ${definition.nameValue},`] : [],
+      "  handler: undefined,",
+      "})",
+      ""
+    ])
+  ].join("\n");
+}
+function stripRealtimeServerHandlers(source) {
+  const replacements = [];
+  let cursor = 0;
+  while (cursor < source.length) {
+    const syntaxEnd = skipSyntax(source, cursor);
+    if (typeof syntaxEnd === "number") {
+      cursor = syntaxEnd;
+      continue;
+    }
+    const match = source.slice(cursor).match(/^[$A-Z_a-z][$\w]*/);
+    const name = match?.[0];
+    if (!name || !serverOnlyRealtimeProperties.has(name)) {
+      cursor += 1;
+      continue;
+    }
+    const afterName = cursor + name.length;
+    if (!isIdentifierBoundary(source[cursor - 1]) || !isIdentifierBoundary(source[afterName])) {
+      cursor += name.length;
+      continue;
+    }
+    let colon = afterName;
+    while (/\s/.test(source[colon] ?? "")) {
+      colon += 1;
+    }
+    if (source[colon] !== ":") {
+      cursor += name.length;
+      continue;
+    }
+    const valueStart = colon + 1;
+    const valueEnd = findRealtimePropertyValueEnd(source, valueStart);
+    replacements.push({
+      start: valueStart,
+      end: valueEnd,
+      text: " undefined"
+    });
+    cursor = valueEnd;
+  }
+  return applyReplacements(source, replacements);
+}
+
+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 CLIENT_OPTIMIZE_DEPS = [
   {
     packageName: `${HOLO_PACKAGE_SCOPE}forms`,
@@ -46,6 +289,18 @@ function isModuleResolutionFailure(error) {
   }
   return "code" in error && (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_MODULE_NOT_FOUND");
 }
+function hasProjectPackage(rootDir, packageName) {
+  const projectRequire = createRequire(resolve(rootDir, "package.json"));
+  try {
+    projectRequire.resolve(packageName);
+    return true;
+  } catch (error) {
+    if (isModuleResolutionFailure(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
 function resolveClientOptimizeDeps(rootDir) {
   const projectRequire = createRequire(resolve(rootDir, "package.json"));
   const deps = [];
@@ -74,6 +329,68 @@ function addViteOptimizeDeps(opts, deps) {
     ])
   ];
 }
+function isRealtimeDefinitionModule(_rootDir, id) {
+  const normalizedId = id.split("?")[0]?.replaceAll("\\", "/") ?? "";
+  return normalizedId.includes("/server/realtime/") && MODEL_FILE_EXTENSIONS.has(extname(normalizedId));
+}
+function resolveExistingRealtimeDefinitionFile(path) {
+  if (MODEL_FILE_EXTENSIONS.has(extname(path)) && existsFile(path)) {
+    return path;
+  }
+  for (const extension of MODEL_FILE_EXTENSIONS) {
+    const candidate = `${path}${extension}`;
+    if (existsFile(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function existsFile(path) {
+  try {
+    return readFileSync(path).length >= 0;
+  } catch {
+    return false;
+  }
+}
+function resolveRealtimeDefinitionImport(source, importer) {
+  if (!source.includes("server/realtime") && !source.includes("server\\realtime")) {
+    return void 0;
+  }
+  const basePath = source.startsWith(".") ? importer ? resolve(dirname(importer.split("?")[0] ?? importer), source) : void 0 : resolve(source);
+  return basePath ? resolveExistingRealtimeDefinitionFile(basePath) : void 0;
+}
+function createRealtimeDefinitionVitePlugin(rootDir) {
+  return {
+    name: "holo-realtime-client-definitions",
+    enforce: "pre",
+    resolveId(source, importer, options) {
+      if (options?.ssr) {
+        return null;
+      }
+      const resolved = resolveRealtimeDefinitionImport(source, importer);
+      return resolved ? `${realtimeClientDefinitionPrefix}${resolved}` : null;
+    },
+    load(id) {
+      if (!id.startsWith(realtimeClientDefinitionPrefix)) {
+        return null;
+      }
+      const sourcePath = id.slice(realtimeClientDefinitionPrefix.length);
+      return createRealtimeClientDefinitionModule(readFileSync(sourcePath, "utf8"));
+    },
+    transform(code, id, options) {
+      if (options?.ssr || !isRealtimeDefinitionModule(rootDir, id)) {
+        return null;
+      }
+      return {
+        code: createRealtimeClientDefinitionModule(code),
+        map: null
+      };
+    }
+  };
+}
+function addVitePlugin(vite, plugin) {
+  vite.plugins = [...vite.plugins ?? [], plugin];
+}
 function addNitroErrorHandler(opts, handler) {
   const current = opts.nitro.errorHandler;
   const handlers = Array.isArray(current) ? current : typeof current === "string" ? [current] : [];
@@ -243,6 +560,33 @@ const module$1 = defineNuxtModule({
       addServerPlugin(resolver.resolve("./runtime/plugins/storage"));
       opts._holoStorageRuntimeRegistered = true;
     }
+    if (hasProjectPackage(rootDir, "@holo-js/broadcast") && !opts._holoBroadcastAuthRouteRegistered) {
+      addServerHandler({
+        route: "/broadcasting/config",
+        handler: resolver.resolve("./runtime/server/routes/broadcast-config.get")
+      });
+      addServerHandler({
+        route: "/broadcasting/auth",
+        handler: resolver.resolve("./runtime/server/routes/broadcast-auth.post")
+      });
+      opts._holoBroadcastAuthRouteRegistered = true;
+    }
+    if (hasProjectPackage(rootDir, "@holo-js/realtime") && !opts._holoRealtimeRouteRegistered) {
+      const realtimeDefinitionPlugin = createRealtimeDefinitionVitePlugin(rootDir);
+      opts.vite = opts.vite || {};
+      addVitePlugin(opts.vite, realtimeDefinitionPlugin);
+      nuxt.hook("vite:extendConfig", (config, context) => {
+        if (context.isServer) {
+          return;
+        }
+        addVitePlugin(config, realtimeDefinitionPlugin);
+      });
+      addPlugin({
+        src: resolver.resolve("./runtime/plugins/realtime"),
+        mode: "all"
+      });
+      opts._holoRealtimeRouteRegistered = true;
+    }
     if (storageModule && normalizedStorage && (!opts.nitro.storage || Object.keys(opts.nitro.storage).every((key) => !key.startsWith("holo:")))) {
       storageModule.applyNitroStorageConfig(opts, normalizedStorage, s3Driver);
     }

package/dist/runtime/composables/client-errors.js

@@ -0,0 +1,67 @@
+export function renderNuxtClientHttpErrorPage(error) {
+  const nuxtGlobal = globalThis;
+  const nuxtError = {
+    statusCode: error.status,
+    statusMessage: error.message,
+    message: error.message
+  };
+  if (typeof nuxtGlobal.showError === "function") {
+    nuxtGlobal.showError(nuxtError);
+    return;
+  }
+  renderFallbackClientHttpErrorPage(error);
+}
+function renderFallbackClientHttpErrorPage(error) {
+  const browserDocument = globalThis.document;
+  if (!browserDocument) {
+    return;
+  }
+  browserDocument.title = `${error.status}: ${error.message}`;
+  const existingRoot = browserDocument.getElementById("__holo_nuxt_client_http_error__");
+  const root = existingRoot ?? browserDocument.createElement("main");
+  root.id = "__holo_nuxt_client_http_error__";
+  root.setAttribute("role", "alert");
+  root.style.cssText = [
+    "position:fixed",
+    "inset:0",
+    "z-index:2147483647",
+    "display:grid",
+    "place-items:center",
+    "margin:0",
+    "background:#fff",
+    "color:#000",
+    "font-family:Arial,Helvetica,sans-serif"
+  ].join(";");
+  const wrapper = browserDocument.createElement("div");
+  wrapper.style.cssText = "display:flex;align-items:center;gap:1.5rem;padding:1.5rem";
+  const status = browserDocument.createElement("h1");
+  status.className = "nuxt-error-h1";
+  status.textContent = String(error.status);
+  status.style.cssText = [
+    "display:inline-block",
+    "margin:0 1.25rem 0 0",
+    "padding:0 1.5rem 0 0",
+    "font-size:24px",
+    "font-weight:500",
+    "line-height:49px",
+    "vertical-align:top",
+    "border-right:1px solid rgba(0,0,0,.3)"
+  ].join(";");
+  const description = browserDocument.createElement("div");
+  description.style.cssText = "display:inline-block;text-align:left;line-height:49px;height:49px;vertical-align:middle";
+  const message = browserDocument.createElement("h2");
+  message.textContent = error.message;
+  message.style.cssText = "font-size:14px;font-weight:400;line-height:49px;margin:0";
+  description.append(message);
+  wrapper.append(status, description);
+  root.replaceChildren(wrapper);
+  for (const child of Array.from(browserDocument.body.children)) {
+    if (child.id === root.id) {
+      continue;
+    }
+    child.style.display = "none";
+  }
+  if (!existingRoot) {
+    browserDocument.body.append(root);
+  }
+}

package/dist/runtime/composables/forms.js

@@ -1,9 +1,12 @@
 import { onScopeDispose, reactive, shallowRef, watchEffect } from "vue";
 import { useCookie } from "#app";
+import { normalizeHoloHttpError } from "@holo-js/core/errors";
 import { DEFAULT_VALIDATION_BAG, createErrorBag } from "@holo-js/validation";
 import {
   createFormClient
 } from "@holo-js/forms/internal/client";
+import { renderNuxtClientHttpErrorPage } from "./client-errors.js";
+import { isPlainObject } from "./object.js";
 const FORM_FAILURE_COOKIE = "holo_form_failure";
 const ARRAY_MUTATION_METHODS = /* @__PURE__ */ new Set([
   "copyWithin",
@@ -16,9 +19,6 @@ const ARRAY_MUTATION_METHODS = /* @__PURE__ */ new Set([
   "splice",
   "unshift"
 ]);
-function isPlainObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Blob);
-}
 function isLeafValue(value) {
   return value instanceof Date || value instanceof Blob || !Array.isArray(value) && !isPlainObject(value);
 }
@@ -68,6 +68,41 @@ function parseFlashedValidationPayload() {
     return void 0;
   }
 }
+function getHttpFailureMessage(result) {
+  return result.errors?._root?.[0];
+}
+function renderFormHttpFailure(result) {
+  if (!isPlainObject(result)) {
+    return;
+  }
+  const httpError = result.ok === false && typeof result.status === "number" ? normalizeHoloHttpError({
+    status: result.status,
+    message: getHttpFailureMessage(result)
+  }) : normalizeHoloHttpError(result);
+  if (!httpError || httpError.status === 422) {
+    return;
+  }
+  renderNuxtClientHttpErrorPage(httpError);
+}
+function createHttpHandledFormOptions(options) {
+  const submitter = options.submitter;
+  if (!submitter) {
+    return options;
+  }
+  return {
+    ...options,
+    async submitter(context) {
+      try {
+        const result = await submitter(context);
+        renderFormHttpFailure(result);
+        return result;
+      } catch (error) {
+        renderFormHttpFailure(error);
+        throw error;
+      }
+    }
+  };
+}
 export function useValidationErrors(bag = DEFAULT_VALIDATION_BAG) {
   const payload = parseFlashedValidationPayload();
   if (!payload || (payload.bag ?? DEFAULT_VALIDATION_BAG) !== bag) {
@@ -229,7 +264,7 @@ export function useForm(schemaDefinition, options = {}) {
     );
   };
   const stopWatching = watchEffect((onCleanup) => {
-    const localForm = createFormClient(schemaDefinition, options);
+    const localForm = createFormClient(schemaDefinition, createHttpHandledFormOptions(options));
     syncValuesFromForm(localForm);
     form.value = localForm;
     version.value = ++versionCounter;
@@ -272,7 +307,9 @@ export function useForm(schemaDefinition, options = {}) {
       return await currentForm().validateField(path);
     },
     async submit() {
-      return await currentForm().submit();
+      const result = await currentForm().submit();
+      renderFormHttpFailure(result);
+      return result;
     },
     reset(nextValues) {
       currentForm().reset(nextValues);

package/dist/runtime/composables/object.js

@@ -0,0 +1,3 @@
+export function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Blob);
+}

package/dist/runtime/composables/realtime.js

@@ -0,0 +1,81 @@
+import { onScopeDispose, reactive } from "vue";
+import { normalizeHoloHttpError } from "@holo-js/core/errors";
+import {
+  configureRealtimeClientRuntime,
+  configureRealtimeClientTransport,
+  createBroadcastRealtimeTransport,
+  getRealtimeQueryStore
+} from "@holo-js/realtime/client";
+import {
+  mutation as createRealtimeMutation,
+  query as createRealtimeQuery
+} from "@holo-js/realtime";
+import { renderNuxtClientHttpErrorPage } from "./client-errors.js";
+import { isPlainObject } from "./object.js";
+function emitRealtimeError(error) {
+  const httpError = normalizeHoloHttpError(error);
+  if (httpError) {
+    renderNuxtClientHttpErrorPage(httpError);
+  }
+}
+export const query = createRealtimeQuery;
+export const mutation = createRealtimeMutation;
+function replaceReactiveObject(target, value) {
+  for (const key of Object.keys(target)) {
+    if (!(key in value)) {
+      delete target[key];
+    }
+  }
+  Object.assign(target, value);
+}
+function replaceReactiveArray(target, value) {
+  target.splice(0, target.length, ...value);
+}
+function createRealtimeReactiveValue(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    return reactive([...value]);
+  }
+  if (isPlainObject(value)) {
+    return reactive({ ...value });
+  }
+  return value;
+}
+function replaceRealtimeReactiveValue(target, value) {
+  if (typeof target === "undefined") {
+    return createRealtimeReactiveValue(value);
+  }
+  if (Array.isArray(target) && Array.isArray(value)) {
+    replaceReactiveArray(target, value);
+    return target;
+  }
+  if (isPlainObject(target) && isPlainObject(value)) {
+    replaceReactiveObject(target, value);
+    return target;
+  }
+  return value;
+}
+function useReactiveRealtimeQuery(definition, args) {
+  const store = getRealtimeQueryStore(definition, args);
+  const initialData = store.snapshot?.data;
+  let current = typeof initialData === "undefined" ? reactive({}) : createRealtimeReactiveValue(initialData);
+  const unsubscribe = store.subscribe(() => {
+    const nextData = store.snapshot?.data;
+    if (typeof nextData !== "undefined") {
+      current = replaceRealtimeReactiveValue(current, nextData);
+    }
+  });
+  if ("window" in globalThis) {
+    store.connect();
+  }
+  onScopeDispose(unsubscribe);
+  return current;
+}
+configureRealtimeClientRuntime({
+  handleError: emitRealtimeError,
+  useQuery: useReactiveRealtimeQuery
+});
+configureRealtimeClientTransport(createBroadcastRealtimeTransport());
+export {};

package/dist/runtime/plugins/realtime.client.js

@@ -0,0 +1 @@
+export { default } from "./realtime.js";

package/dist/runtime/plugins/realtime.js

@@ -0,0 +1,4 @@
+import { defineNuxtPlugin } from "#app";
+import "../composables/realtime";
+export default defineNuxtPlugin(() => {
+});

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

@@ -1,10 +1,6 @@
-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;
+export {
+  holo,
+  useHoloDb,
+  useHoloDebug,
+  useHoloEnv
+} from "../imports/holo.js";

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

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

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

@@ -0,0 +1,47 @@
+import { defineEventHandler, getHeaders, getRequestURL, readRawBody } from "h3";
+import { renderBroadcastAuthResponse } from "@holo-js/broadcast/auth";
+import { holo } from "../../composables/index.js";
+function resolveBroadcastSigning(connection) {
+  if (!connection || typeof connection !== "object") {
+    return {};
+  }
+  const candidate = connection;
+  if (candidate.driver !== "holo" || typeof candidate.key !== "string" || typeof candidate.secret !== "string") {
+    return {};
+  }
+  return {
+    appKey: candidate.key,
+    appSecret: candidate.secret
+  };
+}
+export default defineEventHandler(async (event) => {
+  const app = await holo.getApp();
+  const auth = await holo.getAuth();
+  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, {
+    ...signing,
+    resolveUser: async (_request, context) => {
+      const guardAuth = context.guard ? auth?.guard(context.guard) : void 0;
+      return guardAuth ? await guardAuth.user() : await auth?.user();
+    },
+    channelAuth: {
+      registry: {
+        projectRoot: app.projectRoot,
+        channels: app.registry?.channels ?? []
+      }
+    }
+  });
+});

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

@@ -0,0 +1,7 @@
+import { defineEventHandler } from "h3";
+import { renderBroadcastClientConfigResponse } from "@holo-js/broadcast/client-config";
+import { holo } from "../../composables/index.js";
+export default defineEventHandler(async () => {
+  const app = await holo.getApp();
+  return renderBroadcastClientConfigResponse(app.config.broadcast);
+});

package/dist/runtime/shims.d.ts

@@ -41,6 +41,7 @@ interface HoloRuntimeConfig extends RuntimeConfigInput {
  * runtime config, storage access, and Nitro route/plugin globals.
  */
 declare module '#app' {
+  export function defineNuxtPlugin<T>(plugin: T): T
   export function useRuntimeConfig(): HoloRuntimeConfig
   export function useCookie<T = string | null>(name: string): { value: T | null | undefined }
 }
@@ -67,6 +68,13 @@ declare module 'nitropack/runtime/storage' {
 }
 
 declare global {
+  interface ImportMeta {
+    glob<TModule>(
+      pattern: string,
+      options: { readonly eager: true },
+    ): Record<string, TModule>
+  }
+
   function createError(input: { statusCode: number, statusMessage: string }): Error
   function defineNitroErrorHandler<T>(handler: T): T
   function defineNitroPlugin<T>(plugin: T): T

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/adapter-nuxt",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "Holo-JS Framework - Nuxt adapter",
   "type": "module",
   "license": "MIT",
@@ -17,6 +17,10 @@
       "types": "./dist/runtime/composables/index.d.ts",
       "import": "./dist/runtime/composables/index.js"
     },
+    "./realtime": {
+      "types": "./dist/runtime/composables/realtime.d.ts",
+      "import": "./dist/runtime/composables/realtime.js"
+    },
     "./storage": {
       "types": "./dist/runtime/composables/storage.d.ts",
       "import": "./dist/runtime/composables/storage.js"
@@ -35,21 +39,29 @@
   },
   "dependencies": {
     "@nuxt/kit": "^4.4.4",
-    "@holo-js/config": "^0.1.9",
-    "@holo-js/core": "^0.1.9",
-    "@holo-js/db": "^0.1.9",
-    "@holo-js/validation": "^0.1.9",
+    "@holo-js/config": "^0.2.1",
+    "@holo-js/core": "^0.2.1",
+    "@holo-js/db": "^0.2.1",
+    "@holo-js/validation": "^0.2.1",
     "h3": "^1.15.11"
   },
   "peerDependencies": {
-    "@holo-js/forms": "^0.1.9",
-    "@holo-js/storage": "^0.1.9",
-    "@holo-js/storage-s3": "^0.1.9"
+    "@holo-js/broadcast": "^0.2.1",
+    "@holo-js/forms": "^0.2.1",
+    "@holo-js/realtime": "^0.2.1",
+    "@holo-js/storage": "^0.2.1",
+    "@holo-js/storage-s3": "^0.2.1"
   },
   "peerDependenciesMeta": {
+    "@holo-js/broadcast": {
+      "optional": true
+    },
     "@holo-js/forms": {
       "optional": true
     },
+    "@holo-js/realtime": {
+      "optional": true
+    },
     "@holo-js/storage": {
       "optional": true
     },
@@ -58,7 +70,9 @@
     }
   },
   "devDependencies": {
-    "@holo-js/storage-s3": "^0.1.9",
+    "@holo-js/broadcast": "^0.2.1",
+    "@holo-js/realtime": "^0.2.1",
+    "@holo-js/storage-s3": "^0.2.1",
     "@nuxt/module-builder": "^1.0.2",
     "@types/node": "^22.10.2",
     "nuxt": "^4.4.4",