@abraca/nuxt 2.0.10 → 2.3.0

package/dist/runtime/components/renderers/AProseRenderer.d.vue.ts

@@ -10,14 +10,14 @@ type __VLS_Props = {
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, Record<PropertyKey, unknown>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     rename: (label: string) => any;
+    ready: () => any;
     update: (content: any) => any;
     updateMeta: (patch: Partial<DocPageMeta>) => any;
-    ready: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onRename?: ((label: string) => any) | undefined;
+    onReady?: (() => any) | undefined;
     onUpdate?: ((content: any) => any) | undefined;
     onUpdateMeta?: ((patch: Partial<DocPageMeta>) => any) | undefined;
-    onReady?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/renderers/AProseRenderer.vue.d.ts

@@ -10,14 +10,14 @@ type __VLS_Props = {
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, Record<PropertyKey, unknown>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     rename: (label: string) => any;
+    ready: () => any;
     update: (content: any) => any;
     updateMeta: (patch: Partial<DocPageMeta>) => any;
-    ready: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onRename?: ((label: string) => any) | undefined;
+    onReady?: (() => any) | undefined;
     onUpdate?: ((content: any) => any) | undefined;
     onUpdateMeta?: ((patch: Partial<DocPageMeta>) => any) | undefined;
-    onReady?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/shell/ABreadcrumbForDoc.d.vue.ts

@@ -0,0 +1,11 @@
+type __VLS_Props = {
+    /** Document ID at the leaf of the breadcrumb */
+    docId: string | null | undefined;
+    /** Maximum ancestors to walk (default 8) */
+    maxDepth?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    maxDepth: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/shell/ABreadcrumbForDoc.vue

@@ -0,0 +1,16 @@
+<script setup>
+import { useDocBreadcrumb } from "../../composables/useDocBreadcrumb";
+const props = defineProps({
+  docId: { type: null, required: true },
+  maxDepth: { type: Number, required: false, default: 8 }
+});
+const { items } = useDocBreadcrumb(() => props.docId, { maxDepth: props.maxDepth });
+</script>
+
+<template>
+  <UBreadcrumb
+    v-if="items.length > 0"
+    :items="items"
+    :ui="{ root: 'min-w-0', list: 'min-w-0 flex-nowrap', item: 'truncate', link: 'truncate' }"
+  />
+</template>

package/dist/runtime/components/shell/ABreadcrumbForDoc.vue.d.ts

@@ -0,0 +1,11 @@
+type __VLS_Props = {
+    /** Document ID at the leaf of the breadcrumb */
+    docId: string | null | undefined;
+    /** Maximum ancestors to walk (default 8) */
+    maxDepth?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    maxDepth: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/shell/ASettingsSection.d.vue.ts

@@ -0,0 +1,35 @@
+/**
+ * Settings section primitive — heading + description + actions slot + content.
+ *
+ * Provides a consistent section pattern for settings pages and panels.
+ * Pairs with ASettingsPanel*'s row-style components but is also useful
+ * standalone for custom settings layouts.
+ *
+ * Slots:
+ *  - `default`: section content
+ *  - `description`: rich description (overrides `description` prop)
+ *  - `actions`: top-right inline actions (button, switch, etc.)
+ */
+type __VLS_Props = {
+    /** Section title rendered as <h3> */
+    title: string;
+    /** Optional description rendered under the title */
+    description?: string;
+};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
+type __VLS_Slots = {} & {
+    actions?: (props: typeof __VLS_1) => any;
+} & {
+    description?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/shell/ASettingsSection.vue

@@ -0,0 +1,26 @@
+<script setup>
+defineProps({
+  title: { type: String, required: true },
+  description: { type: String, required: false }
+});
+</script>
+
+<template>
+  <section class="space-y-3">
+    <header class="space-y-1">
+      <div class="flex items-center justify-between gap-3">
+        <h3 class="text-sm font-semibold text-(--ui-text-highlighted)">
+          {{ title }}
+        </h3>
+        <slot name="actions" />
+      </div>
+      <p
+        v-if="description || $slots.description"
+        class="text-xs text-(--ui-text-muted)"
+      >
+        <slot name="description">{{ description }}</slot>
+      </p>
+    </header>
+    <slot />
+  </section>
+</template>

package/dist/runtime/components/shell/ASettingsSection.vue.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Settings section primitive — heading + description + actions slot + content.
+ *
+ * Provides a consistent section pattern for settings pages and panels.
+ * Pairs with ASettingsPanel*'s row-style components but is also useful
+ * standalone for custom settings layouts.
+ *
+ * Slots:
+ *  - `default`: section content
+ *  - `description`: rich description (overrides `description` prop)
+ *  - `actions`: top-right inline actions (button, switch, etc.)
+ */
+type __VLS_Props = {
+    /** Section title rendered as <h3> */
+    title: string;
+    /** Optional description rendered under the title */
+    description?: string;
+};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
+type __VLS_Slots = {} & {
+    actions?: (props: typeof __VLS_1) => any;
+} & {
+    description?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/shell/ASidebar.d.vue.ts

@@ -39,8 +39,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
     "onUpdate:collapsed"?: ((value: boolean) => any) | undefined;
 }>, {
-    width: number;
     open: boolean;
+    width: number;
     collapsed: boolean;
     collapsedWidth: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/shell/ASidebar.vue.d.ts

@@ -39,8 +39,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
     "onUpdate:collapsed"?: ((value: boolean) => any) | undefined;
 }>, {
-    width: number;
     open: boolean;
+    width: number;
     collapsed: boolean;
     collapsedWidth: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/shell/AUserMenu.d.vue.ts

@@ -8,6 +8,8 @@ type __VLS_Props = {
     avatarStyle?: string;
     /** Whether sidebar is collapsed */
     collapsed?: boolean;
+    /** Optional secondary line under the name in the menu header (e.g. "Connected · 3 peers") */
+    statusLabel?: string;
     /** Extra menu items prepended before default actions */
     extraItems?: DropdownMenuItem[][];
 };
@@ -23,6 +25,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     color: string;
     collapsed: boolean;
     avatarStyle: string;
+    statusLabel: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/shell/AUserMenu.vue

@@ -5,6 +5,7 @@ const props = defineProps({
   color: { type: String, required: false, default: "" },
   avatarStyle: { type: String, required: false, default: "" },
   collapsed: { type: Boolean, required: false, default: false },
+  statusLabel: { type: String, required: false, default: "" },
   extraItems: { type: Array, required: false }
 });
 const emit = defineEmits(["open-settings", "open-account", "logout"]);
@@ -16,6 +17,9 @@ const items = computed(() => {
       disabled: true
     }
   ];
+  if (props.statusLabel) {
+    userGroup.push({ type: "label", label: props.statusLabel });
+  }
   const actionGroup = [
     {
       label: "Account",

package/dist/runtime/components/shell/AUserMenu.vue.d.ts

@@ -8,6 +8,8 @@ type __VLS_Props = {
     avatarStyle?: string;
     /** Whether sidebar is collapsed */
     collapsed?: boolean;
+    /** Optional secondary line under the name in the menu header (e.g. "Connected · 3 peers") */
+    statusLabel?: string;
     /** Extra menu items prepended before default actions */
     extraItems?: DropdownMenuItem[][];
 };
@@ -23,6 +25,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     color: string;
     collapsed: boolean;
     avatarStyle: string;
+    statusLabel: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -0,0 +1,83 @@
+/**
+ * useAbracadabraSchema — registry handle + opt-in validator surface.
+ *
+ * Day 2 of the Phase 3 schema rollout. The Nuxt module never imports
+ * `@abraca/schema` statically — see `loadKatex.ts` / `schemaSupport.ts`
+ * for the rationale (Rule 1: core stays schema-free).
+ *
+ * Apps attach a `SchemaRegistry` (typically the result of
+ * `defineSchema({ types: [Kanban, Calendar, ...] })` from `@abraca/schema`,
+ * but any value satisfying `SchemaRegistryLike` works) via the Nuxt
+ * `abracadabra:before-boot` hook, e.g.:
+ *
+ *     // app/plugins/abracadabra-schemas.client.ts
+ *     import { defineSchema, Kanban, Calendar, Doc } from '@abraca/schema'
+ *     export default defineNuxtPlugin(nuxtApp => {
+ *       nuxtApp.hook('abracadabra:before-boot', (ctx) => {
+ *         ctx.attachSchema(defineSchema({ types: [Kanban, Calendar, Doc] }))
+ *       })
+ *     })
+ *
+ * The first attached registry wins for type narrowing; subsequent
+ * registries are merged into the same validator-set so multiple
+ * boot-time plugins can each contribute their own schemas.
+ */
+import { type ComputedRef } from 'vue';
+import { useNuxtApp } from '#imports';
+import type { SchemaRegistryLike, ValidationResultLike } from '../utils/schemaSupport.js';
+import type { AbracadabraPlugin } from '../types.js';
+export type { SchemaRegistryLike, ValidationResultLike };
+/**
+ * Hook payload for `abracadabra:before-boot`. Exposed so consumer
+ * plugins can declare their hook signatures with confidence.
+ */
+export interface BeforeBootCtx {
+    /** Attach a schema registry. Multiple calls accumulate. */
+    attachSchema: (registry: SchemaRegistryLike) => void;
+    /**
+     * Attach an inline AbracadabraPlugin. Lets host apps contribute
+     * mention providers, extensions, suggestion items, etc. without
+     * the external-plugin URL-loader dance. Multiple calls accumulate.
+     */
+    attachPlugin: (plugin: AbracadabraPlugin) => void;
+}
+declare module '#app' {
+    interface RuntimeNuxtHooks {
+        'abracadabra:before-boot': (ctx: BeforeBootCtx) => void | Promise<void>;
+    }
+}
+/**
+ * Internal: collect-and-store registries from the boot hook. Called once
+ * by `plugin-abracadabra.client.ts` before the provider is wired.
+ *
+ * Stored on `nuxtApp` (request-scoped) so multiple roots / SSR workers
+ * don't share state.
+ */
+export declare function _collectSchemaRegistries(nuxtApp: ReturnType<typeof useNuxtApp>): Promise<{
+    schemas: SchemaRegistryLike[];
+    plugins: AbracadabraPlugin[];
+}>;
+/**
+ * Reactive handle to the registries the app attached at boot.
+ *
+ * The composable is safe to call before any registry is attached —
+ * it returns an empty list and a permissive validator (every meta
+ * passes) so renderer code can call it unconditionally.
+ */
+export declare function useAbracadabraSchema(): {
+    /** All registries attached at boot. Read-only — frozen after boot. */
+    registries: ComputedRef<readonly SchemaRegistryLike[]>;
+    /** True if at least one registry has been attached. */
+    hasSchema: ComputedRef<boolean>;
+    /**
+     * Validate `meta` against the first registry that recognises `typeName`.
+     * Returns `{ ok: true }` when no registry knows the type (Rule 4).
+     */
+    validateMeta: (typeName: string, meta: unknown) => ValidationResultLike;
+    /**
+     * Run forward migrations on `meta` against the first registry that
+     * recognises `typeName`. Returns the input unchanged when no
+     * registry knows the type or `@abraca/schema` is not installed.
+     */
+    runMigrations: (typeName: string, meta: unknown) => Promise<unknown>;
+};

package/dist/runtime/composables/useAbracadabraSchema.js

@@ -0,0 +1,52 @@
+import { computed } from "vue";
+import { useNuxtApp } from "#imports";
+export async function _collectSchemaRegistries(nuxtApp) {
+  const collected = [];
+  const plugins = [];
+  const ctx = {
+    attachSchema: (registry) => {
+      if (!registry || typeof registry !== "object") return;
+      if (typeof registry.validateMeta !== "function") {
+        console.warn(
+          "[abracadabra] attachSchema received a value missing validateMeta() \u2014 expected a SchemaRegistry from `@abraca/schema` defineSchema(). Skipping."
+        );
+        return;
+      }
+      collected.push(registry);
+    },
+    attachPlugin: (plugin) => {
+      if (!plugin || typeof plugin !== "object" || typeof plugin.name !== "string") {
+        console.warn("[abracadabra] attachPlugin received an invalid plugin (missing name). Skipping.");
+        return;
+      }
+      plugins.push(plugin);
+    }
+  };
+  await nuxtApp.callHook("abracadabra:before-boot", ctx);
+  nuxtApp._abracadabraSchemas = collected;
+  return { schemas: collected, plugins };
+}
+export function useAbracadabraSchema() {
+  const nuxtApp = useNuxtApp();
+  const stored = nuxtApp._abracadabraSchemas;
+  const list = stored ?? [];
+  const registries = computed(() => list);
+  const hasSchema = computed(() => list.length > 0);
+  function validateMeta(typeName, meta) {
+    for (const r of list) {
+      if (r.types.has(typeName)) {
+        return r.validateMeta(typeName, meta);
+      }
+    }
+    return { ok: true, value: meta };
+  }
+  async function runMigrations(typeName, meta) {
+    const reg = list.find((r) => r.types.has(typeName));
+    if (!reg) return meta;
+    const { tryLoadSchemaModule } = await import("../utils/schemaSupport.js");
+    const mod = await tryLoadSchemaModule();
+    if (!mod) return meta;
+    return mod.runMigrations(reg, typeName, meta);
+  }
+  return { registries, hasSchema, validateMeta, runMigrations };
+}

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

@@ -1,9 +1,4 @@
-export interface PresenceUser {
-    name: string;
-    color: string;
-    publicKey?: string;
-    clientId: number;
-}
+import type { PresenceUser } from './useItemPresence.js';
 interface AwarenessState {
     user?: {
         name?: string;

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

@@ -71,7 +71,7 @@ export declare function useCalendarView(options: UseCalendarViewOptions): {
     nextPeriod: () => void;
     goToday: () => void;
     goToMonth: (y: number, m: number) => void;
-    weekStartOffset: import("vue").ComputedRef<1 | 0>;
+    weekStartOffset: import("vue").ComputedRef<0 | 1>;
     weekDayHeaders: import("vue").ComputedRef<("Sun" | "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat")[]>;
     weekViewDays: import("vue").ComputedRef<3 | 7>;
     weeks: import("vue").ComputedRef<WeekRow[]>;

package/dist/runtime/composables/useChat.js

@@ -25,6 +25,7 @@ export function buildDmChannelId(a, b) {
   return `dm:${[a, b].sort().join(":")}`;
 }
 function normalizeChannel(channelId) {
+  if (typeof channelId !== "string" || !channelId) return "";
   return channelId.startsWith("group:") ? channelId.slice("group:".length) : channelId;
 }
 const messagesByChannel = ref({});

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

@@ -0,0 +1,21 @@
+/**
+ * useDocBreadcrumb — reactive parent chain for a document.
+ *
+ * Walks up the doc-tree from the given docId to the root, returning
+ * the breadcrumb trail as an array of items ready for UBreadcrumb.
+ * Caps depth at `maxDepth` (default 8) to handle malformed cycles
+ * defensively. The last item is the current doc and has no `to`.
+ */
+import { type ComputedRef, type MaybeRef } from 'vue';
+export interface DocBreadcrumbItem {
+    id: string;
+    label: string;
+    icon: string;
+    /** Navigation target — undefined for the current doc */
+    to?: string;
+}
+export declare function useDocBreadcrumb(docId: MaybeRef<string | null | undefined>, options?: {
+    maxDepth?: number;
+}): {
+    items: ComputedRef<DocBreadcrumbItem[]>;
+};

package/dist/runtime/composables/useDocBreadcrumb.js

@@ -0,0 +1,33 @@
+import { computed, unref } from "vue";
+import { resolveDocType } from "../utils/docTypes.js";
+import { useRuntimeConfig } from "#imports";
+import { useDocTree } from "./useDocTree.js";
+export function useDocBreadcrumb(docId, options = {}) {
+  const maxDepth = options.maxDepth ?? 8;
+  const config = useRuntimeConfig();
+  const docBasePath = config.public?.abracadabra?.docBasePath ?? "/doc";
+  const tree = useDocTree();
+  const items = computed(() => {
+    const startId = unref(docId);
+    if (!startId) return [];
+    const trail = [];
+    let id = startId;
+    let safety = maxDepth;
+    const seen = /* @__PURE__ */ new Set();
+    while (id && safety-- > 0 && !seen.has(id)) {
+      seen.add(id);
+      const entry = tree.getEntry(id);
+      if (!entry) break;
+      const isCurrent = id === startId;
+      trail.unshift({
+        id,
+        label: entry.label || "Untitled",
+        icon: resolveDocType(entry.type ?? "doc")?.icon ?? "i-lucide-file-text",
+        ...isCurrent ? {} : { to: `${docBasePath}/${id}` }
+      });
+      id = entry.parentId ?? null;
+    }
+    return trail;
+  });
+  return { items };
+}

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

@@ -0,0 +1,60 @@
+/**
+ * useDocEntryTyped — reactive typed projection of a single doc-tree entry.
+ *
+ * Day 3 of the Phase 3 schema rollout. Pairs with `useTypedDoc` (which
+ * exposes write methods) — this composable is the renderer-side read
+ * surface, including optional auto-migrate-on-read.
+ *
+ * Behaviour:
+ *  - Returns a `ComputedRef<TypedTreeEntry<M> | null>` that updates when
+ *    the underlying Y.Map entry changes.
+ *  - Returns `null` when the entry is missing OR its stored `type`
+ *    doesn't match the requested `expectedType` (cross-schema reads
+ *    return null — same contract as `useTypedDoc.get`).
+ *  - When `options.migrate` (or module-config `schema.migrateOnRead`)
+ *    is true, the composable lazy-loads `@abraca/schema` and runs
+ *    forward migrations before returning. Until the schema module
+ *    resolves, the composable returns the un-migrated projection so
+ *    consumers never observe a flicker through `null`.
+ *
+ * Migrations are read-only — they don't write back to the doc-tree.
+ * Persistence happens on the next typed `update`/`set` call (consumers
+ * who want write-back should call `useTypedDoc(...).set(type, id, m)`
+ * with the migrated meta).
+ */
+import { type ComputedRef, type Ref } from 'vue';
+import { type SchemaModule, type SchemaRegistryLike } from '../utils/schemaSupport.js';
+type SchemaDocTypeName<S> = S extends {
+    __metaMap?: infer M;
+} ? keyof M & string : string;
+type SchemaMetaOf<S, N extends string> = S extends {
+    __metaMap?: infer M;
+} ? N extends keyof M ? M[N] : Record<string, unknown> : Record<string, unknown>;
+export interface TypedDocEntry<M> {
+    readonly id: string;
+    readonly type: string;
+    readonly label: string;
+    readonly parentId: string | null;
+    readonly order: number;
+    readonly meta: M | undefined;
+    readonly createdAt: number | undefined;
+    readonly updatedAt: number | undefined;
+    /**
+     * True if `meta` was rewritten by `runMigrations`. Useful for
+     * renderer authors who want to flag stale storage in the UI.
+     */
+    readonly migrated: boolean;
+}
+export interface UseDocEntryTypedOptions {
+    /**
+     * When true, run `@abraca/schema`'s `runMigrations` on the read meta.
+     * Defaults to module config `schema.migrateOnRead` (false unless set).
+     */
+    migrate?: boolean;
+}
+/** Test-only: reset the module cache so a fresh load runs next call. */
+export declare function __resetUseDocEntryTypedCacheForTests(): void;
+/** Test-only: inject a schema module synchronously (skips dynamic import). */
+export declare function __setSchemaModuleForTests(mod: SchemaModule | null): void;
+export declare function useDocEntryTyped<S extends SchemaRegistryLike>(docId: Ref<string | null | undefined> | string | null | undefined, schema: S, expectedType: SchemaDocTypeName<S>, options?: UseDocEntryTypedOptions): ComputedRef<TypedDocEntry<SchemaMetaOf<S, SchemaDocTypeName<S>>> | null>;
+export {};

package/dist/runtime/composables/useDocEntryTyped.js

@@ -0,0 +1,70 @@
+import { computed, shallowRef, watch, isRef } from "vue";
+import { useDocTree } from "./useDocTree.js";
+import { useAbracadabraSchema } from "./useAbracadabraSchema.js";
+import { tryLoadSchemaModule } from "../utils/schemaSupport.js";
+import { useRuntimeConfig } from "#imports";
+const _moduleRef = shallowRef(null);
+let _moduleRequested = false;
+function _ensureSchemaModule() {
+  if (_moduleRequested) return;
+  _moduleRequested = true;
+  void tryLoadSchemaModule().then((m) => {
+    _moduleRef.value = m;
+  });
+}
+export function __resetUseDocEntryTypedCacheForTests() {
+  _moduleRef.value = null;
+  _moduleRequested = false;
+}
+export function __setSchemaModuleForTests(mod) {
+  _moduleRef.value = mod;
+  _moduleRequested = true;
+}
+function projectEntry(entry, expectedType) {
+  if (!entry) return null;
+  if (entry.type !== expectedType) return null;
+  return {
+    id: entry.id,
+    type: expectedType,
+    label: entry.label,
+    parentId: entry.parentId,
+    order: entry.order,
+    meta: entry.meta,
+    createdAt: entry.createdAt,
+    updatedAt: entry.updatedAt
+  };
+}
+export function useDocEntryTyped(docId, schema, expectedType, options = {}) {
+  const tree = useDocTree();
+  const { runMigrations: _ } = useAbracadabraSchema();
+  void _;
+  const cfg = useRuntimeConfig().public.abracadabra?.schema;
+  const migrateOnRead = options.migrate ?? cfg?.migrateOnRead ?? false;
+  if (migrateOnRead) _ensureSchemaModule();
+  return computed(() => {
+    const id = isRef(docId) ? docId.value : docId;
+    if (!id) return null;
+    const entry = tree.getEntry(id);
+    const projected = projectEntry(entry, expectedType);
+    if (!projected) return null;
+    if (!migrateOnRead) {
+      return { ...projected, migrated: false };
+    }
+    const mod = _moduleRef.value;
+    if (!mod) {
+      return { ...projected, migrated: false };
+    }
+    const before = projected.meta;
+    if (before === void 0 || before === null) {
+      return { ...projected, migrated: false };
+    }
+    const after = mod.runMigrations(schema, expectedType, before);
+    const migrated = after !== before;
+    return {
+      ...projected,
+      meta: migrated ? after : before,
+      migrated
+    };
+  });
+}
+watch(_moduleRef, () => void 0, { flush: "sync" });

package/dist/runtime/composables/useEditorDragHandle.js

@@ -73,6 +73,24 @@ export function useEditorDragHandle(pageConfig) {
         { label: "Download image", icon: "i-lucide-download", to: node?.attrs?.src, download: true }
       ];
     }
+    if (nodeType === "timeline") {
+      return [
+        {
+          label: "Add Event",
+          icon: "i-lucide-plus",
+          onSelect: () => {
+            if (pos === void 0) return;
+            const node = editor.state.doc.nodeAt(pos);
+            if (!node) return;
+            editor.chain().focus().insertContentAt(pos + node.nodeSize - 1, {
+              type: "timelineItem",
+              attrs: { date: "", label: `Event ${node.childCount + 1}`, icon: "" },
+              content: [{ type: "paragraph" }]
+            }).run();
+          }
+        }
+      ];
+    }
     if (nodeType === "table") {
       return [
         {

package/dist/runtime/composables/useEditorSuggestions.js

@@ -73,7 +73,8 @@ export function useEditorSuggestions(options = {}) {
         ...extEnabled("mathBlock") ? [{ kind: "mathBlock", label: "Math (block)", icon: "i-lucide-square-sigma", description: "Display-mode LaTeX equation", keywords: ["katex", "latex", "equation", "formula", "math"] }] : [],
         ...extEnabled("mathInline") ? [{ kind: "mathInline", label: "Math (inline)", icon: "i-lucide-sigma", description: "Inline LaTeX expression", keywords: ["katex", "latex", "inline math"] }] : [],
         ...extEnabled("diff") ? [{ kind: "diff", label: "Diff", icon: "i-lucide-git-compare", description: "Side-by-side text diff", keywords: ["compare", "changes", "git"] }] : [],
-        ...extEnabled("svgEmbed") ? [{ kind: "svgEmbed", label: "SVG embed", icon: "i-lucide-image", description: "Inline SVG (sanitized)", keywords: ["svg", "vector", "icon", "diagram"] }] : []
+        ...extEnabled("svgEmbed") ? [{ kind: "svgEmbed", label: "SVG embed", icon: "i-lucide-image", description: "Inline SVG (sanitized)", keywords: ["svg", "vector", "icon", "diagram"] }] : [],
+        ...extEnabled("timeline") ? [{ kind: "timeline", label: "Timeline", icon: "i-lucide-git-commit-vertical", description: "Vertical event timeline", keywords: ["events", "history", "milestones"] }] : []
       ]
     ];
     try {