@agent-native/core-corpus 0.214.0 → 0.217.0

package/corpus/templates/content/server/lib/suggested-edits.ts

@@ -236,11 +236,32 @@ function matchesDocumentRevision(
   );
 }
 
+type LockedSuggestionTarget = {
+  current: Record<string, unknown>;
+  primaryBlocksFields: Awaited<ReturnType<typeof lockPrimaryBlocksFields>>;
+  identityTx: ReturnType<typeof drizzleTransactionForExec>;
+};
+
+// A proposal decision places every member on the Page in memory, then commits
+// the result once: one write, one Page version, one Yjs update.
+type DeferredProposalCommit = LockedSuggestionTarget & {
+  content: string;
+  /** The Page after each earlier member, kept only for Blocks identity. */
+  intermediateContents: string[];
+  /** Whether a member added or removed a top-level block. */
+  blockCountChanged: boolean;
+  document: ProseMirrorNode;
+  ctx: Record<string, unknown> | undefined;
+  orgId: string | null;
+  operationId: string;
+  now: string;
+};
+
 type ContentDecisionCoordination = {
   ydoc: PreparedYDocMutationLease;
   sync: TransactionalChange;
   deferPersistence?: boolean;
-  finalContent?: string;
+  proposal?: DeferredProposalCommit;
 };
 
 export function publishPersistedAcceptedSuggestion(
@@ -587,6 +608,263 @@ async function reanchorSourceComment(
   });
 }
 
+async function readSuggestionTarget(tx: DbExec, documentId: string) {
+  const current = (
+    await tx.execute({
+      sql: "SELECT id,title,content,body_revision,owner_email,org_id,updated_at,source_mode,source_kind,source_path,trashed_at FROM documents WHERE id = ?",
+      args: [documentId],
+    })
+  ).rows[0];
+  if (!current) throw new Error("Document not found");
+  if (
+    current.source_mode ||
+    current.source_kind ||
+    current.source_path ||
+    current.trashed_at
+  ) {
+    throw new Error("This Page can no longer accept suggestions");
+  }
+  const sourceLink = await tx.execute({
+    sql: "SELECT state FROM document_sync_links WHERE document_id = ? AND state != 'unlinked' LIMIT 1",
+    args: [documentId],
+  });
+  if (sourceLink.rows.length) {
+    throw new Error("Externally linked Pages cannot accept suggestions yet");
+  }
+  return current;
+}
+
+async function placeSuggestion(
+  tx: DbExec,
+  suggestion: ResourceSuggestion,
+  operation: SuggestionOperation,
+  currentContent: string,
+) {
+  let nextContent = applyMarkdownSuggestionOperation(currentContent, operation);
+  if (nextContent === null) {
+    const accepted = await acceptedRangesOnSameText(
+      tx,
+      suggestion,
+      markdownPayload(operation.before, "before").markdown,
+    );
+    if (accepted.length)
+      nextContent = applyMarkdownSuggestionOperation(
+        currentContent,
+        withSiblingRanges(operation, accepted),
+      );
+  }
+  if (nextContent === null) {
+    const error = new Error(
+      "The text around this suggestion changed, so it can't be placed on the current Page. It's still pending: reject it, or suggest the edit again.",
+    );
+    error.name = "SuggestionStaleError";
+    throw error;
+  }
+  return nextContent;
+}
+
+async function lockSuggestionTarget(tx: DbExec, documentId: string) {
+  const eligiblePrimaryIds = await assertSuggestionBodyTarget(tx, documentId);
+  const identityTx = drizzleTransactionForExec(tx);
+  await tx.execute({
+    sql: "SELECT id FROM documents WHERE id = ? FOR UPDATE",
+    args: [documentId],
+  });
+  // Memberships have no document foreign key. Never wait for the table after
+  // locking the Page: other editors lock memberships before the Page.
+  try {
+    await tx.execute(
+      "LOCK TABLE content_database_items IN SHARE ROW EXCLUSIVE MODE NOWAIT",
+    );
+  } catch (error) {
+    if (
+      error &&
+      typeof error === "object" &&
+      "code" in error &&
+      error.code === "55P03"
+    ) {
+      fail("The Page is busy. Try accepting the suggestion again.", {
+        statusCode: 409,
+        errorCode: "suggestion_conflict",
+      });
+    }
+    throw error;
+  }
+  const primaryBlocksFields = await lockPrimaryBlocksFields(
+    identityTx,
+    documentId,
+  );
+  const currentTargets = await tx.execute({
+    sql: `SELECT d.system_role, p.id FROM content_database_items i
+          INNER JOIN content_databases d ON d.id = i.database_id AND d.deleted_at IS NULL
+          LEFT JOIN document_property_definitions p ON p.id = d.primary_blocks_property_id AND p.database_id = d.id AND p.type = 'blocks'
+          WHERE i.document_id = ?`,
+    args: [documentId],
+  });
+  const hasOrdinaryMembership = currentTargets.rows.some(
+    (row) => row.system_role === null,
+  );
+  const hasEligibleTarget = currentTargets.rows.some(
+    (row) =>
+      (row.system_role === null ||
+        (row.system_role === "files" && !hasOrdinaryMembership)) &&
+      eligiblePrimaryIds.includes(String(row.id)) &&
+      primaryBlocksFields.some((field) => field.propertyId === row.id),
+  );
+  if (
+    !hasEligibleTarget &&
+    (eligiblePrimaryIds.length > 0 || currentTargets.rows.length > 0)
+  ) {
+    fail(
+      "This database item has no primary Blocks field for body suggestions.",
+      {
+        statusCode: 409,
+        errorCode: "suggestion_body_unavailable",
+      },
+    );
+  }
+  return { primaryBlocksFields, identityTx };
+}
+
+/** Writes accepted suggestion content as one Page revision and history entry. */
+async function commitAcceptedContent(input: {
+  tx: DbExec;
+  documentId: string;
+  target: LockedSuggestionTarget;
+  nextContent: string;
+  intermediateContents?: readonly string[];
+  blockCountChanged?: boolean;
+  nextDocument: ProseMirrorNode;
+  ydoc: PreparedYDocMutationLease;
+  ctx: Record<string, unknown> | undefined;
+  orgId: string | null;
+  operationId: string;
+  now: string;
+  afterWrite: () => Promise<void>;
+}) {
+  const { tx, documentId, nextContent, now } = input;
+  const { current, primaryBlocksFields, identityTx } = input.target;
+  const currentContent = String(current.content);
+  const bodyRevision = Number(current.body_revision);
+  replacePreparedCollabContent(input.ydoc, input.nextDocument);
+  const nextBodyRevision = bodyRevision + 1;
+  const nextRevision = documentRevisionToken(nextBodyRevision, nextContent);
+  const intent = {
+    writerId: `suggestion:${String(current.owner_email)}`,
+    operationId: input.operationId,
+    authoredBaseRevision: bodyRevision,
+  };
+  const planned = mergeDocumentBodyIntents({
+    authoredBaseContent: currentContent,
+    authoredCandidateContent: nextContent,
+    currentContent,
+    currentRevision: bodyRevision,
+    incoming: intent,
+    priorIntents: [],
+  });
+  if (planned.status !== "resolved") {
+    throw new Error(
+      "The accepted suggestion cannot preserve document structure",
+    );
+  }
+  const applied = await commitCanonicalDocumentBodyMutation({
+    write: async () => {
+      const updated = await tx.execute({
+        sql: "UPDATE documents SET content = ?, body_revision = ?, collab_body_revision = ?, updated_at = ? WHERE id = ? AND body_revision = ? AND updated_at = ? AND content = ?",
+        args: [
+          nextContent,
+          nextBodyRevision,
+          nextBodyRevision,
+          now,
+          documentId,
+          bodyRevision,
+          current.updated_at,
+          currentContent,
+        ],
+      });
+      return updated.rowsAffected === 1;
+    },
+    afterWrite: async () => {
+      if (
+        currentContent.includes("<callout") ||
+        nextContent.includes("<callout")
+      ) {
+        const actorEmail = input.ctx?.userEmail;
+        if (typeof actorEmail !== "string" || !actorEmail) {
+          throw new Error("Authentication is required to accept a suggestion");
+        }
+        await syncPrivateCalloutReferences(identityTx, {
+          documentId,
+          before: currentContent,
+          after: nextContent,
+          userEmail: actorEmail,
+          ownerEmail: String(current.owner_email),
+          orgId: current.org_id === null ? null : String(current.org_id),
+        });
+      }
+      for (const field of primaryBlocksFields) {
+        await persistBlocksFieldIdentity({
+          db: identityTx,
+          ownerEmail: field.ownerEmail,
+          documentId,
+          propertyId: field.propertyId,
+          previousMarkdown: currentContent,
+          markdown: nextContent,
+          intermediateMarkdown: input.intermediateContents,
+          now,
+        });
+      }
+      await recordDocumentHistoryTransition({
+        db: identityTx,
+        ownerEmail: String(current.owner_email),
+        documentId,
+        before: { title: String(current.title), content: currentContent },
+        after: { title: String(current.title), content: nextContent },
+        beforeBodyRevision: bodyRevision,
+        afterBodyRevision: nextBodyRevision,
+        cause: {
+          ctx: input.ctx as ActionRunContext | undefined,
+          operation: "accept-suggestion",
+          origin: "suggestion",
+        },
+        now,
+      });
+      await recordDocumentBodyIntent({
+        db: identityTx,
+        ownerEmail: String(current.owner_email),
+        orgId: input.orgId ?? "",
+        documentId,
+        intent,
+        candidateHash: documentContentHash(nextContent),
+        committedRevision: nextBodyRevision,
+        // Changed blocks are recorded by position. After a proposal member
+        // adds or removes a block, the blocks below it move, so the whole
+        // decision records none, as that member's own save did. A stale save
+        // over them is then kept for review rather than merged into a block
+        // that moved.
+        changedBlockIndexes: input.blockCountChanged
+          ? []
+          : planned.changedBlockIndexes,
+        canonicalChanged: true,
+        now,
+      });
+      await input.afterWrite();
+    },
+  });
+  if (!applied) {
+    const error = new Error("The Page changed while accepting this suggestion");
+    error.name = "SuggestionStaleError";
+    throw error;
+  }
+  return {
+    resourceId: documentId,
+    updatedAt: now,
+    revision: nextRevision,
+    baseRevision: nextRevision,
+    bodyRevision: nextBodyRevision,
+  };
+}
+
 export const contentDocumentSuggestionAdapter: SuggestionAdapter = {
   kind: CONTENT_DOCUMENT_SUGGESTION_ADAPTER,
   version: 1,
@@ -762,15 +1040,29 @@ export const contentDocumentSuggestionAdapter: SuggestionAdapter = {
     const coordination = context.coordination as
       | ContentDecisionCoordination
       | undefined;
-    if (
-      !coordination?.deferPersistence ||
-      coordination.finalContent === undefined
-    ) {
+    const proposal = coordination?.proposal;
+    if (!coordination?.deferPersistence || !proposal) {
       throw new Error("Content proposal decision coordination is incomplete");
     }
     const tx = context.transaction as DbExec;
-    await coordination.ydoc.persist(tx, coordination.finalContent);
-    await coordination.sync.persist(tx);
+    await commitAcceptedContent({
+      tx,
+      documentId: context.resourceId,
+      target: proposal,
+      nextContent: proposal.content,
+      intermediateContents: proposal.intermediateContents,
+      blockCountChanged: proposal.blockCountChanged,
+      nextDocument: proposal.document,
+      ydoc: coordination.ydoc,
+      ctx: proposal.ctx,
+      orgId: proposal.orgId,
+      operationId: proposal.operationId,
+      now: proposal.now,
+      afterWrite: async () => {
+        await coordination.ydoc.persist(tx, proposal.content);
+        await coordination.sync.persist(tx);
+      },
+    });
   },
   async apply(context) {
     const operations = validateOperations(context.operations);
@@ -782,56 +1074,18 @@ export const contentDocumentSuggestionAdapter: SuggestionAdapter = {
     if (!coordination) {
       throw new Error("Content suggestion decision coordination is missing");
     }
-    const current = (
-      await tx.execute({
-        sql: "SELECT id,title,content,body_revision,owner_email,org_id,updated_at,source_mode,source_kind,source_path,trashed_at FROM documents WHERE id = ?",
-        args: [context.resourceId],
-      })
-    ).rows[0];
-    if (!current) throw new Error("Document not found");
-    const currentDocument = {
-      bodyRevision: Number(current.body_revision),
-      content: String(current.content),
-    };
-    if (
-      current.source_mode ||
-      current.source_kind ||
-      current.source_path ||
-      current.trashed_at
-    ) {
-      throw new Error("This Page can no longer accept suggestions");
-    }
-    const sourceLink = await tx.execute({
-      sql: "SELECT state FROM document_sync_links WHERE document_id = ? AND state != 'unlinked' LIMIT 1",
-      args: [context.resourceId],
-    });
-    if (sourceLink.rows.length) {
-      throw new Error("Externally linked Pages cannot accept suggestions yet");
-    }
-    const currentContent = String(current.content);
-    let nextContent = applyMarkdownSuggestionOperation(
-      currentContent,
+    // Later proposal members land on the Page the earlier ones left, which
+    // this transaction already read and locked.
+    const placed = coordination.proposal;
+    const current =
+      placed?.current ?? (await readSuggestionTarget(tx, context.resourceId));
+    const currentContent = placed?.content ?? String(current.content);
+    const nextContent = await placeSuggestion(
+      tx,
+      context.suggestion,
       operation,
+      currentContent,
     );
-    if (nextContent === null) {
-      const accepted = await acceptedRangesOnSameText(
-        tx,
-        context.suggestion,
-        markdownPayload(operation.before, "before").markdown,
-      );
-      if (accepted.length)
-        nextContent = applyMarkdownSuggestionOperation(
-          currentContent,
-          withSiblingRanges(operation, accepted),
-        );
-    }
-    if (nextContent === null) {
-      const error = new Error(
-        "The text around this suggestion changed, so it can't be placed on the current Page. It's still pending: reject it, or suggest the edit again.",
-      );
-      error.name = "SuggestionStaleError";
-      throw error;
-    }
     const nextDocument = validateSuggestionStructure(
       currentContent,
       nextContent,
@@ -843,165 +1097,56 @@ export const contentDocumentSuggestionAdapter: SuggestionAdapter = {
         errorCode: "suggestion_body_unavailable",
       });
     }
-    const eligiblePrimaryIds = await assertSuggestionBodyTarget(
-      tx,
-      context.resourceId,
-    );
-    const identityTx = drizzleTransactionForExec(tx);
-    await tx.execute({
-      sql: "SELECT id FROM documents WHERE id = ? FOR UPDATE",
-      args: [context.resourceId],
-    });
-    // Memberships have no document foreign key. Never wait for the table after
-    // locking the Page: other editors lock memberships before the Page.
-    try {
-      await tx.execute(
-        "LOCK TABLE content_database_items IN SHARE ROW EXCLUSIVE MODE NOWAIT",
-      );
-    } catch (error) {
-      if (
-        error &&
-        typeof error === "object" &&
-        "code" in error &&
-        error.code === "55P03"
-      ) {
-        fail("The Page is busy. Try accepting the suggestion again.", {
-          statusCode: 409,
-          errorCode: "suggestion_conflict",
-        });
-      }
-      throw error;
-    }
-    const primaryBlocksFields = await lockPrimaryBlocksFields(
-      identityTx,
-      context.resourceId,
-    );
-    const currentTargets = await tx.execute({
-      sql: `SELECT d.system_role, p.id FROM content_database_items i
-            INNER JOIN content_databases d ON d.id = i.database_id AND d.deleted_at IS NULL
-            LEFT JOIN document_property_definitions p ON p.id = d.primary_blocks_property_id AND p.database_id = d.id AND p.type = 'blocks'
-            WHERE i.document_id = ?`,
-      args: [context.resourceId],
-    });
-    const hasOrdinaryMembership = currentTargets.rows.some(
-      (row) => row.system_role === null,
-    );
-    const hasEligibleTarget = currentTargets.rows.some(
-      (row) =>
-        (row.system_role === null ||
-          (row.system_role === "files" && !hasOrdinaryMembership)) &&
-        eligiblePrimaryIds.includes(String(row.id)) &&
-        primaryBlocksFields.some((field) => field.propertyId === row.id),
-    );
-    if (
-      !hasEligibleTarget &&
-      (eligiblePrimaryIds.length > 0 || currentTargets.rows.length > 0)
-    ) {
-      fail(
-        "This database item has no primary Blocks field for body suggestions.",
-        {
-          statusCode: 409,
-          errorCode: "suggestion_body_unavailable",
-        },
-      );
-    }
-    replacePreparedCollabContent(coordination.ydoc, nextDocument);
-    const now = new Date().toISOString();
-    const nextBodyRevision = currentDocument.bodyRevision + 1;
-    const nextRevision = documentRevisionToken(nextBodyRevision, nextContent);
-    const intent = {
-      writerId: `suggestion:${String(current.owner_email)}`,
-      operationId: context.suggestion.id,
-      authoredBaseRevision: currentDocument.bodyRevision,
+    const target = placed ?? {
+      current,
+      ...(await lockSuggestionTarget(tx, context.resourceId)),
     };
-    const planned = mergeDocumentBodyIntents({
-      authoredBaseContent: currentContent,
-      authoredCandidateContent: nextContent,
-      currentContent,
-      currentRevision: currentDocument.bodyRevision,
-      incoming: intent,
-      priorIntents: [],
-    });
-    if (planned.status !== "resolved") {
-      throw new Error(
-        "The accepted suggestion cannot preserve document structure",
+    const now = placed?.now ?? new Date().toISOString();
+    if (coordination.deferPersistence) {
+      await reanchorSourceComment(
+        tx,
+        context.resourceId,
+        context.suggestion,
+        currentContent,
+        nextContent,
+        now,
       );
+      const intermediateContents = placed?.intermediateContents ?? [];
+      // Blocks IDs are matched edit by edit, as when each edit was saved.
+      // Matching only the first and last Page can swap blocks whose text
+      // one edit hands to another.
+      if (placed && target.primaryBlocksFields.length)
+        intermediateContents.push(currentContent);
+      const blockCountChanged =
+        placed?.blockCountChanged === true ||
+        nextDocument.childCount !==
+          (placed?.document ?? parseSuggestionMarkdown(currentContent))
+            .childCount;
+      coordination.proposal = {
+        ...target,
+        content: nextContent,
+        intermediateContents,
+        blockCountChanged,
+        document: nextDocument,
+        ctx: placed?.ctx ?? context.ctx,
+        orgId: placed?.orgId ?? context.suggestion.orgId ?? null,
+        operationId: placed?.operationId ?? context.suggestion.id,
+        now,
+      };
+      return { resourceId: context.resourceId };
     }
-    const applied = await commitCanonicalDocumentBodyMutation({
-      write: async () => {
-        const updated = await tx.execute({
-          sql: "UPDATE documents SET content = ?, body_revision = ?, collab_body_revision = ?, updated_at = ? WHERE id = ? AND body_revision = ? AND updated_at = ? AND content = ?",
-          args: [
-            nextContent,
-            nextBodyRevision,
-            nextBodyRevision,
-            now,
-            context.resourceId,
-            currentDocument.bodyRevision,
-            current.updated_at,
-            currentContent,
-          ],
-        });
-        return updated.rowsAffected === 1;
-      },
+    return commitAcceptedContent({
+      tx,
+      documentId: context.resourceId,
+      target,
+      nextContent,
+      nextDocument,
+      ydoc: coordination.ydoc,
+      ctx: context.ctx,
+      orgId: context.suggestion.orgId ?? null,
+      operationId: context.suggestion.id,
+      now,
       afterWrite: async () => {
-        if (
-          currentContent.includes("<callout") ||
-          nextContent.includes("<callout")
-        ) {
-          const actorEmail = context.ctx?.userEmail;
-          if (typeof actorEmail !== "string" || !actorEmail) {
-            throw new Error(
-              "Authentication is required to accept a suggestion",
-            );
-          }
-          await syncPrivateCalloutReferences(identityTx, {
-            documentId: context.resourceId,
-            before: currentContent,
-            after: nextContent,
-            userEmail: actorEmail,
-            ownerEmail: String(current.owner_email),
-            orgId: current.org_id === null ? null : String(current.org_id),
-          });
-        }
-        for (const field of primaryBlocksFields) {
-          await persistBlocksFieldIdentity({
-            db: identityTx,
-            ownerEmail: field.ownerEmail,
-            documentId: context.resourceId,
-            propertyId: field.propertyId,
-            previousMarkdown: currentContent,
-            markdown: nextContent,
-            now,
-          });
-        }
-        await recordDocumentHistoryTransition({
-          db: identityTx,
-          ownerEmail: String(current.owner_email),
-          documentId: context.resourceId,
-          before: { title: String(current.title), content: currentContent },
-          after: { title: String(current.title), content: nextContent },
-          beforeBodyRevision: currentDocument.bodyRevision,
-          afterBodyRevision: nextBodyRevision,
-          cause: {
-            ctx: context.ctx as ActionRunContext | undefined,
-            operation: "accept-suggestion",
-            origin: "suggestion",
-          },
-          now,
-        });
-        await recordDocumentBodyIntent({
-          db: identityTx,
-          ownerEmail: String(current.owner_email),
-          orgId: context.suggestion.orgId ?? "",
-          documentId: context.resourceId,
-          intent,
-          candidateHash: documentContentHash(nextContent),
-          committedRevision: nextBodyRevision,
-          changedBlockIndexes: planned.changedBlockIndexes,
-          canonicalChanged: true,
-          now,
-        });
         await reanchorSourceComment(
           tx,
           context.resourceId,
@@ -1010,28 +1155,10 @@ export const contentDocumentSuggestionAdapter: SuggestionAdapter = {
           nextContent,
           now,
         );
-        if (coordination.deferPersistence) {
-          coordination.finalContent = nextContent;
-        } else {
-          await coordination.ydoc.persist(tx, nextContent);
-          await coordination.sync.persist(tx);
-        }
+        await coordination.ydoc.persist(tx, nextContent);
+        await coordination.sync.persist(tx);
       },
     });
-    if (!applied) {
-      const error = new Error(
-        "The Page changed while accepting this suggestion",
-      );
-      error.name = "SuggestionStaleError";
-      throw error;
-    }
-    return {
-      resourceId: context.resourceId,
-      updatedAt: now,
-      revision: nextRevision,
-      baseRevision: nextRevision,
-      bodyRevision: nextBodyRevision,
-    };
   },
   describeOperation(operation) {
     return operation.kind.split("_").join(" ");

package/corpus/templates/content/server/live-copy/binding.ts

@@ -0,0 +1,31 @@
+import {
+  createBoundedTaskRunner,
+  defineLiveCopy,
+} from "@agent-native/core/collab";
+
+import { LIVE_BODY_FIELD } from "../../shared/live-body.js";
+import { liveBodyWriterGate } from "../lib/live-body-writer.js";
+import { persistContentLiveCopy } from "./persist.js";
+import source from "./tasks.ts?bounded-task";
+import { liveBodyConversionFor } from "./write-cause.js";
+
+/** Edits `tasks.ts` defines, by name. */
+export const CONTENT_LIVE_COPY_EDITS = {
+  replaceBody: "replace-body",
+} as const;
+
+/**
+ * Content's page bodies as live copies. A page is covered while the D2 gate
+ * says `live_copy`, and while it is being switched. Eligibility uses the
+ * request's flag snapshot; persist rechecks flags in its locked transaction.
+ */
+export const contentLiveCopy = defineLiveCopy({
+  name: "content-body",
+  appliesTo: async (documentId) => {
+    if (liveBodyConversionFor(documentId) !== undefined) return true;
+    return (await liveBodyWriterGate(documentId)).writePath === "live_copy";
+  },
+  runner: createBoundedTaskRunner({ source }),
+  field: LIVE_BODY_FIELD,
+  persist: persistContentLiveCopy,
+});

package/corpus/templates/content/server/live-copy/bounded-task.d.ts

@@ -0,0 +1,6 @@
+// `import source from "./tasks.ts?bounded-task"` is bundled at build time by
+// core's bounded-task plugin into a source the worker runner evaluates.
+declare module "*?bounded-task" {
+  const source: import("@agent-native/core/collab").BoundedTaskSource;
+  export default source;
+}

package/corpus/templates/content/server/live-copy/exec-db.ts

@@ -0,0 +1 @@
+export { drizzleOverExec } from "../db/exec.js";