@meistrari/minuta-editor 1.4.0 → 1.6.0

package/README.md

@@ -61,6 +61,13 @@ editor.setImageFallback('dataUri' | 'none')
 editor.variablesInDocument()             // → string[]
 editor.refreshVaultImages(vaultUrl => Promise<string>) // renova o src das imagens do vault (data-vault-src ou src="vault://"); sem undo/onChange
 
+// checklist junto da edição (o documento gerado vem do GET /data/case/:id/html?source=blocks)
+editor.stampGenerated()                  // ao CRIAR a edição a partir do HTML do checklist: marca os blocos como "gerados"
+editor.applyChecklist(htmlGerado, { toggled? }) // → { inserted, removed, regenerated, variablesUpdated, conflicts, … }
+editor.checklistConflicts()              // → [{ blockId, blockTitle, kind: 'replace' | 'remove' }]
+editor.resolveChecklistConflict(blockId, 'keep' | 'apply')
+editor.documentBlockIds()                // → blocos no texto, na ordem
+
 editor.schedulePaginate() // repagina (após mudar algo que afeta altura por fora)
 editor.totalPages()
 editor.destroy()

package/dist/chunks/docxExport.mjs

@@ -1,4 +1,4 @@
-import { f as footnoteHtmlToRuns, p as pocLoneCellIndex, a as formatTopicNumber, b as pocLooksLikeTitle, T as TOPIC_DEFAULT_GROUP } from '../shared/minuta-editor.b3351035.mjs';
+import { f as footnoteHtmlToRuns, p as pocLoneCellIndex, a as formatTopicNumber, b as pocLooksLikeTitle, c as pocNodeHasVisibleContent, d as pocNodePaintsBox, T as TOPIC_DEFAULT_GROUP } from '../shared/minuta-editor.f1239e0b.mjs';
 import { BorderStyle, TextRun, ExternalHyperlink, Paragraph, Document, LevelFormat, AlignmentType, LevelSuffix, Header, Packer, LineRuleType, Table, TableRow, TableCell, WidthType, TableLayoutType, Footer, FootnoteReferenceRun, VerticalAlign, ImageRun, HorizontalPositionRelativeFrom, VerticalPositionRelativeFrom, TextWrappingType, FrameAnchorType, PageNumber, HeadingLevel } from 'docx';
 import '@tiptap/pm/state';
 import '@tiptap/pm/view';
@@ -18,6 +18,48 @@ function topicSequenceFor(ctx, group, roman, number) {
   seq.next = number + 1;
   return seq.reference;
 }
+function listFormatFor(type) {
+  switch (type) {
+    case "a":
+      return LevelFormat.LOWER_LETTER;
+    case "A":
+      return LevelFormat.UPPER_LETTER;
+    case "i":
+      return LevelFormat.LOWER_ROMAN;
+    case "I":
+      return LevelFormat.UPPER_ROMAN;
+    default:
+      return LevelFormat.DECIMAL;
+  }
+}
+function listFormatFromCss(listStyleType) {
+  switch (listStyleType) {
+    case "lower-alpha":
+    case "lower-latin":
+      return LevelFormat.LOWER_LETTER;
+    case "upper-alpha":
+    case "upper-latin":
+      return LevelFormat.UPPER_LETTER;
+    case "lower-roman":
+      return LevelFormat.LOWER_ROMAN;
+    case "upper-roman":
+      return LevelFormat.UPPER_ROMAN;
+    default:
+      return LevelFormat.DECIMAL;
+  }
+}
+function listSequenceFor(ctx, list, run) {
+  const reference = `cdb-list-${ctx.listNumbering.size + 1}`;
+  const start = Number.parseInt(String(list.start ?? 1), 10);
+  ctx.listNumbering.set(reference, {
+    format: list.format,
+    // `start="0"` é válido (o Word aceita w:start=0); só o ausente/inválido vira 1
+    start: Number.isFinite(start) && start >= 0 ? start : 1,
+    suffix: list.suffix || ".",
+    run
+  });
+  return reference;
+}
 function leadingTopicNumber(node) {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
@@ -466,20 +508,28 @@ async function islandToDocx(node, pos, contentWidthPx, ctx) {
     const paragraphs = [];
     const liveLis = islandEl ? [...islandEl.querySelectorAll(":scope > ul > li, :scope > ol > li, :scope > li")] : [];
     const parsedLis = [...el.querySelectorAll(":scope > li")];
-    let n = 1;
+    let reference = null;
     for (let i = 0; i < parsedLis.length; i++) {
       const live = liveLis[i] ?? null;
       const source = live ?? parsedLis[i];
       const m = live ? measureEl(live) : null;
-      const marker = tag === "ol" ? `${n++}. ` : "\u2022  ";
-      const markerColor = m?.color;
+      const markerRun = { color: m?.color, size: m?.sizeHalf, font: m ? primaryFont(m.cs) : void 0 };
+      if (tag === "ol" && !reference) {
+        const liveStyleType = liveLis[0] ? getComputedStyle(liveLis[0]).listStyleType : "";
+        reference = listSequenceFor(ctx, {
+          format: el.hasAttribute("type") ? listFormatFor(el.getAttribute("type")) : listFormatFromCss(liveStyleType),
+          start: el.getAttribute("start"),
+          suffix: el.getAttribute("data-list-suffix")
+        }, markerRun);
+      }
       const runs = live ? domInlineToRuns(live) : [new TextRun({ text: source.textContent?.trim() || "", ...runOptions(parseStyle(source.getAttribute("style"))) })];
       const indentPx = live && islandEl ? live.offsetLeft : 24;
       paragraphs.push(new Paragraph({
         children: [
-          new TextRun({ text: marker, color: markerColor, size: m?.sizeHalf, font: m ? primaryFont(m.cs) : void 0 }),
+          ...tag === "ul" ? [new TextRun({ text: "\u2022  ", ...markerRun })] : [],
           ...runs
         ],
+        numbering: reference ? { reference, level: 0 } : void 0,
         spacing: m ? { after: m.afterTw, before: m.beforeTw, ...m.lineExactTw ? { line: m.lineExactTw, lineRule: LineRuleType.EXACT } : {} } : { after: 80 },
         indent: { left: Math.round(indentPx * PX_TO_TWIP) },
         alignment: m?.align,
@@ -694,6 +744,27 @@ async function flexRowToDocx(node, pos, contentWidthPx, ctx) {
   }
   return tables;
 }
+const INVISIBLE_NODE_TYPES = /* @__PURE__ */ new Set(["paragraph", "styledDiv", "missingImage", "hardBreak", "text"]);
+function rowPaintsOrShowsAnything(row, rowPos, ctx) {
+  const paintsAt = (node, pos) => {
+    if (pocNodePaintsBox(node))
+      return true;
+    const dom = domAt(ctx, pos);
+    return Boolean(bordersFrom(measureAt(ctx, pos), node.attrs?.style)) || Boolean(cellShading(dom ? getComputedStyle(dom) : null));
+  };
+  if (paintsAt(row, rowPos))
+    return true;
+  let found = false;
+  row.descendants((node, offset) => {
+    if (found)
+      return false;
+    const pos = rowPos + 1 + offset;
+    if (!INVISIBLE_NODE_TYPES.has(node.type.name) || pocNodeHasVisibleContent(node) || paintsAt(node, pos))
+      found = true;
+    return !found;
+  });
+  return found;
+}
 function isPlainContainer(node) {
   return node.type.name === "styledDiv" && !isFlexRow(node);
 }
@@ -930,6 +1001,18 @@ async function nodeToDocx(node, pos, contentWidthPx, ctx) {
     }
     case "styledDiv": {
       if (isFlexRow(node)) {
+        if (!rowPaintsOrShowsAnything(node, pos, ctx)) {
+          const rowM2 = measureAt(ctx, pos);
+          const breakBefore = consumeBreak(ctx);
+          const before = breakBefore ? rowM2?.beforeTw ?? 0 : Math.max(0, (rowM2?.beforeTw ?? 0) - ctx.lastAfterTw);
+          const lugar = new Paragraph({
+            children: [],
+            spacing: { after: rowM2?.afterTw ?? 0, before },
+            pageBreakBefore: breakBefore
+          });
+          ctx.lastAfterTw = rowM2?.afterTw ?? 0;
+          return [lugar];
+        }
         const loneIndex = pocLoneCellIndex(node);
         if (loneIndex != null) {
           let childPos = pos + 1;
@@ -1012,31 +1095,41 @@ async function nodeToDocx(node, pos, contentWidthPx, ctx) {
     case "bulletList":
     case "orderedList": {
       const paragraphs = [];
-      let n = 1;
+      const ordered = node.type.name === "orderedList";
+      let reference = null;
       let liPos = pos + 1;
       for (let i = 0; i < node.childCount; i++) {
         const li = node.child(i);
         let childPos = liPos + 1;
+        let marked = false;
         li.forEach((child) => {
           if (child.isTextblock) {
             const m = measureAt(ctx, childPos);
             const base = m ? { bold: m.bold, italics: m.italics, color: m.color, size: m.sizeHalf } : parseStyle(child.attrs.style);
-            const marker = node.type.name === "orderedList" ? `${n}. ` : "\u2022  ";
             const liDom = domAt(ctx, liPos);
             const indentPx = liDom?.offsetLeft ?? 48;
             const liBreak = consumeBreak(ctx);
+            if (ordered && !reference) {
+              reference = listSequenceFor(
+                ctx,
+                { format: listFormatFor(node.attrs.type), start: node.attrs.start },
+                { bold: base.bold, italics: base.italics, color: base.color, size: base.size, font: base.font }
+              );
+            }
+            const bullet = !ordered && !marked ? [new TextRun({ text: "\u2022  ", ...runOptions(base) })] : [];
             const liParagraph = new Paragraph({
-              children: [new TextRun({ text: marker, ...runOptions(base) }), ...inlineToRuns(child, base, ctx)],
+              children: [...bullet, ...inlineToRuns(child, base, ctx)],
+              numbering: ordered && !marked && reference ? { reference, level: 0 } : void 0,
               spacing: spacingFrom(m, child.attrs.style),
               indent: { left: Math.round(indentPx * PX_TO_TWIP) },
               pageBreakBefore: liBreak
             });
+            marked = true;
             ctx.meta.set(liParagraph, { breakBefore: liBreak });
             paragraphs.push(liParagraph);
           }
           childPos += child.nodeSize;
         });
-        n++;
         liPos += li.nodeSize;
       }
       return paragraphs;
@@ -1355,7 +1448,8 @@ async function pocExportDocx(editor, margins, chrome, options = {}) {
     meta: /* @__PURE__ */ new WeakMap(),
     footnotes: [],
     topicNumbering: /* @__PURE__ */ new Map(),
-    topicSequences: /* @__PURE__ */ new Map()
+    topicSequences: /* @__PURE__ */ new Map(),
+    listNumbering: /* @__PURE__ */ new Map()
   };
   const children = [];
   let pos = 0;
@@ -1404,21 +1498,38 @@ async function pocExportDocx(editor, margins, chrome, options = {}) {
       }
     },
     footnotes: Object.keys(footnotes).length ? footnotes : void 0,
-    numbering: ctx.topicNumbering.size ? {
-      config: [...ctx.topicNumbering].map(([reference, { roman, start }]) => ({
-        reference,
-        levels: [{
-          level: 0,
-          format: roman ? LevelFormat.UPPER_ROMAN : LevelFormat.DECIMAL,
-          text: "%1",
-          start,
-          alignment: AlignmentType.START,
-          // o ". " depois do número é texto do template; e sem
-          // recuo/tab o parágrafo fica igual ao preview
-          suffix: LevelSuffix.NOTHING,
-          style: { paragraph: { indent: { left: 0, hanging: 0 } } }
-        }]
-      }))
+    numbering: ctx.topicNumbering.size || ctx.listNumbering.size ? {
+      config: [
+        ...[...ctx.topicNumbering].map(([reference, { roman, start }]) => ({
+          reference,
+          levels: [{
+            level: 0,
+            format: roman ? LevelFormat.UPPER_ROMAN : LevelFormat.DECIMAL,
+            text: "%1",
+            start,
+            alignment: AlignmentType.START,
+            // o ". " depois do número é texto do template; e sem
+            // recuo/tab o parágrafo fica igual ao preview
+            suffix: LevelSuffix.NOTHING,
+            style: { paragraph: { indent: { left: 0, hanging: 0 } } }
+          }]
+        })),
+        ...[...ctx.listNumbering].map(([reference, { format, start, suffix, run }]) => ({
+          reference,
+          levels: [{
+            level: 0,
+            format,
+            text: `%1${suffix}`,
+            start,
+            alignment: AlignmentType.LEFT,
+            // "a. texto": marcador colado ao item com um espaço,
+            // como o preview (list-style-position: inside); o
+            // recuo é o do parágrafo, não da sequência
+            suffix: LevelSuffix.SPACE,
+            style: { paragraph: { indent: { left: 0, hanging: 0 } }, run }
+          }]
+        }))
+      ]
     } : void 0,
     sections: [{
       properties: {

package/dist/docx.mjs

@@ -1,5 +1,5 @@
 export { pocExportDocx } from './chunks/docxExport.mjs';
-import './shared/minuta-editor.b3351035.mjs';
+import './shared/minuta-editor.f1239e0b.mjs';
 import '@tiptap/pm/state';
 import '@tiptap/pm/view';
 import 'docx';

package/dist/index.d.mts

@@ -22,7 +22,7 @@ import { Transaction } from '@tiptap/pm/state';
 import { EditorView } from '@tiptap/pm/view';
 import { P as PocPageConfig } from './shared/minuta-editor.9e65d163.mjs';
 export { e as PAGINATE_META, a as PocDocxChrome, b as PocDocxExportOptions, s as PocLoneRow, d as PocPageBreak, c as PocPageNote, v as PocPaginationPlugin, u as breaksEqual, h as buildPocFooterEl, g as buildPocHeaderEl, j as buildPocNotesEl, l as computePocBreaks, t as computePocLoneRows, i as isPocChromeCanvas, n as isPocFlexRow, f as pocChromeFlowHeight, m as pocDescendsInto, r as pocLoneCellIndex, k as pocLooksLikeTitle, o as pocNodeHasVisibleContent, q as pocNodePaintsBox, p as pocPageKey } from './shared/minuta-editor.9e65d163.mjs';
-import '@tiptap/pm/model';
+import { Node as Node$1 } from '@tiptap/pm/model';
 
 /**
  * Variáveis de template da minuta — o formato do placeholder e a resolução dele.
@@ -206,6 +206,84 @@ declare function buildPocExtensions(pageConfig?: PocPageConfig, options?: {
     handleKeyDown?: (view: EditorView, event: KeyboardEvent) => boolean;
 }): (Node<any, any> | Extension<any, any> | Mark<any, any>)[];
 
+/**
+ * Impressão digital de um bloco da minuta (nó `minutaBlock` do editor) — base
+ * de "o advogado mexeu neste trecho?" quando o checklist muda com uma edição
+ * viva. O bloco nasce com `genHash` = impressão do texto gerado; enquanto a
+ * impressão atual bater com ela, o trecho é do checklist e pode ser
+ * re-gerado sem perder nada.
+ *
+ * Fica de fora o que muda SEM o advogado editar:
+ * - URL descartável de imagem (blob:/placeholder do load progressivo/vault:// do
+ *   save): a imagem entra pela identidade DURÁVEL (`imageIdentity`), então
+ *   trocar a imagem de verdade muda a impressão;
+ * - número de tópico e de nota (re-sequenciam quando outro trecho muda);
+ * - valor das variáveis (o chip é atualizado no lugar, em qualquer bloco —
+ *   inclusive dentro de lista/tabela guardada como HTML cru).
+ *
+ * Mesma regra em `client/utils/minutaBlockFingerprint.ts` (o app ainda mantém a
+ * cópia dele) — a impressão gravada por um tem que bater com a do outro.
+ *
+ * Recebe o JSON do nó (`node.toJSON()`), então é pura e não depende de DOM.
+ */
+interface NodeJson {
+    type: string;
+    attrs?: Record<string, any>;
+    content?: NodeJson[];
+    marks?: {
+        type: string;
+        attrs?: Record<string, any>;
+    }[];
+    text?: string;
+}
+/**
+ * Identidade durável de uma imagem a partir do `src` (e do `data-vault-src` do
+ * placeholder do load progressivo) — no app, blob: do cache → vault://.
+ */
+type ImageIdentity = (src: string) => string;
+declare function minutaBlockFingerprint(blockJson: NodeJson, identity?: ImageIdentity): string;
+
+/**
+ * Checklist × edição viva, para quem usa o editor fora do defesa.ai.
+ *
+ * O documento editado continua dividido em `minutaBlock` (um por bloco do
+ * template, `isolating`), e cada bloco guarda em `genHash` a impressão digital
+ * do texto que o checklist gerou. Com isso, quando o checklist muda (tese que
+ * passou a valer, variável alterada), dá para aplicar a mudança SÓ onde ela
+ * cai, sem passar por cima do que o advogado escreveu:
+ *
+ * - tese que passou a gerar texto → o bloco entra na posição do template;
+ * - tese que deixou de gerar → o bloco sai (se foi editado, vira conflito);
+ * - variável alterada → o chip atualiza no lugar, em qualquer bloco;
+ * - bloco cuja ESTRUTURA mudou → re-gerado se ninguém o editou, conflito se sim.
+ *
+ * Mesma lógica de `client/composables/poc/pocEditionSync.ts` + o
+ * `syncEditionWithChecklist` do app; aqui o documento gerado chega pronto (o
+ * `GET /data/case/:id/html?source=blocks`), em vez de renderizado no browser.
+ */
+interface MinutaChecklistConflict {
+    blockId: string;
+    blockTitle: string | null;
+    /** `replace`: o checklist mudou o texto de um trecho editado; `remove`: desligou uma tese editada */
+    kind: 'replace' | 'remove';
+}
+interface MinutaChecklistResult {
+    inserted: string[];
+    removed: string[];
+    regenerated: string[];
+    /** quantos chips de variável mudaram de valor */
+    variablesUpdated: number;
+    /** conflitos abertos depois desta aplicação (inclui os que já estavam) */
+    conflicts: MinutaChecklistConflict[];
+    /** a tese pedida em `toggled.show` não gera texto (condições internas) */
+    toggledWithoutContent: boolean;
+    /** a remoção não aconteceu porque o documento ficaria sem nenhum bloco */
+    lastBlockKept: boolean;
+}
+declare function blockHash(node: Node$1, identity?: ImageIdentity): string;
+/** o conteúdo ainda é o que o checklist gerou (sem `genHash` = editado, por segurança) */
+declare function isBlockUntouched(node: Node$1, identity?: ImageIdentity): boolean;
+
 /**
  * O editor de minuta como coisa montável em qualquer lugar: `createMinutaEditor(el, opts)`.
  *
@@ -374,6 +452,35 @@ interface MinutaEditor {
      * guarda uma cópia do documento.
      */
     refreshVaultImages: (resolveUrl: (vaultUrl: string) => Promise<string>) => Promise<number>;
+    /**
+     * Checklist junto da edição: aplica o documento GERADO pelo checklist agora
+     * (o `GET /data/case/:id/html?source=blocks`) sobre o documento editado,
+     * bloco a bloco — tese que passou a valer entra na posição do template, a
+     * que deixou de valer sai, variáveis atualizam no lugar e trecho cuja
+     * estrutura mudou é re-gerado só se ninguém o editou (senão vira conflito).
+     * `toggled` força a decisão de UMA tese (o host ligou/desligou na mão).
+     * Uma transação só: o desfazer volta tudo. Blocos novos (e os aceitos em
+     * `resolveChecklistConflict`) podem trazer imagem `vault://` — chame
+     * `refreshVaultImages` depois de aplicar E de resolver os conflitos.
+     */
+    applyChecklist: (generatedHtml: string, options?: {
+        toggled?: {
+            blockId: string;
+            show: boolean;
+        };
+    }) => MinutaChecklistResult;
+    /** trechos editados que o checklist quer mudar e aguardam decisão do advogado */
+    checklistConflicts: () => MinutaChecklistConflict[];
+    /** `apply` usa o texto novo (ou remove); `keep` mantém o editado e não pergunta de novo pela mesma mudança */
+    resolveChecklistConflict: (blockId: string, resolution: 'keep' | 'apply') => boolean;
+    /**
+     * Marca todos os blocos como "texto gerado". Chame UMA vez ao criar a edição
+     * a partir do HTML do checklist — sem a marca, todo bloco conta como editado
+     * e o `applyChecklist` pergunta em vez de re-gerar. Devolve quantos marcou.
+     */
+    stampGenerated: () => number;
+    /** blocos (`data-block-id`) no documento, na ordem — para o checklist mostrar o que está no texto */
+    documentBlockIds: () => string[];
     /** repagina (o host chama após mudar algo que afeta altura fora do editor) */
     schedulePaginate: () => void;
     /** reconstrói cabeçalhos/rodapés com o chrome atual, sem repaginar */
@@ -561,5 +668,5 @@ declare function collectVaultRefs(html: string): string[];
 /** aplica as URLs resolvidas às `<img>` do trecho; tags sem resolução ficam como estão */
 declare function renewVaultImageTags(html: string, resolved: Map<string, string>): string;
 
-export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPageConfig, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, buildPocExtensions, collectVaultRefs, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteHtmlToRuns, footnoteSizePt, formatTopicNumber, fromRoman, iconSvg, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, shouldMoveBreakToHeading, swapVaultSrc, toRoman, topicNumberHtml, variableChipHtml, vaultImageHtml, vaultRefOf };
-export type { FootnoteRun, MinutaChromeText, MinutaEditor, MinutaEditorOptions, MinutaHeader, MinutaMargins, MinutaVariableCatalog, MinutaVariableDef, MinutaVariableRef, PocKeepWithNextItem, RefreshVaultImagesOptions, TopicNumberInfo, VariableClickKind };
+export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPageConfig, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, blockHash, buildPocExtensions, collectVaultRefs, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteHtmlToRuns, footnoteSizePt, formatTopicNumber, fromRoman, iconSvg, isBlockUntouched, minutaBlockFingerprint, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, shouldMoveBreakToHeading, swapVaultSrc, toRoman, topicNumberHtml, variableChipHtml, vaultImageHtml, vaultRefOf };
+export type { FootnoteRun, ImageIdentity, MinutaChecklistConflict, MinutaChecklistResult, MinutaChromeText, MinutaEditor, MinutaEditorOptions, MinutaHeader, MinutaMargins, MinutaVariableCatalog, MinutaVariableDef, MinutaVariableRef, PocKeepWithNextItem, RefreshVaultImagesOptions, TopicNumberInfo, VariableClickKind };

package/dist/index.d.ts

@@ -22,7 +22,7 @@ import { Transaction } from '@tiptap/pm/state';
 import { EditorView } from '@tiptap/pm/view';
 import { P as PocPageConfig } from './shared/minuta-editor.9e65d163.js';
 export { e as PAGINATE_META, a as PocDocxChrome, b as PocDocxExportOptions, s as PocLoneRow, d as PocPageBreak, c as PocPageNote, v as PocPaginationPlugin, u as breaksEqual, h as buildPocFooterEl, g as buildPocHeaderEl, j as buildPocNotesEl, l as computePocBreaks, t as computePocLoneRows, i as isPocChromeCanvas, n as isPocFlexRow, f as pocChromeFlowHeight, m as pocDescendsInto, r as pocLoneCellIndex, k as pocLooksLikeTitle, o as pocNodeHasVisibleContent, q as pocNodePaintsBox, p as pocPageKey } from './shared/minuta-editor.9e65d163.js';
-import '@tiptap/pm/model';
+import { Node as Node$1 } from '@tiptap/pm/model';
 
 /**
  * Variáveis de template da minuta — o formato do placeholder e a resolução dele.
@@ -206,6 +206,84 @@ declare function buildPocExtensions(pageConfig?: PocPageConfig, options?: {
     handleKeyDown?: (view: EditorView, event: KeyboardEvent) => boolean;
 }): (Node<any, any> | Extension<any, any> | Mark<any, any>)[];
 
+/**
+ * Impressão digital de um bloco da minuta (nó `minutaBlock` do editor) — base
+ * de "o advogado mexeu neste trecho?" quando o checklist muda com uma edição
+ * viva. O bloco nasce com `genHash` = impressão do texto gerado; enquanto a
+ * impressão atual bater com ela, o trecho é do checklist e pode ser
+ * re-gerado sem perder nada.
+ *
+ * Fica de fora o que muda SEM o advogado editar:
+ * - URL descartável de imagem (blob:/placeholder do load progressivo/vault:// do
+ *   save): a imagem entra pela identidade DURÁVEL (`imageIdentity`), então
+ *   trocar a imagem de verdade muda a impressão;
+ * - número de tópico e de nota (re-sequenciam quando outro trecho muda);
+ * - valor das variáveis (o chip é atualizado no lugar, em qualquer bloco —
+ *   inclusive dentro de lista/tabela guardada como HTML cru).
+ *
+ * Mesma regra em `client/utils/minutaBlockFingerprint.ts` (o app ainda mantém a
+ * cópia dele) — a impressão gravada por um tem que bater com a do outro.
+ *
+ * Recebe o JSON do nó (`node.toJSON()`), então é pura e não depende de DOM.
+ */
+interface NodeJson {
+    type: string;
+    attrs?: Record<string, any>;
+    content?: NodeJson[];
+    marks?: {
+        type: string;
+        attrs?: Record<string, any>;
+    }[];
+    text?: string;
+}
+/**
+ * Identidade durável de uma imagem a partir do `src` (e do `data-vault-src` do
+ * placeholder do load progressivo) — no app, blob: do cache → vault://.
+ */
+type ImageIdentity = (src: string) => string;
+declare function minutaBlockFingerprint(blockJson: NodeJson, identity?: ImageIdentity): string;
+
+/**
+ * Checklist × edição viva, para quem usa o editor fora do defesa.ai.
+ *
+ * O documento editado continua dividido em `minutaBlock` (um por bloco do
+ * template, `isolating`), e cada bloco guarda em `genHash` a impressão digital
+ * do texto que o checklist gerou. Com isso, quando o checklist muda (tese que
+ * passou a valer, variável alterada), dá para aplicar a mudança SÓ onde ela
+ * cai, sem passar por cima do que o advogado escreveu:
+ *
+ * - tese que passou a gerar texto → o bloco entra na posição do template;
+ * - tese que deixou de gerar → o bloco sai (se foi editado, vira conflito);
+ * - variável alterada → o chip atualiza no lugar, em qualquer bloco;
+ * - bloco cuja ESTRUTURA mudou → re-gerado se ninguém o editou, conflito se sim.
+ *
+ * Mesma lógica de `client/composables/poc/pocEditionSync.ts` + o
+ * `syncEditionWithChecklist` do app; aqui o documento gerado chega pronto (o
+ * `GET /data/case/:id/html?source=blocks`), em vez de renderizado no browser.
+ */
+interface MinutaChecklistConflict {
+    blockId: string;
+    blockTitle: string | null;
+    /** `replace`: o checklist mudou o texto de um trecho editado; `remove`: desligou uma tese editada */
+    kind: 'replace' | 'remove';
+}
+interface MinutaChecklistResult {
+    inserted: string[];
+    removed: string[];
+    regenerated: string[];
+    /** quantos chips de variável mudaram de valor */
+    variablesUpdated: number;
+    /** conflitos abertos depois desta aplicação (inclui os que já estavam) */
+    conflicts: MinutaChecklistConflict[];
+    /** a tese pedida em `toggled.show` não gera texto (condições internas) */
+    toggledWithoutContent: boolean;
+    /** a remoção não aconteceu porque o documento ficaria sem nenhum bloco */
+    lastBlockKept: boolean;
+}
+declare function blockHash(node: Node$1, identity?: ImageIdentity): string;
+/** o conteúdo ainda é o que o checklist gerou (sem `genHash` = editado, por segurança) */
+declare function isBlockUntouched(node: Node$1, identity?: ImageIdentity): boolean;
+
 /**
  * O editor de minuta como coisa montável em qualquer lugar: `createMinutaEditor(el, opts)`.
  *
@@ -374,6 +452,35 @@ interface MinutaEditor {
      * guarda uma cópia do documento.
      */
     refreshVaultImages: (resolveUrl: (vaultUrl: string) => Promise<string>) => Promise<number>;
+    /**
+     * Checklist junto da edição: aplica o documento GERADO pelo checklist agora
+     * (o `GET /data/case/:id/html?source=blocks`) sobre o documento editado,
+     * bloco a bloco — tese que passou a valer entra na posição do template, a
+     * que deixou de valer sai, variáveis atualizam no lugar e trecho cuja
+     * estrutura mudou é re-gerado só se ninguém o editou (senão vira conflito).
+     * `toggled` força a decisão de UMA tese (o host ligou/desligou na mão).
+     * Uma transação só: o desfazer volta tudo. Blocos novos (e os aceitos em
+     * `resolveChecklistConflict`) podem trazer imagem `vault://` — chame
+     * `refreshVaultImages` depois de aplicar E de resolver os conflitos.
+     */
+    applyChecklist: (generatedHtml: string, options?: {
+        toggled?: {
+            blockId: string;
+            show: boolean;
+        };
+    }) => MinutaChecklistResult;
+    /** trechos editados que o checklist quer mudar e aguardam decisão do advogado */
+    checklistConflicts: () => MinutaChecklistConflict[];
+    /** `apply` usa o texto novo (ou remove); `keep` mantém o editado e não pergunta de novo pela mesma mudança */
+    resolveChecklistConflict: (blockId: string, resolution: 'keep' | 'apply') => boolean;
+    /**
+     * Marca todos os blocos como "texto gerado". Chame UMA vez ao criar a edição
+     * a partir do HTML do checklist — sem a marca, todo bloco conta como editado
+     * e o `applyChecklist` pergunta em vez de re-gerar. Devolve quantos marcou.
+     */
+    stampGenerated: () => number;
+    /** blocos (`data-block-id`) no documento, na ordem — para o checklist mostrar o que está no texto */
+    documentBlockIds: () => string[];
     /** repagina (o host chama após mudar algo que afeta altura fora do editor) */
     schedulePaginate: () => void;
     /** reconstrói cabeçalhos/rodapés com o chrome atual, sem repaginar */
@@ -561,5 +668,5 @@ declare function collectVaultRefs(html: string): string[];
 /** aplica as URLs resolvidas às `<img>` do trecho; tags sem resolução ficam como estão */
 declare function renewVaultImageTags(html: string, resolved: Map<string, string>): string;
 
-export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPageConfig, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, buildPocExtensions, collectVaultRefs, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteHtmlToRuns, footnoteSizePt, formatTopicNumber, fromRoman, iconSvg, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, shouldMoveBreakToHeading, swapVaultSrc, toRoman, topicNumberHtml, variableChipHtml, vaultImageHtml, vaultRefOf };
-export type { FootnoteRun, MinutaChromeText, MinutaEditor, MinutaEditorOptions, MinutaHeader, MinutaMargins, MinutaVariableCatalog, MinutaVariableDef, MinutaVariableRef, PocKeepWithNextItem, RefreshVaultImagesOptions, TopicNumberInfo, VariableClickKind };
+export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPageConfig, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, blockHash, buildPocExtensions, collectVaultRefs, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteHtmlToRuns, footnoteSizePt, formatTopicNumber, fromRoman, iconSvg, isBlockUntouched, minutaBlockFingerprint, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, shouldMoveBreakToHeading, swapVaultSrc, toRoman, topicNumberHtml, variableChipHtml, vaultImageHtml, vaultRefOf };
+export type { FootnoteRun, ImageIdentity, MinutaChecklistConflict, MinutaChecklistResult, MinutaChromeText, MinutaEditor, MinutaEditorOptions, MinutaHeader, MinutaMargins, MinutaVariableCatalog, MinutaVariableDef, MinutaVariableRef, PocKeepWithNextItem, RefreshVaultImagesOptions, TopicNumberInfo, VariableClickKind };

package/dist/index.mjs

@@ -22,8 +22,10 @@ import TableCell from '@tiptap/extension-table-cell';
 import TableHeader from '@tiptap/extension-table-header';
 import TableRow from '@tiptap/extension-table-row';
 import { Plugin } from '@tiptap/pm/state';
-import { s as sanitizeRichHtml, T as TOPIC_DEFAULT_GROUP, c as TOPIC_NUMBER_ATTR, r as readTopicNumber, d as TOPIC_GROUP_ATTR, e as TOPIC_ROMAN_ATTR, g as TOPIC_REF_ATTR, a as formatTopicNumber, P as PocPaginationPlugin, h as sanitizeFootnoteHtml, i as computePocBreaks, j as pocPageKey, k as breaksEqual, l as PAGINATE_META } from './shared/minuta-editor.b3351035.mjs';
-export { q as buildPocFooterEl, o as buildPocHeaderEl, t as buildPocNotesEl, y as computePocLoneRows, f as footnoteHtmlToRuns, z as footnoteSizePt, C as fromRoman, n as isPocChromeCanvas, v as isPocFlexRow, m as pocChromeFlowHeight, u as pocDescendsInto, p as pocLoneCellIndex, b as pocLooksLikeTitle, w as pocNodeHasVisibleContent, x as pocNodePaintsBox, A as shouldMoveBreakToHeading, B as toRoman, D as topicNumberHtml } from './shared/minuta-editor.b3351035.mjs';
+import { s as sanitizeRichHtml, e as sanitizeFootnoteHtml, g as footnoteSizePt, T as TOPIC_DEFAULT_GROUP, h as TOPIC_NUMBER_ATTR, r as readTopicNumber, i as TOPIC_GROUP_ATTR, j as TOPIC_ROMAN_ATTR, k as TOPIC_REF_ATTR, a as formatTopicNumber, P as PocPaginationPlugin, l as computePocBreaks, m as pocPageKey, n as breaksEqual, o as PAGINATE_META } from './shared/minuta-editor.f1239e0b.mjs';
+export { v as buildPocFooterEl, u as buildPocHeaderEl, w as buildPocNotesEl, z as computePocLoneRows, f as footnoteHtmlToRuns, C as fromRoman, t as isPocChromeCanvas, y as isPocFlexRow, q as pocChromeFlowHeight, x as pocDescendsInto, p as pocLoneCellIndex, b as pocLooksLikeTitle, c as pocNodeHasVisibleContent, d as pocNodePaintsBox, A as shouldMoveBreakToHeading, B as toRoman, D as topicNumberHtml } from './shared/minuta-editor.f1239e0b.mjs';
+import { closeHistory } from '@tiptap/pm/history';
+import { DOMParser } from '@tiptap/pm/model';
 import '@tiptap/pm/view';
 
 const POC_ASSET_SWAP = "pocAssetSwap";
@@ -35,7 +37,18 @@ function htmlToDom(html) {
 const PocDocument = Node$1.create({
   name: "doc",
   topNode: true,
-  content: "minutaBlock+"
+  content: "minutaBlock+",
+  addAttributes() {
+    return {
+      /**
+       * Estado do checklist × edição (engine/checklistSync): teses que o
+       * checklist queria no texto na última aplicação + conflitos abertos.
+       * Vive NO documento para o desfazer do editor voltar junto com o
+       * texto; não vai para o HTML (sem documento salvo, nasce do texto).
+       */
+      checklist: { default: null, rendered: false, parseHTML: () => null }
+    };
+  }
 });
 const PocMinutaBlock = Node$1.create({
   name: "minutaBlock",
@@ -46,7 +59,17 @@ const PocMinutaBlock = Node$1.create({
   addAttributes() {
     return {
       blockId: { default: null },
-      blockTitle: { default: null }
+      blockTitle: { default: null },
+      /**
+       * impressão digital do texto GERADO pelo checklist (ver
+       * utils/minutaBlockFingerprint no app): enquanto o conteúdo bater
+       * com ela o trecho não foi editado e o checklist pode re-gerá-lo
+       */
+      genHash: {
+        default: null,
+        parseHTML: (el) => el.getAttribute("data-gen-hash"),
+        renderHTML: (attrs) => attrs.genHash ? { "data-gen-hash": attrs.genHash } : {}
+      }
     };
   },
   parseHTML() {
@@ -281,6 +304,14 @@ const PocVariableChip = Node$1.create({
     return {
       variableId: { default: null },
       parentBlockId: { default: null },
+      /**
+       * linha do `<for>` — distingue a mesma variável em linhas diferentes
+       * (`data-loop-index` do app; `data-variable-index` da Data API)
+       */
+      loopIndex: {
+        default: null,
+        parseHTML: (el) => el.getAttribute("data-loop-index") ?? el.getAttribute("data-variable-index")
+      },
       html: { default: "" },
       text: { default: "" }
     };
@@ -292,6 +323,7 @@ const PocVariableChip = Node$1.create({
       getAttrs: (el) => ({
         variableId: el.getAttribute("data-variable-id"),
         parentBlockId: el.getAttribute("data-parent-block-id"),
+        loopIndex: el.getAttribute("data-loop-index") ?? el.getAttribute("data-variable-index"),
         html: el.outerHTML,
         text: el.textContent ?? ""
       })
@@ -408,7 +440,9 @@ const PocFootnoteRef = Node$1.create({
   selectable: false,
   addAttributes() {
     return {
-      number: { default: "" },
+      // o Tiptap relê `number="1"` do `<footnote>` e o converte em número —
+      // e o render do ProseMirror só aceita texto como conteúdo
+      number: { default: "", parseHTML: (el) => el.getAttribute("number") ?? el.textContent ?? "" },
       /** conteúdo da nota em HTML de ênfase (b/i/u/br) */
       text: { default: "" },
       /** corpo declarado no template (`font-size: 9pt`), em pontos */
@@ -424,6 +458,17 @@ const PocFootnoteRef = Node$1.create({
         text: el.getAttribute("data-footnote") ?? "",
         size: Number.parseFloat(el.getAttribute("data-footnote-size") ?? "") || null
       })
+    }, {
+      // `<footnote>` cru do template (HTML de servidor antigo ou de
+      // outra origem): sem esta regra a tag some e o texto da nota
+      // cai no meio do parágrafo
+      tag: "footnote",
+      priority: 110,
+      getAttrs: (el) => ({
+        number: el.getAttribute("number") ?? "",
+        text: sanitizeFootnoteHtml(el.innerHTML.replace(/&nbsp;/g, " ")),
+        size: footnoteSizePt(el.getAttribute("style"))
+      })
     }];
   },
   renderHTML({ node }) {
@@ -705,7 +750,7 @@ const VARIABLE_TAG_RE = /<span\b[^>]*\bdata-minuta-var="([^"]*)"[^>]*>[^<]*<\/sp
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-function decodeAttr(value) {
+function decodeAttr$1(value) {
   return value.replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
 }
 function extractTemplateVariables(html) {
@@ -713,7 +758,7 @@ function extractTemplateVariables(html) {
     return [];
   const keys = [];
   for (const match of html.matchAll(VARIABLE_TAG_RE)) {
-    const key = decodeAttr(match[1] ?? "").trim();
+    const key = decodeAttr$1(match[1] ?? "").trim();
     if (key && !keys.includes(key))
       keys.push(key);
   }
@@ -724,7 +769,7 @@ function resolveTemplateVariables(html, values) {
     return { html: "", missing: [] };
   const missing = [];
   const resolved = html.replace(VARIABLE_TAG_RE, (tag, rawKey) => {
-    const key = decodeAttr(rawKey ?? "").trim();
+    const key = decodeAttr$1(rawKey ?? "").trim();
     if (!key)
       return tag;
     const value = values?.[key];
@@ -841,6 +886,362 @@ async function refreshVaultImages(editor, resolveUrl, options = {}) {
   return touched;
 }
 
+const IMG_TAG = /<img\b[^>]*>/g;
+const ATTR = (name) => new RegExp(`\\s${name}="([^"]*)"`);
+function decodeAttr(value) {
+  return value.replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+}
+function normalizeImgTags(html, identity) {
+  if (!html.includes("<img"))
+    return html;
+  return html.replace(IMG_TAG, (tag) => {
+    const vault = tag.match(ATTR("data-vault-src"))?.[1];
+    const src = tag.match(ATTR("src"))?.[1] ?? "";
+    const id = vault ? decodeAttr(vault) : identity(decodeAttr(src));
+    return tag.replace(/\s(?:src|data-vault-src|data-download-url)="[^"]*"/g, "").replace(/^<img\b/, `<img data-img="${id}"`);
+  });
+}
+const CHIP_SPAN = /<span\b([^>]*\sdata-variable-id="[^"]*"[^>]*)>[\s\S]*?<\/span>/g;
+function normalizeChipSpans(html) {
+  if (!html.includes("data-variable-id"))
+    return html;
+  return html.replace(CHIP_SPAN, (_all, attrs) => {
+    const id = attrs.match(/\sdata-variable-id="([^"]*)"/)?.[1] ?? "";
+    const index = attrs.match(/\sdata-(?:loop|variable)-index="([^"]*)"/)?.[1] ?? "";
+    return `<var:${id}:${index}>`;
+  });
+}
+function normalizeAttrs(attrs, identity, chipSpans = true) {
+  if (!attrs)
+    return void 0;
+  const out = {};
+  for (const key of Object.keys(attrs).sort()) {
+    if (key === "genHash" || key === "uid")
+      continue;
+    const value = attrs[key];
+    if (key === "src" && typeof value === "string") {
+      out[key] = identity(value);
+    } else {
+      out[key] = typeof value === "string" ? chipSpans ? normalizeChipSpans(normalizeImgTags(value, identity)) : normalizeImgTags(value, identity) : value;
+    }
+  }
+  return out;
+}
+function normalize(node, identity, chipSpans = true) {
+  switch (node.type) {
+    case "variableChip":
+      return ["var", node.attrs?.variableId ?? null];
+    case "topicNumber":
+      return ["topic", node.attrs?.group ?? null, !!node.attrs?.ref];
+    case "footnoteRef":
+      return ["note", node.attrs?.text ?? "", node.attrs?.size ?? null];
+    case "text":
+      return ["text", node.text ?? "", (node.marks ?? []).map((mark) => [mark.type, normalizeAttrs(mark.attrs, identity, chipSpans)])];
+  }
+  return [node.type, normalizeAttrs(node.attrs, identity, chipSpans), (node.content ?? []).map((child) => normalize(child, identity, chipSpans))];
+}
+function fnv1a(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function minutaBlockFingerprint(blockJson, identity = (src) => src) {
+  const body = JSON.stringify((blockJson.content ?? []).map((child) => normalize(child, identity)));
+  return `${fnv1a(body)}${body.length.toString(16)}`;
+}
+function minutaBlockFingerprintV1(blockJson, identity = (src) => src) {
+  const body = JSON.stringify((blockJson.content ?? []).map((child) => normalize(child, identity, false)));
+  return `${fnv1a(body)}${body.length.toString(16)}`;
+}
+
+function readChecklist(doc) {
+  const stored = doc.attrs.checklist;
+  return stored ?? { wanted: [...docBlocks(doc).keys()], pending: [] };
+}
+const defaultImageIdentity = (src) => src;
+function blockHash(node, identity = defaultImageIdentity) {
+  return minutaBlockFingerprint(node.toJSON(), identity);
+}
+function isBlockUntouched(node, identity = defaultImageIdentity) {
+  const genHash = node.attrs.genHash;
+  if (!genHash)
+    return false;
+  return genHash === blockHash(node, identity) || genHash === minutaBlockFingerprintV1(node.toJSON(), identity);
+}
+function docBlocks(doc) {
+  const map = /* @__PURE__ */ new Map();
+  doc.forEach((node, offset) => {
+    const id = node.attrs.blockId;
+    if (node.type.name === "minutaBlock" && id && !map.has(id))
+      map.set(id, { pos: offset, node });
+  });
+  return map;
+}
+function parseGeneratedBlocks(schema, html, identity = defaultImageIdentity) {
+  const wrapper = document.createElement("div");
+  wrapper.innerHTML = html;
+  const doc = DOMParser.fromSchema(schema).parse(wrapper);
+  const blocks = [];
+  doc.forEach((node) => {
+    if (node.type.name === "minutaBlock" && node.attrs.blockId)
+      blocks.push(node.type.create({ ...node.attrs, genHash: blockHash(node, identity) }, node.content, node.marks));
+  });
+  return blocks;
+}
+function stampGeneratedBlocks(editor, identity = defaultImageIdentity) {
+  const tr = editor.state.tr;
+  let stamped = 0;
+  editor.state.doc.forEach((node, offset) => {
+    if (node.type.name !== "minutaBlock")
+      return;
+    const genHash = blockHash(node, identity);
+    if (node.attrs.genHash !== genHash) {
+      tr.setNodeMarkup(offset, void 0, { ...node.attrs, genHash });
+      stamped++;
+    }
+  });
+  if (tr.docChanged)
+    editor.view.dispatch(tr);
+  return stamped;
+}
+function baseChipKey(variableId, parentBlockId) {
+  return `${parentBlockId ?? ""}|${variableId ?? ""}`;
+}
+function chipKey(variableId, parentBlockId, loopIndex) {
+  return `${baseChipKey(variableId, parentBlockId)}|${loopIndex ?? ""}`;
+}
+function collectChips(html) {
+  const wrapper = document.createElement("div");
+  wrapper.innerHTML = html;
+  const byKey = /* @__PURE__ */ new Map();
+  const byBase = /* @__PURE__ */ new Map();
+  wrapper.querySelectorAll("span[data-variable-id]").forEach((el) => {
+    const variableId = el.getAttribute("data-variable-id");
+    const parentBlockId = el.getAttribute("data-parent-block-id");
+    const loopIndex = el.getAttribute("data-loop-index") ?? el.getAttribute("data-variable-index");
+    const value = { html: el.outerHTML, text: el.textContent ?? "", loopIndex };
+    for (const [map, key] of [[byKey, chipKey(variableId, parentBlockId, loopIndex)], [byBase, baseChipKey(variableId, parentBlockId)]]) {
+      const list = map.get(key) ?? [];
+      list.push(value);
+      map.set(key, list);
+    }
+  });
+  return { byKey, byBase };
+}
+function matchByValue(docChips, generated) {
+  const pairs = [];
+  const count = (list, text) => list.filter((t) => t === text).length;
+  const docTexts = docChips.map((chip) => chip.node.attrs.text);
+  const genTexts = generated.map((value) => value.text);
+  const freeDoc = new Set(docChips.keys());
+  const freeGen = new Set(generated.keys());
+  docChips.forEach((chip, i) => {
+    const text = docTexts[i];
+    if (count(docTexts, text) !== 1 || count(genTexts, text) !== 1)
+      return;
+    const j = genTexts.indexOf(text);
+    pairs.push({ ...chip, next: generated[j] });
+    freeDoc.delete(i);
+    freeGen.delete(j);
+  });
+  if (freeDoc.size === 1 && freeGen.size === 1) {
+    const [i] = freeDoc;
+    const [j] = freeGen;
+    pairs.push({ ...docChips[i], next: generated[j] });
+  }
+  return pairs;
+}
+function refreshChips(tr, chips) {
+  const inDoc = /* @__PURE__ */ new Map();
+  tr.doc.descendants((node, pos) => {
+    if (node.type.name !== "variableChip")
+      return;
+    const key = chipKey(node.attrs.variableId, node.attrs.parentBlockId, node.attrs.loopIndex);
+    const list = inDoc.get(key) ?? [];
+    list.push({ pos, node });
+    inDoc.set(key, list);
+  });
+  let changed = 0;
+  for (const [key, docChips] of inDoc) {
+    let generated = chips.byKey.get(key);
+    if (!generated?.length && docChips[0].node.attrs.loopIndex == null) {
+      const { variableId, parentBlockId } = docChips[0].node.attrs;
+      generated = chips.byBase.get(baseChipKey(variableId, parentBlockId));
+    }
+    if (!generated?.length)
+      continue;
+    const values = generated;
+    const uniform = values.every((value) => value.html === values[0].html);
+    const pairs = uniform ? docChips.map((chip) => ({ ...chip, next: values[0] })) : matchByValue(docChips, values);
+    for (const { pos, node, next } of pairs) {
+      const loopIndex = uniform ? node.attrs.loopIndex : next.loopIndex ?? node.attrs.loopIndex;
+      if (next.html === node.attrs.html && loopIndex === node.attrs.loopIndex)
+        continue;
+      tr.setNodeMarkup(pos, void 0, { ...node.attrs, html: next.html, text: next.text, loopIndex });
+      if (next.text !== node.attrs.text)
+        changed++;
+    }
+  }
+  return changed;
+}
+function refreshIslandChips(tr, chips) {
+  let changed = 0;
+  tr.doc.descendants((node, pos) => {
+    if (node.type.name !== "htmlIsland" || !String(node.attrs.html ?? "").includes("data-variable-id"))
+      return;
+    const tpl = document.createElement("template");
+    tpl.innerHTML = node.attrs.html;
+    let touched = false;
+    tpl.content.querySelectorAll("span[data-variable-id]").forEach((el) => {
+      const key = chipKey(
+        el.getAttribute("data-variable-id"),
+        el.getAttribute("data-parent-block-id"),
+        el.getAttribute("data-loop-index") ?? el.getAttribute("data-variable-index")
+      );
+      const values = chips.byKey.get(key);
+      if (!values?.length || values.some((value) => value.html !== values[0].html))
+        return;
+      if (el.outerHTML !== values[0].html) {
+        if (el.textContent !== values[0].text)
+          changed++;
+        el.outerHTML = values[0].html;
+        touched = true;
+      }
+    });
+    if (touched)
+      tr.setNodeMarkup(pos, void 0, { ...node.attrs, html: tpl.innerHTML });
+    return false;
+  });
+  return changed;
+}
+function insertPos(doc, blockId, order) {
+  const present = docBlocks(doc);
+  const index = order.indexOf(blockId);
+  for (let i = index - 1; i >= 0; i--) {
+    const prev = present.get(order[i]);
+    if (prev)
+      return prev.pos + prev.node.nodeSize;
+  }
+  return 0;
+}
+function listConflicts(doc) {
+  return readChecklist(doc).pending.map(({ blockId, kind, title }) => ({ blockId, blockTitle: title, kind }));
+}
+function applyChecklistToDocument(editor, generatedHtml, options = {}) {
+  const identity = options.imageIdentity ?? defaultImageIdentity;
+  const generated = parseGeneratedBlocks(editor.schema, generatedHtml, identity);
+  const genById = new Map(generated.map((node) => [node.attrs.blockId, node]));
+  const order = generated.map((node) => node.attrs.blockId);
+  const wanted = new Set(order);
+  const stored = readChecklist(editor.state.doc);
+  const before = new Set(stored.wanted);
+  const previousPending = new Map(stored.pending.map((entry) => [entry.blockId, entry]));
+  const pending = /* @__PURE__ */ new Map();
+  const toggled = options.toggled;
+  const tr = editor.state.tr;
+  const result = {
+    inserted: [],
+    removed: [],
+    regenerated: [],
+    variablesUpdated: 0,
+    conflicts: [],
+    toggledWithoutContent: false,
+    lastBlockKept: false
+  };
+  const setConflict = (id, kind, node, title) => {
+    pending.set(id, { blockId: id, kind, title, node: node ? node.toJSON() : null });
+  };
+  const ids = [...order, ...[...docBlocks(tr.doc).keys()].filter((id) => !wanted.has(id))];
+  if (toggled && !ids.includes(toggled.blockId))
+    ids.push(toggled.blockId);
+  for (const id of ids) {
+    const fresh = genById.get(id) ?? null;
+    const explicit = toggled?.blockId === id;
+    const turnedOn = explicit ? toggled.show : !before.has(id) && !!fresh;
+    const turnedOff = explicit ? !toggled.show : before.has(id) && !fresh;
+    const present = docBlocks(tr.doc).get(id);
+    if (!present) {
+      if (turnedOn && fresh) {
+        tr.insert(insertPos(tr.doc, id, order), fresh);
+        result.inserted.push(id);
+      } else if (explicit && toggled.show && !fresh) {
+        result.toggledWithoutContent = true;
+      }
+      continue;
+    }
+    const untouched = isBlockUntouched(present.node, identity);
+    const title = present.node.attrs.blockTitle ?? null;
+    if (!fresh || turnedOff) {
+      if (!turnedOff) {
+        const open = previousPending.get(id);
+        if (!untouched && open?.kind === "remove")
+          pending.set(id, open);
+        continue;
+      }
+      if (tr.doc.childCount <= 1) {
+        result.lastBlockKept = true;
+        continue;
+      }
+      if (untouched) {
+        tr.delete(present.pos, present.pos + present.node.nodeSize);
+        result.removed.push(id);
+      } else {
+        setConflict(id, "remove", null, title);
+      }
+      continue;
+    }
+    if (fresh.attrs.genHash === present.node.attrs.genHash)
+      continue;
+    if (untouched) {
+      tr.replaceWith(present.pos, present.pos + present.node.nodeSize, fresh);
+      result.regenerated.push(id);
+    } else {
+      setConflict(id, "replace", fresh, title);
+    }
+  }
+  const chips = collectChips(generatedHtml);
+  result.variablesUpdated = refreshChips(tr, chips) + refreshIslandChips(tr, chips);
+  const next = { wanted: [...wanted], pending: [...pending.values()] };
+  if (JSON.stringify(next) !== JSON.stringify(stored) || tr.docChanged)
+    tr.setDocAttribute("checklist", next);
+  if (tr.docChanged) {
+    editor.view.dispatch(closeHistory(tr));
+  }
+  result.conflicts = next.pending.map(({ blockId, kind, title }) => ({ blockId, blockTitle: title, kind }));
+  return result;
+}
+function resolveChecklistConflict(editor, blockId, resolution) {
+  const stored = readChecklist(editor.state.doc);
+  const entry = stored.pending.find((item) => item.blockId === blockId);
+  const present = docBlocks(editor.state.doc).get(blockId);
+  const tr = editor.state.tr;
+  const rest = { ...stored, pending: stored.pending.filter((item) => item.blockId !== blockId) };
+  if (!entry || !present) {
+    if (entry) {
+      tr.setDocAttribute("checklist", rest);
+      editor.view.dispatch(tr);
+    }
+    return false;
+  }
+  if (resolution === "apply" && entry.kind === "remove" && editor.state.doc.childCount <= 1)
+    return false;
+  const fresh = entry.node ? editor.schema.nodeFromJSON(entry.node) : null;
+  if (resolution === "apply") {
+    if (entry.kind === "remove")
+      tr.delete(present.pos, present.pos + present.node.nodeSize);
+    else if (fresh)
+      tr.replaceWith(present.pos, present.pos + present.node.nodeSize, fresh);
+  } else if (entry.kind === "replace" && fresh) {
+    tr.setNodeMarkup(present.pos, void 0, { ...present.node.attrs, genHash: fresh.attrs.genHash });
+  }
+  tr.setDocAttribute("checklist", rest);
+  editor.view.dispatch(closeHistory(tr));
+  return true;
+}
+
 function h(tag, attrs = {}, children = []) {
   const el = document.createElement(tag);
   if (attrs.class)
@@ -2144,6 +2545,32 @@ function createMinutaEditor(element, opts) {
         return Promise.resolve(0);
       return refreshVaultImages(ed, resolveUrl, { meta: { [POC_ASSET_SWAP]: true } });
     },
+    applyChecklist(generatedHtml, options) {
+      const ed = tiptap;
+      if (!ed || ed.isDestroyed)
+        throw new Error("editor n\xE3o montado");
+      return applyChecklistToDocument(ed, generatedHtml, options ?? {});
+    },
+    checklistConflicts() {
+      const ed = tiptap;
+      return ed && !ed.isDestroyed ? listConflicts(ed.state.doc) : [];
+    },
+    resolveChecklistConflict(blockId, resolution) {
+      const ed = tiptap;
+      if (!ed || ed.isDestroyed)
+        return false;
+      return resolveChecklistConflict(ed, blockId, resolution);
+    },
+    stampGenerated() {
+      const ed = tiptap;
+      if (!ed || ed.isDestroyed)
+        return 0;
+      return stampGeneratedBlocks(ed);
+    },
+    documentBlockIds() {
+      const ed = tiptap;
+      return ed && !ed.isDestroyed ? [...docBlocks(ed.state.doc).keys()] : [];
+    },
     schedulePaginate,
     refreshChrome,
     totalPages: () => totalPages,
@@ -2163,4 +2590,4 @@ function createMinutaEditor(element, opts) {
   return api;
 }
 
-export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, PAGINATE_META, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPaginationPlugin, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, breaksEqual, buildPocExtensions, collectVaultRefs, computePocBreaks, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, formatTopicNumber, iconSvg, pocPageKey, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, swapVaultSrc, variableChipHtml, vaultImageHtml, vaultRefOf };
+export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, PAGINATE_META, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPaginationPlugin, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, blockHash, breaksEqual, buildPocExtensions, collectVaultRefs, computePocBreaks, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteSizePt, formatTopicNumber, iconSvg, isBlockUntouched, minutaBlockFingerprint, pocPageKey, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, swapVaultSrc, variableChipHtml, vaultImageHtml, vaultRefOf };

package/dist/shared/{minuta-editor.b3351035.mjs → minuta-editor.f1239e0b.mjs}

@@ -75,84 +75,6 @@ function sanitizeRichHtml(html) {
   return tpl.innerHTML;
 }
 
-const TOPIC_NUMBER_ATTR = "data-topic-number";
-const TOPIC_GROUP_ATTR = "data-topic-group";
-const TOPIC_ROMAN_ATTR = "data-topic-roman";
-const TOPIC_REF_ATTR = "data-topic-ref";
-const TOPIC_DEFAULT_GROUP = "default";
-function toRoman(num) {
-  if (!Number.isFinite(num) || num <= 0)
-    return "";
-  const numerals = [
-    [1e3, "M"],
-    [900, "CM"],
-    [500, "D"],
-    [400, "CD"],
-    [100, "C"],
-    [90, "XC"],
-    [50, "L"],
-    [40, "XL"],
-    [10, "X"],
-    [9, "IX"],
-    [5, "V"],
-    [4, "IV"],
-    [1, "I"]
-  ];
-  let result = "";
-  let rest = Math.floor(num);
-  for (const [value, numeral] of numerals) {
-    while (rest >= value) {
-      result += numeral;
-      rest -= value;
-    }
-  }
-  return result;
-}
-function fromRoman(text) {
-  const upper = text.trim().toUpperCase();
-  if (!upper || !/^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$/.test(upper))
-    return null;
-  const values = { I: 1, V: 5, X: 10, L: 50, C: 100, D: 500, M: 1e3 };
-  let total = 0;
-  for (let i = 0; i < upper.length; i++) {
-    const current = values[upper[i]];
-    const next = values[upper[i + 1] ?? ""] ?? 0;
-    total += current < next ? -current : current;
-  }
-  return total;
-}
-function formatTopicNumber(number, roman) {
-  return roman ? toRoman(number) : String(number);
-}
-function escapeAttr(value) {
-  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function topicNumberHtml(info) {
-  let attrs = `${TOPIC_NUMBER_ATTR}="${info.number}" ${TOPIC_GROUP_ATTR}="${escapeAttr(info.group || TOPIC_DEFAULT_GROUP)}"`;
-  if (info.roman)
-    attrs += ` ${TOPIC_ROMAN_ATTR}="true"`;
-  if (info.ref)
-    attrs += ` ${TOPIC_REF_ATTR}="true"`;
-  return `<span ${attrs}>${formatTopicNumber(info.number, info.roman)}</span>`;
-}
-function readTopicNumber(el) {
-  const roman = el.getAttribute(TOPIC_ROMAN_ATTR) === "true";
-  const raw = el.getAttribute(TOPIC_NUMBER_ATTR) ?? "";
-  let number = Number.parseInt(raw, 10);
-  if (!Number.isFinite(number)) {
-    const text = el.textContent?.trim() ?? "";
-    number = Number.parseInt(text, 10);
-    if (!Number.isFinite(number))
-      number = fromRoman(text) ?? 1;
-  }
-  return {
-    number,
-    group: el.getAttribute(TOPIC_GROUP_ATTR) || TOPIC_DEFAULT_GROUP,
-    roman,
-    ref: el.getAttribute(TOPIC_REF_ATTR) === "true"
-  };
-}
-
 const INLINE_TAGS = /* @__PURE__ */ new Set(["B", "STRONG", "I", "EM", "U", "SUP", "SUB", "BR"]);
 function safeHref(value) {
   const href = (value ?? "").trim();
@@ -208,12 +130,12 @@ function sanitizeFootnoteHtml(html) {
       return style ? `<span style="${style}">${inner}</span>` : inner;
     }
     if (node.tagName === "DIV" || node.tagName === "P")
-      return inner ? `${inner}<br>` : "";
+      return inner.trim() ? `${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();
+  return Array.from(root.childNodes).map(walk).join("").replace(/\s+/g, " ").replace(/^(\s*<br>)+/i, "").replace(/(<br>\s*)+$/i, "").trim();
 }
 function footnoteHtmlToRuns(html) {
   const runs = [];
@@ -271,6 +193,84 @@ function footnoteSizePt(style) {
   return Number.isFinite(value) ? value : null;
 }
 
+const TOPIC_NUMBER_ATTR = "data-topic-number";
+const TOPIC_GROUP_ATTR = "data-topic-group";
+const TOPIC_ROMAN_ATTR = "data-topic-roman";
+const TOPIC_REF_ATTR = "data-topic-ref";
+const TOPIC_DEFAULT_GROUP = "default";
+function toRoman(num) {
+  if (!Number.isFinite(num) || num <= 0)
+    return "";
+  const numerals = [
+    [1e3, "M"],
+    [900, "CM"],
+    [500, "D"],
+    [400, "CD"],
+    [100, "C"],
+    [90, "XC"],
+    [50, "L"],
+    [40, "XL"],
+    [10, "X"],
+    [9, "IX"],
+    [5, "V"],
+    [4, "IV"],
+    [1, "I"]
+  ];
+  let result = "";
+  let rest = Math.floor(num);
+  for (const [value, numeral] of numerals) {
+    while (rest >= value) {
+      result += numeral;
+      rest -= value;
+    }
+  }
+  return result;
+}
+function fromRoman(text) {
+  const upper = text.trim().toUpperCase();
+  if (!upper || !/^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$/.test(upper))
+    return null;
+  const values = { I: 1, V: 5, X: 10, L: 50, C: 100, D: 500, M: 1e3 };
+  let total = 0;
+  for (let i = 0; i < upper.length; i++) {
+    const current = values[upper[i]];
+    const next = values[upper[i + 1] ?? ""] ?? 0;
+    total += current < next ? -current : current;
+  }
+  return total;
+}
+function formatTopicNumber(number, roman) {
+  return roman ? toRoman(number) : String(number);
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function topicNumberHtml(info) {
+  let attrs = `${TOPIC_NUMBER_ATTR}="${info.number}" ${TOPIC_GROUP_ATTR}="${escapeAttr(info.group || TOPIC_DEFAULT_GROUP)}"`;
+  if (info.roman)
+    attrs += ` ${TOPIC_ROMAN_ATTR}="true"`;
+  if (info.ref)
+    attrs += ` ${TOPIC_REF_ATTR}="true"`;
+  return `<span ${attrs}>${formatTopicNumber(info.number, info.roman)}</span>`;
+}
+function readTopicNumber(el) {
+  const roman = el.getAttribute(TOPIC_ROMAN_ATTR) === "true";
+  const raw = el.getAttribute(TOPIC_NUMBER_ATTR) ?? "";
+  let number = Number.parseInt(raw, 10);
+  if (!Number.isFinite(number)) {
+    const text = el.textContent?.trim() ?? "";
+    number = Number.parseInt(text, 10);
+    if (!Number.isFinite(number))
+      number = fromRoman(text) ?? 1;
+  }
+  return {
+    number,
+    group: el.getAttribute(TOPIC_GROUP_ATTR) || TOPIC_DEFAULT_GROUP,
+    roman,
+    ref: el.getAttribute(TOPIC_REF_ATTR) === "true"
+  };
+}
+
 function shouldMoveBreakToHeading(params) {
   const { heading, item, pageStart, capacity } = params;
   if (!heading || !heading.heading || heading.marker)
@@ -897,4 +897,4 @@ function PocPaginationPlugin(cfg) {
   });
 }
 
-export { shouldMoveBreakToHeading as A, toRoman as B, fromRoman as C, topicNumberHtml as D, PocPaginationPlugin as P, TOPIC_DEFAULT_GROUP as T, formatTopicNumber as a, pocLooksLikeTitle as b, TOPIC_NUMBER_ATTR as c, TOPIC_GROUP_ATTR as d, TOPIC_ROMAN_ATTR as e, footnoteHtmlToRuns as f, TOPIC_REF_ATTR as g, sanitizeFootnoteHtml as h, computePocBreaks as i, pocPageKey as j, breaksEqual as k, PAGINATE_META as l, pocChromeFlowHeight as m, isPocChromeCanvas as n, buildPocHeaderEl as o, pocLoneCellIndex as p, buildPocFooterEl as q, readTopicNumber as r, sanitizeRichHtml as s, buildPocNotesEl as t, pocDescendsInto as u, isPocFlexRow as v, pocNodeHasVisibleContent as w, pocNodePaintsBox as x, computePocLoneRows as y, footnoteSizePt as z };
+export { shouldMoveBreakToHeading as A, toRoman as B, fromRoman as C, topicNumberHtml as D, PocPaginationPlugin as P, TOPIC_DEFAULT_GROUP as T, formatTopicNumber as a, pocLooksLikeTitle as b, pocNodeHasVisibleContent as c, pocNodePaintsBox as d, sanitizeFootnoteHtml as e, footnoteHtmlToRuns as f, footnoteSizePt as g, TOPIC_NUMBER_ATTR as h, TOPIC_GROUP_ATTR as i, TOPIC_ROMAN_ATTR as j, TOPIC_REF_ATTR as k, computePocBreaks as l, pocPageKey as m, breaksEqual as n, PAGINATE_META as o, pocLoneCellIndex as p, pocChromeFlowHeight as q, readTopicNumber as r, sanitizeRichHtml as s, isPocChromeCanvas as t, buildPocHeaderEl as u, buildPocFooterEl as v, buildPocNotesEl as w, pocDescendsInto as x, isPocFlexRow as y, computePocLoneRows as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/minuta-editor",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Editor de minuta do defesa.ai sem framework: folha A4 paginada, edição rica, placeholders de variável e export DOCX fiel ao preview — monta em qualquer app (React, Vue, vanilla)",
   "repository": {
     "type": "git",