Fix manual reordering: dedupe context cache paths and stabilize order comparator

[theslyprofessor]

Fixes #443

Full diagnosis with reproduction details is in #443 (comment). Summary:

Manual order is the row order of the files table in .space/context.mdb, and rank is derived at runtime as indexOf against a cached paths array. Two compounding bugs corrupt that array:

1. Double-append in parseContextTableToCache (src/core/superstate/cacheParsers.ts): orderStringArrayByArray returns the entire paths array (unmatched paths included), and missingPaths was then appended again, so any child not matched in the db rows appeared twice in ContextState.paths. The raw row values were also compared without resolvePath (while mergeContextRows does resolve them), so tables storing relative or stale paths never matched: every child was then permanently duplicated on every reindex. Fixed by resolving contextPaths via resolvePath and ordering only the paths actually present in contextPaths, then appending missingPaths once.

2. Inconsistent comparator in orderStringArrayByArray (src/shared/utils/array.ts): when both items were unranked (indexOf == -1 for both) the comparator fell through to -1, which is not a valid consistent comparator, so the unmatched run came out reversed and could differ between sorts. Fixed to return 0 so unranked items keep their original relative order.

Together these put the derived rank (ranks.indexOf in getSpaceItems) in a different index space than the actual db row array a drop inserts into (reorderRowsForPath), which is why drops land in the wrong place and why the order mutates again after reopening Obsidian.

Two smaller fixes on the same code path:

• mergeContextRows (src/core/utils/contexts/linkContextRow.ts) now dedupes rows by resolved path, so a context table that already picked up duplicate rows heals on merge.
• updateContextValue (src/core/utils/contexts/context.ts) used if (rank), silently ignoring rank 0, so a drop at the very top of a list was never persisted. Now rank != null.

The cache self-heals on the next reindex once the double-append is gone, and duplicate db rows heal via the merge dedupe.

Verification: node esbuild.config.mjs production bundles cleanly with no errors. tsc -noEmit -skipLibCheck output is byte-identical before and after this change; the single error it reports (TS1501 in src/adapters/text/textCacher.ts) is pre-existing on clean main and not touched by this PR.

🤖 Generated with Claude Code

https://claude.ai/code/session_015NPvX1eLWMjqdFwEYbvzjM

[Copilot]

Pull request overview

This PR fixes incorrect and unstable manual reordering in spaces by repairing how context-table paths are cached and how “unranked” items are compared during ordering, so drag/drop rank calculations align with the underlying .space/context.mdb row order.

Changes:

• Fixes parseContextTableToCache so cached ContextState.paths is resolved consistently and no longer double-appends missing paths.
• Stabilizes orderStringArrayByArray sorting for unranked items to avoid reversing / non-deterministic ordering.
• Heals existing corrupted context tables by deduping merged rows and ensures rank 0 is persisted when updating context values.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 1 comment.

File	Description
src/shared/utils/array.ts	Adjusts ordering comparator for unranked items to stabilize manual ordering.
src/core/utils/contexts/linkContextRow.ts	Dedupes merged context rows by resolved path to heal duplicated DB rows.
src/core/utils/contexts/context.ts	Persists rank 0 by treating rank as present when rank != null.
src/core/superstate/cacheParsers.ts	Resolves DB row paths consistently and prevents double-append duplication in cached path arrays.

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.