ask-marcel-office-cli 2.4.0 → 2.5.0

package/dist/cli.js

@@ -14817,7 +14817,10 @@ var extractPeople = (root) => {
   return out;
 }, extractFormatChanges = (root) => [
   ...changesIn(root, "w:r", "w:rPr", "w:rPrChange", "run"),
-  ...changesIn(root, "w:p", "w:pPr", "w:pPrChange", "paragraph")
+  ...changesIn(root, "w:p", "w:pPr", "w:pPrChange", "paragraph"),
+  ...changesIn(root, "w:tbl", "w:tblPr", "w:tblPrChange", "table"),
+  ...changesIn(root, "w:tr", "w:trPr", "w:trPrChange", "row"),
+  ...changesIn(root, "w:tc", "w:tcPr", "w:tcPrChange", "cell")
 ], extractDocxMetadata = async (bytes) => {
   const zipR = await openOoxmlZip(bytes);
   if (!zipR.ok)
@@ -15266,6 +15269,8 @@ var TEXT2 = "#text", ATTRS2 = ":@", MAX_REPEAT = 1024, parser3, tagOf2 = (node)
   return [padRow(rows[0] ?? []), separator, ...rows.slice(1).map(padRow)].join(`
 `);
 }, renderBlock = (node, tag) => {
+  if (tag === "text:tracked-changes")
+    return [];
   const kids = kidsOf(node, tag);
   if (tag === "text:h")
     return [renderHeading(node, kids)];
@@ -16095,7 +16100,7 @@ var init_download_drive_item_as_markdown = __esm(() => {
         name: "include-metadata",
         key: "includeMetadata",
         required: false,
-        description: "Pass `--include-metadata true` to surface the side-channel content the rendered body hides. For docx (`## DOCX metadata`): core/app/custom document properties, people registry, external hyperlinks, comments, tracked changes (a deletion sitting next to an insertion by the same author is reported once as a `replacement` carrying `before` + `after`; the halves that pair with nothing stay under `insertions` / `deletions`; `moves` joins the two ends of a moved span by its range name; `formatChanges` names which run or paragraph properties a reviewer altered. Table-structure revisions — cell insert / delete / merge, numbering and section properties — are still unreported), hidden-formatted text (w:vanish), field instructions (MERGEFIELD / HYPERLINK / DOCVARIABLE), bookmarks. For xlsx (`## Workbook metadata`): core/app/custom properties, external relationships, defined names, hidden / very-hidden sheets, legacy cell comments, threaded comments, persons. For pptx (`## PPTX metadata`): properties, external relationships, slide tags, comment authors + comments (legacy + modern), and per-slide title / speaker notes / hidden flag — returned as a standalone document since pptx has no convertible body (use `download-drive-item-as-pdf` for slide visuals). For OpenDocument (`.odt`/`.ods`/`.odp`, `## OpenDocument metadata`): Dublin Core + ODF properties, keywords, user-defined custom fields — appended after the converted body. Each OOXML family also covers its macro-enabled (`.docm` / `.xlsm` / `.pptm`) and template (`.dotx` / `.xltx` / `.potx`, etc.) variants, with a `### Macros (VBA)` section flagging an embedded `vbaProject.bin`. No-op on other sources.",
+        description: "Pass `--include-metadata true` to surface the side-channel content the rendered body hides. For docx (`## DOCX metadata`): core/app/custom document properties, people registry, external hyperlinks, comments, tracked changes (a deletion sitting next to an insertion by the same author is reported once as a `replacement` carrying `before` + `after`; the halves that pair with nothing stay under `insertions` / `deletions`; `moves` joins the two ends of a moved span by its range name; `formatChanges` names which run, paragraph, table, row or cell properties a reviewer altered, and a property whose values hang off child elements rather than its own attributes (`w:tblBorders` is the common one) is reported with its author and scope but names no property. Structural revisions — cell insert / delete / merge, numbering and section properties — are still unreported), hidden-formatted text (w:vanish), field instructions (MERGEFIELD / HYPERLINK / DOCVARIABLE), bookmarks. For xlsx (`## Workbook metadata`): core/app/custom properties, external relationships, defined names, hidden / very-hidden sheets, legacy cell comments, threaded comments, persons. For pptx (`## PPTX metadata`): properties, external relationships, slide tags, comment authors + comments (legacy + modern), and per-slide title / speaker notes / hidden flag — returned as a standalone document since pptx has no convertible body (use `download-drive-item-as-pdf` for slide visuals). For OpenDocument (`.odt`/`.ods`/`.odp`, `## OpenDocument metadata`): Dublin Core + ODF properties, keywords, user-defined custom fields — appended after the converted body. Each OOXML family also covers its macro-enabled (`.docm` / `.xlsm` / `.pptm`) and template (`.dotx` / `.xltx` / `.potx`, etc.) variants, with a `### Macros (VBA)` section flagging an embedded `vbaProject.bin`. No-op on other sources.",
         argumentHint: { kind: "magicValue", values: ["true", "false"] }
       },
       keepQuotedOption,
@@ -17795,12 +17800,15 @@ __export(exports_convert_mail_to_markdown, {
   attachmentsListSchema: () => attachmentsListSchema,
   execute: () => execute18,
   fetchInlineImageBytes: () => fetchInlineImageBytes,
+  formatAddress: () => formatAddress2,
   formatBytes: () => formatBytes,
   isInlineImage: () => isInlineImage,
   meta: () => meta20,
+  nonEmpty: () => nonEmpty,
+  renderMessageAsMarkdown: () => renderMessageAsMarkdown,
   schema: () => schema18
 });
-var schema18, INLINE_IMAGE_SIZE_LIMIT_BYTES = 2000000, ATTACHMENT_METADATA_SELECT = "$select=id,name,contentType,size,isInline,microsoft.graph.fileAttachment/contentId", nonEmpty = (v) => typeof v === "string" && v !== "", formatAddress2 = (a) => {
+var schema18, INLINE_IMAGE_SIZE_LIMIT_BYTES = 2000000, ATTACHMENT_METADATA_SELECT = "$select=id,name,contentType,size,isInline,microsoft.graph.fileAttachment/contentId", nonEmpty = (v) => typeof v === "string" && v !== "", referencesCidImage = (html) => /\bsrc\s*=\s*["']cid:/i.test(html), formatAddress2 = (a) => {
   if (!nonEmpty(a?.address))
     return;
   return nonEmpty(a?.name) ? `${a.name} <${a.address}>` : a.address;
@@ -17832,12 +17840,12 @@ var schema18, INLINE_IMAGE_SIZE_LIMIT_BYTES = 2000000, ATTACHMENT_METADATA_SELEC
   if (n < 1e6)
     return `${(n / 1000).toFixed(1)} KB`;
   return `${(n / 1e6).toFixed(1)} MB`;
-}, isInlineImage = (a) => a.isInline === true && nonEmpty(a.contentType) && a.contentType.toLowerCase().startsWith("image/") && nonEmpty(a.contentId), fetchInlineImageBytes = async (graph, messageId, meta20) => {
+}, isInlineImage = (a) => a.isInline === true && nonEmpty(a.contentType) && a.contentType.toLowerCase().startsWith("image/") && nonEmpty(a.contentId), fetchInlineImageBytes = async (graph, resourcePath, meta20) => {
   if ((meta20.size ?? 0) > INLINE_IMAGE_SIZE_LIMIT_BYTES)
     return { meta: meta20, oversize: true };
   if (!nonEmpty(meta20.id))
     return { meta: meta20, oversize: false };
-  const fetched = await graph.get(`/me/messages/${messageId}/attachments/${meta20.id}`);
+  const fetched = await graph.get(`${resourcePath}/attachments/${meta20.id}`);
   if (!fetched.ok)
     return { meta: meta20, oversize: false };
   const body = fetched.value;
@@ -17857,7 +17865,7 @@ var schema18, INLINE_IMAGE_SIZE_LIMIT_BYTES = 2000000, ATTACHMENT_METADATA_SELEC
     out = out.replaceAll(`cid:${e.meta.contentId}`, label);
   }
   return out;
-}, renderFileAttachmentsList = (attachments, includeInlineImages = false) => {
+}, renderFileAttachmentsList = (attachments, includeInlineImages, fetchHint) => {
   const fileAttachments = attachments.filter((a) => (includeInlineImages || !isInlineImage(a)) && nonEmpty(a.name));
   if (fileAttachments.length === 0)
     return "";
@@ -17867,7 +17875,7 @@ var schema18, INLINE_IMAGE_SIZE_LIMIT_BYTES = 2000000, ATTACHMENT_METADATA_SELEC
     const id = nonEmpty(a.id) ? `, id: ${a.id}` : "";
     return `- ${a.name ?? ""}${size}${type}${id})`;
   });
-  return ["**Attachments:**", ...items, "_Use `convert-mail-attachment-to-pdf` or `get-mail-attachment` with the attachment id to fetch._"].join(`
+  return ["**Attachments:**", ...items, fetchHint].join(`
 `);
 }, withoutTags = (body) => {
   const [leadingText, ...afterTagOpen] = body.split("<");
@@ -17877,37 +17885,32 @@ var schema18, INLINE_IMAGE_SIZE_LIMIT_BYTES = 2000000, ATTACHMENT_METADATA_SELEC
   if (total === 0)
     return 100;
   return Math.round((total - visibleLength(body.slice(0, boundary))) / total * 100);
-}, execute18 = async (graph, params) => {
-  const parsed = schema18.safeParse(params);
-  if (!parsed.success)
-    return err({ type: "validation_error", message: formatZodError(parsed.error) });
-  const { messageId } = parsed.data;
-  const embedInlineImagesEnabled = parsed.data.inlineImages === "true";
-  const keepQuoted = parsed.data.keepQuoted === "true";
-  const fetched = await graph.get(`/me/messages/${messageId}`);
+}, renderMessageAsMarkdown = async (graph, resourcePath, options) => {
+  const { inlineImages: embedInlineImagesEnabled, keepQuoted } = options;
+  const fetched = await graph.get(resourcePath);
   if (!fetched.ok)
     return fetched;
   const m = fetched.value;
+  const rawHtml = m.body?.content ?? "";
   let attachments = [];
   let attachmentsListNote;
-  if (m.hasAttachments === true) {
-    const listed = await graph.get(`/me/messages/${messageId}/attachments?${ATTACHMENT_METADATA_SELECT}`);
+  if (m.hasAttachments === true || referencesCidImage(rawHtml)) {
+    const listed = await graph.get(`${resourcePath}/attachments?${ATTACHMENT_METADATA_SELECT}`);
     if (!listed.ok) {
       attachmentsListNote = `attachments-list fetch failed (${listed.error.type}: ${listed.error.message}) — markdown body returned without attachment metadata`;
     } else {
-      const parsed2 = attachmentsListSchema.safeParse(listed.value);
-      if (parsed2.success) {
-        attachments = parsed2.data.value ?? [];
+      const parsed = attachmentsListSchema.safeParse(listed.value);
+      if (parsed.success) {
+        attachments = parsed.data.value ?? [];
       } else {
-        attachmentsListNote = `attachments-list returned a malformed shape (${formatZodError(parsed2.error)}) — markdown body returned without attachment metadata`;
+        attachmentsListNote = `attachments-list returned a malformed shape (${formatZodError(parsed.error)}) — markdown body returned without attachment metadata`;
       }
     }
   }
   const inlineImageCandidates = embedInlineImagesEnabled ? attachments.filter(isInlineImage) : [];
-  const embedResults = await Promise.all(inlineImageCandidates.map((meta20) => fetchInlineImageBytes(graph, messageId, meta20)));
+  const embedResults = await Promise.all(inlineImageCandidates.map((meta20) => fetchInlineImageBytes(graph, resourcePath, meta20)));
   const inlineImages = embedResults.flatMap((r) => r.inline ? [r.inline] : []);
-  const headers = renderHeaders(m);
-  const rawHtml = m.body?.content ?? "";
+  const headers = options.renderHeaders(m);
   const withPlaceholders = renderOversizePlaceholders(rawHtml, embedResults);
   const embedded = inlineImages.length > 0 ? embedInlineImages(withPlaceholders, inlineImages) : withPlaceholders;
   const labelByContentId = new Map;
@@ -17933,7 +17936,7 @@ var schema18, INLINE_IMAGE_SIZE_LIMIT_BYTES = 2000000, ATTACHMENT_METADATA_SELEC
     quotedBoundary = findPlainTextQuoteBoundary(inlined);
     bodyMd = stripped.text;
   }
-  const fileList = renderFileAttachmentsList(attachments, !embedInlineImagesEnabled);
+  const fileList = renderFileAttachmentsList(attachments, !embedInlineImagesEnabled, options.attachmentHint);
   const text = [headers, bodyMd, fileList].filter((s) => s !== "").join(`
 
 `);
@@ -17950,6 +17953,16 @@ var schema18, INLINE_IMAGE_SIZE_LIMIT_BYTES = 2000000, ATTACHMENT_METADATA_SELEC
   if (notes.length > 0)
     envelope.note = notes.join("; ");
   return ok(envelope);
+}, MAIL_ATTACHMENT_HINT = "_Use `convert-mail-attachment-to-pdf` or `get-mail-attachment` with the attachment id to fetch._", execute18 = async (graph, params) => {
+  const parsed = schema18.safeParse(params);
+  if (!parsed.success)
+    return err({ type: "validation_error", message: formatZodError(parsed.error) });
+  return renderMessageAsMarkdown(graph, `/me/messages/${parsed.data.messageId}`, {
+    inlineImages: parsed.data.inlineImages === "true",
+    keepQuoted: parsed.data.keepQuoted === "true",
+    attachmentHint: MAIL_ATTACHMENT_HINT,
+    renderHeaders
+  });
 }, meta20;
 var init_convert_mail_to_markdown = __esm(() => {
   init_zod();
@@ -17974,7 +17987,7 @@ var init_convert_mail_to_markdown = __esm(() => {
     value: exports_external.array(attachmentMetaSchema).optional()
   });
   meta20 = {
-    summary: "Render a single Outlook email as markdown — headers (`**Subject:**`, `**From:**`, `**To:**`, `**Cc:**` only when present, `**Date:**`), followed by the body run through turndown. By default NO image bytes are fetched: every inline `cid:` image renders as a readable `[inline image: <name>]` placeholder and the images surface in the file-attachments list, so the output stays close to the text size (an email whose 6 KB body carried 30 KB of signature-image base64 now ships at ~6 KB). Pass `--inline-images true` to embed inline images (`isInline:true` + `image/*` content-type, size ≤ 2 MB) as base64 `data:` URIs for self-contained output (non-image inline attachments are never embedded; oversize inline images keep a placeholder note; a cid whose per-image fetch fails degrades to the placeholder too). File attachments are always listed below the body by name + size + id; their bytes are NOT fetched here — call `convert-mail-attachment-to-pdf` or `get-mail-attachment` with the id when you actually need them. Staged-fetch design: one call for the body, one for the attachments-metadata list (only if `hasAttachments:true`), and with `--inline-images true` one per small inline image — replaces the old `?$expand=attachments` which timed out / truncated on messages with multi-MB attachments.",
+    summary: "Render a single Outlook email as markdown — headers (`**Subject:**`, `**From:**`, `**To:**`, `**Cc:**` only when present, `**Date:**`), followed by the body run through turndown. By default NO image bytes are fetched: every inline `cid:` image renders as a readable `[inline image: <name>]` placeholder and the images surface in the file-attachments list, so the output stays close to the text size (an email whose 6 KB body carried 30 KB of signature-image base64 now ships at ~6 KB). Pass `--inline-images true` to embed inline images (`isInline:true` + `image/*` content-type, size ≤ 2 MB) as base64 `data:` URIs for self-contained output (non-image inline attachments are never embedded; oversize inline images keep a placeholder note; a cid whose per-image fetch fails degrades to the placeholder too). File attachments are always listed below the body by name + size + id; their bytes are NOT fetched here — call `convert-mail-attachment-to-pdf` or `get-mail-attachment` with the id when you actually need them. Staged-fetch design: one call for the body, one for the attachments-metadata list (when `hasAttachments` is true or the body references a `cid:` image, since Graph reports false for inline-only mail), and with `--inline-images true` one per small inline image — replaces the old `?$expand=attachments` which timed out / truncated on messages with multi-MB attachments.",
     category: "mail",
     graphMethod: "GET",
     graphPathTemplate: "/me/messages/{message-id}",
@@ -18048,7 +18061,7 @@ var schema19, SCAN_LIMIT = 10, SENT_SCAN_PATH, sentListSchema, messageSchema, in
   if (!parsed.success)
     return { html: block, count: 0, note: "the inline-image list came back in an unreadable shape, so any cid: references are unresolved" };
   const referenced = (parsed.data.value ?? []).filter(isInlineImage).filter((a) => block.includes(`cid:${a.contentId}`));
-  const fetched = await Promise.all(referenced.map((meta21) => fetchInlineImageBytes(graph, messageId, meta21)));
+  const fetched = await Promise.all(referenced.map((meta21) => fetchInlineImageBytes(graph, `/me/messages/${messageId}`, meta21)));
   const embeddable = fetched.flatMap((f) => f.inline === undefined ? [] : [f.inline]);
   const skipped = fetched.filter((f) => f.inline === undefined);
   const html = embeddable.length > 0 ? embedInlineImages(block, embeddable) : block;
@@ -18056,7 +18069,7 @@ var schema19, SCAN_LIMIT = 10, SENT_SCAN_PATH, sentListSchema, messageSchema, in
     return { html, count: embeddable.length };
   const named = skipped.map((f) => `${f.meta.name ?? "image"} (${formatBytes(f.meta.size ?? 0)})`).join(", ");
   return { html, count: embeddable.length, note: `${skipped.length} inline image${skipped.length === 1 ? "" : "s"} left as a cid: reference: ${named}` };
-}, referencesCidImage = (block) => /\bsrc\s*=\s*["']cid:/i.test(block), noSignatureFound = (messageId, scanned) => {
+}, referencesCidImage2 = (block) => /\bsrc\s*=\s*["']cid:/i.test(block), noSignatureFound = (messageId, scanned) => {
   const plural = scanned === 1 ? "" : "s";
   const scanMessage = `No OWA signature block (\`<div id="Signature">\`) was found in the last ${scanned} sent message${plural}. Mail composed in Outlook desktop does not carry the marker, so a signature may exist without being findable this way - pass --message-id to pin a message you know was sent from Outlook on the web.`;
   const pinnedMessage = `Message ${messageId} carries no OWA signature block (\`<div id="Signature">\`). Mail composed in Outlook desktop does not carry the marker; pin a message sent from Outlook on the web instead.`;
@@ -18102,7 +18115,7 @@ var schema19, SCAN_LIMIT = 10, SENT_SCAN_PATH, sentListSchema, messageSchema, in
     const block = extractSignatureBlock(message.data.body.content);
     if (block === undefined)
       continue;
-    const inlined = referencesCidImage(block) ? await inlineSignatureImages(graph, id, block) : { html: block, count: 0 };
+    const inlined = referencesCidImage2(block) ? await inlineSignatureImages(graph, id, block) : { html: block, count: 0 };
     return ok(buildEnvelope(id, block, message.data.sentDateTime, inlined));
   }
   return err(noSignatureFound(messageId, candidates.value.length));
@@ -21142,13 +21155,14 @@ var init_sharepoint_link_extractor = __esm(() => {
 // src/use-cases/commands/convert-mail-attachment-to-markdown.ts
 var exports_convert_mail_attachment_to_markdown = {};
 __export(exports_convert_mail_attachment_to_markdown, {
+  MAIL_HINTS: () => MAIL_HINTS,
   convertAttachmentToMarkdown: () => convertAttachmentToMarkdown,
   convertFetchedAttachment: () => convertFetchedAttachment,
   execute: () => execute86,
   meta: () => meta88,
   schema: () => schema86
 });
-var schema86, MAIL_HINTS, convertFileAttachment = (attachment, opts) => bytesToMarkdown(base64ToBytes(attachment.contentBytes ?? ""), attachment.name ?? "unnamed", opts, MAIL_HINTS), convertReferenceAttachment = async (graph, attachment, opts) => {
+var schema86, MAIL_HINTS, convertFileAttachment = (attachment, opts, hints) => bytesToMarkdown(base64ToBytes(attachment.contentBytes ?? ""), attachment.name ?? "unnamed", opts, hints), convertReferenceAttachment = async (graph, attachment, opts) => {
   const sourceUrl = attachment.sourceUrl;
   if (typeof sourceUrl !== "string" || sourceUrl === "") {
     return err({
@@ -21196,14 +21210,14 @@ var schema86, MAIL_HINTS, convertFileAttachment = (attachment, opts) => bytesToM
     default:
       return err({ type: "api_error", status: 400, message: `unsupported embedded item type: ${innerType}` });
   }
-}, convertFetchedAttachment = (graph, a, opts) => {
+}, convertFetchedAttachment = (graph, a, opts, hints) => {
   const odataType = a["@odata.type"];
   if (typeof odataType !== "string") {
     return err({ type: "api_error", status: 400, message: "attachment response missing @odata.type discriminator" });
   }
   switch (odataType) {
     case "#microsoft.graph.fileAttachment":
-      return convertFileAttachment(a, opts);
+      return convertFileAttachment(a, opts, hints);
     case "#microsoft.graph.referenceAttachment":
       return convertReferenceAttachment(graph, a, opts);
     case "#microsoft.graph.itemAttachment":
@@ -21211,20 +21225,17 @@ var schema86, MAIL_HINTS, convertFileAttachment = (attachment, opts) => bytesToM
     default:
       return err({ type: "api_error", status: 400, message: `unsupported attachment type: ${odataType}` });
   }
-}, convertAttachmentToMarkdown = async (graph, attachmentPath, opts) => {
+}, convertAttachmentToMarkdown = async (graph, attachmentPath, opts, hints) => {
   const fetched = await graph.get(attachmentPath);
   if (!fetched.ok)
     return fetched;
-  return convertFetchedAttachment(graph, fetched.value, opts);
+  return convertFetchedAttachment(graph, fetched.value, opts, hints);
 }, execute86 = async (graph, params) => {
   const parsed = schema86.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   const { messageId, attachmentId } = parsed.data;
-  return convertAttachmentToMarkdown(graph, `/me/messages/${messageId}/attachments/${attachmentId}`, {
-    includeMetadata: parsed.data.includeMetadata === "true",
-    keepQuoted: parsed.data.keepQuoted === "true"
-  });
+  return convertAttachmentToMarkdown(graph, `/me/messages/${messageId}/attachments/${attachmentId}`, { includeMetadata: parsed.data.includeMetadata === "true", keepQuoted: parsed.data.keepQuoted === "true" }, MAIL_HINTS);
 }, meta88;
 var init_convert_mail_attachment_to_markdown = __esm(() => {
   init_zod();
@@ -21346,11 +21357,7 @@ var schema87, isZipAttachment = (a) => {
   const ext = Object.hasOwn(CONTENT_TYPE_EXTENSIONS, contentType) ? CONTENT_TYPE_EXTENSIONS[contentType] : undefined;
   if (ext === undefined)
     return a;
-  const name = typeof a["name"] === "string" ? a["name"] : "";
-  const dot = name.lastIndexOf(".");
-  if ((dot === -1 ? "" : name.slice(dot + 1).toLowerCase()) === ext)
-    return a;
-  return { ...a, name: `${dot === -1 ? name || "attachment" : name.slice(0, dot)}.${ext}` };
+  return { ...a, name: `attachment.${ext}` };
 }, execute87 = async (graph, params) => {
   const parsed = schema87.safeParse(params);
   if (!parsed.success)
@@ -21369,7 +21376,7 @@ var schema87, isZipAttachment = (a) => {
     }
     return convertZipArchive(base64ToBytes(contentBytes), { includeMetadata, keepQuoted });
   }
-  return convertFetchedAttachment(graph, nameByContentType(a), { includeMetadata, keepQuoted });
+  return convertFetchedAttachment(graph, nameByContentType(a), { includeMetadata, keepQuoted }, MAIL_HINTS);
 }, meta89;
 var init_read_mail_attachment = __esm(() => {
   init_zod();
@@ -21702,21 +21709,24 @@ __export(exports_convert_calendar_event_attachment_to_markdown, {
   meta: () => meta93,
   schema: () => schema91
 });
-var schema91, execute91 = async (graph, params) => {
+var CALENDAR_HINTS, schema91, execute91 = async (graph, params) => {
   const parsed = schema91.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   const { eventId, attachmentId } = parsed.data;
-  return convertAttachmentToMarkdown(graph, `/me/events/${eventId}/attachments/${attachmentId}`, {
-    includeMetadata: parsed.data.includeMetadata === "true",
-    keepQuoted: parsed.data.keepQuoted === "true"
-  });
+  return convertAttachmentToMarkdown(graph, `/me/events/${eventId}/attachments/${attachmentId}`, { includeMetadata: parsed.data.includeMetadata === "true", keepQuoted: parsed.data.keepQuoted === "true" }, CALENDAR_HINTS);
 }, meta93;
 var init_convert_calendar_event_attachment_to_markdown = __esm(() => {
   init_zod();
   init_convert_mail_attachment_to_markdown();
   init_format_zod_error();
   init_mail_quote_stripper();
+  CALENDAR_HINTS = {
+    pdfNoText: "pdf attachment has no extractable text layer — it looks scanned / image-only (only page images, no embedded text). Use `convert-calendar-event-attachment-to-pdf --output-path /tmp/file.pdf` to land the bytes on disk, then read the PDF with a vision-capable model, or run OCR.",
+    legacyPpt: "ppt (legacy PowerPoint 97-2003, OLE binary) cannot be converted to markdown — there is no pure-JS parser for the format. Use `convert-calendar-event-attachment-to-pdf --output-path /tmp/file.pdf` to render it, then read the PDF with a vision-capable model.",
+    image: (ext) => `${ext} attachment is an image and cannot be converted to markdown. Fetch the bytes with \`get-calendar-event --event-id <id> --expand attachments\`, which returns each attachment's base64 \`contentBytes\` inline, and feed them into a vision-capable model. (\`convert-calendar-event-attachment-to-pdf\` is NOT a workaround: Graph's format=pdf rejects images with InputFormatNotSupported.)`,
+    generic: (ext) => `${ext} attachment not supported by \`convert-calendar-event-attachment-to-markdown\`. Use \`convert-calendar-event-attachment-to-pdf\` — Graph \`?format=pdf\` accepts 38 input extensions.`
+  };
   schema91 = exports_external.object({
     eventId: exports_external.string().min(1),
     attachmentId: exports_external.string().min(1),
@@ -25508,15 +25518,16 @@ __export(exports_list_group_conversations, {
   meta: () => meta164,
   schema: () => schema162
 });
-var baseSchema85, execute162, schema162, meta164;
+var HONOURED, baseSchema85, execute162, schema162, meta164;
 var init_list_group_conversations = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
+  HONOURED = ["top", "skip", "select", "orderby", "expand"];
   baseSchema85 = exports_external.object({ groupId: exports_external.string().min(1) });
-  ({ execute: execute162, schema: schema162 } = buildListCommand((p) => `/groups/${p.groupId}/conversations`, baseSchema85));
+  ({ execute: execute162, schema: schema162 } = buildPickODataListCommand((p) => `/groups/${p.groupId}/conversations`, baseSchema85, HONOURED));
   meta164 = {
-    summary: "List conversations in a unified (Microsoft 365) group inbox. Each conversation aggregates one or more threads. Only Microsoft 365 groups have a mailbox — security and distribution groups return `MailboxNotEnabledForRESTAPI`. Verify the group is unified before calling.",
+    summary: "List conversations in a unified (Microsoft 365) group inbox. Each conversation aggregates one or more threads. Only Microsoft 365 groups have a mailbox — security and distribution groups return `MailboxNotEnabledForRESTAPI`. Verify the group is unified before calling. Bodies live two levels down: `list-group-threads` then `list-group-thread-posts`, or `--expand 'threads($expand=posts)'` here to fetch conversations, threads and posts in one call.",
     category: "mail",
     graphMethod: "GET",
     graphPathTemplate: "/groups/{group-id}/conversations",
@@ -25528,7 +25539,7 @@ var init_list_group_conversations = __esm(() => {
         required: true,
         description: "Azure AD group object ID for a unified (Microsoft 365) group."
       },
-      ...odataQueryOptions
+      ...pickODataOptions(HONOURED)
     ],
     example: "ask-marcel-office list-group-conversations --group-id 'a1b2c3d4-...'",
     responseShape: "collection of Microsoft Graph `conversation` resources under `value[]`",
@@ -25543,15 +25554,16 @@ __export(exports_list_group_threads, {
   meta: () => meta165,
   schema: () => schema163
 });
-var baseSchema86, execute163, schema163, meta165;
+var HONOURED2, baseSchema86, execute163, schema163, meta165;
 var init_list_group_threads = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
+  HONOURED2 = ["top", "skip", "select", "orderby", "expand"];
   baseSchema86 = exports_external.object({ groupId: exports_external.string().min(1) });
-  ({ execute: execute163, schema: schema163 } = buildListCommand((p) => `/groups/${p.groupId}/threads`, baseSchema86));
+  ({ execute: execute163, schema: schema163 } = buildPickODataListCommand((p) => `/groups/${p.groupId}/threads`, baseSchema86, HONOURED2));
   meta165 = {
-    summary: "List threads in a unified (Microsoft 365) group inbox. Threads are flatter than conversations — one per topic, useful when conversation-level grouping isn't needed. Only Microsoft 365 groups have a mailbox — security and distribution groups return `MailboxNotEnabledForRESTAPI`.",
+    summary: "List threads in a unified (Microsoft 365) group inbox. Threads are flatter than conversations — one per topic, useful when conversation-level grouping isn't needed. Only Microsoft 365 groups have a mailbox — security and distribution groups return `MailboxNotEnabledForRESTAPI`. Each thread carries only a truncated `preview` of its latest post: read the full posts with `list-group-thread-posts`, or pass `--expand posts` here to inline them.",
     category: "mail",
     graphMethod: "GET",
     graphPathTemplate: "/groups/{group-id}/threads",
@@ -25563,7 +25575,7 @@ var init_list_group_threads = __esm(() => {
         required: true,
         description: "Azure AD group object ID for a unified (Microsoft 365) group."
       },
-      ...odataQueryOptions
+      ...pickODataOptions(HONOURED2)
     ],
     example: "ask-marcel-office list-group-threads --group-id 'a1b2c3d4-...'",
     responseShape: "collection of Microsoft Graph `conversationThread` resources under `value[]`",
@@ -25571,25 +25583,391 @@ var init_list_group_threads = __esm(() => {
   };
 });
 
-// src/use-cases/commands/get-mail-message-mime.ts
-var exports_get_mail_message_mime = {};
-__export(exports_get_mail_message_mime, {
+// src/use-cases/commands/list-group-thread-posts.ts
+var exports_list_group_thread_posts = {};
+__export(exports_list_group_thread_posts, {
   execute: () => execute164,
   meta: () => meta166,
   schema: () => schema164
 });
-var schema164, execute164 = async (graph, params) => {
-  const parsed = schema164.safeParse(params);
+var baseSchema87, execute164, schema164, meta166;
+var init_list_group_thread_posts = __esm(() => {
+  init_zod();
+  init_build_command();
+  init_odata_query();
+  baseSchema87 = exports_external.object({ groupId: exports_external.string().min(1), threadId: exports_external.string().min(1) });
+  ({ execute: execute164, schema: schema164 } = buildPickODataListCommand((p) => `/groups/${p.groupId}/threads/${p.threadId}/posts`, baseSchema87, ["select", "expand"]));
+  meta166 = {
+    summary: "List every post in one thread of a unified (Microsoft 365) group inbox: the full `post` resources with the HTML `body.content`, `from`, `sender`, `receivedDateTime` and `hasAttachments`, where `list-group-threads` stops at a truncated `preview`. Graph returns the whole thread in one call with no page cursor, and it silently ignores `$top`, `$skip` and `$orderby` while rejecting `$filter` (probed live 2026-09-03), so only `--select` and `--expand` are exposed; sort on `receivedDateTime` client-side if order matters. `sender` is the person who wrote the post and `from` is normally the group's own address. Render one post as markdown with `convert-group-post-to-markdown`. Access is membership-gated, not scope-gated: a group the signed-in user does not belong to answers `ErrorAccessDenied` even though `list-groups` lists it.",
+    category: "mail",
+    graphMethod: "GET",
+    graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts",
+    graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/conversationthread-list-posts",
+    options: [
+      {
+        name: "group-id",
+        key: "groupId",
+        required: true,
+        description: "Azure AD group object ID for a unified (Microsoft 365) group the signed-in user belongs to."
+      },
+      {
+        name: "thread-id",
+        key: "threadId",
+        required: true,
+        description: "Conversation thread ID, the `id` of a `list-group-threads` entry (also inlined by `list-group-conversations --expand threads`)."
+      },
+      ...selectExpandOptions
+    ],
+    example: "ask-marcel-office list-group-thread-posts --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...'",
+    responseShape: "collection of Microsoft Graph `post` resources under `value[]`: `id`, `createdDateTime`, `lastModifiedDateTime`, `changeKey`, `categories`, `receivedDateTime`, `hasAttachments`, `body { contentType, content }`, `from`, `sender`. No `nextLink` is ever emitted. `hasAttachments` is false for a post whose only attachments are inline images. `--expand attachments` inlines every attachment of every post with its base64 `contentBytes`, so use it sparingly."
+  };
+});
+
+// src/use-cases/commands/get-group-post.ts
+var exports_get_group_post = {};
+__export(exports_get_group_post, {
+  execute: () => execute165,
+  meta: () => meta167,
+  schema: () => schema165
+});
+var baseSchema88, execute165, schema165, meta167;
+var init_get_group_post = __esm(() => {
+  init_zod();
+  init_build_command();
+  init_odata_query();
+  baseSchema88 = exports_external.object({ groupId: exports_external.string().min(1), threadId: exports_external.string().min(1), postId: exports_external.string().min(1) });
+  ({ execute: execute165, schema: schema165 } = buildSelectableCommand((p) => `/groups/${p.groupId}/threads/${p.threadId}/posts/${p.postId}`, baseSchema88));
+  meta167 = {
+    summary: "Get a single post of a unified (Microsoft 365) group thread by ID, the sibling of `get-mail-message` for a group inbox: the full `post` resource including the HTML `body`. `--select` trims the projection. `--expand attachments` returns every attachment inline with its base64 `contentBytes`, which is convenient for a small post and the wrong shape for one carrying a multi-MB file: list them with `list-group-post-attachments` and fetch one with `get-group-post-attachment` instead. Post IDs come from `list-group-thread-posts`; use `convert-group-post-to-markdown` for a readable rendering.",
+    category: "mail",
+    graphMethod: "GET",
+    graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts/{post-id}",
+    graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/post-get",
+    options: [
+      {
+        name: "group-id",
+        key: "groupId",
+        required: true,
+        description: "Azure AD group object ID for a unified (Microsoft 365) group the signed-in user belongs to."
+      },
+      {
+        name: "thread-id",
+        key: "threadId",
+        required: true,
+        description: "Conversation thread ID, the `id` of a `list-group-threads` entry."
+      },
+      {
+        name: "post-id",
+        key: "postId",
+        required: true,
+        description: "Post ID inside that thread. Returned by `list-group-thread-posts`."
+      },
+      ...selectExpandOptions
+    ],
+    example: "ask-marcel-office get-group-post --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...' --post-id 'AQMkAD...'",
+    responseShape: "single Microsoft Graph `post` resource: `id`, `createdDateTime`, `lastModifiedDateTime`, `changeKey`, `categories`, `receivedDateTime`, `hasAttachments`, `body { contentType, content }`, `from` (normally the group address), `sender` (the person who wrote it). With `--expand attachments`, an `attachments[]` array of `fileAttachment` / `itemAttachment` / `referenceAttachment` entries, file attachments carrying `contentBytes` inline."
+  };
+});
+
+// src/use-cases/commands/convert-group-post-to-markdown.ts
+var exports_convert_group_post_to_markdown = {};
+__export(exports_convert_group_post_to_markdown, {
+  execute: () => execute166,
+  meta: () => meta168,
+  schema: () => schema166
+});
+var schema166, renderPostHeaders = (m) => {
+  const lines = [];
+  const from = formatAddress2(m.from?.emailAddress);
+  const author = formatAddress2(m.sender?.emailAddress) ?? from;
+  if (author !== undefined)
+    lines.push(from === undefined || from === author ? `**From:** ${author}` : `**From:** ${author} on behalf of ${from}`);
+  if (nonEmpty(m.receivedDateTime))
+    lines.push(`**Date:** ${m.receivedDateTime}`);
+  return lines.join(`
+`);
+}, POST_ATTACHMENT_HINT = "_Use `convert-group-post-attachment-to-markdown` or `get-group-post-attachment` with the attachment id to fetch._", execute166 = async (graph, params) => {
+  const parsed = schema166.safeParse(params);
+  if (!parsed.success)
+    return err({ type: "validation_error", message: formatZodError(parsed.error) });
+  const { groupId, threadId, postId } = parsed.data;
+  return renderMessageAsMarkdown(graph, `/groups/${groupId}/threads/${threadId}/posts/${postId}`, {
+    inlineImages: parsed.data.inlineImages === "true",
+    keepQuoted: parsed.data.keepQuoted === "true",
+    attachmentHint: POST_ATTACHMENT_HINT,
+    renderHeaders: renderPostHeaders
+  });
+}, meta168;
+var init_convert_group_post_to_markdown = __esm(() => {
+  init_zod();
+  init_convert_mail_to_markdown();
+  init_format_zod_error();
+  schema166 = exports_external.object({
+    groupId: exports_external.string().min(1),
+    threadId: exports_external.string().min(1),
+    postId: exports_external.string().min(1),
+    inlineImages: exports_external.enum(["true", "false"]).optional(),
+    keepQuoted: exports_external.enum(["true", "false"]).optional()
+  });
+  meta168 = {
+    summary: "Render one post of a unified (Microsoft 365) group thread as markdown, the way `convert-mail-to-markdown` renders an Outlook message: a `**From:**` line, a `**Date:**` line, then the HTML body through turndown with quoted reply chains stripped. A post arrives from the group's own address with the writer in `sender`, so the author line reads `Robin Chen <robin.chen@contoso.com> on behalf of Support <support@contoso.com>`. There is no subject line: the thread `topic` is the subject and lives on `list-group-threads`. By default no image bytes are fetched; inline `cid:` images render as `[inline image: <name>]` placeholders unless `--inline-images true`. File attachments are listed below the body by name, size and id and their bytes are never fetched here; read one with `convert-group-post-attachment-to-markdown` or fetch it with `get-group-post-attachment`. Same staged-fetch design as the mail command: one call for the post, one for the attachment list when `hasAttachments` is true or the body references a `cid:` image (Graph reports false for a post whose only attachments are inline), and with `--inline-images true` one per small inline image.",
+    category: "mail",
+    graphMethod: "GET",
+    graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts/{post-id}",
+    graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/post-get",
+    options: [
+      {
+        name: "group-id",
+        key: "groupId",
+        required: true,
+        description: "Azure AD group object ID for a unified (Microsoft 365) group the signed-in user belongs to."
+      },
+      {
+        name: "thread-id",
+        key: "threadId",
+        required: true,
+        description: "Conversation thread ID, the `id` of a `list-group-threads` entry."
+      },
+      {
+        name: "post-id",
+        key: "postId",
+        required: true,
+        description: "Post ID inside that thread. Returned by `list-group-thread-posts`."
+      },
+      {
+        name: "inline-images",
+        key: "inlineImages",
+        required: false,
+        description: "Pass `--inline-images true` to fetch small inline images (≤ 2 MB, `image/*` only) and embed them as base64 `data:` URIs. Default is `false`: no per-image bytes fetch, and every inline `cid:` image renders as a `[inline image: <name>]` placeholder while still appearing in the attachments list. Same rule as `convert-mail-to-markdown`.",
+        argumentHint: { kind: "magicValue", values: ["true", "false"] }
+      },
+      {
+        name: "keep-quoted",
+        key: "keepQuoted",
+        required: false,
+        description: "Quoted reply chains and forwarded-message blocks are stripped by default and replaced with a single visible marker naming this flag; the `note` reports the share of the body text that went with them. Pass `--keep-quoted true` to preserve the full body. The markers recognised are the ones `convert-mail-to-markdown` documents.",
+        argumentHint: { kind: "magicValue", values: ["true", "false"] }
+      }
+    ],
+    example: "ask-marcel-office convert-group-post-to-markdown --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...' --post-id 'AQMkAD...'",
+    responseShape: '`{ contentType: "text/markdown", size, text, note? }`, the same envelope as `convert-mail-to-markdown`: headers, the turndown-rendered body and, when present, an attachments list. The optional `note` carries the attachments-list failure hint and/or the quoted-chain notice with the share of the body text it removed.',
+    producesBytes: true
+  };
+});
+
+// src/use-cases/commands/list-group-post-attachments.ts
+var exports_list_group_post_attachments = {};
+__export(exports_list_group_post_attachments, {
+  execute: () => execute167,
+  meta: () => meta169,
+  schema: () => schema167
+});
+var baseSchema89, DEFAULT_SELECT7 = "id,name,contentType,size,isInline", execute167, schema167, meta169;
+var init_list_group_post_attachments = __esm(() => {
+  init_zod();
+  init_build_command();
+  init_odata_query();
+  baseSchema89 = exports_external.object({ groupId: exports_external.string().min(1), threadId: exports_external.string().min(1), postId: exports_external.string().min(1) });
+  ({ execute: execute167, schema: schema167 } = buildPickODataListCommand((p) => `/groups/${p.groupId}/threads/${p.threadId}/posts/${p.postId}/attachments`, baseSchema89, ["select", "expand"], {
+    defaultSelect: DEFAULT_SELECT7
+  }));
+  meta169 = {
+    summary: "List the attachments (file, item, reference) on one post of a unified (Microsoft 365) group thread. Ships the slim default `--select=id,name,contentType,size,isInline` the mail and calendar siblings use, so a caller sees what is attached without pulling any bytes — the staged alternative to `get-group-post --expand attachments`, which inlines EVERY attachment at once and times out on a post carrying a multi-MB file. Graph returns the whole collection in one response and silently ignores `$top`, `$skip`, `$orderby` and `$filter` (probed live 2026-09-03), so only `--select` and `--expand` are exposed. A post whose only attachments are inline images reports `hasAttachments: false`, so call this whenever the body shows `cid:` references. Read one with `convert-group-post-attachment-to-markdown`, or fetch its bytes with `get-group-post-attachment`.",
+    category: "mail",
+    graphMethod: "GET",
+    graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts/{post-id}/attachments",
+    graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/post-list-attachments",
+    options: [
+      {
+        name: "group-id",
+        key: "groupId",
+        required: true,
+        description: "Azure AD group object ID for a unified (Microsoft 365) group you belong to."
+      },
+      {
+        name: "thread-id",
+        key: "threadId",
+        required: true,
+        description: "Conversation thread ID, the `id` of a `list-group-threads` entry."
+      },
+      {
+        name: "post-id",
+        key: "postId",
+        required: true,
+        description: "Post ID inside that thread. Returned by `list-group-thread-posts`."
+      },
+      ...selectExpandOptions
+    ],
+    example: "ask-marcel-office list-group-post-attachments --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...' --post-id 'AQMkAD...'",
+    responseShape: "collection of Microsoft Graph `attachment` resources under `value[]` (slim metadata by default — see summary), with no page cursor. Graph always includes `@odata.type` and `@odata.mediaContentType` on every entry regardless of `--select`; that discriminator is what the converting sibling branches on. An inline image carries `isInline: true` and a `contentId` matching a `cid:` reference in the post body."
+  };
+});
+
+// src/use-cases/commands/get-group-post-attachment.ts
+var exports_get_group_post_attachment = {};
+__export(exports_get_group_post_attachment, {
+  execute: () => execute168,
+  meta: () => meta170,
+  schema: () => schema168
+});
+var schema168, execute168 = async (graph, params) => {
+  const parsed = schema168.safeParse(params);
+  if (!parsed.success)
+    return err({ type: "validation_error", message: formatZodError(parsed.error) });
+  const { groupId, threadId, postId, attachmentId } = parsed.data;
+  const path = appendOData(`/groups/${groupId}/threads/${threadId}/posts/${postId}/attachments/${attachmentId}`, parsed.data);
+  const result = await graph.get(path);
+  if (!result.ok)
+    return result;
+  const value = result.value;
+  const contentBytes = value["contentBytes"];
+  if (value["@odata.type"] === "#microsoft.graph.fileAttachment" && typeof contentBytes === "string") {
+    return ok({ ...value, base64: contentBytes });
+  }
+  return ok(value);
+}, meta170;
+var init_get_group_post_attachment = __esm(() => {
+  init_zod();
+  init_format_zod_error();
+  init_odata_query();
+  schema168 = exports_external.object({ groupId: exports_external.string().min(1), threadId: exports_external.string().min(1), postId: exports_external.string().min(1), attachmentId: exports_external.string().min(1) }).extend(selectExpandSchema.shape);
+  meta170 = {
+    summary: "Get a single attachment on one post of a unified (Microsoft 365) group thread, the `get-mail-attachment` sibling for a group inbox. Prefer it over `get-group-post --expand attachments`, which expands every attachment at once. fileAttachments carry a `base64` mirror of `contentBytes` so the global output-path flag lands the bytes on disk in one call; with an output-path set both byte fields are stripped from stdout in favour of `savedTo`. Pass `--select id,name,contentType,size` for metadata only. This is also the route to an image attached to a post: fetch the bytes and feed them to a vision-capable model.",
+    category: "mail",
+    graphMethod: "GET",
+    graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts/{post-id}/attachments/{attachment-id}",
+    graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/attachment-get",
+    options: [
+      {
+        name: "group-id",
+        key: "groupId",
+        required: true,
+        description: "Azure AD group object ID for a unified (Microsoft 365) group the signed-in user belongs to."
+      },
+      {
+        name: "thread-id",
+        key: "threadId",
+        required: true,
+        description: "Conversation thread ID, the `id` of a `list-group-threads` entry."
+      },
+      {
+        name: "post-id",
+        key: "postId",
+        required: true,
+        description: "Post ID inside that thread. Returned by `list-group-thread-posts`."
+      },
+      {
+        name: "attachment-id",
+        key: "attachmentId",
+        required: true,
+        description: "Attachment ID inside that post. Returned by `list-group-post-attachments`."
+      },
+      ...selectExpandOptions
+    ],
+    example: "ask-marcel-office get-group-post-attachment --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...' --post-id 'AQMkAD...' --attachment-id 'AAMkAD...'",
+    responseShape: "single Microsoft Graph `attachment` resource. fileAttachments include `contentBytes` (Graph) AND `base64` (CLI mirror) so `--output-path` works; with `--output-path` set, both byte fields are stripped from stdout and replaced by `savedTo`. itemAttachments and referenceAttachments are returned unchanged.",
+    producesBytes: true
+  };
+});
+
+// src/use-cases/commands/convert-group-post-attachment-to-markdown.ts
+var exports_convert_group_post_attachment_to_markdown = {};
+__export(exports_convert_group_post_attachment_to_markdown, {
+  execute: () => execute169,
+  meta: () => meta171,
+  schema: () => schema169
+});
+var POST_HINTS, schema169, execute169 = async (graph, params) => {
+  const parsed = schema169.safeParse(params);
+  if (!parsed.success)
+    return err({ type: "validation_error", message: formatZodError(parsed.error) });
+  const { groupId, threadId, postId, attachmentId } = parsed.data;
+  return convertAttachmentToMarkdown(graph, `/groups/${groupId}/threads/${threadId}/posts/${postId}/attachments/${attachmentId}`, { includeMetadata: parsed.data.includeMetadata === "true", keepQuoted: parsed.data.keepQuoted === "true" }, POST_HINTS);
+}, meta171;
+var init_convert_group_post_attachment_to_markdown = __esm(() => {
+  init_zod();
+  init_convert_mail_attachment_to_markdown();
+  init_format_zod_error();
+  init_mail_quote_stripper();
+  POST_HINTS = {
+    pdfNoText: "pdf attachment has no extractable text layer — it looks scanned / image-only (only page images, no embedded text). Fetch the bytes with `get-group-post-attachment --output-path /tmp/file.pdf`, then read the PDF with a vision-capable model, or run OCR.",
+    legacyPpt: "ppt (legacy PowerPoint 97-2003, OLE binary) cannot be converted to markdown — there is no pure-JS parser for the format. Fetch the bytes with `get-group-post-attachment --output-path /tmp/deck.ppt` and convert them outside the CLI, or open the post in Outlook.",
+    image: (ext) => `${ext} attachment is an image and cannot be converted to markdown. Use \`get-group-post-attachment\` to fetch the bytes (returned base64-encoded) and feed them into a vision-capable model directly — that's the right shape for image content.`,
+    generic: (ext) => `${ext} attachment not supported by \`convert-group-post-attachment-to-markdown\`. Fetch the raw bytes with \`get-group-post-attachment\` (add \`--output-path\` to land them on disk) and handle the format outside the CLI.`
+  };
+  schema169 = exports_external.object({
+    groupId: exports_external.string().min(1),
+    threadId: exports_external.string().min(1),
+    postId: exports_external.string().min(1),
+    attachmentId: exports_external.string().min(1),
+    includeMetadata: exports_external.enum(["true", "false"]).optional(),
+    keepQuoted: keepQuotedSchemaField
+  });
+  meta171 = {
+    summary: "Convert an attachment on one post of a unified (Microsoft 365) group thread to markdown, the `convert-mail-attachment-to-markdown` sibling for a group inbox. Polymorphic on the attachment’s `@odata.type` and sharing the mail pipeline: fileAttachment decodes the inline bytes and converts them locally (docx, xlsx, csv, odt/ods/odp, pptx as per-slide text, pdf text layer, legacy .xls/.doc, an Outlook `.msg` rendered recursively with its quoted chain stripped unless `--keep-quoted true`, plain text passed through); referenceAttachment resolves via `/shares/{token}/driveItem`; an embedded mail, event or contact is rendered locally. There is no PDF sibling here, so an image, a scanned PDF, a legacy `.ppt` and any other unsupported format return a 415 pointing at `get-group-post-attachment` for the raw bytes.",
+    category: "mail",
+    graphMethod: "GET",
+    graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts/{post-id}/attachments/{attachment-id}",
+    graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/attachment-get",
+    options: [
+      {
+        name: "group-id",
+        key: "groupId",
+        required: true,
+        description: "Azure AD group object ID for a unified (Microsoft 365) group the signed-in user belongs to."
+      },
+      {
+        name: "thread-id",
+        key: "threadId",
+        required: true,
+        description: "Conversation thread ID, the `id` of a `list-group-threads` entry."
+      },
+      {
+        name: "post-id",
+        key: "postId",
+        required: true,
+        description: "Post ID inside that thread. Returned by `list-group-thread-posts`."
+      },
+      {
+        name: "attachment-id",
+        key: "attachmentId",
+        required: true,
+        description: "Attachment ID inside that post. Returned by `list-group-post-attachments`."
+      },
+      {
+        name: "include-metadata",
+        key: "includeMetadata",
+        required: false,
+        description: "Pass `--include-metadata true` to append the Office side-channel metadata block, exactly as `convert-mail-attachment-to-markdown` documents it. No-op on other attachment types.",
+        argumentHint: { kind: "magicValue", values: ["true", "false"] }
+      },
+      keepQuotedOption
+    ],
+    example: "ask-marcel-office convert-group-post-attachment-to-markdown --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...' --post-id 'AQMkAD...' --attachment-id 'AAMkAD...'",
+    responseShape: '`{ contentType: "text/markdown", size, text }` on success (file and reference attachments run through the conversion dispatch; an embedded item is rendered locally). Plain-text sources return the raw-bytes envelope, and a PDF source carries `pageCount`. Unsupported types return an api_error with status 415 naming `get-group-post-attachment` as the way to the bytes.',
+    producesBytes: true
+  };
+});
+
+// src/use-cases/commands/get-mail-message-mime.ts
+var exports_get_mail_message_mime = {};
+__export(exports_get_mail_message_mime, {
+  execute: () => execute170,
+  meta: () => meta172,
+  schema: () => schema170
+});
+var schema170, execute170 = async (graph, params) => {
+  const parsed = schema170.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   return inlineBinary(graph, `/me/messages/${parsed.data.messageId}/$value`);
-}, meta166;
+}, meta172;
 var init_get_mail_message_mime = __esm(() => {
   init_zod();
   init_fetch_raw_bytes();
   init_format_zod_error();
-  schema164 = exports_external.object({ messageId: exports_external.string().min(1) });
-  meta166 = {
+  schema170 = exports_external.object({ messageId: exports_external.string().min(1) });
+  meta172 = {
     summary: "Return the raw RFC 5322 MIME source of a single Outlook message — full headers, every attachment encoded inline. Useful for archiving, full-fidelity forensic inspection, or feeding into a tool that reads MIME directly. For human-readable content prefer `get-mail-message` or `convert-mail-to-markdown`.",
     category: "mail",
     graphMethod: "GET",
@@ -25612,12 +25990,12 @@ var init_get_mail_message_mime = __esm(() => {
 // src/use-cases/commands/list-mail-folder-messages-delta.ts
 var exports_list_mail_folder_messages_delta = {};
 __export(exports_list_mail_folder_messages_delta, {
-  execute: () => execute165,
-  meta: () => meta167,
-  schema: () => schema165
+  execute: () => execute171,
+  meta: () => meta173,
+  schema: () => schema171
 });
-var schema165, execute165 = async (graph, params) => {
-  const parsed = schema165.safeParse(params);
+var schema171, execute171 = async (graph, params) => {
+  const parsed = schema171.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   const { mailFolderId, top, ...odata } = parsed.data;
@@ -25625,13 +26003,13 @@ var schema165, execute165 = async (graph, params) => {
   if (top !== undefined)
     headers["Prefer"] = `odata.maxpagesize=${top}`;
   return graph.get(appendOData(`/me/mailFolders/${mailFolderId}/messages/delta()`, odata), headers);
-}, meta167;
+}, meta173;
 var init_list_mail_folder_messages_delta = __esm(() => {
   init_zod();
   init_format_zod_error();
   init_odata_query();
-  schema165 = exports_external.object({ mailFolderId: exports_external.string().min(1) }).extend(pickODataShape(["top", "select", "filter", "expand"]));
-  meta167 = {
+  schema171 = exports_external.object({ mailFolderId: exports_external.string().min(1) }).extend(pickODataShape(["top", "select", "filter", "expand"]));
+  meta173 = {
     summary: 'Track incremental changes (added / updated / deleted messages) within a single mail folder using Microsoft Graph delta tokens. The first call returns the current snapshot plus a `@odata.deltaLink`; subsequent calls with that link return only what has changed since. `--top` is translated into the `Prefer: odata.maxpagesize=N` header: as a `$top` query parameter Graph reads a satisfied count as "sync complete" and hands back a deltaLink after N items, silently abandoning the rest of the folder. `$skip` and `$orderby` are NOT exposed — Graph ignores the former on this endpoint and rejects the latter unless it merely restates the default `receivedDateTime desc`.',
     category: "mail",
     graphMethod: "GET",
@@ -25656,19 +26034,19 @@ var init_list_mail_folder_messages_delta = __esm(() => {
 // src/use-cases/commands/list-shared-mailbox-messages.ts
 var exports_list_shared_mailbox_messages = {};
 __export(exports_list_shared_mailbox_messages, {
-  execute: () => execute166,
-  meta: () => meta168,
-  schema: () => schema166
+  execute: () => execute172,
+  meta: () => meta174,
+  schema: () => schema172
 });
-var baseSchema87, execute166, schema166, meta168;
+var baseSchema90, execute172, schema172, meta174;
 var init_list_shared_mailbox_messages = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
-  baseSchema87 = exports_external.object({ userId: exports_external.string().min(1) });
-  ({ execute: execute166, schema: schema166 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/messages`, baseSchema87));
-  meta168 = {
-    summary: "List messages from a shared or delegated mailbox the signed-in user has read access to. Same shape as `list-mail-messages` but scoped to a specific mailbox owner. 403 if the signed-in user does not have shared access to that mailbox.",
+  baseSchema90 = exports_external.object({ userId: exports_external.string().min(1) });
+  ({ execute: execute172, schema: schema172 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/messages`, baseSchema90));
+  meta174 = {
+    summary: "List messages from a shared or delegated mailbox the signed-in user has read access to. Same shape as `list-mail-messages` but scoped to a specific mailbox owner. Requires the delegated `Mail.Read.Shared` scope, which neither token this CLI can mint carries (verified live on two tenants, 2026-08-30), so any mailbox other than the signed-in user's own is expected to answer `ErrorAccessDenied` whatever delegation Exchange holds. Your own UPN works; a Microsoft 365 group's mailbox is the shared-mail path that does (`list-group-conversations`, `list-group-thread-posts`).",
     category: "mail",
     graphMethod: "GET",
     graphPathTemplate: "/users/{user-id}/messages",
@@ -25691,19 +26069,19 @@ var init_list_shared_mailbox_messages = __esm(() => {
 // src/use-cases/commands/list-shared-mailbox-folder-messages.ts
 var exports_list_shared_mailbox_folder_messages = {};
 __export(exports_list_shared_mailbox_folder_messages, {
-  execute: () => execute167,
-  meta: () => meta169,
-  schema: () => schema167
+  execute: () => execute173,
+  meta: () => meta175,
+  schema: () => schema173
 });
-var baseSchema88, execute167, schema167, meta169;
+var baseSchema91, execute173, schema173, meta175;
 var init_list_shared_mailbox_folder_messages = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
-  baseSchema88 = exports_external.object({ userId: exports_external.string().min(1), mailFolderId: exports_external.string().min(1) });
-  ({ execute: execute167, schema: schema167 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders/${p.mailFolderId}/messages`, baseSchema88));
-  meta169 = {
-    summary: "List messages in a single folder of a shared / delegated mailbox.",
+  baseSchema91 = exports_external.object({ userId: exports_external.string().min(1), mailFolderId: exports_external.string().min(1) });
+  ({ execute: execute173, schema: schema173 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders/${p.mailFolderId}/messages`, baseSchema91));
+  meta175 = {
+    summary: "List messages in a single folder of a shared / delegated mailbox. Requires the delegated `Mail.Read.Shared` scope, which neither token this CLI can mint carries (verified live on two tenants, 2026-08-30), so any mailbox other than the signed-in user's own is expected to answer `ErrorAccessDenied` whatever delegation Exchange holds. Your own UPN works; a Microsoft 365 group's mailbox is the shared-mail path that does (`list-group-conversations`, `list-group-thread-posts`).",
     category: "mail",
     graphMethod: "GET",
     graphPathTemplate: "/users/{user-id}/mailFolders/{mail-folder-id}/messages",
@@ -25732,20 +26110,20 @@ var init_list_shared_mailbox_folder_messages = __esm(() => {
 // src/use-cases/commands/list-shared-mailbox-folders.ts
 var exports_list_shared_mailbox_folders = {};
 __export(exports_list_shared_mailbox_folders, {
-  execute: () => execute168,
-  meta: () => meta170,
-  schema: () => schema168
+  execute: () => execute174,
+  meta: () => meta176,
+  schema: () => schema174
 });
-var baseSchema89, execute168, schema168, meta170;
+var baseSchema92, execute174, schema174, meta176;
 var init_list_shared_mailbox_folders = __esm(() => {
   init_zod();
   init_build_command();
   init_include_hidden_folders();
   init_odata_query();
-  baseSchema89 = exports_external.object({ userId: exports_external.string().min(1), includeHiddenFolders: exports_external.enum(["true", "false"]).optional() });
-  ({ execute: execute168, schema: schema168 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders${p.includeHiddenFolders === "true" ? "?includeHiddenFolders=true" : ""}`, baseSchema89));
-  meta170 = {
-    summary: "List the top-level mail folders of a shared or delegated mailbox. The `/me` sibling is `list-mail-folders`. Use it to discover the folder IDs that `list-shared-mailbox-folder-messages` needs: without it only the well-known names (`inbox`, `sentitems`, `drafts`, …) are reachable, so custom folders are invisible. 403 if the signed-in user does not have shared access to that mailbox.",
+  baseSchema92 = exports_external.object({ userId: exports_external.string().min(1), includeHiddenFolders: exports_external.enum(["true", "false"]).optional() });
+  ({ execute: execute174, schema: schema174 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders${p.includeHiddenFolders === "true" ? "?includeHiddenFolders=true" : ""}`, baseSchema92));
+  meta176 = {
+    summary: "List the top-level mail folders of a shared or delegated mailbox. The `/me` sibling is `list-mail-folders`. Use it to discover the folder IDs that `list-shared-mailbox-folder-messages` needs: without it only the well-known names (`inbox`, `sentitems`, `drafts`, …) are reachable, so custom folders are invisible. Requires the delegated `Mail.Read.Shared` scope, which neither token this CLI can mint carries (verified live on two tenants, 2026-08-30), so any mailbox other than the signed-in user's own is expected to answer `ErrorAccessDenied` whatever delegation Exchange holds. Your own UPN works; a Microsoft 365 group's mailbox is the shared-mail path that does (`list-group-conversations`, `list-group-thread-posts`).",
     category: "mail",
     graphMethod: "GET",
     graphPathTemplate: "/users/{user-id}/mailFolders",
@@ -25769,20 +26147,20 @@ var init_list_shared_mailbox_folders = __esm(() => {
 // src/use-cases/commands/list-shared-mailbox-child-folders.ts
 var exports_list_shared_mailbox_child_folders = {};
 __export(exports_list_shared_mailbox_child_folders, {
-  execute: () => execute169,
-  meta: () => meta171,
-  schema: () => schema169
+  execute: () => execute175,
+  meta: () => meta177,
+  schema: () => schema175
 });
-var baseSchema90, execute169, schema169, meta171;
+var baseSchema93, execute175, schema175, meta177;
 var init_list_shared_mailbox_child_folders = __esm(() => {
   init_zod();
   init_build_command();
   init_include_hidden_folders();
   init_odata_query();
-  baseSchema90 = exports_external.object({ userId: exports_external.string().min(1), mailFolderId: exports_external.string().min(1), includeHiddenFolders: exports_external.enum(["true", "false"]).optional() });
-  ({ execute: execute169, schema: schema169 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders/${p.mailFolderId}/childFolders${p.includeHiddenFolders === "true" ? "?includeHiddenFolders=true" : ""}`, baseSchema90));
-  meta171 = {
-    summary: "List the subfolders of one mail folder in a shared or delegated mailbox. The `/me` sibling is `list-mail-child-folders`. Walk it from the folder IDs `list-shared-mailbox-folders` returns to reach nested custom folders. 403 if the signed-in user does not have shared access to that mailbox.",
+  baseSchema93 = exports_external.object({ userId: exports_external.string().min(1), mailFolderId: exports_external.string().min(1), includeHiddenFolders: exports_external.enum(["true", "false"]).optional() });
+  ({ execute: execute175, schema: schema175 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders/${p.mailFolderId}/childFolders${p.includeHiddenFolders === "true" ? "?includeHiddenFolders=true" : ""}`, baseSchema93));
+  meta177 = {
+    summary: "List the subfolders of one mail folder in a shared or delegated mailbox. The `/me` sibling is `list-mail-child-folders`. Walk it from the folder IDs `list-shared-mailbox-folders` returns to reach nested custom folders. Requires the delegated `Mail.Read.Shared` scope, which neither token this CLI can mint carries (verified live on two tenants, 2026-08-30), so any mailbox other than the signed-in user's own is expected to answer `ErrorAccessDenied` whatever delegation Exchange holds. Your own UPN works; a Microsoft 365 group's mailbox is the shared-mail path that does (`list-group-conversations`, `list-group-thread-posts`).",
     category: "mail",
     graphMethod: "GET",
     graphPathTemplate: "/users/{user-id}/mailFolders/{mail-folder-id}/childFolders",
@@ -25812,19 +26190,19 @@ var init_list_shared_mailbox_child_folders = __esm(() => {
 // src/use-cases/commands/get-shared-mailbox-message.ts
 var exports_get_shared_mailbox_message = {};
 __export(exports_get_shared_mailbox_message, {
-  execute: () => execute170,
-  meta: () => meta172,
-  schema: () => schema170
+  execute: () => execute176,
+  meta: () => meta178,
+  schema: () => schema176
 });
-var baseSchema91, execute170, schema170, meta172;
+var baseSchema94, execute176, schema176, meta178;
 var init_get_shared_mailbox_message = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
-  baseSchema91 = exports_external.object({ userId: exports_external.string().min(1), messageId: exports_external.string().min(1) });
-  ({ execute: execute170, schema: schema170 } = buildSelectableCommand((p) => `/users/${encodeURIComponent(p.userId)}/messages/${p.messageId}`, baseSchema91));
-  meta172 = {
-    summary: "Return a single message from a shared / delegated mailbox. Use `--select` to fetch only specific fields (e.g. `--select id,subject,from,receivedDateTime`) — sibling to `get-mail-message` for /me.",
+  baseSchema94 = exports_external.object({ userId: exports_external.string().min(1), messageId: exports_external.string().min(1) });
+  ({ execute: execute176, schema: schema176 } = buildSelectableCommand((p) => `/users/${encodeURIComponent(p.userId)}/messages/${p.messageId}`, baseSchema94));
+  meta178 = {
+    summary: "Return a single message from a shared / delegated mailbox. Use `--select` to fetch only specific fields (e.g. `--select id,subject,from,receivedDateTime`) — sibling to `get-mail-message` for /me. Requires the delegated `Mail.Read.Shared` scope, which neither token this CLI can mint carries (verified live on two tenants, 2026-08-30), so any mailbox other than the signed-in user's own is expected to answer `ErrorAccessDenied` whatever delegation Exchange holds. Your own UPN works; a Microsoft 365 group's mailbox is the shared-mail path that does (`list-group-conversations`, `list-group-thread-posts`).",
     category: "mail",
     graphMethod: "GET",
     graphPathTemplate: "/users/{user-id}/messages/{message-id}",
@@ -25852,25 +26230,25 @@ var init_get_shared_mailbox_message = __esm(() => {
 // src/use-cases/commands/list-conversation-messages.ts
 var exports_list_conversation_messages = {};
 __export(exports_list_conversation_messages, {
-  execute: () => execute171,
-  meta: () => meta173,
-  schema: () => schema171
+  execute: () => execute177,
+  meta: () => meta179,
+  schema: () => schema177
 });
-var allowedShape, allowedOptions, schema171, execute171 = async (graph, params) => {
-  const parsed = schema171.safeParse(params);
+var allowedShape, allowedOptions, schema177, execute177 = async (graph, params) => {
+  const parsed = schema177.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   const path = appendOData(`/me/messages?$filter=conversationId eq '${odataStringLiteral(parsed.data.conversationId)}'`, parsed.data);
   return graph.get(path);
-}, meta173;
+}, meta179;
 var init_list_conversation_messages = __esm(() => {
   init_zod();
   init_format_zod_error();
   init_odata_query();
   allowedShape = Object.fromEntries(Object.entries(odataQuerySchema.shape).filter(([key]) => key !== "filter" && key !== "orderby"));
   allowedOptions = odataQueryOptions.filter((o) => o.name !== "filter" && o.name !== "orderby");
-  schema171 = exports_external.object({ conversationId: exports_external.string().min(1) }).extend(allowedShape);
-  meta173 = {
+  schema177 = exports_external.object({ conversationId: exports_external.string().min(1) }).extend(allowedShape);
+  meta179 = {
     summary: "List every message in a single Outlook conversation (thread) using `$filter=conversationId eq '...'`. Reconstructs a complete thread regardless of which subject lines or folders the replies landed in. Accepts the OData passthrough flags top/skip/select/expand — the filter and orderby passthroughs are intentionally omitted (the path already pins a `$filter`, and Graph rejects this filter combined with `$orderby` as `InefficientFilter` since `conversationId` is not a sortable index). The caller can sort by `receivedDateTime` client-side. KQL `$search` does not index `conversationId`, so `$filter` is the only documented Graph idiom for whole-thread retrieval.",
     category: "mail",
     graphMethod: "GET",
@@ -25894,18 +26272,18 @@ var init_list_conversation_messages = __esm(() => {
 // src/use-cases/commands/list-focused-inbox-overrides.ts
 var exports_list_focused_inbox_overrides = {};
 __export(exports_list_focused_inbox_overrides, {
-  execute: () => execute172,
-  meta: () => meta174,
-  schema: () => schema172
+  execute: () => execute178,
+  meta: () => meta180,
+  schema: () => schema178
 });
-var baseSchema92, execute172, schema172, meta174;
+var baseSchema95, execute178, schema178, meta180;
 var init_list_focused_inbox_overrides = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
-  baseSchema92 = exports_external.object({}).strict();
-  ({ execute: execute172, schema: schema172 } = buildListCommand(() => "/me/inferenceClassification/overrides", baseSchema92));
-  meta174 = {
+  baseSchema95 = exports_external.object({}).strict();
+  ({ execute: execute178, schema: schema178 } = buildListCommand(() => "/me/inferenceClassification/overrides", baseSchema95));
+  meta180 = {
     summary: "List the signed-in user's Focused Inbox classification overrides — sender addresses they've manually moved to Focused or Other, which override Microsoft's automatic classifier.",
     category: "mail",
     graphMethod: "GET",
@@ -25921,17 +26299,17 @@ var init_list_focused_inbox_overrides = __esm(() => {
 // src/use-cases/commands/list-outlook-categories.ts
 var exports_list_outlook_categories = {};
 __export(exports_list_outlook_categories, {
-  execute: () => execute173,
-  meta: () => meta175,
-  schema: () => schema173
+  execute: () => execute179,
+  meta: () => meta181,
+  schema: () => schema179
 });
-var schema173, execute173, meta175;
+var schema179, execute179, meta181;
 var init_list_outlook_categories = __esm(() => {
   init_zod();
   init_build_command();
-  schema173 = exports_external.object({}).strict();
-  ({ execute: execute173 } = buildCommand(() => "/me/outlook/masterCategories", schema173));
-  meta175 = {
+  schema179 = exports_external.object({}).strict();
+  ({ execute: execute179 } = buildCommand(() => "/me/outlook/masterCategories", schema179));
+  meta181 = {
     summary: "List the signed-in user's Outlook color categories — the named tags that can be applied to mail, calendar items, and contacts. Each entry has `displayName` and a `color` from Outlook's preset palette. Note: Graph silently ignores every OData passthrough on this endpoint (`$top`, `$skip`, `$select`, `$filter`, `$orderby`, `$expand`), so the CLI does not expose any of those flags — the full collection is always returned. Slice client-side.",
     category: "mail",
     graphMethod: "GET",
@@ -25946,18 +26324,18 @@ var init_list_outlook_categories = __esm(() => {
 // src/use-cases/commands/list-shared-calendar-events.ts
 var exports_list_shared_calendar_events = {};
 __export(exports_list_shared_calendar_events, {
-  execute: () => execute174,
-  meta: () => meta176,
-  schema: () => schema174
+  execute: () => execute180,
+  meta: () => meta182,
+  schema: () => schema180
 });
-var baseSchema93, execute174, schema174, meta176;
+var baseSchema96, execute180, schema180, meta182;
 var init_list_shared_calendar_events = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
-  baseSchema93 = exports_external.object({ userId: exports_external.string().min(1) });
-  ({ execute: execute174, schema: schema174 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/calendar/events`, baseSchema93));
-  meta176 = {
+  baseSchema96 = exports_external.object({ userId: exports_external.string().min(1) });
+  ({ execute: execute180, schema: schema180 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/calendar/events`, baseSchema96));
+  meta182 = {
     summary: "List events from another user's primary calendar (shared / delegated access). 403 without `Calendars.Read.Shared`.",
     category: "calendar",
     graphMethod: "GET",
@@ -25981,19 +26359,19 @@ var init_list_shared_calendar_events = __esm(() => {
 // src/use-cases/commands/get-shared-calendar-view.ts
 var exports_get_shared_calendar_view = {};
 __export(exports_get_shared_calendar_view, {
-  execute: () => execute175,
-  meta: () => meta177,
-  schema: () => schema175
+  execute: () => execute181,
+  meta: () => meta183,
+  schema: () => schema181
 });
-var baseSchema94, execute175, schema175, meta177;
+var baseSchema97, execute181, schema181, meta183;
 var init_get_shared_calendar_view = __esm(() => {
   init_zod();
   init_build_command();
   init_iso_datetime_schema();
   init_odata_query();
-  baseSchema94 = exports_external.object({ userId: exports_external.string().min(1), startDateTime: isoDateTimeField, endDateTime: isoDateTimeField });
-  ({ execute: execute175, schema: schema175 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/calendarView?startDateTime=${encodeURIComponent(p.startDateTime)}&endDateTime=${encodeURIComponent(p.endDateTime)}`, baseSchema94));
-  meta177 = {
+  baseSchema97 = exports_external.object({ userId: exports_external.string().min(1), startDateTime: isoDateTimeField, endDateTime: isoDateTimeField });
+  ({ execute: execute181, schema: schema181 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/calendarView?startDateTime=${encodeURIComponent(p.startDateTime)}&endDateTime=${encodeURIComponent(p.endDateTime)}`, baseSchema97));
+  meta183 = {
     summary: "Return a date-windowed calendar view from another user's primary calendar (shared / delegated access). Recurrences expanded into individual occurrences.",
     category: "calendar",
     graphMethod: "GET",
@@ -26019,18 +26397,18 @@ var init_get_shared_calendar_view = __esm(() => {
 // src/use-cases/commands/list-sharepoint-list-columns.ts
 var exports_list_sharepoint_list_columns = {};
 __export(exports_list_sharepoint_list_columns, {
-  execute: () => execute176,
-  meta: () => meta178,
-  schema: () => schema176
+  execute: () => execute182,
+  meta: () => meta184,
+  schema: () => schema182
 });
-var baseSchema95, execute176, schema176, meta178;
+var baseSchema98, execute182, schema182, meta184;
 var init_list_sharepoint_list_columns = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
-  baseSchema95 = exports_external.object({ siteId: exports_external.string().min(1), listId: exports_external.string().min(1) });
-  ({ execute: execute176, schema: schema176 } = buildSelectableCommand((p) => `/sites/${p.siteId}/lists/${p.listId}/columns`, baseSchema95));
-  meta178 = {
+  baseSchema98 = exports_external.object({ siteId: exports_external.string().min(1), listId: exports_external.string().min(1) });
+  ({ execute: execute182, schema: schema182 } = buildSelectableCommand((p) => `/sites/${p.siteId}/lists/${p.listId}/columns`, baseSchema98));
+  meta184 = {
     summary: "List the column definitions (schema) of a SharePoint list. Useful before reading list items so you know which fields exist and their types. Note: Graph silently ignores `$top` and `$skip` on this endpoint, so the CLI exposes only `--select` and `--expand`.",
     category: "sharepoint",
     graphMethod: "GET",
@@ -26059,18 +26437,18 @@ var init_list_sharepoint_list_columns = __esm(() => {
 // src/use-cases/commands/get-sharepoint-list-column.ts
 var exports_get_sharepoint_list_column = {};
 __export(exports_get_sharepoint_list_column, {
-  execute: () => execute177,
-  meta: () => meta179,
-  schema: () => schema177
+  execute: () => execute183,
+  meta: () => meta185,
+  schema: () => schema183
 });
-var baseSchema96, execute177, schema177, meta179;
+var baseSchema99, execute183, schema183, meta185;
 var init_get_sharepoint_list_column = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
-  baseSchema96 = exports_external.object({ siteId: exports_external.string().min(1), listId: exports_external.string().min(1), columnId: exports_external.string().min(1) });
-  ({ execute: execute177, schema: schema177 } = buildSelectableCommand((p) => `/sites/${p.siteId}/lists/${p.listId}/columns/${p.columnId}`, baseSchema96));
-  meta179 = {
+  baseSchema99 = exports_external.object({ siteId: exports_external.string().min(1), listId: exports_external.string().min(1), columnId: exports_external.string().min(1) });
+  ({ execute: execute183, schema: schema183 } = buildSelectableCommand((p) => `/sites/${p.siteId}/lists/${p.listId}/columns/${p.columnId}`, baseSchema99));
+  meta185 = {
     summary: "Return a single column definition from a SharePoint list.",
     category: "sharepoint",
     graphMethod: "GET",
@@ -26123,21 +26501,21 @@ var init_onenote_5k_limit = () => {};
 // src/use-cases/commands/list-sharepoint-site-onenote-notebooks.ts
 var exports_list_sharepoint_site_onenote_notebooks = {};
 __export(exports_list_sharepoint_site_onenote_notebooks, {
-  execute: () => execute178,
-  meta: () => meta180,
-  schema: () => schema178
+  execute: () => execute184,
+  meta: () => meta186,
+  schema: () => schema184
 });
-var baseSchema97, inner14, execute178, schema178, meta180;
+var baseSchema100, inner14, execute184, schema184, meta186;
 var init_list_sharepoint_site_onenote_notebooks = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
   init_onenote_5k_limit();
-  baseSchema97 = exports_external.object({ siteId: exports_external.string().min(1) });
-  inner14 = buildListCommand((p) => `/sites/${p.siteId}/onenote/notebooks`, baseSchema97);
-  execute178 = wrapOnenote5kLimit(inner14.execute);
-  ({ schema: schema178 } = inner14);
-  meta180 = {
+  baseSchema100 = exports_external.object({ siteId: exports_external.string().min(1) });
+  inner14 = buildListCommand((p) => `/sites/${p.siteId}/onenote/notebooks`, baseSchema100);
+  execute184 = wrapOnenote5kLimit(inner14.execute);
+  ({ schema: schema184 } = inner14);
+  meta186 = {
     summary: "List OneNote notebooks attached to a SharePoint site (separate from the personal `list-onenote-notebooks` which targets `/me`).",
     category: "notes",
     graphMethod: "GET",
@@ -26161,21 +26539,21 @@ var init_list_sharepoint_site_onenote_notebooks = __esm(() => {
 // src/use-cases/commands/list-sharepoint-site-onenote-notebook-sections.ts
 var exports_list_sharepoint_site_onenote_notebook_sections = {};
 __export(exports_list_sharepoint_site_onenote_notebook_sections, {
-  execute: () => execute179,
-  meta: () => meta181,
-  schema: () => schema179
+  execute: () => execute185,
+  meta: () => meta187,
+  schema: () => schema185
 });
-var baseSchema98, inner15, execute179, schema179, meta181;
+var baseSchema101, inner15, execute185, schema185, meta187;
 var init_list_sharepoint_site_onenote_notebook_sections = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
   init_onenote_5k_limit();
-  baseSchema98 = exports_external.object({ siteId: exports_external.string().min(1), notebookId: exports_external.string().min(1) });
-  inner15 = buildListCommand((p) => `/sites/${p.siteId}/onenote/notebooks/${p.notebookId}/sections`, baseSchema98);
-  execute179 = wrapOnenote5kLimit(inner15.execute);
-  ({ schema: schema179 } = inner15);
-  meta181 = {
+  baseSchema101 = exports_external.object({ siteId: exports_external.string().min(1), notebookId: exports_external.string().min(1) });
+  inner15 = buildListCommand((p) => `/sites/${p.siteId}/onenote/notebooks/${p.notebookId}/sections`, baseSchema101);
+  execute185 = wrapOnenote5kLimit(inner15.execute);
+  ({ schema: schema185 } = inner15);
+  meta187 = {
     summary: "List sections inside one OneNote notebook attached to a SharePoint site.",
     category: "notes",
     graphMethod: "GET",
@@ -26205,21 +26583,21 @@ var init_list_sharepoint_site_onenote_notebook_sections = __esm(() => {
 // src/use-cases/commands/list-sharepoint-site-onenote-section-pages.ts
 var exports_list_sharepoint_site_onenote_section_pages = {};
 __export(exports_list_sharepoint_site_onenote_section_pages, {
-  execute: () => execute180,
-  meta: () => meta182,
-  schema: () => schema180
+  execute: () => execute186,
+  meta: () => meta188,
+  schema: () => schema186
 });
-var baseSchema99, inner16, execute180, schema180, meta182;
+var baseSchema102, inner16, execute186, schema186, meta188;
 var init_list_sharepoint_site_onenote_section_pages = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
   init_onenote_5k_limit();
-  baseSchema99 = exports_external.object({ siteId: exports_external.string().min(1), onenoteSectionId: exports_external.string().min(1) });
-  inner16 = buildListCommand((p) => `/sites/${p.siteId}/onenote/sections/${p.onenoteSectionId}/pages`, baseSchema99);
-  execute180 = wrapOnenote5kLimit(inner16.execute);
-  ({ schema: schema180 } = inner16);
-  meta182 = {
+  baseSchema102 = exports_external.object({ siteId: exports_external.string().min(1), onenoteSectionId: exports_external.string().min(1) });
+  inner16 = buildListCommand((p) => `/sites/${p.siteId}/onenote/sections/${p.onenoteSectionId}/pages`, baseSchema102);
+  execute186 = wrapOnenote5kLimit(inner16.execute);
+  ({ schema: schema186 } = inner16);
+  meta188 = {
     summary: "List pages inside one section of a SharePoint-site OneNote notebook.",
     category: "notes",
     graphMethod: "GET",
@@ -26249,23 +26627,23 @@ var init_list_sharepoint_site_onenote_section_pages = __esm(() => {
 // src/use-cases/commands/get-sharepoint-site-onenote-page-content.ts
 var exports_get_sharepoint_site_onenote_page_content = {};
 __export(exports_get_sharepoint_site_onenote_page_content, {
-  execute: () => execute181,
-  meta: () => meta183,
-  schema: () => schema181
+  execute: () => execute187,
+  meta: () => meta189,
+  schema: () => schema187
 });
-var schema181, innerExecute = async (graph, params) => {
-  const parsed = schema181.safeParse(params);
+var schema187, innerExecute = async (graph, params) => {
+  const parsed = schema187.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   return graph.getBinary(`/sites/${parsed.data.siteId}/onenote/pages/${parsed.data.onenotePageId}/content`);
-}, execute181, meta183;
+}, execute187, meta189;
 var init_get_sharepoint_site_onenote_page_content = __esm(() => {
   init_zod();
   init_format_zod_error();
   init_onenote_5k_limit();
-  schema181 = exports_external.object({ siteId: exports_external.string().min(1), onenotePageId: exports_external.string().min(1) });
-  execute181 = wrapOnenote5kLimit(innerExecute);
-  meta183 = {
+  schema187 = exports_external.object({ siteId: exports_external.string().min(1), onenotePageId: exports_external.string().min(1) });
+  execute187 = wrapOnenote5kLimit(innerExecute);
+  meta189 = {
     summary: "Return the HTML content of a single OneNote page from a SharePoint site (parallel to `get-onenote-page-content` for `/me`). The response carries the standard `{contentType: text/html, size, text}` shape so the HTML body is available verbatim under either output format.",
     category: "notes",
     graphMethod: "GET",
@@ -26294,19 +26672,19 @@ var init_get_sharepoint_site_onenote_page_content = __esm(() => {
 // src/use-cases/commands/list-drive-item-thumbnails.ts
 var exports_list_drive_item_thumbnails = {};
 __export(exports_list_drive_item_thumbnails, {
-  execute: () => execute182,
-  meta: () => meta184,
-  schema: () => schema182
+  execute: () => execute188,
+  meta: () => meta190,
+  schema: () => schema188
 });
-var baseSchema100, execute182, schema182, meta184;
+var baseSchema103, execute188, schema188, meta190;
 var init_list_drive_item_thumbnails = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
   init_tenant_option();
-  baseSchema100 = exports_external.object({ driveId: exports_external.string().min(1), itemId: exports_external.string().min(1), ...tenantIdShape });
-  ({ execute: execute182, schema: schema182 } = buildNoSkipListCommand((p) => `/drives/${p.driveId}/items/${p.itemId}/thumbnails`, baseSchema100));
-  meta184 = {
+  baseSchema103 = exports_external.object({ driveId: exports_external.string().min(1), itemId: exports_external.string().min(1), ...tenantIdShape });
+  ({ execute: execute188, schema: schema188 } = buildNoSkipListCommand((p) => `/drives/${p.driveId}/items/${p.itemId}/thumbnails`, baseSchema103));
+  meta190 = {
     summary: "List thumbnail URLs (small / medium / large) for a OneDrive / SharePoint file. Each thumbnail set has pre-signed CDN URLs you can render in a UI without further auth.",
     category: "drive",
     graphMethod: "GET",
@@ -26338,12 +26716,12 @@ var init_list_drive_item_thumbnails = __esm(() => {
 // src/use-cases/commands/get-excel-used-range.ts
 var exports_get_excel_used_range = {};
 __export(exports_get_excel_used_range, {
-  execute: () => execute183,
-  meta: () => meta185,
-  schema: () => schema183
+  execute: () => execute189,
+  meta: () => meta191,
+  schema: () => schema189
 });
-var DEFAULT_MAX_CELLS2 = 50000, schema183, execute183 = async (graph, params) => {
-  const parsed = schema183.safeParse(params);
+var DEFAULT_MAX_CELLS2 = 50000, schema189, execute189 = async (graph, params) => {
+  const parsed = schema189.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   const { driveId, itemId, worksheetId } = parsed.data;
@@ -26377,19 +26755,19 @@ var DEFAULT_MAX_CELLS2 = 50000, schema183, execute183 = async (graph, params) =>
     values: body.values,
     projection: "slim"
   });
-}, meta185;
+}, meta191;
 var init_get_excel_used_range = __esm(() => {
   init_zod();
   init_excel_error();
   init_format_zod_error();
-  schema183 = exports_external.object({
+  schema189 = exports_external.object({
     driveId: exports_external.string().min(1),
     itemId: exports_external.string().min(1),
     worksheetId: exports_external.string().min(1),
     full: exports_external.enum(["true", "false"]).optional(),
     maxCells: exports_external.string().regex(/^[1-9]\d*$/, "must be a positive integer").optional()
   });
-  meta185 = {
+  meta191 = {
     summary: 'Return the worksheet\'s used range — the bounding box of every non-empty cell — as a single Excel range. The CLI ships a slim default that strips the redundant `text` / `numberFormat` / `formulas` 2D arrays Graph returns (mostly `"General"` repeated cell-by-cell), keeping `address` / `rowCount` / `columnCount` / `values`. Pass `--full true` to return the raw four-array Graph shape. `--max-cells` (default 50 000) caps the size of the projected `values[]`; oversize ranges drop `values` and surface a hint pointing at `get-excel-range` for band-by-band reads. Avoids fetching the entire 1M × 16K-cell sheet when only a small data island is populated.',
     category: "excel",
     graphMethod: "GET",
@@ -26436,18 +26814,18 @@ var init_get_excel_used_range = __esm(() => {
 // src/use-cases/commands/list-rooms.ts
 var exports_list_rooms = {};
 __export(exports_list_rooms, {
-  execute: () => execute184,
-  meta: () => meta186,
-  schema: () => schema184
+  execute: () => execute190,
+  meta: () => meta192,
+  schema: () => schema190
 });
-var baseSchema101, execute184, schema184, meta186;
+var baseSchema104, execute190, schema190, meta192;
 var init_list_rooms = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
-  baseSchema101 = exports_external.object({}).strict();
-  ({ execute: execute184, schema: schema184 } = buildListCommand(() => "/places/microsoft.graph.room", baseSchema101));
-  meta186 = {
+  baseSchema104 = exports_external.object({}).strict();
+  ({ execute: execute190, schema: schema190 } = buildListCommand(() => "/places/microsoft.graph.room", baseSchema104));
+  meta192 = {
     summary: "List bookable meeting rooms in the tenant. Each `room` has `displayName`, `emailAddress`, `capacity`, `building`, `floorNumber`, and `isWheelChairAccessible`. Use the `emailAddress` as a meeting `attendee` for room booking. Pass `--top 5` to limit the response — large tenants return tens of KB by default.",
     category: "calendar",
     graphMethod: "GET",
@@ -26463,18 +26841,18 @@ var init_list_rooms = __esm(() => {
 // src/use-cases/commands/list-room-lists.ts
 var exports_list_room_lists = {};
 __export(exports_list_room_lists, {
-  execute: () => execute185,
-  meta: () => meta187,
-  schema: () => schema185
+  execute: () => execute191,
+  meta: () => meta193,
+  schema: () => schema191
 });
-var baseSchema102, execute185, schema185, meta187;
+var baseSchema105, execute191, schema191, meta193;
 var init_list_room_lists = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
-  baseSchema102 = exports_external.object({}).strict();
-  ({ execute: execute185, schema: schema185 } = buildListCommand(() => "/places/microsoft.graph.roomList", baseSchema102));
-  meta187 = {
+  baseSchema105 = exports_external.object({}).strict();
+  ({ execute: execute191, schema: schema191 } = buildListCommand(() => "/places/microsoft.graph.roomList", baseSchema105));
+  meta193 = {
     summary: "List room lists — usually one per building. Use these to scope a room search by location: a roomList groups the rooms in one office, then `/places/{roomList}/rooms` lists just those rooms. Pass `--top N` to limit the response on large tenants.",
     category: "calendar",
     graphMethod: "GET",
@@ -26490,18 +26868,18 @@ var init_list_room_lists = __esm(() => {
 // src/use-cases/commands/list-trending-insights.ts
 var exports_list_trending_insights = {};
 __export(exports_list_trending_insights, {
-  execute: () => execute186,
-  meta: () => meta188,
-  schema: () => schema186
+  execute: () => execute192,
+  meta: () => meta194,
+  schema: () => schema192
 });
-var baseSchema103, execute186, schema186, meta188;
+var baseSchema106, execute192, schema192, meta194;
 var init_list_trending_insights = __esm(() => {
   init_zod();
   init_build_command();
   init_odata_query();
-  baseSchema103 = exports_external.object({}).strict();
-  ({ execute: execute186, schema: schema186 } = buildListCommand(() => "/me/insights/trending", baseSchema103));
-  meta188 = {
+  baseSchema106 = exports_external.object({}).strict();
+  ({ execute: execute192, schema: schema192 } = buildListCommand(() => "/me/insights/trending", baseSchema106));
+  meta194 = {
     summary: "List documents trending around the signed-in user — files popular in their working network (colleagues' recent edits, shares, opens). Microsoft's relevance ranking, useful for surfacing unfamiliar but related work.",
     category: "drive",
     graphMethod: "GET",
@@ -26681,6 +27059,12 @@ var init_commands = __esm(() => {
   init_get_group_calendar_view();
   init_list_group_conversations();
   init_list_group_threads();
+  init_list_group_thread_posts();
+  init_get_group_post();
+  init_convert_group_post_to_markdown();
+  init_list_group_post_attachments();
+  init_get_group_post_attachment();
+  init_convert_group_post_attachment_to_markdown();
   init_get_mail_message_mime();
   init_list_mail_folder_messages_delta();
   init_list_shared_mailbox_messages();
@@ -26832,6 +27216,12 @@ var init_commands = __esm(() => {
     "list-group-calendar-view": exports_get_group_calendar_view,
     "list-group-conversations": exports_list_group_conversations,
     "list-group-threads": exports_list_group_threads,
+    "list-group-thread-posts": exports_list_group_thread_posts,
+    "get-group-post": exports_get_group_post,
+    "convert-group-post-to-markdown": exports_convert_group_post_to_markdown,
+    "list-group-post-attachments": exports_list_group_post_attachments,
+    "get-group-post-attachment": exports_get_group_post_attachment,
+    "convert-group-post-attachment-to-markdown": exports_convert_group_post_attachment_to_markdown,
     "get-mail-message-mime": exports_get_mail_message_mime,
     "list-mail-folder-messages-delta": exports_list_mail_folder_messages_delta,
     "list-shared-mailbox-messages": exports_list_shared_mailbox_messages,
@@ -29062,7 +29452,7 @@ var init_error_hints = __esm(() => {
     {
       source: "cli",
       matchCode: (c) => c === "commander.unknownOption",
-      hint: "Unknown CLI flag. Run `ask-marcel-office <command> --help` for the supported flags on that command, or `ask-marcel-office help-json --terse --category <name>` (~6 KB) to scan the whole category."
+      hint: "Unknown CLI flag. Run `ask-marcel-office <command> --help` for the supported flags on that command, or `ask-marcel-office help-json --terse --category <name>` (~8 KB) to scan the whole category."
     },
     {
       source: "cli",
@@ -29082,7 +29472,7 @@ var init_error_hints = __esm(() => {
     {
       source: "cli",
       matchCode: (c) => c === "commander.unknownCommand" || c === "cli_unknown_command",
-      hint: "Unknown ask-marcel-office subcommand. Run `ask-marcel-office help-json --terse` (~31 KB across all categories) or `ask-marcel-office help-json --terse --category mail` (~6 KB for one category) to discover the right command."
+      hint: "Unknown ask-marcel-office subcommand. Run `ask-marcel-office help-json --terse` (~33 KB across all categories) or `ask-marcel-office help-json --terse --category mail` (~8 KB for one category) to discover the right command."
     },
     {
       source: "cli",
@@ -29648,6 +30038,12 @@ var init_graph_scopes = __esm(() => {
     "list-group-owners": ["GroupMember.Read.All"],
     "list-group-conversations": ["Group.Read.All"],
     "list-group-threads": ["Group.Read.All"],
+    "list-group-thread-posts": ["Group.Read.All"],
+    "get-group-post": ["Group.Read.All"],
+    "convert-group-post-to-markdown": ["Group.Read.All"],
+    "list-group-post-attachments": ["Group.Read.All"],
+    "get-group-post-attachment": ["Group.Read.All"],
+    "convert-group-post-attachment-to-markdown": ["Group.Read.All"],
     "list-onenote-notebooks": ["Notes.Read"],
     "list-onenote-notebook-sections": ["Notes.Read"],
     "list-all-onenote-sections": ["Notes.Read"],
@@ -29829,7 +30225,7 @@ var init_docs = __esm(() => {
     },
     {
       name: "help-json",
-      summary: "Print the machine-readable command manifest as JSON. For fresh-session discovery use `--terse --category <name>` (~6 KB for one category). The unflagged form is the *full* reference (every option / example / response shape per command) and is roughly 13× the size of `ask-marcel-office --help` — reach for it only after `--terse` has narrowed the search. `--terse` alone projects each entry to `{name, summary, category}` (summary compacted to its first sentence). Categories: lifecycle, drive, excel, sharepoint, tasks, mail, notes, user, calendar, chats, teams, meta.",
+      summary: "Print the machine-readable command manifest as JSON. For fresh-session discovery use `--terse --category <name>` (~8 KB for one category). The unflagged form is the *full* reference (every option / example / response shape per command) and is roughly 15× the size of `ask-marcel-office --help` — reach for it only after `--terse` has narrowed the search. `--terse` alone projects each entry to `{name, summary, category}` (summary compacted to its first sentence). Categories: lifecycle, drive, excel, sharepoint, tasks, mail, notes, user, calendar, chats, teams, meta.",
       category: "lifecycle",
       graphMethod: "GET",
       graphPathTemplate: "(lifecycle) renders the in-process command manifest",
@@ -29853,7 +30249,7 @@ var init_docs = __esm(() => {
 });
 
 // src/use-cases/commands/login.ts
-var schema187, execute187 = async (auth, options) => {
+var schema193, execute193 = async (auth, options) => {
   const authenticated = await auth.getAccessToken(options);
   if (!authenticated.ok || options?.force === true)
     return authenticated;
@@ -29868,7 +30264,7 @@ var schema187, execute187 = async (auth, options) => {
 };
 var init_login = __esm(() => {
   init_zod();
-  schema187 = exports_external.object({}).strict();
+  schema193 = exports_external.object({}).strict();
 });
 
 // src/use-cases/commands/login-status.ts
@@ -30922,30 +31318,30 @@ function floatSafeRemainder2(val, step) {
   const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
   return valInt % stepInt / 10 ** decCount;
 }
-function deepPartialify(schema190) {
-  if (schema190 instanceof ZodObject2) {
+function deepPartialify(schema196) {
+  if (schema196 instanceof ZodObject2) {
     const newShape = {};
-    for (const key in schema190.shape) {
-      const fieldSchema = schema190.shape[key];
+    for (const key in schema196.shape) {
+      const fieldSchema = schema196.shape[key];
       newShape[key] = ZodOptional2.create(deepPartialify(fieldSchema));
     }
     return new ZodObject2({
-      ...schema190._def,
+      ...schema196._def,
       shape: () => newShape
     });
-  } else if (schema190 instanceof ZodArray2) {
+  } else if (schema196 instanceof ZodArray2) {
     return new ZodArray2({
-      ...schema190._def,
-      type: deepPartialify(schema190.element)
+      ...schema196._def,
+      type: deepPartialify(schema196.element)
     });
-  } else if (schema190 instanceof ZodOptional2) {
-    return ZodOptional2.create(deepPartialify(schema190.unwrap()));
-  } else if (schema190 instanceof ZodNullable2) {
-    return ZodNullable2.create(deepPartialify(schema190.unwrap()));
-  } else if (schema190 instanceof ZodTuple2) {
-    return ZodTuple2.create(schema190.items.map((item) => deepPartialify(item)));
+  } else if (schema196 instanceof ZodOptional2) {
+    return ZodOptional2.create(deepPartialify(schema196.unwrap()));
+  } else if (schema196 instanceof ZodNullable2) {
+    return ZodNullable2.create(deepPartialify(schema196.unwrap()));
+  } else if (schema196 instanceof ZodTuple2) {
+    return ZodTuple2.create(schema196.items.map((item) => deepPartialify(item)));
   } else {
-    return schema190;
+    return schema196;
   }
 }
 function mergeValues2(a, b) {
@@ -32366,9 +32762,9 @@ var init_types = __esm(() => {
       return this.min(1, message);
     }
   };
-  ZodArray2.create = (schema190, params) => {
+  ZodArray2.create = (schema196, params) => {
     return new ZodArray2({
-      type: schema190,
+      type: schema196,
       minLength: null,
       maxLength: null,
       exactLength: null,
@@ -32528,8 +32924,8 @@ var init_types = __esm(() => {
       });
       return merged;
     }
-    setKey(key, schema190) {
-      return this.augment({ [key]: schema190 });
+    setKey(key, schema196) {
+      return this.augment({ [key]: schema196 });
     }
     catchall(index) {
       return new ZodObject2({
@@ -32874,10 +33270,10 @@ var init_types = __esm(() => {
         status.dirty();
       }
       const items = [...ctx.data].map((item, itemIndex) => {
-        const schema190 = this._def.items[itemIndex] || this._def.rest;
-        if (!schema190)
+        const schema196 = this._def.items[itemIndex] || this._def.rest;
+        if (!schema196)
           return null;
-        return schema190._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
+        return schema196._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
       }).filter((x) => !!x);
       if (ctx.common.async) {
         return Promise.all(items).then((results) => {
@@ -33384,9 +33780,9 @@ var init_types = __esm(() => {
       }));
     }
   };
-  ZodPromise2.create = (schema190, params) => {
+  ZodPromise2.create = (schema196, params) => {
     return new ZodPromise2({
-      type: schema190,
+      type: schema196,
       typeName: ZodFirstPartyTypeKind2.ZodPromise,
       ...processCreateParams(params)
     });
@@ -33514,17 +33910,17 @@ var init_types = __esm(() => {
       util.assertNever(effect);
     }
   };
-  ZodEffects.create = (schema190, effect, params) => {
+  ZodEffects.create = (schema196, effect, params) => {
     return new ZodEffects({
-      schema: schema190,
+      schema: schema196,
       typeName: ZodFirstPartyTypeKind2.ZodEffects,
       effect,
       ...processCreateParams(params)
     });
   };
-  ZodEffects.createWithPreprocess = (preprocess2, schema190, params) => {
+  ZodEffects.createWithPreprocess = (preprocess2, schema196, params) => {
     return new ZodEffects({
-      schema: schema190,
+      schema: schema196,
       effect: { type: "preprocess", transform: preprocess2 },
       typeName: ZodFirstPartyTypeKind2.ZodEffects,
       ...processCreateParams(params)
@@ -33892,8 +34288,8 @@ var init_schemas3 = __esm(() => {
     inst.with = inst.check;
     inst.clone = (_def, params) => clone(inst, _def, params);
     inst.brand = () => inst;
-    inst.register = (reg, meta189) => {
-      reg.add(inst, meta189);
+    inst.register = (reg, meta195) => {
+      reg.add(inst, meta195);
       return inst;
     };
     inst.apply = (fn) => fn(inst);
@@ -33933,8 +34329,8 @@ var init_v4_mini = __esm(() => {
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 function isZ4Schema(s) {
-  const schema190 = s;
-  return !!schema190._zod;
+  const schema196 = s;
+  return !!schema196._zod;
 }
 function objectFromShape(shape) {
   const values = Object.values(shape);
@@ -33948,33 +34344,33 @@ function objectFromShape(shape) {
     return objectType(shape);
   throw new Error("Mixed Zod versions detected in object shape.");
 }
-function safeParse3(schema190, data) {
-  if (isZ4Schema(schema190)) {
-    const result2 = safeParse(schema190, data);
+function safeParse3(schema196, data) {
+  if (isZ4Schema(schema196)) {
+    const result2 = safeParse(schema196, data);
     return result2;
   }
-  const v3Schema = schema190;
+  const v3Schema = schema196;
   const result = v3Schema.safeParse(data);
   return result;
 }
-async function safeParseAsync3(schema190, data) {
-  if (isZ4Schema(schema190)) {
-    const result2 = await safeParseAsync(schema190, data);
+async function safeParseAsync3(schema196, data) {
+  if (isZ4Schema(schema196)) {
+    const result2 = await safeParseAsync(schema196, data);
     return result2;
   }
-  const v3Schema = schema190;
+  const v3Schema = schema196;
   const result = await v3Schema.safeParseAsync(data);
   return result;
 }
-function getObjectShape(schema190) {
-  if (!schema190)
+function getObjectShape(schema196) {
+  if (!schema196)
     return;
   let rawShape;
-  if (isZ4Schema(schema190)) {
-    const v4Schema = schema190;
+  if (isZ4Schema(schema196)) {
+    const v4Schema = schema196;
     rawShape = v4Schema._zod?.def?.shape;
   } else {
-    const v3Schema = schema190;
+    const v3Schema = schema196;
     rawShape = v3Schema.shape;
   }
   if (!rawShape)
@@ -33988,29 +34384,29 @@ function getObjectShape(schema190) {
   }
   return rawShape;
 }
-function normalizeObjectSchema(schema190) {
-  if (!schema190)
+function normalizeObjectSchema(schema196) {
+  if (!schema196)
     return;
-  if (typeof schema190 === "object") {
-    const asV3 = schema190;
-    const asV4 = schema190;
+  if (typeof schema196 === "object") {
+    const asV3 = schema196;
+    const asV4 = schema196;
     if (!asV3._def && !asV4._zod) {
-      const values = Object.values(schema190);
+      const values = Object.values(schema196);
       if (values.length > 0 && values.every((v) => typeof v === "object" && v !== null && (v._def !== undefined || v._zod !== undefined || typeof v.parse === "function"))) {
-        return objectFromShape(schema190);
+        return objectFromShape(schema196);
       }
     }
   }
-  if (isZ4Schema(schema190)) {
-    const v4Schema = schema190;
+  if (isZ4Schema(schema196)) {
+    const v4Schema = schema196;
     const def = v4Schema._zod?.def;
     if (def && (def.type === "object" || def.shape !== undefined)) {
-      return schema190;
+      return schema196;
     }
   } else {
-    const v3Schema = schema190;
+    const v3Schema = schema196;
     if (v3Schema.shape !== undefined) {
-      return schema190;
+      return schema196;
     }
   }
   return;
@@ -34034,23 +34430,23 @@ function getParseErrorMessage(error48) {
   }
   return String(error48);
 }
-function getSchemaDescription(schema190) {
-  return schema190.description;
+function getSchemaDescription(schema196) {
+  return schema196.description;
 }
-function isSchemaOptional(schema190) {
-  if (isZ4Schema(schema190)) {
-    const v4Schema = schema190;
+function isSchemaOptional(schema196) {
+  if (isZ4Schema(schema196)) {
+    const v4Schema = schema196;
     return v4Schema._zod?.def?.type === "optional";
   }
-  const v3Schema = schema190;
-  if (typeof schema190.isOptional === "function") {
-    return schema190.isOptional();
+  const v3Schema = schema196;
+  if (typeof schema196.isOptional === "function") {
+    return schema196.isOptional();
   }
   return v3Schema._def?.typeName === "ZodOptional";
 }
-function getLiteralValue(schema190) {
-  if (isZ4Schema(schema190)) {
-    const v4Schema = schema190;
+function getLiteralValue(schema196) {
+  if (isZ4Schema(schema196)) {
+    const v4Schema = schema196;
     const def2 = v4Schema._zod?.def;
     if (def2) {
       if (def2.value !== undefined)
@@ -34060,7 +34456,7 @@ function getLiteralValue(schema190) {
       }
     }
   }
-  const v3Schema = schema190;
+  const v3Schema = schema196;
   const def = v3Schema._def;
   if (def) {
     if (def.value !== undefined)
@@ -34069,7 +34465,7 @@ function getLiteralValue(schema190) {
       return def.values[0];
     }
   }
-  const directValue = schema190.value;
+  const directValue = schema196.value;
   if (directValue !== undefined)
     return directValue;
   return;
@@ -35220,16 +35616,16 @@ function parseIntersectionDef(def, refs) {
   ].filter((x) => !!x);
   let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : undefined;
   const mergedAllOf = [];
-  allOf.forEach((schema190) => {
-    if (isJsonSchema7AllOfType(schema190)) {
-      mergedAllOf.push(...schema190.allOf);
-      if (schema190.unevaluatedProperties === undefined) {
+  allOf.forEach((schema196) => {
+    if (isJsonSchema7AllOfType(schema196)) {
+      mergedAllOf.push(...schema196.allOf);
+      if (schema196.unevaluatedProperties === undefined) {
         unevaluatedProperties = undefined;
       }
     } else {
-      let nestedSchema = schema190;
-      if ("additionalProperties" in schema190 && schema190.additionalProperties === false) {
-        const { additionalProperties, ...rest } = schema190;
+      let nestedSchema = schema196;
+      if ("additionalProperties" in schema196 && schema196.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema196;
         nestedSchema = rest;
       } else {
         unevaluatedProperties = undefined;
@@ -35414,60 +35810,60 @@ function escapeNonAlphaNumeric(source) {
   }
   return result;
 }
-function addFormat(schema190, value, message, refs) {
-  if (schema190.format || schema190.anyOf?.some((x) => x.format)) {
-    if (!schema190.anyOf) {
-      schema190.anyOf = [];
+function addFormat(schema196, value, message, refs) {
+  if (schema196.format || schema196.anyOf?.some((x) => x.format)) {
+    if (!schema196.anyOf) {
+      schema196.anyOf = [];
     }
-    if (schema190.format) {
-      schema190.anyOf.push({
-        format: schema190.format,
-        ...schema190.errorMessage && refs.errorMessages && {
-          errorMessage: { format: schema190.errorMessage.format }
+    if (schema196.format) {
+      schema196.anyOf.push({
+        format: schema196.format,
+        ...schema196.errorMessage && refs.errorMessages && {
+          errorMessage: { format: schema196.errorMessage.format }
         }
       });
-      delete schema190.format;
-      if (schema190.errorMessage) {
-        delete schema190.errorMessage.format;
-        if (Object.keys(schema190.errorMessage).length === 0) {
-          delete schema190.errorMessage;
+      delete schema196.format;
+      if (schema196.errorMessage) {
+        delete schema196.errorMessage.format;
+        if (Object.keys(schema196.errorMessage).length === 0) {
+          delete schema196.errorMessage;
         }
       }
     }
-    schema190.anyOf.push({
+    schema196.anyOf.push({
       format: value,
       ...message && refs.errorMessages && { errorMessage: { format: message } }
     });
   } else {
-    setResponseValueAndErrors(schema190, "format", value, message, refs);
+    setResponseValueAndErrors(schema196, "format", value, message, refs);
   }
 }
-function addPattern(schema190, regex, message, refs) {
-  if (schema190.pattern || schema190.allOf?.some((x) => x.pattern)) {
-    if (!schema190.allOf) {
-      schema190.allOf = [];
+function addPattern(schema196, regex, message, refs) {
+  if (schema196.pattern || schema196.allOf?.some((x) => x.pattern)) {
+    if (!schema196.allOf) {
+      schema196.allOf = [];
     }
-    if (schema190.pattern) {
-      schema190.allOf.push({
-        pattern: schema190.pattern,
-        ...schema190.errorMessage && refs.errorMessages && {
-          errorMessage: { pattern: schema190.errorMessage.pattern }
+    if (schema196.pattern) {
+      schema196.allOf.push({
+        pattern: schema196.pattern,
+        ...schema196.errorMessage && refs.errorMessages && {
+          errorMessage: { pattern: schema196.errorMessage.pattern }
         }
       });
-      delete schema190.pattern;
-      if (schema190.errorMessage) {
-        delete schema190.errorMessage.pattern;
-        if (Object.keys(schema190.errorMessage).length === 0) {
-          delete schema190.errorMessage;
+      delete schema196.pattern;
+      if (schema196.errorMessage) {
+        delete schema196.errorMessage.pattern;
+        if (Object.keys(schema196.errorMessage).length === 0) {
+          delete schema196.errorMessage;
         }
       }
     }
-    schema190.allOf.push({
+    schema196.allOf.push({
       pattern: stringifyRegExpWithFlags(regex, refs),
       ...message && refs.errorMessages && { errorMessage: { pattern: message } }
     });
   } else {
-    setResponseValueAndErrors(schema190, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+    setResponseValueAndErrors(schema196, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
   }
 }
 function stringifyRegExpWithFlags(regex, refs) {
@@ -35589,7 +35985,7 @@ function parseRecordDef(def, refs) {
       additionalProperties: refs.rejectedAdditionalProperties
     };
   }
-  const schema190 = {
+  const schema196 = {
     type: "object",
     additionalProperties: parseDef(def.valueType._def, {
       ...refs,
@@ -35597,17 +35993,17 @@ function parseRecordDef(def, refs) {
     }) ?? refs.allowedAdditionalProperties
   };
   if (refs.target === "openApi3") {
-    return schema190;
+    return schema196;
   }
   if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodString && def.keyType._def.checks?.length) {
     const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
     return {
-      ...schema190,
+      ...schema196,
       propertyNames: keyType
     };
   } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodEnum) {
     return {
-      ...schema190,
+      ...schema196,
       propertyNames: {
         enum: def.keyType._def.values
       }
@@ -35615,11 +36011,11 @@ function parseRecordDef(def, refs) {
   } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && def.keyType._def.type._def.checks?.length) {
     const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
     return {
-      ...schema190,
+      ...schema196,
       propertyNames: keyType
     };
   }
-  return schema190;
+  return schema196;
 }
 var init_record = __esm(() => {
   init_v3();
@@ -35915,9 +36311,9 @@ function decideAdditionalProperties(def, refs) {
       return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
   }
 }
-function safeIsOptional(schema190) {
+function safeIsOptional(schema196) {
   try {
-    return schema190.isOptional();
+    return schema196.isOptional();
   } catch {
     return true;
   }
@@ -35986,18 +36382,18 @@ function parseSetDef(def, refs) {
     ...refs,
     currentPath: [...refs.currentPath, "items"]
   });
-  const schema190 = {
+  const schema196 = {
     type: "array",
     uniqueItems: true,
     items
   };
   if (def.minSize) {
-    setResponseValueAndErrors(schema190, "minItems", def.minSize.value, def.minSize.message, refs);
+    setResponseValueAndErrors(schema196, "minItems", def.minSize.value, def.minSize.message, refs);
   }
   if (def.maxSize) {
-    setResponseValueAndErrors(schema190, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+    setResponseValueAndErrors(schema196, "maxItems", def.maxSize.value, def.maxSize.message, refs);
   }
-  return schema190;
+  return schema196;
 }
 var init_set = __esm(() => {
   init_parseDef();
@@ -36230,17 +36626,17 @@ var init_parseDef = __esm(() => {
 var init_parseTypes = () => {};
 
 // node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
-var zodToJsonSchema = (schema190, options) => {
+var zodToJsonSchema = (schema196, options) => {
   const refs = getRefs(options);
-  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema191]) => ({
+  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema197]) => ({
     ...acc,
-    [name2]: parseDef(schema191._def, {
+    [name2]: parseDef(schema197._def, {
       ...refs,
       currentPath: [...refs.basePath, refs.definitionPath, name2]
     }, true) ?? parseAnyDef(refs)
   }), {}) : undefined;
   const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? undefined : options?.name;
-  const main = parseDef(schema190._def, name === undefined ? refs : {
+  const main = parseDef(schema196._def, name === undefined ? refs : {
     ...refs,
     currentPath: [...refs.basePath, refs.definitionPath, name]
   }, false) ?? parseAnyDef(refs);
@@ -36341,20 +36737,20 @@ function mapMiniTarget(t) {
     return "draft-2020-12";
   return "draft-7";
 }
-function toJsonSchemaCompat(schema190, opts) {
-  if (isZ4Schema(schema190)) {
-    return toJSONSchema(schema190, {
+function toJsonSchemaCompat(schema196, opts) {
+  if (isZ4Schema(schema196)) {
+    return toJSONSchema(schema196, {
       target: mapMiniTarget(opts?.target),
       io: opts?.pipeStrategy ?? "input"
     });
   }
-  return zodToJsonSchema(schema190, {
+  return zodToJsonSchema(schema196, {
     strictUnions: opts?.strictUnions ?? true,
     pipeStrategy: opts?.pipeStrategy ?? "input"
   });
 }
-function getMethodLiteral(schema190) {
-  const shape = getObjectShape(schema190);
+function getMethodLiteral(schema196) {
+  const shape = getObjectShape(schema196);
   const methodSchema = shape?.method;
   if (!methodSchema) {
     throw new Error("Schema is missing a method literal");
@@ -36365,8 +36761,8 @@ function getMethodLiteral(schema190) {
   }
   return value;
 }
-function parseWithCompat(schema190, data) {
-  const result = safeParse3(schema190, data);
+function parseWithCompat(schema196, data) {
+  const result = safeParse3(schema196, data);
   if (!result.success) {
     throw result.error;
   }
@@ -38246,52 +38642,52 @@ var require_util = __commonJS(function(exports) {
     return hash2;
   }
   exports.toHash = toHash;
-  function alwaysValidSchema(it, schema190) {
-    if (typeof schema190 == "boolean")
-      return schema190;
-    if (Object.keys(schema190).length === 0)
+  function alwaysValidSchema(it, schema196) {
+    if (typeof schema196 == "boolean")
+      return schema196;
+    if (Object.keys(schema196).length === 0)
       return true;
-    checkUnknownRules(it, schema190);
-    return !schemaHasRules(schema190, it.self.RULES.all);
+    checkUnknownRules(it, schema196);
+    return !schemaHasRules(schema196, it.self.RULES.all);
   }
   exports.alwaysValidSchema = alwaysValidSchema;
-  function checkUnknownRules(it, schema190 = it.schema) {
+  function checkUnknownRules(it, schema196 = it.schema) {
     const { opts, self } = it;
     if (!opts.strictSchema)
       return;
-    if (typeof schema190 === "boolean")
+    if (typeof schema196 === "boolean")
       return;
     const rules = self.RULES.keywords;
-    for (const key in schema190) {
+    for (const key in schema196) {
       if (!rules[key])
         checkStrictMode(it, `unknown keyword: "${key}"`);
     }
   }
   exports.checkUnknownRules = checkUnknownRules;
-  function schemaHasRules(schema190, rules) {
-    if (typeof schema190 == "boolean")
-      return !schema190;
-    for (const key in schema190)
+  function schemaHasRules(schema196, rules) {
+    if (typeof schema196 == "boolean")
+      return !schema196;
+    for (const key in schema196)
       if (rules[key])
         return true;
     return false;
   }
   exports.schemaHasRules = schemaHasRules;
-  function schemaHasRulesButRef(schema190, RULES) {
-    if (typeof schema190 == "boolean")
-      return !schema190;
-    for (const key in schema190)
+  function schemaHasRulesButRef(schema196, RULES) {
+    if (typeof schema196 == "boolean")
+      return !schema196;
+    for (const key in schema196)
       if (key !== "$ref" && RULES.all[key])
         return true;
     return false;
   }
   exports.schemaHasRulesButRef = schemaHasRulesButRef;
-  function schemaRefOrVal({ topSchemaRef, schemaPath }, schema190, keyword, $data) {
+  function schemaRefOrVal({ topSchemaRef, schemaPath }, schema196, keyword, $data) {
     if (!$data) {
-      if (typeof schema190 == "number" || typeof schema190 == "boolean")
-        return schema190;
-      if (typeof schema190 == "string")
-        return (0, codegen_1._)`${schema190}`;
+      if (typeof schema196 == "number" || typeof schema196 == "boolean")
+        return schema196;
+      if (typeof schema196 == "string")
+        return (0, codegen_1._)`${schema196}`;
     }
     return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
   }
@@ -38551,10 +38947,10 @@ var require_boolSchema = __commonJS(function(exports) {
     message: "boolean schema is false"
   };
   function topBoolOrEmptySchema(it) {
-    const { gen, schema: schema190, validateName } = it;
-    if (schema190 === false) {
+    const { gen, schema: schema196, validateName } = it;
+    if (schema196 === false) {
       falseSchemaError(it, false);
-    } else if (typeof schema190 == "object" && schema190.$async === true) {
+    } else if (typeof schema196 == "object" && schema196.$async === true) {
       gen.return(names_1.default.data);
     } else {
       gen.assign((0, codegen_1._)`${validateName}.errors`, null);
@@ -38563,8 +38959,8 @@ var require_boolSchema = __commonJS(function(exports) {
   }
   exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
   function boolOrEmptySchema(it, valid) {
-    const { gen, schema: schema190 } = it;
-    if (schema190 === false) {
+    const { gen, schema: schema196 } = it;
+    if (schema196 === false) {
       gen.var(valid, false);
       falseSchemaError(it);
     } else {
@@ -38620,18 +39016,18 @@ var require_rules = __commonJS(function(exports) {
 var require_applicability = __commonJS(function(exports) {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = undefined;
-  function schemaHasRulesForType({ schema: schema190, self }, type) {
+  function schemaHasRulesForType({ schema: schema196, self }, type) {
     const group = self.RULES.types[type];
-    return group && group !== true && shouldUseGroup(schema190, group);
+    return group && group !== true && shouldUseGroup(schema196, group);
   }
   exports.schemaHasRulesForType = schemaHasRulesForType;
-  function shouldUseGroup(schema190, group) {
-    return group.rules.some((rule) => shouldUseRule(schema190, rule));
+  function shouldUseGroup(schema196, group) {
+    return group.rules.some((rule) => shouldUseRule(schema196, rule));
   }
   exports.shouldUseGroup = shouldUseGroup;
-  function shouldUseRule(schema190, rule) {
+  function shouldUseRule(schema196, rule) {
     var _a2;
-    return schema190[rule.keyword] !== undefined || ((_a2 = rule.definition.implements) === null || _a2 === undefined ? undefined : _a2.some((kwd) => schema190[kwd] !== undefined));
+    return schema196[rule.keyword] !== undefined || ((_a2 = rule.definition.implements) === null || _a2 === undefined ? undefined : _a2.some((kwd) => schema196[kwd] !== undefined));
   }
   exports.shouldUseRule = shouldUseRule;
 });
@@ -38650,17 +39046,17 @@ var require_dataType = __commonJS(function(exports) {
     DataType2[DataType2["Correct"] = 0] = "Correct";
     DataType2[DataType2["Wrong"] = 1] = "Wrong";
   })(DataType || (exports.DataType = DataType = {}));
-  function getSchemaTypes(schema190) {
-    const types2 = getJSONTypes(schema190.type);
+  function getSchemaTypes(schema196) {
+    const types2 = getJSONTypes(schema196.type);
     const hasNull = types2.includes("null");
     if (hasNull) {
-      if (schema190.nullable === false)
+      if (schema196.nullable === false)
         throw new Error("type: null contradicts nullable: false");
     } else {
-      if (!types2.length && schema190.nullable !== undefined) {
+      if (!types2.length && schema196.nullable !== undefined) {
         throw new Error('"nullable" cannot be used without "type"');
       }
-      if (schema190.nullable === true)
+      if (schema196.nullable === true)
         types2.push("null");
     }
     return types2;
@@ -38792,8 +39188,8 @@ var require_dataType = __commonJS(function(exports) {
   }
   exports.checkDataTypes = checkDataTypes;
   var typeError = {
-    message: ({ schema: schema190 }) => `must be ${schema190}`,
-    params: ({ schema: schema190, schemaValue }) => typeof schema190 == "string" ? (0, codegen_1._)`{type: ${schema190}}` : (0, codegen_1._)`{type: ${schemaValue}}`
+    message: ({ schema: schema196 }) => `must be ${schema196}`,
+    params: ({ schema: schema196, schemaValue }) => typeof schema196 == "string" ? (0, codegen_1._)`{type: ${schema196}}` : (0, codegen_1._)`{type: ${schemaValue}}`
   };
   function reportTypeError(it) {
     const cxt = getTypeErrorContext(it);
@@ -38801,16 +39197,16 @@ var require_dataType = __commonJS(function(exports) {
   }
   exports.reportTypeError = reportTypeError;
   function getTypeErrorContext(it) {
-    const { gen, data, schema: schema190 } = it;
-    const schemaCode = (0, util_1.schemaRefOrVal)(it, schema190, "type");
+    const { gen, data, schema: schema196 } = it;
+    const schemaCode = (0, util_1.schemaRefOrVal)(it, schema196, "type");
     return {
       gen,
       keyword: "type",
       data,
-      schema: schema190.type,
+      schema: schema196.type,
       schemaCode,
       schemaValue: schemaCode,
-      parentSchema: schema190,
+      parentSchema: schema196,
       params: {},
       it
     };
@@ -38956,15 +39352,15 @@ var require_code2 = __commonJS(function(exports) {
   }
   exports.validateArray = validateArray;
   function validateUnion(cxt) {
-    const { gen, schema: schema190, keyword, it } = cxt;
-    if (!Array.isArray(schema190))
+    const { gen, schema: schema196, keyword, it } = cxt;
+    if (!Array.isArray(schema196))
       throw new Error("ajv implementation error");
-    const alwaysValid = schema190.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
+    const alwaysValid = schema196.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
     if (alwaysValid && !it.opts.unevaluated)
       return;
     const valid = gen.let("valid", false);
     const schValid = gen.name("_valid");
-    gen.block(() => schema190.forEach((_sch, i) => {
+    gen.block(() => schema196.forEach((_sch, i) => {
       const schCxt = cxt.subschema({
         keyword,
         schemaProp: i,
@@ -38989,8 +39385,8 @@ var require_keyword = __commonJS(function(exports) {
   var code_1 = require_code2();
   var errors_1 = require_errors();
   function macroKeywordCode(cxt, def) {
-    const { gen, keyword, schema: schema190, parentSchema, it } = cxt;
-    const macroSchema = def.macro.call(it.self, schema190, parentSchema, it);
+    const { gen, keyword, schema: schema196, parentSchema, it } = cxt;
+    const macroSchema = def.macro.call(it.self, schema196, parentSchema, it);
     const schemaRef = useKeyword(gen, keyword, macroSchema);
     if (it.opts.validateSchema !== false)
       it.self.validateSchema(macroSchema, true);
@@ -39007,9 +39403,9 @@ var require_keyword = __commonJS(function(exports) {
   exports.macroKeywordCode = macroKeywordCode;
   function funcKeywordCode(cxt, def) {
     var _a2;
-    const { gen, keyword, schema: schema190, parentSchema, $data, it } = cxt;
+    const { gen, keyword, schema: schema196, parentSchema, $data, it } = cxt;
     checkAsyncKeyword(it, def);
-    const validate = !$data && def.compile ? def.compile.call(it.self, schema190, parentSchema, it) : def.validate;
+    const validate = !$data && def.compile ? def.compile.call(it.self, schema196, parentSchema, it) : def.validate;
     const validateRef = useKeyword(gen, keyword, validate);
     const valid = gen.let("valid");
     cxt.block$data(valid, validateKeyword);
@@ -39069,20 +39465,20 @@ var require_keyword = __commonJS(function(exports) {
       throw new Error(`keyword "${keyword}" failed to compile`);
     return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1.stringify)(result) });
   }
-  function validSchemaType(schema190, schemaType, allowUndefined = false) {
-    return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema190) : st === "object" ? schema190 && typeof schema190 == "object" && !Array.isArray(schema190) : typeof schema190 == st || allowUndefined && typeof schema190 == "undefined");
+  function validSchemaType(schema196, schemaType, allowUndefined = false) {
+    return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema196) : st === "object" ? schema196 && typeof schema196 == "object" && !Array.isArray(schema196) : typeof schema196 == st || allowUndefined && typeof schema196 == "undefined");
   }
   exports.validSchemaType = validSchemaType;
-  function validateKeywordUsage({ schema: schema190, opts, self, errSchemaPath }, def, keyword) {
+  function validateKeywordUsage({ schema: schema196, opts, self, errSchemaPath }, def, keyword) {
     if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {
       throw new Error("ajv implementation error");
     }
     const deps = def.dependencies;
-    if (deps === null || deps === undefined ? undefined : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema190, kwd))) {
+    if (deps === null || deps === undefined ? undefined : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema196, kwd))) {
       throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
     }
     if (def.validateSchema) {
-      const valid = def.validateSchema(schema190[keyword]);
+      const valid = def.validateSchema(schema196[keyword]);
       if (!valid) {
         const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self.errorsText(def.validateSchema.errors);
         if (opts.validateSchema === "log")
@@ -39101,8 +39497,8 @@ var require_subschema = __commonJS(function(exports) {
   exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = undefined;
   var codegen_1 = require_codegen();
   var util_1 = require_util();
-  function getSubschema(it, { keyword, schemaProp, schema: schema190, schemaPath, errSchemaPath, topSchemaRef }) {
-    if (keyword !== undefined && schema190 !== undefined) {
+  function getSubschema(it, { keyword, schemaProp, schema: schema196, schemaPath, errSchemaPath, topSchemaRef }) {
+    if (keyword !== undefined && schema196 !== undefined) {
       throw new Error('both "keyword" and "schema" passed, only one allowed');
     }
     if (keyword !== undefined) {
@@ -39117,12 +39513,12 @@ var require_subschema = __commonJS(function(exports) {
         errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
       };
     }
-    if (schema190 !== undefined) {
+    if (schema196 !== undefined) {
       if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) {
         throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
       }
       return {
-        schema: schema190,
+        schema: schema196,
         schemaPath,
         topSchemaRef,
         errSchemaPath
@@ -39219,7 +39615,7 @@ var require_fast_deep_equal = __commonJS(function(exports, module) {
 
 // node_modules/json-schema-traverse/index.js
 var require_json_schema_traverse = __commonJS(function(exports, module) {
-  var traverse = module.exports = function(schema190, opts, cb) {
+  var traverse = module.exports = function(schema196, opts, cb) {
     if (typeof opts == "function") {
       cb = opts;
       opts = {};
@@ -39227,7 +39623,7 @@ var require_json_schema_traverse = __commonJS(function(exports, module) {
     cb = opts.cb || cb;
     var pre = typeof cb == "function" ? cb : cb.pre || function() {};
     var post = cb.post || function() {};
-    _traverse(opts, pre, post, schema190, "", schema190);
+    _traverse(opts, pre, post, schema196, "", schema196);
   };
   traverse.keywords = {
     additionalItems: true,
@@ -39273,26 +39669,26 @@ var require_json_schema_traverse = __commonJS(function(exports, module) {
     maxProperties: true,
     minProperties: true
   };
-  function _traverse(opts, pre, post, schema190, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
-    if (schema190 && typeof schema190 == "object" && !Array.isArray(schema190)) {
-      pre(schema190, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
-      for (var key in schema190) {
-        var sch = schema190[key];
+  function _traverse(opts, pre, post, schema196, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+    if (schema196 && typeof schema196 == "object" && !Array.isArray(schema196)) {
+      pre(schema196, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+      for (var key in schema196) {
+        var sch = schema196[key];
         if (Array.isArray(sch)) {
           if (key in traverse.arrayKeywords) {
             for (var i = 0;i < sch.length; i++)
-              _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema190, i);
+              _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema196, i);
           }
         } else if (key in traverse.propsKeywords) {
           if (sch && typeof sch == "object") {
             for (var prop in sch)
-              _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema190, prop);
+              _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema196, prop);
           }
         } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
-          _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema190);
+          _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema196);
         }
       }
-      post(schema190, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+      post(schema196, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
     }
   }
   function escapeJsonPtr(str3) {
@@ -39325,14 +39721,14 @@ var require_resolve = __commonJS(function(exports) {
     "enum",
     "const"
   ]);
-  function inlineRef(schema190, limit = true) {
-    if (typeof schema190 == "boolean")
+  function inlineRef(schema196, limit = true) {
+    if (typeof schema196 == "boolean")
       return true;
     if (limit === true)
-      return !hasRef(schema190);
+      return !hasRef(schema196);
     if (!limit)
       return false;
-    return countKeys(schema190) <= limit;
+    return countKeys(schema196) <= limit;
   }
   exports.inlineRef = inlineRef;
   var REF_KEYWORDS = new Set([
@@ -39342,11 +39738,11 @@ var require_resolve = __commonJS(function(exports) {
     "$dynamicRef",
     "$dynamicAnchor"
   ]);
-  function hasRef(schema190) {
-    for (const key in schema190) {
+  function hasRef(schema196) {
+    for (const key in schema196) {
       if (REF_KEYWORDS.has(key))
         return true;
-      const sch = schema190[key];
+      const sch = schema196[key];
       if (Array.isArray(sch) && sch.some(hasRef))
         return true;
       if (typeof sch == "object" && hasRef(sch))
@@ -39354,16 +39750,16 @@ var require_resolve = __commonJS(function(exports) {
     }
     return false;
   }
-  function countKeys(schema190) {
+  function countKeys(schema196) {
     let count = 0;
-    for (const key in schema190) {
+    for (const key in schema196) {
       if (key === "$ref")
         return Infinity;
       count++;
       if (SIMPLE_INLINED.has(key))
         continue;
-      if (typeof schema190[key] == "object") {
-        (0, util_1.eachItem)(schema190[key], (sch) => count += countKeys(sch));
+      if (typeof schema196[key] == "object") {
+        (0, util_1.eachItem)(schema196[key], (sch) => count += countKeys(sch));
       }
       if (count === Infinity)
         return Infinity;
@@ -39393,16 +39789,16 @@ var require_resolve = __commonJS(function(exports) {
   }
   exports.resolveUrl = resolveUrl;
   var ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
-  function getSchemaRefs(schema190, baseId) {
-    if (typeof schema190 == "boolean")
+  function getSchemaRefs(schema196, baseId) {
+    if (typeof schema196 == "boolean")
       return {};
     const { schemaId, uriResolver } = this.opts;
-    const schId = normalizeId(schema190[schemaId] || baseId);
+    const schId = normalizeId(schema196[schemaId] || baseId);
     const baseIds = { "": schId };
     const pathPrefix = getFullPath(uriResolver, schId, false);
     const localRefs = {};
     const schemaRefs = new Set;
-    traverse(schema190, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
+    traverse(schema196, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
       if (parentJsonPtr === undefined)
         return;
       const fullPath = pathPrefix + jsonPtr;
@@ -39480,15 +39876,15 @@ var require_validate = __commonJS(function(exports) {
     validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
   }
   exports.validateFunctionCode = validateFunctionCode;
-  function validateFunction({ gen, validateName, schema: schema190, schemaEnv, opts }, body) {
+  function validateFunction({ gen, validateName, schema: schema196, schemaEnv, opts }, body) {
     if (opts.code.es5) {
       gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
-        gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema190, opts)}`);
+        gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema196, opts)}`);
         destructureValCxtES5(gen, opts);
         gen.code(body);
       });
     } else {
-      gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema190, opts)).code(body));
+      gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema196, opts)).code(body));
     }
   }
   function destructureValCxt(opts) {
@@ -39512,9 +39908,9 @@ var require_validate = __commonJS(function(exports) {
     });
   }
   function topSchemaObjCode(it) {
-    const { schema: schema190, opts, gen } = it;
+    const { schema: schema196, opts, gen } = it;
     validateFunction(it, () => {
-      if (opts.$comment && schema190.$comment)
+      if (opts.$comment && schema196.$comment)
         commentKeyword(it);
       checkNoDefault(it);
       gen.let(names_1.default.vErrors, null);
@@ -39532,8 +39928,8 @@ var require_validate = __commonJS(function(exports) {
     gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`));
     gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`));
   }
-  function funcSourceUrl(schema190, opts) {
-    const schId = typeof schema190 == "object" && schema190[opts.schemaId];
+  function funcSourceUrl(schema196, opts) {
+    const schId = typeof schema196 == "object" && schema196[opts.schemaId];
     return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil;
   }
   function subschemaCode(it, valid) {
@@ -39546,10 +39942,10 @@ var require_validate = __commonJS(function(exports) {
     }
     (0, boolSchema_1.boolOrEmptySchema)(it, valid);
   }
-  function schemaCxtHasRules({ schema: schema190, self }) {
-    if (typeof schema190 == "boolean")
-      return !schema190;
-    for (const key in schema190)
+  function schemaCxtHasRules({ schema: schema196, self }) {
+    if (typeof schema196 == "boolean")
+      return !schema196;
+    for (const key in schema196)
       if (self.RULES.all[key])
         return true;
     return false;
@@ -39558,8 +39954,8 @@ var require_validate = __commonJS(function(exports) {
     return typeof it.schema != "boolean";
   }
   function subSchemaObjCode(it, valid) {
-    const { schema: schema190, gen, opts } = it;
-    if (opts.$comment && schema190.$comment)
+    const { schema: schema196, gen, opts } = it;
+    if (opts.$comment && schema196.$comment)
       commentKeyword(it);
     updateContext(it);
     checkAsyncSchema(it);
@@ -39579,14 +39975,14 @@ var require_validate = __commonJS(function(exports) {
     schemaKeywords(it, types2, !checkedTypes, errsCount);
   }
   function checkRefsAndKeywords(it) {
-    const { schema: schema190, errSchemaPath, opts, self } = it;
-    if (schema190.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema190, self.RULES)) {
+    const { schema: schema196, errSchemaPath, opts, self } = it;
+    if (schema196.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema196, self.RULES)) {
       self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
     }
   }
   function checkNoDefault(it) {
-    const { schema: schema190, opts } = it;
-    if (schema190.default !== undefined && opts.useDefaults && opts.strictSchema) {
+    const { schema: schema196, opts } = it;
+    if (schema196.default !== undefined && opts.useDefaults && opts.strictSchema) {
       (0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
     }
   }
@@ -39599,8 +39995,8 @@ var require_validate = __commonJS(function(exports) {
     if (it.schema.$async && !it.schemaEnv.$async)
       throw new Error("async schema in sync schema");
   }
-  function commentKeyword({ gen, schemaEnv, schema: schema190, errSchemaPath, opts }) {
-    const msg = schema190.$comment;
+  function commentKeyword({ gen, schemaEnv, schema: schema196, errSchemaPath, opts }) {
+    const msg = schema196.$comment;
     if (opts.$comment === true) {
       gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
     } else if (typeof opts.$comment == "function") {
@@ -39627,9 +40023,9 @@ var require_validate = __commonJS(function(exports) {
       gen.assign((0, codegen_1._)`${evaluated}.items`, items);
   }
   function schemaKeywords(it, types2, typeErrors, errsCount) {
-    const { gen, schema: schema190, data, allErrors, opts, self } = it;
+    const { gen, schema: schema196, data, allErrors, opts, self } = it;
     const { RULES } = self;
-    if (schema190.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema190, RULES))) {
+    if (schema196.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema196, RULES))) {
       gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
       return;
     }
@@ -39641,7 +40037,7 @@ var require_validate = __commonJS(function(exports) {
       groupKeywords(RULES.post);
     });
     function groupKeywords(group) {
-      if (!(0, applicability_1.shouldUseGroup)(schema190, group))
+      if (!(0, applicability_1.shouldUseGroup)(schema196, group))
         return;
       if (group.type) {
         gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
@@ -39659,12 +40055,12 @@ var require_validate = __commonJS(function(exports) {
     }
   }
   function iterateKeywords(it, group) {
-    const { gen, schema: schema190, opts: { useDefaults } } = it;
+    const { gen, schema: schema196, opts: { useDefaults } } = it;
     if (useDefaults)
       (0, defaults_1.assignDefaults)(it, group.type);
     gen.block(() => {
       for (const rule of group.rules) {
-        if ((0, applicability_1.shouldUseRule)(schema190, rule)) {
+        if ((0, applicability_1.shouldUseRule)(schema196, rule)) {
           keywordCode(it, rule.keyword, rule.definition, group.type);
         }
       }
@@ -40003,17 +40399,17 @@ var require_compile = __commonJS(function(exports) {
       var _a2;
       this.refs = {};
       this.dynamicAnchors = {};
-      let schema190;
+      let schema196;
       if (typeof env.schema == "object")
-        schema190 = env.schema;
+        schema196 = env.schema;
       this.schema = env.schema;
       this.schemaId = env.schemaId;
       this.root = env.root || this;
-      this.baseId = (_a2 = env.baseId) !== null && _a2 !== undefined ? _a2 : (0, resolve_1.normalizeId)(schema190 === null || schema190 === undefined ? undefined : schema190[env.schemaId || "$id"]);
+      this.baseId = (_a2 = env.baseId) !== null && _a2 !== undefined ? _a2 : (0, resolve_1.normalizeId)(schema196 === null || schema196 === undefined ? undefined : schema196[env.schemaId || "$id"]);
       this.schemaPath = env.schemaPath;
       this.localRefs = env.localRefs;
       this.meta = env.meta;
-      this.$async = schema190 === null || schema190 === undefined ? undefined : schema190.$async;
+      this.$async = schema196 === null || schema196 === undefined ? undefined : schema196.$async;
       this.refs = {};
     }
   }
@@ -40111,10 +40507,10 @@ var require_compile = __commonJS(function(exports) {
       return schOrFunc;
     let _sch = resolve.call(this, root, ref);
     if (_sch === undefined) {
-      const schema190 = (_a2 = root.localRefs) === null || _a2 === undefined ? undefined : _a2[ref];
+      const schema196 = (_a2 = root.localRefs) === null || _a2 === undefined ? undefined : _a2[ref];
       const { schemaId } = this.opts;
-      if (schema190)
-        _sch = new SchemaEnv({ schema: schema190, schemaId, root, baseId });
+      if (schema196)
+        _sch = new SchemaEnv({ schema: schema196, schemaId, root, baseId });
     }
     if (_sch === undefined)
       return;
@@ -40162,12 +40558,12 @@ var require_compile = __commonJS(function(exports) {
     if (!schOrRef.validate)
       compileSchema.call(this, schOrRef);
     if (id === (0, resolve_1.normalizeId)(ref)) {
-      const { schema: schema190 } = schOrRef;
+      const { schema: schema196 } = schOrRef;
       const { schemaId } = this.opts;
-      const schId = schema190[schemaId];
+      const schId = schema196[schemaId];
       if (schId)
         baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
-      return new SchemaEnv({ schema: schema190, schemaId, root, baseId });
+      return new SchemaEnv({ schema: schema196, schemaId, root, baseId });
     }
     return getJsonPointer.call(this, p, schOrRef);
   }
@@ -40179,29 +40575,29 @@ var require_compile = __commonJS(function(exports) {
     "dependencies",
     "definitions"
   ]);
-  function getJsonPointer(parsedRef, { baseId, schema: schema190, root }) {
+  function getJsonPointer(parsedRef, { baseId, schema: schema196, root }) {
     var _a2;
     if (((_a2 = parsedRef.fragment) === null || _a2 === undefined ? undefined : _a2[0]) !== "/")
       return;
     for (const part of parsedRef.fragment.slice(1).split("/")) {
-      if (typeof schema190 === "boolean")
+      if (typeof schema196 === "boolean")
         return;
-      const partSchema = schema190[(0, util_1.unescapeFragment)(part)];
+      const partSchema = schema196[(0, util_1.unescapeFragment)(part)];
       if (partSchema === undefined)
         return;
-      schema190 = partSchema;
-      const schId = typeof schema190 === "object" && schema190[this.opts.schemaId];
+      schema196 = partSchema;
+      const schId = typeof schema196 === "object" && schema196[this.opts.schemaId];
       if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
         baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
       }
     }
     let env;
-    if (typeof schema190 != "boolean" && schema190.$ref && !(0, util_1.schemaHasRulesButRef)(schema190, this.RULES)) {
-      const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema190.$ref);
+    if (typeof schema196 != "boolean" && schema196.$ref && !(0, util_1.schemaHasRulesButRef)(schema196, this.RULES)) {
+      const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema196.$ref);
       env = resolveSchema.call(this, root, $ref);
     }
     const { schemaId } = this.opts;
-    env = env || new SchemaEnv({ schema: schema190, schemaId, root, baseId });
+    env = env || new SchemaEnv({ schema: schema196, schemaId, root, baseId });
     if (env.schema !== env.root.schema)
       return env;
     return;
@@ -40229,9 +40625,28 @@ var require_data = __commonJS(function(exports, module) {
 var require_utils = __commonJS(function(exports, module) {
   var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
   var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+  var isPort = RegExp.prototype.test.bind(/^\d*$/u);
   var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
   var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
-  var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+  var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+  var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+  var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+  var BYTE_HEX = new Array(256);
+  {
+    const HEX_DIGITS = "0123456789ABCDEF";
+    for (let i = 0;i < 256; i++) {
+      BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+    }
+  }
+  function percentEncodeNonAscii(cp) {
+    if (cp < 2048) {
+      return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+    }
+    if (cp < 65536) {
+      return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+    }
+    return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+  }
   function stringArrayToHexStripped(input) {
     let acc = "";
     let code = 0;
@@ -40256,91 +40671,122 @@ var require_utils = __commonJS(function(exports, module) {
     }
     return acc;
   }
+  var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+  var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+  var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
   var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-  function consumeIsZone(buffer) {
-    buffer.length = 0;
-    return true;
-  }
-  function consumeHextets(buffer, address, output) {
-    if (buffer.length) {
-      const hex3 = stringArrayToHexStripped(buffer);
-      if (hex3 !== "") {
-        address.push(hex3);
-      } else {
-        output.error = true;
-        return false;
+  function isZoneIdentifier(zone) {
+    if (zone.length === 0)
+      return false;
+    for (let i = 0;i < zone.length; i++) {
+      if (isZoneCharacter(zone[i]))
+        continue;
+      if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+        i += 2;
+        continue;
       }
-      buffer.length = 0;
+      return false;
     }
     return true;
   }
-  function getIPV6(input) {
-    let tokenCount = 0;
-    const output = { error: false, address: "", zone: "" };
-    const address = [];
-    const buffer = [];
-    let endipv6Encountered = false;
-    let endIpv6 = false;
-    let consume = consumeHextets;
-    for (let i = 0;i < input.length; i++) {
-      const cursor = input[i];
-      if (cursor === "[" || cursor === "]") {
-        continue;
-      }
-      if (cursor === ":") {
-        if (endipv6Encountered === true) {
-          endIpv6 = true;
-        }
-        if (!consume(buffer, address, output)) {
-          break;
-        }
-        if (++tokenCount > 7) {
-          output.error = true;
-          break;
-        }
-        if (i > 0 && input[i - 1] === ":") {
-          endipv6Encountered = true;
+  function compressIPv6ZeroRun(hextets) {
+    let bestStart = -1;
+    let bestLength = 0;
+    let runStart = -1;
+    let runLength = 0;
+    for (let i = 0;i < hextets.length; i++) {
+      if (hextets[i] === "0") {
+        if (runStart === -1)
+          runStart = i;
+        runLength++;
+        if (runLength > bestLength) {
+          bestLength = runLength;
+          bestStart = runStart;
         }
-        address.push(":");
-        continue;
-      } else if (cursor === "%") {
-        if (!consume(buffer, address, output)) {
-          break;
-        }
-        consume = consumeIsZone;
       } else {
-        buffer.push(cursor);
-        continue;
+        runStart = -1;
+        runLength = 0;
       }
     }
-    if (buffer.length) {
-      if (consume === consumeIsZone) {
-        output.zone = buffer.join("");
-      } else if (endIpv6) {
-        address.push(buffer.join(""));
-      } else {
-        address.push(stringArrayToHexStripped(buffer));
+    if (bestLength < 2)
+      return hextets.join(":");
+    const head = hextets.slice(0, bestStart).join(":");
+    const tail = hextets.slice(bestStart + bestLength).join(":");
+    return head + "::" + tail;
+  }
+  function normalizeIPv6Address(input) {
+    const compression = input.indexOf("::");
+    if (compression !== -1 && input.indexOf("::", compression + 1) !== -1)
+      return;
+    const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+    const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+    if (compression !== -1) {
+      if (left.length === 1 && left[0] === "")
+        left.length = 0;
+      if (right.length === 1 && right[0] === "")
+        right.length = 0;
+    }
+    const parts = left.concat(right);
+    let hextetCount = 0;
+    for (let i = 0;i < parts.length; i++) {
+      const part = parts[i];
+      if (part === "")
+        return;
+      if (part.indexOf(".") !== -1) {
+        if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part))
+          return;
+        hextetCount += 2;
+        continue;
       }
+      if (!isHextet(part))
+        return;
+      parts[i] = parseInt(part, 16).toString(16);
+      hextetCount++;
     }
-    output.address = address.join("");
-    return output;
+    if (compression === -1) {
+      if (hextetCount !== 8)
+        return;
+      return compressIPv6ZeroRun(parts);
+    }
+    if (hextetCount >= 8)
+      return;
+    const expanded = parts.slice(0, left.length);
+    for (let i = hextetCount;i < 8; i++)
+      expanded.push("0");
+    for (let i = left.length;i < parts.length; i++)
+      expanded.push(parts[i]);
+    return compressIPv6ZeroRun(expanded);
   }
   function normalizeIPv6(host) {
-    if (findToken(host, ":") < 2) {
-      return { host, isIPV6: false };
-    }
-    const ipv63 = getIPV6(host);
-    if (!ipv63.error) {
-      let newHost = ipv63.address;
-      let escapedHost = ipv63.address;
-      if (ipv63.zone) {
-        newHost += "%" + ipv63.zone;
-        escapedHost += "%25" + ipv63.zone;
-      }
-      return { host: newHost, isIPV6: true, escapedHost };
-    } else {
-      return { host, isIPV6: false };
-    }
+    const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+    const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+    if (hasBracket && !bracketed)
+      return { host, isIPV6: false, error: true };
+    let input = bracketed ? host.slice(1, -1) : host;
+    if (bracketed && isIPvFuture(input)) {
+      input = input.toLowerCase();
+      return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+    }
+    if (findToken(input, ":") < 2) {
+      return { host, isIPV6: false, error: bracketed };
+    }
+    let zoneIdentifier = "";
+    const zoneSeparator = input.indexOf("%");
+    if (zoneSeparator !== -1) {
+      const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+      zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+      if (!isZoneIdentifier(zoneIdentifier))
+        return { host, isIPV6: false, error: true };
+      input = input.slice(0, zoneSeparator);
+    }
+    const address = normalizeIPv6Address(input);
+    if (address === undefined)
+      return { host, isIPV6: false, error: true };
+    return {
+      host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+      escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+      isIPV6: true
+    };
   }
   function findToken(str3, token) {
     let ind = 0;
@@ -40460,7 +40906,8 @@ var require_utils = __commonJS(function(exports, module) {
   function normalizePathEncoding(input) {
     let output = "";
     for (let i = 0;i < input.length; i++) {
-      if (input[i] === "%" && i + 2 < input.length) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
         const hex3 = input.slice(i + 1, i + 3);
         if (isHexPair(hex3)) {
           const normalizedHex = hex3.toUpperCase();
@@ -40474,10 +40921,152 @@ var require_utils = __commonJS(function(exports, module) {
           continue;
         }
       }
-      if (isPathCharacter(input[i])) {
-        output += input[i];
+      if (isPathCharacter(ch)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function serializePathEncoding(input, pathNoScheme = false) {
+    let output = "";
+    let firstSegment = pathNoScheme && input[0] !== "/";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex3 = input.slice(i + 1, i + 3);
+        if (isHexPair(hex3)) {
+          output += "%" + hex3.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (ch === "/") {
+        firstSegment = false;
+      }
+      if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function encodeComponent(input, isAllowed) {
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex3 = input.slice(i + 1, i + 3);
+        if (isHexPair(hex3)) {
+          output += "%" + hex3.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (isAllowed(ch)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function encodeUserinfo(input) {
+    return encodeComponent(input, isUserinfoCharacter);
+  }
+  function encodeQuery(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
+  function encodeFragment(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
+  function isEscapeSafe(cp) {
+    return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+  }
+  function normalizeQueryFragmentEncoding(input) {
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex3 = input.slice(i + 1, i + 3);
+        if (isHexPair(hex3)) {
+          const normalizedHex = hex3.toUpperCase();
+          const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+          if (isUnreserved(decoded)) {
+            output += decoded;
+          } else {
+            output += "%" + normalizedHex;
+          }
+          i += 2;
+          continue;
+        }
+      }
+      if (isQueryFragmentCharacter(ch)) {
+        output += ch;
       } else {
-        output += escape(input[i]);
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
       }
     }
     return output;
@@ -40500,14 +41089,18 @@ var require_utils = __commonJS(function(exports, module) {
   function recomposeAuthority(component) {
     const uriTokens = [];
     if (component.userinfo !== undefined) {
-      uriTokens.push(component.userinfo);
+      uriTokens.push(encodeUserinfo(component.userinfo));
       uriTokens.push("@");
     }
     if (component.host !== undefined) {
-      let host = unescape(component.host);
+      let host = component.host;
       if (!isIPv4(host)) {
-        const ipV6res = normalizeIPv6(host);
-        if (ipV6res.isIPV6 === true) {
+        let ipV6res = normalizeIPv6(host);
+        if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+          host = normalizePercentEncoding(host, true);
+          ipV6res = normalizeIPv6(host);
+        }
+        if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
           host = `[${ipV6res.escapedHost}]`;
         } else {
           host = reescapeHostDelimiters(host, false);
@@ -40516,8 +41109,12 @@ var require_utils = __commonJS(function(exports, module) {
       uriTokens.push(host);
     }
     if (typeof component.port === "number" || typeof component.port === "string") {
+      const port = String(component.port);
+      if (!isPort(port)) {
+        throw new TypeError("URI port is malformed.");
+      }
       uriTokens.push(":");
-      uriTokens.push(String(component.port));
+      uriTokens.push(port);
     }
     return uriTokens.length ? uriTokens.join("") : undefined;
   }
@@ -40527,6 +41124,11 @@ var require_utils = __commonJS(function(exports, module) {
     reescapeHostDelimiters,
     normalizePercentEncoding,
     normalizePathEncoding,
+    serializePathEncoding,
+    normalizeQueryFragmentEncoding,
+    encodeUserinfo,
+    encodeQuery,
+    encodeFragment,
     escapePreservingEscapes,
     removeDotSegments,
     isIPv4,
@@ -40539,7 +41141,7 @@ var require_utils = __commonJS(function(exports, module) {
 // node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS(function(exports, module) {
   var { isUUID } = require_utils();
-  var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+  var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
   var supportedSchemeNames = [
     "http",
     "https",
@@ -40594,9 +41196,10 @@ var require_schemes = __commonJS(function(exports, module) {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path, query] = wsComponent.resourceName.split("?");
+      const queryIndex = wsComponent.resourceName.indexOf("?");
+      const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
       wsComponent.path = path && path !== "/" ? path : undefined;
-      wsComponent.query = query;
+      wsComponent.query = queryIndex === -1 ? undefined : wsComponent.resourceName.slice(queryIndex + 1);
       wsComponent.resourceName = undefined;
     }
     wsComponent.fragment = undefined;
@@ -40608,7 +41211,7 @@ var require_schemes = __commonJS(function(exports, module) {
       return urnComponent;
     }
     const matches = urnComponent.path.match(URN_REG);
-    if (matches) {
+    if (matches && matches[0] === urnComponent.path) {
       const scheme = options.scheme || urnComponent.scheme || "urn";
       urnComponent.nid = matches[1].toLowerCase();
       urnComponent.nss = matches[2];
@@ -40712,8 +41315,17 @@ var require_schemes = __commonJS(function(exports, module) {
 
 // node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS(function(exports, module) {
-  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
   var { SCHEMES, getSchemeHandler } = require_schemes();
+  var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+  var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+  function decodeValidScheme(scheme) {
+    const decodedScheme = unescape(String(scheme));
+    if (!VALID_SCHEME.test(decodedScheme)) {
+      throw new TypeError(MALFORMED_SCHEME_ERROR);
+    }
+    return decodedScheme;
+  }
   function normalize(uri, options) {
     if (typeof uri === "string") {
       uri = normalizeString(uri, options);
@@ -40724,12 +41336,34 @@ var require_fast_uri = __commonJS(function(exports, module) {
   }
   function resolve(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-    const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
-    const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
-    if (baseMalformed || relativeMalformed) {
+    const {
+      parsed: baseParsed,
+      malformedAuthorityOrPort: baseMalformed,
+      malformedPercentEncoding: baseMalformedPercentEncoding,
+      malformedSchemeSpecific: baseMalformedSchemeSpecific,
+      malformedHost: baseMalformedHost,
+      malformedScheme: baseMalformedScheme
+    } = parseWithStatus(baseURI, schemelessOptions);
+    const {
+      parsed: relativeParsed,
+      malformedAuthorityOrPort: relativeMalformed,
+      malformedPercentEncoding: relativeMalformedPercentEncoding,
+      malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+      malformedHost: relativeMalformedHost,
+      malformedScheme: relativeMalformedScheme
+    } = parseWithStatus(relativeURI, schemelessOptions);
+    if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
       throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
     }
     const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+    const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+    const resolvedHost = resolved.host;
+    const resolvedHostIsIP = resolvedHost !== undefined && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+    canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+    const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
+    if (resolved.error && !encodedASCIIHost) {
+      throw new Error(resolved.error);
+    }
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
@@ -40789,7 +41423,7 @@ var require_fast_uri = __commonJS(function(exports, module) {
   function equal(uriA, uriB, options) {
     const normalizedA = normalizeComparableURI(uriA, options);
     const normalizedB = normalizeComparableURI(uriB, options);
-    return normalizedA !== undefined && normalizedB !== undefined && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+    return normalizedA !== undefined && normalizedB !== undefined && normalizedA === normalizedB;
   }
   function serialize(cmpts, opts) {
     const component = {
@@ -40810,20 +41444,23 @@ var require_fast_uri = __commonJS(function(exports, module) {
     };
     const options = Object.assign({}, opts);
     const uriTokens = [];
+    if (component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
+    }
     const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
     if (schemeHandler && schemeHandler.serialize)
       schemeHandler.serialize(component, options);
+    const hasAuthority = component.userinfo !== undefined || component.host !== undefined || component.port !== undefined;
+    const pathNoScheme = !options.skipEscape && component.scheme === undefined && !hasAuthority;
     if (component.path !== undefined) {
       if (!options.skipEscape) {
-        component.path = escapePreservingEscapes(component.path);
-        if (component.scheme !== undefined) {
-          component.path = component.path.split("%3A").join(":");
-        }
+        component.path = serializePathEncoding(component.path, pathNoScheme);
       } else {
         component.path = normalizePercentEncoding(component.path);
       }
     }
     if (options.reference !== "suffix" && component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
       uriTokens.push(component.scheme, ":");
     }
     const authority = recomposeAuthority(component);
@@ -40841,16 +41478,19 @@ var require_fast_uri = __commonJS(function(exports, module) {
       if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
         s = removeDotSegments(s);
       }
+      if (pathNoScheme) {
+        s = serializePathEncoding(s, true);
+      }
       if (authority === undefined && s[0] === "/" && s[1] === "/") {
         s = "/%2F" + s.slice(2);
       }
       uriTokens.push(s);
     }
     if (component.query !== undefined) {
-      uriTokens.push("?", component.query);
+      uriTokens.push("?", encodeQuery(component.query));
     }
     if (component.fragment !== undefined) {
-      uriTokens.push("#", component.fragment);
+      uriTokens.push("#", encodeFragment(component.fragment));
     }
     return uriTokens.join("");
   }
@@ -40866,6 +41506,36 @@ var require_fast_uri = __commonJS(function(exports, module) {
     }
     return;
   }
+  function hasMalformedPercentEncoding(component) {
+    if (component === undefined)
+      return false;
+    let percent = component.indexOf("%");
+    while (percent !== -1) {
+      if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+        return true;
+      }
+      percent = component.indexOf("%", percent + 3);
+    }
+    return false;
+  }
+  function isIPLiteral(host) {
+    return host[0] === "[" && host[host.length - 1] === "]";
+  }
+  function hasMalformedComponentPercentEncoding(matches) {
+    const host = matches[4];
+    return hasMalformedPercentEncoding(matches[3]) || host !== undefined && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+  }
+  function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+    if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+      try {
+        parsed.host = new URL("http://" + parsed.host).hostname;
+      } catch (e) {
+        parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+        return true;
+      }
+    }
+    return false;
+  }
   function parseWithStatus(uri, opts) {
     const options = Object.assign({}, opts);
     const parsed = {
@@ -40878,6 +41548,11 @@ var require_fast_uri = __commonJS(function(exports, module) {
       fragment: undefined
     };
     let malformedAuthorityOrPort = false;
+    let malformedPercentEncoding = false;
+    let malformedSchemeSpecific = false;
+    let malformedHost = false;
+    let malformedIPLiteral = false;
+    let malformedScheme = false;
     let isIP = false;
     if (options.reference === "suffix") {
       if (options.scheme) {
@@ -40914,6 +41589,19 @@ var require_fast_uri = __commonJS(function(exports, module) {
       parsed.path = matches[6] || "";
       parsed.query = matches[7];
       parsed.fragment = matches[8];
+      if (parsed.scheme !== undefined) {
+        const decodedScheme = unescape(parsed.scheme);
+        if (VALID_SCHEME.test(decodedScheme)) {
+          parsed.scheme = decodedScheme.toLowerCase();
+        } else {
+          parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+          malformedScheme = true;
+        }
+      }
+      malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+      if (malformedPercentEncoding) {
+        parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+      }
       if (isNaN(parsed.port)) {
         parsed.port = matches[5];
       }
@@ -40925,9 +41613,16 @@ var require_fast_uri = __commonJS(function(exports, module) {
       if (parsed.host) {
         const ipv4result = isIPv4(parsed.host);
         if (ipv4result === false) {
+          const bracketedIPLiteral = isIPLiteral(parsed.host);
+          const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
           const ipv6result = normalizeIPv6(parsed.host);
-          parsed.host = ipv6result.host.toLowerCase();
-          isIP = ipv6result.isIPV6;
+          isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+          malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+          parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+          if (malformedIPLiteral) {
+            parsed.error = parsed.error || "URI host is malformed.";
+            malformedAuthorityOrPort = true;
+          }
         } else {
           isIP = true;
         }
@@ -40945,42 +41640,36 @@ var require_fast_uri = __commonJS(function(exports, module) {
         parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
       }
       const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-        if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-          try {
-            parsed.host = new URL("http://" + parsed.host).hostname;
-          } catch (e) {
-            parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-          }
-        }
+      if (!malformedIPLiteral) {
+        malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
       }
       if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
         if (uri.indexOf("%") !== -1) {
-          if (parsed.scheme !== undefined) {
-            parsed.scheme = unescape(parsed.scheme);
-          }
-          if (parsed.host !== undefined) {
-            parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
+          if (parsed.host !== undefined && !malformedIPLiteral) {
+            const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+            parsed.host = reescapeHostDelimiters(host, isIP);
           }
         }
         if (parsed.path) {
           parsed.path = normalizePathEncoding(parsed.path);
         }
+        if (parsed.query) {
+          parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+        }
         if (parsed.fragment) {
-          try {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-          } catch {
-            parsed.error = parsed.error || "URI malformed";
-          }
+          parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
         }
       }
       if (schemeHandler && schemeHandler.parse) {
         schemeHandler.parse(parsed, options);
+        if (schemeHandler === SCHEMES.urn && parsed.nid === undefined) {
+          malformedSchemeSpecific = true;
+        }
       }
     } else {
       parsed.error = parsed.error || "URI can not be parsed.";
     }
-    return { parsed, malformedAuthorityOrPort };
+    return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
   }
   function parse10(uri, opts) {
     return parseWithStatus(uri, opts).parsed;
@@ -40989,20 +41678,28 @@ var require_fast_uri = __commonJS(function(exports, module) {
     return normalizeStringWithStatus(uri, opts).normalized;
   }
   function normalizeStringWithStatus(uri, opts) {
-    const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+    const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
     return {
-      normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-      malformedAuthorityOrPort
+      normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+      malformedAuthorityOrPort,
+      malformedPercentEncoding,
+      malformedSchemeSpecific,
+      malformedHost,
+      malformedScheme
     };
   }
   function normalizeComparableURI(uri, opts) {
-    if (typeof uri === "string") {
-      const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-      return malformedAuthorityOrPort ? undefined : normalized;
+    if (typeof uri !== "string" && typeof uri !== "object") {
+      return;
     }
-    if (typeof uri === "object") {
-      return serialize(uri, opts);
+    let value;
+    try {
+      value = typeof uri === "string" ? uri : serialize(uri, opts);
+    } catch {
+      return;
     }
+    const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+    return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? undefined : normalized;
   }
   var fastUri = {
     SCHEMES,
@@ -41166,19 +41863,19 @@ var require_core = __commonJS(function(exports) {
       this.addKeyword("$async");
     }
     _addDefaultMetaSchema() {
-      const { $data, meta: meta189, schemaId } = this.opts;
+      const { $data, meta: meta195, schemaId } = this.opts;
       let _dataRefSchema = $dataRefSchema;
       if (schemaId === "id") {
         _dataRefSchema = { ...$dataRefSchema };
         _dataRefSchema.id = _dataRefSchema.$id;
         delete _dataRefSchema.$id;
       }
-      if (meta189 && $data)
+      if (meta195 && $data)
         this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
     }
     defaultMeta() {
-      const { meta: meta189, schemaId } = this.opts;
-      return this.opts.defaultMeta = typeof meta189 == "object" ? meta189[schemaId] || meta189 : undefined;
+      const { meta: meta195, schemaId } = this.opts;
+      return this.opts.defaultMeta = typeof meta195 == "object" ? meta195[schemaId] || meta195 : undefined;
     }
     validate(schemaKeyRef, data) {
       let v;
@@ -41194,16 +41891,16 @@ var require_core = __commonJS(function(exports) {
         this.errors = v.errors;
       return valid;
     }
-    compile(schema190, _meta) {
-      const sch = this._addSchema(schema190, _meta);
+    compile(schema196, _meta) {
+      const sch = this._addSchema(schema196, _meta);
       return sch.validate || this._compileSchemaEnv(sch);
     }
-    compileAsync(schema190, meta189) {
+    compileAsync(schema196, meta195) {
       if (typeof this.opts.loadSchema != "function") {
         throw new Error("options.loadSchema should be a function");
       }
       const { loadSchema } = this.opts;
-      return runCompileAsync.call(this, schema190, meta189);
+      return runCompileAsync.call(this, schema196, meta195);
       async function runCompileAsync(_schema, _meta) {
         await loadMetaSchema.call(this, _schema.$schema);
         const sch = this._addSchema(_schema, _meta);
@@ -41235,7 +41932,7 @@ var require_core = __commonJS(function(exports) {
         if (!this.refs[ref])
           await loadMetaSchema.call(this, _schema.$schema);
         if (!this.refs[ref])
-          this.addSchema(_schema, ref, meta189);
+          this.addSchema(_schema, ref, meta195);
       }
       async function _loadSchema(ref) {
         const p = this._loading[ref];
@@ -41248,34 +41945,34 @@ var require_core = __commonJS(function(exports) {
         }
       }
     }
-    addSchema(schema190, key, _meta, _validateSchema = this.opts.validateSchema) {
-      if (Array.isArray(schema190)) {
-        for (const sch of schema190)
+    addSchema(schema196, key, _meta, _validateSchema = this.opts.validateSchema) {
+      if (Array.isArray(schema196)) {
+        for (const sch of schema196)
           this.addSchema(sch, undefined, _meta, _validateSchema);
         return this;
       }
       let id;
-      if (typeof schema190 === "object") {
+      if (typeof schema196 === "object") {
         const { schemaId } = this.opts;
-        id = schema190[schemaId];
+        id = schema196[schemaId];
         if (id !== undefined && typeof id != "string") {
           throw new Error(`schema ${schemaId} must be string`);
         }
       }
       key = (0, resolve_1.normalizeId)(key || id);
       this._checkUnique(key);
-      this.schemas[key] = this._addSchema(schema190, _meta, key, _validateSchema, true);
+      this.schemas[key] = this._addSchema(schema196, _meta, key, _validateSchema, true);
       return this;
     }
-    addMetaSchema(schema190, key, _validateSchema = this.opts.validateSchema) {
-      this.addSchema(schema190, key, true, _validateSchema);
+    addMetaSchema(schema196, key, _validateSchema = this.opts.validateSchema) {
+      this.addSchema(schema196, key, true, _validateSchema);
       return this;
     }
-    validateSchema(schema190, throwOrLogError) {
-      if (typeof schema190 == "boolean")
+    validateSchema(schema196, throwOrLogError) {
+      if (typeof schema196 == "boolean")
         return true;
       let $schema;
-      $schema = schema190.$schema;
+      $schema = schema196.$schema;
       if ($schema !== undefined && typeof $schema != "string") {
         throw new Error("$schema must be a string");
       }
@@ -41285,7 +41982,7 @@ var require_core = __commonJS(function(exports) {
         this.errors = null;
         return true;
       }
-      const valid = this.validate($schema, schema190);
+      const valid = this.validate($schema, schema196);
       if (!valid && throwOrLogError) {
         const message = "schema is invalid: " + this.errorsText();
         if (this.opts.validateSchema === "log")
@@ -41419,9 +42116,9 @@ var require_core = __commonJS(function(exports) {
           if (typeof rule != "object")
             continue;
           const { $data } = rule.definition;
-          const schema190 = keywords[key];
-          if ($data && schema190)
-            keywords[key] = schemaOrData(schema190);
+          const schema196 = keywords[key];
+          if ($data && schema196)
+            keywords[key] = schemaOrData(schema196);
         }
       }
       return metaSchema;
@@ -41439,23 +42136,23 @@ var require_core = __commonJS(function(exports) {
         }
       }
     }
-    _addSchema(schema190, meta189, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
+    _addSchema(schema196, meta195, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
       let id;
       const { schemaId } = this.opts;
-      if (typeof schema190 == "object") {
-        id = schema190[schemaId];
+      if (typeof schema196 == "object") {
+        id = schema196[schemaId];
       } else {
         if (this.opts.jtd)
           throw new Error("schema must be object");
-        else if (typeof schema190 != "boolean")
+        else if (typeof schema196 != "boolean")
           throw new Error("schema must be object or boolean");
       }
-      let sch = this._cache.get(schema190);
+      let sch = this._cache.get(schema196);
       if (sch !== undefined)
         return sch;
       baseId = (0, resolve_1.normalizeId)(id || baseId);
-      const localRefs = resolve_1.getSchemaRefs.call(this, schema190, baseId);
-      sch = new compile_1.SchemaEnv({ schema: schema190, schemaId, meta: meta189, baseId, localRefs });
+      const localRefs = resolve_1.getSchemaRefs.call(this, schema196, baseId);
+      sch = new compile_1.SchemaEnv({ schema: schema196, schemaId, meta: meta195, baseId, localRefs });
       this._cache.set(sch.schema, sch);
       if (addSchema && !baseId.startsWith("#")) {
         if (baseId)
@@ -41463,7 +42160,7 @@ var require_core = __commonJS(function(exports) {
         this.refs[baseId] = sch;
       }
       if (validateSchema)
-        this.validateSchema(schema190, true);
+        this.validateSchema(schema196, true);
       return sch;
     }
     _checkUnique(id) {
@@ -41614,8 +42311,8 @@ var require_core = __commonJS(function(exports) {
   var $dataRef = {
     $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"
   };
-  function schemaOrData(schema190) {
-    return { anyOf: [schema190, $dataRef] };
+  function schemaOrData(schema196) {
+    return { anyOf: [schema196, $dataRef] };
   }
 });
 
@@ -41891,7 +42588,7 @@ var require_pattern = __commonJS(function(exports) {
     $data: true,
     error: error48,
     code(cxt) {
-      const { gen, data, $data, schema: schema190, schemaCode, it } = cxt;
+      const { gen, data, $data, schema: schema196, schemaCode, it } = cxt;
       const u = it.opts.unicodeRegExp ? "u" : "";
       if ($data) {
         const { regExp } = it.opts.code;
@@ -41900,7 +42597,7 @@ var require_pattern = __commonJS(function(exports) {
         gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
         cxt.fail$data((0, codegen_1._)`!${valid}`);
       } else {
-        const regExp = (0, code_1.usePattern)(cxt, schema190);
+        const regExp = (0, code_1.usePattern)(cxt, schema196);
         cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
       }
     }
@@ -41951,11 +42648,11 @@ var require_required = __commonJS(function(exports) {
     $data: true,
     error: error48,
     code(cxt) {
-      const { gen, schema: schema190, schemaCode, data, $data, it } = cxt;
+      const { gen, schema: schema196, schemaCode, data, $data, it } = cxt;
       const { opts } = it;
-      if (!$data && schema190.length === 0)
+      if (!$data && schema196.length === 0)
         return;
-      const useLoop = schema190.length >= opts.loopRequired;
+      const useLoop = schema196.length >= opts.loopRequired;
       if (it.allErrors)
         allErrorsMode();
       else
@@ -41963,7 +42660,7 @@ var require_required = __commonJS(function(exports) {
       if (opts.strictRequired) {
         const props = cxt.parentSchema.properties;
         const { definedProperties } = cxt.it;
-        for (const requiredKey of schema190) {
+        for (const requiredKey of schema196) {
           if ((props === null || props === undefined ? undefined : props[requiredKey]) === undefined && !definedProperties.has(requiredKey)) {
             const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
             const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`;
@@ -41975,7 +42672,7 @@ var require_required = __commonJS(function(exports) {
         if (useLoop || $data) {
           cxt.block$data(codegen_1.nil, loopAllRequired);
         } else {
-          for (const prop of schema190) {
+          for (const prop of schema196) {
             (0, code_1.checkReportMissingProp)(cxt, prop);
           }
         }
@@ -41987,7 +42684,7 @@ var require_required = __commonJS(function(exports) {
           cxt.block$data(valid, () => loopUntilMissing(missing, valid));
           cxt.ok(valid);
         } else {
-          gen.if((0, code_1.checkMissingProp)(cxt, schema190, missing));
+          gen.if((0, code_1.checkMissingProp)(cxt, schema196, missing));
           (0, code_1.reportMissingProp)(cxt, missing);
           gen.else();
         }
@@ -42065,8 +42762,8 @@ var require_uniqueItems = __commonJS(function(exports) {
     $data: true,
     error: error48,
     code(cxt) {
-      const { gen, data, $data, schema: schema190, parentSchema, schemaCode, it } = cxt;
-      if (!$data && !schema190)
+      const { gen, data, $data, schema: schema196, parentSchema, schemaCode, it } = cxt;
+      if (!$data && !schema196)
         return;
       const valid = gen.let("valid");
       const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
@@ -42126,11 +42823,11 @@ var require_const = __commonJS(function(exports) {
     $data: true,
     error: error48,
     code(cxt) {
-      const { gen, data, $data, schemaCode, schema: schema190 } = cxt;
-      if ($data || schema190 && typeof schema190 == "object") {
+      const { gen, data, $data, schemaCode, schema: schema196 } = cxt;
+      if ($data || schema196 && typeof schema196 == "object") {
         cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
       } else {
-        cxt.fail((0, codegen_1._)`${schema190} !== ${data}`);
+        cxt.fail((0, codegen_1._)`${schema196} !== ${data}`);
       }
     }
   };
@@ -42153,10 +42850,10 @@ var require_enum = __commonJS(function(exports) {
     $data: true,
     error: error48,
     code(cxt) {
-      const { gen, data, $data, schema: schema190, schemaCode, it } = cxt;
-      if (!$data && schema190.length === 0)
+      const { gen, data, $data, schema: schema196, schemaCode, it } = cxt;
+      if (!$data && schema196.length === 0)
         throw new Error("enum must have non-empty array");
-      const useLoop = schema190.length >= it.opts.loopEnum;
+      const useLoop = schema196.length >= it.opts.loopEnum;
       let eql;
       const getEql = () => eql !== null && eql !== undefined ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default);
       let valid;
@@ -42164,10 +42861,10 @@ var require_enum = __commonJS(function(exports) {
         valid = gen.let("valid");
         cxt.block$data(valid, loopEnum);
       } else {
-        if (!Array.isArray(schema190))
+        if (!Array.isArray(schema196))
           throw new Error("ajv implementation error");
         const vSchema = gen.const("vSchema", schemaCode);
-        valid = (0, codegen_1.or)(...schema190.map((_x, i) => equalCode(vSchema, i)));
+        valid = (0, codegen_1.or)(...schema196.map((_x, i) => equalCode(vSchema, i)));
       }
       cxt.pass(valid);
       function loopEnum() {
@@ -42175,7 +42872,7 @@ var require_enum = __commonJS(function(exports) {
         gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break()));
       }
       function equalCode(vSchema, i) {
-        const sch = schema190[i];
+        const sch = schema196[i];
         return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
       }
     }
@@ -42240,13 +42937,13 @@ var require_additionalItems = __commonJS(function(exports) {
     }
   };
   function validateAdditionalItems(cxt, items) {
-    const { gen, schema: schema190, data, keyword, it } = cxt;
+    const { gen, schema: schema196, data, keyword, it } = cxt;
     it.items = true;
     const len = gen.const("len", (0, codegen_1._)`${data}.length`);
-    if (schema190 === false) {
+    if (schema196 === false) {
       cxt.setParams({ len: items.length });
       cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
-    } else if (typeof schema190 == "object" && !(0, util_1.alwaysValidSchema)(it, schema190)) {
+    } else if (typeof schema196 == "object" && !(0, util_1.alwaysValidSchema)(it, schema196)) {
       const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
       gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
       cxt.ok(valid);
@@ -42276,11 +42973,11 @@ var require_items = __commonJS(function(exports) {
     schemaType: ["object", "array", "boolean"],
     before: "uniqueItems",
     code(cxt) {
-      const { schema: schema190, it } = cxt;
-      if (Array.isArray(schema190))
-        return validateTuple(cxt, "additionalItems", schema190);
+      const { schema: schema196, it } = cxt;
+      if (Array.isArray(schema196))
+        return validateTuple(cxt, "additionalItems", schema196);
       it.items = true;
-      if ((0, util_1.alwaysValidSchema)(it, schema190))
+      if ((0, util_1.alwaysValidSchema)(it, schema196))
         return;
       cxt.ok((0, code_1.validateArray)(cxt));
     }
@@ -42349,10 +43046,10 @@ var require_items2020 = __commonJS(function(exports) {
     before: "uniqueItems",
     error: error48,
     code(cxt) {
-      const { schema: schema190, parentSchema, it } = cxt;
+      const { schema: schema196, parentSchema, it } = cxt;
       const { prefixItems } = parentSchema;
       it.items = true;
-      if ((0, util_1.alwaysValidSchema)(it, schema190))
+      if ((0, util_1.alwaysValidSchema)(it, schema196))
         return;
       if (prefixItems)
         (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
@@ -42380,7 +43077,7 @@ var require_contains = __commonJS(function(exports) {
     trackErrors: true,
     error: error48,
     code(cxt) {
-      const { gen, schema: schema190, parentSchema, data, it } = cxt;
+      const { gen, schema: schema196, parentSchema, data, it } = cxt;
       let min;
       let max;
       const { minContains, maxContains } = parentSchema;
@@ -42401,7 +43098,7 @@ var require_contains = __commonJS(function(exports) {
         cxt.fail();
         return;
       }
-      if ((0, util_1.alwaysValidSchema)(it, schema190)) {
+      if ((0, util_1.alwaysValidSchema)(it, schema196)) {
         let cond = (0, codegen_1._)`${len} >= ${min}`;
         if (max !== undefined)
           cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
@@ -42482,14 +43179,14 @@ var require_dependencies = __commonJS(function(exports) {
       validateSchemaDeps(cxt, schDeps);
     }
   };
-  function splitDependencies({ schema: schema190 }) {
+  function splitDependencies({ schema: schema196 }) {
     const propertyDeps = {};
     const schemaDeps = {};
-    for (const key in schema190) {
+    for (const key in schema196) {
       if (key === "__proto__")
         continue;
-      const deps = Array.isArray(schema190[key]) ? propertyDeps : schemaDeps;
-      deps[key] = schema190[key];
+      const deps = Array.isArray(schema196[key]) ? propertyDeps : schemaDeps;
+      deps[key] = schema196[key];
     }
     return [propertyDeps, schemaDeps];
   }
@@ -42554,8 +43251,8 @@ var require_propertyNames = __commonJS(function(exports) {
     schemaType: ["object", "boolean"],
     error: error48,
     code(cxt) {
-      const { gen, schema: schema190, data, it } = cxt;
-      if ((0, util_1.alwaysValidSchema)(it, schema190))
+      const { gen, schema: schema196, data, it } = cxt;
+      if ((0, util_1.alwaysValidSchema)(it, schema196))
         return;
       const valid = gen.name("valid");
       gen.forIn("key", data, (key) => {
@@ -42598,12 +43295,12 @@ var require_additionalProperties = __commonJS(function(exports) {
     trackErrors: true,
     error: error48,
     code(cxt) {
-      const { gen, schema: schema190, parentSchema, data, errsCount, it } = cxt;
+      const { gen, schema: schema196, parentSchema, data, errsCount, it } = cxt;
       if (!errsCount)
         throw new Error("ajv implementation error");
       const { allErrors, opts } = it;
       it.props = true;
-      if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema190))
+      if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema196))
         return;
       const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
       const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
@@ -42636,18 +43333,18 @@ var require_additionalProperties = __commonJS(function(exports) {
         gen.code((0, codegen_1._)`delete ${data}[${key}]`);
       }
       function additionalPropertyCode(key) {
-        if (opts.removeAdditional === "all" || opts.removeAdditional && schema190 === false) {
+        if (opts.removeAdditional === "all" || opts.removeAdditional && schema196 === false) {
           deleteAdditional(key);
           return;
         }
-        if (schema190 === false) {
+        if (schema196 === false) {
           cxt.setParams({ additionalProperty: key });
           cxt.error();
           if (!allErrors)
             gen.break();
           return;
         }
-        if (typeof schema190 == "object" && !(0, util_1.alwaysValidSchema)(it, schema190)) {
+        if (typeof schema196 == "object" && !(0, util_1.alwaysValidSchema)(it, schema196)) {
           const valid = gen.name("valid");
           if (opts.removeAdditional === "failing") {
             applyAdditionalSchema(key, valid, false);
@@ -42694,18 +43391,18 @@ var require_properties = __commonJS(function(exports) {
     type: "object",
     schemaType: "object",
     code(cxt) {
-      const { gen, schema: schema190, parentSchema, data, it } = cxt;
+      const { gen, schema: schema196, parentSchema, data, it } = cxt;
       if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === undefined) {
         additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"));
       }
-      const allProps = (0, code_1.allSchemaProperties)(schema190);
+      const allProps = (0, code_1.allSchemaProperties)(schema196);
       for (const prop of allProps) {
         it.definedProperties.add(prop);
       }
       if (it.opts.unevaluated && allProps.length && it.props !== true) {
         it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);
       }
-      const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema190[p]));
+      const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema196[p]));
       if (properties.length === 0)
         return;
       const valid = gen.name("valid");
@@ -42723,7 +43420,7 @@ var require_properties = __commonJS(function(exports) {
         cxt.ok(valid);
       }
       function hasDefault(prop) {
-        return it.opts.useDefaults && !it.compositeRule && schema190[prop].default !== undefined;
+        return it.opts.useDefaults && !it.compositeRule && schema196[prop].default !== undefined;
       }
       function applyPropertySchema(prop) {
         cxt.subschema({
@@ -42749,10 +43446,10 @@ var require_patternProperties = __commonJS(function(exports) {
     type: "object",
     schemaType: "object",
     code(cxt) {
-      const { gen, schema: schema190, data, parentSchema, it } = cxt;
+      const { gen, schema: schema196, data, parentSchema, it } = cxt;
       const { opts } = it;
-      const patterns = (0, code_1.allSchemaProperties)(schema190);
-      const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema190[p]));
+      const patterns = (0, code_1.allSchemaProperties)(schema196);
+      const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema196[p]));
       if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) {
         return;
       }
@@ -42817,8 +43514,8 @@ var require_not = __commonJS(function(exports) {
     schemaType: ["object", "boolean"],
     trackErrors: true,
     code(cxt) {
-      const { gen, schema: schema190, it } = cxt;
-      if ((0, util_1.alwaysValidSchema)(it, schema190)) {
+      const { gen, schema: schema196, it } = cxt;
+      if ((0, util_1.alwaysValidSchema)(it, schema196)) {
         cxt.fail();
         return;
       }
@@ -42865,12 +43562,12 @@ var require_oneOf = __commonJS(function(exports) {
     trackErrors: true,
     error: error48,
     code(cxt) {
-      const { gen, schema: schema190, parentSchema, it } = cxt;
-      if (!Array.isArray(schema190))
+      const { gen, schema: schema196, parentSchema, it } = cxt;
+      if (!Array.isArray(schema196))
         throw new Error("ajv implementation error");
       if (it.opts.discriminator && parentSchema.discriminator)
         return;
-      const schArr = schema190;
+      const schArr = schema196;
       const valid = gen.let("valid", false);
       const passing = gen.let("passing", null);
       const schValid = gen.name("_valid");
@@ -42913,11 +43610,11 @@ var require_allOf = __commonJS(function(exports) {
     keyword: "allOf",
     schemaType: "array",
     code(cxt) {
-      const { gen, schema: schema190, it } = cxt;
-      if (!Array.isArray(schema190))
+      const { gen, schema: schema196, it } = cxt;
+      if (!Array.isArray(schema196))
         throw new Error("ajv implementation error");
       const valid = gen.name("valid");
-      schema190.forEach((sch, i) => {
+      schema196.forEach((sch, i) => {
         if ((0, util_1.alwaysValidSchema)(it, sch))
           return;
         const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i }, valid);
@@ -42989,8 +43686,8 @@ var require_if = __commonJS(function(exports) {
     }
   };
   function hasSchema(it, keyword) {
-    const schema190 = it.schema[keyword];
-    return schema190 !== undefined && !(0, util_1.alwaysValidSchema)(it, schema190);
+    const schema196 = it.schema[keyword];
+    return schema196 !== undefined && !(0, util_1.alwaysValidSchema)(it, schema196);
   }
   exports.default = def;
 });
@@ -43068,7 +43765,7 @@ var require_format = __commonJS(function(exports) {
     $data: true,
     error: error48,
     code(cxt, ruleType) {
-      const { gen, data, $data, schema: schema190, schemaCode, it } = cxt;
+      const { gen, data, $data, schema: schema196, schemaCode, it } = cxt;
       const { opts, errSchemaPath, schemaEnv, self } = it;
       if (!opts.validateFormats)
         return;
@@ -43098,7 +43795,7 @@ var require_format = __commonJS(function(exports) {
         }
       }
       function validateFormat() {
-        const formatDef = self.formats[schema190];
+        const formatDef = self.formats[schema196];
         if (!formatDef) {
           unknownFormat();
           return;
@@ -43115,12 +43812,12 @@ var require_format = __commonJS(function(exports) {
           }
           throw new Error(unknownMsg());
           function unknownMsg() {
-            return `unknown format "${schema190}" ignored in schema at path "${errSchemaPath}"`;
+            return `unknown format "${schema196}" ignored in schema at path "${errSchemaPath}"`;
           }
         }
         function getFormat(fmtDef) {
-          const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema190)}` : undefined;
-          const fmt = gen.scopeValue("formats", { key: schema190, ref: fmtDef, code });
+          const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema196)}` : undefined;
+          const fmt = gen.scopeValue("formats", { key: schema196, ref: fmtDef, code });
           if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) {
             return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`];
           }
@@ -43216,15 +43913,15 @@ var require_discriminator = __commonJS(function(exports) {
     schemaType: "object",
     error: error48,
     code(cxt) {
-      const { gen, data, schema: schema190, parentSchema, it } = cxt;
+      const { gen, data, schema: schema196, parentSchema, it } = cxt;
       const { oneOf } = parentSchema;
       if (!it.opts.discriminator) {
         throw new Error("discriminator: requires discriminator option");
       }
-      const tagName = schema190.propertyName;
+      const tagName = schema196.propertyName;
       if (typeof tagName != "string")
         throw new Error("discriminator: requires propertyName");
-      if (schema190.mapping)
+      if (schema196.mapping)
         throw new Error("discriminator: mapping is not supported");
       if (!oneOf)
         throw new Error("discriminator: requires oneOf keyword");
@@ -43825,8 +44522,8 @@ class AjvJsonSchemaValidator {
   constructor(ajv) {
     this._ajv = ajv ?? createDefaultAjvInstance();
   }
-  getValidator(schema190) {
-    const ajvValidator = "$id" in schema190 && typeof schema190.$id === "string" ? this._ajv.getSchema(schema190.$id) ?? this._ajv.compile(schema190) : this._ajv.compile(schema190);
+  getValidator(schema196) {
+    const ajvValidator = "$id" in schema196 && typeof schema196.$id === "string" ? this._ajv.getSchema(schema196.$id) ?? this._ajv.compile(schema196) : this._ajv.compile(schema196);
     return (input) => {
       const valid = ajvValidator(input);
       if (valid) {
@@ -44309,12 +45006,12 @@ var init_server2 = __esm(() => {
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
-function isCompletable(schema190) {
-  return !!schema190 && typeof schema190 === "object" && COMPLETABLE_SYMBOL in schema190;
+function isCompletable(schema196) {
+  return !!schema196 && typeof schema196 === "object" && COMPLETABLE_SYMBOL in schema196;
 }
-function getCompleter(schema190) {
-  const meta189 = schema190[COMPLETABLE_SYMBOL];
-  return meta189?.complete;
+function getCompleter(schema196) {
+  const meta195 = schema196[COMPLETABLE_SYMBOL];
+  return meta195?.complete;
 }
 var COMPLETABLE_SYMBOL, McpZodTypeKind;
 var init_completable = __esm(() => {
@@ -45067,20 +45764,20 @@ function isZodRawShapeCompat(obj) {
   }
   return Object.values(obj).some(isZodTypeLike);
 }
-function getZodSchemaObject(schema190) {
-  if (!schema190) {
+function getZodSchemaObject(schema196) {
+  if (!schema196) {
     return;
   }
-  if (isZodRawShapeCompat(schema190)) {
-    return objectFromShape(schema190);
+  if (isZodRawShapeCompat(schema196)) {
+    return objectFromShape(schema196);
   }
-  if (!isZodSchemaInstance(schema190)) {
+  if (!isZodSchemaInstance(schema196)) {
     throw new Error("inputSchema must be a Zod schema or raw shape, received an unrecognized object");
   }
-  return schema190;
+  return schema196;
 }
-function promptArgumentsFromSchema(schema190) {
-  const shape = getObjectShape(schema190);
+function promptArgumentsFromSchema(schema196) {
+  const shape = getObjectShape(schema196);
   if (!shape)
     return [];
   return Object.entries(shape).map(([name, field]) => {
@@ -45093,8 +45790,8 @@ function promptArgumentsFromSchema(schema190) {
     };
   });
 }
-function getMethodValue(schema190) {
-  const shape = getObjectShape(schema190);
+function getMethodValue(schema196) {
+  const shape = getObjectShape(schema196);
   const methodSchema = shape?.method;
   if (!methodSchema) {
     throw new Error("Schema is missing a method literal");
@@ -45227,7 +45924,7 @@ var PACKAGE_NAME = "ask-marcel-office-cli", okText = (text) => ({ content: [{ ty
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
   }, async ({ force }) => {
     const loginAuth = deps.makeLoginAuth ? deps.makeLoginAuth() : auth;
-    const result = await execute187(loginAuth, { force: force ?? false });
+    const result = await execute193(loginAuth, { force: force ?? false });
     if (!result.ok)
       return errText(result.error.type === "auth_cancelled" ? "Authentication cancelled" : result.error.message);
     const info = await graph.getCachedTokenInfo();
@@ -45362,7 +46059,7 @@ import updateNotifier from "update-notifier";
 // package.json
 var package_default = {
   name: "ask-marcel-office-cli",
-  version: "2.4.0",
+  version: "2.5.0",
   description: "Microsoft Graph CLI + library — typed Bun/TypeScript wrapper around 150+ Graph operations (read + on-the-fly PDF/markdown conversion + federated Microsoft Search) reachable from a Teams browser-OAuth token.",
   license: "MIT",
   author: "Vincent Delacourt <vincent.delacourt@adama-development.com>",
@@ -45438,6 +46135,7 @@ var package_default = {
     "lint:strict": "LINT_STRICT=1 eslint --max-warnings=0",
     typecheck: "bun --bun x tsc --noEmit",
     coverage: "bun run scripts/check-coverage.ts",
+    "check:docs": "bun run scripts/check-doc-numbers.ts",
     mutate: "stryker run",
     "mutate:changed": "bash scripts/mutate-changed.sh",
     "mutate:staged": "bash scripts/mutate-staged.sh",
@@ -47385,9 +48083,9 @@ var createWinstonLogger = (config2 = {}) => {
     transports: [new transports.Console({ stderrLevels: ALL_LEVELS })]
   });
   return {
-    info: (event, meta189) => winston.info(event, meta189),
-    warn: (event, meta189) => winston.warn(event, meta189),
-    error: (event, meta189) => winston.error(event, meta189)
+    info: (event, meta195) => winston.info(event, meta195),
+    warn: (event, meta195) => winston.warn(event, meta195),
+    error: (event, meta195) => winston.error(event, meta195)
   };
 };
 // src/infra/process-runner-bun.ts
@@ -47421,9 +48119,9 @@ var createNodeProcessRunner = () => ({
 var defaultCachePath = (home) => join2(home, ".ask-marcel", "token-cache.json");
 var commandNamesWhere = (matches) => Object.entries(commands).filter(([, cmd]) => matches(cmd.meta)).map(([name]) => name).toSorted((a, b) => a.localeCompare(b));
 var secondaryTokenCommands = {
-  elevated: commandNamesWhere((meta189) => meta189.needsElevatedToken === true),
-  chatsvcagg: commandNamesWhere((meta189) => meta189.needsSubstrateToken === "chatsvcagg"),
-  ic3: commandNamesWhere((meta189) => meta189.needsSubstrateToken === "ic3")
+  elevated: commandNamesWhere((meta195) => meta195.needsElevatedToken === true),
+  chatsvcagg: commandNamesWhere((meta195) => meta195.needsSubstrateToken === "chatsvcagg"),
+  ic3: commandNamesWhere((meta195) => meta195.needsSubstrateToken === "ic3")
 };
 var defaultFileSystem3 = () => typeof globalThis.Bun !== "undefined" ? createBunFileSystem() : createNodeFileSystem();
 var defaultProcessRunner = () => typeof globalThis.Bun !== "undefined" ? createBunProcessRunner() : createNodeProcessRunner();
@@ -47485,8 +48183,8 @@ init_login_status();
 
 // src/use-cases/commands/logout.ts
 init_zod();
-var schema188 = exports_external.object({}).strict();
-var execute188 = async (auth) => auth.logout();
+var schema194 = exports_external.object({}).strict();
+var execute194 = async (auth) => auth.logout();
 
 // src/composition/cli.ts
 init_output_path();
@@ -47495,8 +48193,8 @@ init_output_path();
 init_zod();
 var PACKAGE = "ask-marcel-office-cli";
 var argsFor = (manager) => manager === "bun" ? ["add", "-g", `${PACKAGE}@latest`] : ["i", "-g", `${PACKAGE}@latest`];
-var schema189 = exports_external.object({}).strict();
-var execute189 = async (runner, manager) => {
+var schema195 = exports_external.object({}).strict();
+var execute195 = async (runner, manager) => {
   const result = await runner.runInherit(manager, argsFor(manager));
   if (!result.ok)
     return err({ type: "spawn_failed", message: result.error.message });
@@ -47560,6 +48258,7 @@ var buildCli = (deps) => {
   const searchPostNames = Object.entries(commands).filter(([, c]) => c.meta.graphMethod === "POST" && c.meta.mutates !== true).map(([n]) => n).toSorted((a, b) => a.localeCompare(b));
   const surfaceDescription = `Microsoft Graph CLI. Read-mostly by design — the ONLY writes are the ${mutatingCommandNames.length} mail-draft commands (${mutatingCommandNames.join(", ")}), which can only create or update an UNSENT draft; the CLI cannot send mail, create or modify calendar items, or write files (there is no send-mail / send-draft / create-event / upload-file command). ${getEndpointCount} GET endpoints + ${searchPostNames.length} search POST (${searchPostNames.join(", ")}). Safe default for LLM autonomy.`;
   program2.name("ask-marcel-office").description(surfaceDescription).version(version2 ?? "0.0.0").configureHelp({
+    helpWidth: 80,
     subcommandDescription: (cmd) => firstSentence(cmd.description())
   }).option("--output-path <path>", 'Globally available. When the command returns inlined bytes (`{contentType, size, base64}` for binary or `{..., text}` for text), decode and write them to <path>, replacing the inline field with `savedTo: <path>` in the JSON envelope. Use this for multi-MB PDFs / images so the LLM never has to round-trip a base64 string through stdout. Parent directories are auto-created. When applied to a command whose response has neither `base64` nor `text` (e.g. plain JSON gets like `get-current-user`) the CLI emits a clear `{"ok":false,"error":"--output-path: <cmd> did not return inlined bytes …"}` envelope rather than silently writing nothing — a JSON-only command paired with this flag is almost certainly a mistake.').option("--output-dir <dir>", "Globally available. For commands that return a `media` array (the `extract-*-images` family), decode and write every image to <dir>/<filename>, replacing each `base64` with `savedTo` in the JSON envelope. The directory is auto-created. Use this for image-heavy decks so the LLM never round-trips a base64 blob through stdout. Applied to a command that returns no media array, the CLI emits a clear error rather than writing nothing.").addOption((() => {
     const ALLOWED = ["text", "json"];
@@ -47609,7 +48308,7 @@ var buildCli = (deps) => {
     }
     fail(`Unknown command "${result.error.name}". Run \`ask-marcel-office --help\` to list every command.`, "cli_unknown_command");
   });
-  program2.command("help-json").description("Print the machine-readable command manifest as JSON. **Use `--terse --category <name>` for fresh-session discovery** — that combo is the actual token-friendly path (~6 KB for one category, vs ~440 KB unfiltered). The unflagged form is the *full* reference (every option / example / response shape per command) and is well over 10× the size of `ask-marcel-office --help`; reach for it only after `--terse` has narrowed the search. `--terse` alone projects to `{name, summary, category}` with each summary compacted to its first sentence (~30 KB across all categories). Categories: lifecycle, drive, excel, sharepoint, tasks, mail, notes, user, calendar, chats, teams, meta.").option("--terse", "Strip per-command options/example/graphPathTemplate/responseShape/etc., emitting only `{ name, summary, category }`. Roughly 95% smaller than the full manifest — use for command discovery, switch to the full manifest once you know which command to invoke.").option("--category <name>", "Filter the manifest to a single category (one of: lifecycle, drive, excel, sharepoint, tasks, mail, notes, user, calendar, chats, teams, meta). Composes with `--terse`. Unknown categories return a structured `{ ok: false, error }` envelope.").action(async (opts) => {
+  program2.command("help-json").description("Print the machine-readable command manifest as JSON. **Use `--terse --category <name>` for fresh-session discovery** — that combo is the actual token-friendly path (~8 KB for one category, vs ~505 KB unfiltered). The unflagged form is the *full* reference (every option / example / response shape per command) and is well over 10× the size of `ask-marcel-office --help`; reach for it only after `--terse` has narrowed the search. `--terse` alone projects to `{name, summary, category}` with each summary compacted to its first sentence (~33 KB across all categories). Categories: lifecycle, drive, excel, sharepoint, tasks, mail, notes, user, calendar, chats, teams, meta.").option("--terse", "Strip per-command options/example/graphPathTemplate/responseShape/etc., emitting only `{ name, summary, category }`. Roughly 95% smaller than the full manifest — use for command discovery, switch to the full manifest once you know which command to invoke.").option("--category <name>", "Filter the manifest to a single category (one of: lifecycle, drive, excel, sharepoint, tasks, mail, notes, user, calendar, chats, teams, meta). Composes with `--terse`. Unknown categories return a structured `{ ok: false, error }` envelope.").action(async (opts) => {
     const outputSource = program2.getOptionValueSource("output");
     if (outputSource === "cli" && getFormat() === "text") {
       fail("help-json always emits JSON (that's the contract — the manifest is the LLM-consumable serialized form of every command's meta). Drop `--output text` for this command. To browse the manifest as Markdown, use `ask-marcel-office docs <command>` instead.");
@@ -47631,7 +48330,7 @@ var buildCli = (deps) => {
   const loginCmd = program2.command("login").description("Authenticate against Microsoft Graph via the Teams web client (cached token → refresh → browser). Already signed in? Reports all four cached tokens (basic / elevated / chatsvcagg / ic3) with their time-left and refresh route; --force re-captures every token via the browser.").option("--force", 'Ignore the cache and re-capture every token via the browser. Rarely needed, and NOT free: it clears the browser session first so the token grant re-fires, which deletes the 90-day "Stay signed in" cookie and usually means entering your password again. A plain `login` already re-captures the elevated (M365) token when it is missing and leaves that session intact, so reach for `--force` only when a tier is stuck and a plain `login` has not fixed it.').action(async () => {
     const force = loginCmd.opts().force ?? false;
     const loginAuth = deps.makeLoginAuth ? deps.makeLoginAuth() : auth;
-    const result = await execute187(loginAuth, { force });
+    const result = await execute193(loginAuth, { force });
     if (!result.ok) {
       fail(result.error.type === "auth_cancelled" ? "Authentication cancelled" : result.error.message);
       return;
@@ -47660,7 +48359,7 @@ var buildCli = (deps) => {
   ].join(`
   `));
   const logoutCmd = program2.command("logout").description("Clear the cached Microsoft Graph token so the next command forces a fresh sign-in.").action(async () => {
-    const result = await execute188(auth);
+    const result = await execute194(auth);
     if (result.ok)
       renderOut({ status: "logged_out" });
     else
@@ -47676,7 +48375,7 @@ var buildCli = (deps) => {
   `));
   const updateCmd = program2.command("update").description("Re-install the latest published ask-marcel-office from npm, in place. Auto-detects whether you originally installed via npm or bun.").action(async () => {
     const manager = deps.packageManager ?? detectPackageManager(process.argv[1] ?? "");
-    const result = await execute189(processRunner, manager);
+    const result = await execute195(processRunner, manager);
     if (result.ok)
       renderOut({ status: "updated", via: manager });
     else if (result.error.type === "spawn_failed")