@dxos/plugin-markdown 0.8.4-main.fcfe5033a5 → 0.8.4-staging.60fe92afc8

package/src/operations/create.test.ts

@@ -6,26 +6,24 @@ import { describe, expect, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 
 import { MemoizedAiService } from '@dxos/ai/testing';
-import { AgentService } from '@dxos/assistant';
-import { AssistantTestLayer } from '@dxos/assistant/testing';
-import { Blueprint } from '@dxos/blueprints';
 import { SpaceProperties } from '@dxos/client-protocol';
-import { DXN, Database, Feed, Obj, Query } from '@dxos/echo';
-import { Collection } from '@dxos/echo';
+import { Blueprint, Operation } from '@dxos/compute';
+import { Collection, Database, EID, Feed, Obj, Query } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
+import { AgentService } from '@dxos/functions-runtime';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 import { invariant } from '@dxos/invariant';
-import { ObjectId } from '@dxos/keys';
-import { Operation } from '@dxos/operation';
-import { Markdown } from '@dxos/plugin-markdown/types';
+import { EntityId } from '@dxos/keys';
+import { Markdown } from '@dxos/plugin-markdown';
 import { HasSubject } from '@dxos/types';
 
 import { WithProperties } from '#testing';
 
 import MarkdownBlueprint from '../blueprints/markdown-blueprint';
-import { Create } from './definitions';
+import { MarkdownOperation } from '../types';
 import { MarkdownOperationHandlerSet } from './index';
 
-ObjectId.dangerouslyDisableRandomness();
+EntityId.dangerouslyDisableRandomness();
 
 const TestLayer = AssistantTestLayer({
   aiServicePreset: 'edge-remote',
@@ -49,12 +47,12 @@ describe('create', () => {
       function* (_) {
         const name = 'BlueYard';
         const content = 'Founders and portfolio of BlueYard.';
-        const result = yield* Operation.invoke(Create, {
+        const result = yield* Operation.invoke(MarkdownOperation.Create, {
           name,
           content,
         });
 
-        const doc = yield* Database.resolve(DXN.parse(result.id), Markdown.Document);
+        const doc = yield* Database.resolve(EID.parse(result.id), Markdown.Document);
         expect(doc.name).toBe(name);
         const text = yield* Database.load(doc.content);
         expect(text.content).toBe(content);
@@ -76,7 +74,7 @@ describe('create', () => {
         yield* agent.waitForCompletion();
 
         {
-          const docs = yield* Database.runQuery(Query.type(Markdown.Document));
+          const docs = yield* Database.query(Query.type(Markdown.Document)).run;
           if (docs.length !== 1) {
             throw new Error(`Expected 1 document; got ${docs.length}: ${docs.map((_) => _.name)}`);
           }

package/src/operations/create.ts

@@ -4,21 +4,34 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Obj } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
-import { CollectionModel } from '@dxos/schema';
+import { CollectionModel } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { Database, Obj } from '@dxos/echo';
 
-import { Markdown } from '../types';
-import { Create } from './definitions';
+import { Markdown, MarkdownOperation } from '../types';
 
-const handler: Operation.WithHandler<typeof Create> = Create.pipe(
+const handler: Operation.WithHandler<typeof MarkdownOperation.Create> = MarkdownOperation.Create.pipe(
   Operation.withHandler(
     Effect.fn(function* ({ name, content }) {
-      const object = Markdown.make({ name, content });
-      yield* CollectionModel.add({ object });
+      // Add the object to the database directly so it is persisted with a space-qualified URI and is
+      // resolvable by id. `CollectionModel.add` only pushes a `Ref` into the space root collection;
+      // when that collection does not yet exist (e.g. a freshly-created space in a headless/agent
+      // flow) it builds a detached collection that never triggers the transitive ref-save, leaving
+      // the object unattached — so a returned `echo:/<id>` never resolves.
+      const object = yield* Database.add(Markdown.make({ name, content }));
+
+      // Best-effort: add to the space root collection for navigation. Concurrent sub-agents both
+      // materializing the root collection can throw EntityNotFoundError while loading a
+      // not-yet-flushed collection ref; the document itself is already persisted above, so swallow
+      // ONLY that transient case and let any other (non-race) failure surface.
+      yield* CollectionModel.add({ object }).pipe(Effect.catchTag('EntityNotFoundError', () => Effect.void));
+
+      // Persist before returning the id so other tools/processes (e.g. an agent's add-artifact, run
+      // as a separate invocation) can resolve the freshly-created document.
+      yield* Database.flush();
 
       return {
-        id: Obj.getDXN(object).toString(),
+        id: Obj.getURI(object),
       };
     }),
   ),

package/src/operations/index.ts

@@ -2,9 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { OperationHandlerSet } from '@dxos/operation';
-
-export * as MarkdownOperation from './definitions';
+import { OperationHandlerSet } from '@dxos/compute';
 
 export const MarkdownOperationHandlerSet = OperationHandlerSet.lazy(
   () => import('./create'),
@@ -12,5 +10,5 @@ export const MarkdownOperationHandlerSet = OperationHandlerSet.lazy(
   () => import('./open'),
   () => import('./scroll-to-anchor'),
   () => import('./set-view-mode'),
-  () => import('./update'),
+  () => import('./update-markdown'),
 );

package/src/operations/open.ts

@@ -4,12 +4,12 @@
 
 import * as Effect from 'effect/Effect';
 
+import { Operation } from '@dxos/compute';
 import { Database } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
 
-import { Open } from './definitions';
+import { MarkdownOperation } from '../types';
 
-const handler: Operation.WithHandler<typeof Open> = Open.pipe(
+const handler: Operation.WithHandler<typeof MarkdownOperation.Open> = MarkdownOperation.Open.pipe(
   Operation.withHandler(
     Effect.fn(function* ({ doc }) {
       const { content } = yield* doc.pipe(

package/src/operations/scroll-to-anchor.ts

@@ -6,31 +6,33 @@ import { EditorView } from '@codemirror/view';
 import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';
-import { Operation } from '@dxos/operation';
-import { Cursor, setSelection } from '@dxos/ui-editor';
+import { Operation } from '@dxos/compute';
+import { Cursor, isRangeVisible, scrollThreadIntoView } from '@dxos/ui-editor';
 
-import { MarkdownCapabilities } from '../types';
-import { ScrollToAnchor } from './definitions';
+import { MarkdownCapabilities, MarkdownOperation } from '../types';
 
-const handler: Operation.WithHandler<typeof ScrollToAnchor> = ScrollToAnchor.pipe(
+const SCROLL_OPTIONS = { y: 'start', yMargin: 96 } as const;
+
+const handler: Operation.WithHandler<typeof MarkdownOperation.ScrollToAnchor> = MarkdownOperation.ScrollToAnchor.pipe(
   Operation.withHandler(
-    Effect.fnUntraced(function* ({ subject, cursor }) {
+    Effect.fnUntraced(function* ({ subject, cursor, ref }) {
       const editorViews = yield* Capability.get(MarkdownCapabilities.EditorViews);
       const entry = editorViews.get(subject);
       if (!entry) {
         return;
       }
+
+      // When a thread ref is supplied, delegate to the shared editor helper which
+      // scrolls (only if not already visible) and marks the comment current.
+      if (ref) {
+        scrollThreadIntoView(entry.view, ref, SCROLL_OPTIONS);
+        return;
+      }
+
+      // Fallback: no thread ref — scroll the cursor range into view if needed.
       const range = Cursor.getRangeFromCursor(entry.view.state, cursor);
-      if (range) {
-        const selection = entry.view.state.selection.main.from !== range.from ? { anchor: range.from } : undefined;
-        const effects: any[] = [EditorView.scrollIntoView(range.from, { y: 'start', yMargin: 96 })];
-        if (selection) {
-          effects.push(setSelection.of({ current: entry.documentId }));
-        }
-        entry.view.dispatch({
-          effects,
-          selection: selection ? { anchor: range.from } : undefined,
-        });
+      if (range && !isRangeVisible(entry.view, range)) {
+        entry.view.dispatch({ effects: EditorView.scrollIntoView(range.from, SCROLL_OPTIONS) });
       }
     }),
   ),

package/src/operations/set-view-mode.ts

@@ -5,12 +5,11 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities } from '@dxos/app-framework';
-import { Operation } from '@dxos/operation';
+import { Operation } from '@dxos/compute';
 
-import { MarkdownCapabilities } from '../types';
-import { SetViewMode } from './definitions';
+import { MarkdownCapabilities, MarkdownOperation } from '../types';
 
-const handler: Operation.WithHandler<typeof SetViewMode> = SetViewMode.pipe(
+const handler: Operation.WithHandler<typeof MarkdownOperation.SetViewMode> = MarkdownOperation.SetViewMode.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* ({ id, viewMode }) {
       yield* Capabilities.updateAtomValue(MarkdownCapabilities.State, (current) => ({

package/src/operations/{update.ts → update-markdown.ts}

@@ -5,13 +5,13 @@
 import { next as A, type Doc } from '@automerge/automerge';
 import * as Effect from 'effect/Effect';
 
+import { Operation } from '@dxos/compute';
 import { Database } from '@dxos/echo';
-import { DocAccessor, createDocAccessor } from '@dxos/echo-db';
-import { Operation } from '@dxos/operation';
+import { DocAccessor, createDocAccessor } from '@dxos/echo-client';
 
-import { Update } from './definitions';
+import { MarkdownOperation } from '../types';
 
-const handler: Operation.WithHandler<typeof Update> = Update.pipe(
+const handler: Operation.WithHandler<typeof MarkdownOperation.Update> = MarkdownOperation.Update.pipe(
   Operation.withHandler(
     Effect.fn(function* ({ doc, edits }) {
       const content = yield* doc.pipe(