@agent-native/core 0.160.0 → 0.161.0

package/corpus/templates/content/shared/blocks-field-identity.ts

@@ -4,6 +4,83 @@ export const BLOCKS_FIELD_IDENTITY_VERSION = 1;
 export const BLOCK_TOMBSTONE_REVISION_WINDOW = 20;
 export const MAX_BLOCK_TOMBSTONES_PER_FIELD = 500;
 
+export const BLOCKS_FIELD_BLOCK_KINDS = [
+  "paragraph",
+  "heading",
+  "horizontalRule",
+  "codeBlock",
+  "blockquote",
+  "bulletList",
+  "orderedList",
+  "listItem",
+  "taskList",
+  "taskItem",
+  "notionToggle",
+  "notionCallout",
+  "notionColumns",
+  "notionColumn",
+  "notionSyncedBlock",
+  "table",
+  "tableRow",
+  "tableHeader",
+  "tableCell",
+  "image",
+  "video",
+  "audio",
+  "notionBlockAtom",
+  "registryBlock",
+  "contentReference",
+  "localMdxComponent",
+] as const;
+
+export type BlocksFieldBlockKind = (typeof BLOCKS_FIELD_BLOCK_KINDS)[number];
+export type BlocksFieldBlockOperation =
+  | "insert"
+  | "update"
+  | "upsert"
+  | "delete"
+  | "reorder";
+
+const FULL_BLOCK_OPERATIONS = [
+  "insert",
+  "update",
+  "upsert",
+  "delete",
+  "reorder",
+] as const;
+const ORDER_ONLY_BLOCK_OPERATIONS = ["delete", "reorder"] as const;
+
+export const BLOCKS_FIELD_OPERATION_CAPABILITIES: Readonly<
+  Record<BlocksFieldBlockKind, readonly BlocksFieldBlockOperation[]>
+> = {
+  paragraph: FULL_BLOCK_OPERATIONS,
+  heading: FULL_BLOCK_OPERATIONS,
+  horizontalRule: FULL_BLOCK_OPERATIONS,
+  codeBlock: FULL_BLOCK_OPERATIONS,
+  blockquote: FULL_BLOCK_OPERATIONS,
+  bulletList: [],
+  orderedList: [],
+  listItem: ORDER_ONLY_BLOCK_OPERATIONS,
+  taskList: [],
+  taskItem: ORDER_ONLY_BLOCK_OPERATIONS,
+  notionToggle: FULL_BLOCK_OPERATIONS,
+  notionCallout: FULL_BLOCK_OPERATIONS,
+  notionColumns: FULL_BLOCK_OPERATIONS,
+  notionColumn: FULL_BLOCK_OPERATIONS,
+  notionSyncedBlock: FULL_BLOCK_OPERATIONS,
+  table: FULL_BLOCK_OPERATIONS,
+  tableRow: [],
+  tableHeader: [],
+  tableCell: [],
+  image: FULL_BLOCK_OPERATIONS,
+  video: FULL_BLOCK_OPERATIONS,
+  audio: FULL_BLOCK_OPERATIONS,
+  notionBlockAtom: FULL_BLOCK_OPERATIONS,
+  registryBlock: FULL_BLOCK_OPERATIONS,
+  contentReference: FULL_BLOCK_OPERATIONS,
+  localMdxComponent: FULL_BLOCK_OPERATIONS,
+};
+
 export type BlocksFieldIdentityStatus = "legacy" | "materialized" | "stale";
 
 export interface BlocksFieldBlock {
@@ -46,7 +123,7 @@ export interface StoredBlocksFieldIdentity {
   blocks: StoredBlocksFieldBlock[];
 }
 
-interface BlockSnapshot {
+export interface BlocksFieldBlockSnapshot {
   path: string;
   parentPath: string | null;
   kind: string;
@@ -57,34 +134,7 @@ interface BlockSnapshot {
   preferredId: string | null;
 }
 
-const BLOCK_NODE_TYPES = new Set([
-  "paragraph",
-  "heading",
-  "horizontalRule",
-  "codeBlock",
-  "blockquote",
-  "bulletList",
-  "orderedList",
-  "listItem",
-  "taskList",
-  "taskItem",
-  "notionToggle",
-  "notionCallout",
-  "notionColumns",
-  "notionColumn",
-  "notionSyncedBlock",
-  "table",
-  "tableRow",
-  "tableHeader",
-  "tableCell",
-  "image",
-  "video",
-  "audio",
-  "notionBlockAtom",
-  "registryBlock",
-  "contentReference",
-  "localMdxComponent",
-]);
+const BLOCK_NODE_TYPES = new Set<string>(BLOCKS_FIELD_BLOCK_KINDS);
 
 const NON_ADDRESSABLE_NODE_TYPES = new Set([
   "bulletList",
@@ -133,8 +183,10 @@ function nodeMarkdown(node: PMNode): string {
   return docToNfm({ type: "doc", content: [node] });
 }
 
-function snapshotMarkdown(markdown: string): BlockSnapshot[] {
-  const snapshots: BlockSnapshot[] = [];
+export function snapshotBlocksFieldMarkdown(
+  markdown: string,
+): BlocksFieldBlockSnapshot[] {
+  const snapshots: BlocksFieldBlockSnapshot[] = [];
   const doc = nfmToDoc(markdown);
 
   function visit(nodes: PMNode[] | undefined, parentPath: string | null) {
@@ -172,7 +224,7 @@ function snapshotMarkdown(markdown: string): BlockSnapshot[] {
 
 function deterministicBlockId(
   fieldId: string,
-  snapshot: Pick<BlockSnapshot, "path" | "kind" | "contentHash">,
+  snapshot: Pick<BlocksFieldBlockSnapshot, "path" | "kind" | "contentHash">,
 ): string {
   return `block_${hashString(
     `${fieldId}\0${snapshot.path}\0${snapshot.kind}\0${snapshot.contentHash}`,
@@ -225,7 +277,7 @@ export function legacyBlocksFieldIdentity(args: {
   markdown: string;
 }): BlocksFieldIdentity {
   const fieldId = blocksFieldId(args.documentId, args.propertyId);
-  const snapshots = snapshotMarkdown(args.markdown);
+  const snapshots = snapshotBlocksFieldMarkdown(args.markdown);
   const idByPath = new Map<string, string>();
   const usedIds = new Set<string>();
   const blocks: StoredBlocksFieldBlock[] = snapshots.map((snapshot) => {
@@ -308,9 +360,10 @@ export function reconcileBlocksFieldIdentity(args: {
   previous: StoredBlocksFieldIdentity;
   markdown: string;
   createId: () => string;
+  preferredIdsByPath?: Readonly<Record<string, string>>;
 }): StoredBlocksFieldIdentity {
   const nextRevision = args.previous.revision + 1;
-  const snapshots = snapshotMarkdown(args.markdown);
+  const snapshots = snapshotBlocksFieldMarkdown(args.markdown);
   const previousLive = args.previous.blocks.filter(
     (block) => block.state === "live",
   );
@@ -320,6 +373,21 @@ export function reconcileBlocksFieldIdentity(args: {
   const matchedPrevious = new Set<number>();
   const assigned = new Map<number, StoredBlocksFieldBlock>();
   const usedIds = new Set(args.previous.blocks.map((block) => block.id));
+  const assignedNextIds = new Set<string>();
+
+  const previousLiveById = new Map(
+    previousLive.map((block, index) => [block.id, index]),
+  );
+  for (let nextIndex = 0; nextIndex < snapshots.length; nextIndex++) {
+    const explicitId = args.preferredIdsByPath?.[snapshots[nextIndex]!.path];
+    if (!explicitId) continue;
+    const previousIndex = previousLiveById.get(explicitId);
+    if (previousIndex === undefined || matchedPrevious.has(previousIndex)) {
+      continue;
+    }
+    matchedPrevious.add(previousIndex);
+    assigned.set(nextIndex, previousLive[previousIndex]!);
+  }
 
   const previousExact = uniqueIndexByKey(
     previousLive,
@@ -440,8 +508,9 @@ export function reconcileBlocksFieldIdentity(args: {
   const recoveredIds = new Set<string>();
   const idByPath = new Map<string, string>();
   const nextBlocks = snapshots.map((snapshot, nextIndex) => {
+    const explicitId = args.preferredIdsByPath?.[snapshot.path];
     let previous = assigned.get(nextIndex);
-    if (!previous) {
+    if (!previous && !explicitId) {
       const recoveredIndex = recoverable.get(
         `${snapshot.kind}\0${snapshot.contentHash}`,
       );
@@ -453,16 +522,24 @@ export function reconcileBlocksFieldIdentity(args: {
         }
       }
     }
+    if (explicitId && usedIds.has(explicitId) && explicitId !== previous?.id) {
+      throw new Error(`Preferred Block ID is already reserved: ${explicitId}`);
+    }
     let id =
+      explicitId ??
       previous?.id ??
       fieldScopedBlockId(
         args.previous.fieldId,
         snapshot.preferredId ?? args.createId(),
       );
-    while (usedIds.has(id) && id !== previous?.id) {
+    while (
+      assignedNextIds.has(id) ||
+      (!explicitId && usedIds.has(id) && id !== previous?.id)
+    ) {
       id = fieldScopedBlockId(args.previous.fieldId, args.createId());
     }
     usedIds.add(id);
+    assignedNextIds.add(id);
     idByPath.set(snapshot.path, id);
     return {
       id,
@@ -537,7 +614,7 @@ export function materializeLegacyBlocksFieldIdentity(args: {
   markdown: string;
 }): StoredBlocksFieldIdentity {
   const publicState = legacyBlocksFieldIdentity(args);
-  const snapshots = snapshotMarkdown(args.markdown);
+  const snapshots = snapshotBlocksFieldMarkdown(args.markdown);
   return {
     fieldId: publicState.fieldId,
     revision: 0,

package/corpus/templates/content/shared/database-block-actions.ts

@@ -0,0 +1,82 @@
+import type { ContentDatabaseMutationTarget } from "./api.js";
+import type {
+  BlocksFieldBlockKind,
+  BlocksFieldBlockOperation,
+  BlocksFieldIdentityStatus,
+} from "./blocks-field-identity.js";
+
+export interface ContentDatabaseBlockTarget extends ContentDatabaseMutationTarget {
+  itemId: string;
+  rowDocumentId: string;
+  propertyId: string;
+}
+
+export interface ContentDatabaseBlockValue {
+  format: "nfm";
+  nfm: string;
+}
+
+export interface ContentDatabaseBlock {
+  id: string;
+  parentId: string | null;
+  kind: BlocksFieldBlockKind;
+  index: number;
+  addressable: boolean;
+  value: ContentDatabaseBlockValue;
+  supportedOperations: readonly BlocksFieldBlockOperation[];
+  degraded: boolean;
+}
+
+export interface ContentDatabaseBlocksReadResult {
+  target: ContentDatabaseBlockTarget;
+  rowLink: { urlPath: string; label: string };
+  schemaRevision: string;
+  rowRevision: string;
+  fieldRevision: number;
+  identityStatus: BlocksFieldIdentityStatus;
+  total: number;
+  order: string[];
+  blocks: ContentDatabaseBlock[];
+  page: { offset: number; limit: number; nextCursor: string | null };
+}
+
+export type ContentDatabaseBlockMutationOperation =
+  | "insert"
+  | "update"
+  | "upsert"
+  | "delete"
+  | "reorder";
+
+export interface ContentDatabaseBlockMutationReceipt {
+  receiptId: string;
+  operation: ContentDatabaseBlockMutationOperation;
+  outcome: "inserted" | "updated" | "deleted" | "reordered" | "unchanged";
+  target: ContentDatabaseBlockTarget;
+  rowLink: { urlPath: string; label: string };
+  schemaRevision: string;
+  idempotency: {
+    key: string;
+    result: "applied" | "replayed";
+    payloadDigest: string;
+  };
+  revisions: {
+    row: { before: string; after: string };
+    field: { before: number; after: number };
+  };
+  affected: {
+    blockIds: string[];
+    deletedBlockIds: string[];
+    order: string[];
+  };
+  readback: {
+    verified: true;
+    fieldRevision: number;
+    contentHash: string;
+    order: string[];
+    blocks: ContentDatabaseBlock[];
+  };
+}
+
+export interface ContentDatabaseBlockMutationResult {
+  receipt: ContentDatabaseBlockMutationReceipt;
+}

package/corpus/templates/content/shared/database-block-mutations.ts

@@ -0,0 +1,366 @@
+import {
+  BLOCKS_FIELD_BLOCK_KINDS,
+  BLOCKS_FIELD_OPERATION_CAPABILITIES,
+  type BlocksFieldBlockKind,
+  type BlocksFieldBlockOperation,
+  type BlocksFieldIdentity,
+} from "./blocks-field-identity.js";
+import { docToNfm, nfmToDoc, type PMDoc, type PMNode } from "./nfm.js";
+
+type Placement =
+  | { placement: "start" | "end"; parentBlockId?: string | null }
+  | { placement: "before" | "after"; anchorBlockId: string };
+
+export type BlockDocumentMutation =
+  | {
+      operation: "insert";
+      block: { kind: BlocksFieldBlockKind; nfm: string };
+      position: Placement;
+    }
+  | {
+      operation: "update" | "upsert";
+      blockId: string;
+      block: { kind: BlocksFieldBlockKind; nfm: string };
+      position?: Placement;
+    }
+  | { operation: "delete"; blockId: string }
+  | { operation: "reorder"; blockId: string; position: Placement };
+
+interface NodeRef {
+  node: PMNode;
+  nodes: PMNode[];
+  nodeIndex: number;
+  path: string;
+  parentPath: string | null;
+}
+
+export interface BlockDocumentMutationResult {
+  markdown: string;
+  preferredIdsByPath: Record<string, string>;
+  requestedBlockId: string | null;
+  deletedCandidateIds: string[];
+  changed: boolean;
+}
+
+const BLOCK_KIND_SET = new Set<string>(BLOCKS_FIELD_BLOCK_KINDS);
+
+function collectNodeRefs(doc: PMDoc): NodeRef[] {
+  const refs: NodeRef[] = [];
+  const visit = (nodes: PMNode[] | undefined, parentPath: string | null) => {
+    let blockPosition = 0;
+    for (let nodeIndex = 0; nodeIndex < (nodes?.length ?? 0); nodeIndex++) {
+      const node = nodes![nodeIndex]!;
+      if (!BLOCK_KIND_SET.has(node.type)) continue;
+      const path =
+        parentPath === null
+          ? `${blockPosition}`
+          : `${parentPath}.${blockPosition}`;
+      refs.push({ node, nodes: nodes!, nodeIndex, path, parentPath });
+      visit(node.content, path);
+      blockPosition++;
+    }
+  };
+  visit(doc.content, null);
+  return refs;
+}
+
+function indexIdentity(markdown: string, identity: BlocksFieldIdentity) {
+  const doc = nfmToDoc(markdown);
+  const refs = collectNodeRefs(doc);
+  if (refs.length !== identity.blocks.length) {
+    throw new Error("Blocks identity does not match the current field body.");
+  }
+  const byId = new Map<string, NodeRef>();
+  const idByNode = new Map<PMNode, string>();
+  refs.forEach((ref, index) => {
+    const block = identity.blocks[index]!;
+    if (block.kind !== ref.node.type) {
+      throw new Error(
+        "Blocks identity kind does not match the current field body.",
+      );
+    }
+    byId.set(block.id, ref);
+    idByNode.set(ref.node, block.id);
+  });
+  return { doc, byId, idByNode };
+}
+
+function parsedBlock(kind: BlocksFieldBlockKind, nfm: string): PMNode {
+  const doc = nfmToDoc(nfm);
+  if (doc.content.length !== 1 || doc.content[0]?.type !== kind) {
+    throw new Error(
+      `Block value must be canonical NFM containing exactly one top-level ${kind} block.`,
+    );
+  }
+  return doc.content[0];
+}
+
+function requireOperation(
+  kind: BlocksFieldBlockKind,
+  operation: BlocksFieldBlockOperation,
+) {
+  const supported = BLOCKS_FIELD_OPERATION_CAPABILITIES[
+    kind
+  ] as readonly string[];
+  if (!supported.includes(operation as string)) {
+    throw new Error(`Block kind "${kind}" does not support ${operation}.`);
+  }
+}
+
+function destination(
+  position: Placement,
+  byId: Map<string, NodeRef>,
+  doc: PMDoc,
+): { nodes: PMNode[]; index: number; parentPath: string | null } {
+  if ("anchorBlockId" in position) {
+    const anchor = byId.get(position.anchorBlockId);
+    if (!anchor) throw new Error("Anchor block not found.");
+    return {
+      nodes: anchor.nodes,
+      index: anchor.nodeIndex + (position.placement === "after" ? 1 : 0),
+      parentPath: anchor.parentPath,
+    };
+  }
+  if (!position.parentBlockId) {
+    return {
+      nodes: doc.content,
+      index: position.placement === "start" ? 0 : doc.content.length,
+      parentPath: null,
+    };
+  }
+  const parent = byId.get(position.parentBlockId);
+  if (!parent) throw new Error("Parent block not found.");
+  const nodes = (parent.node.content ??= []);
+  return {
+    nodes,
+    index: position.placement === "start" ? 0 : nodes.length,
+    parentPath: parent.path,
+  };
+}
+
+function assertCompatibleParent(
+  parentPath: string | null,
+  kind: BlocksFieldBlockKind,
+  byId: Map<string, NodeRef>,
+) {
+  const parent = [...byId.values()].find(
+    (ref) => ref.path === parentPath,
+  )?.node;
+  const parentKind = parent?.type;
+  const generalContainerKinds = new Set([
+    "blockquote",
+    "listItem",
+    "taskItem",
+    "notionToggle",
+    "notionCallout",
+    "notionColumn",
+    "notionSyncedBlock",
+    "tableHeader",
+    "tableCell",
+  ]);
+  const valid =
+    parentKind === undefined
+      ? ![
+          "listItem",
+          "taskItem",
+          "notionColumn",
+          "tableRow",
+          "tableHeader",
+          "tableCell",
+        ].includes(kind)
+      : parentKind === "bulletList" || parentKind === "orderedList"
+        ? kind === "listItem"
+        : parentKind === "taskList"
+          ? kind === "taskItem"
+          : parentKind === "notionColumns"
+            ? kind === "notionColumn"
+            : parentKind === "table"
+              ? kind === "tableRow"
+              : parentKind === "tableRow"
+                ? kind === "tableHeader" || kind === "tableCell"
+                : generalContainerKinds.has(parentKind) &&
+                  ![
+                    "listItem",
+                    "taskItem",
+                    "notionColumn",
+                    "tableRow",
+                    "tableHeader",
+                    "tableCell",
+                  ].includes(kind);
+  if (!valid) {
+    throw new Error(
+      `Block kind "${kind}" is not valid inside ${parentKind ?? "the field root"}.`,
+    );
+  }
+}
+
+function repositionNode(args: {
+  blockId: string;
+  current: NodeRef;
+  node: PMNode;
+  position: Placement;
+  byId: Map<string, NodeRef>;
+  doc: PMDoc;
+}) {
+  if (
+    "anchorBlockId" in args.position &&
+    args.position.anchorBlockId === args.blockId
+  ) {
+    throw new Error("A block cannot be reordered relative to itself.");
+  }
+  const target = destination(args.position, args.byId, args.doc);
+  if (target.parentPath !== args.current.parentPath) {
+    throw new Error("Cross-parent block reorder is not supported.");
+  }
+  args.current.nodes.splice(args.current.nodeIndex, 1);
+  const targetIndex =
+    "anchorBlockId" in args.position
+      ? (() => {
+          const anchor = args.byId.get(args.position.anchorBlockId);
+          if (!anchor || anchor.nodes !== target.nodes) {
+            throw new Error("Reorder anchor is outside the current parent.");
+          }
+          const anchorIndex = target.nodes.indexOf(anchor.node);
+          return anchorIndex + (args.position.placement === "after" ? 1 : 0);
+        })()
+      : args.position.placement === "start"
+        ? 0
+        : target.nodes.length;
+  target.nodes.splice(targetIndex, 0, args.node);
+}
+
+function preferredIds(
+  doc: PMDoc,
+  idByNode: Map<PMNode, string>,
+  requestedNode?: PMNode,
+  requestedId?: string,
+  createInsertedDescendantId?: () => string,
+) {
+  const requestedDescendants = new Set<PMNode>();
+  const collectRequestedDescendants = (nodes: PMNode[] | undefined) => {
+    for (const node of nodes ?? []) {
+      requestedDescendants.add(node);
+      collectRequestedDescendants(node.content);
+    }
+  };
+  if (requestedId && requestedNode) {
+    collectRequestedDescendants(requestedNode.content);
+  }
+  return Object.fromEntries(
+    collectNodeRefs(doc).flatMap((ref) => {
+      const id =
+        idByNode.get(ref.node) ??
+        (ref.node === requestedNode
+          ? requestedId
+          : requestedDescendants.has(ref.node)
+            ? createInsertedDescendantId?.()
+            : undefined);
+      if (
+        requestedDescendants.has(ref.node) &&
+        !id &&
+        !createInsertedDescendantId
+      ) {
+        throw new Error(
+          "Inserting a nested block requires fresh descendant Block IDs.",
+        );
+      }
+      return id ? [[ref.path, id]] : [];
+    }),
+  );
+}
+
+export function mutateBlocksFieldDocument(args: {
+  markdown: string;
+  identity: BlocksFieldIdentity;
+  mutation: BlockDocumentMutation;
+  insertedBlockId?: string;
+  createInsertedDescendantId?: () => string;
+}): BlockDocumentMutationResult {
+  const indexed = indexIdentity(args.markdown, args.identity);
+  const { doc, byId, idByNode } = indexed;
+  const before = docToNfm(doc);
+  let requestedNode: PMNode | undefined;
+  let requestedBlockId: string | null = null;
+  let deletedCandidateIds: string[] = [];
+
+  if (args.mutation.operation === "insert") {
+    requireOperation(args.mutation.block.kind, "insert");
+    requestedNode = parsedBlock(
+      args.mutation.block.kind,
+      args.mutation.block.nfm,
+    );
+    const target = destination(args.mutation.position, byId, doc);
+    assertCompatibleParent(target.parentPath, args.mutation.block.kind, byId);
+    target.nodes.splice(target.index, 0, requestedNode);
+  } else {
+    const current = byId.get(args.mutation.blockId);
+    if (!current) throw new Error("Block not found.");
+    const currentKind = current.node.type as BlocksFieldBlockKind;
+    requireOperation(currentKind, args.mutation.operation);
+    requestedBlockId = args.mutation.blockId;
+
+    if (
+      args.mutation.operation === "update" ||
+      args.mutation.operation === "upsert"
+    ) {
+      if (args.mutation.block.kind !== currentKind) {
+        throw new Error("Individual block mutations cannot change block kind.");
+      }
+      requestedNode = parsedBlock(currentKind, args.mutation.block.nfm);
+      current.nodes[current.nodeIndex] = requestedNode;
+      current.node = requestedNode;
+      idByNode.set(requestedNode, args.mutation.blockId);
+      if (args.mutation.operation === "upsert" && args.mutation.position) {
+        repositionNode({
+          blockId: args.mutation.blockId,
+          current,
+          node: requestedNode,
+          position: args.mutation.position,
+          byId,
+          doc,
+        });
+      }
+    } else if (args.mutation.operation === "delete") {
+      deletedCandidateIds = args.identity.blocks
+        .filter((block) => {
+          const ref = byId.get(block.id);
+          return (
+            ref?.path === current.path ||
+            ref?.path.startsWith(`${current.path}.`)
+          );
+        })
+        .map((block) => block.id);
+      current.nodes.splice(current.nodeIndex, 1);
+    } else if (args.mutation.operation === "reorder") {
+      repositionNode({
+        blockId: args.mutation.blockId,
+        current,
+        node: current.node,
+        position: args.mutation.position,
+        byId,
+        doc,
+      });
+    }
+  }
+
+  const markdown = docToNfm(doc);
+  const preferredIdsByPath = preferredIds(
+    doc,
+    idByNode,
+    requestedNode,
+    args.insertedBlockId,
+    args.createInsertedDescendantId,
+  );
+  const identityOrderChanged = collectNodeRefs(doc).some(
+    (ref, index) =>
+      preferredIdsByPath[ref.path] !== undefined &&
+      preferredIdsByPath[ref.path] !== args.identity.blocks[index]?.id,
+  );
+  return {
+    markdown,
+    preferredIdsByPath,
+    requestedBlockId,
+    deletedCandidateIds,
+    changed: markdown !== before || identityOrderChanged,
+  };
+}

package/corpus/templates/content/shared/nfm.ts

@@ -986,7 +986,8 @@ function serializeToggle(node: PMNode, ind: number): string[] {
     return out;
   }
   const attrStr = serializeAttrs([["color", isColor(color) ? color : null]]);
-  out.push(indentStr(ind) + `<details${attrStr}>`);
+  const openAttr = node.attrs?.open === true ? " open" : "";
+  out.push(indentStr(ind) + `<details${attrStr}${openAttr}>`);
   out.push(indentStr(ind) + `<summary>${summary}</summary>`);
   out.push(...serializeBlocks(node.content || [], ind + 1));
   out.push(indentStr(ind) + "</details>");
@@ -2006,7 +2007,7 @@ function parseContainer(
       attrs: {
         summary,
         headingLevel: null,
-        open: false,
+        open: attrs.open !== undefined || /(?:^|\s)open(?:\s|>)/.test(openLine),
         color: isColor(attrs.color) ? attrs.color : null,
         indent: 0,
       },