@crowi/api-contract 2.0.0-alpha.10 → 2.0.0-alpha.11

package/dist/index.mjs

@@ -1722,14 +1722,51 @@ var UploadAttachmentResponseSchema = z17.object({
   mimeType: z17.string(),
   sizeBytes: z17.number()
 });
-var UploadAttachmentErrorCodeSchema = z17.enum(["too_large", "disallowed_type", "rate_limited", "no_permission"]);
+var UploadAttachmentErrorCodeSchema = z17.enum(["too_large", "disallowed_type", "DISALLOWED_MIME", "rate_limited", "no_permission"]);
 var UploadAttachmentErrorSchema = z17.object({
   error: UploadAttachmentErrorCodeSchema,
   message: z17.string(),
   details: z17.record(z17.string(), z17.unknown()).optional()
 });
-var IMAGE_UPLOAD_MIME = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/svg+xml"];
-var DND_EXTRA_UPLOAD_MIME = ["application/pdf", "text/plain", "text/markdown", "text/csv", "application/zip"];
+var UPLOAD_ALLOWED_MIME = [
+  // Raster + vector images.
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/svg+xml",
+  "image/bmp",
+  "image/avif",
+  "image/apng",
+  "image/x-icon",
+  // Documents / text.
+  "application/pdf",
+  "text/plain",
+  "text/markdown",
+  "text/csv",
+  "application/json",
+  "application/xml",
+  "text/html",
+  // Office documents.
+  "application/msword",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.ms-excel",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.ms-powerpoint",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  // Archives.
+  "application/zip",
+  "application/gzip",
+  "application/x-tar",
+  // Audio / video.
+  "audio/mpeg",
+  "audio/wav",
+  "video/mp4",
+  "video/webm",
+  "video/quicktime",
+  // Unknown / unset — see the note above.
+  "application/octet-stream"
+];
 
 // src/contracts/attachment.ts
 var PageIdPathParamsSchema = z18.object({
@@ -1811,6 +1848,10 @@ var addAttachmentRoute = createRoute10({
       description: "Request body exceeds the multipart envelope ceiling",
       content: { "application/json": { schema: AttachmentErrorSchema } }
     },
+    415: {
+      description: "MIME type not in the unified upload allow-list (feature-attachment-upload-policy)",
+      content: { "application/json": { schema: AttachmentErrorSchema } }
+    },
     500: {
       description: "Upload / storage failure",
       content: { "application/json": { schema: AttachmentErrorSchema } }
@@ -1914,7 +1955,7 @@ var uploadAttachmentRoute = createRoute10({
       content: { "application/json": { schema: UploadAttachmentErrorSchema } }
     },
     415: {
-      description: "MIME type not in the per-intent allow-list",
+      description: "MIME type not in the unified upload allow-list (feature-attachment-upload-policy)",
       content: { "application/json": { schema: UploadAttachmentErrorSchema } }
     },
     429: {
@@ -2109,7 +2150,7 @@ var GetBacklinksResponseSchema = z20.object({
 });
 
 // src/schemas/page.ts
-import { z as z22 } from "@hono/zod-openapi";
+import { z as z23 } from "@hono/zod-openapi";
 
 // src/schemas/collab.ts
 import { z as z21 } from "@hono/zod-openapi";
@@ -2147,15 +2188,341 @@ var CollabForceReloadMessageSchema = z21.object({
   reason: z21.string().optional()
 });
 
+// src/schemas/rendered-ast.ts
+import { z as z22 } from "@hono/zod-openapi";
+var CURRENT_AST_VERSION = 1;
+var AST_INPUT_LIMIT_BYTES = 8 * 1024 * 1024;
+var AST_OUTPUT_WARN_BYTES = 512 * 1024;
+var AST_OUTPUT_BUDGET_BYTES = 2 * 1024 * 1024;
+var AST_MAX_TREE_DEPTH = 64;
+var AST_MAX_HAST_DEPTH = 16;
+var AST_MAX_IMAGE_BASE64_CHARS = 14e4;
+var AST_MAX_VALUE_CHARS = 2e5;
+var HPropertyValueSchema = z22.union([
+  z22.string().max(4096),
+  z22.number(),
+  z22.boolean(),
+  z22.array(z22.union([z22.string().max(4096), z22.number()])).max(64)
+  // className etc.
+]);
+var HPropertiesSchema = z22.object({
+  id: z22.string().max(256).optional(),
+  className: z22.union([z22.string().max(4096), z22.array(z22.string().max(256)).max(64)]).optional(),
+  role: z22.string().max(64).optional(),
+  ariaLabel: z22.string().max(256).optional(),
+  "data-source-line": z22.union([z22.string().max(32), z22.number()]).optional(),
+  "data-crowi-image-align": z22.string().max(16).optional(),
+  "data-crowi-image-float": z22.string().max(16).optional(),
+  "data-crowi-image-width": z22.string().max(16).optional(),
+  "data-crowi-image-height": z22.string().max(16).optional()
+}).catchall(HPropertyValueSchema);
+var HChildSchema = z22.lazy(
+  () => z22.discriminatedUnion("type", [
+    z22.object({ type: z22.literal("raw"), value: z22.string().max(AST_MAX_VALUE_CHARS) }),
+    z22.object({ type: z22.literal("text"), value: z22.string().max(AST_MAX_VALUE_CHARS) }),
+    z22.object({
+      type: z22.literal("element"),
+      tagName: z22.string().max(32).regex(/^[a-zA-Z][a-zA-Z0-9-]*$/),
+      properties: HPropertiesSchema.optional(),
+      children: z22.array(HChildSchema)
+    })
+  ])
+);
+var HChildrenSchema = z22.array(HChildSchema).max(256);
+var HNameSchema = z22.string().max(32).regex(/^[a-zA-Z][a-zA-Z0-9-]*$/);
+var HastHintDataSchema = z22.object({
+  hName: HNameSchema.optional(),
+  hProperties: HPropertiesSchema.optional(),
+  hChildren: HChildrenSchema.optional()
+});
+var CrowiDimensionSchema = z22.number().int().min(1).max(16384);
+var CrowiImagePayloadSchema = z22.object({
+  mediaType: z22.enum(["image/svg+xml", "image/png"]),
+  base64: z22.string().max(AST_MAX_IMAGE_BASE64_CHARS),
+  /** Intrinsic dimensions — required (parent spec §3). Producers that cannot derive them fall back to html-only. */
+  width: CrowiDimensionSchema,
+  height: CrowiDimensionSchema
+});
+var ShikiTokenStyleSchema = z22.object({
+  color: z22.string().max(32),
+  bgColor: z22.string().max(32).optional(),
+  fontStyle: z22.array(z22.enum(["italic", "bold", "underline", "strikethrough"])).max(4).optional()
+});
+var ShikiTokenSchema = z22.object({
+  content: z22.string().max(4096),
+  light: ShikiTokenStyleSchema,
+  dark: ShikiTokenStyleSchema
+});
+var ShikiTokenLinesSchema = z22.array(z22.array(ShikiTokenSchema)).max(2e4);
+var CrowiCodeSidecarSchema = z22.object({
+  lang: z22.string().max(64).optional(),
+  value: z22.string().max(AST_MAX_VALUE_CHARS),
+  /** Lines of themed tokens (light/dark both, `defaultColor: false`). */
+  tokens: ShikiTokenLinesSchema
+});
+var CrowiMathSidecarSchema = z22.object({
+  tex: z22.string().max(AST_MAX_VALUE_CHARS),
+  display: z22.boolean()
+});
+var CrowiDiagramSidecarSchema = z22.object({
+  kind: z22.enum(["mermaid", "plantuml"]),
+  /** Mermaid's closed-enum diagram-type keyword (flowchart / sequence / ...). */
+  diagramType: z22.string().max(32).optional(),
+  alt: z22.string().max(256),
+  image: CrowiImagePayloadSchema
+});
+var CrowiLinkCardSidecarSchema = z22.object({
+  url: z22.string().max(4096),
+  title: z22.string().max(512).optional(),
+  description: z22.string().max(2048).optional(),
+  /** OGP image stays an external URL (never inlined server-side — parent spec §10). */
+  image: z22.object({ url: z22.string().max(4096) }).optional(),
+  siteName: z22.string().max(256).optional(),
+  domain: z22.string().max(256).optional()
+});
+var CrowiPlaceholderKindSchema = z22.enum([
+  "error-auth",
+  "error-rate-limit",
+  "error-not-found",
+  "error-network",
+  "error-timeout",
+  "error-unknown",
+  "error-blocked",
+  "error-busy",
+  "size-limit-entry",
+  "size-limit-page",
+  "dispatch-limit",
+  "validation-failed",
+  "envelope-invalid"
+]);
+var ReservationSchema = z22.discriminatedUnion("variant", [
+  z22.object({ variant: z22.literal("fixed"), widthPx: z22.number().optional(), heightPx: z22.number() }),
+  z22.object({ variant: z22.literal("aspect"), aspectRatio: z22.number() }),
+  z22.object({ variant: z22.literal("card"), size: z22.enum(["small", "medium", "large"]) })
+]);
+var CrowiPlaceholderSidecarSchema = z22.object({
+  kind: CrowiPlaceholderKindSchema,
+  label: z22.string().max(512),
+  reservation: ReservationSchema
+});
+var SIDECAR_KEYS = ["crowiCode", "crowiMath", "crowiDiagram", "crowiLinkCard", "crowiPlaceholder"];
+var noFields = z22.object({});
+var headingFields = z22.object({ depth: z22.number().int().min(1).max(6) });
+var valueFields = z22.object({ value: z22.string().max(AST_MAX_VALUE_CHARS) });
+var codeFields = z22.object({
+  value: z22.string().max(AST_MAX_VALUE_CHARS),
+  lang: z22.string().max(64).nullable().optional(),
+  meta: z22.string().max(1024).nullable().optional()
+});
+var mathFields = z22.object({
+  value: z22.string().max(AST_MAX_VALUE_CHARS),
+  meta: z22.string().max(1024).nullable().optional()
+});
+var listFields = z22.object({
+  ordered: z22.boolean().nullable().optional(),
+  start: z22.number().int().nullable().optional(),
+  spread: z22.boolean().nullable().optional()
+});
+var listItemFields = z22.object({
+  checked: z22.boolean().nullable().optional(),
+  spread: z22.boolean().nullable().optional()
+});
+var linkFields = z22.object({
+  url: z22.string().max(4096),
+  title: z22.string().max(512).nullable().optional()
+});
+var imageFields = z22.object({
+  url: z22.string().max(4096),
+  alt: z22.string().max(1024).nullable().optional(),
+  title: z22.string().max(512).nullable().optional()
+});
+var tableFields = z22.object({
+  align: z22.array(z22.enum(["left", "right", "center"]).nullable()).max(256).nullable().optional()
+});
+var definitionFields = z22.object({
+  identifier: z22.string().max(256),
+  url: z22.string().max(4096),
+  label: z22.string().max(256).optional(),
+  title: z22.string().max(512).nullable().optional()
+});
+var footnoteDefinitionFields = z22.object({
+  identifier: z22.string().max(256),
+  label: z22.string().max(256).optional()
+});
+var footnoteReferenceFields = footnoteDefinitionFields;
+var referenceTypeSchema = z22.enum(["shortcut", "collapsed", "full"]);
+var linkReferenceFields = z22.object({
+  identifier: z22.string().max(256),
+  referenceType: referenceTypeSchema,
+  label: z22.string().max(256).optional()
+});
+var imageReferenceFields = z22.object({
+  identifier: z22.string().max(256),
+  referenceType: referenceTypeSchema,
+  label: z22.string().max(256).optional(),
+  alt: z22.string().max(1024).nullable().optional()
+});
+var crowiOpaqueFields = z22.object({
+  reason: z22.enum(["unknown-type", "invalid-shape", "invalid-position"]),
+  /** Best-effort diagnostics only — never a rendering hint. Truncated to 64 chars before assignment. */
+  originalType: z22.string().max(64).optional()
+});
+var RENDERED_AST_NODE_DEFS = {
+  root: { placement: "flow", childModel: "flow", fields: noFields },
+  paragraph: { placement: "flow", childModel: "phrasing", fields: noFields },
+  heading: { placement: "flow", childModel: "phrasing", fields: headingFields },
+  thematicBreak: { placement: "flow", childModel: "none", fields: noFields },
+  blockquote: { placement: "flow", childModel: "flow", fields: noFields },
+  list: { placement: "flow", childModel: "listItems", fields: listFields },
+  listItem: { placement: "listItems", childModel: "flow", fields: listItemFields },
+  html: { placement: "both", childModel: "none", fields: valueFields },
+  code: { placement: "flow", childModel: "none", fields: codeFields },
+  inlineCode: { placement: "phrasing", childModel: "none", fields: valueFields },
+  math: { placement: "flow", childModel: "none", fields: mathFields },
+  inlineMath: { placement: "phrasing", childModel: "none", fields: mathFields },
+  text: { placement: "phrasing", childModel: "none", fields: valueFields },
+  strong: { placement: "phrasing", childModel: "phrasing", fields: noFields },
+  emphasis: { placement: "phrasing", childModel: "phrasing", fields: noFields },
+  delete: { placement: "phrasing", childModel: "phrasing", fields: noFields },
+  break: { placement: "phrasing", childModel: "none", fields: noFields },
+  link: { placement: "phrasing", childModel: "phrasing", fields: linkFields },
+  image: { placement: "phrasing", childModel: "none", fields: imageFields },
+  table: { placement: "flow", childModel: "tableRows", fields: tableFields },
+  tableRow: { placement: "tableRows", childModel: "tableCells", fields: noFields },
+  tableCell: { placement: "tableCells", childModel: "phrasing", fields: noFields },
+  definition: { placement: "flow", childModel: "none", fields: definitionFields },
+  footnoteDefinition: { placement: "flow", childModel: "flow", fields: footnoteDefinitionFields },
+  footnoteReference: { placement: "phrasing", childModel: "none", fields: footnoteReferenceFields },
+  linkReference: { placement: "phrasing", childModel: "phrasing", fields: linkReferenceFields },
+  imageReference: { placement: "phrasing", childModel: "none", fields: imageReferenceFields },
+  // Crowi-owned types. `crowiFigure` is the only one that also appears
+  // in stored ASTs; the other three only exist as projection outputs
+  // (or as defensively-validated plugin-injected nodes).
+  crowiFigure: { placement: "flow", childModel: "phrasing", fields: noFields },
+  crowiDiagram: { placement: "flow", childModel: "none", fields: CrowiDiagramSidecarSchema },
+  crowiLinkCard: { placement: "flow", childModel: "none", fields: CrowiLinkCardSidecarSchema },
+  crowiPlaceholder: { placement: "both", childModel: "none", fields: CrowiPlaceholderSidecarSchema },
+  crowiOpaque: { placement: "both", childModel: "none", fields: crowiOpaqueFields }
+};
+var RenderedAstNodeSchema = z22.lazy(
+  () => z22.discriminatedUnion("type", [
+    RootNodeSchema,
+    ParagraphNodeSchema,
+    HeadingNodeSchema,
+    ThematicBreakNodeSchema,
+    BlockquoteNodeSchema,
+    ListNodeSchema,
+    ListItemNodeSchema,
+    HtmlNodeSchema,
+    CodeNodeSchema,
+    InlineCodeNodeSchema,
+    MathNodeSchema,
+    InlineMathNodeSchema,
+    TextNodeSchema,
+    StrongNodeSchema,
+    EmphasisNodeSchema,
+    DeleteNodeSchema,
+    BreakNodeSchema,
+    LinkNodeSchema,
+    ImageNodeSchema,
+    TableNodeSchema,
+    TableRowNodeSchema,
+    TableCellNodeSchema,
+    DefinitionNodeSchema,
+    FootnoteDefinitionNodeSchema,
+    FootnoteReferenceNodeSchema,
+    LinkReferenceNodeSchema,
+    ImageReferenceNodeSchema,
+    CrowiFigureNodeSchema,
+    CrowiDiagramNodeSchema,
+    CrowiLinkCardNodeSchema,
+    CrowiPlaceholderNodeSchema,
+    CrowiOpaqueNodeSchema
+  ])
+);
+var childrenSchema = z22.array(RenderedAstNodeSchema);
+var dataSchema = HastHintDataSchema.optional();
+var RootNodeSchema = z22.object({ type: z22.literal("root"), data: dataSchema, children: childrenSchema });
+var ParagraphNodeSchema = z22.object({ type: z22.literal("paragraph"), data: dataSchema, children: childrenSchema });
+var HeadingNodeSchema = headingFields.extend({ type: z22.literal("heading"), data: dataSchema, children: childrenSchema });
+var ThematicBreakNodeSchema = z22.object({ type: z22.literal("thematicBreak"), data: dataSchema });
+var BlockquoteNodeSchema = z22.object({ type: z22.literal("blockquote"), data: dataSchema, children: childrenSchema });
+var ListNodeSchema = listFields.extend({ type: z22.literal("list"), data: dataSchema, children: childrenSchema });
+var ListItemNodeSchema = listItemFields.extend({ type: z22.literal("listItem"), data: dataSchema, children: childrenSchema });
+var HtmlNodeSchema = valueFields.extend({ type: z22.literal("html"), data: dataSchema });
+var CodeDataSchema = HastHintDataSchema.extend({
+  renderPending: z22.boolean().optional(),
+  tokens: ShikiTokenLinesSchema.optional()
+}).optional();
+var CodeNodeSchema = codeFields.extend({ type: z22.literal("code"), data: CodeDataSchema });
+var InlineCodeNodeSchema = valueFields.extend({ type: z22.literal("inlineCode"), data: dataSchema });
+var MathNodeSchema = mathFields.extend({ type: z22.literal("math"), data: dataSchema });
+var InlineMathNodeSchema = mathFields.extend({ type: z22.literal("inlineMath"), data: dataSchema });
+var TextNodeSchema = valueFields.extend({ type: z22.literal("text"), data: dataSchema });
+var StrongNodeSchema = z22.object({ type: z22.literal("strong"), data: dataSchema, children: childrenSchema });
+var EmphasisNodeSchema = z22.object({ type: z22.literal("emphasis"), data: dataSchema, children: childrenSchema });
+var DeleteNodeSchema = z22.object({ type: z22.literal("delete"), data: dataSchema, children: childrenSchema });
+var BreakNodeSchema = z22.object({ type: z22.literal("break"), data: dataSchema });
+var LinkNodeSchema = linkFields.extend({ type: z22.literal("link"), data: dataSchema, children: childrenSchema });
+var ImageNodeSchema = imageFields.extend({ type: z22.literal("image"), data: dataSchema });
+var TableNodeSchema = tableFields.extend({ type: z22.literal("table"), data: dataSchema, children: childrenSchema });
+var TableRowNodeSchema = z22.object({ type: z22.literal("tableRow"), data: dataSchema, children: childrenSchema });
+var TableCellNodeSchema = z22.object({ type: z22.literal("tableCell"), data: dataSchema, children: childrenSchema });
+var DefinitionNodeSchema = definitionFields.extend({ type: z22.literal("definition"), data: dataSchema });
+var FootnoteDefinitionNodeSchema = footnoteDefinitionFields.extend({
+  type: z22.literal("footnoteDefinition"),
+  data: dataSchema,
+  children: childrenSchema
+});
+var FootnoteReferenceNodeSchema = footnoteReferenceFields.extend({ type: z22.literal("footnoteReference"), data: dataSchema });
+var LinkReferenceNodeSchema = linkReferenceFields.extend({ type: z22.literal("linkReference"), data: dataSchema, children: childrenSchema });
+var ImageReferenceNodeSchema = imageReferenceFields.extend({ type: z22.literal("imageReference"), data: dataSchema });
+var CrowiFigureNodeSchema = z22.object({
+  type: z22.literal("crowiFigure"),
+  data: HastHintDataSchema.extend({ hName: z22.literal("figure"), hProperties: HPropertiesSchema }),
+  children: childrenSchema
+});
+var CrowiDiagramNodeSchema = CrowiDiagramSidecarSchema.extend({ type: z22.literal("crowiDiagram"), data: dataSchema });
+var CrowiLinkCardNodeSchema = CrowiLinkCardSidecarSchema.extend({ type: z22.literal("crowiLinkCard"), data: dataSchema });
+var CrowiPlaceholderNodeSchema = CrowiPlaceholderSidecarSchema.extend({ type: z22.literal("crowiPlaceholder"), data: dataSchema });
+var CrowiOpaqueNodeSchema = crowiOpaqueFields.extend({ type: z22.literal("crowiOpaque"), data: dataSchema });
+var RenderedAstRootSchema = RootNodeSchema;
+var RenderedAstEnvelopeSchema = z22.object({
+  astVersion: z22.literal(CURRENT_AST_VERSION),
+  root: RenderedAstRootSchema
+});
+var RenderedAstEnvelopeOpenApiSchema = z22.object({
+  astVersion: z22.literal(CURRENT_AST_VERSION),
+  root: z22.unknown()
+}).openapi("RenderedAstEnvelope");
+var LooseRenderedAstRootSchema = z22.object({
+  type: z22.literal("root"),
+  children: z22.array(z22.unknown())
+}).openapi("LegacyRenderedAstRoot");
+var RenderedAstValueSchema = z22.union([RenderedAstEnvelopeOpenApiSchema, LooseRenderedAstRootSchema]);
+var RenderedAstArtifactKeySchema = z22.string().max(64);
+function unwrapRenderedAst(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "object") return void 0;
+  if (value.astVersion === CURRENT_AST_VERSION) {
+    const root = value.root;
+    return root === null ? void 0 : root;
+  }
+  if (value.type === "root" && Array.isArray(value.children)) {
+    return value;
+  }
+  return void 0;
+}
+
 // src/schemas/page.ts
-var PageGrantSchema = z22.enum(["1", "2", "3", "4"]).transform((val) => Number(val));
+var PageGrantSchema = z23.enum(["1", "2", "3", "4"]).transform((val) => Number(val));
 var PageGrantEnum = {
   PUBLIC: 1,
   RESTRICTED: 2,
   SPECIFIED: 3,
   OWNER: 4
 };
-var PageStatusSchema = z22.enum(["wip", "published", "deleted", "deprecated", "draft"]);
+var PageStatusSchema = z23.enum(["wip", "published", "deleted", "deprecated", "draft"]);
 var PageStatusEnum = {
   WIP: "wip",
   PUBLISHED: "published",
@@ -2163,43 +2530,43 @@ var PageStatusEnum = {
   DEPRECATED: "deprecated",
   DRAFT: "draft"
 };
-var PageTypeSchema = z22.enum(["portal", "user", "public"]);
+var PageTypeSchema = z23.enum(["portal", "user", "public"]);
 var PageTypeEnum = {
   PORTAL: "portal",
   USER: "user",
   PUBLIC: "public"
 };
-var PageUserSchema = z22.object({
-  _id: z22.string(),
-  id: z22.string().optional(),
+var PageUserSchema = z23.object({
+  _id: z23.string(),
+  id: z23.string().optional(),
   // for compatibility
-  username: z22.string(),
-  name: z22.string(),
-  email: z22.string().email(),
-  image: z22.string().nullable().optional(),
-  createdAt: z22.string()
-});
-var TocEntrySchema = z22.object({
-  level: z22.number().int().min(1).max(6),
-  text: z22.string(),
-  anchorId: z22.string()
-});
-var WikiLinkSchema = z22.object({
+  username: z23.string(),
+  name: z23.string(),
+  email: z23.string().email(),
+  image: z23.string().nullable().optional(),
+  createdAt: z23.string()
+});
+var TocEntrySchema = z23.object({
+  level: z23.number().int().min(1).max(6),
+  text: z23.string(),
+  anchorId: z23.string()
+});
+var WikiLinkSchema = z23.object({
   /** Verbatim source between the `[[` `]]` (no surrounding brackets). */
-  raw: z22.string(),
+  raw: z23.string(),
   /** Normalised target (left of the `|`, fragment trimmed for resolution). */
-  target: z22.string(),
+  target: z23.string(),
   /** Optional pipe-aliased display text (right of the `|`). */
-  displayText: z22.string().optional()
+  displayText: z23.string().optional()
 });
-var MentionSchema = z22.object({
-  username: z22.string()
+var MentionSchema = z23.object({
+  username: z23.string()
 });
-var RevisionMetaSchemaShape = z22.object({
-  toc: z22.array(TocEntrySchema).optional(),
-  wikiLinks: z22.array(WikiLinkSchema).optional(),
-  mentions: z22.array(MentionSchema).optional(),
-  codeBlockLanguages: z22.array(z22.string()).optional(),
+var RevisionMetaSchemaShape = z23.object({
+  toc: z23.array(TocEntrySchema).optional(),
+  wikiLinks: z23.array(WikiLinkSchema).optional(),
+  mentions: z23.array(MentionSchema).optional(),
+  codeBlockLanguages: z23.array(z23.string()).optional(),
   // feature-backlink-raw-space-metadata: raw destinations recovered by
   // `renderer/core/raw-space-links.ts` (`[label](/a b)` — a raw-space
   // absolute path CommonMark itself rejects as a link). Verbatim, NOT
@@ -2207,58 +2574,66 @@ var RevisionMetaSchemaShape = z22.object({
   // `stripFragmentAndQuery` -> `decodeLinkPath` pipeline the regex-based
   // extraction path uses. Mirrors `wikiLinks` above: pushed by the core
   // transform into `PipelineMetadata`, persisted verbatim on `revision.meta`.
-  rawSpaceLinks: z22.array(z22.string()).optional()
+  rawSpaceLinks: z23.array(z23.string()).optional()
 });
-var RevisionSchema = z22.object({
-  _id: z22.string(),
-  path: z22.string(),
-  body: z22.string(),
-  format: z22.string().default("markdown"),
+var RevisionSchema = z23.object({
+  _id: z23.string(),
+  path: z23.string(),
+  body: z23.string(),
+  format: z23.string().default("markdown"),
   author: PageUserSchema.nullable().optional(),
-  createdAt: z22.string(),
+  createdAt: z23.string(),
   meta: RevisionMetaSchemaShape.optional(),
-  // RFC-0002 Phase 3: transformed mdast (parse + core plugins +
-  // shiki) for the web client to render without re-parsing the body.
-  // Typed as opaque `unknown` because mdast is too deep / external-
-  // spec to maintain a strict Zod schema for. Only single-page detail
-  // (`getPage`) and single-revision detail (`getRevision`) emit it;
-  // list endpoints skip it for payload weight.
-  renderedAst: z22.unknown().optional(),
+  // RFC-0002 Phase 3 / RFC-0023: transformed mdast. Requests that
+  // declare `X-Crowi-Ast-Version: 1` receive the typed envelope
+  // (`{astVersion, root}`); everyone else (including the web,
+  // permanently) receives the stored bare mdast `Root` verbatim and
+  // unvalidated — see `schemas/rendered-ast.ts` for the full contract.
+  // Only single-page detail (`getPage`), the listPages portal document
+  // and single-revision detail (`getRevision`) emit it; list rows skip
+  // it for payload weight.
+  renderedAst: RenderedAstValueSchema.optional(),
+  // RFC-0023 (design doc §14): identity of the served AST artifact —
+  // `rendererVersion` for a verbatim stored AST, a per-response nonce
+  // when the served tree differs from the stored one (pending-marker
+  // retry / freshness-mismatch recompute). The web render memo keys on
+  // `[revisionId, renderedAstArtifactKey]`.
+  renderedAstArtifactKey: RenderedAstArtifactKeySchema.optional(),
   // RFC-0002 round 3.1: semver of the renderer pipeline that produced
   // `renderedAst`. The read path uses this to detect stale entries
   // (rebuilt by `renderer:rebuild` once RFC-0008 lands). Absent on
   // revisions saved before this field was introduced.
-  rendererVersion: z22.string().optional(),
+  rendererVersion: z23.string().optional(),
   // RFC-0003 collaborative-save fields. All optional; v1.x revisions
   // emit none of them. See `packages/api/src/models/revision.ts` for
   // semantics. The list-page endpoint currently does not surface
   // these — they only appear on the Phase 5+ checkpoint Revisions
   // produced by Hocuspocus and on the single-revision detail route.
-  parentRevisionId: z22.string().nullable().optional(),
+  parentRevisionId: z23.string().nullable().optional(),
   type: RevisionTypeSchema.optional(),
-  savedBy: z22.union([z22.string(), PageUserSchema]).nullable().optional(),
-  contributors: z22.array(z22.union([z22.string(), PageUserSchema])).optional(),
-  message: z22.string().optional(),
+  savedBy: z23.union([z23.string(), PageUserSchema]).nullable().optional(),
+  contributors: z23.array(z23.union([z23.string(), PageUserSchema])).optional(),
+  message: z23.string().optional(),
   // RFC-0010 — edit channel ('web' | 'oauth' | 'pat'); absent on
   // pre-RFC-0010 / collaborative / browser revisions.
-  editVia: z22.enum(["web", "oauth", "pat"]).optional()
-});
-var PageExtendedSchema = z22.record(z22.string(), z22.any()).optional();
-var PageSchema = z22.object({
-  _id: z22.string(),
-  path: z22.string(),
-  revision: z22.union([z22.string(), RevisionSchema]).optional(),
-  redirectTo: z22.string().nullable().optional(),
+  editVia: z23.enum(["web", "oauth", "pat"]).optional()
+});
+var PageExtendedSchema = z23.record(z23.string(), z23.any()).optional();
+var PageSchema = z23.object({
+  _id: z23.string(),
+  path: z23.string(),
+  revision: z23.union([z23.string(), RevisionSchema]).optional(),
+  redirectTo: z23.string().nullable().optional(),
   status: PageStatusSchema.nullable().optional(),
-  grant: z22.number().optional(),
-  grantedUsers: z22.array(z22.string()).optional(),
-  creator: z22.union([z22.string(), PageUserSchema]).nullable().optional(),
-  lastUpdateUser: z22.union([z22.string(), PageUserSchema]).nullable().optional(),
-  liker: z22.array(z22.string()).optional(),
-  commentCount: z22.number().default(0),
+  grant: z23.number().optional(),
+  grantedUsers: z23.array(z23.string()).optional(),
+  creator: z23.union([z23.string(), PageUserSchema]).nullable().optional(),
+  lastUpdateUser: z23.union([z23.string(), PageUserSchema]).nullable().optional(),
+  liker: z23.array(z23.string()).optional(),
+  commentCount: z23.number().default(0),
   extended: PageExtendedSchema,
-  createdAt: z22.string(),
-  updatedAt: z22.string().optional(),
+  createdAt: z23.string(),
+  updatedAt: z23.string().optional(),
   // RFC-0003 collaborative-edit fields. All optional; `null` is the
   // "no live state yet" value. Existing read endpoints (list /
   // detail) do not currently emit these — the contract is widened
@@ -2266,32 +2641,32 @@ var PageSchema = z22.object({
   // bump. `yjsState` is intentionally omitted from the contract:
   // the binary blob lives only inside Hocuspocus and never crosses
   // the HTTP API.
-  currentRevision: z22.string().nullable().optional(),
-  yjsCheckpointAt: z22.string().nullable().optional(),
+  currentRevision: z23.string().nullable().optional(),
+  yjsCheckpointAt: z23.string().nullable().optional(),
   // dynamic fields
-  latestRevision: z22.string().optional(),
-  likerCount: z22.number().optional(),
-  seenUsersCount: z22.number().optional()
+  latestRevision: z23.string().optional(),
+  likerCount: z23.number().optional(),
+  seenUsersCount: z23.number().optional()
 });
 var PageWithRevisionSchema = PageSchema.extend({
   revision: RevisionSchema,
   creator: PageUserSchema.nullable().optional(),
   lastUpdateUser: PageUserSchema.nullable().optional()
 });
-var GetPageRequestSchema = z22.object({
-  path: z22.string().optional(),
-  page_id: z22.string().optional(),
-  revision_id: z22.string().optional()
+var GetPageRequestSchema = z23.object({
+  path: z23.string().optional(),
+  page_id: z23.string().optional(),
+  revision_id: z23.string().optional()
 });
-var GetPageResponseSchema = z22.object({
+var GetPageResponseSchema = z23.object({
   page: PageWithRevisionSchema
 });
-var ClaimPageLinkAccessResponseSchema = GetPageResponseSchema.extend({ granted: z22.boolean() });
-var ListPagesRequestSchema = z22.object({
-  path: z22.string().optional(),
-  user: z22.string().optional(),
-  limit: z22.coerce.number().optional().default(50),
-  offset: z22.coerce.number().optional().default(0),
+var ClaimPageLinkAccessResponseSchema = GetPageResponseSchema.extend({ granted: z23.boolean() });
+var ListPagesRequestSchema = z23.object({
+  path: z23.string().optional(),
+  user: z23.string().optional(),
+  limit: z23.coerce.number().optional().default(50),
+  offset: z23.coerce.number().optional().default(0),
   // NOT `z.coerce.boolean()`: that uses JS `Boolean(v)`, so the string
   // `"false"` (which is how the web client serialises `false` on the
   // query string) coerces to `true`. That silently flipped
@@ -2299,25 +2674,25 @@ var ListPagesRequestSchema = z22.object({
   // filter and leak other users' drafts. Parse the string explicitly so
   // only `"true"` / `true` is truthy; anything else (incl. `"false"`,
   // absent) is `false`.
-  include_deleted: z22.preprocess((v) => v === true || v === "true" || v === "1", z22.boolean()).optional().default(false),
+  include_deleted: z23.preprocess((v) => v === true || v === "true" || v === "1", z23.boolean()).optional().default(false),
   // Sort field + direction for the listing. Defaults preserve the legacy
   // "newest-updated first" order so existing callers are unaffected.
   // `path` sorts alphabetically by full page path (≈ name order).
-  sort: z22.enum(["updatedAt", "createdAt", "path"]).optional().default("updatedAt"),
-  order: z22.enum(["asc", "desc"]).optional().default("desc"),
+  sort: z23.enum(["updatedAt", "createdAt", "path"]).optional().default("updatedAt"),
+  order: z23.enum(["asc", "desc"]).optional().default("desc"),
   // When listing a portal path (`/foo/`), open the portal document at this
   // past revision so the catch-all can mirror `?revision_id=` on portals.
   // Only the `portalPage` is rewound — the child rows always reflect the
   // latest. Absent for normal listings.
-  revision_id: z22.string().optional()
+  revision_id: z23.string().optional()
 });
-var PagerSchema = z22.object({
-  prev: z22.number().nullable(),
-  next: z22.number().nullable(),
-  offset: z22.number()
+var PagerSchema = z23.object({
+  prev: z23.number().nullable(),
+  next: z23.number().nullable(),
+  offset: z23.number()
 });
-var ListPagesResponseSchema = z22.object({
-  pages: z22.array(PageSchema),
+var ListPagesResponseSchema = z23.object({
+  pages: z23.array(PageSchema),
   pager: PagerSchema,
   portalPage: PageSchema.nullable().optional(),
   // When listing a portal path (`/foo/`) that has NO portal document of
@@ -2327,144 +2702,151 @@ var ListPagesResponseSchema = z22.object({
   // (feature-update-pages-list-ux §4). Mutually exclusive with `portalPage`
   // — only set when `portalPage` is null. Absent / null for ordinary
   // listings.
-  contentPage: PageSchema.nullable().optional()
+  contentPage: PageSchema.nullable().optional(),
+  // feature-profile-stats-and-page-total — the exact count of the viewer-
+  // visible set `pages` pages from (i.e. matching `pages`' visibility
+  // conditions, independent of `limit`/`offset`, and excluding whichever
+  // ids `portalPage`/`contentPage` already removed from `pages`). Not part
+  // of `PagerSchema` — mirrors `ListUsersResponseSchema.total`, a sibling
+  // top-level field alongside `pager`.
+  total: z23.number()
 });
-var PageChildSegmentSchema = z22.object({
+var PageChildSegmentSchema = z23.object({
   // The bare segment name immediately under the queried path
   // (e.g. 'rfc' for /crowi/rfc/... when querying /crowi/).
-  segment: z22.string(),
+  segment: z23.string(),
   // Portal-style path for this segment (always trailing-slashed),
   // e.g. '/crowi/rfc/'. Drop the trailing slash for the page path when
   // the segment is a leaf page (see `isPage`).
-  path: z22.string(),
+  path: z23.string(),
   // True when a real page is saved at the segment path itself
   // (e.g. `/crowi/rfc`, no trailing slash) — i.e. the segment is a
   // navigable page, not only an inferred directory.
-  isPage: z22.boolean(),
+  isPage: z23.boolean(),
   // True when a real portal page is saved at `path` (→ compass icon).
-  hasPortal: z22.boolean(),
+  hasPortal: z23.boolean(),
   // Number of descendant content pages strictly under this segment
   // (excludes the segment's own page / portal docs). A rough "how much
   // lives here" hint; > 0 means the segment is an expandable directory.
-  count: z22.number(),
+  count: z23.number(),
   // ISO8601 timestamp of the segment's representative page: the segment's
   // own page when `isPage` is true, otherwise the most-recently-updated
   // descendant (including the portal doc itself). `null` when no
   // representative page's timestamp could be derived. Optional so
   // existing clients (web SidebarTree) that don't read it keep working
   // unchanged — additive contract extension, feature-child-segments-metadata.
-  lastUpdatedAt: z22.string().nullable().optional(),
+  lastUpdatedAt: z23.string().nullable().optional(),
   // The representative page's last updater (same page as `lastUpdatedAt`
   // above). `null` when the updater can't be resolved (e.g. a deleted
   // user, or legacy rows predating `lastUpdateUser`).
   updater: PageUserSchema.nullable().optional()
 });
-var ListPageChildrenRequestSchema = z22.object({
+var ListPageChildrenRequestSchema = z23.object({
   // Portal path to list children of. Trailing slash optional — the
   // handler normalises it. '/' lists the top-level segments.
-  path: z22.string()
+  path: z23.string()
 });
-var ListPageChildrenResponseSchema = z22.object({
+var ListPageChildrenResponseSchema = z23.object({
   // Sorted alphabetically by segment.
-  children: z22.array(PageChildSegmentSchema)
-});
-var CreatePageRequestSchema = z22.object({
-  path: z22.string(),
-  body: z22.string(),
-  grant: z22.number().optional()
-});
-var UpdatePageRequestSchema = z22.object({
-  page_id: z22.string(),
-  body: z22.string(),
-  revision_id: z22.string().optional(),
-  grant: z22.number().optional()
-});
-var RevertToRevisionRequestSchema = z22.object({
-  page_id: z22.string(),
-  revision_id: z22.string()
-});
-var SetPageGrantRequestSchema = z22.object({
-  page_id: z22.string(),
-  grant: z22.number().int()
-});
-var RenamePageRequestSchema = z22.object({
-  page_id: z22.string(),
-  new_path: z22.string(),
-  revision_id: z22.string().optional(),
-  create_redirect: z22.boolean().optional(),
+  children: z23.array(PageChildSegmentSchema)
+});
+var CreatePageRequestSchema = z23.object({
+  path: z23.string(),
+  body: z23.string(),
+  grant: z23.number().optional()
+});
+var UpdatePageRequestSchema = z23.object({
+  page_id: z23.string(),
+  body: z23.string(),
+  revision_id: z23.string().optional(),
+  grant: z23.number().optional()
+});
+var RevertToRevisionRequestSchema = z23.object({
+  page_id: z23.string(),
+  revision_id: z23.string()
+});
+var SetPageGrantRequestSchema = z23.object({
+  page_id: z23.string(),
+  grant: z23.number().int()
+});
+var RenamePageRequestSchema = z23.object({
+  page_id: z23.string(),
+  new_path: z23.string(),
+  revision_id: z23.string().optional(),
+  create_redirect: z23.boolean().optional(),
   // When true, rename the page together with its whole (grant-visible)
   // descendant subtree (renameTree) instead of just the single page.
   // Defaults to false — the single-page rename behaviour.
-  include_descendants: z22.boolean().optional()
+  include_descendants: z23.boolean().optional()
 });
-var RenamePageResponseSchema = z22.object({
+var RenamePageResponseSchema = z23.object({
   page: PageSchema,
-  renamed_count: z22.number()
-});
-var RenameTreeErrorSchema = z22.object({
-  error: z22.object({
-    code: z22.literal("PAGE_RENAME_TREE_FAILED"),
-    message: z22.string(),
-    conflicts: z22.array(
-      z22.object({
-        path: z22.string(),
-        reasons: z22.array(z22.string())
+  renamed_count: z23.number()
+});
+var RenameTreeErrorSchema = z23.object({
+  error: z23.object({
+    code: z23.literal("PAGE_RENAME_TREE_FAILED"),
+    message: z23.string(),
+    conflicts: z23.array(
+      z23.object({
+        path: z23.string(),
+        reasons: z23.array(z23.string())
       })
     ),
     // True when the failure happened after some pages were already moved
     // (non-transactional best-effort). When omitted/false the failure was
     // detected up-front and nothing was moved.
-    partial: z22.boolean().optional()
+    partial: z23.boolean().optional()
   })
 });
-var RenameSubtreeRequestSchema = z22.object({
-  old_path: z22.string(),
-  new_path: z22.string(),
-  create_redirect: z22.boolean().optional()
+var RenameSubtreeRequestSchema = z23.object({
+  old_path: z23.string(),
+  new_path: z23.string(),
+  create_redirect: z23.boolean().optional()
 });
-var RenameSubtreeResponseSchema = z22.object({
-  renamed_count: z22.number()
+var RenameSubtreeResponseSchema = z23.object({
+  renamed_count: z23.number()
 });
-var PageNotFoundErrorSchema = z22.object({
-  error: z22.object({
-    code: z22.literal("PAGE_NOT_FOUND"),
-    message: z22.literal("Page not found")
+var PageNotFoundErrorSchema = z23.object({
+  error: z23.object({
+    code: z23.literal("PAGE_NOT_FOUND"),
+    message: z23.literal("Page not found")
   })
 });
-var PageNotGrantedErrorSchema = z22.object({
-  error: z22.object({
-    code: z22.literal("PAGE_NOT_GRANTED"),
-    message: z22.literal("Page is not granted for the user")
+var PageNotGrantedErrorSchema = z23.object({
+  error: z23.object({
+    code: z23.literal("PAGE_NOT_GRANTED"),
+    message: z23.literal("Page is not granted for the user")
   })
 });
-var PageRevisionErrorSchema = z22.object({
-  error: z22.object({
-    code: z22.literal("PAGE_REVISION_ERROR"),
-    message: z22.string()
+var PageRevisionErrorSchema = z23.object({
+  error: z23.object({
+    code: z23.literal("PAGE_REVISION_ERROR"),
+    message: z23.string()
   })
 });
-var SeenPageRequestSchema = z22.object({
-  page_id: z22.string()
+var SeenPageRequestSchema = z23.object({
+  page_id: z23.string()
 });
-var SeenUsersResponseSchema = z22.object({
-  seenUsers: z22.array(UserPublicSchema),
-  seenUsersCount: z22.number()
+var SeenUsersResponseSchema = z23.object({
+  seenUsers: z23.array(UserPublicSchema),
+  seenUsersCount: z23.number()
 });
-var GetSeenUsersRequestSchema = z22.object({
-  page_id: z22.string(),
+var GetSeenUsersRequestSchema = z23.object({
+  page_id: z23.string(),
   // Optional cap on returned `seenUsers`. `seenUsersCount` always reflects
   // the full count regardless of `limit`. Omit for the full list.
-  limit: z22.coerce.number().int().positive().optional()
+  limit: z23.coerce.number().int().positive().optional()
 });
-var GetWatchStatusRequestSchema = z22.object({
-  page_id: z22.string()
+var GetWatchStatusRequestSchema = z23.object({
+  page_id: z23.string()
 });
-var WatchStatusResponseSchema = z22.object({
-  watching: z22.boolean()
+var WatchStatusResponseSchema = z23.object({
+  watching: z23.boolean()
 });
-var SetWatchStatusRequestSchema = z22.object({
-  page_id: z22.string(),
-  watching: z22.boolean()
+var SetWatchStatusRequestSchema = z23.object({
+  page_id: z23.string(),
+  watching: z23.boolean()
 });
 
 // src/contracts/backlink.ts
@@ -2504,88 +2886,95 @@ var backlinkRoutes = {
 import { createRoute as createRoute13 } from "@hono/zod-openapi";
 
 // src/schemas/bookmark.ts
-import { z as z23 } from "@hono/zod-openapi";
-var BookmarkSchema = z23.object({
-  _id: z23.string(),
+import { z as z24 } from "@hono/zod-openapi";
+var BookmarkSchema = z24.object({
+  _id: z24.string(),
   page: PageSchema,
-  user: z23.union([z23.string(), UserPublicSchema]),
-  createdAt: z23.string()
+  user: z24.union([z24.string(), UserPublicSchema]),
+  createdAt: z24.string()
 });
-var GetBookmarkRequestSchema = z23.object({
-  page_id: z23.string()
+var GetBookmarkRequestSchema = z24.object({
+  page_id: z24.string()
 });
-var BookmarkResponseSchema = z23.object({
+var BookmarkResponseSchema = z24.object({
   bookmark: BookmarkSchema.nullable()
 });
-var ListMyBookmarksResponseSchema = z23.object({
-  bookmarks: z23.array(BookmarkSchema),
+var ListMyBookmarksResponseSchema = z24.object({
+  bookmarks: z24.array(BookmarkSchema),
   pager: PagerSchema,
-  total: z23.number()
+  total: z24.number()
 });
-var AddBookmarkRequestSchema = z23.object({
-  page_id: z23.string()
+var AddBookmarkRequestSchema = z24.object({
+  page_id: z24.string()
 });
-var RemoveBookmarkRequestSchema = z23.object({
-  page_id: z23.string()
+var RemoveBookmarkRequestSchema = z24.object({
+  page_id: z24.string()
 });
-var RemoveBookmarkResponseSchema = z23.object({
-  ok: z23.literal(true)
+var RemoveBookmarkResponseSchema = z24.object({
+  ok: z24.literal(true)
 });
 
 // src/schemas/user.ts
-import { z as z24 } from "@hono/zod-openapi";
-var UserStatusSchema = z24.enum(["1", "2", "3", "4", "5"]).transform((val) => Number(val));
+import { z as z25 } from "@hono/zod-openapi";
+var UserStatusSchema = z25.enum(["1", "2", "3", "4", "5"]).transform((val) => Number(val));
 var UserStatusEnum = UserPublicStatus;
-var UserLanguageSchema = z24.enum(["en", "ja"]);
-var PaginationRequestSchema = z24.object({
-  limit: z24.coerce.number().optional().default(50),
-  offset: z24.coerce.number().optional().default(0)
+var UserLanguageSchema = z25.enum(["en", "ja"]);
+var PaginationRequestSchema = z25.object({
+  limit: z25.coerce.number().optional().default(50),
+  offset: z25.coerce.number().optional().default(0)
 });
-var UserListItemSchema = z24.object({
-  _id: z24.string(),
-  username: z24.string(),
-  name: z24.string(),
-  image: z24.string().nullable().optional()
+var UserListItemSchema = z25.object({
+  _id: z25.string(),
+  username: z25.string(),
+  name: z25.string(),
+  image: z25.string().nullable().optional()
 });
-var ListUsersRequestSchema = z24.object({
-  q: z24.string().optional(),
+var ListUsersRequestSchema = z25.object({
+  q: z25.string().optional(),
   // Cap the page size so a client can't request the whole user table in one
   // unbounded find+sort (mirrors the page-list `limit` guard).
-  limit: z24.coerce.number().int().min(1).max(100).optional().default(24),
-  offset: z24.coerce.number().int().min(0).optional().default(0)
+  limit: z25.coerce.number().int().min(1).max(100).optional().default(24),
+  offset: z25.coerce.number().int().min(0).optional().default(0)
 });
-var UserSubpagesRequestSchema = z24.object({
-  limit: z24.coerce.number().int().min(1).max(50).optional().default(30),
-  offset: z24.coerce.number().int().min(0).optional().default(0)
+var UserSubpagesRequestSchema = z25.object({
+  limit: z25.coerce.number().int().min(1).max(50).optional().default(30),
+  offset: z25.coerce.number().int().min(0).optional().default(0)
 });
-var ListUsersResponseSchema = z24.object({
-  users: z24.array(UserListItemSchema),
+var ListUsersResponseSchema = z25.object({
+  users: z25.array(UserListItemSchema),
   pager: PagerSchema,
-  total: z24.number()
+  total: z25.number()
 });
-var UserPageResponseSchema = z24.object({
+var UserPageResponseSchema = z25.object({
   user: UserPublicSchema,
   // Page statistics
-  createdPagesCount: z24.number(),
-  bookmarksCount: z24.number(),
+  createdPagesCount: z25.number(),
+  bookmarksCount: z25.number(),
+  // feature-profile-stats-and-page-total — the target user's OWN actions:
+  // pages they liked (`Page.liker` contains their id) and comments they
+  // wrote (`Comment.creator` is their id). NOT activity their own pages
+  // received from others, and not re-filtered by the viewer's grants —
+  // see the spec's "プロフィール統計の主語と API 契約" section.
+  likesCount: z25.number(),
+  commentsCount: z25.number(),
   // Optionally include recent items for initial display
-  recentPages: z24.array(PageSchema).optional(),
-  recentBookmarks: z24.array(BookmarkSchema).optional()
+  recentPages: z25.array(PageSchema).optional(),
+  recentBookmarks: z25.array(BookmarkSchema).optional()
 });
-var UserBookmarksResponseSchema = z24.object({
-  bookmarks: z24.array(BookmarkSchema),
+var UserBookmarksResponseSchema = z25.object({
+  bookmarks: z25.array(BookmarkSchema),
   pager: PagerSchema,
-  total: z24.number()
+  total: z25.number()
 });
-var UserPagesResponseSchema = z24.object({
-  pages: z24.array(PageSchema),
+var UserPagesResponseSchema = z25.object({
+  pages: z25.array(PageSchema),
   pager: PagerSchema,
-  total: z24.number()
+  total: z25.number()
 });
-var UserNotFoundErrorSchema = z24.object({
-  error: z24.object({
-    code: z24.literal("USER_NOT_FOUND"),
-    message: z24.literal("User not found")
+var UserNotFoundErrorSchema = z25.object({
+  error: z25.object({
+    code: z25.literal("USER_NOT_FOUND"),
+    message: z25.literal("User not found")
   })
 });
 
@@ -2713,51 +3102,51 @@ var bookmarkRoutes = {
 import { createRoute as createRoute14 } from "@hono/zod-openapi";
 
 // src/schemas/comment.ts
-import { z as z25 } from "@hono/zod-openapi";
-var CommentSchema = z25.object({
-  _id: z25.string(),
-  page: z25.string(),
+import { z as z26 } from "@hono/zod-openapi";
+var CommentSchema = z26.object({
+  _id: z26.string(),
+  page: z26.string(),
   // creator is populated to a user object on the API side; allow string fallback for safety
-  creator: z25.union([z25.string(), PageUserSchema]).nullable(),
-  revision: z25.string(),
-  comment: z25.string(),
-  commentPosition: z25.number().default(-1),
-  createdAt: z25.string()
-});
-var ListCommentsRequestSchema = z25.object({
-  page_id: z25.string().optional(),
-  revision_id: z25.string().optional()
-});
-var ListCommentsResponseSchema = z25.object({
-  comments: z25.array(CommentSchema)
-});
-var AddCommentRequestSchema = z25.object({
-  page_id: z25.string().min(1, "page_id is required"),
-  revision_id: z25.string().min(1, "revision_id is required"),
-  comment: z25.string().min(1, "comment is required"),
-  comment_position: z25.number().int().optional()
-});
-var AddCommentResponseSchema = z25.object({
+  creator: z26.union([z26.string(), PageUserSchema]).nullable(),
+  revision: z26.string(),
+  comment: z26.string(),
+  commentPosition: z26.number().default(-1),
+  createdAt: z26.string()
+});
+var ListCommentsRequestSchema = z26.object({
+  page_id: z26.string().optional(),
+  revision_id: z26.string().optional()
+});
+var ListCommentsResponseSchema = z26.object({
+  comments: z26.array(CommentSchema)
+});
+var AddCommentRequestSchema = z26.object({
+  page_id: z26.string().min(1, "page_id is required"),
+  revision_id: z26.string().min(1, "revision_id is required"),
+  comment: z26.string().min(1, "comment is required"),
+  comment_position: z26.number().int().optional()
+});
+var AddCommentResponseSchema = z26.object({
   comment: CommentSchema,
-  newlyWatching: z25.boolean()
+  newlyWatching: z26.boolean()
 });
-var DeleteCommentRequestSchema = z25.object({
-  comment_id: z25.string().min(1, "comment_id is required"),
-  page_id: z25.string().min(1, "page_id is required")
+var DeleteCommentRequestSchema = z26.object({
+  comment_id: z26.string().min(1, "comment_id is required"),
+  page_id: z26.string().min(1, "page_id is required")
 });
-var DeleteCommentResponseSchema = z25.object({
-  ok: z25.literal(true)
+var DeleteCommentResponseSchema = z26.object({
+  ok: z26.literal(true)
 });
-var CommentNotFoundErrorSchema = z25.object({
-  error: z25.object({
-    code: z25.literal("COMMENT_NOT_FOUND"),
-    message: z25.literal("Comment not found")
+var CommentNotFoundErrorSchema = z26.object({
+  error: z26.object({
+    code: z26.literal("COMMENT_NOT_FOUND"),
+    message: z26.literal("Comment not found")
   })
 });
-var CommentInvalidRequestErrorSchema = z25.object({
-  error: z25.object({
-    code: z25.literal("INVALID_REQUEST"),
-    message: z25.string()
+var CommentInvalidRequestErrorSchema = z26.object({
+  error: z26.object({
+    code: z26.literal("INVALID_REQUEST"),
+    message: z26.string()
   })
 });
 
@@ -2861,48 +3250,48 @@ var commentRoutes = {
 };
 
 // src/contracts/draft.ts
-import { createRoute as createRoute15, z as z27 } from "@hono/zod-openapi";
+import { createRoute as createRoute15, z as z28 } from "@hono/zod-openapi";
 
 // src/schemas/draft.ts
-import { z as z26 } from "@hono/zod-openapi";
-var CreateDraftRequestSchema = z26.object({
-  path: z26.string().min(1),
-  initialBody: z26.string().optional()
+import { z as z27 } from "@hono/zod-openapi";
+var CreateDraftRequestSchema = z27.object({
+  path: z27.string().min(1),
+  initialBody: z27.string().optional()
 });
-var CreateDraftResponseSchema = z26.object({
-  pageId: z26.string()
+var CreateDraftResponseSchema = z27.object({
+  pageId: z27.string()
 });
-var DraftConflictOwnerSchema = z26.object({
-  id: z26.string(),
-  username: z26.string(),
-  displayName: z26.string()
+var DraftConflictOwnerSchema = z27.object({
+  id: z27.string(),
+  username: z27.string(),
+  displayName: z27.string()
 });
-var DraftPathConflictErrorSchema = z26.object({
-  error: z26.literal("path_taken_by_draft"),
+var DraftPathConflictErrorSchema = z27.object({
+  error: z27.literal("path_taken_by_draft"),
   owner: DraftConflictOwnerSchema,
-  message: z26.string()
+  message: z27.string()
 });
-var DraftBadRequestErrorSchema = z26.object({
-  error: z26.enum(["invalid_path", "path_taken"]),
-  message: z26.string()
+var DraftBadRequestErrorSchema = z27.object({
+  error: z27.enum(["invalid_path", "path_taken"]),
+  message: z27.string()
 });
-var DraftNotFoundErrorSchema = z26.object({
-  error: z26.literal("draft_not_found"),
-  message: z26.string()
+var DraftNotFoundErrorSchema = z27.object({
+  error: z27.literal("draft_not_found"),
+  message: z27.string()
 });
-var DraftSummarySchema = z26.object({
-  pageId: z26.string(),
-  path: z26.string(),
-  createdAt: z26.string(),
-  updatedAt: z26.string()
+var DraftSummarySchema = z27.object({
+  pageId: z27.string(),
+  path: z27.string(),
+  createdAt: z27.string(),
+  updatedAt: z27.string()
 });
-var ListDraftsResponseSchema = z26.object({
-  drafts: z26.array(DraftSummarySchema)
+var ListDraftsResponseSchema = z27.object({
+  drafts: z27.array(DraftSummarySchema)
 });
 
 // src/contracts/draft.ts
-var DraftIdPathParamsSchema = z27.object({
-  id: z27.string().openapi({ description: "Draft page id (24-char hex ObjectId)", example: "507f1f77bcf86cd799439011" })
+var DraftIdPathParamsSchema = z28.object({
+  id: z28.string().openapi({ description: "Draft page id (24-char hex ObjectId)", example: "507f1f77bcf86cd799439011" })
 });
 var createDraftRoute = createRoute15({
   method: "post",
@@ -2985,22 +3374,22 @@ var draftRoutes = {
 import { createRoute as createRoute16 } from "@hono/zod-openapi";
 
 // src/schemas/installer.ts
-import { z as z28 } from "@hono/zod-openapi";
-var InstallerStatusResponseSchema = z28.object({
-  status: z28.enum(["installer_required", "already_installed"])
-});
-var CreateAdminRequestSchema = z28.object({
-  registerForm: z28.object({
-    username: z28.string().min(1).regex(/^[\da-zA-Z\-_.]+$/, "username may only contain letters, digits, hyphens, underscores, and dots"),
-    name: z28.string().min(1),
-    email: z28.string().email(),
-    password: z28.string().min(6).regex(/^[\x20-\x7F]{6,}$/, "password must be 6+ printable ASCII characters")
+import { z as z29 } from "@hono/zod-openapi";
+var InstallerStatusResponseSchema = z29.object({
+  status: z29.enum(["installer_required", "already_installed"])
+});
+var CreateAdminRequestSchema = z29.object({
+  registerForm: z29.object({
+    username: z29.string().min(1).regex(/^[\da-zA-Z\-_.]+$/, "username may only contain letters, digits, hyphens, underscores, and dots"),
+    name: z29.string().min(1),
+    email: z29.string().email(),
+    password: z29.string().min(6).regex(/^[\x20-\x7F]{6,}$/, "password must be 6+ printable ASCII characters")
   })
 });
-var CreateAdminResponseSchema = z28.object({
-  status: z28.enum(["ok", "error"]),
-  message: z28.string().optional(),
-  errors: z28.array(z28.string()).optional()
+var CreateAdminResponseSchema = z29.object({
+  status: z29.enum(["ok", "error"]),
+  message: z29.string().optional(),
+  errors: z29.array(z29.string()).optional()
 });
 
 // src/contracts/installer.ts
@@ -3072,84 +3461,84 @@ var createAdminRoute = createRoute16({
 var installerRoutes = { getInstallerStatusRoute, createAdminRoute };
 
 // src/contracts/me.ts
-import { createRoute as createRoute17, z as z30 } from "@hono/zod-openapi";
+import { createRoute as createRoute17, z as z31 } from "@hono/zod-openapi";
 
 // src/schemas/me.ts
-import { z as z29 } from "@hono/zod-openapi";
-var LanguageSchema = z29.enum(["en", "ja"]);
-var ThemeSchema = z29.enum(["system", "light", "dark"]);
-var UserProfileResponseSchema = z29.object({
-  id: z29.string(),
-  username: z29.string(),
-  name: z29.string(),
-  email: z29.string().email(),
+import { z as z30 } from "@hono/zod-openapi";
+var LanguageSchema = z30.enum(["en", "ja"]);
+var ThemeSchema = z30.enum(["system", "light", "dark"]);
+var UserProfileResponseSchema = z30.object({
+  id: z30.string(),
+  username: z30.string(),
+  name: z30.string(),
+  email: z30.string().email(),
   lang: LanguageSchema,
   theme: ThemeSchema,
-  image: z29.string().nullable(),
-  introduction: z29.string().optional(),
-  hasPassword: z29.boolean(),
-  createdAt: z29.string(),
+  image: z30.string().nullable(),
+  introduction: z30.string().optional(),
+  hasPassword: z30.boolean(),
+  createdAt: z30.string(),
   /**
    * True when the profile update requested a new email that is awaiting
    * confirmation: the stored `email` is unchanged and a confirmation
    * link was sent to the new address.
    */
-  emailChangePending: z29.boolean().optional()
+  emailChangePending: z30.boolean().optional()
 });
-var UpdateProfileRequestSchema = z29.object({
-  userForm: z29.object({
-    name: z29.string().min(1, "Name is required"),
-    email: z29.string().email("Invalid email format"),
+var UpdateProfileRequestSchema = z30.object({
+  userForm: z30.object({
+    name: z30.string().min(1, "Name is required"),
+    email: z30.string().email("Invalid email format"),
     lang: LanguageSchema
   })
 });
-var UpdateThemeRequestSchema = z29.object({
+var UpdateThemeRequestSchema = z30.object({
   theme: ThemeSchema
 });
-var ThemeUpdateResponseSchema = z29.object({
-  status: z29.literal("ok"),
+var ThemeUpdateResponseSchema = z30.object({
+  status: z30.literal("ok"),
   theme: ThemeSchema
 });
-var PictureUploadResponseSchema = z29.object({
-  status: z29.boolean(),
-  url: z29.string().optional(),
-  message: z29.string().optional()
+var PictureUploadResponseSchema = z30.object({
+  status: z30.boolean(),
+  url: z30.string().optional(),
+  message: z30.string().optional()
 });
-var SuccessResponseSchema = z29.object({
-  status: z29.literal("ok"),
-  message: z29.string().optional()
+var SuccessResponseSchema = z30.object({
+  status: z30.literal("ok"),
+  message: z30.string().optional()
 });
-var ProfileErrorResponseSchema = z29.object({
-  status: z29.literal("error"),
+var ProfileErrorResponseSchema = z30.object({
+  status: z30.literal("error"),
   /** Stable code so the web can localize the message (e.g. EMAIL_TAKEN). */
-  code: z29.string().optional(),
-  message: z29.string().optional(),
-  errors: z29.array(z29.string()).optional()
+  code: z30.string().optional(),
+  message: z30.string().optional(),
+  errors: z30.array(z30.string()).optional()
 });
 var PASSWORD_REGEX = /^(?=.*[a-zA-Z])(?=.*\d)(?=.*[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?`~])[a-zA-Z\d!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?`~]+$/;
-var UpdatePasswordRequestSchema = z29.object({
-  oldPassword: z29.string().optional(),
-  newPassword: z29.string().min(8, "Password must be at least 8 characters").max(100, "Password must be at most 100 characters").regex(PASSWORD_REGEX, "Password must contain at least one letter, one digit, and one special character"),
-  newPasswordConfirm: z29.string()
+var UpdatePasswordRequestSchema = z30.object({
+  oldPassword: z30.string().optional(),
+  newPassword: z30.string().min(8, "Password must be at least 8 characters").max(100, "Password must be at most 100 characters").regex(PASSWORD_REGEX, "Password must contain at least one letter, one digit, and one special character"),
+  newPasswordConfirm: z30.string()
 }).refine((data) => data.newPassword === data.newPasswordConfirm, {
   message: "Passwords do not match",
   path: ["newPasswordConfirm"]
 });
-var PasswordUpdateSuccessSchema = z29.object({
-  status: z29.literal("ok"),
-  message: z29.string(),
-  accessToken: z29.string(),
-  refreshToken: z29.string(),
+var PasswordUpdateSuccessSchema = z30.object({
+  status: z30.literal("ok"),
+  message: z30.string(),
+  accessToken: z30.string(),
+  refreshToken: z30.string(),
   /** Access-token lifetime in seconds. */
-  expiresIn: z29.number()
+  expiresIn: z30.number()
 });
-var PasswordErrorResponseSchema = z29.object({
-  status: z29.literal("error"),
-  message: z29.string(),
-  errors: z29.array(z29.string()).optional()
+var PasswordErrorResponseSchema = z30.object({
+  status: z30.literal("error"),
+  message: z30.string(),
+  errors: z30.array(z30.string()).optional()
 });
-var RecentlyViewedPagesResponseSchema = z29.object({
-  pages: z29.array(PageSchema)
+var RecentlyViewedPagesResponseSchema = z30.object({
+  pages: z30.array(PageSchema)
 });
 
 // src/contracts/me.ts
@@ -3232,8 +3621,8 @@ var uploadPictureRoute = createRoute17({
     body: {
       content: {
         "multipart/form-data": {
-          schema: z30.object({
-            file: z30.any().optional().describe("Profile picture file")
+          schema: z31.object({
+            file: z31.any().optional().describe("Profile picture file")
           })
         }
       }
@@ -3333,37 +3722,37 @@ var meRoutes = {
 };
 
 // src/contracts/access-token.ts
-import { createRoute as createRoute18, z as z32 } from "@hono/zod-openapi";
+import { createRoute as createRoute18, z as z33 } from "@hono/zod-openapi";
 
 // src/schemas/access-token.ts
-import { z as z31 } from "@hono/zod-openapi";
-var AccessTokenSchema = z31.object({
-  id: z31.string(),
-  name: z31.string(),
-  scopes: z31.array(z31.string()),
+import { z as z32 } from "@hono/zod-openapi";
+var AccessTokenSchema = z32.object({
+  id: z32.string(),
+  name: z32.string(),
+  scopes: z32.array(z32.string()),
   /** ISO-8601 expiry, or `null` for a non-expiring token. */
-  expiresAt: z31.string().nullable(),
+  expiresAt: z32.string().nullable(),
   /** ISO-8601 of last successful use, or `null` if never used. */
-  lastUsedAt: z31.string().nullable(),
-  createdAt: z31.string()
+  lastUsedAt: z32.string().nullable(),
+  createdAt: z32.string()
 });
-var ListAccessTokensResponseSchema = z31.object({
-  accessTokens: z31.array(AccessTokenSchema)
+var ListAccessTokensResponseSchema = z32.object({
+  accessTokens: z32.array(AccessTokenSchema)
 });
-var CreateAccessTokenRequestSchema = z31.object({
-  name: z31.string().min(1, "Name is required").max(200),
-  scopes: z31.array(z31.string()).min(1, "At least one scope is required"),
-  expiresAt: z31.string().datetime().nullable().optional()
+var CreateAccessTokenRequestSchema = z32.object({
+  name: z32.string().min(1, "Name is required").max(200),
+  scopes: z32.array(z32.string()).min(1, "At least one scope is required"),
+  expiresAt: z32.string().datetime().nullable().optional()
 });
 var CreateAccessTokenResponseSchema = AccessTokenSchema.extend({
-  token: z31.string()
-});
-var InvalidScopeErrorSchema = z31.object({
-  error: z31.object({
-    code: z31.literal("INVALID_SCOPE"),
-    message: z31.string(),
-    details: z31.object({
-      invalidScopes: z31.array(z31.string())
+  token: z32.string()
+});
+var InvalidScopeErrorSchema = z32.object({
+  error: z32.object({
+    code: z32.literal("INVALID_SCOPE"),
+    message: z32.string(),
+    details: z32.object({
+      invalidScopes: z32.array(z32.string())
     }).optional()
   })
 });
@@ -3435,7 +3824,7 @@ var deleteAccessTokenRoute = createRoute18({
   security: [{ bearerAuth: [] }],
   summary: "Revoke a personal access token",
   request: {
-    params: z32.object({ id: z32.string() })
+    params: z33.object({ id: z33.string() })
   },
   responses: {
     200: {
@@ -3467,13 +3856,13 @@ var accessTokenRoutes = {
 };
 
 // src/contracts/oauth.ts
-import { createRoute as createRoute19, z as z35 } from "@hono/zod-openapi";
+import { createRoute as createRoute19, z as z36 } from "@hono/zod-openapi";
 
 // src/schemas/oauth-endpoints.ts
-import { z as z34 } from "@hono/zod-openapi";
+import { z as z35 } from "@hono/zod-openapi";
 
 // src/schemas/oauth.ts
-import { z as z33 } from "@hono/zod-openapi";
+import { z as z34 } from "@hono/zod-openapi";
 var SCOPES = [
   // umbrella
   "read",
@@ -3541,11 +3930,11 @@ function scopeSatisfies(required, granted) {
   return false;
 }
 var InsufficientScopeErrorSchema = ApiErrorSchema.extend({
-  error: z33.object({
-    code: z33.literal("INSUFFICIENT_SCOPE"),
-    message: z33.string(),
-    details: z33.object({
-      requiredScope: z33.string()
+  error: z34.object({
+    code: z34.literal("INSUFFICIENT_SCOPE"),
+    message: z34.string(),
+    details: z34.object({
+      requiredScope: z34.string()
     }).optional()
   })
 });
@@ -3564,97 +3953,97 @@ var OAUTH_ERROR_CODES = [
   "slow_down",
   "expired_token"
 ];
-var OAuthErrorSchema = z34.object({
-  error: z34.enum(OAUTH_ERROR_CODES),
-  error_description: z34.string().optional()
-});
-var AuthorizeRequestSchema = z34.object({
-  client_id: z34.string().min(1),
-  redirect_uri: z34.string().min(1),
-  scope: z34.string().min(1),
-  code_challenge: z34.string().min(1),
-  code_challenge_method: z34.literal("S256"),
-  state: z34.string().optional()
-});
-var AuthorizeResponseSchema = z34.object({
-  redirectUri: z34.string()
-});
-var TokenRequestSchema = z34.discriminatedUnion("grant_type", [
-  z34.object({
-    grant_type: z34.literal("authorization_code"),
-    code: z34.string().min(1),
-    code_verifier: z34.string().min(1),
-    redirect_uri: z34.string().min(1),
-    client_id: z34.string().min(1)
+var OAuthErrorSchema = z35.object({
+  error: z35.enum(OAUTH_ERROR_CODES),
+  error_description: z35.string().optional()
+});
+var AuthorizeRequestSchema = z35.object({
+  client_id: z35.string().min(1),
+  redirect_uri: z35.string().min(1),
+  scope: z35.string().min(1),
+  code_challenge: z35.string().min(1),
+  code_challenge_method: z35.literal("S256"),
+  state: z35.string().optional()
+});
+var AuthorizeResponseSchema = z35.object({
+  redirectUri: z35.string()
+});
+var TokenRequestSchema = z35.discriminatedUnion("grant_type", [
+  z35.object({
+    grant_type: z35.literal("authorization_code"),
+    code: z35.string().min(1),
+    code_verifier: z35.string().min(1),
+    redirect_uri: z35.string().min(1),
+    client_id: z35.string().min(1)
   }),
-  z34.object({
-    grant_type: z34.literal("refresh_token"),
-    refresh_token: z34.string().min(1),
-    client_id: z34.string().min(1),
-    scope: z34.string().optional()
+  z35.object({
+    grant_type: z35.literal("refresh_token"),
+    refresh_token: z35.string().min(1),
+    client_id: z35.string().min(1),
+    scope: z35.string().optional()
   }),
   // RFC 8628 §3.4 — device authorization grant. The client polls with the
   // opaque `device_code` returned by `/oauth/device/authorize`.
-  z34.object({
-    grant_type: z34.literal("urn:ietf:params:oauth:grant-type:device_code"),
-    device_code: z34.string().min(1),
-    client_id: z34.string().min(1)
+  z35.object({
+    grant_type: z35.literal("urn:ietf:params:oauth:grant-type:device_code"),
+    device_code: z35.string().min(1),
+    client_id: z35.string().min(1)
   })
 ]);
 var DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
-var TokenResponseSchema = z34.object({
-  access_token: z34.string(),
-  token_type: z34.literal("Bearer"),
-  expires_in: z34.number(),
-  refresh_token: z34.string(),
-  scope: z34.string()
-});
-var RevokeRequestSchema = z34.object({
-  token: z34.string().min(1),
-  token_type_hint: z34.string().optional()
-});
-var RevokeResponseSchema = z34.object({});
-var DeviceAuthorizeRequestSchema = z34.object({
-  client_id: z34.string().min(1),
-  scope: z34.string().min(1)
-});
-var DeviceAuthorizeResponseSchema = z34.object({
-  device_code: z34.string(),
-  user_code: z34.string(),
-  verification_uri: z34.string(),
-  verification_uri_complete: z34.string(),
-  expires_in: z34.number(),
-  interval: z34.number()
-});
-var DeviceVerifyRequestSchema = z34.object({
-  user_code: z34.string().min(1),
-  action: z34.enum(["approve", "deny"])
-});
-var DeviceVerifyResponseSchema = z34.object({
-  status: z34.enum(["approved", "denied"])
-});
-var DeviceInfoResponseSchema = z34.object({
-  client_id: z34.string(),
-  scopes: z34.array(z34.string())
-});
-var ClientInfoResponseSchema = z34.object({
-  clientId: z34.string(),
-  name: z34.string(),
-  firstParty: z34.boolean(),
-  trusted: z34.boolean()
+var TokenResponseSchema = z35.object({
+  access_token: z35.string(),
+  token_type: z35.literal("Bearer"),
+  expires_in: z35.number(),
+  refresh_token: z35.string(),
+  scope: z35.string()
+});
+var RevokeRequestSchema = z35.object({
+  token: z35.string().min(1),
+  token_type_hint: z35.string().optional()
+});
+var RevokeResponseSchema = z35.object({});
+var DeviceAuthorizeRequestSchema = z35.object({
+  client_id: z35.string().min(1),
+  scope: z35.string().min(1)
+});
+var DeviceAuthorizeResponseSchema = z35.object({
+  device_code: z35.string(),
+  user_code: z35.string(),
+  verification_uri: z35.string(),
+  verification_uri_complete: z35.string(),
+  expires_in: z35.number(),
+  interval: z35.number()
+});
+var DeviceVerifyRequestSchema = z35.object({
+  user_code: z35.string().min(1),
+  action: z35.enum(["approve", "deny"])
+});
+var DeviceVerifyResponseSchema = z35.object({
+  status: z35.enum(["approved", "denied"])
+});
+var DeviceInfoResponseSchema = z35.object({
+  client_id: z35.string(),
+  scopes: z35.array(z35.string())
+});
+var ClientInfoResponseSchema = z35.object({
+  clientId: z35.string(),
+  name: z35.string(),
+  firstParty: z35.boolean(),
+  trusted: z35.boolean()
 });
 var GRANT_TYPES_SUPPORTED = ["authorization_code", "refresh_token", DEVICE_CODE_GRANT_TYPE];
-var DiscoveryResponseSchema = z34.object({
-  issuer: z34.string(),
-  authorization_endpoint: z34.string(),
-  token_endpoint: z34.string(),
-  revocation_endpoint: z34.string(),
-  device_authorization_endpoint: z34.string().optional(),
-  scopes_supported: z34.array(z34.string()),
-  response_types_supported: z34.array(z34.string()),
-  grant_types_supported: z34.array(z34.string()),
-  code_challenge_methods_supported: z34.array(z34.string()),
-  token_endpoint_auth_methods_supported: z34.array(z34.string())
+var DiscoveryResponseSchema = z35.object({
+  issuer: z35.string(),
+  authorization_endpoint: z35.string(),
+  token_endpoint: z35.string(),
+  revocation_endpoint: z35.string(),
+  device_authorization_endpoint: z35.string().optional(),
+  scopes_supported: z35.array(z35.string()),
+  response_types_supported: z35.array(z35.string()),
+  grant_types_supported: z35.array(z35.string()),
+  code_challenge_methods_supported: z35.array(z35.string()),
+  token_endpoint_auth_methods_supported: z35.array(z35.string())
 });
 var DISCOVERY_SCOPES_SUPPORTED = ISSUABLE_SCOPES;
 
@@ -3790,7 +4179,7 @@ var deviceInfoRoute = createRoute19({
   // scopes so the web consent screen can show them before approval. Reveals
   // no secret. Unknown / expired / non-pending → 404 (PHASE4-Q9 option A).
   request: {
-    query: z35.object({ user_code: z35.string().min(1) })
+    query: z36.object({ user_code: z36.string().min(1) })
   },
   responses: {
     200: {
@@ -3844,7 +4233,7 @@ var clientInfoRoute = createRoute19({
   // no redirectUris/allowedScopes — mirroring deviceInfoRoute's own
   // non-secret-lookup shape. Unknown client_id → 404.
   request: {
-    query: z35.object({ client_id: z35.string().min(1) })
+    query: z36.object({ client_id: z36.string().min(1) })
   },
   responses: {
     200: {
@@ -3869,24 +4258,24 @@ var oauthRoutes = {
 };
 
 // src/contracts/notification.ts
-import { createRoute as createRoute20, z as z37 } from "@hono/zod-openapi";
+import { createRoute as createRoute20, z as z38 } from "@hono/zod-openapi";
 
 // src/schemas/notification.ts
-import { z as z36 } from "@hono/zod-openapi";
-var NotificationStatusSchema = z36.enum(["UNREAD", "UNOPENED", "OPENED"]);
+import { z as z37 } from "@hono/zod-openapi";
+var NotificationStatusSchema = z37.enum(["UNREAD", "UNOPENED", "OPENED"]);
 var NotificationStatusEnum = {
   UNREAD: "UNREAD",
   UNOPENED: "UNOPENED",
   OPENED: "OPENED"
 };
-var NotificationActionSchema = z36.enum(["COMMENT", "LIKE", "MENTION", "UPDATE"]);
+var NotificationActionSchema = z37.enum(["COMMENT", "LIKE", "MENTION", "UPDATE"]);
 var NotificationActionEnum = {
   COMMENT: "COMMENT",
   LIKE: "LIKE",
   MENTION: "MENTION",
   UPDATE: "UPDATE"
 };
-var NotificationTargetModelSchema = z36.enum(["Page"]);
+var NotificationTargetModelSchema = z37.enum(["Page"]);
 var NotificationTargetModelEnum = {
   PAGE: "Page"
 };
@@ -3895,68 +4284,68 @@ var PageRefSchema = PageSchema.pick({
   path: true,
   status: true
 });
-var NotificationSchema = z36.object({
-  _id: z36.string(),
-  user: z36.string(),
+var NotificationSchema = z37.object({
+  _id: z37.string(),
+  user: z37.string(),
   targetModel: NotificationTargetModelSchema,
   target: PageRefSchema,
   action: NotificationActionSchema,
   status: NotificationStatusSchema,
-  actionUsers: z36.array(UserPublicSchema),
-  createdAt: z36.string()
+  actionUsers: z37.array(UserPublicSchema),
+  createdAt: z37.string()
 });
-var ListNotificationsRequestSchema = z36.object({
-  limit: z36.coerce.number().optional().default(10),
-  offset: z36.coerce.number().optional().default(0)
+var ListNotificationsRequestSchema = z37.object({
+  limit: z37.coerce.number().optional().default(10),
+  offset: z37.coerce.number().optional().default(0)
 });
-var ListNotificationsResponseSchema = z36.object({
-  notifications: z36.array(NotificationSchema),
+var ListNotificationsResponseSchema = z37.object({
+  notifications: z37.array(NotificationSchema),
   pager: PagerSchema
 });
-var MarkAllAsReadResponseSchema = z36.object({
-  ok: z36.literal(true)
+var MarkAllAsReadResponseSchema = z37.object({
+  ok: z37.literal(true)
 });
-var OpenNotificationParamSchema = z36.object({
-  id: z36.string()
+var OpenNotificationParamSchema = z37.object({
+  id: z37.string()
 });
-var OpenNotificationResponseSchema = z36.object({
+var OpenNotificationResponseSchema = z37.object({
   notification: NotificationSchema
 });
-var NotificationStatusResponseSchema = z36.object({
-  count: z36.number()
+var NotificationStatusResponseSchema = z37.object({
+  count: z37.number()
 });
-var NotificationNotFoundErrorSchema = z36.object({
-  error: z36.object({
-    code: z36.literal("NOTIFICATION_NOT_FOUND"),
-    message: z36.literal("Notification not found")
+var NotificationNotFoundErrorSchema = z37.object({
+  error: z37.object({
+    code: z37.literal("NOTIFICATION_NOT_FOUND"),
+    message: z37.literal("Notification not found")
   })
 });
-var NotificationsTokenResponseSchema = z36.object({
-  token: z36.string(),
-  selfUserId: z36.string(),
-  expiresAt: z36.string()
+var NotificationsTokenResponseSchema = z37.object({
+  token: z37.string(),
+  selfUserId: z37.string(),
+  expiresAt: z37.string()
 });
-var NotificationsTokenPayloadSchema = z36.object({
-  selfUserId: z36.string(),
+var NotificationsTokenPayloadSchema = z37.object({
+  selfUserId: z37.string(),
   // Random UUID mixed into every signed token so two tokens minted
   // within the same second still produce byte-different JWT strings.
   // The browser uses the token as a React effect dependency to drive
   // the WebSocket reconnect — without `jti`, the iat/exp pair is
   // identical at second granularity and the dep stays stable.
-  jti: z36.string().uuid(),
-  iat: z36.number().int(),
-  exp: z36.number().int()
+  jti: z37.string().uuid(),
+  iat: z37.number().int(),
+  exp: z37.number().int()
 });
-var NotificationsChangedMessageSchema = z36.object({
-  type: z36.literal("changed")
+var NotificationsChangedMessageSchema = z37.object({
+  type: z37.literal("changed")
 });
 var NotificationsServerMessageSchema = NotificationsChangedMessageSchema;
 
 // src/contracts/notification.ts
-var NotificationInvalidRequestErrorSchema = z37.object({
-  error: z37.object({
-    code: z37.literal("INVALID_REQUEST"),
-    message: z37.string()
+var NotificationInvalidRequestErrorSchema = z38.object({
+  error: z38.object({
+    code: z38.literal("INVALID_REQUEST"),
+    message: z38.string()
   })
 });
 var listNotificationsRoute = createRoute20({
@@ -4092,9 +4481,9 @@ var notificationRoutes = {
 };
 
 // src/contracts/page-collab.ts
-import { createRoute as createRoute21, z as z38 } from "@hono/zod-openapi";
-var PageIdPathParamsSchema2 = z38.object({
-  id: z38.string().openapi({ description: "Page id (24-char hex ObjectId)", example: "507f1f77bcf86cd799439011" })
+import { createRoute as createRoute21, z as z39 } from "@hono/zod-openapi";
+var PageIdPathParamsSchema2 = z39.object({
+  id: z39.string().openapi({ description: "Page id (24-char hex ObjectId)", example: "507f1f77bcf86cd799439011" })
 });
 var getYjsTokenRoute = createRoute21({
   method: "get",
@@ -4133,25 +4522,25 @@ var pageCollabRoutes = {
 };
 
 // src/contracts/page.ts
-import { createRoute as createRoute22, z as z39 } from "@hono/zod-openapi";
-var PageBadRequestErrorSchema = z39.object({
-  error: z39.object({
-    code: z39.string(),
-    message: z39.string()
+import { createRoute as createRoute22, z as z40 } from "@hono/zod-openapi";
+var PageBadRequestErrorSchema = z40.object({
+  error: z40.object({
+    code: z40.string(),
+    message: z40.string()
   })
 });
-var DeletePageRequestSchema = z39.object({
-  page_id: z39.string(),
-  revision_id: z39.string().optional(),
-  completely: z39.boolean().optional()
+var DeletePageRequestSchema = z40.object({
+  page_id: z40.string(),
+  revision_id: z40.string().optional(),
+  completely: z40.boolean().optional()
 });
-var RevertDeletedPageRequestSchema = z39.object({
-  page_id: z39.string()
+var RevertDeletedPageRequestSchema = z40.object({
+  page_id: z40.string()
 });
-var PageIdBodySchema = z39.object({
-  page_id: z39.string()
+var PageIdBodySchema = z40.object({
+  page_id: z40.string()
 });
-var PageResponseSchema = z39.object({ page: PageSchema });
+var PageResponseSchema = z40.object({ page: PageSchema });
 var getPageRoute = createRoute22({
   method: "get",
   path: "/pages",
@@ -4163,7 +4552,7 @@ var getPageRoute = createRoute22({
   },
   responses: {
     200: {
-      description: "The requested page with populated revision",
+      description: "The requested page with populated revision. `revision.renderedAst` shape is content-negotiated via the `X-Crowi-Ast-Version` request header (RFC-0023): requests declaring `X-Crowi-Ast-Version: 1` receive the typed `{astVersion, root}` envelope; all other requests receive the stored bare mdast Root verbatim. The response varies on this header (`Vary: X-Crowi-Ast-Version`).",
       content: { "application/json": { schema: GetPageResponseSchema } }
     },
     401: {
@@ -4200,7 +4589,7 @@ var listPagesRoute = createRoute22({
   },
   responses: {
     200: {
-      description: "Page list (newest first) with optional portal page",
+      description: "Page list (newest first) with optional portal page and an accurate `total` (the full, unpaginated count of the same viewer-visible set `pages` is a page of). The portal document is the only row carrying `revision.renderedAst`; its shape is content-negotiated via the `X-Crowi-Ast-Version` request header (RFC-0023, same semantics as GET /pages). The response varies on this header (`Vary: X-Crowi-Ast-Version`).",
       content: { "application/json": { schema: ListPagesResponseSchema } }
     },
     401: {
@@ -4465,7 +4854,7 @@ var claimPageLinkAccessRoute = createRoute22({
       description: "The caller has no access to the page (isGrantedFor is false) or lacks scope / is a non-web session \u2014 403 is about the caller lacking access, never about the page grant type per se",
       content: {
         "application/json": {
-          schema: z39.union([PageNotGrantedErrorSchema, InsufficientScopeErrorSchema])
+          schema: z40.union([PageNotGrantedErrorSchema, InsufficientScopeErrorSchema])
         }
       }
     },
@@ -4655,7 +5044,7 @@ var renamePageRoute = createRoute22({
       description: "PAGE_INVALID_NAME / PAGE_EXISTS / PAGE_RENAME_FAILED / PAGE_RENAME_TREE_FAILED",
       content: {
         "application/json": {
-          schema: z39.union([PageBadRequestErrorSchema, RenameTreeErrorSchema])
+          schema: z40.union([PageBadRequestErrorSchema, RenameTreeErrorSchema])
         }
       }
     },
@@ -4693,7 +5082,7 @@ var renameSubtreeRoute = createRoute22({
       description: "PAGE_INVALID_NAME / PAGE_RENAME_TREE_FAILED (collisions, nothing to move, or partial failure)",
       content: {
         "application/json": {
-          schema: z39.union([PageBadRequestErrorSchema, RenameTreeErrorSchema])
+          schema: z40.union([PageBadRequestErrorSchema, RenameTreeErrorSchema])
         }
       }
     },
@@ -4746,12 +5135,13 @@ var pageRoutes = {
 import { createRoute as createRoute23 } from "@hono/zod-openapi";
 
 // src/schemas/page-preview.ts
-import { z as z40 } from "@hono/zod-openapi";
-var PreviewPageRequestSchema = z40.object({
-  body: z40.string()
+import { z as z41 } from "@hono/zod-openapi";
+var PreviewPageRequestSchema = z41.object({
+  body: z41.string()
 });
-var PreviewPageResponseSchema = z40.object({
-  renderedAst: z40.unknown()
+var PreviewPageResponseSchema = z41.object({
+  renderedAst: RenderedAstValueSchema.optional(),
+  renderedAstArtifactKey: RenderedAstArtifactKeySchema.optional()
 });
 
 // src/contracts/page-preview.ts
@@ -4768,7 +5158,7 @@ var previewPageRoute = createRoute23({
   },
   responses: {
     200: {
-      description: "Rendered mdast tree (serialised \u2014 same shape as a persisted revision.renderedAst)",
+      description: "Rendered mdast tree (serialised \u2014 same shape as a persisted revision.renderedAst). Content-negotiated via the `X-Crowi-Ast-Version` request header (RFC-0023): requests declaring `X-Crowi-Ast-Version: 1` receive the typed `{astVersion, root}` envelope; all other requests receive the bare mdast Root. The response varies on this header (`Vary: X-Crowi-Ast-Version`).",
       content: { "application/json": { schema: PreviewPageResponseSchema } }
     },
     401: {
@@ -4793,78 +5183,78 @@ var pagePreviewRoutes = {
 };
 
 // src/contracts/presence.ts
-import { createRoute as createRoute24, z as z42 } from "@hono/zod-openapi";
+import { createRoute as createRoute24, z as z43 } from "@hono/zod-openapi";
 
 // src/schemas/presence.ts
-import { z as z41 } from "@hono/zod-openapi";
-var PresenceTokenResponseSchema = z41.object({
-  token: z41.string(),
-  pageId: z41.string(),
-  selfUserId: z41.string(),
-  expiresAt: z41.string()
-});
-var PresenceTokenPayloadSchema = z41.object({
-  userId: z41.string(),
-  pageId: z41.string(),
-  iat: z41.number().int(),
-  exp: z41.number().int()
-});
-var PresenceViewerSchema = z41.object({
-  userId: z41.string(),
-  username: z41.string(),
-  displayName: z41.string(),
-  avatarUrl: z41.string().nullable(),
-  isEditing: z41.boolean(),
-  joinedAt: z41.number().int()
-});
-var PresenceHeartbeatMessageSchema = z41.object({
-  type: z41.literal("heartbeat")
+import { z as z42 } from "@hono/zod-openapi";
+var PresenceTokenResponseSchema = z42.object({
+  token: z42.string(),
+  pageId: z42.string(),
+  selfUserId: z42.string(),
+  expiresAt: z42.string()
+});
+var PresenceTokenPayloadSchema = z42.object({
+  userId: z42.string(),
+  pageId: z42.string(),
+  iat: z42.number().int(),
+  exp: z42.number().int()
+});
+var PresenceViewerSchema = z42.object({
+  userId: z42.string(),
+  username: z42.string(),
+  displayName: z42.string(),
+  avatarUrl: z42.string().nullable(),
+  isEditing: z42.boolean(),
+  joinedAt: z42.number().int()
+});
+var PresenceHeartbeatMessageSchema = z42.object({
+  type: z42.literal("heartbeat")
 });
 var PresenceClientMessageSchema = PresenceHeartbeatMessageSchema;
-var PresenceViewersMessageSchema = z41.object({
-  type: z41.literal("viewers"),
-  viewers: z41.array(PresenceViewerSchema),
-  generation: z41.number().int()
-});
-var PresencePageUpdatedMessageSchema = z41.object({
-  type: z41.literal("page-updated"),
-  pageId: z41.string(),
-  revisionId: z41.string(),
-  editorUserId: z41.string(),
-  editorDisplayName: z41.string()
-});
-var PresenceCommentChangedMessageSchema = z41.object({
-  type: z41.literal("comment-changed"),
-  pageId: z41.string(),
-  changeType: z41.enum(["added", "removed"]),
-  commentId: z41.string(),
-  actorUserId: z41.string().optional()
-});
-var PresenceServerMessageSchema = z41.discriminatedUnion("type", [
+var PresenceViewersMessageSchema = z42.object({
+  type: z42.literal("viewers"),
+  viewers: z42.array(PresenceViewerSchema),
+  generation: z42.number().int()
+});
+var PresencePageUpdatedMessageSchema = z42.object({
+  type: z42.literal("page-updated"),
+  pageId: z42.string(),
+  revisionId: z42.string(),
+  editorUserId: z42.string(),
+  editorDisplayName: z42.string()
+});
+var PresenceCommentChangedMessageSchema = z42.object({
+  type: z42.literal("comment-changed"),
+  pageId: z42.string(),
+  changeType: z42.enum(["added", "removed"]),
+  commentId: z42.string(),
+  actorUserId: z42.string().optional()
+});
+var PresenceServerMessageSchema = z42.discriminatedUnion("type", [
   PresenceViewersMessageSchema,
   PresencePageUpdatedMessageSchema,
   PresenceCommentChangedMessageSchema
 ]);
-var LikerSchema = z41.object({
-  id: z41.string(),
-  username: z41.string(),
-  displayName: z41.string(),
-  avatarUrl: z41.string().nullable(),
-  likedAt: z41.string().nullable()
-});
-var LikersResponseSchema = z41.object({
-  users: z41.array(LikerSchema),
-  totalCount: z41.number().int().nonnegative()
-});
-var GetLikersRequestSchema = z41.object({
+var LikerSchema = z42.object({
+  id: z42.string(),
+  username: z42.string(),
+  displayName: z42.string(),
+  avatarUrl: z42.string().nullable(),
+  likedAt: z42.string().nullable()
+});
+var LikersResponseSchema = z42.object({
+  users: z42.array(LikerSchema),
+  totalCount: z42.number().int().nonnegative()
+});
+var GetLikersRequestSchema = z42.object({
   // Optional cap on returned `users`. `totalCount` always reflects the
   // full count regardless of `limit`. Omit for the full list.
-  limit: z41.coerce.number().int().positive().optional()
+  limit: z42.coerce.number().int().positive().optional()
 });
 
 // src/contracts/presence.ts
-var PageIdPathParamsSchema3 = z42.object({
-  id: z42.string().openapi({ description: "Page id (24-char hex ObjectId)", example: "507f1f77bcf86cd799439011" })
+var PageIdPathParamsSchema3 = z43.object({
+  id: z43.string().openapi({ description: "Page id (24-char hex ObjectId)", example: "507f1f77bcf86cd799439011" })
 });
 var getPresenceTokenRoute = createRoute24({
   method: "get",
@@ -4937,49 +5327,49 @@ var presenceRoutes = {
 };
 
 // src/contracts/revision.ts
-import { createRoute as createRoute25, z as z44 } from "@hono/zod-openapi";
+import { createRoute as createRoute25, z as z45 } from "@hono/zod-openapi";
 
 // src/schemas/revision.ts
-import { z as z43 } from "@hono/zod-openapi";
-var RevisionMetaSchema = z43.object({
-  _id: z43.string(),
-  path: z43.string(),
+import { z as z44 } from "@hono/zod-openapi";
+var RevisionMetaSchema = z44.object({
+  _id: z44.string(),
+  path: z44.string(),
   author: PageUserSchema.nullable().optional(),
   savedBy: PageUserSchema.nullable().optional(),
-  contributors: z43.array(PageUserSchema).optional(),
+  contributors: z44.array(PageUserSchema).optional(),
   // RFC-0010 — edit channel. `web` (browser / collab editor) vs the API
   // token paths (`oauth` / `pat`). Absent on pre-RFC-0010 revisions. The
   // history UI shows an "app" chip for the token paths.
-  editVia: z43.enum(["web", "oauth", "pat"]).optional(),
-  createdAt: z43.string()
+  editVia: z44.enum(["web", "oauth", "pat"]).optional(),
+  createdAt: z44.string()
 });
-var ListRevisionsRequestSchema = z43.object({
-  limit: z43.coerce.number().int().positive().max(200).optional().default(50),
-  offset: z43.coerce.number().int().min(0).optional().default(0)
+var ListRevisionsRequestSchema = z44.object({
+  limit: z44.coerce.number().int().positive().max(200).optional().default(50),
+  offset: z44.coerce.number().int().min(0).optional().default(0)
 });
-var ListRevisionsResponseSchema = z43.object({
-  revisions: z43.array(RevisionMetaSchema),
+var ListRevisionsResponseSchema = z44.object({
+  revisions: z44.array(RevisionMetaSchema),
   pager: PagerSchema
 });
-var GetRevisionResponseSchema = z43.object({
+var GetRevisionResponseSchema = z44.object({
   revision: RevisionSchema
 });
-var GetRevisionsRequestSchema = z43.object({
-  ids: z43.string().min(1, "ids is required")
+var GetRevisionsRequestSchema = z44.object({
+  ids: z44.string().min(1, "ids is required")
 });
-var GetRevisionsResponseSchema = z43.object({
-  revisions: z43.array(RevisionSchema)
+var GetRevisionsResponseSchema = z44.object({
+  revisions: z44.array(RevisionSchema)
 });
-var RevisionInvalidRequestErrorSchema = z43.object({
-  error: z43.object({
-    code: z43.literal("INVALID_REQUEST"),
-    message: z43.string()
+var RevisionInvalidRequestErrorSchema = z44.object({
+  error: z44.object({
+    code: z44.literal("INVALID_REQUEST"),
+    message: z44.string()
   })
 });
 
 // src/contracts/revision.ts
-var PageIdParamSchema = z44.object({ page_id: z44.string() });
-var RevisionIdParamSchema = z44.object({ id: z44.string() });
+var PageIdParamSchema = z45.object({ page_id: z45.string() });
+var RevisionIdParamSchema = z45.object({ id: z45.string() });
 var listRevisionsRoute = createRoute25({
   method: "get",
   path: "/pages/{page_id}/revisions",
@@ -5048,7 +5438,7 @@ var getRevisionRoute = createRoute25({
   },
   responses: {
     200: {
-      description: "Full revision document",
+      description: "Full revision document. `renderedAst` shape is content-negotiated via the `X-Crowi-Ast-Version` request header (RFC-0023): requests declaring `X-Crowi-Ast-Version: 1` receive the typed `{astVersion, root}` envelope; all other requests receive the stored bare mdast Root verbatim. The response varies on this header (`Vary: X-Crowi-Ast-Version`).",
       content: { "application/json": { schema: GetRevisionResponseSchema } }
     },
     400: {
@@ -5078,31 +5468,31 @@ var revisionRoutes = {
 import { createRoute as createRoute26 } from "@hono/zod-openapi";
 
 // src/schemas/admin-crypto.ts
-import { z as z45 } from "@hono/zod-openapi";
-var SensitiveConfigEntrySchema = z45.object({
-  ns: z45.string(),
-  key: z45.string(),
-  present: z45.boolean(),
-  encrypted: z45.boolean()
-});
-var CryptoStatusResponseSchema = z45.object({
+import { z as z46 } from "@hono/zod-openapi";
+var SensitiveConfigEntrySchema = z46.object({
+  ns: z46.string(),
+  key: z46.string(),
+  present: z46.boolean(),
+  encrypted: z46.boolean()
+});
+var CryptoStatusResponseSchema = z46.object({
   /** False when CROWI_ENCRYPTION_KEY is not configured — UI shows a setup hint. */
-  encryptionConfigured: z45.boolean(),
-  unencryptedCount: z45.number().int().min(0),
-  encryptedCount: z45.number().int().min(0),
-  entries: z45.array(SensitiveConfigEntrySchema)
+  encryptionConfigured: z46.boolean(),
+  unencryptedCount: z46.number().int().min(0),
+  encryptedCount: z46.number().int().min(0),
+  entries: z46.array(SensitiveConfigEntrySchema)
 });
-var ReencryptResponseSchema = z45.object({
-  rewritten: z45.number().int().min(0),
+var ReencryptResponseSchema = z46.object({
+  rewritten: z46.number().int().min(0),
   /** Already encrypted, skipped on this run. */
-  alreadyEncrypted: z45.number().int().min(0),
+  alreadyEncrypted: z46.number().int().min(0),
   /** Sensitive registry entries that had no row in the DB at all. */
-  missing: z45.number().int().min(0)
+  missing: z46.number().int().min(0)
 });
-var EncryptionNotConfiguredErrorSchema = z45.object({
-  error: z45.object({
-    code: z45.literal("ENCRYPTION_NOT_CONFIGURED"),
-    message: z45.string()
+var EncryptionNotConfiguredErrorSchema = z46.object({
+  error: z46.object({
+    code: z46.literal("ENCRYPTION_NOT_CONFIGURED"),
+    message: z46.string()
   })
 });
 
@@ -5170,30 +5560,30 @@ var adminCryptoRoutes = {
 import { createRoute as createRoute27 } from "@hono/zod-openapi";
 
 // src/schemas/search.ts
-import { z as z47 } from "@hono/zod-openapi";
-var SearchPageTypeSchema = z47.enum(["portal", "public", "user"]);
-var SearchPagesRequestSchema = z47.object({
-  q: z47.string().min(1),
-  tree: z47.string().optional(),
+import { z as z48 } from "@hono/zod-openapi";
+var SearchPageTypeSchema = z48.enum(["portal", "public", "user"]);
+var SearchPagesRequestSchema = z48.object({
+  q: z48.string().min(1),
+  tree: z48.string().optional(),
   type: SearchPageTypeSchema.optional(),
-  page: z47.coerce.number().int().min(1).default(1),
-  limit: z47.coerce.number().int().min(1).max(100).default(50)
-});
-var SearchHitSchema = z47.object({
-  pageId: z47.string(),
-  path: z47.string(),
-  score: z47.number().optional(),
-  snippet: z47.string().optional(),
-  bookmarkCount: z47.number(),
+  page: z48.coerce.number().int().min(1).default(1),
+  limit: z48.coerce.number().int().min(1).max(100).default(50)
+});
+var SearchHitSchema = z48.object({
+  pageId: z48.string(),
+  path: z48.string(),
+  score: z48.number().optional(),
+  snippet: z48.string().optional(),
+  bookmarkCount: z48.number(),
   page: PageSchema
 });
-var SearchPagesResponseSchema = z47.object({
-  meta: z47.object({
-    took: z47.number().optional(),
-    total: z47.number(),
-    results: z47.number()
+var SearchPagesResponseSchema = z48.object({
+  meta: z48.object({
+    took: z48.number().optional(),
+    total: z48.number(),
+    results: z48.number()
   }),
-  data: z47.array(SearchHitSchema)
+  data: z48.array(SearchHitSchema)
 });
 
 // src/contracts/search.ts
@@ -5234,53 +5624,53 @@ var searchRoutes = {
 };
 
 // src/contracts/token-auth.ts
-import { createRoute as createRoute28, z as z49 } from "@hono/zod-openapi";
+import { createRoute as createRoute28, z as z50 } from "@hono/zod-openapi";
 
 // src/schemas/auth.ts
-import { z as z48 } from "@hono/zod-openapi";
-var TokenAuthLoginRequestSchema = z48.object({
-  email: z48.string().email(),
-  password: z48.string().min(6)
-});
-var TokenAuthResponseSchema = z48.object({
-  accessToken: z48.string(),
-  refreshToken: z48.string(),
-  expiresIn: z48.number(),
+import { z as z49 } from "@hono/zod-openapi";
+var TokenAuthLoginRequestSchema = z49.object({
+  email: z49.string().email(),
+  password: z49.string().min(6)
+});
+var TokenAuthResponseSchema = z49.object({
+  accessToken: z49.string(),
+  refreshToken: z49.string(),
+  expiresIn: z49.number(),
   // seconds until expiration
-  user: z48.object({
-    id: z48.string(),
-    username: z48.string(),
-    email: z48.string().email(),
-    name: z48.string(),
-    image: z48.string().optional(),
-    admin: z48.boolean().optional()
+  user: z49.object({
+    id: z49.string(),
+    username: z49.string(),
+    email: z49.string().email(),
+    name: z49.string(),
+    image: z49.string().optional(),
+    admin: z49.boolean().optional()
   })
 });
-var RefreshTokenRequestSchema = z48.object({
-  refreshToken: z48.string()
+var RefreshTokenRequestSchema = z49.object({
+  refreshToken: z49.string()
 });
-var TokenAuthRegisterRequestSchema = z48.object({
-  username: z48.string(),
-  name: z48.string(),
-  email: z48.string().email(),
-  password: z48.string().min(6)
+var TokenAuthRegisterRequestSchema = z49.object({
+  username: z49.string(),
+  name: z49.string(),
+  email: z49.string().email(),
+  password: z49.string().min(6)
 });
-var RegisterPendingResponseSchema = z48.object({
-  status: z48.enum(["confirmation_required", "approval_required"])
+var RegisterPendingResponseSchema = z49.object({
+  status: z49.enum(["confirmation_required", "approval_required"])
 });
 
 // src/contracts/token-auth.ts
-var TokenLogoutResponseSchema = z49.object({ message: z49.string() });
-var TokenMeResponseSchema = z49.object({
-  user: z49.object({
-    id: z49.string(),
-    username: z49.string(),
-    email: z49.string().email(),
-    name: z49.string(),
-    image: z49.string().optional(),
-    status: z49.number(),
-    admin: z49.boolean().optional(),
-    createdAt: z49.string()
+var TokenLogoutResponseSchema = z50.object({ message: z50.string() });
+var TokenMeResponseSchema = z50.object({
+  user: z50.object({
+    id: z50.string(),
+    username: z50.string(),
+    email: z50.string().email(),
+    name: z50.string(),
+    image: z50.string().optional(),
+    status: z50.number(),
+    admin: z50.boolean().optional(),
+    createdAt: z50.string()
   })
 });
 var tokenLoginRoute = createRoute28({
@@ -5408,7 +5798,7 @@ var tokenLogoutRoute = createRoute28({
     body: {
       content: {
         "application/json": {
-          schema: z49.object({ refreshToken: z49.string().optional() })
+          schema: z50.object({ refreshToken: z50.string().optional() })
         }
       }
     }
@@ -5461,15 +5851,15 @@ var tokenAuthRoutes = {
 import { createRoute as createRoute29 } from "@hono/zod-openapi";
 
 // src/schemas/invite-accept.ts
-import { z as z50 } from "@hono/zod-openapi";
-var InviteAcceptRequestSchema = z50.object({
-  token: z50.string(),
-  username: z50.string().min(1),
-  name: z50.string().min(1),
-  password: z50.string().min(6)
+import { z as z51 } from "@hono/zod-openapi";
+var InviteAcceptRequestSchema = z51.object({
+  token: z51.string(),
+  username: z51.string().min(1),
+  name: z51.string().min(1),
+  password: z51.string().min(6)
 });
-var InvitePreviewResponseSchema = z50.object({
-  email: z50.string().email()
+var InvitePreviewResponseSchema = z51.object({
+  email: z51.string().email()
 });
 
 // src/contracts/invite-accept.ts
@@ -5546,16 +5936,16 @@ var inviteAcceptRoutes = {
 import { createRoute as createRoute30 } from "@hono/zod-openapi";
 
 // src/schemas/password-reset.ts
-import { z as z51 } from "@hono/zod-openapi";
-var ForgotPasswordRequestSchema = z51.object({
-  email: z51.string().email()
+import { z as z52 } from "@hono/zod-openapi";
+var ForgotPasswordRequestSchema = z52.object({
+  email: z52.string().email()
 });
-var ForgotPasswordResponseSchema = z51.object({
-  ok: z51.literal(true)
+var ForgotPasswordResponseSchema = z52.object({
+  ok: z52.literal(true)
 });
-var ResetPasswordRequestSchema = z51.object({
-  token: z51.string(),
-  password: z51.string().min(6)
+var ResetPasswordRequestSchema = z52.object({
+  token: z52.string(),
+  password: z52.string().min(6)
 });
 
 // src/contracts/password-reset.ts
@@ -5650,12 +6040,12 @@ var passwordResetRoutes = {
 import { createRoute as createRoute31 } from "@hono/zod-openapi";
 
 // src/schemas/activation.ts
-import { z as z52 } from "@hono/zod-openapi";
-var ActivateRequestSchema = z52.object({
-  token: z52.string()
+import { z as z53 } from "@hono/zod-openapi";
+var ActivateRequestSchema = z53.object({
+  token: z53.string()
 });
-var ActivateValidationResponseSchema = z52.object({
-  ok: z52.literal(true)
+var ActivateValidationResponseSchema = z53.object({
+  ok: z53.literal(true)
 });
 
 // src/contracts/activation.ts
@@ -5720,14 +6110,14 @@ var activationRoutes = {
 import { createRoute as createRoute32 } from "@hono/zod-openapi";
 
 // src/schemas/email-change.ts
-import { z as z53 } from "@hono/zod-openapi";
-var ConfirmEmailChangeRequestSchema = z53.object({
-  token: z53.string()
+import { z as z54 } from "@hono/zod-openapi";
+var ConfirmEmailChangeRequestSchema = z54.object({
+  token: z54.string()
 });
-var ConfirmEmailChangeResponseSchema = z53.object({
-  ok: z53.literal(true),
+var ConfirmEmailChangeResponseSchema = z54.object({
+  ok: z54.literal(true),
   /** The newly-confirmed email address. */
-  email: z53.string().email()
+  email: z54.string().email()
 });
 
 // src/contracts/email-change.ts
@@ -5793,8 +6183,8 @@ var emailChangeRoutes = {
 };
 
 // src/contracts/user.ts
-import { createRoute as createRoute33, z as z54 } from "@hono/zod-openapi";
-var UsernameParamSchema = z54.object({ username: z54.string() });
+import { createRoute as createRoute33, z as z55 } from "@hono/zod-openapi";
+var UsernameParamSchema = z55.object({ username: z55.string() });
 var getUserPageRoute = createRoute33({
   method: "get",
   path: "/user/{username}",
@@ -5806,7 +6196,7 @@ var getUserPageRoute = createRoute33({
   },
   responses: {
     200: {
-      description: "User profile with statistics + recent activity",
+      description: "User profile with statistics (createdPagesCount, bookmarksCount, likesCount, commentsCount \u2014 the last two are the target user's OWN likes/comments, not activity their pages received) + recent activity",
       content: { "application/json": { schema: UserPageResponseSchema } }
     },
     401: {
@@ -6029,7 +6419,9 @@ var stubUserPublic = {
 var stubUserPage = {
   user: stubUserPublic,
   createdPagesCount: 0,
-  bookmarksCount: 0
+  bookmarksCount: 0,
+  likesCount: 0,
+  commentsCount: 0
 };
 var stubPager = { prev: null, next: null, offset: 0 };
 var stubUserBookmarks = {
@@ -6116,11 +6508,11 @@ var stubPageWithRevision = {
   }
 };
 var stubPageResponse = { page: stubPage };
-var stubListPages = { pages: [], pager: stubPager, portalPage: null };
+var stubListPages = { pages: [], pager: stubPager, portalPage: null, total: 0 };
 var stubListPageChildren = { children: [] };
 var stubSeenUsers = { seenUsers: [], seenUsersCount: 0 };
 var stubWatchStatus = { watching: false };
-var stubPreview = { renderedAst: null };
+var stubPreview = {};
 var stubWsToken = {
   wsToken: "",
   pageId: "",
@@ -6257,19 +6649,19 @@ var createClient = (baseUrl, options = {}) => hc(baseUrl, {
 });
 
 // src/schemas/mail-token.ts
-import { z as z55 } from "@hono/zod-openapi";
-var MailTokenPurposeSchema = z55.enum(["invite", "activate", "reset", "email-change"]);
-var MailTokenPayloadSchema = z55.object({
+import { z as z56 } from "@hono/zod-openapi";
+var MailTokenPurposeSchema = z56.enum(["invite", "activate", "reset", "email-change"]);
+var MailTokenPayloadSchema = z56.object({
   purpose: MailTokenPurposeSchema,
-  userId: z55.string(),
+  userId: z56.string(),
   /** Target address. For `email-change` this is the NEW address. */
-  email: z55.string().email(),
+  email: z56.string().email(),
   /**
    * For `email-change`: the account's email at issue time. The confirm
    * endpoint rejects the token unless it still matches, making the token
    * single-use (a stale token cannot revert a later change).
    */
-  fromEmail: z55.string().email().optional(),
+  fromEmail: z56.string().email().optional(),
   /**
    * For `reset`: the account's `passwordResetGeneration` at issue time.
    * Consuming the link increments that counter, so the token only matches
@@ -6278,7 +6670,7 @@ var MailTokenPayloadSchema = z55.object({
    * schema because the other purposes don't carry it (and links minted
    * before the claim existed simply no longer match).
    */
-  resetGeneration: z55.number().int().nonnegative().optional(),
+  resetGeneration: z56.number().int().nonnegative().optional(),
   /**
    * For `email-change`: the account's `authVersion` at issue time. The
    * confirm endpoint requires it to still match, so a pending address change
@@ -6290,10 +6682,10 @@ var MailTokenPayloadSchema = z55.object({
    * semantics wanted are exactly "the session that asked for this is gone",
    * and that is what every bump of it already means.
    */
-  authVersion: z55.number().int().nonnegative().optional(),
+  authVersion: z56.number().int().nonnegative().optional(),
   // iat / exp are injected and verified by the JWT layer.
-  iat: z55.number().optional(),
-  exp: z55.number().optional()
+  iat: z56.number().optional(),
+  exp: z56.number().optional()
 });
 
 // src/util/html-elements.ts
@@ -6453,6 +6845,13 @@ export {
   ALL_CAPABILITIES,
   ALL_SCOPES,
   API_SURFACE_VERSION,
+  AST_INPUT_LIMIT_BYTES,
+  AST_MAX_HAST_DEPTH,
+  AST_MAX_IMAGE_BASE64_CHARS,
+  AST_MAX_TREE_DEPTH,
+  AST_MAX_VALUE_CHARS,
+  AST_OUTPUT_BUDGET_BYTES,
+  AST_OUTPUT_WARN_BYTES,
   AccessTokenSchema,
   ActivateRequestSchema,
   ActivateValidationResponseSchema,
@@ -6489,6 +6888,7 @@ export {
   BacklinkSchema,
   BookmarkResponseSchema,
   BookmarkSchema,
+  CURRENT_AST_VERSION,
   CapabilitySchema,
   ClaimPageLinkAccessResponseSchema,
   ClearRenderCacheResponseSchema,
@@ -6511,10 +6911,21 @@ export {
   CreateDraftRequestSchema,
   CreateDraftResponseSchema,
   CreatePageRequestSchema,
+  CrowiCodeSidecarSchema,
+  CrowiDiagramNodeSchema,
+  CrowiDiagramSidecarSchema,
+  CrowiDimensionSchema,
+  CrowiImagePayloadSchema,
+  CrowiLinkCardNodeSchema,
+  CrowiLinkCardSidecarSchema,
+  CrowiMathSidecarSchema,
+  CrowiOpaqueNodeSchema,
+  CrowiPlaceholderKindSchema,
+  CrowiPlaceholderNodeSchema,
+  CrowiPlaceholderSidecarSchema,
   CryptoStatusResponseSchema,
   DEVICE_CODE_GRANT_TYPE,
   DISCOVERY_SCOPES_SUPPORTED,
-  DND_EXTRA_UPLOAD_MIME,
   DYNAMIC_CAPABILITIES,
   DeleteAdminUserResponseSchema,
   DeleteCommentRequestSchema,
@@ -6555,7 +6966,11 @@ export {
   GetSeenUsersRequestSchema,
   GetStorageStatusResponseSchema,
   GetWatchStatusRequestSchema,
-  IMAGE_UPLOAD_MIME,
+  HChildSchema,
+  HChildrenSchema,
+  HNameSchema,
+  HPropertiesSchema,
+  HastHintDataSchema,
   ISSUABLE_SCOPES,
   InstallerStatusResponseSchema,
   InsufficientScopeErrorSchema,
@@ -6590,6 +7005,7 @@ export {
   ListRevisionsResponseSchema,
   ListUsersRequestSchema,
   ListUsersResponseSchema,
+  LooseRenderedAstRootSchema,
   MailSettingsValidationErrorSchema,
   MailTokenPayloadSchema,
   MailTokenPurposeSchema,
@@ -6653,6 +7069,7 @@ export {
   PreviewPageRequestSchema,
   PreviewPageResponseSchema,
   ProfileErrorResponseSchema,
+  RENDERED_AST_NODE_DEFS,
   RecentlyViewedPagesResponseSchema,
   ReencryptResponseSchema,
   RefreshTokenRequestSchema,
@@ -6666,6 +7083,13 @@ export {
   RenameSubtreeRequestSchema,
   RenameSubtreeResponseSchema,
   RenameTreeErrorSchema,
+  RenderedAstArtifactKeySchema,
+  RenderedAstEnvelopeOpenApiSchema,
+  RenderedAstEnvelopeSchema,
+  RenderedAstNodeSchema,
+  RenderedAstRootSchema,
+  RenderedAstValueSchema,
+  ReservationSchema,
   ResetPasswordRequestSchema,
   ResetPasswordResponseSchema,
   RevertToRevisionRequestSchema,
@@ -6677,6 +7101,7 @@ export {
   RevokeRequestSchema,
   RevokeResponseSchema,
   SCOPES,
+  SIDECAR_KEYS,
   STATIC_CAPABILITIES,
   STRIP_KNOWN_HTML_TAGS_MAX_LENGTH,
   SearchAdminUsersByEmailRequestSchema,
@@ -6696,6 +7121,9 @@ export {
   ServiceUnavailableErrorSchema,
   SetPageGrantRequestSchema,
   SetWatchStatusRequestSchema,
+  ShikiTokenLinesSchema,
+  ShikiTokenSchema,
+  ShikiTokenStyleSchema,
   StorageDriverEntrySchema,
   SuccessResponseSchema,
   ThemeSchema,
@@ -6708,6 +7136,7 @@ export {
   TokenAuthResponseSchema,
   TokenRequestSchema,
   TokenResponseSchema,
+  UPLOAD_ALLOWED_MIME,
   UpdateAdminUserEmailRequestSchema,
   UpdateAppSettingsRequestSchema,
   UpdateAppSettingsResponseSchema,
@@ -6889,6 +7318,7 @@ export {
   tokenRegisterRoute,
   tokenRoute,
   unlikePageRoute,
+  unwrapRenderedAst,
   updateAppSettingsRoute,
   updateAuthSettingsRoute,
   updateMailSettingsRoute,