@abraca/nuxt 2.0.11 → 2.4.0

package/dist/runtime/plugin-abracadabra.client.js

@@ -130,6 +130,10 @@ function toNuxtUIPrimary(name) {
 function toNuxtUINeutral(name) {
   return NUXT_UI_NEUTRAL_COLORS.has(name) ? name : CUSTOM_TO_NUXT_UI_NEUTRAL[name] ?? "zinc";
 }
+function hostHasCustomPalette(name) {
+  if (typeof document === "undefined") return false;
+  return getComputedStyle(document.documentElement).getPropertyValue(`--color-${name}-500`).trim() !== "";
+}
 const STORAGE_KEY_EXTERNAL_PLUGINS = "abracadabra_external_plugins";
 const STORAGE_KEY_DISABLED_BUILTINS = "abracadabra_disabled_builtins";
 const CLAIMED_FLAG_KEY = "abracadabra_was_claimed";
@@ -238,10 +242,29 @@ export default defineNuxtPlugin({
         localStorage.setItem(STORAGE_KEY_EXTERNAL_PLUGINS, JSON.stringify(updated));
       }
     }
+    const { _collectSchemaRegistries } = await import("./composables/useAbracadabraSchema.js");
+    const { schemas: schemaRegistries, plugins: inlinePlugins } = await _collectSchemaRegistries(nuxtApp);
+    for (const plugin of inlinePlugins) {
+      registry.register(plugin);
+    }
     registry.freeze();
     if (debug) {
       console.log("[abracadabra] plugins:", registry.getPlugins().map((p) => p.name));
     }
+    const schemaCfg = abraConfig.schema ?? {};
+    if (debug && schemaRegistries.length > 0) {
+      console.log(
+        "[abracadabra] schema registries attached:",
+        schemaRegistries.map((r) => Array.from(r.types.keys())),
+        "validate=",
+        schemaCfg.validate,
+        "migrateOnRead=",
+        schemaCfg.migrateOnRead
+      );
+    }
+    if (schemaCfg.bundleDir && debug) {
+      console.log("[abracadabra] server bundle_dir advertised:", schemaCfg.bundleDir);
+    }
     const doc = shallowRef(new Y.Doc());
     const provider = shallowRef(null);
     const client = shallowRef(null);
@@ -300,6 +323,7 @@ export default defineNuxtPlugin({
     let _serversLoaded = false;
     let _initPromise = null;
     let _wsp = null;
+    let _tokenManager = null;
     let authFailureCount = 0;
     const AUTH_FAILURE_LIMIT = 3;
     let lastClientIds = /* @__PURE__ */ new Set();
@@ -421,14 +445,18 @@ export default defineNuxtPlugin({
       userColorName.value = colorName;
       localStorage.setItem("abracadabra_usercolor", colorName);
       const appConfig = useAppConfig();
-      if (appConfig.ui?.colors) appConfig.ui.colors.primary = toNuxtUIPrimary(colorName);
+      if (appConfig.ui?.colors) {
+        appConfig.ui.colors.primary = hostHasCustomPalette(colorName) ? colorName : toNuxtUIPrimary(colorName);
+      }
       publishAwarenessUser();
     }
     function setNeutralColor(colorName) {
       userNeutralColorName.value = colorName;
       localStorage.setItem("abracadabra_neutralcolor", colorName);
       const appConfig = useAppConfig();
-      if (appConfig.ui?.colors) appConfig.ui.colors.neutral = toNuxtUINeutral(colorName);
+      if (appConfig.ui?.colors) {
+        appConfig.ui.colors.neutral = hostHasCustomPalette(colorName) ? colorName : toNuxtUINeutral(colorName);
+      }
     }
     function setUserStatusIcon(icon) {
       const normalized = icon.replace(/^i-lucide-/, "");
@@ -474,6 +502,13 @@ export default defineNuxtPlugin({
         }
         provider.value = null;
       }
+      if (_tokenManager) {
+        try {
+          _tokenManager.dispose();
+        } catch {
+        }
+        _tokenManager = null;
+      }
       client.value = null;
       keystore.value = null;
       isReady.value = false;
@@ -537,6 +572,7 @@ export default defineNuxtPlugin({
           addLog("No active session \u2014 registering passkey from scratch", "auth");
           await client.value.registerWithKey({
             publicKey: newPubKey,
+            x25519Key: x25519PublicKey,
             deviceName,
             displayName: userName.value,
             inviteCode: pendingInviteCode.value ?? void 0
@@ -623,6 +659,15 @@ export default defineNuxtPlugin({
     }
     async function logout() {
       addLog("Clearing identity...", "auth");
+      const sessionId = _tokenManager?.currentSession?.sessionId;
+      if (client.value && sessionId) {
+        try {
+          await client.value.revokeDeviceSession(sessionId);
+        } catch (e) {
+          if (import.meta.dev) console.warn("[abracadabra] revoke device session failed", e);
+        }
+      }
+      _tokenManager?.clearSession();
       if (client.value) client.value.logout();
       if (keystore.value) await keystore.value.clear();
       localStorage.removeItem("abracadabra_privkey");
@@ -783,7 +828,7 @@ export default defineNuxtPlugin({
           import("@noble/hashes/sha2.js")
         ]);
         setSdkModule(sdkModule);
-        const { AbracadabraClient, AbracadabraProvider, AbracadabraWS, CryptoIdentityKeystore } = sdkModule;
+        const { AbracadabraClient, AbracadabraProvider, AbracadabraWS, CryptoIdentityKeystore, TokenManager, LocalStorageDeviceSessionStorage } = sdkModule;
         const ed = edModule.default ?? edModule;
         if (!ed.hashes) {
           throw new Error("@noble/ed25519 v3: `hashes` export missing from imported namespace \u2014 check Vite optimizeDeps");
@@ -827,24 +872,38 @@ export default defineNuxtPlugin({
         const storedColor = localStorage.getItem("abracadabra_usercolor");
         const storedNeutral = localStorage.getItem("abracadabra_neutralcolor");
         const derived = deriveColorFromPubKey(pubKey);
+        const appConfig = useAppConfig();
+        const fromAppConfigPrimary = appConfig.ui?.colors?.primary;
+        const fromAppConfigNeutral = appConfig.ui?.colors?.neutral;
+        let primaryFromHost = false;
+        let neutralFromHost = false;
         if (storedColor && UI_COLORS.includes(storedColor)) {
           const h = COLOR_HUES[storedColor] ?? 0;
           userColor.value = `hsl(${h}, 70%, 75%)`;
           userColorName.value = storedColor;
+          primaryFromHost = true;
+        } else if (fromAppConfigPrimary && UI_COLORS.includes(fromAppConfigPrimary)) {
+          const h = COLOR_HUES[fromAppConfigPrimary] ?? 0;
+          userColor.value = `hsl(${h}, 70%, 75%)`;
+          userColorName.value = fromAppConfigPrimary;
+          primaryFromHost = true;
         } else {
           userColor.value = derived.hsl;
           userColorName.value = derived.name;
         }
         if (storedNeutral && UI_NEUTRALS.includes(storedNeutral)) {
           userNeutralColorName.value = storedNeutral;
+          neutralFromHost = true;
+        } else if (fromAppConfigNeutral && UI_NEUTRALS.includes(fromAppConfigNeutral)) {
+          userNeutralColorName.value = fromAppConfigNeutral;
+          neutralFromHost = true;
         } else {
           userNeutralColorName.value = derived.neutralName;
         }
         try {
-          const appConfig = useAppConfig();
           if (appConfig.ui?.colors) {
-            appConfig.ui.colors.primary = toNuxtUIPrimary(userColorName.value);
-            appConfig.ui.colors.neutral = toNuxtUINeutral(userNeutralColorName.value);
+            appConfig.ui.colors.primary = primaryFromHost || hostHasCustomPalette(userColorName.value) ? userColorName.value : toNuxtUIPrimary(userColorName.value);
+            appConfig.ui.colors.neutral = neutralFromHost || hostHasCustomPalette(userNeutralColorName.value) ? userNeutralColorName.value : toNuxtUINeutral(userNeutralColorName.value);
           }
         } catch {
         }
@@ -860,6 +919,24 @@ export default defineNuxtPlugin({
         const _client = new AbracadabraClient({ url: serverUrl, persistAuth, storageKey: authStorageKey });
         client.value = _client;
         addLog(`Server: ${serverUrl}`, "connection");
+        const tm = new TokenManager({
+          client: _client,
+          storage: new LocalStorageDeviceSessionStorage(`${authStorageKey}:device-session`)
+        });
+        _tokenManager = tm;
+        tm.on("refresh", () => addLog("JWT auto-refreshed via device session", "auth"));
+        tm.on("session-expired", () => {
+          addLog("Device session rejected \u2014 please re-authenticate", "auth");
+          if (identityState.value === "claimed") identityState.value = "needsReauth";
+        });
+        if (tm.hasSession && !_client.isTokenValid()) {
+          try {
+            await tm.bootstrap();
+            addLog("Refreshed JWT via stored device session", "auth");
+          } catch (e) {
+            addLog(`Device session refresh failed: ${e instanceof Error ? e.message : String(e)}`, "auth");
+          }
+        }
         let useExistingToken = _client.isTokenValid();
         if (useExistingToken) {
           try {
@@ -876,6 +953,7 @@ export default defineNuxtPlugin({
               }
               ;
               _client.token = null;
+              tm.clearSession();
               useExistingToken = false;
             }
           }
@@ -913,6 +991,23 @@ export default defineNuxtPlugin({
         }
         _client.updateMe({ displayName: userName.value }).catch(() => {
         });
+        if (_client.isTokenValid() && !tm.hasSession) {
+          try {
+            const sess = await _client.requestDeviceSession({
+              publicKey: pubKey,
+              deviceName: "Abracadabra Web (" + (navigator.platform || "Browser") + ")"
+            });
+            await tm.attachSession({
+              sessionId: sess.sessionId,
+              sessionToken: sess.sessionToken,
+              expiresAt: sess.expiresAt
+            });
+            addLog("Device session registered \u2014 JWT auto-refresh enabled", "auth");
+          } catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            addLog(`Device session unavailable: ${msg.slice(0, 80)}`, "auth");
+          }
+        }
         const [info, spaceDocs] = await Promise.all([
           fetchServerInfo(serverUrl),
           _client.listSpaces().catch((e) => {
@@ -967,6 +1062,12 @@ export default defineNuxtPlugin({
           document: _doc,
           websocketProvider: wsp,
           client: _client,
+          // Route every WS auth handshake (initial + reconnects) through
+          // the TokenManager so an expired JWT is silently refreshed via
+          // the device session before being sent. Without this, a tab
+          // left open past the 4 h JWT TTL ends up reconnecting forever
+          // with a dead token.
+          token: () => tm.getValidToken(),
           onStatus({ status: s }) {
             if (s === status.value) return;
             const oldStatus = status.value;

package/dist/runtime/plugin-registry.d.ts

@@ -1,34 +1,15 @@
-import type { Extension } from '@tiptap/core';
-import type { AbracadabraPlugin, AbracadabraPageType, AbracadabraToolbarItem, AbracadabraSuggestionItem, AbracadabraDragHandleItem, AbracadabraMentionProvider, AbracadabraAwarenessContribution, AbracadabraCommandItem, AbracadabraNodePanelSlot, AbracadabraSettingsPanel, AbracadabraKeyboardShortcut, EditorPluginCtx, DragHandlePluginCtx, CommandPaletteCtx } from './types.js';
 /**
- * PluginRegistry — manages the lifecycle of AbracadabraPlugin instances.
+ * The module's plugin registry — a thin wrapper around `@abraca/plugin`'s
+ * generic `PluginRegistry`, typed with `AbracadabraPlugin` so consumers get
+ * fully-typed aggregator returns (toolbar item type, page type, command
+ * palette item type, etc.) without casts.
  *
- * Instantiated once per Nuxt app inside the main client plugin.
- * After freezePluginRegistry() is called, no new plugins can be registered.
- * All aggregator methods are safe to call after freezing.
+ * The class extension is intentionally empty — all behaviour lives in the
+ * shared base. We re-export the class under the historical name so existing
+ * imports (`import { PluginRegistry } from './plugin-registry'`) keep
+ * resolving.
  */
-export declare class PluginRegistry {
-    private _plugins;
-    private _frozen;
-    register(plugin: AbracadabraPlugin): void;
-    /** Lock the registry. Called after all plugins (built-in + external) are loaded. */
-    freeze(): void;
-    isFrozen(): boolean;
-    getPlugins(): readonly AbracadabraPlugin[];
-    getAllExtensions(): Extension[];
-    /** Waits until all plugins with async extension bundles have finished loading. */
-    waitForExtensions(): Promise<void>;
-    getServerExtensions(): Extension[];
-    getAllPageTypes(): Record<string, AbracadabraPageType>;
-    getAllCustomHandlers(): Record<string, (...args: any[]) => any>;
-    getAllToolbarItems(ctx: EditorPluginCtx): AbracadabraToolbarItem[][];
-    getAllBubbleMenuItems(ctx: EditorPluginCtx): AbracadabraToolbarItem[][];
-    getAllSuggestionItems(ctx: EditorPluginCtx): AbracadabraSuggestionItem[][];
-    getAllDragHandleItems(ctx: DragHandlePluginCtx): AbracadabraDragHandleItem[][];
-    getAllMentionProviders(): AbracadabraMentionProvider[];
-    getAllAwarenessContributions(): AbracadabraAwarenessContribution[];
-    getAllCommandPaletteItems(ctx: CommandPaletteCtx): Promise<AbracadabraCommandItem[]>;
-    getAllNodePanelSlots(): AbracadabraNodePanelSlot[];
-    getSettingsPanels(): AbracadabraSettingsPanel[];
-    getAllKeyboardShortcuts(): AbracadabraKeyboardShortcut[];
+import { PluginRegistry as BasePluginRegistry } from '@abraca/plugin';
+import type { AbracadabraPlugin } from './types.js';
+export declare class PluginRegistry extends BasePluginRegistry<AbracadabraPlugin> {
 }

package/dist/runtime/plugin-registry.js

@@ -1,83 +1,3 @@
-export class PluginRegistry {
-  _plugins = [];
-  _frozen = false;
-  register(plugin) {
-    if (this._frozen) {
-      console.warn(`[abracadabra] Plugin registry frozen \u2014 cannot register "${plugin.name}"`);
-      return;
-    }
-    if (this._plugins.some((p) => p.name === plugin.name)) {
-      console.warn(`[abracadabra] Plugin "${plugin.name}" already registered`);
-      return;
-    }
-    this._plugins.push(plugin);
-  }
-  /** Lock the registry. Called after all plugins (built-in + external) are loaded. */
-  freeze() {
-    this._frozen = true;
-  }
-  isFrozen() {
-    return this._frozen;
-  }
-  getPlugins() {
-    return this._plugins;
-  }
-  // ── Aggregated getters ───────────────────────────────────────────────────────
-  getAllExtensions() {
-    return this._plugins.flatMap((p) => p.extensions?.() ?? []);
-  }
-  /** Waits until all plugins with async extension bundles have finished loading. */
-  async waitForExtensions() {
-    await Promise.all(this._plugins.map((p) => p.extensionsReady ?? Promise.resolve()));
-  }
-  getServerExtensions() {
-    return this._plugins.flatMap((p) => p.serverExtensions?.() ?? []);
-  }
-  getAllPageTypes() {
-    const merged = {};
-    for (const p of this._plugins) {
-      if (p.pageTypes) Object.assign(merged, p.pageTypes);
-    }
-    return merged;
-  }
-  getAllCustomHandlers() {
-    const merged = {};
-    for (const p of this._plugins) {
-      if (p.customHandlers) Object.assign(merged, p.customHandlers());
-    }
-    return merged;
-  }
-  getAllToolbarItems(ctx) {
-    return this._plugins.flatMap((p) => p.toolbarItems?.(ctx) ?? []);
-  }
-  getAllBubbleMenuItems(ctx) {
-    return this._plugins.flatMap((p) => p.bubbleMenuItems?.(ctx) ?? []);
-  }
-  getAllSuggestionItems(ctx) {
-    return this._plugins.flatMap((p) => p.suggestionItems?.(ctx) ?? []);
-  }
-  getAllDragHandleItems(ctx) {
-    return this._plugins.flatMap((p) => p.dragHandleItems?.(ctx) ?? []);
-  }
-  getAllMentionProviders() {
-    return this._plugins.flatMap((p) => p.mentionProviders ?? []);
-  }
-  getAllAwarenessContributions() {
-    return this._plugins.flatMap((p) => p.awarenessContributions ?? []);
-  }
-  async getAllCommandPaletteItems(ctx) {
-    const results = await Promise.all(
-      this._plugins.filter((p) => p.commandPaletteItems).map((p) => Promise.resolve(p.commandPaletteItems(ctx)))
-    );
-    return results.flat().filter((item) => !item.when || item.when(ctx));
-  }
-  getAllNodePanelSlots() {
-    return this._plugins.flatMap((p) => p.nodePanelSlots ?? []);
-  }
-  getSettingsPanels() {
-    return this._plugins.flatMap((p) => p.settingsPanel ? [p.settingsPanel] : []);
-  }
-  getAllKeyboardShortcuts() {
-    return this._plugins.flatMap((p) => p.keyboardShortcuts ?? []);
-  }
+import { PluginRegistry as BasePluginRegistry } from "@abraca/plugin";
+export class PluginRegistry extends BasePluginRegistry {
 }

package/dist/runtime/plugins/core.plugin.js

@@ -16,7 +16,9 @@ const OPTIONAL_BUILTIN_EXTENSIONS = /* @__PURE__ */ new Set([
   "mathBlock",
   "mathInline",
   "diff",
-  "svgEmbed"
+  "svgEmbed",
+  "timeline",
+  "timelineItem"
 ]);
 async function loadClientExtensions() {
   const [
@@ -73,7 +75,8 @@ async function loadClientExtensions() {
     { ColorSwatch },
     { MathBlock, MathInline },
     { Diff },
-    { SvgEmbed }
+    { SvgEmbed },
+    { Timeline, TimelineItem }
   ] = await Promise.all([
     import("@tiptap/extension-task-list"),
     import("@tiptap/extension-task-item"),
@@ -128,7 +131,8 @@ async function loadClientExtensions() {
     import("../extensions/color-swatch.js"),
     import("../extensions/math.js"),
     import("../extensions/diff.js"),
-    import("../extensions/svg-embed.js")
+    import("../extensions/svg-embed.js"),
+    import("../extensions/timeline.js")
   ]);
   const lowlight = createLowlight(common);
   const extensions = [
@@ -202,7 +206,9 @@ async function loadClientExtensions() {
     MathBlock,
     MathInline,
     Diff,
-    SvgEmbed
+    SvgEmbed,
+    Timeline,
+    TimelineItem
   ];
   try {
     const emojiPkg = "@tiptap/extension-emoji";

package/dist/runtime/server/api/_abracadabra/spaces.get.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<Omit<import("h3").EventHandlerRequest, "body">, Promise<never[] | unknown[]>>;
+declare const _default: import("h3").EventHandler<Omit<import("h3").EventHandlerRequest, "body">, Promise<unknown[] | never[]>>;
 export default _default;

package/dist/runtime/server/plugins/abracadabra-service.js

@@ -4,6 +4,7 @@ import { useStorage } from "nitropack/runtime/storage";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { registerServerPlugin, bootRunners, shutdownAllRunners } from "../utils/serverRunner.js";
+import { buildServerSchemaValidator } from "../utils/schemaServerSupport.js";
 import { createDocCacheAPI } from "../utils/docCache.js";
 import { docTreeCacheRunner } from "../runners/doc-tree-cache.js";
 import { initSlugMap, loadPersistedSlugMap } from "../utils/slugMap.js";
@@ -212,7 +213,34 @@ export default defineNitroPlugin(async (nitroApp) => {
       };
       registerServerPlugin(coreServerPlugin);
     }
+    const attachedSchemas = [];
+    const schemaCfg = publicConfig?.schema ?? {};
+    if (schemaCfg.bundleDir) {
+      console.log(
+        `[abracadabra-service] schema bundle_dir advertised: ${schemaCfg.bundleDir} (server-side bundle_dir = same path; informational only \u2014 server is authoritative)`
+      );
+    }
+    Object.assign(ctx, {
+      attachSchema: (registry) => {
+        if (!registry || typeof registry !== "object") return;
+        if (typeof registry.validateMeta !== "function") {
+          console.warn("[abracadabra-service] attachSchema received a value missing validateMeta() \u2014 skipping");
+          return;
+        }
+        attachedSchemas.push(registry);
+      }
+    });
     await nitroApp.hooks.callHook("abracadabra:before-runners", ctx);
+    delete ctx.attachSchema;
+    if (attachedSchemas.length > 0) {
+      const validator = buildServerSchemaValidator(attachedSchemas);
+      if (validator) ctx.validateMeta = validator;
+      const advertisedTypes = /* @__PURE__ */ new Set();
+      for (const r of attachedSchemas) for (const t of r.types.keys()) advertisedTypes.add(t);
+      console.log(
+        `[abracadabra-service] ${attachedSchemas.length} schema registr${attachedSchemas.length === 1 ? "y" : "ies"} attached covering types: [${[...advertisedTypes].sort().join(", ")}]`
+      );
+    }
     await bootRunners(ctx);
     console.log("[abracadabra-service] All runners started");
     nitroApp.hooks.hook("close", async () => {

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

@@ -7,15 +7,36 @@ export function initDocCache(storage, extraExtensions = []) {
   _storage = storage;
   _extensions = extraExtensions;
 }
+let _serverDoc = null;
+async function getServerDoc() {
+  if (_serverDoc) return _serverDoc;
+  const happyDom = await import("happy-dom");
+  const Window = happyDom.Window ?? happyDom.default?.Window;
+  if (!Window) {
+    throw new Error("happy-dom did not export Window \u2014 install happy-dom or use the legacy DOM-global path.");
+  }
+  _serverDoc = new Window().document;
+  return _serverDoc;
+}
 async function renderDocToHTML(ydoc) {
   try {
-    const [{ generateHTML }, { yDocToProsemirrorJSON }, { default: StarterKit }] = await Promise.all([
+    const [{ getSchema }, { yDocToProsemirrorJSON }, { default: StarterKit }, { Node, DOMSerializer }] = await Promise.all([
       import("@tiptap/core"),
       import("@tiptap/y-tiptap"),
-      import("@tiptap/starter-kit")
+      import("@tiptap/starter-kit"),
+      import("prosemirror-model")
     ]);
+    const schema = getSchema([StarterKit, ..._extensions]);
     const json = yDocToProsemirrorJSON(ydoc, "default");
-    return generateHTML(json, [StarterKit, ..._extensions]);
+    const node = Node.fromJSON(schema, json);
+    const serverDoc = await getServerDoc();
+    const container = serverDoc.createElement("div");
+    DOMSerializer.fromSchema(schema).serializeFragment(
+      node.content,
+      { document: serverDoc },
+      container
+    );
+    return container.innerHTML;
   } catch (e) {
     console.warn("[abracadabra:doc-cache] HTML render failed:", e);
     return null;

package/dist/runtime/server/utils/schemaServerSupport.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Server-side mirror of `runtime/utils/schemaSupport.ts`.
+ *
+ * Reuses the same dynamic-import pattern so a Nitro service plugin can
+ * advertise + delegate to `@abraca/schema` registries without forcing
+ * the package onto consumers that never opt in (Rule 2). Importing
+ * from `runtime/utils/schemaSupport.ts` directly would pull in browser-
+ * leaning client-side state (`shallowRef`, the Vue cache); this file
+ * is a thin Nitro-only re-implementation with no Vue dependency.
+ */
+/** Structural shape of a `@abraca/schema` SchemaRegistry. */
+export interface SchemaRegistryLike<TMap = Record<string, unknown>> {
+    readonly types: ReadonlyMap<string, unknown>;
+    get: (name: string) => unknown;
+    validateMeta: (name: string, value: unknown) => ValidationResultLike;
+    validateChildType: (parent: string | null, child: string) => ValidationResultLike;
+    readonly __metaMap?: TMap;
+}
+export type ValidationResultLike = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    errors: ReadonlyArray<{
+        path: ReadonlyArray<PropertyKey>;
+        message: string;
+        code?: string;
+    }>;
+};
+/** Subset of the `@abraca/schema` public surface the server needs at runtime. */
+export interface ServerSchemaModule {
+    defineSchema: (spec: {
+        types: ReadonlyArray<unknown>;
+    }) => SchemaRegistryLike;
+    defineDocType: (spec: unknown) => unknown;
+    runMigrations: (registry: SchemaRegistryLike, typeName: string, meta: unknown) => unknown;
+}
+/**
+ * Resolve `@abraca/schema` if it is installed alongside the Nuxt app.
+ *
+ * Returns `null` (and warns once) when the package is missing or fails
+ * to import. Caches the result; subsequent calls reuse it.
+ */
+export declare function tryLoadServerSchemaModule(): Promise<ServerSchemaModule | null>;
+/**
+ * Build a merged "first-registry-wins" validator from a list of attached
+ * registries. Returns null when no registries provide a matching type
+ * (Rule 4: pass-through for unknown doc-types).
+ */
+export declare function buildServerSchemaValidator(registries: ReadonlyArray<SchemaRegistryLike>): ((typeName: string, meta: unknown) => ValidationResultLike) | null;
+/** Test-only — reset the cached resolution. */
+export declare function __resetServerSchemaSupportCacheForTests(): void;

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

@@ -0,0 +1,51 @@
+let cached;
+let loading = null;
+let warned = false;
+export async function tryLoadServerSchemaModule() {
+  if (cached !== void 0) return cached;
+  if (loading) return loading;
+  loading = (async () => {
+    try {
+      const mod = await import("@abraca/schema");
+      const candidate = {
+        defineSchema: mod.defineSchema,
+        defineDocType: mod.defineDocType,
+        runMigrations: mod.runMigrations
+      };
+      if (typeof candidate.defineSchema !== "function" || typeof candidate.defineDocType !== "function" || typeof candidate.runMigrations !== "function") {
+        throw new TypeError("unexpected @abraca/schema shape \u2014 missing one of defineSchema / defineDocType / runMigrations");
+      }
+      cached = candidate;
+      return cached;
+    } catch (err) {
+      if (!warned) {
+        warned = true;
+        const reason = err instanceof Error ? err.message : String(err);
+        console.warn(
+          `[abracadabra-service] schema integration requested but @abraca/schema could not be loaded \u2014 install it as a peer dependency to enable server-side typed surfaces (${reason})`
+        );
+      }
+      cached = null;
+      return null;
+    } finally {
+      loading = null;
+    }
+  })();
+  return loading;
+}
+export function buildServerSchemaValidator(registries) {
+  if (registries.length === 0) return null;
+  return (typeName, meta) => {
+    for (const r of registries) {
+      if (r.types.has(typeName)) {
+        return r.validateMeta(typeName, meta);
+      }
+    }
+    return { ok: true, value: meta };
+  };
+}
+export function __resetServerSchemaSupportCacheForTests() {
+  cached = void 0;
+  loading = null;
+  warned = false;
+}