@im-nobsidian/core 0.18.0 → 0.19.1

package/dist/index.d.ts

@@ -597,10 +597,16 @@ interface PullResult {
      */
     readonly relinkedPaths?: readonly string[];
     /**
-     * dry-run 만 — 상태 기록에 Notion 과 이은 노트가 없어 실제 pull 은 같은 자리의 노트를 먼저 다시 잇는다(P7). 미리 보기는
-     * 노트 글을 받아 견주지 않아 그 노트들도 {@link created} 로 센다. 이을 노트가 없으면 생략.
+     * dry-run 만 — {@link relinkedPaths} 는 이은 것이 아니라 실제 pull 이 다시 이을 것이다(P7). 미리 보기는 노트 글을 받아
+     * 견주지 않아 글이 다른 노트는 실제 pull 에서 충돌로 남는다. 자연 이름의 노트는 이은 노트가 없는 볼트에서만 이을 것으로
+     * 센다 — 이은 노트가 있는 볼트는 글이 같아야 잇는다. 이을 노트가 없으면 생략.
      */
     readonly relinkPending?: true;
+    /**
+     * dry-run 만 — 이번 pull 이 새로 찾을 DB(처음 훑는 볼트 · 새로 받을 페이지 안의 DB)의 행은 세지 않았다. 받아 봐야 그 DB 가
+     * 있는지 안다. 없으면 생략.
+     */
+    readonly undiscoveredDatabases?: true;
     /**
      * 볼트에서 고쳐 덮어쓰지 않은 사이드카(`.notion.json`) — push 하면 고친 속성을 Notion 에 올린다(ADR-045). 없으면 생략.
      */
@@ -2820,7 +2826,7 @@ declare class SyncOrchestrator {
      *   적어 push 가 올린다 — dry-run 은 받지 않아 원격이 바뀐 그대로라, 원격을 보고 거절하지 않는다.
      */
     /**
-     * @param relinkedByPull 같은 sync 의 dry-run pull 이 다시 이을 것이라고 미리 봤다 — 실제 sync 는 받으며 먼저 잇고 올리므로
+     * @param relinkedByPull 같은 sync 의 dry-run pull 이 받거나 다시 이을 것이 있다 — 실제 sync 는 받으며 먼저 잇고 올리므로
      *   상태 기록이 비었어도 막지 않는다({@link assertVaultLinked}).
      */
     private executePush;
@@ -3643,6 +3649,8 @@ interface PlannedRow {
     readonly moves?: readonly RemoteMove[];
     /** 로컬도 고친 행을 실제 pull 이 받지 않는 까닭 — 없으면 받는다. */
     readonly resolution?: PlannedResolution;
+    /** `create` 만 — 상태 기록에 없던 같은 자리의 행 노트를 다시 잇는다(P7). 새로 받는 것으로 세지 않는다. */
+    readonly relink?: true;
 }
 /**
  * 로컬도 고친 노트를 실제 pull 이 어떻게 처리하나 — 충돌로 남김 · 합침(merge) · 받지 않음(원격이 그대로거나
@@ -3798,6 +3806,8 @@ declare class DatabaseSyncer {
          * 볼트에서 옮긴 레코드 — dry-run 은 옮겨 적지 않아 이동 WAL 이 없다. 실제 pull 처럼 볼트가 먼저다.
          */
         movingInVault?: ReadonlySet<string>;
+        /** 이번 미리 보기가 다시 이을 것으로 고른 자리({@link pathKey}) — 고르면 더한다. */
+        relinkTaken?: Set<string>;
     }): Promise<PlannedRow[]>;
     /**
      * 받은 행이 지난 사본 그대로인가 — 렌더한 글이 달라도 받을 것이 없으면 그 사이 로컬 편집을 충돌로 올리지 않는다
@@ -4110,7 +4120,8 @@ declare class WikilinkResolver implements Processor {
     process(input: ProcessorInput): ProcessorOutput;
     /**
      * `[[노트#제목]]` · `[[노트#^블록]]` · `[[#제목]]` → `[글자](https://www.notion.so/<페이지>#<블록>)`. 글자는 별칭,
-     * 없으면 Obsidian 이 보이는 「노트 > 제목」 — pull 이 그 글자면 별칭을 붙이지 않는다. 대상 페이지 · 블록을 못 찾으면 null.
+     * 없으면 Obsidian 이 보이는 「노트 > 제목」 — pull 이 그 글자면 별칭을 붙이지 않는다. 앵커 링크가 아니면 null, 못 풀면
+     * 그 까닭({@link AnchorMiss}).
      */
     private anchorLink;
 }

package/dist/index.js

@@ -5994,6 +5994,9 @@ function anchorBlockOf(block) {
     text: (body?.rich_text ?? []).map((t) => t.plain_text ?? "").join("")
   };
 }
+function flattenBlockTree(blocks) {
+  return blocks.flatMap((block) => [block, ...flattenBlockTree(block.children ?? [])]);
+}
 var ANCHORED_WIKILINK_RE = new LookbehindRegExp(
   /\[\[([^[\]|]*#[^[\]|]*?)\\?(?:\|[^[\]]+)?\]\]/g,
   void 0,
@@ -6037,7 +6040,7 @@ var WikilinkResolver = class {
           const target = display === void 0 ? written : withoutTableAliasEscape(written);
           const label = display ?? target;
           const anchored = this.anchorLink(target, display, input.context.anchors);
-          if (anchored) return anchored;
+          if (anchored?.link) return anchored.link;
           if (this.resolve) {
             const entry = this.resolve(target);
             if (entry) {
@@ -6048,6 +6051,7 @@ var WikilinkResolver = class {
             }
           }
           const params = display ? { text: target, display } : { text: target };
+          if (anchored?.miss) params.anchor = anchored.miss;
           params.__anchor = computeAnchor(input.content, base + offset);
           preserveMarkers.push({
             type: "wikilink",
@@ -6065,16 +6069,19 @@ var WikilinkResolver = class {
   }
   /**
    * `[[노트#제목]]` · `[[노트#^블록]]` · `[[#제목]]` → `[글자](https://www.notion.so/<페이지>#<블록>)`. 글자는 별칭,
-   * 없으면 Obsidian 이 보이는 「노트 > 제목」 — pull 이 그 글자면 별칭을 붙이지 않는다. 대상 페이지 · 블록을 못 찾으면 null.
+   * 없으면 Obsidian 이 보이는 「노트 > 제목」 — pull 이 그 글자면 별칭을 붙이지 않는다. 앵커 링크가 아니면 null, 못 풀면
+   * 그 까닭({@link AnchorMiss}).
    */
   anchorLink(target, display, anchors) {
     const split = anchors ? splitAnchor(target) : null;
     if (!anchors || !split) return null;
     const pageId = split.note === "" ? anchors.selfPageId : this.resolve?.(split.note)?.notionPageId ?? null;
-    if (!pageId) return null;
+    if (!pageId) return { miss: "page" };
     const blockId = anchors.blockOf(pageId, split.anchor);
-    if (!blockId) return null;
-    return `[${display ?? anchorDisplay(split.note, split.anchor)}](${notionBlockUrl(pageId, blockId)})`;
+    if (!blockId) return { miss: "block" };
+    return {
+      link: `[${display ?? anchorDisplay(split.note, split.anchor)}](${notionBlockUrl(pageId, blockId)})`
+    };
   }
 };
 
@@ -15686,6 +15693,77 @@ async function readLocalNote(vaultFs, path) {
   }
 }
 
+// src/utils/db-row-path.ts
+function selectDbRowFiles(files, localFolder) {
+  const prefix = localFolder.endsWith("/") ? localFolder : `${localFolder}/`;
+  return files.filter((file) => {
+    if (!file.path.startsWith(prefix)) return false;
+    const rel = file.path.slice(prefix.length);
+    return rel.length > 0 && !rel.includes("/");
+  });
+}
+var PAGE_ID_SUFFIX_LENGTHS = [8, 16, 32];
+var PAGE_ID_SUFFIX = new RegExp(
+  ` \\((?:${PAGE_ID_SUFFIX_LENGTHS.map((length) => `[0-9a-f]{${length}}`).join("|")})\\)$`,
+  "i"
+);
+function withoutPageIdSuffix(name) {
+  return name.replace(PAGE_ID_SUFFIX, "");
+}
+function pagePathCandidates(dir, safeName, pageId) {
+  const base = dir ? `${dir}/${safeName}` : safeName;
+  const raw = pageId.replace(/-/g, "");
+  return [
+    `${base}.md`,
+    ...PAGE_ID_SUFFIX_LENGTHS.map((len) => `${base} (${raw.slice(0, len)}).md`)
+  ];
+}
+function resolveDbRowPath(localFolder, safeName, pageId, lookupByPath) {
+  const ownedBySelf = (candidate) => {
+    const owner = lookupByPath(candidate);
+    if (!owner) return true;
+    return owner.notionPageId != null && notionIdsEqual(owner.notionPageId, pageId);
+  };
+  const candidates = pagePathCandidates(localFolder, safeName, pageId);
+  return candidates.find(ownedBySelf) ?? candidates[candidates.length - 1];
+}
+function inClaimOrder(items, chosen, idOf2) {
+  const slots = items.flatMap((item, index) => chosen(item) ? [index] : []);
+  const key = (item) => compactNotionId(idOf2(item));
+  const members = slots.map((index) => items[index]).sort((a, b) => key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0);
+  const ordered = [...items];
+  slots.forEach((slot, k) => ordered[slot] = members[k]);
+  return ordered;
+}
+
+// src/utils/path-key.ts
+function pathKey(path) {
+  return path.normalize("NFC").toLowerCase();
+}
+function foldedOwnerOf(stateDb, candidate, pageId) {
+  return stateDb.getByPathKey(candidate).some(
+    (record) => record.obsidianPath !== candidate && !(record.notionPageId != null && notionIdsEqual(record.notionPageId, pageId))
+  );
+}
+
+// src/sync/untracked-note.ts
+async function findUntrackedNote(stateDb, vaultFs, dir, safeName, pageId, taken) {
+  const [natural, ...suffixed] = pagePathCandidates(dir, safeName, pageId);
+  const order = [
+    ...suffixed.map((path) => ({ path, existing: "own" })),
+    { path: natural, existing: "name" }
+  ];
+  for (const candidate of order) {
+    if (taken(pathKey(candidate.path)) || stateDb.getByPath(candidate.path)) continue;
+    if (foldedOwnerOf(stateDb, candidate.path, pageId)) continue;
+    if (await vaultFs.exists(candidate.path)) return candidate;
+  }
+  return null;
+}
+function relinksWithoutContent(note, unlinkedVault) {
+  return note.existing === "own" || unlinkedVault;
+}
+
 // src/conflict/merger.ts
 function threeWayMerge(base, local, remote) {
   const baseLines = base.split("\n");
@@ -16151,49 +16229,6 @@ function withUnsentProperties(content, keys, before) {
   return (lines && replaceFrontmatterLines(content, lines)) ?? content;
 }
 
-// src/utils/db-row-path.ts
-function selectDbRowFiles(files, localFolder) {
-  const prefix = localFolder.endsWith("/") ? localFolder : `${localFolder}/`;
-  return files.filter((file) => {
-    if (!file.path.startsWith(prefix)) return false;
-    const rel = file.path.slice(prefix.length);
-    return rel.length > 0 && !rel.includes("/");
-  });
-}
-var PAGE_ID_SUFFIX_LENGTHS = [8, 16, 32];
-var PAGE_ID_SUFFIX = new RegExp(
-  ` \\((?:${PAGE_ID_SUFFIX_LENGTHS.map((length) => `[0-9a-f]{${length}}`).join("|")})\\)$`,
-  "i"
-);
-function withoutPageIdSuffix(name) {
-  return name.replace(PAGE_ID_SUFFIX, "");
-}
-function pagePathCandidates(dir, safeName, pageId) {
-  const base = dir ? `${dir}/${safeName}` : safeName;
-  const raw = pageId.replace(/-/g, "");
-  return [
-    `${base}.md`,
-    ...PAGE_ID_SUFFIX_LENGTHS.map((len) => `${base} (${raw.slice(0, len)}).md`)
-  ];
-}
-function resolveDbRowPath(localFolder, safeName, pageId, lookupByPath) {
-  const ownedBySelf = (candidate) => {
-    const owner = lookupByPath(candidate);
-    if (!owner) return true;
-    return owner.notionPageId != null && notionIdsEqual(owner.notionPageId, pageId);
-  };
-  const candidates = pagePathCandidates(localFolder, safeName, pageId);
-  return candidates.find(ownedBySelf) ?? candidates[candidates.length - 1];
-}
-function inClaimOrder(items, chosen, idOf2) {
-  const slots = items.flatMap((item, index) => chosen(item) ? [index] : []);
-  const key = (item) => compactNotionId(idOf2(item));
-  const members = slots.map((index) => items[index]).sort((a, b) => key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0);
-  const ordered = [...items];
-  slots.forEach((slot, k) => ordered[slot] = members[k]);
-  return ordered;
-}
-
 // src/sync/note-title.ts
 function explicitTitle(frontmatter) {
   const title = frontmatter.title;
@@ -16543,6 +16578,10 @@ function decodeId(id) {
 // src/sync/discovered-databases.ts
 var ROOT_DATABASES_FOLDER = "databases";
 var DISCOVERED_DBS_META_KEY = "discovered_dbs";
+var DISCOVERY_SCANNED_META_KEY = "discovery_scanned_at";
+function discoveryScanPending(stateDb) {
+  return parseDiscoveredDbs(stateDb.getMeta(DISCOVERED_DBS_META_KEY)).length === 0 && !stateDb.getMeta(DISCOVERY_SCANNED_META_KEY);
+}
 var INACCESSIBLE_DBS_META_KEY = "inaccessible_dbs";
 var LINKED_DBS_META_KEY = "linked_dbs";
 function parseDiscoveredDbs(raw) {
@@ -19161,16 +19200,6 @@ function joinPath(folder, name) {
   return folder === "" ? name : `${folder}/${name}`;
 }
 
-// src/utils/path-key.ts
-function pathKey(path) {
-  return path.normalize("NFC").toLowerCase();
-}
-function foldedOwnerOf(stateDb, candidate, pageId) {
-  return stateDb.getByPathKey(candidate).some(
-    (record) => record.obsidianPath !== candidate && !(record.notionPageId != null && notionIdsEqual(record.notionPageId, pageId))
-  );
-}
-
 // src/converter/unknown-tag-fallback.ts
 var UNKNOWN_BLOCK_TAG_RE2 = /<unknown (url|id)="([^"]*)"[^>]*\/>/g;
 var UNKNOWN_MENTION_TAG_RE = /<unknown_mention\s+url="([^"]*)"[^>]*?\/>/g;
@@ -19846,7 +19875,13 @@ var DatabaseSyncer = class {
     const target = await this.queryRows(dbConfig, opts);
     if (target.kind !== "rows") return [];
     const folderMove = opts?.followPlacement && !opts.paths ? await this.unblocked(this.placementMoveOf(dbConfig, target.meta, opts.movingInVault)) : null;
-    const planned = await this.planRows(dbConfig, target, opts?.paths, opts?.movingInVault);
+    const planned = await this.planRows(
+      dbConfig,
+      target,
+      opts?.paths,
+      opts?.movingInVault,
+      opts?.relinkTaken
+    );
     if (!folderMove) return planned;
     const moved = (path) => within(path, folderMove.from) ? folderMove.to + path.slice(folderMove.from.length) : path;
     return [
@@ -19925,7 +19960,7 @@ var DatabaseSyncer = class {
       return false;
     }
   }
-  async planRows(dbConfig, target, paths, movingInVault = /* @__PURE__ */ new Set()) {
+  async planRows(dbConfig, target, paths, movingInVault = /* @__PURE__ */ new Set(), relinkTaken = /* @__PURE__ */ new Set()) {
     const opts = { paths };
     const planned = [];
     const claimed = /* @__PURE__ */ new Map();
@@ -19946,6 +19981,24 @@ var DatabaseSyncer = class {
       if (action === "skip") continue;
       if (!record) {
         const name = sanitizeFileName(this.notionClient.extractTitle(page));
+        const untracked = await findUntrackedNote(
+          this.stateDb,
+          this.vaultFs,
+          dbConfig.localFolder,
+          name,
+          page.id,
+          (key) => relinkTaken.has(key) || claimed.has(key)
+        );
+        if (untracked && relinksWithoutContent(untracked, this.unlinkedVault)) {
+          relinkTaken.add(pathKey(untracked.path));
+          planned.push({
+            pageId: page.id,
+            path: untracked.path,
+            operation: "create",
+            relink: true
+          });
+          continue;
+        }
         const ownerOf = await this.rowPathOwners(dbConfig.localFolder, name, page.id);
         const path = resolveDbRowPath(dbConfig.localFolder, name, page.id, (p) => {
           const owner = claimed.get(pathKey(p));
@@ -20761,20 +20814,16 @@ var DatabaseSyncer = class {
    * `claimExistingNote` 와 같은 규칙이다.
    */
   async claimExistingRow(localFolder, safeName, pageId) {
-    const [natural, ...suffixed] = pagePathCandidates(localFolder, safeName, pageId);
-    const order = [
-      ...suffixed.map((path) => [path, "own"]),
-      [natural, "name"]
-    ];
-    for (const [candidate, existing] of order) {
-      const key = pathKey(candidate);
-      if (this.relinkClaims.has(key) || this.stateDb.getByPath(candidate)) continue;
-      if (foldedOwnerOf(this.stateDb, candidate, pageId)) continue;
-      if (!await this.vaultFs.exists(candidate)) continue;
-      this.relinkClaims.add(key);
-      return { path: candidate, existing };
-    }
-    return null;
+    const found2 = await findUntrackedNote(
+      this.stateDb,
+      this.vaultFs,
+      localFolder,
+      safeName,
+      pageId,
+      (key) => this.relinkClaims.has(key)
+    );
+    if (found2) this.relinkClaims.add(pathKey(found2.path));
+    return found2;
   }
   /**
    * 상태 기록에 없던 행 노트를 이 행과 다시 잇는다(P7) — 페이지의 `relinkExistingNote` 와 같은 규칙. 글이 같으면 잇고, 다르면
@@ -23332,7 +23381,6 @@ function dropEmbeddedBaseMarkers(content, basePaths) {
 
 // src/sync/database-discovery.ts
 var DISCOVERY_RETRY_META_KEY = "discovery_retry";
-var DISCOVERY_SCANNED_META_KEY = "discovery_scanned_at";
 function parseDiscoveryRetry(raw) {
   if (!raw) return { parents: [], dbs: [] };
   try {
@@ -23511,7 +23559,7 @@ var DatabaseDiscovery = class {
           retryLater(dbId, parentPageId, outcome.error);
         }
       };
-      const scanAll = forceRediscovery || dbConfigs.length === 0 && !this.stateDb.getMeta(DISCOVERY_SCANNED_META_KEY);
+      const scanAll = forceRediscovery || discoveryScanPending(this.stateDb);
       if (signal?.aborted) {
         nextRetry.parents.push(...retry.parents);
         nextRetry.dbs.push(...retry.dbs);
@@ -26099,23 +26147,32 @@ var PagePusher = class {
     return uploads;
   }
   /**
-   * 노트의 제목 · 블록 링크(`[[노트#제목]]`)가 가리키는 페이지의 맨 위 블록을 읽어 둔다 — 변환은 기다리지 않는다
-   * (anchor-links). 그런 링크가 없으면 읽지 않는다. 읽지 못한 페이지의 링크는 예전처럼 간다.
+   * 노트의 제목 · 블록 링크(`[[노트#제목]]`)가 가리키는 페이지의 블록을 읽어 둔다 — 변환은 기다리지 않는다
+   * (anchor-links). 맨 위 블록에서 모두 찾으면 거기서 멈추고, 못 찾은 앵커가 있으면 콜아웃 · 토글 · 목록 자식까지 읽는다.
+   * 그런 링크가 없으면 읽지 않는다. 읽지 못한 페이지의 링크는 예전처럼 간다.
    *
-   * @param selfPageId 이 노트의 페이지 — `[[#제목]]` 의 대상. 새로 만드는 노트는 아직 없다(그 링크는 다음 push 에 걸린다).
+   * @param selfPageId 이 노트의 페이지 — `[[#제목]]` 의 대상. 새로 만드는 노트는 아직 없다(그 링크는 push 뒤 패스가 다시 보낸다 — `push-link-pass`).
    */
   async anchorLookup(content, selfPageId) {
-    const pages = /* @__PURE__ */ new Set();
+    const pages = /* @__PURE__ */ new Map();
     for (const target of anchoredWikilinkTargets(content)) {
-      const { note } = splitAnchor(target);
+      const { note, anchor } = splitAnchor(target);
       const pageId = note === "" ? selfPageId : this.stateDb.resolveWikilink(note)?.notionPageId ?? null;
-      if (pageId) pages.add(compactNotionId(pageId));
+      if (!pageId) continue;
+      const key = compactNotionId(pageId);
+      pages.set(key, [...pages.get(key) ?? [], anchor]);
     }
     if (pages.size === 0) return void 0;
     const blocks = /* @__PURE__ */ new Map();
-    for (const pageId of pages) {
+    for (const [pageId, anchors] of pages) {
       try {
-        blocks.set(pageId, (await this.notionClient.fetchAllChildren(pageId)).map(anchorBlockOf));
+        const top = (await this.notionClient.fetchAllChildren(pageId)).map(anchorBlockOf);
+        blocks.set(pageId, top);
+        if (anchors.every((anchor) => anchorBlockId(top, anchor) !== null)) continue;
+        blocks.set(
+          pageId,
+          flattenBlockTree(await this.notionClient.getBlockTree(pageId)).map(anchorBlockOf)
+        );
       } catch (error) {
         getLogger().debug(
           `[Im-Nobsidian] \uC81C\uBAA9 \uB9C1\uD06C\uC758 \uB300\uC0C1 \uD398\uC774\uC9C0 \uBE14\uB85D\uC744 \uC77D\uC9C0 \uBABB\uD568 (${pageId}): ${error instanceof Error ? error.message : String(error)}`
@@ -27396,6 +27453,36 @@ var PagePuller = class {
       sanitizeFileName(this.notionClient.extractTitle(page))
     );
   }
+  /**
+   * dry-run — 실제 pull 이 이 새 페이지를 새로 받지 않고 상태 기록에 없던 노트 · 폴더와 다시 잇는가(P7). 다시 이을 노트(`note`) ·
+   * 이미 있는 폴더(`folder` — 이은 노트가 없는 볼트에서 폴더로만 받으면 만들지 않는다), 아니면 null. 받기 전에는 폴더 노트가 될지
+   * 모른다 — 노트 자리 · 폴더 노트 자리를 차례로 본다. `taken` 은 이번 미리 보기가 이미 이은 자리({@link pathKey}) — 고르면
+   * 더한다. 볼트도 상태 DB 도 바꾸지 않는다.
+   */
+  async plannedRelink(pageId, taken) {
+    const page = this.detector.discoveredPage(pageId) ?? await this.notionClient.getPage(pageId);
+    const safeName = sanitizeFileName(this.notionClient.extractTitle(page));
+    const parentPath = await this.resolveParentPath(page);
+    const folder = parentPath ? `${parentPath}/${safeName}` : safeName;
+    for (const dir of [parentPath, folder]) {
+      const found2 = await findUntrackedNote(
+        this.stateDb,
+        this.vaultFs,
+        dir,
+        safeName,
+        pageId,
+        (key) => taken.has(key)
+      );
+      if (found2 && relinksWithoutContent(found2, this.unlinkedVault)) {
+        taken.add(pathKey(found2.path));
+        return { path: found2.path, kind: "note" };
+      }
+    }
+    const folderExists = this.unlinkedVault && !taken.has(pathKey(folder)) && this.stateDb.getByPath(folder) === null && await this.vaultFs.exists(folder);
+    if (!folderExists) return null;
+    taken.add(pathKey(folder));
+    return { path: folder, kind: "folder" };
+  }
   /**
    * 새 페이지가 놓일 자리가 뺀 자리인가 — 부모 폴더 · 노트 이름 · 폴더 노트가 될 때의 폴더를 본다. 받기 전에는 폴더 노트가
    * 될지 모른다(본문을 받아 봐야 안다) — 어느 쪽이든 빠지면 뺀다. 자연 이름으로 보고, 같은 이름이 있을 때 붙는 id 접미사는
@@ -28081,21 +28168,22 @@ var PagePuller = class {
    * 이름. 다시 이을지는 받은 글과 견줘 호출측이 정한다({@link relinkExistingNote}) — 잇지 않으면 장부에서 지운다.
    */
   async claimExistingNote(dir, safeName, pageId) {
-    const [natural, ...suffixed] = pagePathCandidates(dir, safeName, pageId);
-    const order = [
-      ...suffixed.map((path) => [path, "own"]),
-      [natural, "name"]
-    ];
-    for (const [candidate, existing] of order) {
-      const key = pathKey(candidate);
-      if (this.claimedPaths.has(key) || this.stateDb.getByPath(candidate)) continue;
-      if (this.foldedOwner(candidate, pageId)) continue;
-      if (!await this.vaultFs.exists(candidate)) continue;
+    const taken = (key) => this.claimedPaths.has(key);
+    for (; ; ) {
+      const found2 = await findUntrackedNote(
+        this.stateDb,
+        this.vaultFs,
+        dir,
+        safeName,
+        pageId,
+        taken
+      );
+      if (!found2) return null;
+      const key = pathKey(found2.path);
       if (this.claimedPaths.has(key)) continue;
-      this.claimedPaths.set(key, candidate);
-      return { path: candidate, existing };
+      this.claimedPaths.set(key, found2.path);
+      return found2;
     }
-    return null;
   }
   async claimFilePath(dir, safeName, pageId) {
     const candidates = pagePathCandidates(dir, safeName, pageId);
@@ -28297,17 +28385,31 @@ async function resolveNotionLinks(stateDb, vaultFs, paths, pageTitle, blockAncho
 }
 
 // src/sync/push-link-pass.ts
-function notesWithResolvableWikilinks(stateDb) {
+function notesWithResolvableWikilinks(stateDb, pushed = /* @__PURE__ */ new Set()) {
   const paths = [];
   for (const record of stateDb.getAll()) {
     if (!record.notionPageId || record.status !== "synced") continue;
-    const resolvable = stateDb.getPreserveMarkers(record.obsidianPath).some(
-      (marker) => marker.type === "wikilink" && marker.params.text !== void 0 && stateDb.resolveWikilink(marker.params.text) !== null
-    );
+    const resolvable = stateDb.getPreserveMarkers(record.obsidianPath).some((marker) => marker.type === "wikilink" && resolvesNow(stateDb, record, marker, pushed));
     if (resolvable) paths.push(record.obsidianPath);
   }
   return paths.sort();
 }
+function resolvesNow(stateDb, record, marker, pushed) {
+  const text = marker.params.text;
+  if (text === void 0) return false;
+  const split = splitAnchor(text);
+  if (!split) return stateDb.resolveWikilink(text) !== null;
+  const target = split.note === "" ? null : stateDb.resolveWikilink(split.note);
+  if (split.note !== "" && target === null) return false;
+  switch (marker.params.anchor) {
+    case "page":
+      return true;
+    case "block":
+      return target !== null && target.obsidianPath !== record.obsidianPath && pushed.has(target.obsidianPath);
+    default:
+      return true;
+  }
+}
 
 // src/sync/pull-planner.ts
 var PullPlanner = class {
@@ -28356,12 +28458,19 @@ var PullPlanner = class {
       }
       planned.push(change);
     }
+    const relinks = await this.plannedRelinks(planned);
     const queued = new Set(
       [...filtered, ...restoreChanges].map((change) => compactNotionId(change.pageId))
     );
     const movingInVault = new Set(localPlan?.scan.adoptions.map((adoption) => adoption.record.id));
     const rows = [];
-    for (const row of await this.planDatabaseRows(options.paths, failed, ledger, movingInVault)) {
+    for (const row of await this.planDatabaseRows(
+      options.paths,
+      failed,
+      ledger,
+      movingInVault,
+      relinks.taken
+    )) {
       if (queued.has(compactNotionId(row.pageId))) continue;
       if (row.resolution?.action === "conflict") conflicts.push(row.resolution.conflict);
       else if (row.resolution?.action === "merge") mergedPaths.push(row.path);
@@ -28371,16 +28480,27 @@ var PullPlanner = class {
     const items = [];
     const plannedPath = this.planner.plannedPaths(localPlan);
     for (const change of [...planned, ...restoreChanges]) {
+      const relink = relinks.byPage.get(change.pageId);
+      if (relink) {
+        items.push({ path: relink.path, operation: "create", unchanged: true });
+        continue;
+      }
       const record = this.stateDb.getByNotionId(change.pageId);
       items.push({
         path: (record && plannedPath.get(record.id)) ?? record?.obsidianPath ?? change.title ?? change.pageId,
         operation: change.type === "created" ? "create" : change.type === "deleted" ? "delete" : "update"
       });
     }
-    for (const row of rows) items.push({ path: row.path, operation: row.operation });
+    for (const row of rows) {
+      items.push({
+        path: row.path,
+        operation: row.operation,
+        ...row.relink ? { unchanged: true } : {}
+      });
+    }
     const movedRows = rows.filter((row) => row.moves !== void 0);
     items.forEach((item, index) => options.onProgress?.(index + 1, items.length, item));
-    const count = (type) => planned.filter((c) => c.type === type).length;
+    const count = (type) => planned.filter((c) => c.type === type && !relinks.byPage.has(c.pageId)).length;
     const restoredModified = planned.filter(
       (c) => c.type === "modified" && restoreIds.has(c.pageId)
     ).length;
@@ -28391,7 +28511,14 @@ var PullPlanner = class {
       ].map((change) => this.stateDb.getByNotionId(change.pageId)?.obsidianPath).filter((path) => path !== void 0),
       ...rows.filter((row) => row.operation === "update" && row.restore).map((row) => row.path)
     ];
-    const rowCount = (operation, restore = false) => rows.filter((row) => row.operation === operation && (row.restore ?? false) === restore).length;
+    const rowCount = (operation, restore = false) => rows.filter(
+      (row) => row.operation === operation && (row.restore ?? false) === restore && !row.relink
+    ).length;
+    const undiscoveredDatabases = !isDatabaseMode(this.config) && (discoveryScanPending(this.stateDb) || planned.some((c) => c.type === "created"));
+    const relinkedPaths = [
+      ...[...relinks.byPage.values()].filter((relink) => relink.kind === "note").map((relink) => relink.path),
+      ...rows.filter((row) => row.relink).map((row) => row.path)
+    ];
     return {
       created: count("created") + rowCount("create"),
       updated: count("modified") - restoredModified + rowCount("update"),
@@ -28403,6 +28530,8 @@ var PullPlanner = class {
       ...movedRows.length > 0 ? { moved: movedRows.flatMap((row) => row.moves) } : {},
       conflicts,
       ...mergedPaths.length > 0 ? { mergedPaths } : {},
+      ...relinkedPaths.length > 0 ? { relinkedPaths, relinkPending: true } : {},
+      ...undiscoveredDatabases ? { undiscoveredDatabases: true } : {},
       writtenPaths: [],
       failed,
       duration: Date.now() - startTime,
@@ -28419,6 +28548,27 @@ var PullPlanner = class {
       }
     };
   }
+  /**
+   * 새 페이지 가운데 실제 pull 이 상태 기록에 없던 노트 · 폴더와 다시 이을 것({@link PagePuller.plannedRelink}) — 페이지 id →
+   * 자리. `taken` 은 고른 자리라 행도 피한다.
+   */
+  async plannedRelinks(planned) {
+    const byPage = /* @__PURE__ */ new Map();
+    const taken = /* @__PURE__ */ new Set();
+    for (const change of planned) {
+      if (change.type !== "created") continue;
+      try {
+        const relink = await this.puller.plannedRelink(change.pageId, taken);
+        if (relink) byPage.set(change.pageId, relink);
+      } catch (error) {
+        getLogger().debug(
+          `[Im-Nobsidian] \uB2E4\uC2DC \uC774\uC744 \uC790\uB9AC\uB97C \uBBF8\uB9AC \uBCF4\uC9C0 \uBABB\uD568 (${change.pageId}):`,
+          error
+        );
+      }
+    }
+    return { byPage, taken };
+  }
   /**
    * 고친 페이지를 실제 pull 이 받는가 — 폴더로만 추적하는 페이지는 본문이 생겼을 때만 폴더 노트로 받는다. 하위 페이지 ·
    * DB 를 옮기기만 해도 그 페이지의 수정 시각이 바뀌어 고친 것으로 보였다. 확인하지 못하면 센다(실제 pull 이 받아 본다).
@@ -28467,7 +28617,7 @@ var PullPlanner = class {
    * (`DatabaseDiscovery.pullDiscoveredDatabases`)를 같은 규칙으로 고른다. 세지 못한 DB 는 이유와
    * 함께 `failed` 에 싣는다 — 세지 못한 것을 없다고 하지 않는다.
    */
-  async planDatabaseRows(paths, failed, ledger, movingInVault) {
+  async planDatabaseRows(paths, failed, ledger, movingInVault, relinkTaken) {
     const configured = this.config.notion.databases ?? [];
     const rows = [];
     const plan = async (dbConfig, resolveDbFolder2) => {
@@ -28481,7 +28631,8 @@ var PullPlanner = class {
             paths,
             resolveDbFolder: resolveDbFolder2,
             followPlacement: resolveDbFolder2 !== void 0,
-            movingInVault
+            movingInVault,
+            relinkTaken
           })
         );
       } catch (error) {
@@ -29518,7 +29669,7 @@ var SyncOrchestrator = class {
    *   적어 push 가 올린다 — dry-run 은 받지 않아 원격이 바뀐 그대로라, 원격을 보고 거절하지 않는다.
    */
   /**
-   * @param relinkedByPull 같은 sync 의 dry-run pull 이 다시 이을 것이라고 미리 봤다 — 실제 sync 는 받으며 먼저 잇고 올리므로
+   * @param relinkedByPull 같은 sync 의 dry-run pull 이 받거나 다시 이을 것이 있다 — 실제 sync 는 받으며 먼저 잇고 올리므로
    *   상태 기록이 비었어도 막지 않는다({@link assertVaultLinked}).
    */
   async executePush(options, mergedByPull = /* @__PURE__ */ new Set(), relinkedByPull = false) {
@@ -29876,7 +30027,7 @@ var SyncOrchestrator = class {
           );
         }
       };
-      const relinkable = notesWithResolvableWikilinks(this.stateDb).filter(
+      const relinkable = notesWithResolvableWikilinks(this.stateDb, pushedBodies).filter(
         (path) => inAnyPathScope(path, options?.paths) && !excludeSet?.has(path)
       );
       await runPool(relinkable, relink, {
@@ -30190,8 +30341,7 @@ var SyncOrchestrator = class {
         },
         moved: [...relocated.moved, ...plan.moved ?? []],
         moveSkipped: relocated.skipped,
-        excluded: [...exclusions.values()],
-        ...this.puller.unlinkedVaultAtStart && plan.created > 0 ? { relinkPending: true } : {}
+        excluded: [...exclusions.values()]
       };
     }
     let pullTotal = workItems.length;
@@ -30403,15 +30553,16 @@ var SyncOrchestrator = class {
     const tagged = (direction) => onProgress && ((current, total, item) => onProgress(current, total, { ...item, direction }));
     const pullResult = await this.executePull({ ...options, onProgress: tagged("pull") });
     const conflicted = options?.dryRun ? pullResult.conflicts.map((conflict) => conflict.syncRecord.obsidianPath) : [];
+    const relinked = options?.dryRun ? pullResult.relinkedPaths ?? [] : [];
     const pushResult = await this.executePush(
       {
         ...options,
         onProgress: tagged("push"),
         paths: options?.paths,
-        excludePaths: [...pullResult.writtenPaths, ...conflicted]
+        excludePaths: [...pullResult.writtenPaths, ...conflicted, ...relinked]
       },
       new Set(options?.dryRun ? pullResult.mergedPaths ?? [] : []),
-      pullResult.relinkPending === true
+      options?.dryRun === true && (pullResult.created > 0 || relinked.length > 0)
     );
     return {
       pull: pullResult,