Merge PR #513: fix(obsidian): make cross-file resolution work in the WASM engine

Author: merge-queue-bot

editors/obsidian/src/main.test.ts

@@ -41,16 +41,23 @@ function makeApp(): {
     };
     workspace: {
       on(event: string, cb: () => unknown): unknown;
+      onLayoutReady(cb: () => unknown): void;
       getActiveViewOfType(_t: unknown): FakeView | null;
       getLeavesOfType(_t: string): unknown[];
     };
   };
   active: { view: FakeView | null };
   fireModify(path: string): void;
+  fireLayoutReady(): void;
+  layoutReadyCount(): number;
   modifyListenerCount(): number;
 } {
   type Handler = (f: FakeFile) => unknown;
   const vaultHandlers: Record<string, Handler[]> = {};
+  // Captured onLayoutReady callbacks. The fake never runs them eagerly,
+  // modelling Obsidian's cold start where the vault index is not ready
+  // when onload runs; fireLayoutReady() simulates the vault becoming ready.
+  const layoutReadyCbs: Array<() => unknown> = [];
   const active: { view: FakeView | null } = { view: null };
   return {
     app: {
@@ -71,6 +78,9 @@ function makeApp(): {
         on(_event: string, _cb: () => unknown): unknown {
           return {};
         },
+        onLayoutReady(cb: () => unknown): void {
+          layoutReadyCbs.push(cb);
+        },
         getActiveViewOfType(_t: unknown): FakeView | null {
           return active.view;
         },
@@ -83,6 +93,12 @@ function makeApp(): {
     fireModify(path: string): void {
       for (const cb of vaultHandlers["modify"] ?? []) cb({ path });
     },
+    fireLayoutReady(): void {
+      for (const cb of layoutReadyCbs) cb();
+    },
+    layoutReadyCount(): number {
+      return layoutReadyCbs.length;
+    },
     modifyListenerCount(): number {
       return vaultHandlers["modify"]?.length ?? 0;
     },
@@ -375,3 +391,30 @@ describe("engine-down / restart safety (Copilot review)", () => {
     expect(ok).toBe(false);
   });
 });
+
+describe("onload — defers the first snapshot to layout-ready (cold-start race)", () => {
+  // On a cold Obsidian start the vault file index is not fully populated
+  // when onload runs, so app.vault.getMarkdownFiles() — the workspace-
+  // snapshot source — can return a partial list, dropping deep
+  // include/link targets and making cross-file directives report a
+  // missing file. onload must defer the first startRuntime() until
+  // app.workspace.onLayoutReady fires, when the vault is fully indexed.
+  test("startRuntime runs on layout-ready, not during onload", async () => {
+    const { plugin, harness } = makePlugin();
+    const startSpy = mock(() => Promise.resolve(true));
+    (
+      plugin as unknown as { startRuntime: () => Promise<boolean> }
+    ).startRuntime = startSpy;
+
+    await plugin.onload();
+
+    // Deferred: onload registered exactly one layout-ready callback and
+    // has NOT snapshotted the vault yet.
+    expect(startSpy).not.toHaveBeenCalled();
+    expect(harness.layoutReadyCount()).toBe(1);
+
+    // The vault finishes loading: the snapshot runs now.
+    harness.fireLayoutReady();
+    expect(startSpy).toHaveBeenCalledTimes(1);
+  });
+});

editors/obsidian/src/main.ts

@@ -7,9 +7,14 @@
 // workspace, diagnostics, actions, settings, wiring); the methods here
 // just orchestrate the Obsidian lifecycle.
 //
-// onload order (plan 217 §Lifecycle): read settings → load the WASM
-// bundle → build the workspace snapshot → createRuntime once → register
-// the CM6 extension, commands, diagnostics view, and vault listeners.
+// onload order (plan 217 §Lifecycle): read settings → register the CM6
+// extension, commands, diagnostics view, and vault listeners → then,
+// once app.workspace.onLayoutReady fires, build the workspace snapshot
+// and createRuntime. The snapshot is deferred to layout-ready because
+// app.vault.getMarkdownFiles() is only complete after the vault finishes
+// indexing; running it during a cold-start onload can return a partial
+// file list, which drops deep include/link targets and makes cross-file
+// directives report a missing file.
 // onunload disposes the runtime, cancels listeners, and detaches the
 // view. A "Restart session" command runs the same dispose + create
 // flow a configPath change uses.
@@ -110,7 +115,12 @@ export default class MdsmithPlugin extends Plugin {
     this.registerActiveFileCheck();
     this.registerCursorCommands();
 
-    await this.startRuntime();
+    // Defer the first snapshot until the vault index is fully populated.
+    // onLayoutReady runs the callback once the vault is ready — or
+    // immediately if it already is (e.g. the plugin is enabled after
+    // startup) — so app.vault.getMarkdownFiles() returns the complete
+    // file list and cross-file include/link resolution sees every file.
+    this.app.workspace.onLayoutReady(() => void this.startRuntime());
   }
 
   override onunload(): void {

editors/obsidian/src/plugin.e2e.test.ts

@@ -243,6 +243,10 @@ async function bootPlugin(
       on(_event: string, _cb: () => unknown): unknown {
         return {};
       },
+      // onload defers the first snapshot to onLayoutReady; this e2e boots
+      // the runtime explicitly below (and awaits it), so the fake captures
+      // the callback without firing it to avoid starting the runtime twice.
+      onLayoutReady(_cb: () => unknown): void {},
       getActiveViewOfType(_t: unknown): FakeMarkdownView | null {
         return active.view;
       },
@@ -281,6 +285,12 @@ async function bootPlugin(
   internals.saveData = async () => {};
 
   await plugin.onload();
+  // onload now defers startRuntime() to onLayoutReady (faked as a no-op
+  // above); start the runtime here and await it so the assertions below
+  // run against a ready engine, exactly as the pre-deferral onload did.
+  await (
+    plugin as unknown as { startRuntime(): Promise<boolean> }
+  ).startRuntime();
 
   return {
     plugin,

internal/engine/runner.go

@@ -553,6 +553,15 @@ func (r *Runner) populateFileFields(f *lint.File, path string) {
 	case filepath.IsAbs(path):
 		gitignoreDir = filepath.Dir(path)
 	}
+	// An in-memory workspace (the Session's MemWorkspace, e.g. the WASM
+	// build) has no on-disk RootDir, but its SourceFS is rooted at the
+	// project root — the same contract os.DirFS(RootDir) gives on disk.
+	// Wire it as RootFS so RootFS-aware cross-file rules (include's ".."
+	// resolution, MDS020's schema reads) read through the workspace
+	// instead of falling back to os.*, which is "not implemented on js".
+	if r.RootDir == "" && r.SourceFS != nil {
+		f.RootFS = r.SourceFS
+	}
 	if gitignoreDir != "" {
 		gd := gitignoreDir
 		f.GitignoreFunc = func() *gitignore.Matcher {

internal/rules/crossfilereferenceintegrity/rule.go

@@ -5,6 +5,7 @@ import (
 	"io/fs"
 	"net/url"
 	"os"
+	"path"
 	"path/filepath"
 	"strings"
 
@@ -522,12 +523,24 @@ func (r *Rule) checkRelativeTarget(
 // resolveTargetFile when only file existence (not the read
 // helper) matters.
 func targetExists(f *lint.File, linkPath, resolvedRoot string) bool {
-	if path, ok := resolveTargetOSPath(f.Path, linkPath); ok && cachedStatExists(path) {
-		if resolvedRoot == "" || isWithinRoot(resolvedRoot, path) {
+	if osPath, ok := resolveTargetOSPath(f.Path, linkPath); ok && cachedStatExists(osPath) {
+		if resolvedRoot == "" || isWithinRoot(resolvedRoot, osPath) {
 			return true
 		}
 		return false
 	}
+	// In-memory / workspace-relative resolution: the WASM and LSP engines
+	// have no OS disk for the branch above. Resolve the link against the
+	// source file's directory within the project-root FS, collapsing ".."
+	// so io/fs — which rejects paths containing ".." — can stat an
+	// up-and-over target (e.g. docs/x.md -> ../../internal/y.md).
+	if f.RootFS != nil && !filepath.IsAbs(f.Path) {
+		if rel, ok := resolveWorkspaceRelTarget(f.Path, linkPath); ok {
+			if _, err := fs.Stat(f.RootFS, rel); err == nil {
+				return true
+			}
+		}
+	}
 	fsPath := filepath.ToSlash(linkPath)
 	fsPath = strings.TrimPrefix(fsPath, "./")
 	if fsPath == "" || strings.HasPrefix(fsPath, "/") {
@@ -843,23 +856,40 @@ func buildAnchorsForTarget(target targetFile) (map[string]struct{}, error) {
 
 func resolveTargetFile(f *lint.File, linkPath, resolvedRoot string) (targetFile, bool) {
 	maxBytes := f.MaxInputBytes
-	if path, ok := resolveTargetOSPath(f.Path, linkPath); ok {
-		if cachedStatExists(path) {
+	if osPath, ok := resolveTargetOSPath(f.Path, linkPath); ok {
+		if cachedStatExists(osPath) {
 			// Reject links that resolve outside the project root,
 			// evaluating symlinks to prevent bypass via symlinked dirs.
-			if resolvedRoot != "" && !isWithinRoot(resolvedRoot, path) {
+			if resolvedRoot != "" && !isWithinRoot(resolvedRoot, osPath) {
 				return targetFile{}, false
 			}
 			return targetFile{
-				cacheKey:    "os:" + path,
-				runCacheKey: path,
+				cacheKey:    "os:" + osPath,
+				runCacheKey: osPath,
 				read: func() ([]byte, error) {
-					return bytelimit.ReadFileLimited(path, maxBytes)
+					return bytelimit.ReadFileLimited(osPath, maxBytes)
 				},
 			}, true
 		}
 	}
 
+	// In-memory / workspace-relative resolution (see targetExists): resolve
+	// the link within the project-root FS so an up-and-over ".." target,
+	// which io/fs rejects as a raw path, still reads on the WASM/LSP engines.
+	if f.RootFS != nil && !filepath.IsAbs(f.Path) {
+		if rel, ok := resolveWorkspaceRelTarget(f.Path, linkPath); ok {
+			if _, err := fs.Stat(f.RootFS, rel); err == nil {
+				rootFS := f.RootFS
+				return targetFile{
+					cacheKey: "fs:" + rel,
+					read: func() ([]byte, error) {
+						return bytelimit.ReadFSFileLimited(rootFS, rel, maxBytes)
+					},
+				}, true
+			}
+		}
+	}
+
 	fsPath := filepath.ToSlash(linkPath)
 	fsPath = strings.TrimPrefix(fsPath, "./")
 	if fsPath == "" || strings.HasPrefix(fsPath, "/") {
@@ -936,6 +966,26 @@ func resolveTargetOSPath(sourcePath, linkPath string) (string, bool) {
 	return filepath.Clean(filepath.Join(filepath.Dir(sourcePath), linkPath)), true
 }
 
+// resolveWorkspaceRelTarget maps a workspace-relative source path and a
+// file-relative link to a slash path valid for fs.Stat against the
+// project-root FS (f.RootFS). It joins the link onto the source file's
+// directory and cleans ".." away — io/fs rejects any path containing
+// ".." — and returns ("", false) when the result escapes the workspace
+// root, is empty, or is absolute, none of which name a file inside the
+// in-memory workspace.
+func resolveWorkspaceRelTarget(sourcePath, linkPath string) (string, bool) {
+	lp := filepath.ToSlash(linkPath)
+	if lp == "" || strings.HasPrefix(lp, "/") {
+		return "", false
+	}
+	dir := path.Dir(filepath.ToSlash(sourcePath))
+	rel := path.Clean(path.Join(dir, lp))
+	if rel == "." || rel == ".." || strings.HasPrefix(rel, "../") {
+		return "", false
+	}
+	return rel, true
+}
+
 func isMarkdownPath(path string) bool {
 	ext := strings.ToLower(filepath.Ext(path))
 	return ext == ".md" || ext == ".markdown"

internal/rules/crossfilereferenceintegrity/rule_test.go

@@ -683,6 +683,73 @@ func TestResolveTargetFile_EmptyFSPathReturnsNotFound(t *testing.T) {
 	require.False(t, ok, "fsPath='' after TrimPrefix must return not found")
 }
 
+// TestTargetExists_ParentTraversalViaRootFS mirrors the WASM/Session
+// shape: a workspace-relative source path in a subdirectory, a
+// project-root RootFS, and an up-and-over link. The OS branch cannot
+// help (no on-disk file) and the legacy FS branch would hand ".." to
+// io/fs (which rejects it); RootFS-relative resolution collapses the
+// "..".
+func TestTargetExists_ParentTraversalViaRootFS(t *testing.T) {
+	root := t.TempDir()
+	require.NoError(t, os.MkdirAll(filepath.Join(root, "internal", "rules", "x"), 0o755))
+	writeFile(t, filepath.Join(root, "internal", "rules", "x", "README.md"), "# X\n")
+
+	f := &lint.File{
+		Path:   "docs/background/linters.md",
+		FS:     os.DirFS(root),
+		RootFS: os.DirFS(root),
+	}
+	assert.True(t, targetExists(f, "../../internal/rules/x/README.md", ""),
+		"an existing up-and-over target must resolve via RootFS")
+	assert.False(t, targetExists(f, "../../internal/rules/x/MISSING.md", ""),
+		"a missing up-and-over target must still report absent")
+	assert.False(t, targetExists(f, "../../../escape.md", ""),
+		"a link escaping the workspace root must not resolve here")
+}
+
+// TestResolveWorkspaceRelTarget covers every branch of the helper:
+// joining onto the source dir, collapsing "..", and the rejections for
+// empty, absolute, and root-escaping links.
+func TestResolveWorkspaceRelTarget(t *testing.T) {
+	rel, ok := resolveWorkspaceRelTarget("docs/background/linters.md", "../../internal/x.md")
+	require.True(t, ok)
+	assert.Equal(t, "internal/x.md", rel)
+
+	rel, ok = resolveWorkspaceRelTarget("docs/a.md", "b.md")
+	require.True(t, ok)
+	assert.Equal(t, "docs/b.md", rel)
+
+	_, ok = resolveWorkspaceRelTarget("docs/a.md", "")
+	assert.False(t, ok, "empty link is not a workspace target")
+	_, ok = resolveWorkspaceRelTarget("docs/a.md", "/etc/passwd")
+	assert.False(t, ok, "absolute link is not a workspace target")
+	_, ok = resolveWorkspaceRelTarget("docs/a.md", "../../escape.md")
+	assert.False(t, ok, "a link escaping the workspace root is rejected")
+}
+
+// TestResolveTargetFile_ParentTraversalViaRootFS exercises the in-memory
+// RootFS branch of resolveTargetFile (the anchored-link path), which the
+// Session/WASM engine takes for an up-and-over target.
+func TestResolveTargetFile_ParentTraversalViaRootFS(t *testing.T) {
+	root := t.TempDir()
+	require.NoError(t, os.MkdirAll(filepath.Join(root, "internal", "rules", "x"), 0o755))
+	writeFile(t, filepath.Join(root, "internal", "rules", "x", "README.md"), "# X\n")
+
+	f := &lint.File{
+		Path:   "docs/background/linters.md",
+		FS:     os.DirFS(root),
+		RootFS: os.DirFS(root),
+	}
+	tf, ok := resolveTargetFile(f, "../../internal/rules/x/README.md", "")
+	require.True(t, ok, "an existing up-and-over target must resolve via RootFS")
+	data, err := tf.read()
+	require.NoError(t, err)
+	assert.Equal(t, []byte("# X\n"), data)
+
+	_, ok = resolveTargetFile(f, "../../internal/rules/x/MISSING.md", "")
+	assert.False(t, ok, "a missing up-and-over target must not resolve")
+}
+
 // =====================================================================
 // Additional coverage: toStringSlice with []string type
 // =====================================================================