@meistrari/minuta-nuxt 0.1.0

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

@@ -0,0 +1,34 @@
+import type { Editor } from '@tiptap/core';
+import type { Node as PMNode } from '@tiptap/pm/model';
+import type { Change } from '@tiptap/pm/changeset';
+import { PluginKey } from '@tiptap/pm/state';
+import { DecorationSet } from '@tiptap/pm/view';
+/**
+ * Comparação read-only entre uma versão do histórico e o documento atual
+ * (estilo histórico do Google Docs): verde = inserido, vermelho tachado =
+ * removido. O diff roda sobre os DOCS ProseMirror — nunca sobre o HTML cru,
+ * que quebraria em chips de variável, html islands e atributos vault://.
+ *
+ * Diferente do usePocTrackChanges (tracking incremental de edições ao vivo,
+ * órfão), aqui o changeset é computado UMA vez entre dois estados arbitrários
+ * e vira um DecorationSet estático num plugin efêmero — registrado ao entrar
+ * no modo comparação e removido ao sair, fora do buildPocExtensions.
+ */
+export declare const pocVersionDiffKey: PluginKey<DecorationSet>;
+/**
+ * Doc ProseMirror a partir do html salvo, com o MESMO schema do editor vivo —
+ * qualquer divergência de parse apareceria como mudança fantasma.
+ */
+export declare function pocDocFromHtml(editor: Editor, html: string): PMNode;
+/**
+ * Mudanças mínimas entre oldDoc e o doc ATUAL do editor: uma Transform
+ * substitui o oldDoc inteiro pelo atual e o ChangeSet reduz aos ranges reais
+ * (computeDiff interno); simplifyChanges agrupa em fronteiras de palavra.
+ * Posições resultantes (fromB/toB) são no doc atual.
+ */
+export declare function pocComputeVersionDiff(editor: Editor, oldDoc: PMNode): Change[];
+/** Liga a comparação: computa o diff contra `oldHtml` e decora o doc atual. */
+export declare function pocEnterVersionDiff(editor: Editor, oldHtml: string): {
+    changeCount: number;
+};
+export declare function pocExitVersionDiff(editor: Editor): void;

package/dist/runtime/composables/versionDiff.js

@@ -0,0 +1,62 @@
+import { createNodeFromContent } from "@tiptap/core";
+import { ChangeSet, simplifyChanges } from "@tiptap/pm/changeset";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Transform } from "@tiptap/pm/transform";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+export const pocVersionDiffKey = new PluginKey("pocVersionDiff");
+const DELETED_PREVIEW_MAX = 500;
+export function pocDocFromHtml(editor, html) {
+  return createNodeFromContent(html, editor.schema, { slice: false });
+}
+export function pocComputeVersionDiff(editor, oldDoc) {
+  const newDoc = editor.state.doc;
+  const tr = new Transform(oldDoc);
+  tr.replaceWith(0, oldDoc.content.size, newDoc.content);
+  const changeset = ChangeSet.create(oldDoc).addSteps(tr.doc, tr.mapping.maps, {});
+  return simplifyChanges(changeset.changes, tr.doc);
+}
+function buildDecorations(doc, oldDoc, changes) {
+  const decorations = [];
+  for (const change of changes) {
+    if (change.toB > change.fromB)
+      decorations.push(Decoration.inline(change.fromB, change.toB, { class: "poc-ins" }));
+    if (change.toA > change.fromA) {
+      const deleted = oldDoc.textBetween(change.fromA, change.toA, " ");
+      if (deleted.trim()) {
+        decorations.push(Decoration.widget(change.fromB, () => {
+          const span = document.createElement("span");
+          span.className = "poc-del";
+          span.textContent = deleted.length > DELETED_PREVIEW_MAX ? `${deleted.slice(0, DELETED_PREVIEW_MAX)}\u2026` : deleted;
+          return span;
+        }, { side: -1 }));
+      }
+    }
+  }
+  return DecorationSet.create(doc, decorations);
+}
+export function pocEnterVersionDiff(editor, oldHtml) {
+  pocExitVersionDiff(editor);
+  const oldDoc = pocDocFromHtml(editor, oldHtml);
+  const changes = pocComputeVersionDiff(editor, oldDoc);
+  const decorations = buildDecorations(editor.state.doc, oldDoc, changes);
+  editor.registerPlugin(new Plugin({
+    key: pocVersionDiffKey,
+    state: {
+      init: () => decorations,
+      // o editor está read-only no modo comparação, mas troca de imagem
+      // fria ainda gera transação — mapear mantém as marcas no lugar
+      apply: (tr, value) => tr.docChanged ? value.map(tr.mapping, tr.doc) : value
+    },
+    props: {
+      decorations(state) {
+        return pocVersionDiffKey.getState(state);
+      }
+    }
+  }));
+  return { changeCount: changes.length };
+}
+export function pocExitVersionDiff(editor) {
+  if (editor.isDestroyed)
+    return;
+  editor.unregisterPlugin(pocVersionDiffKey);
+}

package/dist/runtime/server/api/minuta/[...path].d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/minuta/[...path].js

@@ -0,0 +1,6 @@
+import { defineEventHandler, getRouterParam } from "h3";
+import { proxyToMinutaApi } from "../../utils/minuta-proxy.js";
+export default defineEventHandler((event) => {
+  const path = getRouterParam(event, "_") ?? getRouterParam(event, "path") ?? "";
+  return proxyToMinutaApi(event, path);
+});

package/dist/runtime/server/api/minuta/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/minuta/index.js

@@ -0,0 +1,3 @@
+import { defineEventHandler } from "h3";
+import { proxyToMinutaApi } from "../../utils/minuta-proxy.js";
+export default defineEventHandler((event) => proxyToMinutaApi(event, ""));

package/dist/runtime/server/utils/minuta-proxy.d.ts

@@ -0,0 +1,10 @@
+import type { H3Event } from 'h3';
+/**
+ * Resolve o JWT Tela do usuário logado no app hospedeiro (mesma receita do
+ * chat-nuxt): contexto de auth do host → cookie configurado → cookie padrão.
+ * O token nunca chega ao browser do embed — só trafega server-side.
+ */
+export declare function resolveMinutaAuthToken(event: H3Event): string | undefined;
+/** Valida segmentos do path (sem traversal) e monta a URL de destino no CDB. */
+export declare function buildMinutaTargetUrl(event: H3Event, path: string): string;
+export declare function proxyToMinutaApi(event: H3Event, path: string): Promise<any>;

package/dist/runtime/server/utils/minuta-proxy.js

@@ -0,0 +1,63 @@
+import { createError, getCookie, proxyRequest } from "h3";
+import { useRuntimeConfig } from "#imports";
+const DEFAULT_JWT_COOKIES = ["tela-access-token", "tela-jwt"];
+export function resolveMinutaAuthToken(event) {
+  const auth = event.context.auth;
+  if (auth?.token)
+    return auth.token;
+  const config = useRuntimeConfig(event);
+  const cookieName = config.minutaNuxt?.authTokenCookie;
+  if (cookieName)
+    return getCookie(event, cookieName) || void 0;
+  for (const name of DEFAULT_JWT_COOKIES) {
+    const token = getCookie(event, name);
+    if (token)
+      return token;
+  }
+  return void 0;
+}
+function resolveCdbApiUrl(event) {
+  const config = useRuntimeConfig(event);
+  const url = config.minutaNuxt?.cdbApiUrl;
+  if (!url) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "minutaNuxt.cdbApiUrl is not configured"
+    });
+  }
+  return url.replace(/\/$/, "");
+}
+export function buildMinutaTargetUrl(event, path) {
+  const segments = path.split("/").map((s) => s.trim()).filter(Boolean);
+  for (const segment of segments) {
+    let decoded = "";
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      throw createError({ statusCode: 400, statusMessage: "Invalid proxy path" });
+    }
+    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\"))
+      throw createError({ statusCode: 400, statusMessage: "Invalid proxy path" });
+  }
+  const base = resolveCdbApiUrl(event);
+  return segments.length ? `${base}/standalone-minuta/${segments.join("/")}` : `${base}/standalone-minuta`;
+}
+export function proxyToMinutaApi(event, path) {
+  const token = resolveMinutaAuthToken(event);
+  if (!token) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Authentication token is required"
+    });
+  }
+  return proxyRequest(event, buildMinutaTargetUrl(event, path), {
+    headers: {
+      authorization: `Bearer ${token}`,
+      // o h3 repassa TODOS os headers do request menos os hop-by-hop —
+      // inclusive o Cookie do app hospedeiro. A API do CDB se autentica
+      // pelo Bearer acima e não precisa (nem deve receber) a sessão do
+      // host: zera o header em vez de vazá-la para outro serviço.
+      cookie: ""
+    }
+  });
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Conteúdo de nota de rodapé: o template escreve HTML dentro de `<footnote>`
+ * (negrito, itálico, links) e declara o corpo da nota em `style="font-size: 9pt"`.
+ * O marcador do preview carrega esse conteúdo num atributo, então ele precisa
+ * de um subconjunto seguro — atributo nenhum sobrevive, só as tags de ênfase.
+ */
+/** HTML da nota reduzido a ênfase inline + links (o resto vira texto) */
+export declare function sanitizeFootnoteHtml(html: string): string;
+export interface FootnoteRun {
+    text: string;
+    bold?: boolean;
+    italics?: boolean;
+    underline?: boolean;
+    break?: boolean;
+    /** quando presente, o run vira ExternalHyperlink no .docx */
+    href?: string;
+    /** personalização por trecho (spans do popover) */
+    font?: string;
+    sizePt?: number;
+    /** hex SEM '#' (formato do docx) */
+    color?: string;
+}
+/** o mesmo HTML fatiado em runs — é assim que o .docx representa ênfase */
+export declare function footnoteHtmlToRuns(html: string): FootnoteRun[];
+/** tamanho declarado na nota (`font-size: 9pt`) em pontos */
+export declare function footnoteSizePt(style: string | null | undefined): number | null;

package/dist/runtime/utils/footnoteHtml.js

@@ -0,0 +1,117 @@
+const INLINE_TAGS = /* @__PURE__ */ new Set(["B", "STRONG", "I", "EM", "U", "SUP", "SUB", "BR"]);
+function safeHref(value) {
+  const href = (value ?? "").trim();
+  return /^https?:\/\//i.test(href) ? href : null;
+}
+function rgbToHex(value) {
+  const match = value.match(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/i);
+  if (!match)
+    return null;
+  return `#${match.slice(1, 4).map((n) => Number(n).toString(16).padStart(2, "0")).join("")}`;
+}
+function safeSpanStyle(style) {
+  if (!style)
+    return null;
+  const out = [];
+  const family = style.match(/font-family\s*:\s*([^;]+)/i)?.[1]?.trim();
+  if (family && /^[\w\s,'"-]+$/.test(family))
+    out.push(`font-family: ${family.replace(/"/g, "'")}`);
+  const size = style.match(/font-size\s*:\s*([\d.]+)\s*pt/i)?.[1];
+  if (size)
+    out.push(`font-size: ${size}pt`);
+  const rawColor = style.match(/(?:^|;)\s*color\s*:\s*([^;]+)/i)?.[1]?.trim();
+  if (rawColor) {
+    const hex = rawColor.startsWith("#") ? /^#[0-9a-f]{6}$/i.test(rawColor) ? rawColor : null : rgbToHex(rawColor);
+    if (hex)
+      out.push(`color: ${hex}`);
+  }
+  return out.length ? out.join("; ") : null;
+}
+export function sanitizeFootnoteHtml(html) {
+  if (!html)
+    return "";
+  const doc = new DOMParser().parseFromString(`<div>${html}</div>`, "text/html");
+  const root = doc.body.firstElementChild;
+  if (!root)
+    return "";
+  const walk = (node) => {
+    if (node.nodeType === Node.TEXT_NODE)
+      return (node.textContent ?? "").replace(/[<>&]/g, (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;" })[c]);
+    if (!(node instanceof Element))
+      return "";
+    if (node.tagName === "SCRIPT" || node.tagName === "STYLE")
+      return "";
+    const inner = Array.from(node.childNodes).map(walk).join("");
+    if (node.tagName === "BR")
+      return "<br>";
+    if (node.tagName === "A") {
+      const href = safeHref(node.getAttribute("href"));
+      return href ? `<a href="${href.replace(/"/g, "&quot;")}">${inner}</a>` : inner;
+    }
+    if (node.tagName === "SPAN" || node.tagName === "FONT") {
+      const style = safeSpanStyle(node.getAttribute("style"));
+      return style ? `<span style="${style}">${inner}</span>` : inner;
+    }
+    if (node.tagName === "DIV" || node.tagName === "P")
+      return inner ? `${inner}<br>` : "";
+    if (INLINE_TAGS.has(node.tagName))
+      return `<${node.tagName.toLowerCase()}>${inner}</${node.tagName.toLowerCase()}>`;
+    return inner;
+  };
+  return Array.from(root.childNodes).map(walk).join("").replace(/\s+/g, " ").replace(/(<br>\s*)+$/i, "").trim();
+}
+export function footnoteHtmlToRuns(html) {
+  const runs = [];
+  if (!html)
+    return runs;
+  const doc = new DOMParser().parseFromString(`<div>${html}</div>`, "text/html");
+  const root = doc.body.firstElementChild;
+  if (!root)
+    return runs;
+  const walk = (node, style) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+      const text = node.textContent ?? "";
+      if (text)
+        runs.push({ ...style, text });
+      return;
+    }
+    if (!(node instanceof Element))
+      return;
+    if (node.tagName === "BR") {
+      runs.push({ text: "", break: true });
+      return;
+    }
+    const next = { ...style };
+    if (node.tagName === "B" || node.tagName === "STRONG")
+      next.bold = true;
+    if (node.tagName === "I" || node.tagName === "EM")
+      next.italics = true;
+    if (node.tagName === "U")
+      next.underline = true;
+    if (node.tagName === "A") {
+      const href = safeHref(node.getAttribute("href"));
+      if (href)
+        next.href = href;
+    }
+    if (node.tagName === "SPAN") {
+      const spanStyle = node.getAttribute("style") ?? "";
+      const family = spanStyle.match(/font-family\s*:\s*([^;]+)/i)?.[1]?.split(",")[0]?.trim().replace(/['"]/g, "");
+      if (family)
+        next.font = family;
+      const size = spanStyle.match(/font-size\s*:\s*([\d.]+)\s*pt/i)?.[1];
+      if (size)
+        next.sizePt = Number.parseFloat(size);
+      const color = spanStyle.match(/color\s*:\s*#([0-9a-f]{6})/i)?.[1];
+      if (color)
+        next.color = color.toUpperCase();
+    }
+    node.childNodes.forEach((child) => walk(child, next));
+  };
+  root.childNodes.forEach((child) => walk(child, {}));
+  return runs;
+}
+export function footnoteSizePt(style) {
+  const match = style?.match(/font-size\s*:\s*([\d.]+)\s*pt/i);
+  const value = match ? Number.parseFloat(match[1]) : Number.NaN;
+  return Number.isFinite(value) ? value : null;
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Regra de *keep-with-next* do motor de paginação: um título não pode ficar
+ * órfão no pé da página, então a quebra sobe para antes dele.
+ *
+ * Vive separada de usePocPaginationPlugin porque o laço que a usa tem
+ * RETROCESSO — ele volta o índice para reavaliar o item depois de mover a
+ * quebra — e uma decisão que não avança trava o laço para sempre. Sendo pura,
+ * a regra pode ser testada sem DOM nem ProseMirror.
+ */
+export interface PocKeepWithNextItem {
+    /** topo do item no fluxo normalizado (sem chrome), em px */
+    top: number;
+    /** altura do item em px */
+    height: number;
+    /** margem superior, que conta como parte da página que o item abre */
+    marginTop: number;
+    /** é um título (h1–h4)? */
+    heading: boolean;
+    /** é o parágrafo-marcador de quebra manual do template? */
+    marker: boolean;
+}
+/**
+ * A quebra deve subir do item para o título imediatamente anterior?
+ *
+ * Duas condições, e as duas são necessárias para o laço TERMINAR:
+ *
+ * 1. o título ainda não abre a página corrente — comparado pelo topo COM
+ *    MARGEM, que é exatamente o valor que vira o novo `pageStart`. Comparar
+ *    `prev.top` puro faz um título com `margin-top > 0` satisfazer a condição
+ *    para sempre: `pageStart` vira `prev.top - prev.marginTop`, que é sempre
+ *    menor que `prev.top`, e a mesma quebra é reemitida em loop;
+ *
+ * 2. o par título+item precisa CABER na página nova. Se o item sozinho já
+ *    estoura a página (uma tabela ou imagem grande vinda de DOCX), descer o
+ *    título não resolve — a quebra não avança e o laço volta ao mesmo ponto.
+ */
+export declare function shouldMoveBreakToHeading(params: {
+    heading: PocKeepWithNextItem | undefined;
+    item: PocKeepWithNextItem;
+    /** topo da página corrente no fluxo normalizado */
+    pageStart: number;
+    /** altura útil disponível, já descontadas as notas de rodapé */
+    capacity: number;
+}): boolean;

package/dist/runtime/utils/pocKeepWithNext.js

@@ -0,0 +1,9 @@
+export function shouldMoveBreakToHeading(params) {
+  const { heading, item, pageStart, capacity } = params;
+  if (!heading || !heading.heading || heading.marker)
+    return false;
+  const headingStart = heading.top - heading.marginTop;
+  if (headingStart <= pageStart)
+    return false;
+  return item.top + item.height - headingStart <= capacity;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Sanitização do HTML rico de cabeçalho/rodapé (chrome) — conteúdo criado em
+ * contenteditable e PERSISTIDO (template.headers, case_edition.chrome). Sem
+ * isso, um usuário do workspace poderia armazenar markup executável que roda
+ * no browser de quem abrir o caso/preview (stored XSS).
+ *
+ * Aplicar em TODO sink (v-html / innerHTML) e ao persistir. Mantém a
+ * formatação suportada (b/i/u, spans com estilo, imagens data:/blob:/https).
+ */
+export declare function sanitizeRichHtml(html: string | null | undefined): string;

package/dist/runtime/utils/sanitizeRichHtml.js

@@ -0,0 +1,73 @@
+const BLOCKED_TAGS = /* @__PURE__ */ new Set([
+  "SCRIPT",
+  "STYLE",
+  "IFRAME",
+  "OBJECT",
+  "EMBED",
+  "LINK",
+  "META",
+  "BASE",
+  "FORM",
+  "INPUT",
+  "BUTTON",
+  "TEXTAREA",
+  "SELECT",
+  "TEMPLATE",
+  "DIALOG",
+  // SMIL: anima/troca atributo de outro elemento DEPOIS da sanitização —
+  // <a><animate attributeName="href" to="javascript:…"> devolve o href
+  // proibido no clique, com a URL nunca passando pelo allowlist abaixo
+  "ANIMATE",
+  "ANIMATEMOTION",
+  "ANIMATETRANSFORM",
+  "SET",
+  "DISCARD",
+  // hospedam markup de outro namespace (HTML dentro de SVG, MathML) — o
+  // parser reinterpreta na 2ª passada e é o vetor clássico de mXSS
+  "FOREIGNOBJECT",
+  "ANNOTATION-XML",
+  "NOSCRIPT",
+  "NOEMBED",
+  "NOFRAMES",
+  "XMP",
+  "PLAINTEXT",
+  // <use> puxa e clona um nó por referência (inclusive de fora do documento)
+  "USE"
+]);
+const BLOCKED_ATTRS = /* @__PURE__ */ new Set(["attributename", "attributetype", "to", "values", "from", "by"]);
+const SAFE_URL = /^(?:https?:|data:image\/|blob:|vault:)/i;
+function scrubElement(el) {
+  for (const child of [...el.children]) {
+    if (BLOCKED_TAGS.has(child.tagName.toUpperCase())) {
+      child.remove();
+      continue;
+    }
+    for (const attr of [...child.attributes]) {
+      const name = attr.name.toLowerCase();
+      if (name.startsWith("on")) {
+        child.removeAttribute(attr.name);
+        continue;
+      }
+      if (BLOCKED_ATTRS.has(name)) {
+        child.removeAttribute(attr.name);
+        continue;
+      }
+      if ((name === "src" || name === "href" || name === "xlink:href" || name === "formaction" || name === "srcdoc") && (name === "srcdoc" || !SAFE_URL.test(attr.value.trim()))) {
+        child.removeAttribute(attr.name);
+        continue;
+      }
+      if (name === "style" && /url\s*\(/i.test(attr.value) && !/url\s*\(\s*['"]?(?:https?:|data:image\/|blob:)/i.test(attr.value)) {
+        child.removeAttribute(attr.name);
+      }
+    }
+    scrubElement(child);
+  }
+}
+export function sanitizeRichHtml(html) {
+  if (!html)
+    return "";
+  const tpl = document.createElement("template");
+  tpl.innerHTML = html;
+  scrubElement(tpl.content);
+  return tpl.innerHTML;
+}

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.js'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.js'

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module'

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@meistrari/minuta-nuxt",
+  "version": "0.1.0",
+  "description": "Embed do editor de minuta (docx paginado A4) do defesa.ai para apps Nuxt — componente + proxy Nitro, sem segredos no browser",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/meistrari/case-defense-builder.git",
+    "directory": "packages/minuta-nuxt"
+  },
+  "license": "UNLICENSED",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    },
+    "./runtime/*": {
+      "types": "./dist/runtime/*.d.ts",
+      "import": "./dist/runtime/*.js"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "build": "nuxt-module-build build",
+    "dev:prepare": "nuxt-module-build build --stub && nuxi prepare playground",
+    "dev": "nuxi dev playground"
+  },
+  "dependencies": {
+    "@fontsource-variable/inter": "5.3.0",
+    "@nuxt/kit": "^3.17.7",
+    "@phosphor-icons/vue": "2.2.1",
+    "@tiptap/core": "2.11.9",
+    "@tiptap/extension-table": "2.11.9",
+    "@tiptap/extension-table-cell": "2.11.9",
+    "@tiptap/extension-table-header": "2.11.9",
+    "@tiptap/extension-table-row": "2.11.9",
+    "@tiptap/pm": "2.11.9",
+    "@tiptap/starter-kit": "2.11.9",
+    "@tiptap/vue-3": "2.11.9",
+    "defu": "^6.1.4",
+    "docx": "9.7.1",
+    "h3": "^1.15.0",
+    "ofetch": "^1.4.1"
+  },
+  "overrides": {
+    "@tiptap/core": "2.11.9",
+    "@tiptap/pm": "2.11.9",
+    "@tiptap/extension-blockquote": "2.11.9",
+    "@tiptap/extension-bold": "2.11.9",
+    "@tiptap/extension-bullet-list": "2.11.9",
+    "@tiptap/extension-code": "2.11.9",
+    "@tiptap/extension-code-block": "2.11.9",
+    "@tiptap/extension-document": "2.11.9",
+    "@tiptap/extension-dropcursor": "2.11.9",
+    "@tiptap/extension-gapcursor": "2.11.9",
+    "@tiptap/extension-hard-break": "2.11.9",
+    "@tiptap/extension-heading": "2.11.9",
+    "@tiptap/extension-history": "2.11.9",
+    "@tiptap/extension-horizontal-rule": "2.11.9",
+    "@tiptap/extension-italic": "2.11.9",
+    "@tiptap/extension-list-item": "2.11.9",
+    "@tiptap/extension-ordered-list": "2.11.9",
+    "@tiptap/extension-paragraph": "2.11.9",
+    "@tiptap/extension-strike": "2.11.9",
+    "@tiptap/extension-text": "2.11.9",
+    "@tiptap/extension-text-style": "2.11.9",
+    "@tiptap/extension-bubble-menu": "2.11.9",
+    "@tiptap/extension-floating-menu": "2.11.9"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "^0.8.4",
+    "nuxt": "~3.17.7",
+    "pino-pretty": "^13.1.3",
+    "typescript": "^5.8.2",
+    "vue": "^3.5.13",
+    "@meistrari/chat-nuxt": "3.14.0-rc.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@meistrari/chat-nuxt": ">=3.13.0"
+  },
+  "peerDependenciesMeta": {
+    "@meistrari/chat-nuxt": {
+      "optional": true
+    }
+  }
+}