@abraca/nuxt 2.0.10 → 2.3.0

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;
+}

package/dist/runtime/types.d.ts

@@ -1,49 +1,39 @@
 import type { ShallowRef, Ref, Component } from 'vue';
-import type { Extension } from '@tiptap/core';
 import type { Editor } from '@tiptap/vue-3';
 import type { Node as ProsemirrorNode } from '@tiptap/pm/model';
 import type * as Y from 'yjs';
 import type { AbracadabraClient, AbracadabraProvider, AbracadabraWS, CryptoIdentityKeystore } from '@abraca/dabra';
 import type { Router } from 'vue-router';
+import type { AbraPlugin, AbraAwarenessContribution as BaseAbraAwarenessContribution, AbraNodePanelSlot as BaseAbraNodePanelSlot, AbraSettingsPanel as BaseAbraSettingsPanel, AbraKeyboardShortcut as BaseAbraKeyboardShortcut, AbraMentionItem } from '@abraca/plugin';
 /**
  * An Abracadabra plugin contributes editor extensions, page types, toolbar items,
  * slash commands, mentions, awareness fields, command palette items, and more.
  *
  * Plugins are registered before the registry is frozen at boot.
  * After freezing all contributions are stable for the lifetime of the app.
+ *
+ * `AbracadabraPlugin` is a tightened alias of `@abraca/plugin`'s universal
+ * `AbraPlugin` — same shape, but contribution fields are narrowed to the
+ * module's concrete types (`AbracadabraToolbarItem`, `AbracadabraPageType`,
+ * `AbracadabraState`-aware setup context, etc.).
  */
-export interface AbracadabraPlugin {
-    /** Unique slug — must be stable across versions, e.g. 'core', 'kanban', 'my-plugin' */
-    name: string;
-    label?: string;
-    version?: string;
-    description?: string;
-    /** TipTap extensions (nodes, marks, extensions) contributed by this plugin */
-    extensions?: () => Extension[];
-    /**
-     * Optional promise that resolves when this plugin's extensions are fully
-     * loaded. Used by PluginRegistry.waitForExtensions() to ensure the editor
-     * doesn't initialize before async extension bundles are ready.
-     */
-    extensionsReady?: Promise<void>;
+export interface AbracadabraPlugin extends AbraPlugin {
     /** Document/page type renderers keyed by type slug */
     pageTypes?: Record<string, AbracadabraPageType>;
     /** Extra toolbar item groups appended after the built-in toolbar groups */
-    toolbarItems?: (ctx: EditorPluginCtx) => AbracadabraToolbarItem[][];
+    toolbarItems?(ctx: EditorPluginCtx): AbracadabraToolbarItem[][];
     /** Extra bubble menu item groups (appear on text selection) */
-    bubbleMenuItems?: (ctx: EditorPluginCtx) => AbracadabraToolbarItem[][];
+    bubbleMenuItems?(ctx: EditorPluginCtx): AbracadabraToolbarItem[][];
     /** Slash command (/) suggestion menu item groups */
-    suggestionItems?: (ctx: EditorPluginCtx) => AbracadabraSuggestionItem[][];
+    suggestionItems?(ctx: EditorPluginCtx): AbracadabraSuggestionItem[][];
     /** Extra drag-handle menu items (per-block context menu) */
-    dragHandleItems?: (ctx: DragHandlePluginCtx) => AbracadabraDragHandleItem[][];
-    /** Custom editor handlers merged into UEditorCustomHandlers */
-    customHandlers?: () => Record<string, (...args: unknown[]) => unknown>;
+    dragHandleItems?(ctx: DragHandlePluginCtx): AbracadabraDragHandleItem[][];
     /** Mention (@) providers contributing items to the mention popup */
     mentionProviders?: AbracadabraMentionProvider[];
     /** Awareness field declarations — keys this plugin reads/writes on awareness */
     awarenessContributions?: AbracadabraAwarenessContribution[];
     /** Global command palette (⌘K) items */
-    commandPaletteItems?: (ctx: CommandPaletteCtx) => AbracadabraCommandItem[] | Promise<AbracadabraCommandItem[]>;
+    commandPaletteItems?(ctx: CommandPaletteCtx): AbracadabraCommandItem[] | Promise<AbracadabraCommandItem[]>;
     /** Extra tabs rendered in the child document slideover panel */
     nodePanelSlots?: AbracadabraNodePanelSlot[];
     /** Settings panel contributed to the global settings view */
@@ -54,14 +44,7 @@ export interface AbracadabraPlugin {
      * Client-side setup hook — called once after client + provider are ready.
      * May return a teardown function called on app unmount.
      */
-    clientSetup?: (ctx: ClientPluginCtx) => undefined | Promise<undefined | (() => void)>;
-    /** TipTap extensions safe for server-side Y.Doc → HTML rendering (no Vue NodeViews) */
-    serverExtensions?: () => Extension[];
-    /**
-     * Custom cache renderer for non-doc page types.
-     * Receives the Y.Doc and returns serializable data for the cache.
-     */
-    serverCacheRenderer?: (docId: string, ydoc: Y.Doc) => unknown;
+    clientSetup?(ctx: ClientPluginCtx): undefined | Promise<undefined | (() => void)>;
     /**
      * Server-side background runners (Nitro context).
      * Each runner receives a ServerRunnerContext and returns a cleanup function.
@@ -165,37 +148,32 @@ export interface AbracadabraCommandItem {
     icon?: string;
     group?: string;
     shortcut?: string;
-    when?: (ctx: CommandPaletteCtx) => boolean;
-    handler: (ctx: CommandPaletteCtx) => void | Promise<void>;
+    when?(ctx: CommandPaletteCtx): boolean;
+    handler(ctx: CommandPaletteCtx): void | Promise<void>;
 }
 export interface AbracadabraMentionProvider {
     /** Group label shown in the suggestion popup */
     label: string;
-    getItems: (query: string, ctx: MentionPluginCtx) => AbracadabraMentionItem[] | Promise<AbracadabraMentionItem[]>;
+    getItems(query: string, ctx: MentionPluginCtx): AbracadabraMentionItem[] | Promise<AbracadabraMentionItem[]>;
 }
 export interface MentionPluginCtx {
     docId: string;
     connectedUsers: CollaborationUser[];
     rootDoc: Y.Doc;
 }
-export interface AbracadabraMentionItem {
-    id: string;
-    label: string;
-    avatar?: string;
-    color?: string;
-    attrs?: Record<string, unknown>;
-}
-export interface AbracadabraAwarenessContribution {
+/** Module-level alias of `AbraMentionItem` for callers that import from `@abraca/nuxt`. */
+export type AbracadabraMentionItem = AbraMentionItem;
+export interface AbracadabraAwarenessContribution extends BaseAbraAwarenessContribution {
     /** Namespaced keys this plugin writes, e.g. ['cursor', 'presence:kanban'] */
     keys: string[];
     /** Optional per-canvas cursor overlay component */
     cursorComponent?: Component;
 }
-export interface AbracadabraNodePanelSlot {
+export interface AbracadabraNodePanelSlot extends Omit<BaseAbraNodePanelSlot, 'when' | 'component'> {
     id: string;
     label: string;
     icon: string;
-    when: (ctx: NodePanelCtx) => boolean;
+    when(ctx: NodePanelCtx): boolean;
     component: Component;
 }
 export interface NodePanelCtx {
@@ -206,12 +184,12 @@ export interface NodePanelCtx {
     meta: Record<string, unknown>;
     tree: DocTreeHelper;
 }
-export interface AbracadabraSettingsPanel {
+export interface AbracadabraSettingsPanel extends Omit<BaseAbraSettingsPanel, 'component'> {
     label: string;
     icon: string;
     component: Component;
 }
-export interface AbracadabraKeyboardShortcut {
+export interface AbracadabraKeyboardShortcut extends BaseAbraKeyboardShortcut {
     /** e.g. 'Meta+Shift+K', 'Control+Alt+P' */
     key: string;
     description: string;
@@ -577,6 +555,45 @@ export interface ServerRunnerContext {
     storage: NitroStorage;
     /** Document cache API: read/write HTML+JSON renders, build tree snapshots */
     docCache: DocCacheAPI;
+    /**
+     * Pre-write meta validator built from any `@abraca/schema` registries
+     * Nitro plugins attached via `BeforeRunnersCtx.attachSchema(...)` during
+     * the `abracadabra:before-runners` hook. `undefined` when no plugin
+     * attached a registry — runners must short-circuit on `undefined`
+     * rather than treating absence as "all writes are invalid" (Rule 4).
+     *
+     * Returns `{ ok: true, value }` for unknown doc-types — the validator
+     * mirrors the server's bundle_path / bundle_dir skip-on-collision rule.
+     */
+    validateMeta?: (typeName: string, meta: unknown) => {
+        ok: true;
+        value?: unknown;
+    } | {
+        ok: false;
+        errors: ReadonlyArray<{
+            path: ReadonlyArray<PropertyKey>;
+            message: string;
+            code?: string;
+        }>;
+    };
+}
+/**
+ * Payload of the `abracadabra:before-runners` Nitro hook. Plugins can
+ * register runners (`registerServerPlugin(plugin)`) and/or attach
+ * `@abraca/schema` registries (`attachSchema(registry)`) before the
+ * runner boot fires.
+ */
+export interface BeforeRunnersCtx extends ServerRunnerContext {
+    /**
+     * Attach a SchemaRegistry. Multiple calls accumulate. Validators are
+     * built in attach order — the first registry that recognises a type
+     * wins. Mirrors the server's bundle_path / bundle_dir behaviour.
+     *
+     * Available even when `@abraca/schema` is not installed — just collects
+     * the references for downstream `validateMeta` wiring; if no module
+     * is present the cumulative validator is still safe to call.
+     */
+    attachSchema?: (registry: import('./server/utils/schemaServerSupport').SchemaRegistryLike) => void;
 }
 /**
  * A named background task that runs inside the Nitro server process.
@@ -584,7 +601,7 @@ export interface ServerRunnerContext {
  */
 export interface ServerRunnerDefinition {
     name: string;
-    start: (ctx: ServerRunnerContext) => Promise<RunnerCleanup>;
+    start(ctx: ServerRunnerContext): Promise<RunnerCleanup>;
 }
 /**
  * API surface for reading/writing cached document renders.

package/dist/runtime/utils/docTypes.d.ts

@@ -148,6 +148,21 @@ export interface DocTypeDefinition {
     grandchildLabel?: string;
     /** Metadata fields shown/edited in the document properties panel. */
     metaSchema?: MetaField[];
+    /**
+     * Optional `@abraca/schema` registry that governs the data shape of
+     * this doc-type's `meta` field. Orthogonal to `metaSchema` (UI-form
+     * declarations) — `dataSchema` is the wire-level validator surface.
+     *
+     * When set, renderers can read with `useDocEntryTyped(id, dataSchema, key)`
+     * and write through `useTypedDoc(dataSchema)` to get type-narrowed
+     * meta and pre-write validation. Built-in `DOC_TYPES` records leave
+     * this undefined — apps wire it themselves so the canonical schemas
+     * stay opt-in (Rule 2).
+     *
+     * Typed as `SchemaRegistryLike` (structural, no static peer-dep
+     * import) so this file stays buildable without `@abraca/schema`.
+     */
+    dataSchema?: import('./schemaSupport').SchemaRegistryLike;
 }
 /**
  * Per-geoType meta schemas. Used by AEditor to show the right fields

package/dist/runtime/utils/docTypes.js

@@ -81,6 +81,26 @@ export const DOC_TYPES = {
       () => import("../components/renderers/AProseRenderer.vue")
     )
   },
+  code: {
+    key: "code",
+    label: "Code",
+    icon: "i-lucide-code-2",
+    description: "Collaborative plain-text code editor with syntax highlighting",
+    available: true,
+    hasEditor: false,
+    supportsChildren: false,
+    component: defineDocComponent(
+      () => import("../components/renderers/ACodeRenderer.vue")
+    ),
+    metaSchema: [
+      {
+        type: "select",
+        key: "language",
+        options: ["javascript", "typescript", "tsx", "jsx", "css", "vue", "json", "markdown", "plain"],
+        label: "Language"
+      }
+    ]
+  },
   kanban: {
     key: "kanban",
     label: "Kanban",

package/dist/runtime/utils/loadCodeMirror.d.ts

@@ -0,0 +1,32 @@
+/**
+ * loadCodeMirror — try-import the CodeMirror peer dependencies.
+ *
+ * Returns a bundle of the modules needed by <ACodeEditor> if the consumer
+ * installed them, or `null` if any required package is missing. Cached after
+ * the first call; the first failed lookup logs once in dev.
+ *
+ * Required peers: codemirror, @codemirror/state, @codemirror/view,
+ * @codemirror/language, @codemirror/commands, @codemirror/autocomplete,
+ * @codemirror/search, @codemirror/lang-javascript, @codemirror/lang-css,
+ * @codemirror/lang-vue, @codemirror/lang-json, y-codemirror.next.
+ *
+ * Apps that want code editing install:
+ *   pnpm add codemirror @codemirror/state @codemirror/view @codemirror/language \
+ *            @codemirror/commands @codemirror/autocomplete @codemirror/search \
+ *            @codemirror/lang-javascript @codemirror/lang-css @codemirror/lang-vue \
+ *            @codemirror/lang-json y-codemirror.next
+ */
+export interface CodeMirrorBundle {
+    view: typeof import('@codemirror/view');
+    state: typeof import('@codemirror/state');
+    language: typeof import('@codemirror/language');
+    commands: typeof import('@codemirror/commands');
+    autocomplete: typeof import('@codemirror/autocomplete');
+    search: typeof import('@codemirror/search');
+    langJavascript: typeof import('@codemirror/lang-javascript');
+    langCss: typeof import('@codemirror/lang-css');
+    langVue: typeof import('@codemirror/lang-vue');
+    langJson: typeof import('@codemirror/lang-json');
+    yCollab: typeof import('y-codemirror.next');
+}
+export declare function loadCodeMirror(): Promise<CodeMirrorBundle | null>;

package/dist/runtime/utils/loadCodeMirror.js

@@ -0,0 +1,65 @@
+let cache = null;
+let loading = null;
+let warnedMissing = false;
+export async function loadCodeMirror() {
+  if (cache) return cache;
+  if (loading) return loading;
+  loading = (async () => {
+    try {
+      const names = [
+        "@codemirror/view",
+        "@codemirror/state",
+        "@codemirror/language",
+        "@codemirror/commands",
+        "@codemirror/autocomplete",
+        "@codemirror/search",
+        "@codemirror/lang-javascript",
+        "@codemirror/lang-css",
+        "@codemirror/lang-vue",
+        "@codemirror/lang-json",
+        "y-codemirror.next"
+      ];
+      const [
+        view,
+        state,
+        language,
+        commands,
+        autocomplete,
+        search,
+        langJavascript,
+        langCss,
+        langVue,
+        langJson,
+        yCollab
+      ] = await Promise.all(names.map((n) => import(
+        /* @vite-ignore */
+        n
+      )));
+      cache = {
+        view,
+        state,
+        language,
+        commands,
+        autocomplete,
+        search,
+        langJavascript,
+        langCss,
+        langVue,
+        langJson,
+        yCollab
+      };
+      return cache;
+    } catch {
+      if (import.meta.dev && !warnedMissing) {
+        warnedMissing = true;
+        console.warn(
+          "[abracadabra] CodeMirror peer dependencies not installed. Code page type will fall back to a read-only <textarea>. Install: pnpm add codemirror @codemirror/state @codemirror/view @codemirror/language @codemirror/commands @codemirror/autocomplete @codemirror/search @codemirror/lang-javascript @codemirror/lang-css @codemirror/lang-vue @codemirror/lang-json y-codemirror.next"
+        );
+      }
+      return null;
+    } finally {
+      loading = null;
+    }
+  })();
+  return loading;
+}

package/dist/runtime/utils/markdownToYjs.d.ts

@@ -1,23 +1 @@
-/**
- * markdownToYjs.ts
- *
- * Parses markdown and populates a Y.XmlFragment with TipTap-compatible nodes.
- * Also provides YAML frontmatter parsing and filename → label conversion.
- *
- * Ported from cou-sh/app/utils/markdownToYjs.ts
- */
-import * as Y from 'yjs';
-import type { DocPageMeta } from '../types.js';
-export declare function filenameToLabel(raw: string): string;
-export interface FrontmatterResult {
-    title?: string;
-    type?: string;
-    meta: Partial<DocPageMeta>;
-    body: string;
-}
-export declare function parseFrontmatter(markdown: string): FrontmatterResult;
-/**
- * Parses markdown and writes content into a Y.XmlFragment.
- * The fragment must already be attached to a live Y.Doc.
- */
-export declare function populateYDocFromMarkdown(fragment: Y.XmlFragment, markdown: string, fallbackTitle?: string): void;
+export { filenameToLabel, parseFrontmatter, populateYDocFromMarkdown, type FrontmatterResult, } from '@abraca/convert';