@agent-native/core 0.101.7 → 0.101.11

package/corpus/templates/content/app/components/editor/extensions/NotionExtensions.tsx

@@ -1,3 +1,4 @@
+import { findTrailingPlainInlineMath } from "@shared/inline-math";
 import {
   escapeHtml,
   indentMarkdown,
@@ -10,6 +11,7 @@ import {
   IconExternalLink,
   IconFileText,
 } from "@tabler/icons-react";
+import { InputRule } from "@tiptap/core";
 import type { Fragment, Node as ProseMirrorNode } from "@tiptap/pm/model";
 import {
   Mark,
@@ -21,6 +23,8 @@ import {
   type NodeViewProps,
 } from "@tiptap/react";
 
+import { MathRenderer } from "../MathRenderer";
+
 const BLOCK_ATOM_TAGS = [
   "page",
   "database",
@@ -452,6 +456,17 @@ function BlockAtomView({ node, extension }: NodeViewProps) {
   const canOpenLocalPage = Boolean(pageLink && options.onOpenPageLink);
   const externalUrl = safeExternalPageUrl(attrs.url || attrs.href || null);
 
+  if (tagName === "equation") {
+    return (
+      <NodeViewWrapper
+        className="content-equation"
+        data-latex={label || attrs.latex || ""}
+      >
+        <MathRenderer latex={label || attrs.latex || ""} displayMode={true} />
+      </NodeViewWrapper>
+    );
+  }
+
   if (tagName === "page") {
     const openPage = () => {
       if (pageLink && options.onOpenPageLink) {
@@ -511,6 +526,36 @@ function BlockAtomView({ node, extension }: NodeViewProps) {
   );
 }
 
+function InlineAtomView({ node }: NodeViewProps) {
+  const tagName = (node.attrs.tagName || "mention") as string;
+  const label = (node.attrs.label || "") as string;
+  const attrs = parseAttrsJson(node.attrs.attrsJson as string);
+
+  if (tagName === "math") {
+    const latex = label || attrs.latex || "";
+    return (
+      <NodeViewWrapper
+        as="span"
+        className="content-inline-equation"
+        contentEditable={false}
+        data-latex={latex}
+      >
+        <MathRenderer latex={latex} displayMode={false} />
+      </NodeViewWrapper>
+    );
+  }
+
+  return (
+    <NodeViewWrapper
+      as="span"
+      className="notion-inline-atom"
+      contentEditable={false}
+    >
+      {label || humanizeTag(tagName)}
+    </NodeViewWrapper>
+  );
+}
+
 export const NotionSpanMark = Mark.create({
   name: "notionSpan",
 
@@ -975,6 +1020,35 @@ export const NotionInlineAtom = Node.create({
   atom: true,
   selectable: false,
 
+  addInputRules() {
+    return [
+      new InputRule({
+        find: (text) => {
+          const match = findTrailingPlainInlineMath(text);
+          if (!match) return null;
+          return {
+            index: match.from,
+            text: text.slice(match.from, match.to),
+            data: { latex: match.latex },
+          };
+        },
+        handler: ({ state, range, match }) => {
+          const latex = match.data?.latex;
+          if (typeof latex !== "string") return null;
+
+          const mathNode = state.schema.nodes.notionInlineAtom?.create({
+            tagName: "math",
+            attrsJson: "{}",
+            label: latex,
+          });
+          if (!mathNode) return null;
+
+          state.tr.replaceWith(range.from, range.to, mathNode).scrollIntoView();
+        },
+      }),
+    ];
+  },
+
   addAttributes() {
     return {
       tagName: { default: "mention-user" },
@@ -1023,6 +1097,10 @@ export const NotionInlineAtom = Node.create({
     ];
   },
 
+  addNodeView() {
+    return ReactNodeViewRenderer(InlineAtomView);
+  },
+
   addStorage() {
     return {
       markdown: {

package/corpus/templates/content/app/components/editor/previewDocumentSaveController.ts

@@ -61,12 +61,39 @@ export interface PreviewDocumentPayload {
   loadedContentWasEmpty?: boolean;
 }
 
-export interface PreviewDocumentSaveSkipped {
-  skipped: true;
+export interface PreviewDocumentSaveDeferred {
+  outcome: "deferred";
+  reason: "hydration" | "conflict";
+  conflictSnapshot?: PreviewDocumentDraftSnapshot;
 }
 
-export function skippedPreviewDocumentSave(): PreviewDocumentSaveSkipped {
-  return { skipped: true };
+export interface PreviewDocumentSaveAdapter {
+  save: (
+    documentId: string,
+    payload: PreviewDocumentPayload,
+    baseline?: PreviewDocumentPayload,
+  ) => Promise<unknown>;
+  onSaved?: (payload: PreviewDocumentPayload) => void;
+  onError?: (error: unknown) => void;
+  onDraftConflict?: (snapshot: PreviewDocumentDraftSnapshot) => void;
+}
+
+export interface PreviewDocumentDraftSnapshot {
+  lastSaved: PreviewDocumentPayload;
+  pending: PreviewDocumentPayload;
+  deferredReason: PreviewDocumentSaveDeferred["reason"] | null;
+}
+
+/**
+ * The save could not run yet, but the payload is still user-owned and must stay
+ * dirty until a later flush can persist it. This is intentionally different
+ * from success: callers must never advance or reset the confirmed baseline.
+ */
+export function deferredPreviewDocumentSave(
+  reason: PreviewDocumentSaveDeferred["reason"] = "hydration",
+  conflictSnapshot?: PreviewDocumentDraftSnapshot,
+): PreviewDocumentSaveDeferred {
+  return { outcome: "deferred", reason, conflictSnapshot };
 }
 
 export interface PreviewDocumentSaveController {
@@ -89,6 +116,19 @@ export interface PreviewDocumentSaveController {
   cancel(): void;
   /** Adopt `payload` as the confirmed-saved baseline (no save scheduled). */
   mark(payload: PreviewDocumentPayload): void;
+  /**
+   * Adopt a fresher server baseline while retaining the user's pending title
+   * and content. Used only after an explicit "keep local draft" choice.
+   */
+  rebasePending(payload: PreviewDocumentPayload): void;
+  /** Replace callbacks captured by an older preview mount. */
+  replaceSaveAdapter(adapter: PreviewDocumentSaveAdapter): void;
+  /** Serializable dirty state for bounded browser draft storage. */
+  draftSnapshot(): PreviewDocumentDraftSnapshot;
+  /** Restore a previously persisted dirty draft into a fresh controller. */
+  restoreDraft(snapshot: PreviewDocumentDraftSnapshot): void;
+  /** Notify whichever preview mount currently owns this controller. */
+  notifyDraftConflict(snapshot: PreviewDocumentDraftSnapshot): void;
   /** The payload last CONFIRMED persisted. */
   readonly lastSaved: PreviewDocumentPayload;
   /** The latest payload the user has typed (may differ from lastSaved). */
@@ -97,6 +137,8 @@ export interface PreviewDocumentSaveController {
   readonly hasPendingTimer: boolean;
   /** Whether a save() call is currently outstanding (in flight). */
   readonly isSaving: boolean;
+  /** Why the latest attempted save remains dirty, if it was deferred. */
+  readonly deferredReason: PreviewDocumentSaveDeferred["reason"] | null;
   /**
    * Whether this controller has confirmed at least one local save since creation.
    * Until the server query echoes that payload, clean local state is newer than
@@ -109,25 +151,21 @@ function payloadsEqual(a: PreviewDocumentPayload, b: PreviewDocumentPayload) {
   return a.title === b.title && a.content === b.content;
 }
 
-export function createPreviewDocumentSaveController(args: {
-  /**
-   * The document id this controller persists to, fixed for its entire life. A
-   * controller NEVER changes which document it targets — switching rows acquires
-   * a different controller (see previewDocumentSaveRegistry).
-   */
-  documentId: string;
-  initial: PreviewDocumentPayload;
-  /** Persist `payload` to this controller's document. */
-  save: (
-    documentId: string,
-    payload: PreviewDocumentPayload,
-  ) => Promise<unknown>;
-  onSaved?: (payload: PreviewDocumentPayload) => void;
-  onError?: (error: unknown) => void;
-  debounceMs?: number;
-  setTimeoutFn?: typeof setTimeout;
-  clearTimeoutFn?: typeof clearTimeout;
-}): PreviewDocumentSaveController {
+export function createPreviewDocumentSaveController(
+  args: PreviewDocumentSaveAdapter & {
+    /**
+     * The document id this controller persists to, fixed for its entire life. A
+     * controller NEVER changes which document it targets — switching rows acquires
+     * a different controller (see previewDocumentSaveRegistry).
+     */
+    documentId: string;
+    initial: PreviewDocumentPayload;
+    /** Persist `payload` to this controller's document. */
+    debounceMs?: number;
+    setTimeoutFn?: typeof setTimeout;
+    clearTimeoutFn?: typeof clearTimeout;
+  },
+): PreviewDocumentSaveController {
   const documentId = args.documentId;
   const debounceMs = args.debounceMs ?? 450;
   const setTimeoutFn = args.setTimeoutFn ?? setTimeout;
@@ -137,6 +175,13 @@ export function createPreviewDocumentSaveController(args: {
   let pending: PreviewDocumentPayload = { ...args.initial };
   let timer: ReturnType<typeof setTimeout> | null = null;
   let hasSavedLocally = false;
+  let deferredReason: PreviewDocumentSaveDeferred["reason"] | null = null;
+  let saveAdapter: PreviewDocumentSaveAdapter = {
+    save: args.save,
+    onSaved: args.onSaved,
+    onError: args.onError,
+    onDraftConflict: args.onDraftConflict,
+  };
 
   // The single in-flight save, or null when idle. A debounced edit made while
   // this is set does NOT start a new save; it updates `pending` and a trailing
@@ -161,29 +206,42 @@ export function createPreviewDocumentSaveController(args: {
     if (payloadsEqual(pending, lastSaved)) return; // nothing dirty.
 
     const attempted = { ...pending };
-    const promise = Promise.resolve(args.save(documentId, attempted))
+    const promise = Promise.resolve(
+      saveAdapter.save(documentId, attempted, { ...lastSaved }),
+    )
       .then((result) => {
         if (
           result &&
           typeof result === "object" &&
-          "skipped" in result &&
-          result.skipped === true
+          "outcome" in result &&
+          result.outcome === "deferred" &&
+          "reason" in result &&
+          (result.reason === "hydration" || result.reason === "conflict")
         ) {
-          pending = { ...lastSaved };
+          // Hydration can begin after a keystroke but before the debounce fires.
+          // Keep the attempted payload dirty so the registry can retain it across
+          // close/reopen and a later flush can retry it. A deferred save is not a
+          // successful save, and user-authored content is never disposable.
+          deferredReason = result.reason;
           inFlight = null;
+          const deferredResult = result as PreviewDocumentSaveDeferred;
+          if (deferredResult.conflictSnapshot) {
+            saveAdapter.onDraftConflict?.(deferredResult.conflictSnapshot);
+          }
           return;
         }
         lastSaved = attempted;
         hasSavedLocally = true;
+        deferredReason = null;
         inFlight = null;
-        args.onSaved?.(attempted);
+        saveAdapter.onSaved?.(attempted);
         // A trailing edit may have landed while this save was in flight. Issue
         // exactly one more for the LATEST payload. Bounded: stops once quiescent.
         kick();
       })
       .catch((error) => {
         inFlight = null;
-        args.onError?.(error);
+        saveAdapter.onError?.(error);
       });
     inFlight = promise;
   }
@@ -201,10 +259,12 @@ export function createPreviewDocumentSaveController(args: {
     documentId,
     changeTitle(title: string) {
       pending = { ...pending, title };
+      deferredReason = null;
       schedule();
     },
     changeContent(content: string) {
       pending = { ...pending, content };
+      deferredReason = null;
       schedule();
     },
     flush() {
@@ -233,6 +293,38 @@ export function createPreviewDocumentSaveController(args: {
       lastSaved = { ...payload };
       pending = { ...payload };
       hasSavedLocally = false;
+      deferredReason = null;
+    },
+    rebasePending(payload: PreviewDocumentPayload) {
+      clearTimer();
+      lastSaved = { ...payload };
+      pending = {
+        ...pending,
+        loadedUpdatedAt: payload.loadedUpdatedAt,
+        loadedContentWasEmpty: payload.loadedContentWasEmpty,
+      };
+      hasSavedLocally = false;
+      deferredReason = null;
+    },
+    replaceSaveAdapter(adapter: PreviewDocumentSaveAdapter) {
+      saveAdapter = adapter;
+    },
+    draftSnapshot() {
+      return {
+        lastSaved: { ...lastSaved },
+        pending: { ...pending },
+        deferredReason,
+      };
+    },
+    restoreDraft(snapshot: PreviewDocumentDraftSnapshot) {
+      clearTimer();
+      lastSaved = { ...snapshot.lastSaved };
+      pending = { ...snapshot.pending };
+      deferredReason = snapshot.deferredReason;
+      hasSavedLocally = false;
+    },
+    notifyDraftConflict(snapshot: PreviewDocumentDraftSnapshot) {
+      saveAdapter.onDraftConflict?.(snapshot);
     },
     get lastSaved() {
       return { ...lastSaved };
@@ -246,6 +338,9 @@ export function createPreviewDocumentSaveController(args: {
     get isSaving() {
       return inFlight !== null;
     },
+    get deferredReason() {
+      return deferredReason;
+    },
     get hasSavedLocally() {
       return hasSavedLocally;
     },

package/corpus/templates/content/app/components/editor/previewDocumentSaveRegistry.ts

@@ -67,12 +67,14 @@ function controllerIsDirty(controller: PreviewDocumentSaveController): boolean {
 export function acquirePreviewDocumentSaveController(
   documentId: string,
   factory: () => PreviewDocumentSaveController,
+  refreshAdapter?: (controller: PreviewDocumentSaveController) => void,
 ): PreviewDocumentSaveController {
   let entry = registry.get(documentId);
   if (!entry) {
     entry = { controller: factory(), refCount: 0, evicting: false };
     registry.set(documentId, entry);
   }
+  refreshAdapter?.(entry.controller);
   entry.refCount += 1;
   // A reopen before a pending eviction settled: keep the instance alive.
   entry.evicting = false;

package/corpus/templates/content/app/global.css

@@ -364,6 +364,21 @@
   line-height: 1.45;
 }
 
+.notion-editor h5 {
+  font-size: 1em;
+  font-weight: 600;
+  margin: 0.8em 0 0.15em;
+  line-height: 1.5;
+}
+
+.notion-editor h6 {
+  font-size: 0.95em;
+  font-weight: 600;
+  margin: 0.75em 0 0.15em;
+  line-height: 1.5;
+  color: hsl(var(--muted-foreground));
+}
+
 /* Paragraphs */
 .notion-editor p {
   margin: 0.5em 0;
@@ -408,7 +423,9 @@
 .notion-editor h1.is-empty::before,
 .notion-editor h2.is-empty::before,
 .notion-editor h3.is-empty::before,
-.notion-editor h4.is-empty::before {
+.notion-editor h4.is-empty::before,
+.notion-editor h5.is-empty::before,
+.notion-editor h6.is-empty::before {
   content: attr(data-placeholder);
   float: left;
   color: hsl(var(--muted-foreground));
@@ -1201,6 +1218,59 @@ div[data-notion-column] > :last-child {
   white-space: nowrap;
 }
 
+.content-inline-equation {
+  display: inline-block;
+  max-width: 100%;
+  margin: 0 0.08em;
+  vertical-align: -0.08em;
+}
+
+.content-equation {
+  display: block;
+  max-width: 100%;
+  margin: 1em 0;
+  overflow-x: auto;
+  padding: 0.25rem 0;
+}
+
+.content-math {
+  color: inherit;
+}
+
+.content-math--inline {
+  display: inline-block;
+}
+
+.content-math--block {
+  display: block;
+  min-width: max-content;
+  text-align: center;
+}
+
+.content-math-error {
+  border: 1px solid hsl(var(--destructive) / 0.3);
+  border-radius: 0.375rem;
+  background: hsl(var(--destructive) / 0.06);
+  color: hsl(var(--foreground));
+  font-family:
+    "JetBrains Mono Variable", ui-monospace, SFMono-Regular, Menlo, Consolas,
+    monospace;
+  white-space: pre-wrap;
+}
+
+.content-math-error--inline {
+  padding: 0.05rem 0.25rem;
+  font-size: 0.9em;
+}
+
+.content-math-error--block {
+  display: block;
+  width: 100%;
+  padding: 0.75rem 0.9rem;
+  overflow-wrap: anywhere;
+  text-align: left;
+}
+
 .notion-editor span[data-notion-span="true"][underline="true"] {
   text-decoration: underline;
   text-underline-offset: 3px;

package/corpus/templates/content/app/hooks/use-content-database.ts

@@ -4,6 +4,8 @@ import type {
   AddDatabaseItemRequest,
   AttachContentDatabaseSourceRequest,
   BuilderCmsModelsResponse,
+  CancelPreparedBuilderSourceUpdateRequest,
+  CancelPreparedBuilderSourceUpdateResponse,
   ChangeContentDatabaseSourceRoleRequest,
   ContentDatabaseResponse,
   ContentDatabasePersonalViewResponse,
@@ -25,6 +27,7 @@ import type {
   ExecuteBuilderSourceExecutionRequest,
   MoveDatabaseItemRequest,
   PrepareBuilderSourceExecutionRequest,
+  PreviewBuilderSourceReviewResponse,
   PrepareBuilderSourceReviewRequest,
   PrepareBuilderSourceReviewResponse,
   ProcessBuilderBodyHydrationRequest,
@@ -815,6 +818,27 @@ export function useAddContentDatabaseSourceFieldProperty(documentId: string) {
   });
 }
 
+export function useMaterializeBuilderRequiredFields(documentId: string) {
+  const queryClient = useQueryClient();
+  return useActionMutation<
+    ContentDatabaseResponse,
+    { documentId: string; sourceId: string }
+  >("materialize-builder-required-fields", {
+    onSuccess: (data) => {
+      writeContentDatabaseResponseToCache(queryClient, documentId, data);
+      queryClient.invalidateQueries({
+        queryKey: contentDatabaseQueryKey(documentId),
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["action", "get-content-database-source", { documentId }],
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["action", "list-document-properties", { documentId }],
+      });
+    },
+  });
+}
+
 export function useBuilderCmsModels(enabled: boolean) {
   return useActionQuery<BuilderCmsModelsResponse>(
     "list-builder-cms-models",
@@ -1014,6 +1038,23 @@ export function usePrepareBuilderSourceExecution(documentId: string) {
   });
 }
 
+export function useCancelPreparedBuilderSourceUpdate(documentId: string) {
+  const queryClient = useQueryClient();
+  return useActionMutation<
+    CancelPreparedBuilderSourceUpdateResponse,
+    CancelPreparedBuilderSourceUpdateRequest
+  >("cancel-prepared-builder-source-update", {
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: contentDatabaseQueryKey(documentId),
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["action", "get-content-database-source", { documentId }],
+      });
+    },
+  });
+}
+
 export function useValidateBuilderSourceExecution(documentId: string) {
   const queryClient = useQueryClient();
   return useActionMutation<
@@ -1099,6 +1140,33 @@ export function usePrepareBuilderSourceReview(documentId: string) {
   });
 }
 
+export function usePreviewBuilderSourceReview(args: {
+  documentId: string;
+  sourceId: string | null;
+  scope: "selected" | "all";
+  documentIds?: string[];
+  enabled: boolean;
+}) {
+  return useActionQuery<PreviewBuilderSourceReviewResponse>(
+    "preview-builder-source-review",
+    args.enabled && args.sourceId
+      ? {
+          documentId: args.documentId,
+          sourceId: args.sourceId,
+          scope: args.scope,
+          documentIds: args.documentIds,
+        }
+      : undefined,
+    {
+      enabled: args.enabled && !!args.sourceId,
+      retry: false,
+      staleTime: 0,
+      gcTime: 0,
+      refetchOnWindowFocus: false,
+    },
+  );
+}
+
 export function useStageBuilderSourceBulkUpdate(documentId: string) {
   const queryClient = useQueryClient();
   return useActionMutation<

package/corpus/templates/content/app/hooks/use-documents.ts

@@ -92,13 +92,15 @@ export function seedDatabaseItemDocumentCaches(
   // Seed only cold caches. Overwriting an existing entry would bump its
   // freshness with possibly older table-snapshot data (a background database
   // refetch can lag a just-saved document edit) and suppress the correcting
-  // refetch for the whole staleTime window. Rows whose Builder body has not
-  // hydrated yet, or whose source-backed list snapshot intentionally omits the
-  // body, are never seeded: their empty table-snapshot `content` would render as
-  // an authoritative empty document.
+  // refetch for the whole staleTime window. Source-backed rows are never seeded:
+  // list snapshots are not authoritative enough to unlock the body editor, even
+  // when they happen to contain non-empty content. The dedicated get-document
+  // response owns that decision and prevents an edit from racing hydration.
   if (
     !databaseItemBodyHydrationIsPending(item) &&
     !sourceBackedEmptyBody &&
+    !item.bodyHydration &&
+    !item.document.databaseMembership?.sourceId &&
     queryClient.getQueryData(documentQueryKey(item.document.id)) === undefined
   ) {
     queryClient.setQueryData<Document>(documentQueryKey(item.document.id), {
@@ -139,6 +141,53 @@ export function useDocument(id: string | null) {
   });
 }
 
+export interface PreviewDocumentDraftRecord {
+  documentId: string;
+  title: string;
+  content: string;
+  baseDocumentUpdatedAt: string | null;
+  loadedContentWasEmpty: number;
+  deferredReason: string | null;
+  version: number;
+  updatedAt: string;
+}
+
+export function usePreviewDocumentDraft(documentId: string | null) {
+  return useActionQuery<{ draft: PreviewDocumentDraftRecord | null }>(
+    "get-preview-document-draft",
+    documentId ? { documentId } : undefined,
+    { enabled: !!documentId, retry: false },
+  );
+}
+
+export function useUpdatePreviewDocumentDraft() {
+  return useActionMutation<
+    {
+      status: "saved" | "deleted" | "conflict";
+      draft: PreviewDocumentDraftRecord | null;
+    },
+    | {
+        operation: "upsert";
+        documentId: string;
+        expectedVersion: number | null;
+        draft: {
+          title: string;
+          content: string;
+          baseDocumentUpdatedAt: string | null;
+          loadedContentWasEmpty: boolean;
+          deferredReason: "hydration" | "conflict" | null;
+        };
+      }
+    | {
+        operation: "delete";
+        documentId: string;
+        expectedVersion: number;
+        expectedTitle: string;
+        expectedContent: string;
+      }
+  >("update-preview-document-draft");
+}
+
 export function useCreateDocument() {
   return useActionMutation<Document, DocumentCreateRequest>("create-document");
 }