@im-nobsidian/core 0.3.1 → 0.4.1

package/dist/index.d.ts

@@ -1,7 +1,11 @@
 import { z } from 'zod';
 import { Client } from '@notionhq/client';
-import { PageObjectResponse, BlockObjectResponse, PageMarkdownResponse, PartialBlockObjectResponse } from '@notionhq/client/build/src/api-endpoints.js';
+import { PageObjectResponse, BlockObjectResponse, PageMarkdownResponse, PartialBlockObjectResponse, LanguageRequest } from '@notionhq/client/build/src/api-endpoints.js';
 
+/** Notion 내부 통합 토큰의 머리 — 설정 검증과 CLI 의 입력 검사가 함께 읽는다. */
+declare const NOTION_TOKEN_PREFIX = "ntn_";
+/** DB 의 제목 속성 이름 기본값 — Notion 이 새 DB 에 붙이는 이름. */
+declare const DEFAULT_TITLE_PROPERTY = "Name";
 declare const DatabaseSyncSchema: z.ZodObject<{
     databaseId: z.ZodString;
     localFolder: z.ZodString;
@@ -81,20 +85,23 @@ declare const ConfigSchema: z.ZodObject<{
         conflictStrategy: z.ZodDefault<z.ZodEnum<["local-first", "remote-first", "manual", "duplicate"]>>;
         autoSync: z.ZodDefault<z.ZodBoolean>;
         autoSyncInterval: z.ZodDefault<z.ZodNumber>;
+        fullReconcileInterval: z.ZodDefault<z.ZodNumber>;
         deleteSync: z.ZodDefault<z.ZodBoolean>;
         syncFiles: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
-        direction: "push" | "pull" | "both";
-        conflictStrategy: "local-first" | "remote-first" | "manual" | "duplicate";
+        direction: "push" | "both" | "pull";
+        conflictStrategy: "manual" | "local-first" | "remote-first" | "duplicate";
         autoSync: boolean;
         autoSyncInterval: number;
+        fullReconcileInterval: number;
         deleteSync: boolean;
         syncFiles: boolean;
     }, {
-        direction?: "push" | "pull" | "both" | undefined;
-        conflictStrategy?: "local-first" | "remote-first" | "manual" | "duplicate" | undefined;
+        direction?: "push" | "both" | "pull" | undefined;
+        conflictStrategy?: "manual" | "local-first" | "remote-first" | "duplicate" | undefined;
         autoSync?: boolean | undefined;
         autoSyncInterval?: number | undefined;
+        fullReconcileInterval?: number | undefined;
         deleteSync?: boolean | undefined;
         syncFiles?: boolean | undefined;
     }>;
@@ -103,25 +110,28 @@ declare const ConfigSchema: z.ZodObject<{
         exclude: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         attachments: z.ZodDefault<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
+        attachments: string;
         include: string[];
         exclude: string[];
-        attachments: string;
     }, {
+        attachments?: string | undefined;
         include?: string[] | undefined;
         exclude?: string[] | undefined;
-        attachments?: string | undefined;
     }>;
     conversion: z.ZodObject<{
         preferMarkdownApi: z.ZodDefault<z.ZodBoolean>;
         preserveMarkers: z.ZodDefault<z.ZodBoolean>;
         frontmatterMapping: z.ZodDefault<z.ZodBoolean>;
         imageDownload: z.ZodDefault<z.ZodEnum<["immediate", "lazy", "skip"]>>;
+        timeZone: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     }, "strip", z.ZodTypeAny, {
         preferMarkdownApi: boolean;
         preserveMarkers: boolean;
         frontmatterMapping: boolean;
         imageDownload: "immediate" | "lazy" | "skip";
+        timeZone?: string | undefined;
     }, {
+        timeZone?: string | undefined;
         preferMarkdownApi?: boolean | undefined;
         preserveMarkers?: boolean | undefined;
         frontmatterMapping?: boolean | undefined;
@@ -142,6 +152,9 @@ declare const ConfigSchema: z.ZodObject<{
         mediaRetryBaseMs: z.ZodDefault<z.ZodNumber>;
         fileConcurrency: z.ZodDefault<z.ZodNumber>;
         maxFileSizeBytes: z.ZodDefault<z.ZodNumber>;
+        mediaDownloadTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        itemTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        markdownCompletionMaxBlocks: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         concurrency: number;
         timeoutMs: number;
@@ -157,6 +170,9 @@ declare const ConfigSchema: z.ZodObject<{
         mediaRetryBaseMs: number;
         fileConcurrency: number;
         maxFileSizeBytes: number;
+        mediaDownloadTimeoutMs: number;
+        itemTimeoutMs: number;
+        markdownCompletionMaxBlocks: number;
     }, {
         concurrency?: number | undefined;
         timeoutMs?: number | undefined;
@@ -172,6 +188,9 @@ declare const ConfigSchema: z.ZodObject<{
         mediaRetryBaseMs?: number | undefined;
         fileConcurrency?: number | undefined;
         maxFileSizeBytes?: number | undefined;
+        mediaDownloadTimeoutMs?: number | undefined;
+        itemTimeoutMs?: number | undefined;
+        markdownCompletionMaxBlocks?: number | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     version: 1;
@@ -190,23 +209,25 @@ declare const ConfigSchema: z.ZodObject<{
         workspaceId?: string | undefined;
     };
     sync: {
-        direction: "push" | "pull" | "both";
-        conflictStrategy: "local-first" | "remote-first" | "manual" | "duplicate";
+        direction: "push" | "both" | "pull";
+        conflictStrategy: "manual" | "local-first" | "remote-first" | "duplicate";
         autoSync: boolean;
         autoSyncInterval: number;
+        fullReconcileInterval: number;
         deleteSync: boolean;
         syncFiles: boolean;
     };
     paths: {
+        attachments: string;
         include: string[];
         exclude: string[];
-        attachments: string;
     };
     conversion: {
         preferMarkdownApi: boolean;
         preserveMarkers: boolean;
         frontmatterMapping: boolean;
         imageDownload: "immediate" | "lazy" | "skip";
+        timeZone?: string | undefined;
     };
     advanced: {
         concurrency: number;
@@ -223,6 +244,9 @@ declare const ConfigSchema: z.ZodObject<{
         mediaRetryBaseMs: number;
         fileConcurrency: number;
         maxFileSizeBytes: number;
+        mediaDownloadTimeoutMs: number;
+        itemTimeoutMs: number;
+        markdownCompletionMaxBlocks: number;
     };
 }, {
     version: 1;
@@ -241,19 +265,21 @@ declare const ConfigSchema: z.ZodObject<{
         }[] | undefined;
     };
     sync: {
-        direction?: "push" | "pull" | "both" | undefined;
-        conflictStrategy?: "local-first" | "remote-first" | "manual" | "duplicate" | undefined;
+        direction?: "push" | "both" | "pull" | undefined;
+        conflictStrategy?: "manual" | "local-first" | "remote-first" | "duplicate" | undefined;
         autoSync?: boolean | undefined;
         autoSyncInterval?: number | undefined;
+        fullReconcileInterval?: number | undefined;
         deleteSync?: boolean | undefined;
         syncFiles?: boolean | undefined;
     };
     paths: {
+        attachments?: string | undefined;
         include?: string[] | undefined;
         exclude?: string[] | undefined;
-        attachments?: string | undefined;
     };
     conversion: {
+        timeZone?: string | undefined;
         preferMarkdownApi?: boolean | undefined;
         preserveMarkers?: boolean | undefined;
         frontmatterMapping?: boolean | undefined;
@@ -274,6 +300,9 @@ declare const ConfigSchema: z.ZodObject<{
         mediaRetryBaseMs?: number | undefined;
         fileConcurrency?: number | undefined;
         maxFileSizeBytes?: number | undefined;
+        mediaDownloadTimeoutMs?: number | undefined;
+        itemTimeoutMs?: number | undefined;
+        markdownCompletionMaxBlocks?: number | undefined;
     };
 }>;
 type Config = z.infer<typeof ConfigSchema>;
@@ -291,6 +320,12 @@ interface SyncRecord {
     readonly notionParentId: string | null;
     readonly contentHash: string;
     readonly notionLastEdited: string | null;
+    /** {@link RemoteObservation.lastEditedBy} — 모르면 null. */
+    readonly notionLastEditedBy: string | null;
+    /** {@link RemoteObservation.seenAt} — 모르면 null. */
+    readonly notionSeenAt: string | null;
+    /** 지난 동기화 사본에 해당하는 원격 본문의 지문(`remoteBodyFingerprint`). 모르면 null. */
+    readonly notionBodyFingerprint: string | null;
     readonly localLastModified: string;
     readonly syncDirection: SyncDirection;
     readonly fileType: FileType;
@@ -302,6 +337,23 @@ interface SyncRecord {
     readonly createdAt: string;
     readonly updatedAt: string;
 }
+/**
+ * 원격 페이지를 본 기록(N-05). Notion 의 수정 시각은 분 단위로 잘려, 시각만으로는 우리가 본 뒤
+ * 같은 분 안에서 고친 것을 알 수 없다 — 누가 고쳤는지와 언제 봤는지를 함께 적는다.
+ */
+interface RemoteObservation {
+    /** Notion `last_edited_time` — 분 단위로 잘린 값. */
+    readonly lastEdited: string;
+    /** Notion `last_edited_by.id`. 응답에 없으면 null. */
+    readonly lastEditedBy: string | null;
+    /**
+     * 이 기기 시계로 본 때 — 그 실행을 시작한 때(실제로 읽은 때보다 이르다). 이때까지의 원격
+     * 편집은 레코드에 들어 있다. 모르면 null — 다음에 내용으로 확인한다.
+     */
+    readonly seenAt: string | null;
+    /** 원격 본문 지문. 적지 않으면(undefined) 있던 값을 둔다 — 본문을 건드리지 않은 관측. */
+    readonly bodyFingerprint?: string | null;
+}
 interface LocalChange {
     readonly path: string;
     readonly type: "created" | "modified" | "deleted" | "moved";
@@ -309,12 +361,34 @@ interface LocalChange {
     readonly previousHash: string | null;
     readonly movedFrom?: string;
 }
+/**
+ * DB 행 frontmatter 의 속성 차이 — 지난 동기화 시점과 비교해 바뀐 것만(S-01).
+ * `title` 은 속성이 아니라 행 제목이라 여기 들어가지 않는다.
+ */
+interface RowPropertyChanges {
+    /** 새로 생겼거나 값이 바뀐 속성과 그 새 값. 날짜는 적힌 모양의 문자열로 되돌려 둔다. */
+    readonly changed: Readonly<Record<string, unknown>>;
+    /** 로컬에서 비웠거나 지운 속성 이름. */
+    readonly cleared: readonly string[];
+}
 interface RemoteChange {
     readonly pageId: string;
     readonly type: "created" | "modified" | "deleted" | "moved";
     readonly lastEdited: string;
     readonly previousEdited: string | null;
     readonly movedFromParent?: string;
+    /**
+     * 추적 중인 노트의 볼트 경로. 화면이 내부 id 대신 노트 이름을 보이고, 그 노트만 받을 때 쓴다.
+     * 아직 볼트에 없는 새 페이지는 없다.
+     */
+    readonly path?: string;
+    /** Notion 제목 — 볼트 경로가 아직 없는 새 페이지를 화면이 이름으로 보일 때 쓴다. */
+    readonly title?: string;
+    /**
+     * 수정 시각 · 편집자로는 바뀌었는지 가를 수 없다 — 같은 분 안의 편집일 수 있다(N-05).
+     * 받는 쪽이 내용으로 확인한다. `modified` 에만 붙는다.
+     */
+    readonly unverified?: boolean;
 }
 interface Conflict {
     readonly syncRecord: SyncRecord;
@@ -326,7 +400,16 @@ interface Conflict {
 }
 interface ProgressItem {
     readonly path: string;
-    readonly operation: "create" | "update" | "delete";
+    /** `move` — 볼트에서 옮기거나 이름을 바꾼 노트 · 폴더를 Notion 에 반영한다(push). */
+    readonly operation: "create" | "update" | "delete" | "move";
+    /** 받기(pull) · 올리기(push) 중 어느 쪽 항목인가 — `sync` 만 채운다. 둘을 한 번에 돌려 가를 수 없다. */
+    readonly direction?: "pull" | "push";
+    /**
+     * 받아 봤지만 볼트에 쓰지 않았다(pull) — 바뀐 것이 없거나 로컬을 지켰다. 진행 수에는 들지만 화면이 바뀐
+     * 노트로 적지 않는다. 다시 그리기(B14)는
+     * 받아 둔 노트를 모두 받아 보므로, 적으면 바뀌지 않은 노트마다 「updated」 줄이 찍혔다.
+     */
+    readonly unchanged?: boolean;
 }
 type ProgressCallback = (current: number, total: number, item: ProgressItem) => void;
 /** push/pull/sync 가 공통으로 받는 동기화 옵션. */
@@ -337,22 +420,76 @@ interface BaseSyncOptions {
     readonly onProgress?: ProgressCallback;
     readonly signal?: AbortSignal;
 }
+/** 원격까지 보는 상태 확인(`status`)의 옵션. */
+interface StatusOptions {
+    /** 취소하면 원격을 훑다 멈추고 {@link OperationAbortedError} 를 던진다 — 반쯤 본 상태를 돌려주지 않는다. */
+    readonly signal?: AbortSignal;
+}
 interface PushOptions extends BaseSyncOptions {
     readonly excludePaths?: string[];
 }
-type PullOptions = BaseSyncOptions;
+interface PullOptions extends BaseSyncOptions {
+    /**
+     * Notion 에서 바뀌지 않은 받아 둔 노트도 지금 변환기로 다시 그린다(B14, `sync/rerender-targets.ts`).
+     * 볼트에서 고친 노트는 건드리지 않는다. dry-run 에서는 쓰지 않는다 — 다시 그려 봐야 바뀌는지 안다.
+     */
+    readonly rerender?: boolean;
+}
 type SyncOptions = BaseSyncOptions;
 interface PushResult {
     readonly created: number;
     readonly updated: number;
     readonly deleted: number;
+    /**
+     * Notion 에 옮김을 반영한 노트 · 폴더 수. 옮기며 본문도 고친 노트도 여기서만 센다 — updated 와
+     * 겹치지 않는다. 예전에는 updated 에 섞여, 이름만 바꾼 노트도 「수정」 으로 보였다.
+     */
+    readonly moved: number;
     readonly failed: FailedOperation[];
     readonly duration: number;
 }
+/**
+ * 전체 대조를 한 이유 (ADR-027).
+ *
+ * - `first` — 받은 것이 없다(처음 pull · 빈 상태 DB).
+ * - `forced` — `--force`.
+ * - `database-mode` — 루트가 DB 하나라 그 DB 조회가 곧 전체 대조다.
+ * - `every-pull` — 주기(`sync.fullReconcileInterval`)가 0 이다.
+ * - `due` — 주기가 됐다.
+ */
+type FullScanReason = "first" | "forced" | "database-mode" | "every-pull" | "due";
+/**
+ * 이번 실행이 원격을 얼마나 훑었나 (ADR-027). `incremental` 은 지난 pull 뒤에 바뀐 페이지 · 행 · DB 만
+ * 찾았다는 뜻이다 — 원격에서 지운 것 · 범위 밖으로 옮긴 것은 다음 전체 대조가 반영한다. 화면은 이것으로
+ * 그 사실과 다음 전체 대조 시각을 알린다.
+ */
+interface RemoteScanInfo {
+    readonly kind: "full" | "incremental";
+    /** 전체 대조한 이유 — `full` 에만. */
+    readonly reason?: FullScanReason;
+    /** 마지막으로 전체 대조를 마친 때. 한 번도 없으면 null. */
+    readonly lastFullAt: string | null;
+    /** 다음 전체 대조 예정 시각 — `incremental` 에만. null 이면 이미 때가 됐다(다음 pull 이 한다). */
+    readonly nextFullAt: string | null;
+    /**
+     * Notion 에서 지운 노트가 아직 볼트에 반영되지 않았을 수 있나 — 바뀐 것만 찾았고 원격 삭제를 볼트에
+     * 반영하는 설정(`sync.deleteSync`)일 때. 다음 전체 대조가 반영한다. 설정이 꺼져 있으면 원격 삭제는
+     * 볼트에 반영하지 않으므로 늘 false 다.
+     */
+    readonly deletionsDeferred: boolean;
+    /** 바뀐 것이 보이지 않아 조회하지 않은 DB 수 — pull 에만. */
+    readonly skippedDatabases?: number;
+}
 interface PullResult {
     readonly created: number;
     readonly updated: number;
     readonly deleted: number;
+    /**
+     * 로컬에서 사라졌다가 리모트 원본으로 되살린 파일 수.
+     * updated 와 분리해 보고한다 — "수정 N건" 에 섞이면 사용자는 자기 볼트에서
+     * 파일이 없어졌다가 복구됐다는 사실 자체를 알 수 없다.
+     */
+    readonly restored: number;
     readonly conflicts: Conflict[];
     readonly writtenPaths: string[];
     readonly failed: FailedOperation[];
@@ -360,6 +497,8 @@ interface PullResult {
     readonly imageCount: number;
     readonly fileCount: number;
     readonly linkCount: number;
+    /** 원격을 얼마나 훑었나. 원격을 보지 않은 실행(받기 방향이 아님 · 취소)에는 없다. */
+    readonly remoteScan?: RemoteScanInfo;
 }
 interface SyncResult {
     readonly push: PushResult;
@@ -367,13 +506,42 @@ interface SyncResult {
     readonly conflicts: Conflict[];
     readonly duration: number;
 }
+/** 볼트에서 옮기거나 이름을 바꾼 폴더 — 다음 push 가 Notion 에 반영한다(DB 폴더는 볼트 쪽만). */
+interface FolderMoveChange {
+    readonly from: string;
+    readonly to: string;
+}
+/**
+ * 변경 하나를 줄 비교로 보이는 두 글 — `SyncOrchestrator.localChangeDiff` · `remoteChangeDiff` 가 내고,
+ * `lineDiff` 로 견준다.
+ */
+interface ChangeDiff {
+    /** 볼트 경로 — 옮긴 노트는 새 자리. */
+    readonly path: string;
+    readonly type: LocalChange["type"];
+    /** 옮긴 노트의 옛 자리. */
+    readonly movedFrom?: string;
+    /** 지난 동기화 때의 글. 새 노트는 null — 견줄 옛 글이 없다. */
+    readonly before: string | null;
+    /** 지금 글 — 로컬 변경은 볼트의 글, 원격 변경은 Notion 의 글. 지운 노트 · 페이지는 null. */
+    readonly after: string | null;
+}
 interface StatusResult {
     readonly localChanges: LocalChange[];
+    /** 옮긴 폴더. 그 안의 노트는 `localChanges` 에 `moved` 로 따로 있다. */
+    readonly folderMoves: readonly FolderMoveChange[];
     readonly remoteChanges: RemoteChange[];
     readonly conflicts: Conflict[];
     readonly conflictRecords: SyncRecord[];
     readonly pendingOperations: number;
     readonly lastSyncAt: string | null;
+    /**
+     * 마지막으로 원격을 전체 대조한 pull 이 시작한 때. 한 번도 없으면 null. Notion 에서 지운 노트는 전체
+     * 대조 때 볼트에 반영된다 — 화면은 이것으로 그때를 알린다 (ADR-027).
+     */
+    readonly lastFullScanAt: string | null;
+    /** 원격을 얼마나 훑었나. 로컬만 본 확인(`statusLocal`)에는 없다. */
+    readonly remoteScan?: RemoteScanInfo;
 }
 interface FailedOperation {
     readonly path: string;
@@ -381,6 +549,17 @@ interface FailedOperation {
     readonly error: string;
 }
 
+/** Notion 이 돌려준 본문에 실린 자식 하나. */
+interface ChildTag {
+    readonly kind: "page" | "database";
+    /** 하이픈 없는 32자리 hex. */
+    readonly id: string;
+    /** 태그 안의 제목 그대로(굵게 `**` 가 섞여 있을 수 있다). */
+    readonly title: string;
+    /** 태그 원문 — 복원은 받은 그대로 다시 싣는다(실측: 받은 태그를 보내면 자식이 그대로 남는다). */
+    readonly tag: string;
+}
+
 type ConversionPath = "markdown-api" | "block-api";
 interface ProcessorInput {
     readonly content: string;
@@ -402,6 +581,23 @@ interface ProcessorMetadata {
      * true: 무조건 재간격 / false: 무동작 / 미지정: 내용 기반 휴리스틱 폴백.
      */
     readonly notionExportCompact?: boolean;
+    /**
+     * pull 직전 로컬 노트 원문 — 있을 때만. Notion 에 남길 자리가 없는 표기(코드 펜스의 원래 언어 ·
+     * 펜스 기호 S-20, 주석 S-29)를 되살리는 근거다. 호출측이 로컬 파일을 읽어 넘긴다.
+     */
+    readonly localContent?: string;
+    /**
+     * 행 노트에서 Notion 이 정하는 frontmatter 키 — 행을 받을 때만. 받은 속성을 로컬 frontmatter 에 합칠 때
+     * 이 밖의 키(`aliases` 등)는 로컬 것으로 두고, 키 차례 · 적은 모양도 로컬을 따른다(F-08).
+     */
+    readonly notionKeys?: readonly string[];
+    /**
+     * 받은 본문(원시 글)에 실린 자식 페이지 · 자식 DB — 페이지를 받을 때만. push 는 가리키는 줄이 없는 자식을
+     * 본문 끝에 되돌려 놓으므로(`restoreChildTags`), 로컬 표기를 되살릴 때 보낼 꼴을 그와 같이 만든다.
+     */
+    readonly remoteChildren?: readonly ChildTag[];
+    /** Markdown API 로 보낼 수 없어 본문을 쓴 뒤 블록으로 채울 코드({@link DeferredCode}). */
+    readonly deferredCode?: DeferredCode[];
     readonly [key: string]: unknown;
 }
 interface ConversionContext {
@@ -420,6 +616,27 @@ interface ConversionResult {
     readonly properties: Record<string, unknown>;
     readonly images: ImageReference[];
     readonly preserveMarkers: PreserveMarker[];
+    readonly deferredCode: DeferredCode[];
+}
+/**
+ * 본문을 쓴 뒤 블록으로 채울 코드(S-22). Notion Markdown API 는 코드에 ``` 로 시작하는 줄이 있으면
+ * 어떤 펜스로 보내도 그 줄에서 블록을 가른다 — 코드 자리에 자리표시(`token`)만 보내고, 페이지를
+ * 쓴 뒤 그 자리표시를 가진 코드 블록의 글을 `code` 로 바꾼다.
+ */
+interface DeferredCode {
+    /** 코드 블록에 대신 보낸 자리표시 — 페이지 안에서 하나뿐이다. */
+    readonly token: string;
+    /** Obsidian 이 보여 주는 그대로의 코드 — 컨테이너 접두 · 펜스 들여쓰기를 뗀 것. */
+    readonly code: string;
+}
+/**
+ * 북마크 블록의 주소와 캡션(F-09). Markdown API 는 북마크를 주소 · 캡션 없는 자리 태그로만 보내,
+ * 블록으로 따로 읽는다(`NotionClient.getBookmarks`).
+ */
+interface BookmarkTarget {
+    readonly url: string;
+    /** 캡션의 글 — 없으면 빈 문자열. */
+    readonly caption: string;
 }
 interface PreserveMarker {
     readonly type: string;
@@ -485,6 +702,37 @@ interface DatabaseViewsConfig {
     readonly lastSynced: string;
     readonly views: ViewConfig[];
 }
+/** select/multi_select/status 의 선택지 하나. */
+interface BasePropertyOption {
+    readonly name: string;
+    readonly color?: string;
+    /**
+     * Notion 내부 옵션 id. 사람이 보는 산출물에는 절대 나가지 않지만,
+     * status 그룹(`BaseStatusGroup.optionIds`)을 옵션명으로 되돌리는 유일한 열쇠다 —
+     * 뷰 필터가 옵션명 대신 그룹명으로 오기 때문에(예: `["To-do"]`) 이게 없으면
+     * 필터를 옮길 수 없다.
+     */
+    readonly id?: string;
+}
+/** status 속성의 그룹(To-do/In progress/Complete). 소속 옵션을 id 로 가리킨다. */
+interface BaseStatusGroup {
+    readonly name: string;
+    readonly color?: string;
+    readonly optionIds?: string[];
+}
+/**
+ * Notion DB 속성 스키마 — `.base` 생성·사이드카·필터 번역이 함께 쓰는 SSOT.
+ *
+ * 같은 모양을 세 군데(클라이언트 반환형·생성기 입력형)에 따로 적어 두면 한쪽만
+ * 넓혔을 때 조용히 어긋난다. 실제로 옵션 `id` 가 클라이언트에서만 빠져 있어
+ * status 그룹 필터를 옮길 수 없었다.
+ */
+interface BasePropertySchema {
+    readonly id: string;
+    readonly type: string;
+    readonly options?: BasePropertyOption[];
+    readonly groups?: BaseStatusGroup[];
+}
 interface PageCover {
     readonly type: "file" | "external";
     readonly url: string;
@@ -515,7 +763,8 @@ declare class ConfigManager {
 }
 
 interface IStateDB {
-    close(): void;
+    /** 닫는다 — 파일에 남은 쓰기를 마쳐야 하는 구현(플러그인의 sql.js)은 그 일을 Promise 로 돌려준다. */
+    close(): void | Promise<void>;
     getByPath(path: string): SyncRecord | null;
     getByNotionId(pageId: string): SyncRecord | null;
     getByStatus(status: SyncStatus): SyncRecord[];
@@ -523,7 +772,10 @@ interface IStateDB {
     upsert(record: UpsertSyncRecord): SyncRecord;
     updateStatus(id: string, status: SyncStatus): void;
     updateHash(id: string, hash: string, snapshot?: Buffer | Uint8Array | null): void;
-    setNotionLastEdited(id: string, lastEdited: string): void;
+    /** 원격을 본 기록을 적는다(N-05). 지문을 적지 않으면 있던 지문을 둔다. */
+    setRemoteObservation(id: string, observation: RemoteObservation): void;
+    /** 원격 본문 지문만 바꾼다 — 본문을 보냈지만 수정 시각은 올리지 않을 때. */
+    setNotionBodyFingerprint(id: string, fingerprint: string | null): void;
     updateStatCache(id: string, mtime: string, fileSize: number): void;
     setNotionParentId(id: string, parentId: string): void;
     /** 레코드의 로컬 경로를 갱신한다 (파일 rename/move 추적용). */
@@ -553,11 +805,19 @@ interface IStateDB {
 }
 
 declare class StateDB implements IStateDB {
+    private readonly lock;
     private readonly db;
     private constructor();
+    /**
+     * 상태 DB 파일을 연다 — 없으면 새로 만든다. 한 볼트의 상태 DB 는 한 곳만 연다 — 플러그인이나 다른 CLI 가 쓰는
+     * 중이면 {@link StateDbLockedError} 를 던진다(ADR-026). 저장된 파일이 비었거나 잘렸으면 빈 DB 로 열지 않고
+     * {@link SavedStateDbError} 를 던진다. 예전에는 0 · 1바이트 파일을 빈 DB 로 열고 닫을 때 빈 DB 로 덮었다.
+     */
     static open(dbPath: string): StateDB;
+    private static openLocked;
     private migrate;
     private getSchemaVersion;
+    /** 닫고 잠금을 푼다 — 닫는 사이 다른 곳이 열지 않게 닫은 뒤에 푼다. */
     close(): void;
     getByPath(path: string): SyncRecord | null;
     getByNotionId(pageId: string): SyncRecord | null;
@@ -566,7 +826,8 @@ declare class StateDB implements IStateDB {
     upsert(record: UpsertSyncRecord): SyncRecord;
     updateStatus(id: string, status: SyncStatus): void;
     updateHash(id: string, hash: string, snapshot?: Buffer | null): void;
-    setNotionLastEdited(id: string, lastEdited: string): void;
+    setRemoteObservation(id: string, observation: RemoteObservation): void;
+    setNotionBodyFingerprint(id: string, fingerprint: string | null): void;
     updateStatCache(id: string, mtime: string, fileSize: number): void;
     setNotionParentId(id: string, parentId: string): void;
     updatePath(id: string, newPath: string): void;
@@ -602,6 +863,9 @@ interface UpsertSyncRecord {
     readonly notionParentId?: string | null;
     readonly contentHash: string;
     readonly notionLastEdited?: string | null;
+    readonly notionLastEditedBy?: string | null;
+    readonly notionSeenAt?: string | null;
+    readonly notionBodyFingerprint?: string | null;
     readonly localLastModified: string;
     readonly syncDirection: SyncRecord["syncDirection"];
     readonly fileType: SyncRecord["fileType"];
@@ -647,26 +911,339 @@ interface RecordPendingInput {
     readonly payload?: string | null;
 }
 
+/** 스키마 하나 — 이 버전보다 낮은 DB 에 `sql` 을 돌린다. `sql` 은 끝에 `schema_version` 을 올린다. */
+interface StateDbMigration {
+    readonly version: number;
+    readonly sql: string;
+}
+/**
+ * 상태 DB 스키마 — 차례대로. CLI(better-sqlite3)와 플러그인(sql.js)이 이 목록 하나를 돈다. 예전에는 플러그인이
+ * SQL 을 손으로 베껴, 처음 두 스키마의 CHECK 제약이 플러그인 DB 에만 없었다.
+ */
+declare const STATE_DB_MIGRATIONS: readonly StateDbMigration[];
+
+/**
+ * 상태 DB 를 지금 쓸 수 없다 — 사용자가 풀 수 있는 실패다. 파일이 깨졌거나({@link SavedStateDbError}), 다른 곳이
+ * 쓰는 중이거나({@link StateDbLockedError}), CLI 가 남긴 기록이 아직 WAL 파일에만 있다({@link PendingWalError}).
+ *
+ * 할 일(`guidance`)을 같이 싣는다. 엔진을 띄우지 못한 것 같은 다른 실패와 가른다 — 거기에 할 일을 붙이면 멀쩡한
+ * 기록을 치우게 된다. 화면(CLI · 플러그인)은 이 종류인지만 보고, 다시 해 보는 법만 넘긴다.
+ *
+ * @see ./saved-state-db-error.ts
+ * @see ./state-lock.ts
+ */
+declare abstract class StateDbUnavailableError extends Error {
+    /** 할 일 — 화면마다 다시 해 보는 법(`retry`, 예: 「명령을 다시 실행하세요」)만 다르다. */
+    abstract guidance(retry: string): string;
+}
+
+/**
+ * 저장된 상태 DB 파일로 DB 를 열지 못했다 — 비었거나 잘렸거나 상태 DB 가 아닌 파일이다. 두 구현(CLI 의
+ * better-sqlite3 · 플러그인의 sql.js)이 같이 던진다. 엔진을 띄우지 못한 것 같은 다른 실패와 가른다 — 파일을
+ * 치우라는 안내({@link SavedStateDbError.guidance})는 이 경우에만 맞다.
+ */
+declare class SavedStateDbError extends StateDbUnavailableError {
+    constructor(message: string);
+    /**
+     * 동기화 기록 표가 없다 — SQLite 는 비었거나(0바이트) 앞 한 바이트만 남은 파일을 «빈 DB» 로 연다. 보지 않으면
+     * 기록을 잃은 채 처음부터 시작하고, 다음 push 가 모든 노트의 페이지를 또 만든다.
+     */
+    static noTables(bytes: number): SavedStateDbError;
+    /** SQLite 가 파일을 열지 못했다 — 잘렸거나(malformed) 상태 DB 가 아니다(not a database). */
+    static unreadable(error: unknown): SavedStateDbError;
+    /**
+     * 파일을 사본으로 바꾸거나 치운다. 폴더 이름이 점으로 시작해 Obsidian 의 파일 탐색기에는 보이지 않으므로 볼트
+     * 폴더에서 찾으라고 적는다.
+     */
+    guidance(retry: string): string;
+}
+/**
+ * 저장된 파일에 동기화 기록 표가 있는지 묻는 조회 — 한 번이라도 쓴 파일에는 마이그레이션이 만든 표가 있다. 한
+ * 페이지 이상 잘린 파일은 SQLite 가 이 조회에서 던진다(malformed).
+ */
+declare const SAVED_STATE_TABLES_QUERY = "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'sync_metadata'";
+
+/**
+ * 위키링크 글자 → `wikilink_map` 행을 찾는 조회들 — 앞에서부터 처음 맞는 행을 쓴다.
+ *
+ * CLI 의 better-sqlite3(`StateDB`)와 플러그인의 sql.js(`SqlJsStateDB`)가 같은 차례 · 같은 SQL 을 쓰도록
+ * 여기 한 벌만 둔다. 예전에는 두 곳에 손으로 베껴 있었다.
+ *
+ * - 제목 → 별칭 → 파일 이름 차례. 파일 이름은 `[[노트]]` 와 `[[폴더/노트]]` 둘 다 받는다.
+ *   예전 조회(`LIKE '%/노트.md'`)는 슬래시가 앞에 있어야 맞아서 볼트 맨 위 노트와 경로 붙은 링크를 못 찾았다 —
+ *   제목이 파일 이름과 다른 노트(파일 이름에 못 쓰는 글자를 바꾼 노트)로 가는 링크가 Notion 에서 글로 남았다.
+ * - LIKE 의 `%` · `_` 는 글자로 견준다. 예전에는 `a_b` 가 `a-b.md` 에도 맞았다.
+ */
+interface WikilinkLookup {
+    readonly sql: string;
+    readonly params: (text: string) => string[];
+}
+declare const WIKILINK_LOOKUPS: readonly WikilinkLookup[];
+
+/** 상태 DB 파일 옆의 잠금 파일. */
+declare function stateDbLockPath(dbPath: string): string;
+/** 상태 DB 를 여는 도구. */
+type StateDbTool = "cli" | "plugin";
+/** 잠금을 잡는 쪽 — 화면에 보일 이름(`label`, 예: 플러그인 이름)은 있으면 적는다. */
+interface StateLockClaim {
+    readonly tool: StateDbTool;
+    readonly label?: string;
+}
+/** 잠금 파일에 적는 주인. */
+interface StateLockOwner extends StateLockClaim {
+    readonly pid: number;
+    /** PID 가 같은 뜻을 갖는 범위 — {@link processScope}. */
+    readonly scope: string;
+    /** 잠금을 잡은 실행 환경 — 같은 PID 의 옛 환경이 남긴 잠금을 가른다({@link processContext}). */
+    readonly context: string;
+    readonly startedAt: string;
+    /** 잠금마다 새로 만드는 표 — 넘겨받힌 뒤 남의 잠금을 지우지 않도록 내 것인지 가른다. */
+    readonly token: string;
+}
+/** 잠금이 보는 바깥 — 시험이 갈아 끼운다. */
+interface StateLockEnv {
+    readonly pid: number;
+    readonly scope: string;
+    readonly context: string;
+    now(): number;
+    isAlive(pid: number): boolean;
+}
+declare class StateLock {
+    private readonly path;
+    readonly owner: StateLockOwner;
+    private readonly env;
+    private heartbeat;
+    private constructor();
+    /**
+     * 잠금을 잡는다. 다른 곳이 쥐고 있으면 {@link StateDbLockedError} 를 던진다. 주인이 끝나지 않고 죽었으면 넘겨받는다
+     * — 같은 PID 공간이면 PID 가 없거나 이 프로세스의 옛 실행 환경일 때, 아니면 신호가
+     * {@link STATE_LOCK_STALE_MS} 넘게 끊겼을 때다({@link isAbandoned}).
+     */
+    static acquire(path: string, claim: StateLockClaim, env?: StateLockEnv): StateLock;
+    /** 아직 내 잠금인가 — 잠금 파일에 내 표가 적혀 있다. */
+    isOwned(): boolean;
+    /**
+     * 내 잠금이 아니면 던진다 — 파일에 쓰기 전에 부른다. 멈춘 줄 알고 다른 곳이 넘겨받았는데 옛 사본을 쓰면 그쪽
+     * 기록을 지운다.
+     */
+    assertOwned(): void;
+    /**
+     * 잠금을 푼다 — 내 잠금일 때만 파일을 지운다. 여러 번 불러도 된다. 풀지 못해도 던지지 않는다 — 할 일은 이미
+     * 끝났고, 남은 잠금은 이 프로세스가 끝나면 다음에 여는 곳이 넘겨받는다.
+     */
+    release(): void;
+    private beat;
+}
+/**
+ * 상태 DB 를 다른 곳이 쓰는 중이다 — 기다렸다가 다시 하면 된다. 쓰는 곳이 없는데도 계속 막히면(PID 를 다른
+ * 프로세스가 물려받음) 잠금 파일을 지우는 법까지 알린다.
+ */
+declare class StateDbLockedError extends StateDbUnavailableError {
+    readonly holder: StateLockOwner | null;
+    private constructor();
+    /** 다른 곳이 잠금을 쥐고 있다. */
+    static held(holder: StateLockOwner | null, signalAgeMs: number): StateDbLockedError;
+    /** 쥐고 있던 잠금을 다른 곳이 넘겨받았다 — 멈춘 것으로 보였다. 옛 사본을 파일에 쓰지 않는다. */
+    static lost(holder: StateLockOwner | null): StateDbLockedError;
+    guidance(retry: string): string;
+}
+
+/** SQLite 가 WAL 모드에서 쓰는 옆 파일 — 이름은 SQLite 가 정한다. */
+declare function stateDbWalPath(dbPath: string): string;
+/**
+ * 최근 기록이 아직 WAL 파일에만 있다 — CLI 가 쓰는 중이거나 끝까지 닫지 못했다. CLI 가 닫으면(끝났으면 명령 하나를
+ * 다시 실행하면) 본 파일로 합쳐진다.
+ */
+declare class PendingWalError extends StateDbUnavailableError {
+    readonly walBytes: number;
+    constructor(walBytes: number);
+    guidance(retry: string): string;
+}
+/** WAL 파일에 쌓인 바이트 — 파일이 없으면 0. */
+declare function pendingWalBytes(dbPath: string): number;
+/**
+ * WAL 파일에 기록이 남았으면 던진다. 잠금을 잡은 뒤에 부른다 — 지금 CLI 는 잠금이 먼저 막으므로, 여기서 본 WAL 은
+ * 끝나지 않고 죽은 CLI 나 잠금을 모르는 옛 CLI 의 것이다.
+ */
+declare function assertNoPendingWal(dbPath: string): void;
+
 type NotionPropertyValue = Record<string, unknown>;
 interface WikilinkResolver$1 {
     resolve(title: string): string | null;
     resolvePageId(pageId: string): string | null;
 }
+interface PropertyMapperOptions {
+    /**
+     * 날짜시각을 적고 보낼 시간대(IANA 이름, 설정 `conversion.timeZone`). 없으면 이 컴퓨터의 시간대.
+     */
+    readonly timeZone?: string;
+}
+/** {@link PropertyMapper.toNotionPropertyChanges} 가 기준으로 삼는 지금 값들. */
+interface PropertyChangeContext {
+    /**
+     * 지금 로컬 frontmatter — 기간의 시작과 끝 중 하나만 바뀌어도 둘 다 보내야 해서 읽는다. 없으면 바뀐
+     * 값만 본다(새 행처럼 비교할 기준이 없을 때와 같다).
+     */
+    readonly current?: Readonly<Record<string, unknown>>;
+    /**
+     * 원격 페이지의 지금 속성(`page.properties`) — 글 속성 · 제목은 이 서식 위에 바뀐 글자만 고친다
+     * ({@link patchRichText}). 없으면 평문으로 보낸다.
+     */
+    readonly remote?: Readonly<Record<string, unknown>>;
+}
 declare class PropertyMapper {
+    private readonly options;
     private schema;
     private wikilinkResolver;
+    constructor(options?: PropertyMapperOptions);
+    /** 설정의 변환 옵션으로 만든다 — 시간대를 이 한 곳에서 읽는다. */
+    static fromConfig(config: Pick<Config, "conversion">): PropertyMapper;
     setWikilinkResolver(resolver: WikilinkResolver$1): void;
     loadSchema(properties: Record<string, {
         id: string;
         type: string;
     }>): void;
+    /**
+     * frontmatter 전체를 Notion 속성 값으로 바꾼다 — 비교할 기준이 없는 새 행을 만들 때 쓴다.
+     *
+     * 스키마를 읽었으면 스키마에 없는 키는 보내지 않는다. pull 이 적는 `cover` · `icon` 이나
+     * 사용자가 붙인 `aliases` 처럼 DB 속성이 아닌 키를 보내면 Notion 이 «그런 속성은 없다»
+     * 며 요청 전체를 거부한다 — 행의 다른 속성까지 하나도 반영되지 않는다.
+     */
     toNotionProperties(frontmatter: Record<string, unknown>, title: string): Record<string, NotionPropertyValue>;
+    /**
+     * 바뀐 속성만 Notion 속성 값으로 바꾼다(S-01).
+     *
+     * 비운 속성은 그 타입의 빈 값으로 보낸다. 되돌릴 수 없는 것은 비우지 않는다 — `files`
+     * 를 비우면 Notion 에 올라간 첨부가 지워지고 볼트에는 그 파일이 없다. `status` 는 빈 값이
+     * 없다. 스키마에 없는 키와 읽기 전용 속성(수식 · 롤업 · 생성일 …)도 보내지 않는다.
+     *
+     * 날짜는 오프셋 없는 시각에 시간대의 오프셋을 붙여 보낸다 — Notion 은 오프셋 없는 시각을 UTC 로 읽는다.
+     * 기간은 시작과 끝(짝 키) 중 하나만 바뀌어도 둘을 함께 보낸다 — 날짜 값은 통째로 바뀐다. 글 속성 ·
+     * 제목은 원격 서식 위에 바뀐 글자만 고친다(`context.remote`).
+     *
+     * @param title 제목이 바뀌었을 때만 새 제목, 아니면 null.
+     * @returns `skipped` — 바뀌었지만 보내지 않은 속성 이름. 호출측이 알린다.
+     */
+    toNotionPropertyChanges(changes: RowPropertyChanges, title: string | null, context?: PropertyChangeContext): {
+        properties: Record<string, NotionPropertyValue>;
+        skipped: string[];
+    };
+    /**
+     * 값을 보낼 수 있는 속성만, pull 이 적는 모양으로 — 원격 값과 로컬 값을 견줄 때 쓴다.
+     *
+     * 고르는 것은 스키마에 있고 읽기 전용이 아니고 제목이 아닌 키와 날짜 속성의 짝 키다. 수식 · 롤업 같은
+     * 값은 달라도 보낼 수 없으니 견주지 않는다. 날짜는 예전 버전이 적은 모양(`…+09:00` · `{start, end}`)도
+     * 시간대의 벽시계 시각 · 짝 키로 바꿔 같은 순간이면 같게 본다(F-08).
+     */
+    writableValues(values: Readonly<Record<string, unknown>>): Record<string, unknown>;
+    /**
+     * `written` 에서 예전 버전이 적은 날짜 모양이 남은 키(F-08) — 날짜 · 생성일 · 수정일 · 날짜 수식 · 날짜
+     * 롤업 가운데, 지금 받으면 적을 값과 같은 순간인데 적힌 모양이 다른 것(`…Z` · `…+09:00` · `{start, end}`).
+     * 기간은 짝 키(`<이름>_end`)도 함께 — 둘 중 하나라도 적혀 있거나 받으면 적을 키만. 원격이 그대로인 행은
+     * 다시 받지 않으므로, 이런 행은 따로 골라 이 키들을 새 모양으로 고쳐 써야 한다.
+     *
+     * 값이 다른 키는 보지 않는다 — 수식 · 롤업은 행의 수정 시각을 바꾸지 않고 다시 계산되고, 시간대 설정을
+     * 바꾸면 벽시계 시각이 달라진다. 모양 때문이 아니다.
+     *
+     * @param written 행 노트에 적힌 frontmatter.
+     * @param notionProps 원격 행의 속성(`page.properties`).
+     * @returns 고쳐 쓸 키. 없으면 빈 배열.
+     */
+    outdatedDateKeys(written: Readonly<Record<string, unknown>>, notionProps: Record<string, unknown>): string[];
     fromNotionProperties(notionProps: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * 이 행에서 기간의 끝을 적는 짝 키 — 날짜 속성 이름 → 짝 키. 값이 기간인 속성만이다
+     * ({@link fromNotionProperties} 가 끝을 짝 키에 적는 것과 같다).
+     */
+    rangeEndKeysOf(notionProps: Readonly<Record<string, unknown>>): Map<string, string>;
+    /**
+     * 이 행에서 Notion 이 정하는 frontmatter 키 — {@link fromNotionProperties} 가 적을 수 있는 키 전부다.
+     * 값이 비어 적지 않은 속성과 지금은 기간이 아니어서 적지 않은 짝 키도 든다. pull 이 받은 속성을 로컬
+     * frontmatter 와 합칠 때 이 밖의 키는 로컬 것으로 둔다.
+     */
+    ownedKeys(notionProps: Readonly<Record<string, unknown>>): string[];
+    private zone;
+    /** `key` 가 날짜 속성의 짝 키면 그 날짜 속성 이름. */
+    private rangeOwnerOf;
+    /** 날짜 속성인데 짝 키를 쓰는가 — 같은 이름의 속성이 DB 에 따로 없을 때. */
+    private hasRangeKey;
+    /**
+     * 짝 키를 쓰는 날짜 속성에 보낼 값 — 시작(`name`)과 끝(`name_end`)을 함께. 둘 다 비었으면 지운다.
+     * 끝만 있으면 보낼 수 없다(Notion 의 날짜는 시작이 있어야 한다) — null.
+     */
+    private rangeRequest;
     private convertBySchema;
     private inferAndConvert;
     private extractValue;
 }
 
+/**
+ * 취소 신호. `AbortSignal` 과 호환되며, 테스트에서 가벼운 목 객체로도 쓸 수 있다.
+ */
+interface AbortLike {
+    readonly aborted: boolean;
+}
+
+/** 만들 블록 — 블록 API 요청 모양. 자식은 몸통의 `children` 에 깊이 제한 없이 담는다. */
+interface BlockRequest {
+    readonly type: string;
+    readonly [body: string]: unknown;
+}
+
+/** {@link NotionClient.searchRecentPages} 의 한 줄. */
+interface RecentPage {
+    readonly id: string;
+    readonly last_edited_time: string;
+    readonly last_edited_by: {
+        readonly id: string;
+    } | null;
+    /**
+     * DB 행이면 그 DB 의 id, 페이지면 null — 바뀐 행이 있는 DB 만 조회하는 데 쓴다(ADR-027). search 는 행의
+     * 부모를 `data_source_id` 로 주면서 DB id 를 함께 싣는다(실측 2026-09-28).
+     */
+    readonly parentDatabaseId: string | null;
+    /**
+     * 부모와 제목 — search 는 페이지 객체를 통째로 준다(실측 2026-10-21: 부모 · 제목 속성 포함). 새 페이지가 받을
+     * 것인지 가르는 데 쓴다. 예전에는 추적하지 않는 페이지마다 다시 읽어 이 둘을 얻었다 — 워크스페이스에서 최근
+     * 고친 페이지가 많을수록 pull 마다 요청이 그만큼 늘었다(B8).
+     */
+    readonly parent: PageObjectResponse["parent"];
+    readonly title: string;
+}
+/**
+ * {@link NotionClient.searchRecentDataSources} 의 한 줄 — 속성(스키마) · 제목이 바뀐 data source. 행을 고쳐도
+ * data source 의 수정 시각은 오르지 않는다(실측 2026-09-28) — 행의 변경은 {@link RecentPage} 로 본다.
+ */
+interface RecentDataSource {
+    readonly id: string;
+    readonly last_edited_time: string;
+    /** 이 data source 가 속한 DB. 모르면 null. */
+    readonly databaseId: string | null;
+}
+/** 블록 API 의 블록 하나 — 자식이 있으면 `children` 에 담겨 온다({@link NotionClient.getBlockTree}). */
+type BlockTreeNode = BlockObjectResponse & {
+    children?: BlockTreeNode[];
+};
+/**
+ * DB 하나를 한 번 받은 것 — 행 조회 · 스키마 · 제목이 같은 것을 다시 받지 않고 이것을 읽는다. 예전에는 DB 하나를
+ * 받는 데 같은 DB 를 서너 번 다시 받아(요청 6~8회) 발견 DB 166개의 pull 이 분 단위였다.
+ */
+interface DatabaseMeta {
+    readonly databaseId: string;
+    /** DB 제목. 없으면 "". */
+    readonly title: string;
+    /** 행을 조회할 data source. 비었으면 옛 단일 소스 DB 다 — DB id 로 조회한다. */
+    readonly dataSources: ReadonlyArray<{
+        readonly id: string;
+        readonly name: string;
+    }>;
+    /**
+     * 속성 스키마 — 읽을 수 있는 모든 data source 의 속성을 합친 것(이름이 겹치면 앞의 것). 읽을 수 있는 data
+     * source 가 없으면 DB 객체의 속성.
+     */
+    readonly properties: Readonly<Record<string, unknown>>;
+}
 interface NotionClientOptions {
     readonly token: string;
     readonly concurrency?: number;
@@ -677,6 +1254,10 @@ interface NotionClientOptions {
     readonly retryBackoffFactor?: number;
     readonly pageSize?: number;
     readonly batchSize?: number;
+    /** 잘린 Markdown 을 채우려고 다시 받는 블록 수 상한 (S-06) */
+    readonly markdownCompletionMaxBlocks?: number;
+    /** 페이지 속성의 날짜시각을 적을 시간대(`conversion.timeZone`) — 없으면 이 컴퓨터의 시간대. */
+    readonly timeZone?: string;
     readonly fetch?: typeof globalThis.fetch;
 }
 declare class NotionClient {
@@ -689,10 +1270,30 @@ declare class NotionClient {
     private readonly retryBackoffFactor;
     private readonly defaultPageSize;
     private readonly batchSize;
+    private readonly markdownCompletionMaxBlocks;
+    /** {@link getBotUserId} 가 받은 값 — 받는 중이면 그 약속. */
+    private botUserId;
+    /** {@link getUserNames} 가 물은 사용자 이름 — 읽지 못한 사용자는 null. */
+    private readonly userNames;
     constructor(options: NotionClientOptions);
     /** config.advanced 의 운영 튜닝값으로 클라이언트를 생성한다 (매직넘버 단일 진실원). */
     static fromConfig(config: Config, fetch?: typeof globalThis.fetch): NotionClient;
     getInternalClient(): Client;
+    /**
+     * 이 토큰의 봇 사용자 id(`GET /v1/users/me`). 이 통합이 고친 페이지는 `last_edited_by` 가 이
+     * id 다 — 같은 분 안에서 우리 뒤에 누가 고쳤는지 가르는 데 쓴다(`sync/remote-observation.ts`).
+     * 받은 값은 기억한다. 받지 못하면 던지고 기억하지 않는다 — 다음 호출이 다시 묻는다.
+     */
+    getBotUserId(): Promise<string>;
+    /**
+     * 사용자 멘션에 보일 이름(`GET /v1/users/:id`). Markdown API 는 사용자 멘션을 이름 없는 태그로
+     * 내보낸다(`converter/mention.ts`).
+     *
+     * 물은 사용자는 기억한다 — 같은 사람이 여러 노트에 나와도 한 번만 묻는다. 읽지 못한 사용자(권한 없는
+     * 통합 · 나간 사용자)는 이유를 남기고 맵에서 뺀다. 그 멘션은 이름 대신 정해 둔 글로 보이지만, 멘션
+     * 자체는 id 로 보존된다.
+     */
+    getUserNames(ids: readonly string[]): Promise<Map<string, string>>;
     getPage(pageId: string): Promise<PageObjectResponse>;
     createPage(params: {
         parentId: string;
@@ -708,27 +1309,63 @@ declare class NotionClient {
         markdown: string;
         properties?: Record<string, unknown>;
     }): Promise<PageObjectResponse>;
+    /**
+     * {@link createPageWithMarkdown} 이 버린 맨 앞 `# H1` 을 되살린다 — 그 markdown 이 H1 으로
+     * 시작할 때만 같은 markdown 으로 본문을 한 번 바꾼다({@link startsWithHeading1}).
+     *
+     * 만든 직후, 하위 페이지를 만들기 전에 부른다 — 교체가 지울 자식이 없다. 호출측은 먼저 페이지
+     * 매핑을 적어 둔다: 여기서 실패해도 다음 push 가 새로 만들지 않고 본문을 다시 보낸다.
+     *
+     * @returns 본문을 바꿨으면 true
+     */
+    restoreLeadingHeading(pageId: string, markdown: string): Promise<boolean>;
     updatePageProperties(pageId: string, properties: Record<string, unknown>): Promise<PageObjectResponse>;
+    /**
+     * 페이지 마크다운. 블록이 많아 잘린 부분은 블록 ID 로 다시 받아 채운다(S-06 —
+     * {@link completeTruncatedMarkdown}). 돌려준 `unknown_block_ids` 는 권한이 닿지 않아 끝내
+     * 읽지 못한 블록이고, 그 자리는 원래 블록을 지키는 태그로 남아 있다.
+     */
     getPageMarkdown(pageId: string): Promise<PageMarkdownResponse>;
+    private retrieveMarkdown;
+    /**
+     * 본문을 통째로 바꾼다. 자식 페이지 · 자식 DB 는 **지우지 않는다**(S-03).
+     *
+     * `allow_deleting_content: true` 로 보내면 새 본문에 `<page>` · `<database>` 태그가 없는
+     * 자식을 Notion 이 휴지통으로 보낸다. 삭제를 허용하지 않으면 무엇이 지워질지 나열하며
+     * `validation_error` 로 거절하고 아무것도 바꾸지 않는다(2026-09-27 실측) — 호출측이
+     * 자식 태그를 되돌려 놓고 다시 보낸다(`sync/page-body.ts`).
+     */
     replacePageMarkdown(pageId: string, markdown: string): Promise<PageMarkdownResponse>;
     updatePageMarkdownPartial(pageId: string, patches: Array<{
         oldStr: string;
         newStr: string;
         replaceAll?: boolean;
     }>): Promise<PageMarkdownResponse>;
-    movePage(pageId: string, newParentId: string, newParentType: "page" | "database"): Promise<PageObjectResponse>;
     /**
-     * 데이터베이스 1개를 신 모델(2025-09-03 data source 분리)로 조회한다.
-     * - title: database 객체에 그대로 존재한다.
-     * - properties(스키마): 신 모델에선 data source 에 있으므로 1차 data source 를 조회해 채운다.
+     * 페이지를 다른 페이지 아래로 옮긴다 — `POST /v1/pages/{id}/move`.
+     *
+     * 페이지 갱신(pages.update)은 부모를 바꾸지 않는다 — `parent` 를 보내도 오류 없이 무시한다.
+     * 예전 movePage 가 그 길을 써서, 옮긴 노트의 Notion 부모가 한 번도 바뀌지 않았다(S-11).
+     * 같은 부모로 다시 옮겨도 결과가 같아 모호한 실패는 다시 보낸다.
+     */
+    movePage(pageId: string, parentPageId: string): Promise<void>;
+    /**
+     * 데이터베이스 1개를 신 모델(2025-09-03 data source 분리)로 조회한다 — DB 1회 + data source 마다 1회.
+     * - title · data source 목록: database 객체에 그대로 존재한다.
+     * - properties(스키마): 신 모델에선 data source 에 있으므로 data source 를 조회해 채운다.
      *   data source 접근 불가(링크드 DB 등)면 database 객체의 properties 로 폴백한다(제목은 보존).
      *
+     * 같은 DB 의 행 조회 · 스키마 · 제목은 받은 것({@link DatabaseMeta})을 넘겨 다시 받지 않는다.
+     *
      * 폐기한 레거시 raw fetch(`GET /v1/databases/{id}`, Notion-Version 2022-06-28)는 신 모델로
      * 업그레이드된 다수 DB에 400 을 반환해 자동 발견 DB 가 통째 드롭(내용 손실)되던 원인이었다.
      * SDK(`databases.retrieve`/`dataSources.retrieve`)는 동일 토큰으로 정상 동작한다.
      */
-    private fetchDatabaseModern;
-    getDatabaseTitle(databaseId: string): Promise<string>;
+    getDatabaseMeta(databaseId: string): Promise<DatabaseMeta>;
+    /** `from` 이 이 DB 를 받은 것이면 그것을, 아니면 새로 받는다. */
+    private metaOf;
+    /** @param from 이미 받은 이 DB — 주면 다시 받지 않는다. */
+    getDatabaseTitle(databaseId: string, from?: DatabaseMeta): Promise<string>;
     /**
      * 발견된 DB 가 **동기화 가능한지**(접근 가능한 data source 가 있는지) 판별한다.
      * 신 모델(2025-09-03)에서 링크드 DB·미공유 데이터 소스·삭제 DB 는 `data_sources` 가
@@ -757,23 +1394,22 @@ declare class NotionClient {
         originalDbId: string;
         viewName: string;
     } | null>;
-    getDatabaseSchema(databaseId: string): Promise<Record<string, {
-        id: string;
-        type: string;
-    }>>;
-    getDatabaseSchemaFull(databaseId: string): Promise<Record<string, {
+    /** @param from 이미 받은 이 DB — 주면 다시 받지 않는다. */
+    getDatabaseSchema(databaseId: string, from?: DatabaseMeta): Promise<Record<string, {
         id: string;
         type: string;
-        options?: Array<{
-            name: string;
-            color?: string;
-        }>;
-        groups?: Array<{
-            name: string;
-            color?: string;
-            optionIds?: string[];
-        }>;
     }>>;
+    /**
+     * DB 속성 스키마 전체(선택지·status 그룹 포함).
+     *
+     * 옵션 `id` 까지 그대로 실어 보낸다 — 산출물에는 안 나가지만, status 뷰 필터가
+     * 옵션명이 아니라 **그룹명**(`To-do` 등)으로 오기 때문에 `groups[].optionIds` 를
+     * 옵션명으로 되돌리려면 이 id 가 있어야 한다. 예전엔 여기서 id 를 떨궈,
+     * 그룹으로 필터링된 뷰를 Bases 로 옮길 방법이 아예 없었다.
+     *
+     * @param from 이미 받은 이 DB — 주면 다시 받지 않는다.
+     */
+    getDatabaseSchemaFull(databaseId: string, from?: DatabaseMeta): Promise<Record<string, BasePropertySchema>>;
     /** 특정 data source 1개를 직접 쿼리한다(저수준). 다중 data source 순회의 빌딩블록. */
     private queryDataSource;
     /**
@@ -794,8 +1430,10 @@ declare class NotionClient {
      * 페이지네이션하면 2번째+ 의 행이 통째 침묵 유실된다. 전 data source 를 순회·페이지네이션
      * 하고 page_id 로 디듀프(소스 간 동일 페이지 방어)한 뒤 합친다. 다중 소스면 1회 경고해
      * "소스별 탭 구분이 한 폴더로 병합"되는 점을 비침묵으로 알린다.
+     *
+     * @param from 이미 받은 이 DB — 주면 data source 목록을 다시 받지 않는다.
      */
-    queryAllDatabasePages(databaseId: string, filter?: unknown): Promise<PageObjectResponse[]>;
+    queryAllDatabasePages(databaseId: string, filter?: unknown, from?: DatabaseMeta): Promise<PageObjectResponse[]>;
     /** database 의 1차 data source id(없으면 databaseId 폴백). 단일 소스 경로 호환용. */
     getDataSourceId(databaseId: string): Promise<string>;
     /**
@@ -807,7 +1445,19 @@ declare class NotionClient {
         name: string;
     }>>;
     archivePage(pageId: string): Promise<void>;
+    /**
+     * 파일 블록의 지금 받을 수 있는 주소. 블록이 없거나 볼 수 없으면 null 이다.
+     * 그 밖의 실패(일시 오류 등)는 던진다 — 예전에는 모두 null 로 삼켜 이유가 남지 않았다.
+     */
     getFileBlockUrl(blockId: string): Promise<string | null>;
+    /**
+     * 북마크 블록의 주소와 캡션(F-09). Markdown API 는 북마크를 주소 없는 자리 태그로만 보낸다
+     * (`converter/bookmark.ts`) — 블록마다 한 번 읽는다.
+     *
+     * 읽지 못한 블록은 이유를 남기고 맵에서 뺀다. 그 북마크는 Notion 의 블록을 가리키는 링크로 보이고,
+     * 블록 자체는 마커로 보존된다. 북마크가 아닌 블록도 뺀다.
+     */
+    getBookmarks(blockIds: readonly string[]): Promise<Map<string, BookmarkTarget>>;
     getBlock(blockId: string): Promise<BlockObjectResponse>;
     listChildren(blockId: string, options?: {
         startCursor?: string;
@@ -819,8 +1469,51 @@ declare class NotionClient {
     fetchAllChildren(blockId: string): Promise<BlockObjectResponse[]>;
     private static readonly CONTAINER_BLOCK_TYPES;
     fetchAllChildrenDeep(blockId: string): Promise<BlockObjectResponse[]>;
-    appendChildren(blockId: string, children: unknown[]): Promise<void>;
+    /**
+     * 블록 트리 — 자식이 있는 블록은 `children` 에 자식을 담는다. 자식 페이지 · DB 는 열지 않는다. 동기화
+     * 참조 블록은 Notion 이 원본의 자식을 돌려주므로 그대로 담는다(Markdown API 도 원본 내용을 싣는다).
+     *
+     * 블록 하나라도 읽지 못하면 던진다 — 빠진 채로 노트를 쓰면 다음 push 가 그 블록을 Notion 에서 지운다.
+     */
+    getBlockTree(blockId: string): Promise<BlockTreeNode[]>;
+    /**
+     * 자식 블록을 덧붙인다. `options.after` 를 주면 그 블록 **바로 뒤**에 삽입한다
+     * (기본은 맨 끝). 자리표시자를 실제 미디어 블록으로 제자리 교체할 때 필요하다.
+     *
+     * 실측(2025-09-03): position 삽입 응답의 `results` 는 방금 넣은 블록뿐 아니라
+     * 삽입 지점 이후의 형제까지 함께 돌려준다. 앞에서부터 batch 길이만큼이 새 블록이므로
+     * 배치를 이어 붙일 때는 그 마지막 id 를 다음 기준점으로 삼는다.
+     */
+    appendChildren(blockId: string, children: unknown[], options?: {
+        readonly after?: string;
+    }): Promise<string[]>;
+    /**
+     * {@link appendChildren} 과 같되 새로 만든 블록을 통째로 돌려준다. 파일을 붙인 미디어 블록은
+     * 응답에 Notion 이 저장한 파일의 URL 이 실려 온다 — 다시 조회하지 않고 그 파일을 알아 둔다(S-05).
+     */
+    appendChildBlocks(blockId: string, children: unknown[], options?: {
+        readonly after?: string;
+    }): Promise<(BlockObjectResponse | PartialBlockObjectResponse)[]>;
+    /**
+     * 깊이 제한 없는 블록 트리를 맨 끝에 덧붙인다 — 요청 한도(깊이 두 단계 · 100 개 · 1000 블록)를 넘는
+     * 자식은 부모를 만든 뒤 그 아래에 마저 붙인다({@link shapeAppendRequests}). 더 깊은 블록의 id 는
+     * 응답에 없어 부모의 자식 목록을 읽어 찾는다.
+     *
+     * 중간에 실패하면 그때까지 만든 블록은 남는다 — 호출측이 실패로 알린다.
+     */
+    appendBlockTree(parentId: string, blocks: readonly BlockRequest[]): Promise<void>;
     deleteBlock(blockId: string): Promise<void>;
+    /**
+     * 코드 블록의 글을 바꾼다 — Markdown API 로 보낼 수 없는 코드(코드 속 ``` 줄, S-22)를 블록으로
+     * 채운다. 긴 코드는 rich text 여럿에 나눠 담는다. 같은 글로 다시 보내도 결과가 같아 모호한 실패는
+     * 다시 보낸다.
+     */
+    updateCodeBlockText(blockId: string, code: string, language: LanguageRequest): Promise<void>;
+    /**
+     * 페이지 코드 블록의 글 — 컨테이너 안까지. 받은 markdown 만으로 코드 범위를 가를 수 없을 때(코드 속
+     * ``` 줄, S-22) 블록의 글로 맞춘다.
+     */
+    getCodeBlockTexts(pageId: string): Promise<string[]>;
     /** single_part 업로드 상한 (Notion API 규격 20MB) */
     private static readonly SINGLE_PART_MAX_BYTES;
     /** multi_part 파트 크기 — 규격상 마지막 파트 제외 5~20MB, 10MB 고정 사용 */
@@ -840,13 +1533,17 @@ declare class NotionClient {
         results: PageObjectResponse[];
         nextCursor: string | null;
     }>;
-    searchRecentPages(since: string): Promise<Array<{
-        id: string;
-        last_edited_time: string;
-    }>>;
+    /**
+     * `since` 뒤에 고친 페이지 — 최근 것부터. DB 행도 온다. 누가 마지막으로 고쳤는지도 싣는다: 수정
+     * 시각은 분 단위라 같은 분 안의 편집은 편집자로만 가를 수 있다(N-05).
+     */
+    searchRecentPages(since: string, signal?: AbortLike): Promise<RecentPage[]>;
+    /**
+     * `since` 뒤에 속성(스키마) · 제목이 바뀐 data source — 최근 것부터. 속성을 더하거나 이름을 바꾸면 행은
+     * 그대로라도 그 DB 의 `.base` 와 행의 frontmatter 가 바뀐다.
+     */
+    searchRecentDataSources(since: string, signal?: AbortLike): Promise<RecentDataSource[]>;
     getChildPages(parentId: string): Promise<PageObjectResponse[]>;
-    /** 페이지가 휴지통(in_trash)이거나 보관(archived) 상태인지 판정한다. */
-    private static isTrashedOrArchived;
     getChildDatabaseIds(parentId: string): Promise<string[]>;
     /**
      * root 서브트리를 직접 BFS 순회해 하위 페이지를 모두 수집한다(중첩 깊이 무관·무손실).
@@ -854,13 +1551,17 @@ declare class NotionClient {
      *
      * @param opts.deadlineMs `Date.now()` 기준 마감 시각. 각 페이지 처리 전 초과를 검사해
      *   초과 시 {@link DiscoveryTooLargeError}를 던진다(대규모 서브트리 → search 폴백 유도).
+     *   **그때까지 찾은 페이지는 에러의 `partial` 에 실어 보낸다** — 버리면 호출측이 두
+     *   경로를 경합시키게 되고, 어느 쪽이 이기는지를 벽시계가 정하게 된다(R12-A).
      *   미지정 시 무제한(기존 동작 유지 — 테스트 mock 경로는 영향 없음).
+     * @param opts.signal 취소되면 다음 페이지로 가기 전에 `OperationAbortedError` 로 멈춘다.
      */
     getChildPagesRecursive(parentId: string, opts?: {
         deadlineMs?: number;
+        signal?: AbortLike;
     }): Promise<PageObjectResponse[]>;
     /** 워크스페이스에서 통합에 공유된 모든 페이지를 bulk search 로 열거한다(100/요청). */
-    searchAllPages(): Promise<PageObjectResponse[]>;
+    searchAllPages(signal?: AbortLike): Promise<PageObjectResponse[]>;
     /**
      * root 하위 페이지를 **search 기반**으로 디스커버리한다(대규모 서브트리용 폴백).
      *
@@ -875,7 +1576,7 @@ declare class NotionClient {
      *  - 휴지통/보관(in_trash/archived) 페이지 제외
      *  - root 자신은 제외(직접 순회도 root 의 *자식*부터 수집)
      */
-    getPagesUnderRootViaSearch(rootId: string): Promise<PageObjectResponse[]>;
+    getPagesUnderRootViaSearch(rootId: string, signal?: AbortLike): Promise<PageObjectResponse[]>;
     listDatabaseViews(databaseId: string): Promise<ViewConfig[]>;
     getView(viewId: string): Promise<ViewConfig | null>;
     getDatabaseViewsConfig(databaseId: string): Promise<DatabaseViewsConfig>;
@@ -892,8 +1593,35 @@ declare class NotionClient {
     setWikilinkResolver(resolver: WikilinkResolver$1): void;
     extractProperties(page: PageObjectResponse): Record<string, unknown>;
     private lastRequestTime;
+    /**
+     * 429 이후 **클라이언트 전체**가 쉬어야 하는 시각(epoch ms).
+     *
+     * rate limit 은 요청 하나의 문제가 아니라 워크스페이스 전체에 걸린 신호다. 그러니
+     * 429 를 맞은 요청만 기다리게 두면 나머지 슬롯이 곧바로 다시 두드려 429 를 재생산한다.
+     * 슬롯을 붙잡아 남을 막는 대신, 다 같이 보는 이 게이트로 쉬게 한다.
+     */
+    private cooldownUntil;
+    /**
+     * 요청 1건을 rate limit 슬롯 안에서 실행하고, 재시도 가능한 실패는 백오프 후 다시 시도한다.
+     *
+     * 백오프 대기는 **슬롯을 놓은 뒤** 한다. 예전 구현은 `sema.acquire()` 안에서 재시도
+     * 전체(최대 60초 x 5회)를 돌려, 불운한 요청 하나가 동시성 한 칸을 최대 5분 점유했다.
+     * 동시성 기본값이 3이므로 그런 요청 3건이면 클라이언트 전체가 멈춘다. 게다가 재시도는
+     * 로그를 한 줄도 남기지 않아, 겉보기에는 죽은 프로세스와 구분되지 않았다 — 실제로
+     * 268페이지 pull 이 진행 로그가 멈춘 채 수 분씩 정지하는 것으로 나타났다(R9).
+     * 그래서 (1) 대기 중에는 슬롯을 반납하고, (2) 429 는 {@link cooldownUntil} 전역
+     * 게이트로 함께 쉬고, (3) 모든 재시도를 경고로 남긴다.
+     *
+     * `idempotent: false` 는 두 번 적용되면 결과가 달라지는 쓰기다(페이지 생성 · 블록
+     * 덧붙이기 · 부분 치환). 이런 요청은 서버가 «처리하지 않았다» 고 분명히 말한 실패만
+     * 다시 보낸다. 타임아웃 · 연결 끊김 · 5xx 는 요청이 이미 적용됐을 수 있고 Notion 은
+     * 멱등 키를 받지 않으므로, 다시 보내면 같은 페이지 · 같은 블록이 두 벌 생긴다.
+     * 그런 실패는 호출측으로 올린다 — 페이지 생성은 WAL(pending_operations)이 부모에서
+     * 제목으로 찾아 입양한다.
+     */
     private withRateLimit;
-    private executeWithRetry;
+    /** 슬롯을 쥔 뒤의 발사 대기 — 전역 쿨다운(429)과 최소 요청 간격을 함께 지킨다. */
+    private waitForTurn;
 }
 
 interface RichTextSegment {
@@ -1000,17 +1728,188 @@ declare class NotionBlockBuilder {
     static table(rows: string[][], hasColumnHeader?: boolean, hasRowHeader?: boolean): NotionBlock;
 }
 
-interface FileInfo {
-    readonly path: string;
-    readonly content: string;
-    readonly mtime: string;
-}
+/**
+ * DB 완결성 게이트 — "원격에 있는 행이 볼트에도 전부 있는가"를 대조한다.
+ *
+ * ## 왜 필요한가 (R11)
+ *
+ * 기존 게이트는 전부 **멱등성**(같은 입력에 같은 출력)을 본다 — 해시 불일치 0, repull
+ * 바이트 동일, churn 0. 그런데 멱등성은 *체계적 미발견*을 구조적으로 잡지 못한다:
+ * 디스커버리가 매번 **같은 행을 똑같이 놓치면** 두 번째 pull 도 첫 번째와 동일한
+ * 결과를 내므로 churn 은 0 이고 해시도 전부 일치한다. 실제로 2026-07-17 pull 은 DB 행
+ * 296개를 침묵 유실한 채 `audit-vault 결함 0 · 해시 불일치 0 · byte-identical repull`
+ * 을 전부 통과했다. "안 바뀐다"와 "빠짐없다"는 다른 성질이고, 후자를 보는 게이트가
+ * 없었던 것이다.
+ *
+ * 이 모듈은 후자만 본다. 원격 행 id 집합과 볼트가 추적 중인 db-row id 집합을 직접
+ * 대조해, 어느 쪽에만 있는지를 센다. 카운트가 아니라 **집합**을 비교하는 이유는
+ * 카운트만 보면 "1건 미발견 + 1건 잔재"가 상쇄돼 통과하기 때문이다.
+ *
+ * ## 범위와 한계
+ *
+ * 볼트가 **아는** database 에 대해 "그 DB 의 모든 행이 있는가"를 보장한다. database
+ * 자체를 통째로 못 찾은 경우는 볼트에 흔적이 없어 여기서 알 수 없으므로, 호출부가
+ * 설정/디스커버리가 아는 database id 를 {@link CompletenessOptions.databaseIds} 로
+ * 넘겨 그 구멍까지 덮는다(행 0개로 대조되어 미발견이 그대로 드러난다).
+ *
+ * 원격 열거는 {@link CompletenessRemoteSource.queryAllDatabasePages} — 전 data source
+ * 를 순회하는 SSOT — 하나만 쓴다. 여기서 별도 쿼리를 짜면 검증기가 피검증 대상과 다른
+ * 열거 규칙을 갖게 돼, 게이트가 통과해도 실제 pull 은 놓치는 상황이 생긴다.
+ */
+/** 원격 행 열거 — {@link NotionClient} 가 그대로 만족한다(전 data source 순회 SSOT). */
+interface CompletenessRemoteSource {
+    queryAllDatabasePages(databaseId: string, filter?: unknown): Promise<Array<{
+        id: string;
+    }>>;
+}
+/** 볼트가 추적 중인 레코드 열거 — {@link IStateDB} 가 그대로 만족한다. */
+interface CompletenessLocalSource {
+    getAll(): ReadonlyArray<{
+        readonly notionPageId: string | null;
+        readonly notionParentId: string | null;
+        readonly fileType: string;
+    }>;
+}
+/** database 1개의 대조 결과. */
+interface DatabaseCompleteness {
+    /** 대조 대상 database id(입력 표기 그대로). */
+    readonly databaseId: string;
+    /** 원격 행 수(전 data source 합·page id 디듀프 후). */
+    readonly remoteRows: number;
+    /** 볼트가 이 DB 소속으로 추적 중인 db-row 수. */
+    readonly localRows: number;
+    /** 원격에만 있는 행 id — **침묵 미발견**. 비어야 정상. */
+    readonly missingIds: readonly string[];
+    /** 볼트에만 있는 행 id — 원격 삭제 잔재/부모 오배치. 비어야 정상. */
+    readonly extraIds: readonly string[];
+}
+/** 원격 열거가 실패한 database — 결과를 "이상 없음"으로 접지 않기 위해 따로 싣는다. */
+interface CompletenessFailure {
+    readonly databaseId: string;
+    readonly error: string;
+}
+/** {@link verifyDatabaseCompleteness} 결과. */
+interface CompletenessReport {
+    /** database 별 대조 결과(입력 순서). */
+    readonly databases: readonly DatabaseCompleteness[];
+    /** 원격 열거 실패 목록. 하나라도 있으면 `complete` 는 false. */
+    readonly failures: readonly CompletenessFailure[];
+    /** 대조에 성공한 database 들의 원격 행 총합. */
+    readonly remoteTotal: number;
+    /** 같은 database 들의 볼트 db-row 총합. */
+    readonly localTotal: number;
+    /** 미발견·잔재·조회 실패가 모두 0. */
+    readonly complete: boolean;
+}
+interface CompletenessOptions {
+    /**
+     * 볼트에 행이 하나도 없어도 반드시 대조할 database id(설정 `notion.databases[]` ·
+     * 디스커버리 캐시 등). 통째로 미발견된 DB 를 드러내는 유일한 경로다.
+     */
+    readonly databaseIds?: readonly string[];
+}
+/**
+ * 원격 행 집합과 볼트 db-row 집합을 database 별로 대조한다.
+ *
+ * 대조 대상 = 볼트가 db-row 를 추적 중인 모든 database ∪
+ * {@link CompletenessOptions.databaseIds}. 한 database 의 열거가 실패해도 나머지는
+ * 계속 대조하고, 실패는 {@link CompletenessReport.failures} 로 비침묵 보고한다.
+ */
+declare function verifyDatabaseCompleteness(remote: CompletenessRemoteSource, local: CompletenessLocalSource, options?: CompletenessOptions): Promise<CompletenessReport>;
+/**
+ * 원격 페이지 열거 — {@link NotionClient} 가 그대로 만족한다.
+ *
+ * DB 쪽과 달리 여기서는 **일부러 pull 과 다른 열거를 쓴다**. DB 행은 열거 방법이 하나뿐이라
+ * 검증기가 다른 규칙을 쓰면 게이트가 통과해도 pull 은 놓치는 상황이 생기지만, 페이지는
+ * 열거 경로가 둘(직접 순회 · search)이고 **둘이 같은 집합을 내지 않는다**는 게 애초의
+ * 결함이다(R12-A). pull 이 어느 경로로 돌았든 독립된 두 번째 열거와 대조해야 의미가 있다.
+ */
+interface PageCompletenessRemoteSource {
+    getPagesUnderRootViaSearch(rootId: string): Promise<Array<{
+        id: string;
+    }>>;
+}
+/** {@link verifyPageCompleteness} 결과. */
+interface PageCompletenessReport {
+    /** 원격(search 열거) root 하위 페이지 수. */
+    readonly remotePages: number;
+    /** 볼트가 추적 중인 페이지 수(db-row 제외). */
+    readonly vaultPages: number;
+    /** 원격에만 있는 페이지 id — **침묵 미발견**. 비어야 정상. */
+    readonly missingIds: readonly string[];
+    /**
+     * 볼트에만 있는 페이지 id — **정보성**(판정에 쓰지 않는다).
+     *
+     * DB 행과 달리 페이지는 볼트에만 있는 게 정상일 수 있다: 아직 push 하지 않은 로컬 노트,
+     * root 페이지 자신(search 열거는 root 를 제외한다), search 색인이 아직 못 따라온 신규
+     * 페이지. 이걸 실패로 접으면 게이트가 거짓 적색을 내며 신뢰를 잃는다.
+     */
+    readonly localOnlyIds: readonly string[];
+    /** 열거 실패 사유. 있으면 `complete` 는 false(실패를 통과로 접지 않는다). */
+    readonly error?: string;
+    /** 미발견 0 이고 열거도 성공. */
+    readonly complete: boolean;
+}
+/** {@link SyncOrchestrator.verifyCompleteness} 결과 — DB 와 페이지 대조를 한 판정으로 묶는다. */
+interface VaultCompletenessReport {
+    readonly databases: CompletenessReport;
+    /** 페이지 모드에서만 채워진다. DB 모드에는 root 서브트리가 없어 `null`. */
+    readonly pages: PageCompletenessReport | null;
+    /** 두 대조가 모두 통과. */
+    readonly complete: boolean;
+}
+/**
+ * 원격 root 하위 페이지 집합과 볼트가 추적 중인 페이지 집합을 대조한다.
+ *
+ * 볼트 쪽은 `fileType !== "db-row"` 로 고른다 — 페이지형 타입을 열거하면
+ * (`file`·`folder-note`·`folder-only`) 새 타입이 생겼을 때 한쪽만 낡아 조용히 게이트를
+ * 빠져나간다. "행이 아닌 것은 전부 페이지"가 이 대조가 실제로 뜻하는 바다.
+ */
+declare function verifyPageCompleteness(remote: PageCompletenessRemoteSource, local: CompletenessLocalSource, rootPageId: string): Promise<PageCompletenessReport>;
+
+/** 이름 변경 힌트 — 지금 경로 → 마지막 동기화 때 알던 경로. */
+interface RenameHints {
+    readonly files: Readonly<Record<string, string>>;
+    readonly folders: Readonly<Record<string, string>>;
+}
+type RenameKind = "file" | "folder";
+
+interface FileInfo {
+    readonly path: string;
+    readonly content: string;
+    readonly mtime: string;
+}
+/** 변경 감지 옵션 — 옮긴 노트를 찾는 데 쓴다(S-11). */
+interface LocalScanOptions {
+    /** 플러그인이 적어 둔 이름 변경 힌트. */
+    readonly hints?: RenameHints;
+}
+/**
+ * 옮긴 것으로 짝지은 추적 노트. 상태 DB 는 아직 옛 경로(`record.obsidianPath`)를 적고 있다.
+ */
+interface LocalMoveAdoption {
+    readonly record: SyncRecord;
+    /** 파일의 지금 경로. */
+    readonly to: string;
+    /** 마지막으로 Notion 에 반영한 경로 — 앞서 입양해 둔 이동이면 그 WAL 의 옛 경로. */
+    readonly origin: string;
+}
+interface LocalScan {
+    /** 입양을 마친 것으로 보고 가른 변경 — 옮긴 노트는 새 경로의 `moved` 다. */
+    readonly changes: LocalChange[];
+    readonly adoptions: readonly LocalMoveAdoption[];
+}
 declare class ChangeDetector {
     private readonly stateDb;
     constructor(stateDb: IStateDB);
-    detectLocalChangesFast(stats: FileStatInfo[], readFile: (path: string) => Promise<string>): Promise<LocalChange[]>;
-    detectLocalChanges(currentFiles: FileInfo[]): LocalChange[];
-    private detectMoves;
+    detectLocalChangesFast(stats: FileStatInfo[], readFile: (path: string) => Promise<string>, options?: LocalScanOptions): Promise<LocalChange[]>;
+    detectLocalChanges(currentFiles: FileInfo[], options?: LocalScanOptions): LocalChange[];
+    /** 파일 크기 · 수정 시각이 지난 동기화와 같으면 내용을 읽지 않는다. */
+    scanLocalChangesFast(stats: readonly FileStatInfo[], readFile: (path: string) => Promise<string>, options?: LocalScanOptions): Promise<LocalScan>;
+    scanLocalChanges(currentFiles: readonly FileInfo[], options?: LocalScanOptions): LocalScan;
+    /** 이름을 바꿔도 파일 크기 · 수정 시각은 그대로다 — 옮긴 노트는 그것으로 건너뛰지 않는다. */
+    private movePending;
+    private assemble;
 }
 
 interface NonMdFileInfo {
@@ -1039,12 +1938,34 @@ interface VaultFS {
 }
 
 type ResolutionChoice = "local" | "remote" | "merge" | "duplicate";
+/**
+ * Notion 에서 지운 노트의 충돌인가 — 올리지 않은 로컬 편집이 남은 채 원격이 휴지통 · 보관 · 없음이다.
+ * 풀 수 있는 것은 «로컬 유지»(Notion 에 새 페이지로 다시 만든다)와 «원격 유지»(볼트에서도 지운다)
+ * 뿐이다 — 병합하거나 사본으로 남길 원격 본문이 없다.
+ */
+declare function isRemoteDeletion(conflict: Conflict): boolean;
+/** 이 충돌을 풀 수 있는 선택지 — 앱은 이것만 보여 준다. */
+declare function applicableChoices(conflict: Conflict): readonly ResolutionChoice[];
+/**
+ * 전략이 이 충돌에 고르는 것. 원격에서 지운 노트는 복제할 원격이 없어 duplicate 도 «로컬 유지» —
+ * 둘 다 잃는 것이 없다. manual 은 자동 병합인데 지운 원격과는 병합할 수 없어 던진다.
+ */
+declare function choiceForStrategy(conflict: Conflict, strategy: ConflictStrategy): ResolutionChoice;
 interface ResolutionResult {
     readonly path: string;
     readonly choice: ResolutionChoice;
     readonly success: boolean;
     readonly mergeHadConflicts?: boolean;
+    /** 풀지 못한 이유 — 일괄 해결(`resolveAllConflicts`)이 실패를 던지지 않고 싣는다. */
+    readonly error?: string;
 }
+/**
+ * 충돌을 볼트 파일과 상태 DB 에서 푼다. **Notion 에는 올리지 않는다.**
+ *
+ * 앱은 `SyncOrchestrator.resolveConflict` 를 쓴다 — 이 클래스로 푼 뒤 고른 결과를 Notion 에 올리고,
+ * 올리지 못하면 충돌로 되돌린다. 이 클래스만 부르면 지난 동기화 사본만 해결 결과로 바뀌어, 다음
+ * pull 이 바뀐 원격으로 고른 로컬 · 병합 결과를 덮는다(N-06).
+ */
 declare class ConflictResolver {
     private readonly stateDb;
     private readonly vaultFs;
@@ -1052,160 +1973,159 @@ declare class ConflictResolver {
     resolve(conflict: Conflict, choice: ResolutionChoice): Promise<ResolutionResult>;
     resolveByStrategy(conflict: Conflict, strategy: ConflictStrategy): Promise<ResolutionResult>;
     resolveAll(conflicts: Conflict[], strategy: ConflictStrategy): Promise<ResolutionResult[]>;
+    /**
+     * Notion 에서 지운 노트 — «로컬 유지» 는 추적만 놓아 파일을 새 노트로 만든다(다음 push 가 새 페이지로
+     * 올린다. 앱은 오케스트레이터가 곧바로 올린다). «원격 유지» 는 볼트에서도 지운다.
+     */
+    private resolveRemoteDeletion;
     private resolveLocal;
     private resolveRemote;
     private resolveMerge;
     private resolveDuplicate;
+    /**
+     * 충돌 미리보기 — 로컬(`-`)과 원격(`+`)의 줄 비교. 바뀐 곳과 앞뒤 세 줄을 `@@` 묶음으로 보인다.
+     *
+     * 예전에는 같은 번호의 줄끼리 견줬다 — 한쪽 앞에 한 줄만 더해도 그 뒤의 모든 줄이 바뀐 것으로 보여,
+     * 무엇이 실제로 다른지 찾을 수 없었다.
+     */
     generateDiff(conflict: Conflict): string;
 }
 
+/**
+ * 한 오케스트레이터의 작업은 한 번에 하나만 돈다(S-09).
+ *
+ * 오케스트레이터는 실행마다 상태를 쥔다 — 원격을 본 시각(N-05, `RunObservation`) · 이번 실행이 고른
+ * 새 경로(`PagePuller` 의 `claimedPaths`) · 준비하지 못한 폴더(`FolderPlacement`). 두 실행이 겹치면
+ * 뒤 실행이 앞 실행의 것을 덮는다. 앞 pull 이 원격을 본 시각이 뒤로 밀려 그 사이의 Notion 편집을 본
+ * 것으로 적고(영영 받지 않는다), 두 실행이 같은 새 경로를 골라 서로의 파일을 덮는다. 플러그인의
+ * 수동 · 자동 · 볼트 이벤트 sync 와 CLI `watch` 의 파일 변경 · 주기 sync 가 이렇게 겹쳤다.
+ *
+ * 겹친 요청은 기다리게 하지 않고 거절한다. 무엇을 할지는 부른 쪽마다 다르다 — 사용자가 누른
+ * 것은 알리고, 자동 sync 는 건너뛰고, 파일 감시는 끝난 뒤 다시 돌린다. 여기서 줄을 세우면
+ * 긴 sync(실볼트 pull 500초) 동안 주기 sync 가 쌓인다.
+ */
+/** 잠그는 작업 — 볼트 · 상태 DB · 원격을 바꾸거나 이번 실행의 기준을 정하는 것. */
+type GatedOperation = "push" | "pull" | "sync" | "status" | "fetch" | "resolve" | "discard";
+declare function operationLabel(operation: GatedOperation): string;
+declare class SyncBusyError extends Error {
+    /** 이미 도는 작업. */
+    readonly running: GatedOperation;
+    /** 거절한 작업. */
+    readonly requested: GatedOperation;
+    constructor(
+    /** 이미 도는 작업. */
+    running: GatedOperation, 
+    /** 거절한 작업. */
+    requested: GatedOperation);
+}
+
 declare class SyncOrchestrator {
     private readonly config;
     private readonly stateDb;
     private readonly notionClient;
     private readonly vaultFs;
-    private readonly changeDetector;
-    private readonly pipeline;
-    private readonly blockConverter;
-    private readonly imageHandler;
     private readonly fileHandler;
     private readonly databaseSyncer;
-    private readonly propertyMapper;
-    private readonly conflictResolver;
-    private dbSchemaLoaded;
-    private _pullImageCount;
-    private _pullFileCount;
-    private _inlineDbRefs;
-    private _childParentIds;
-    private static readonly DISCOVERY_RECURSIVE_BUDGET_MS;
+    /** DB 행 push 용 — DB 마다 스키마를 읽은 매퍼. 실행마다 비운다(S-01). */
+    private readonly rowSchemas;
+    private readonly observation;
+    private readonly placement;
+    private readonly planner;
+    private readonly detector;
+    private readonly drift;
+    private readonly discovery;
+    private readonly puller;
+    private readonly pullPlanner;
+    private readonly pusher;
+    private readonly conflictWorkflow;
+    private readonly inspector;
+    private readonly recovery;
+    private readonly gate;
     constructor(config: Config, stateDb: IStateDB, notionClient: NotionClient, vaultFs: VaultFS, customFetch?: typeof globalThis.fetch);
+    /** 도는 작업 — 없으면 null(S-09). 부른 쪽이 겹칠 요청을 미리 거를 때 쓴다. */
+    get runningOperation(): GatedOperation | null;
     push(options?: PushOptions): Promise<PushResult>;
+    private executePush;
+    /** 볼트의 노트가 마지막으로 올린 내용 그대로인가 — 읽지 못하면(지움 · 옮김) 아니다. */
+    private unchangedSincePush;
     pull(options?: PullOptions): Promise<PullResult>;
+    private executePull;
     sync(options?: SyncOptions): Promise<SyncResult>;
-    status(): Promise<StatusResult>;
+    private executeSync;
+    /**
+     * 원격까지 본다 — 이번 실행의 원격 기준을 정하므로 다른 작업과 겹치지 않는다. 원격을 훑는 데 분 단위가
+     * 걸릴 수 있어 취소를 받는다. 취소하면 {@link OperationAbortedError} 를 던진다.
+     */
+    status(options?: StatusOptions): Promise<StatusResult>;
+    private executeStatus;
+    /**
+     * 로컬만 본다 — 원격 기준을 정하지 않아 도는 작업과 겹쳐도 된다. 변경은 push 가 쓰는 판정 그대로다
+     * (옮긴 노트 · 폴더 포함). 상태 DB 는 바꾸지 않는다.
+     */
     statusLocal(): Promise<StatusResult>;
+    /**
+     * 볼트에서 노트 · 폴더의 이름을 바꿨다는 기록 — 플러그인이 볼트의 rename 이벤트로 알린다(S-11).
+     *
+     * 다음 실행이 옮긴 노트를 추적 레코드와 짝지을 때 쓴다. 이름과 내용을 함께 바꾼 노트는 이
+     * 기록 없이는 짝을 찾지 못해, 옛 페이지를 지우고 새 페이지를 만든다.
+     */
+    recordLocalRename(from: string, to: string, kind: RenameKind): void;
+    /** 볼트에서 지운 노트 · 폴더 — 그 자리를 새 경로로 적은 힌트를 버린다. */
+    recordLocalDelete(path: string): void;
+    /**
+     * 볼트 완결성 검증 — 원격에 있는 것이 볼트에 빠짐없이 있는지 대조한다(R11-B · R12-C).
+     *
+     * 기존 게이트(해시 일치·repull 바이트 동일·churn 0)는 전부 **멱등성**을 본다. 매번
+     * 같은 것을 놓치는 체계적 미발견은 그 게이트를 전부 통과한다 — 실제로 296개 DB 행이
+     * 그렇게 침묵 유실됐다. 여기서만 "빠짐없다"를 본다.
+     *
+     * 대조 대상 database id 는 이 클래스가 조립한다: 설정에 적힌 것 + 디스커버리 캐시가
+     * 아는 것 + DB 모드의 루트 DB. 캐시 표현(`discovered_dbs` 메타 키)은 `discovered-databases.ts`
+     * 한 곳이 정하고 여기서 조립한다 — 호출부(CLI·E2E)가 그 표현을 각자 다시 해석하지 않게.
+     *
+     * 페이지(R12-C)는 pull 이 쓴 경로가 아니라 **search 열거**로 대조한다. 페이지는 열거
+     * 경로가 둘이고 둘이 같은 집합을 내지 않는 게 애초의 결함이므로(R12-A), 독립된 두 번째
+     * 열거와 맞대 봐야 의미가 있다.
+     */
+    verifyCompleteness(): Promise<VaultCompletenessReport>;
     fetch(): Promise<{
         newPages: number;
         deletedPages: number;
         modifiedPages: number;
         duration: number;
     }>;
-    private buildConflictsFromRecords;
-    private get isDatabaseMode();
-    private discoverChildDatabases;
-    /**
-     * 자동 발견된 child_database 1개를 DatabaseSyncer 설정으로 변환한다.
-     * 블록 스캔/markdown 양쪽 발견 경로에서 공통으로 사용한다.
-     * - localFolder: 부모 페이지의 obsidianPath 기준으로 폴더를 잡아 원본 중첩 구조를 보존
-     *   (예: 부모 "AI Engineer (1).md" + DB "Minirecord Project" → "AI Engineer (1)/Minirecord-Project")
-     * - 제목 취득 실패 시 부모 폴더명 기반 안전 이름으로 폴백
-     */
-    private buildDiscoveredDbConfig;
-    /** 접근 불가 DB denylist 를 상태 메타에서 로드한다(하이픈 정규화). */
-    private loadInaccessibleDbIds;
-    /** linked view 컨테이너 → 원본 DB 매핑을 상태 메타에서 로드한다(nohyph → nohyph). */
-    private loadLinkedDbMap;
-    private pullDiscoveredDatabases;
-    /**
-     * pull 산출 md 의 인라인 DB placeholder(`**제목** *(Notion DB)*` + 보존 마커)를
-     * `![[<실제 .base 경로>|제목]]` 임베드로 재작성한다(F22) — folder note 본문에서
-     * DB 가 텍스트 한 줄이 아니라 실제 Bases 뷰로 보이게 하는 마지막 조각. linked view
-     * 컨테이너는 linkedMap 을 거쳐 원본 DB 의 .base 로 향한다. .base 경로는 DatabaseSyncer
-     * 가 실제 기록한 경로(baseFileInfo)가 SSOT — 폴더명과 .base 파일명은 새니타이즈 규칙이
-     * 달라(공백→하이픈 vs 공백 보존) localFolder 로 추측하면 깨진 임베드가 된다(E2E 실측
-     * 91/158건). 최종적으로 .base 실존까지 확인해, 없으면 placeholder 를 마커째 보존한다.
-     */
-    private rewriteDbPlaceholderEmbeds;
+    private executeFetch;
+    /** pull 이 쓴 노트의 Notion 링크를 볼트 링크로 푼다 — 푼 링크 수를 돌려준다. */
     private resolveNotionLinks;
-    private ensureDbSchema;
-    private pushCreate;
-    private pushUpdate;
+    /**
+     * 해소 대상 충돌 목록 — 원격 본문을 pull 과 같은 파이프라인으로 렌더해 담는다. 렌더가 첨부를 볼트에
+     * 내려받고 경로를 고르므로 다른 작업과 겹치지 않게 돌린다 — 도는 sync 와 같은 첨부 · 경로를 두고 다툰다.
+     */
+    listConflicts(): Promise<Conflict[]>;
+    /**
+     * 추적 파일의 현재 원격 본문을 pull 과 같은 변환으로 렌더한다 — 표시 전용이라 첨부를 내려받지
+     * 않는다. 추적되지 않았거나 원격 페이지가 없으면 null.
+     */
+    renderRemoteSnapshot(path: string): Promise<string | null>;
+    /** 로컬 변경 하나의 두 글 — 지난 동기화 때의 글과 지금 볼트의 글. 표시 전용이라 잠그지 않는다. */
+    localChangeDiff(change: LocalChange): Promise<ChangeDiff>;
+    /** 원격 변경 하나의 두 글 — 지난 동기화 때의 글과 Notion 의 지금 글. 표시 전용이라 잠그지 않는다. */
+    remoteChangeDiff(change: RemoteChange): Promise<ChangeDiff>;
+    /** 해소할 게 남지 않은 충돌 레코드를 `synced` 로 되돌리고, 되돌린 경로를 반환한다. */
+    clearStaleConflicts(conflicts: readonly Conflict[]): string[];
     /** 단일 충돌을 사용자가 고른 선택지(local/remote/merge/duplicate)로 해소 + Notion 전파. */
     resolveConflict(conflict: Conflict, choice: ResolutionChoice): Promise<ResolutionResult>;
     /** 단일 충돌을 전략(manual/local-first/remote-first/duplicate)으로 해소 + Notion 전파. */
     resolveConflictByStrategy(conflict: Conflict, strategy: ConflictStrategy): Promise<ResolutionResult>;
-    /** 여러 충돌을 동일 전략으로 일괄 해소 + Notion 전파. */
+    /** 여러 충돌을 동일 전략으로 일괄 해소 + Notion 전파. 하나를 올리지 못해도 나머지를 푼다. */
     resolveAllConflicts(conflicts: Conflict[], strategy: ConflictStrategy): Promise<ResolutionResult[]>;
-    /** 충돌 미리보기용 통합 diff(원본 vs 로컬 vs 원격). 해소 없이 표시 전용. */
-    generateConflictDiff(conflict: Conflict): string;
     /**
-     * 해소 결과를 Notion 으로 전파해 로컬↔원격 일관성을 봉합한다.
-     * - remote 선택: 로컬이 원격으로 갱신됐을 뿐이므로 push 불필요. notionLastEdited 만
-     *   원격 변경의 lastEdited 로 재조정 → 다음 pull 이 같은 변경을 재충돌로 보지 않음.
-     * - merge 실패(충돌 마커 잔존): 사용자가 직접 풀어야 하므로 conflict 상태 유지·push 안 함.
-     * - local / merge(성공) / duplicate: 해소된 로컬 내용을 Notion 에 재push(pushUpdate 가
-     *   변환·이미지·속성·해시·notionLastEdited 를 한 트랜잭션으로 재조정) → 무손실 수렴.
-     */
-    private propagateResolution;
-    private pushDelete;
-    private pushMove;
-    private detectRemoteChanges;
-    /**
-     * 증분 원격 변경 감지 — `since` 이후 수정된 페이지만 search 로 받아 created/modified 만
-     * 만든다. **삭제는 의도적으로 감지하지 않는다**: search API 는 in_trash/archived 페이지를
-     * 반환하지 않아(=사라진 것을 증분만으로는 구분 불가) 삭제 판정에는 전체 enumeration 이
-     * 필수다. 따라서 호출부는 `deleteSync` 가 켜진 경우 이 fast-path 를 쓰지 않고
-     * `detectRemoteChanges`(전체 스캔, 삭제 diff 포함)로 우회한다. (I10)
-     */
-    private detectRemoteChangesIncremental;
-    private isTrackedParent;
-    private pullCreate;
-    /**
-     * 페이지가 폴더(자식 페이지·자식 DB 보유)인지 신뢰성 있게 판정한다.
-     *
-     * 결함(폴더노트 본문분리)의 근본 원인은 얕은 판정이었다 — 최상위 블록 첫 페이지에서
-     * child_page 만 검사하면 callout·column·toggle 안에 중첩된 자식 페이지나 child_database 를
-     * 놓쳐 폴더노트가 file 로 오분류되고, 본문이 폴더 밖 최상위로 밀려 resolveUniqueFilePath
-     * 충돌(' (1).md')로 쪼개졌다.
-     *
-     * 1차: 발견 단계(서브트리 순회/증분)에서 전 페이지의 부모를 해소하며 만든
-     *      _childParentIds 집합으로 O(1) 판정(추가 API 호출 0, 처리 순서 무관) — 전체 pull 경로.
-     * 폴백: 집합에 없을 때만(증분 pull 의 신규 폴더 등) fetchAllChildrenDeep 로 컨테이너를
-     *       재귀 탐색해 child_page·child_database 를 직접 확인한다.
-     */
-    private pageHasChildContainers;
-    private pullUpdate;
-    private pullDelete;
-    private ensureFolderPage;
-    private resolveNotionParent;
-    private repairFolderRecords;
-    private isFolderNote;
-    private resolveParentPath;
-    private pushCreatePage;
-    private pageHasLiveChildren;
-    private pushUpdatePage;
-    private fetchPageMarkdown;
-    private collectInlineDbRefs;
-    /**
-     * 이번 라운드에 기록된 DB row md 를 읽어 본문의 인라인 DB 참조를 수집한다.
-     * row 페이지는 DatabaseSyncer 자체 파이프라인으로 변환돼 fetchPageMarkdown 의
-     * _inlineDbRefs 수집을 타지 않는다 — 디스크에 남은 보존 마커가 유일한 발견 신호다.
-     * 부모 Notion 페이지 id 는 state DB 역조회(getByPath)로 얻는다(row upsert 직후라 항상 존재).
-     */
-    private collectRowInlineRefs;
-    private resolveNotionIdWikilinks;
-    private extractParentId;
-    private resolveBlockToPageId;
-    private cleanupInterruptedSync;
-    /**
-     * I12 — 중단된 push create 작업 재개.
-     *
-     * pending_operations 에 미완료(create·push) 항목이 있으면:
-     *  - state 에 notion_page_id 가 이미 있으면 → 생성·매핑까지는 끝났고 markCompleted 직전에
-     *    중단된 것 → 완료 처리(잔여 본문/이미지는 다음 변경감지가 pushUpdate 로 마무리).
-     *  - notion_page_id 가 비어 있으면(Window A: 생성 적용됐으나 매핑 기록 전 중단) → 부모에서
-     *    제목으로 child_page 를 검색해 고아 페이지를 입양(중복 생성 차단). 없으면 자리표시
-     *    레코드를 제거(FK CASCADE 로 op 도 삭제)해 다음 push 가 새로 생성하게 한다.
-     *
-     * 한계(문서화): Notion 은 idempotency key 가 없어 "생성 요청 적용 직후 같은 호출 내 재시도"
-     * 로 인한 중복은 완전히 차단하지 못한다. 429 는 적용 전 거절이라 안전하고, 프로세스 재시작
-     * 후 재개는 본 검색-입양으로 중복을 막는다. DB 모드(부모가 database)는 child_page 검색이
-     * 불가하므로 자리표시 제거 후 재생성으로 폴백한다.
-     */
-    private recoverInterruptedPushOps;
-    /** 부모 페이지의 직속 자식 중 제목이 일치하는(보관/휴지통 제외) child_page id 를 찾는다. */
-    private findChildPageByTitle;
-    private resolveUniqueFilePath;
+     * 로컬 변경 하나를 지난 동기화 때의 글로 되돌린다 — Git 의 `restore` 와 같다. Notion 은 건드리지
+     * 않는다. 되돌릴 원본이 없는 것은 이유와 함께 거절한다.
+     */
+    discardLocalChange(path: string): Promise<void>;
+    /** 충돌 미리보기용 줄 비교(로컬 vs 원격). 해소 없이 표시 전용. */
+    generateConflictDiff(conflict: Conflict): string;
 }
 
 interface PathFilterConfig {
@@ -1237,18 +2157,48 @@ declare class NodeVaultFS implements VaultFS {
     private walkDir;
 }
 
+/**
+ * push 가 노트 임베드를 올려 만든 미디어 블록 하나 — Notion 에 저장된 파일과 노트의 임베드를
+ * 잇는다(S-05).
+ *
+ * 예전(R1)에는 올린 블록의 캡션에 임베드 대상을 그대로 적고, pull 이 그 캡션으로 임베드를
+ * 되찾았다. 그래서 Notion 에서 보는 캡션이 `assets/사진.png|300` 같은 경로 · 크기 · 파일
+ * 이름이었다. 이제 캡션에는 사람이 적은 설명만 싣고, 어느 임베드였는지는 여기 적어 둔다.
+ *
+ * 파일 id 로 잇는 이유: Notion 에서 같은 이름의 다른 파일로 바꾸면 id 가 바뀐다. 이름으로 이으면
+ * 바뀐 파일을 옛 로컬 파일로 되돌려 Notion 의 편집을 잃는다.
+ */
+interface UploadedMedia {
+    /** Notion 이 그 파일을 저장한 id(`notionFileIdOf`) — 블록 id · file_upload id 와 다르다. */
+    readonly fileId: string;
+    /** 노트에 적혀 있던 임베드 대상 그대로 — `경로|별칭`. */
+    readonly target: string;
+    /** 올린 볼트 파일(해석한 경로) — pull 이 아직 있는지 보고 되살린다. */
+    readonly localPath: string;
+    /**
+     * 올린 · 받은 파일의 전체 sha256. 볼트의 그 파일이 아직 이 바이트면 본문 push 가 다시 올리지 않고
+     * Notion 의 그 블록을 둔다(`ImageHandler.keepUploadedMedia`). 이 값을 적기 전에 적은 기록에는
+     * 없다 — 그 미디어는 한 번 더 올리고 그때 적는다.
+     */
+    readonly fileHash?: string;
+}
+
 /** 미디어(이미지/파일) 다운로드 운영 튜닝값. 미지정 시 기존 동작과 동일한 기본값 사용. */
 interface MediaOptions {
     readonly concurrency?: number;
     readonly maxRetries?: number;
     readonly retryBaseMs?: number;
     readonly maxFileSizeBytes?: number;
+    /** 다운로드 1회 시도의 시간 상한(ms). 기본 300초. 0 이하면 상한 없음(권장하지 않음). */
+    readonly downloadTimeoutMs?: number;
 }
 interface ImageDownloadResult {
     readonly originalUrl: string;
     readonly localPath: string;
     readonly hash: string;
     readonly size: number;
+    /** 받은 파일의 전체 sha256 — 받은 미디어 기록에 적어 push 가 그 파일이 그대로인지 본다. */
+    readonly fileHash?: string;
 }
 interface ImageUploadResult {
     readonly localPath: string;
@@ -1257,6 +2207,24 @@ interface ImageUploadResult {
     readonly fileHash: string;
     readonly fileSize: number;
 }
+/** {@link ImageHandler.keepUploadedMedia} 의 결과. */
+interface KeptMedia {
+    /** 보낼 본문 — 다시 올리지 않아도 되는 자리표시자를 Notion 의 그 파일로 바꿨다. */
+    readonly markdown: string;
+    /** 그대로 둔 미디어 — 본문을 보낸 뒤 올린 미디어 기록에 다시 적는다. */
+    readonly kept: readonly UploadedMedia[];
+}
+/** 제자리 교체 결과 — 어떤 임베드 대상이 처리됐는지 호출자가 알아야 중복 업로드를 막는다. */
+interface MaterializeResult {
+    readonly uploaded: ImageUploadResult[];
+    /** 실제 블록으로 바뀐 임베드 대상(원본 문자열 + 별칭 제거형 둘 다 담는다). */
+    readonly handledTargets: Set<string>;
+    /**
+     * 자리표시자를 찾아 본문을 고치려 했다 — 도중에 실패했어도 페이지가 바뀌었을 수 있다. 호출측은
+     * 보낸 본문으로 만든 지문을 버리고 다시 받는다.
+     */
+    readonly touched: boolean;
+}
 declare class ImageHandler {
     private readonly vaultFs;
     private readonly attachmentFolder;
@@ -1267,11 +2235,47 @@ declare class ImageHandler {
     private readonly maxRetries;
     private readonly retryBaseMs;
     private readonly maxFileSizeBytes;
+    private readonly downloadTimeoutMs;
     constructor(vaultFs: VaultFS, attachmentFolder?: string, notionClient?: NotionClient | undefined, customFetch?: typeof globalThis.fetch, options?: MediaOptions, stateDb?: IStateDB | undefined);
     private get fetchFn();
+    /** 상한 로직은 첨부 경로와 공유한다 — 한쪽만 빠뜨리지 않도록(utils/download-fetch). */
+    private fetchForDownload;
     downloadImage(url: string, pageTitle: string): Promise<ImageDownloadResult>;
     private fetchImage;
+    /**
+     * 캡션이 push 가 적어 둔 원본 임베드 대상인지 판정한다(R1). 맞으면 그 문자열을
+     * 그대로 돌려주고, 호출자는 사본을 내려받는 대신 `![[원본]]` 으로 되살린다.
+     *
+     * 사용자가 Notion 에서 손으로 쓴 캡션을 경로로 오인하면 깨진 위키링크가 되므로,
+     * ① 파일명이 실제 업로드된 파일명과 같고 ② 볼트에 그 파일이 실재할 때만 인정한다.
+     * 둘 중 하나라도 어긋나면 null 을 돌려 기존 다운로드 경로로 떨어진다.
+     *
+     * ②의 실재 확인은 push 와 **같은 후보 사다리**(노트 폴더 → 루트 → attachments/)를
+     * 쓴다 — 위키링크는 파일명만 적는 게 관례라 볼트 루트만 보면 노트 옆 파일을 놓친다.
+     */
+    private resolveOriginalTarget;
     private persistImage;
+    /**
+     * push 가 올린 미디어를 노트에 적혀 있던 임베드로 되돌린다 — 아무것도 내려받지 않는다(S-05).
+     *
+     * push 는 임베드 하나를 제자리 블록 하나로 올리고, Notion 이 그 파일을 저장한 id 를 임베드
+     * 대상과 함께 적어 둔다({@link rememberUploadedMedia}). 여기서는 받은 본문의 미디어 URL 에서
+     * 그 id 를 읽어 대상을 되찾는다. 캡션에 경로를 적지 않아도 되고, Notion 에서 같은 이름의 다른
+     * 파일로 바꾼 것(id 가 다르다)을 옛 로컬 파일로 되돌리지도 않는다.
+     *
+     * 적어 둔 것이 없으면 옛 push 처럼 캡션이 임베드 대상인지 본다(R1). 둘 다 아니면 그대로 두고,
+     * 뒤따르는 {@link downloadAllImages} · {@link downloadAllFiles} 가 사본을 받는다.
+     *
+     * 내려받지 않으므로 표시 전용 렌더(diff)나 이미지 다운로드를 끈 설정에서도 부른다.
+     *
+     * @param pageId 본문을 받은 페이지 — 그 페이지에 올린 것만 되찾는다
+     * @param notePath 노트 경로 — 옛 캡션의 파일을 push 와 같은 사다리로 찾는다
+     */
+    restoreUploadedMedia(markdown: string, pageId?: string, notePath?: string): Promise<string>;
+    /** 적어 둔 업로드면 되살릴 임베드 대상. 볼트에서 그 파일이 사라졌으면 null — 사본을 받는다. */
+    private knownEmbedTarget;
+    /** 미디어 URL 이 가리키는 파일 이름 — 서명 URL 은 경로 끝, 내부 참조는 `attachment:` 뒤. */
+    private uploadedNameOf;
     downloadAllImages(markdown: string, pageTitle: string, pageId?: string): Promise<{
         content: string;
         downloads: ImageDownloadResult[];
@@ -1279,13 +2283,99 @@ declare class ImageHandler {
     uploadLocalImage(localPath: string, noteFolder?: string): Promise<ImageUploadResult>;
     uploadAndAppendImages(pageId: string, images: ImageReference[], notePath?: string): Promise<ImageUploadResult[]>;
     /**
-     * 임베드 경로를 볼트 실제 파일로 해석한다(F23). Obsidian 위키링크 임베드는 노트 옆
-     * 파일을 파일명만으로 참조하는 게 관례라, 노트 폴더 → 볼트 루트 → attachments/ 순으로
-     * 시도한다. 폴백은 조용히 진행하고, 전부 실패했을 때만 마지막 오류를 던진다.
+     * 본문을 보내기 전에, 다시 올리지 않아도 되는 미디어 자리표시자를 Notion 에 이미 있는 그 파일로
+     * 바꾼다.
+     *
+     * 본문 push 는 자리표시자를 심어 본문을 통째로 바꾸고, 바꾼 뒤 자리표시자를 하나씩 올려 블록으로
+     * 바꾼다({@link materializeLocalMedia}). 그래서 글 한 줄만 고쳐도 그 페이지의 미디어를 모두 다시
+     * 올렸다 — 업로드 요청이 미디어마다 셋이고, Notion 의 블록 · 파일이 새로 바뀌었다. 받은 본문의 미디어
+     * URL 을 그대로 실어 본문을 바꾸면 Notion 은 그 블록을 그대로 둔다 — 블록 id · 파일이 같고 캡션만
+     * 실은 글로 바뀐다. 자리를 옮겨도, 서명(쿼리)을 떼도 같다(2026-10-12 실측).
+     *
+     * 둘 다 맞는 자리표시자만 바꾼다 — 나머지는 예전처럼 올린다.
+     * - 그 페이지의 미디어 기록에 같은 경로의 임베드가 있고, 받은 본문에 그 파일이 지금 있다
+     * - 볼트의 그 파일이 적어 둔 지문과 같다 — 같은 이름에 다른 내용이면 올려야 한다
+     *
+     * 기록이 없거나(이 기능 이전에 올린 미디어) 본문을 읽지 못하면 아무것도 바꾸지 않는다 — 다시 올릴
+     * 뿐 잃는 것은 없다.
+     *
+     * @param markdown 보낼 본문(Notion markdown) — 자리표시자가 줄 단독으로 있다
+     */
+    keepUploadedMedia(pageId: string, markdown: string, notePath?: string): Promise<KeptMedia>;
+    /**
+     * 자리표시자 자리에 실을 Notion 미디어 한 줄. 종류 · 캡션 · URL 을 그대로 실을 수 없거나 볼트의 파일이
+     * 올린 것과 다르면 null — 그 자리표시자는 다시 올린다.
+     */
+    private keptMediaLine;
+    /**
+     * 그대로 둔 미디어에 실을 캡션 — 임베드의 설명. 캡션 없는 파일을 받으면 올라간 이름을 별칭으로
+     * 적으므로({@link fileNameOf}), Notion 에 캡션이 없고 별칭이 그 이름이면 캡션을 비운 채 둔다 — 실으면
+     * 받은 파일마다 이름이 캡션으로 붙는다.
+     */
+    private keptCaptionOf;
+    /**
+     * push 가 심어 둔 자리표시자 quote 를 **제자리에서** 실제 image/file 블록으로 바꾼다(R1).
+     *
+     * 그 전에는 임베드 하나가 Notion 에서 두 조각으로 갈라졌다 — 본문 자리에는
+     * `> 📎 foo.png` + `%% im-nobsidian:local-image:… %%` 리터럴 마커가, 실제 이미지는
+     * 페이지 맨 끝에 따로. 실측: 볼트 175개 파일에서 마커 978건이 Notion 에 그대로
+     * 텍스트로 새고 있었고 그중 964건(98.6%)이 이 미디어 쌍이었다. 사용자가 Notion 에서
+     * 보는 화면이 깨질 뿐 아니라 이미지가 본문 흐름에서 이탈한다.
+     *
+     * 캡션에는 사람이 적은 설명만 단다({@link captionOfEmbed}). 어느 임베드였는지는 Notion 이
+     * 그 파일을 저장한 id 와 함께 적어 두고({@link rememberUploadedMedia}), pull 이 그것으로
+     * 임베드를 되찾는다(S-05). 예전에는 캡션에 임베드 대상을 그대로 적어 Notion 에 경로 · 크기 ·
+     * 파일 이름이 보였다.
+     *
+     * 볼트에서 파일을 못 찾으면 자리표시자를 그대로 둔다 — 마커가 남아야 pull 이
+     * 임베드를 복원할 수 있으므로, 반쯤 지우는 것보다 안전하다.
+     */
+    materializeLocalMedia(pageId: string, pushedMarkdown: string, notePath?: string, kept?: readonly UploadedMedia[]): Promise<MaterializeResult>;
+    /**
+     * 방금 만든 미디어 블록의 파일을 Notion 이 저장한 id. 만든 응답에 파일 URL 이 실려 오고,
+     * 없으면 블록을 한 번 조회한다. 끝내 모르면 null — 던지지 않는다(블록은 이미 제자리에 있다).
+     */
+    private storedFileIdOf;
+    /**
+     * 페이지 블록 트리를 훑어 자리표시자를 부모와 함께 모은다. 콜아웃·토글·목록 안에
+     * 들어간 임베드도 제자리 교체하려면 부모 id 가 필요하다(append 의 after_block 은
+     * 같은 부모의 자식만 기준으로 삼는다).
+     */
+    private collectPlaceholders;
+    /**
+     * 업로드분을 file_registry 에 남긴다. 노트 임베드는 여기서 페이지에 붙으므로,
+     * 이후 FileHandler.pushAllFiles 가 같은 첨부를 폴더 페이지에 standalone 으로
+     * 재업로드하는 중복을 공유 레지스트리로 차단한다.
+     */
+    private registerUploads;
+    /**
+     * 올린 미디어를 임베드와 함께 적어 둔다(S-05). 적지 못해도 push 는 깨뜨리지 않는다 — 블록은
+     * 이미 제자리에 있고, 다음 pull 이 그 파일을 알아보지 못해 사본을 받을 뿐이다.
+     */
+    private rememberUploads;
+    /**
+     * 받은 미디어를 그 페이지의 미디어 기록에 더한다 — 그 노트를 고쳐 push 할 때 Notion 의 원래 블록을
+     * 둔다({@link keepUploadedMedia}). 적지 못해도 pull 은 깨뜨리지 않는다 — 그 노트를 push 하면 예전처럼
+     * 다시 올릴 뿐이다.
+     */
+    private rememberReceived;
+    /**
+     * 임베드 경로가 가리킬 수 있는 볼트 실제 파일 후보를 우선순위대로 만든다(F23).
+     * Obsidian 위키링크 임베드는 노트 옆 파일을 파일명만으로 참조하는 게 관례라
+     * 노트 폴더 → 볼트 루트 → attachments/ 순.
+     *
+     * push(업로드)와 pull(원본 복원)이 **같은 사다리**를 봐야 왕복이 닫힌다. 예전에는
+     * pull 쪽이 볼트 루트만 확인해서, `__e2e_probe__/노트.md` 안의 `![[t-img.png]]` 는
+     * 올라갈 때는 노트 폴더에서 잘 찾아 올리고도 내려올 때는 원본을 못 찾아 사본을
+     * 새로 받았다(실측) — 왕복할 때마다 첨부가 한 벌씩 늘어난다.
+     */
+    private vaultCandidates;
+    /**
+     * 임베드 경로를 볼트 실제 파일로 해석해 읽는다(F23).
+     * 폴백은 조용히 진행하고, 전부 실패했을 때만 마지막 오류를 던진다.
      */
     private readImageFromVault;
-    private getContentTypeFromPath;
-    downloadAllFiles(markdown: string, pageTitle: string): Promise<{
+    downloadAllFiles(markdown: string, pageTitle: string, pageId?: string): Promise<{
         content: string;
         downloads: ImageDownloadResult[];
     }>;
@@ -1307,7 +2397,25 @@ declare class ImageHandler {
     private guessFileExtension;
 }
 
+/**
+ * 확장자 → MIME / Notion 블록타입 매핑의 단일 출처.
+ *
+ * 예전에는 ImageHandler 가 이미지 확장자만 담은 축소판 테이블을 따로 들고 있었다.
+ * 그 결과 노트에 박힌 `![[문서.txt]]` 같은 임베드를 올릴 때 `application/octet-stream`
+ * 으로 요청해 Notion File Upload API 가 400 으로 거절했다(실측). 업로드 경로가 둘인데
+ * 테이블이 둘이면 한쪽만 고쳐지므로 여기로 합친다.
+ */
 type NotionBlockType = "image" | "pdf" | "video" | "audio" | "file";
+
+/** 첨부 다운로드 운영 튜닝값. 미지정 시 기존 동작과 동일한 기본값 사용. */
+interface FileHandlerOptions {
+    /** 다운로드에 쓸 fetch 구현(테스트 주입용). 기본 전역 fetch. */
+    readonly fetch?: typeof globalThis.fetch;
+    /** 다운로드 1회 시도의 시간 상한(ms). 기본 300초. 0 이하면 상한 없음(권장하지 않음). */
+    readonly downloadTimeoutMs?: number;
+    /** 첨부 1건 업로드 전체의 시간 상한(ms). 기본 30분. 0 이하면 상한 없음. */
+    readonly itemTimeoutMs?: number;
+}
 interface FileUploadResult {
     readonly localPath: string;
     readonly fileUploadId: string;
@@ -1324,13 +2432,37 @@ declare class FileHandler {
     private readonly notionClient;
     private readonly stateDb;
     private readonly sema;
-    constructor(vaultFs: VaultFS, notionClient: NotionClient, stateDb: IStateDB, concurrency?: number);
+    private readonly customFetch?;
+    private readonly downloadTimeoutMs;
+    private readonly itemTimeoutMs;
+    constructor(vaultFs: VaultFS, notionClient: NotionClient, stateDb: IStateDB, concurrency?: number, options?: FileHandlerOptions);
+    private get fetchFn();
     pushFilesForFolder(folderPageId: string, folderPath: string): Promise<FileUploadResult[]>;
     /**
-     * 업로드 후보 목록 — 도구 내부 산출물(`.base`/`.notion.json`)은 제외한다.
-     * node 측 VaultFS 는 과거 `.base` 를 워커에서 빼는 식으로 우회했지만, Obsidian
-     * 어댑터는 모든 파일을 반환하므로 플러그인 push 가 사이드카를 Notion 첨부로
-     * 오염시켰다. 소비자인 여기서 일괄 차단해 구현체 간 동작을 통일한다.
+     * 첨부 1건을 폴더 페이지에 올린다 — 두 push 경로(`pushFilesForFolder` · `pushAllFiles`)의
+     * 공통 단위. 변경 없음 판정·동시성 슬롯·시간 상한·실패 격리를 모두 여기 한 곳에 둔다.
+     *
+     * 한 곳에 모은 이유는 R9a 에서 실제로 데인 적이 있어서다. 같은 다운로드 로직이
+     * image/file 핸들러에 두 벌 존재한 탓에 한쪽에만 상한이 걸린 채로 남았고, 상한 없는
+     * 쪽이 세마포어를 쥔 채 영원히 매달렸다. 여기도 같은 코드가 두 루프에 나뉘어 있었다.
+     *
+     * 상한(R9f): 업로드는 호출 1건마다 상한이 있어도(SDK 30초) 멀티파트는 파트 수만큼
+     * 호출이 늘어나는 **합성 경로**라 전체로는 여전히 무한대다. 상한을 넘긴 첨부는 경고만
+     * 남기고 나머지 첨부는 계속 올린다 — 첨부 하나가 push 전체를 멎게 하지 않는다.
+     *
+     * @returns 업로드 결과. 변경 없음(스킵)이거나 실패했으면 null.
+     */
+    private pushSingleFile;
+    /**
+     * 업로드 후보 목록 — 도구 내부 산출물(`.base`/`.notion.json`)은 아예 빼고, Notion 이 받지 않는
+     * 형식은 따로 모은다.
+     *
+     * 내부 산출물: node 측 VaultFS 는 과거 `.base` 를 워커에서 빼는 식으로 우회했지만, Obsidian
+     * 어댑터는 모든 파일을 반환하므로 플러그인 push 가 사이드카를 Notion 첨부로 오염시켰다.
+     * 소비자인 여기서 일괄 차단해 구현체 간 동작을 통일한다.
+     *
+     * 받지 않는 형식(S-14): 올리면 업로드를 만들 때 400 으로 거절된다. 등록되지 않으니 push 할
+     * 때마다 같은 요청을 다시 보내 같은 이유로 실패했다(실볼트 `.ipynb` 22개).
      */
     private listUploadableFiles;
     pushAllFiles(): Promise<FileUploadResult[]>;
@@ -1355,19 +2487,120 @@ declare class ConversionPipeline {
     convertToMarkdown(content: string, context: ConversionContext, metadata?: ProcessorMetadata): string;
 }
 
+interface DbBaseFile {
+    readonly basePath: string;
+    readonly title: string;
+}
+/**
+ * DB 마다 실제로 기록한 `.base` 경로와 DB 제목 — 인라인 DB placeholder 를 `.base` 임베드로 바꿀 때
+ * 쓴다(F22). 폴더명(하이픈 새니타이즈)과 `.base` 파일명(sanitizeFileName: 공백 · 점 보존)은 규칙이
+ * 달라, 폴더로 추측한 경로는 깨진 임베드가 된다(E2E 실측 91/158건).
+ *
+ * 예전에는 이번 실행이 기록한 것만 메모리에 두었다 — pull 마다 모든 DB 의 `.base` 를 다시 썼기
+ * 때문이다. 이제는 바뀐 DB 만 조회하므로(ADR-027) 이번에 조회하지 않은 DB 의 것도 알아야 한다. 그래서
+ * 상태 DB 에 남긴다. 값이 바뀔 때만 쓴다 — 전체 대조는 DB 마다 한 번씩 부른다.
+ */
+declare class DbBaseFiles {
+    private readonly stateDb;
+    private entries;
+    constructor(stateDb: Pick<IStateDB, "getMeta" | "setMeta">);
+    get(databaseId: string): DbBaseFile | undefined;
+    set(databaseId: string, info: DbBaseFile): void;
+    /** 상태 메타에서 한 번 읽는다. 없거나 깨졌으면 비어 있다 — 이번 실행이 기록하는 것부터 다시 쌓는다. */
+    private load;
+}
+
+/**
+ * 원격을 얼마나 훑을지 — 전체 대조인가, 바뀐 것만인가 (ADR-027).
+ *
+ * 전체 대조는 루트 아래 페이지를 모두 순회하고 동기화하는 DB 를 모두 조회한다. 원격에서 지운 것 ·
+ * 범위 밖으로 옮긴 것은 이것으로만 보인다 — search 는 휴지통을 돌려주지 않는다. 대신 비싸다: 실볼트
+ * (발견 DB 166개)에서 원격이 그대로인데도 재pull 이 523.5초 걸렸다(실측 2026-09-28). 예전에는
+ * `deleteSync` 가 켜져 있으면 pull · 상태 확인마다 전체 대조를 했고, 플러그인은 늘 켠다.
+ *
+ * 그래서 전체 대조는 주기(`sync.fullReconcileInterval`)마다만 하고, 그 사이에는 지난 pull 뒤에 바뀐
+ * 페이지 · 행 · DB 스키마만 search 로 찾아 그 DB 만 조회한다. 원격 삭제는 다음 전체 대조가 반영한다.
+ */
+
+/**
+ * 이번 pull 이 조회할 DB. `all` — 전체 대조. `changed` — 바뀐 것이 보인 DB 만(id 는
+ * {@link compactNotionId}). 새로 발견한 DB 는 어느 쪽이든 조회한다 — 받은 적이 없다.
+ */
+type DatabaseSelection = {
+    readonly kind: "all";
+} | {
+    readonly kind: "changed";
+    readonly ids: ReadonlySet<string>;
+};
+/**
+ * DB 마다 이번 pull 이 어떻게 끝났나 — 다음 pull 이 바뀐 것이 없어도 다시 조회할 DB
+ * ({@link PENDING_DATABASES_META_KEY})를 가른다.
+ *
+ * 조회하다 실패했거나 · 받지 못한 행이 있거나 · 취소로 닿지 못한 DB 는 대기로 남는다. 받았거나 · 이제
+ * 없어서 뺀 DB 는 대기에서 빠진다. 이번에 조회하지 않은 DB 의 대기는 그대로 남는다.
+ */
+declare class DatabasePullLedger {
+    private readonly selection;
+    private readonly pending;
+    private readonly settled;
+    private readonly unfinished;
+    private skippedCount;
+    /** 이제 동기화하는 DB — 알면 대기를 이것으로 좁힌다. */
+    private syncing;
+    constructor(selection: DatabaseSelection, pending: ReadonlySet<string>);
+    /** 이 DB 를 조회하나 — 새로 발견한 DB 는 부른 쪽이 따로 조회한다(받은 적이 없다). */
+    selects(databaseId: string): boolean;
+    /** 바뀐 것이 보이지 않아 조회하지 않았다. */
+    skip(): void;
+    /** 받았거나 · 이제 없어서 뺐다 — 다시 조회할 것이 없다. */
+    settle(databaseId: string): void;
+    /** 조회하다 실패했거나 · 받지 못한 행이 있거나 · 취소로 닿지 못했다 — 다음 pull 이 다시 조회한다. */
+    retry(databaseId: string): void;
+    get skipped(): number;
+    /**
+     * 이제 동기화하는 DB 를 알린다 — 대기를 이것으로 좁힌다. 설정에서 뺐거나 접근 불가로 뺀 DB 를 영영
+     * 들고 있지 않는다. 알리지 않으면(발견이 멈춤 등) 좁히지 않는다 — 모르는 것을 버리지 않는다.
+     */
+    keepOnly(databaseIds: Iterable<string>): void;
+    /** 다음 pull 의 대기 — 지난 대기에서 받은 것을 빼고 이번에 받지 못한 것을 더한다. */
+    nextPending(): Set<string>;
+}
+
+/** 한 번의 동기화가 원격을 보는 기준 — 판정 · 기록에 함께 쓴다. */
+interface ObservationContext {
+    /**
+     * 이번 동기화가 시작한 시각. 원격을 «본» 시각으로 적는다 — 실제로 본 시각보다 이르거나 같아서
+     * 가라앉았다고 서둘러 보지 않는다. 동기화 밖이면 null(가라앉았다고 보지 않는다).
+     */
+    readonly seenAt: string | null;
+    /** 이 토큰의 봇 id. 받지 못했으면 null — 봇 규칙 없이 가른다. */
+    readonly botUserId: string | null;
+}
+
 interface DatabaseSyncResult {
     created: number;
     updated: number;
-    /** Pull 시 로컬·리모트 동시 수정으로 발생한 충돌 (push 는 항상 빈 배열). */
+    /**
+     * Notion 에서 지워져 볼트에서도 지운 행 수(deleteSync). 행은 DB 조회로만 보여, 행의 삭제는 전체
+     * 대조가 아니라 여기서 가른다(S-12).
+     */
+    deleted: number;
+    /** Pull 시 로컬·리모트 동시 수정으로 발생한 충돌. */
     conflicts: Conflict[];
     failed: FailedOperation[];
     /**
      * 이번 pull 에서 실제로 디스크에 기록한 db-row 파일 경로(SSOT).
      * 오케스트레이터의 링크 해소(resolveNotionLinks) 대상은 반드시 이 목록으로 정한다 —
      * 과거의 `getByStatus("synced").slice(-N)` 휴리스틱은 ORDER BY 가 없어 증분 pull 에서
-     * 엉뚱한 행을 골라 정작 바뀐 행의 relation UUID 를 영영 해소하지 못했다(M3). push 경로는 항상 빈 배열.
+     * 엉뚱한 행을 골라 정작 바뀐 행의 relation UUID 를 영영 해소하지 못했다(M3).
      */
     writtenPaths: string[];
+    /**
+     * R13: 볼트에서 사라졌기에 되살린 행 수. `updated` 와 섞지 않는다 — 리모트는 그대로이고
+     * 바뀐 것은 로컬의 부재이므로, 합쳐 세면 dry-run 과 멱등성 게이트(churn)가 "원격이
+     * 바뀌었다"고 거짓말한다. 페이지 경로가 이미 같은 이유로 `restored` 를 분리해 보고한다.
+     */
+    restored: number;
     /**
      * F25: 이 config 가 linked view 컨테이너로 판정된 경우 data source 원본 database id.
      * 행 처리는 원본 config 에 양보하고 건너뛰었으므로, 호출처(디스커버리 캐시)는 이 config
@@ -1375,6 +2608,22 @@ interface DatabaseSyncResult {
      */
     linkedOriginalDbId?: string;
 }
+/** dry-run 이 센 행 하나 — 경로와 할 일. `restore` 는 볼트에서 사라진 행을 되살리는 것이다. */
+interface PlannedRow {
+    readonly pageId: string;
+    readonly path: string;
+    readonly operation: "create" | "update" | "delete";
+    readonly restore?: boolean;
+}
+/**
+ * 행을 받는 진행 — 진행 표시가 페이지와 행을 한 목록 · 한 수로 보이게 한다. 행은 DB 를 조회해야 몇
+ * 개인지 알아, 받기 전에 이 DB 에서 받을 행 수를 `planned` 로 알리고 행 하나를 마칠 때마다 `done` 을
+ * 부른다. 지운 행은 조회에 없어 미리 셀 수 없다 — 지울 때 `planned(1)` 뒤에 `done` 을 부른다.
+ */
+interface RowProgress {
+    planned(count: number): void;
+    done(item: ProgressItem): void;
+}
 declare class DatabaseSyncer {
     private readonly config;
     private readonly stateDb;
@@ -1382,23 +2631,33 @@ declare class DatabaseSyncer {
     private readonly vaultFs;
     private readonly pipeline;
     private readonly imageHandler;
+    /**
+     * 이번 동기화가 원격을 보는 기준(N-05) — 오케스트레이터가 실행마다 정한다. 따로 쓰면(시험)
+     * 아무것도 가라앉았다고 보지 않는다 — 수정 시각이 같은 행도 받아서 견준다.
+     */
+    private readonly observation;
     private readonly propertyMapper;
     private readonly baseFileGenerator;
     private readonly sidecarGenerator;
     /**
-     * 이번 프로세스가 실제로 기록한 .base 경로/DB 제목 (databaseId nohyph → info).
-     * placeholder 임베드 재작성(F22)의 SSOT — 폴더명(하이픈 새니타이즈)과 .base 파일명
-     * (sanitizeFileName: 공백·점 보존)은 규칙이 달라 localFolder 로 추측한 경로는 깨진
-     * 임베드가 된다. generateBaseFile 은 매 pull 모든 DB 에 대해 실행되므로 pull 종료
-     * 시점에는 성공한 DB 전체가 채워져 있다.
+     * 실제로 기록한 .base 경로/DB 제목 — placeholder 임베드 재작성(F22)의 SSOT. 이번 pull 이 조회하지
+     * 않은 DB 의 것도 남아 있다({@link DbBaseFiles}).
      */
-    readonly baseFileInfo: Map<string, {
-        basePath: string;
-        title: string;
-    }>;
-    constructor(config: Config, stateDb: IStateDB, notionClient: NotionClient, vaultFs: VaultFS, pipeline: ConversionPipeline, imageHandler: ImageHandler);
-    pullAll(): Promise<DatabaseSyncResult>;
-    pushAll(): Promise<DatabaseSyncResult>;
+    readonly baseFileInfo: DbBaseFiles;
+    constructor(config: Config, stateDb: IStateDB, notionClient: NotionClient, vaultFs: VaultFS, pipeline: ConversionPipeline, imageHandler: ImageHandler, 
+    /**
+     * 이번 동기화가 원격을 보는 기준(N-05) — 오케스트레이터가 실행마다 정한다. 따로 쓰면(시험)
+     * 아무것도 가라앉았다고 보지 않는다 — 수정 시각이 같은 행도 받아서 견준다.
+     */
+    observation?: () => ObservationContext);
+    pullAll(opts?: {
+        readonly paths?: readonly string[];
+        readonly progress?: RowProgress;
+        /** 조회할 DB 와 DB 마다의 결과(ADR-027). 없으면 모든 DB 를 조회한다. */
+        readonly ledger?: DatabasePullLedger;
+        /** 취소하면 다음 DB 를 조회하지 않는다 — 닿지 못한 DB 는 다음 pull 이 조회한다. */
+        readonly signal?: AbortLike;
+    }): Promise<DatabaseSyncResult>;
     pullDatabase(dbConfig: DatabaseSyncConfig, opts?: {
         /**
          * F25: database id(하이픈 유무 무관) → 그 DB 행이 사는 로컬 폴더. 디스커버리 캐시가
@@ -1406,8 +2665,100 @@ declare class DatabaseSyncer {
          * 경우에만 행 소유를 양보한다 — 원본이 미발견이면 이 컨테이너가 유일한 접근 통로다.
          */
         resolveDbFolder?: (databaseId: string) => string | null;
+        /**
+         * 이 범위의 행만 받고 지운다(`pull --path` · 변경 패널의 항목별 받기). 없으면 모든 행.
+         * 새 행은 DB 폴더 전체가 범위일 때만 만든다 — 받기 전에는 어느 경로에 쓸지 모른다.
+         */
+        paths?: readonly string[];
+        /** 받은 행 · 지운 행을 하나씩 알린다. 예전에는 pull 진행 표시에 행이 하나도 보이지 않았다. */
+        progress?: RowProgress;
     }): Promise<DatabaseSyncResult>;
+    /**
+     * 받을 행을 세기만 한다(dry-run) — 볼트 · 상태 DB · Notion 을 바꾸지 않는다. 조회 · 범위 · 받을
+     * 행 판정 · 삭제 확인은 {@link pullDatabase} 와 같다.
+     *
+     * 행 본문은 읽지 않는다. 그래서 같은 분 안의 편집(«확인 안 됨»)은 고침으로 세고, 받아 보고 같으면
+     * 쓰지 않을 행 · local-first 로 지킬 행 · 충돌로 남길 행도 고침으로 센다. 새 행의 경로는 pull 과 같은
+     * 차례(ID 순)로 고른다 — 이번에 만들 행끼리 이름이 겹치면 뒤 차례에 id 가 붙는다.
+     */
+    planDatabase(dbConfig: DatabaseSyncConfig, opts?: {
+        resolveDbFolder?: (databaseId: string) => string | null;
+        paths?: readonly string[];
+    }): Promise<PlannedRow[]>;
+    /**
+     * 이 DB 에서 볼 행을 조회한다. 범위(`paths`)가 이 DB 폴더에 닿지 않으면 조회하지 않는다 — 예전에는
+     * 범위와 상관없이 모든 행을 만들고 고쳤다.
+     *
+     * F25: 행 parent 로 data source 의 원본 database 를 검증한다(추가 API 0회). 신 모델에선
+     * linked view 컨테이너도 data_sources 가 채워져 retrieve 만으론 원본과 구분되지 않아
+     * 캐시에 오등록될 수 있는데, 그대로 두면 같은 행 집합을 여러 config 가 각자 자기 폴더로
+     * 릴레이 재배치해 원격 무변경에도 매 pull 재작성이 쌓인다(실측 66건/pull, 행당 최대 4중).
+     * 컨테이너로 판정되면 행은 원본에 양보하고 .base 만 원본 폴더 필터로 재지향해
+     * "같은 데이터의 다른 뷰"라는 Notion 의미를 보존한다.
+     *
+     * DB 는 한 번만 받는다(`meta`) — 행 조회 · 스키마 · `.base` 제목이 이것을 같이 읽는다. 예전에는 같은 DB 를
+     * 세 번 넘게 다시 받아 DB 하나에 요청 6~8회가 들었다(ADR-027).
+     */
+    private queryRows;
+    /**
+     * 조회한 행 하나에 할 일 — 건너뜀 · 되살림 · 받음. 범위가 행 몇 개면 그 행만 받고 새 행은
+     * 만들지 않는다(어느 경로에 쓸지 받기 전에는 모른다).
+     *
+     * 리모트가 지난번에 본 그대로면 건너뜀. 수정 시각이 같아도 같은 분 안의 편집일 수 있으면
+     * («확인 안 됨», N-05) 받아서 견준다 — 같으면 파일을 쓰지 않는다. 단 두 가지 예외가 있다.
+     *  · 레코드 경로가 현재 DB 폴더 직속이 아니면(F24 동명 DB 폴더 분리 후 옛 공유 폴더 잔류)
+     *    원격 무변경이어도 재처리해 현 폴더로 재배치한다.
+     *  · 로컬 파일이 사라졌으면 되살린다(R13). 이 확인이 없으면 pullDatabasePage 안의 복원
+     *    판정(localExists → resolvePullConflict)에 영영 도달하지 못해 지운 행이 조용히 영구
+     *    소실된다. 페이지 경로는 R0 으로 이미 마감한 계약인데 행 경로만 빠져 있었다 —
+     *    오케스트레이터의 detectMissingLocalFiles 가 "행은 여기서 이미 같은 판정을 거친다"는
+     *    (틀린) 전제로 db-row 를 제외해 두었기에 양쪽 어디에도 복원 경로가 없는 상태였다.
+     *    deleteSync 가 켜져 있으면 되살리지 않는다 — 지운 것은 Notion 에서도 지우라는 뜻이고, sync 는
+     *    pull 을 먼저 돌려 되살리면 뒤이은 push 가 지울 것을 잃는다(detectMissingLocalFiles 와 같다).
+     *  · 예전 버전이 적은 날짜 모양이 남은 행은 그 줄만 새 모양으로 고쳐 쓴다({@link outdatedDateForm},
+     *    F-08).
+     */
+    private rowAction;
+    /**
+     * 원격이 그대로인 행이지만 예전 버전이 적은 날짜 모양(`…Z` · `…+09:00` · `{start, end}`)이 남아 새
+     * 모양으로 고쳐 쓸 행인가(F-08, {@link PropertyMapper.outdatedDateKeys}). 고쳐 쓰면 사본도 새 모양이
+     * 되어 다음 pull 은 건너뛴다.
+     *
+     * 지난 동기화 뒤 로컬을 고친 행은 고르지 않는다 — 로컬 편집을 지키느라 쓰지 않으니 pull 마다 고르기만
+     * 한다. 그 편집을 올린 뒤의 pull 이 고른다. 로컬 파일을 읽지 못하면 고르지 않는다.
+     */
+    private outdatedDateForm;
+    /**
+     * 예전 버전이 적은 날짜 모양이 남은 행에서 그 키들만 새 모양으로 고쳐 쓴다(F-08) — 원격이 그대로라 본문 ·
+     * 첨부는 다시 받지 않는다. 본문은 한 글자도 바꾸지 않고, 다른 키의 줄은 그대로 둔다(키 단위로 나눠 읽을
+     * 수 없는 frontmatter 는 값만 지킨다 — {@link mergeRowFrontmatter}).
+     *
+     * 예전에는 행을 통째로 다시 받았다. 행마다 본문을 읽어 요청이 늘고, 다시 그릴 때마다 달라지는 본문(빈
+     * 블록 · 첨부 이름)까지 바뀌었다 — 실볼트 사본에서 다시 받은 149행 중 99행.
+     *
+     * 고른 뒤 로컬을 고쳤으면 쓰지 않는다(`skipped`) — 이어지는 push 가 올린다.
+     */
+    private rewriteDateForms;
+    /** 이 DB 의 추적 행 가운데 이번 조회에 없던 것 — 지워졌는지는 아직 모른다. */
+    private unlistedRows;
+    /**
+     * 조회에 없던 이 DB 의 추적 행 가운데 Notion 에서 정말 지워진 것만 볼트에서 지운다(deleteSync, S-12).
+     *
+     * 행은 DB 조회로만 보인다 — 전체 대조(페이지 순회)는 행을 보지 못해 행의 삭제는 여기서 가른다.
+     * 조회에 없다는 것만으로 지우지 않고 행마다 원격에 묻는다({@link remotePresence}): 살아 있는 행은
+     * 다른 DB 로 옮겨졌을 수 있다(그 DB 의 pull 이 옮겨 받는다). 묻지 못한 행은 이번에는 둔다 — 다음
+     * pull 이 다시 묻는다.
+     *
+     * 조회 필터(`pullFilter`)가 있으면 가르지 않는다 — 조회에 없는 행이 필터 밖인지 지워진 것인지
+     * 모르고, 필터 밖으로 나간 행을 매번 물으면 요청이 끝없이 는다.
+     *
+     * 올리지 않은 로컬 편집이 있는 행은 페이지와 같은 규칙을 따른다({@link applyRemoteDeletion}) —
+     * 지우지 않고 충돌로 남기거나 파일을 둔다.
+     */
+    private pullDeletedRows;
     private pullDatabaseViews;
+    /** 행들 가운데 한 번이라도 기간인 날짜 속성 → 그 짝 키. */
+    private rangeEndsOf;
     private generateBaseFile;
     /**
      * DB 제목이 바뀌면 `.base`/`.notion.json` 파일명(safeName)이 바뀌어 옛 이름의 산출물이
@@ -1430,107 +2781,58 @@ declare class DatabaseSyncer {
      * (extractValue 는 URL 만 남긴다). 사용자가 넣은 진짜 외부 URL 은 그대로 둔다.
      */
     private localizeFileProperties;
+    /**
+     * 행 하나를 pull 이 쓰는 모양 그대로 렌더한다 — 파일은 쓰지 않는다.
+     *
+     * pull(pullDatabasePage)과 충돌 비교 · 원격 선택 해소 · 원격 미리보기(오케스트레이터의
+     * renderRemotePage)가 같은 렌더를 봐야 한다. 행을 페이지처럼 렌더하면 커버 · 아이콘 ·
+     * 첨부 속성이 빠지고, 본문 첫머리의 옛 속성 블록 값이 실제 속성을 덮는다(S-02).
+     *
+     * 본문을 읽지 못하면 던진다 — 행은 실패로 남고 레코드가 그대로라 다음 pull 이 다시
+     * 받는다. 예전에는 빈 본문으로 넘어가, 로컬이 그대로인 행은 본문이 지워진 채 «동기화
+     * 완료» 로 기록됐다(S-10). 읽지 못한 것은 비어 있는 것이 아니다.
+     *
+     * @param options.downloadMedia false 면 첨부를 내려받지 않는다(표시 전용). 비교를 보려다
+     *   볼트에 파일이 생기면 안 된다 — 그 대가로 아직 내려받지 않은 첨부는 원격 URL 로 남는다.
+     * @param options.localPath 로컬 노트가 지금 있는 자리 — 코드 펜스 표기를 되살리는 근거(S-20).
+     *   다른 폴더로 옮기기 전이면 옛 경로다. 기본은 `filePath`.
+     */
+    renderRow(page: PageObjectResponse, filePath: string, options?: {
+        downloadMedia?: boolean;
+        localPath?: string;
+    }): Promise<{
+        content: string;
+        title: string;
+        properties: Record<string, unknown>;
+        /** 받은 원격 본문의 지문(`remoteBodyFingerprint`). */
+        bodyFingerprint: string;
+    }>;
+    /**
+     * 행의 본문 밖이 지난 동기화 사본 그대로인가(N-05) — 제목과 보낼 수 있는 속성, 그리고
+     * {@link renderRow} 로 받는 행이면 아이콘 · 커버. push 는 원격을 덮어써도 되는지, pull 은 받을
+     * 것이 있는지를 이 규칙으로 가른다. 읽기 전용 속성(수식 · 롤업 · 수정 시각)은 보지 않는다 —
+     * 로컬에서 고칠 수 없고 push 가 보내지 않는다.
+     *
+     * @param mapper 그 행의 DB 스키마를 읽은 매퍼.
+     * @param base 지난 동기화 시점의 frontmatter.
+     * @param path 지난 동기화 시점의 경로 — 파일 이름을 따르던 제목을 가른다.
+     * @param decorated 아이콘 · 커버도 견주나 — {@link renderRow} 로 받는 행만 그것을 노트에 적는다.
+     */
+    rowOutsideBodyUnchanged(mapper: PropertyMapper, page: PageObjectResponse, base: Readonly<Record<string, unknown>>, path: string, decorated: boolean): boolean;
+    /**
+     * 원격 행의 아이콘 · 커버가 `frontmatter` 에 적힌 그대로인가 — {@link renderRow} 가 적는 모양으로
+     * 견준다(N-05). Notion 에 올린 파일은 읽을 때마다 주소가 바뀌고(서명) 커버는 볼트로 내려받아
+     * 적으므로, 있는지만 견준다.
+     */
+    private decorationsUnchanged;
+    /** 레코드가 지난번에 본 원격 행과 지금 행을 견준다 — 이번 동기화의 기준으로(N-05). */
+    private remoteVerdict;
+    /**
+     * 행 경로 후보의 주인 — 상태 DB 의 레코드, 없으면 볼트에 이미 있는 파일(주인 모름). 추적하지 않는 로컬 파일
+     * (아직 push 하지 않은 노트)을 새 행이 덮어쓰면 그 글이 사라졌다. 일반 페이지 받기(`claimFilePath`)처럼 피한다.
+     */
+    private rowPathOwners;
     private pullDatabasePage;
-    private pushDatabase;
-    /**
-     * rename 감지를 위한 고아 레코드 인덱스(내용 해시 → 레코드)를 만든다.
-     * 고아 = 해당 DB 소속 db-row 레코드 중 로컬 파일이 더 이상 존재하지 않는(livePaths 에 없는) 것.
-     * 같은 해시가 여러 고아에 걸리면 첫 항목을 유지한다(희박한 케이스).
-     */
-    private buildOrphanHashIndex;
-}
-
-declare class BlockConverter {
-    private n2m;
-    private client;
-    initNotionToMd(client: Client): void;
-    private registerCustomTransformers;
-    /**
-     * `numbered_list_item` 을 `1.` 마크다운으로 내보내 **번호 목록 타입을 보존**한다(I2 블록 라운드트립).
-     *
-     * notion-to-md 기본 렌더는 `md.bullet(text, block.numbered_list_item.number)` 를 쓰는데
-     * Notion API 는 list item 에 `.number` 를 채워주지 않아 `undefined` → 불릿(`- `)으로 **강등**된다.
-     * 그러면 블록 폴백 경로(notionBlocksToMarkdown)로 pull 한 뒤 다시 push 하면 numbered_list_item 이
-     * bulleted_list_item 으로 **타입 유실**된다(기본 markdown-api 경로는 영향 없음).
-     *
-     * 항상 `1.` 로 내보내면 마크다운이 시각적으로 자동 재번호하므로 표시는 동일하고, martian 이 다시
-     * numbered_list_item 으로 파싱해 타입이 보존된다. 커스텀 트랜스포머 등록은 notion-to-md 의 기본
-     * 자식 처리를 끄므로(라이브러리 설계), 자식은 toggle/callout 과 동일하게 직접 fetch·들여쓰기한다.
-     */
-    private registerNumberedListTransformer;
-    private registerToggleTransformer;
-    private registerToggleHeadingTransformers;
-    private registerColumnTransformer;
-    private registerSyncedBlockTransformer;
-    private registerBookmarkTransformer;
-    private registerVideoTransformer;
-    private registerAudioTransformer;
-    private registerFileTransformer;
-    private registerChildPageTransformer;
-    private registerChildDatabaseTransformer;
-    private registerLinkToPageTransformer;
-    private registerTocTransformer;
-    private registerBreadcrumbTransformer;
-    private registerLinkPreviewTransformer;
-    private registerPdfTransformer;
-    private registerEmbedTransformer;
-    private registerCalloutTransformer;
-    markdownToNotionBlocks(markdown: string): unknown[];
-    private toggleContents;
-    private columnContents;
-    private toggleCounter;
-    private columnCounter;
-    private preProcessMarkdown;
-    /**
-     * compact underline/color 보존마커를 평문으로 강등 — block(martian) 폴백 경로 전용.
-     *
-     * 무손실 underline/color 복원은 기본 경로인 Markdown API({@link obsidianToNotionEnhanced})가
-     * 전담한다. martian 은 이 서식을 표현할 수 없으므로, Markdown API 가 실패해 이 폴백을 탈 때는
-     * 마커 텍스트가 본문에 리터럴로 새지 않도록 텍스트만 남기고 마커를 제거한다(서식 degrade).
-     */
-    private stripInlineAnnotationMarkers;
-    private replaceDividers;
-    private extractToggleBlocks;
-    private extractColumnBlocks;
-    private postProcessBlocks;
-    private convertTogglePlaceholder;
-    private convertColumnPlaceholder;
-    private convertDividerPlaceholder;
-    /**
-     * 단일 라인 보존 마커(목차·breadcrumb)를 원래 블록으로 복원한다.
-     * pull 시 마크다운 표현이 없는 블록을 `%%im-nobsidian:toc%%` /
-     * `%%im-nobsidian:breadcrumb%%` 마커 문단으로 남겨두므로, push 시 이 문단을
-     * 감지해 table_of_contents / breadcrumb 블록으로 되돌린다. 그러지 않으면
-     * 마커 텍스트가 일반 문단으로 Notion 에 기록되는 잠재 손실이 된다.
-     */
-    private convertSingleLineMarker;
-    private convertImageToVideoOrEmbed;
-    /**
-     * `@tryfabric/martian` 의 blockquote 표현을 **평탄화**한다(I2/I3 무손실 push).
-     *
-     * martian 의 parseBlockquote 는 `notion.blockquote([], children)` 로 본문을 quote 의
-     * **자식 paragraph** 로 내려보내고 quote.rich_text 를 비운다(라이브러리 설계). 그 결과
-     * `> 인용문` 을 push 하면 Notion 에 "빈 인용 줄 + 들여쓴 자식 문단"이 만들어지고, 다시
-     * pull 하면 `> `(빈 줄) 아래에 자식 문단이 매달려 **원문과 구조가 갈라진다**(라운드트립 손실).
-     * 또한 quote.rich_text[0] 이 항상 비어 callout 이모지 감지({@link convertQuoteToCallout})도
-     * 무력화됐다.
-     *
-     * 선두의 연속된 paragraph 자식을 quote.rich_text 로 끌어올리고(문단 사이는 줄바꿈 rich_text
-     * 로 연결 — Notion 네이티브 멀티라인 인용 표현), paragraph 가 아닌 자식(중첩 리스트 등)은
-     * children 으로 남겨 구조를 보존한다. 이미 rich_text 에 본문이 있거나 끌어올릴 paragraph 가
-     * 없으면 원본을 그대로 반환한다(안전 no-op).
-     */
-    private flattenMartianBlockquote;
-    private convertQuoteToCallout;
-    notionBlocksToMarkdown(pageId: string): Promise<string>;
-    /**
-     * **in-memory** 블록 배열을 마크다운으로 변환한다(페이지 fetch 없음). notion-to-md 의
-     * blocksToMarkdown 을 직접 호출하므로, `has_children:false` 인 평면 블록은 Notion 클라이언트를
-     * 전혀 건드리지 않는다 → 고정 픽스처로 **오프라인 결정론** 블록 라운드트립(I2)을 잠글 수 있는
-     * 정식 테스트 시임. children 이 있는 블록(table 행·callout 자식 등)은 클라이언트를 호출하므로
-     * 호출 측이 평면 블록만 넣어야 오프라인이 보장된다.
-     */
-    notionBlockArrayToMarkdown(blocks: Array<Record<string, unknown>>): Promise<string>;
 }
 
 declare class FrontmatterExtractor implements Processor {
@@ -1560,6 +2862,28 @@ declare class InlineDBParser implements Processor {
     process(input: ProcessorInput): ProcessorOutput;
 }
 
+/**
+ * 블록 수식(`$$…$$`)의 두 `$$` 를 저마다 제 줄에 세운다 — Notion 은 `$$` 가 줄에 혼자 있을 때만 블록
+ * 수식으로 읽는다. 한 줄로 쓴 `$$ x^2 $$` · 식이 `$$` 줄에 붙은 `$$ a` … `b $$` 는 빈 인라인 수식과
+ * 글이 된다(실측).
+ *
+ * 콜아웃 · 목록 안의 수식은 새 줄에도 줄머리(`> ` · 들여쓰기)를 단다. 예전에는 닫는 `$$` 를 줄머리
+ * 없이 세워 콜아웃 밖으로 꺼냈고, Notion 은 그 `$$` 부터 뒤 문단을 수식으로 삼켰다(실측).
+ * 글 사이의 `$$x$$` 는 둔다 — Notion 은 인라인 수식으로 읽는데, 줄을 가르면 빈 수식과 글이 된다.
+ *
+ * 코드 펜스 · 인라인 코드 안의 `$` 는 코드다. 셸의 `$$`(PID) · `$HOME` 을 수식으로 보면 Notion 의
+ * 코드가 바뀌고, 코드 속 `$$` 가 코드 밖 수식의 `$$` 와 짝지어져 그 사이 본문까지 옮겨졌다(S-21).
+ *
+ * 블록 수식으로 서지 못하는 `$$` 는 Notion 이 빈 인라인 수식으로 읽는다(2026-10-21 실측) — 짝이 없는 `$$` 는
+ * Obsidian 이 글로 그리는데 Notion 에는 빈 수식 상자가 생겼다. 그래서 줄 안에서 짝이 없는 `$$` 는 `\$\$`(두 쪽 모두
+ * 글 `$$`)로, 글과 한 줄인 `$$ x $$` 는 안쪽 공백을 떼어 `$$x$$`(Notion 의 인라인 수식)로 보낸다
+ * ({@link settleLineDollars}). 제 줄의 `$$` 는 블록 수식의 경계라 둔다.
+ *
+ * 인라인 수식(`$…$`)의 안쪽은 건드리지 않는다. 예전에는 안쪽 공백을 잘라 `$ x $` 가 수식이 되고
+ * `$5 and $10` 이 `$5 and$10` 으로 바뀌었다. Obsidian 과 Notion 은 여는 `$` 뒤 · 닫는 `$` 앞이
+ * 공백이거나 닫는 `$` 뒤가 숫자면 수식으로 읽지 않는다(Obsidian 1.13.7 의 토크나이저 · Notion 실측).
+ * 다만 Notion 은 글자에 붙은 수식(`w$^9$가`)도 글로 읽는다 — 그런 수식만 `` $`식`$ `` 로 보낸다({@link quoteGluedMath}).
+ */
 declare class MathNormalizer implements Processor {
     readonly name = "MathNormalizer";
     readonly order = 50;
@@ -1570,6 +2894,10 @@ declare class EmbedResolver implements Processor {
     readonly name = "EmbedResolver";
     readonly order = 60;
     process(input: ProcessorInput): ProcessorOutput;
+    /** `![[대상]]` — 첨부는 자리표시자로(push), 노트 임베드는 원문 그대로. */
+    private resolveEmbeds;
+    /** `![설명](url)` — 동영상 URL 은 임베드 마커로, 외부 이미지는 목록에 모은다. */
+    private resolveMarkdownImages;
 }
 
 declare class PreserveMarkerCollector implements Processor {
@@ -1584,6 +2912,20 @@ declare class UnsupportedBlockStripper implements Processor {
     process(input: ProcessorInput): ProcessorOutput;
 }
 
+/**
+ * 보내기 직전에 코드 밖의 이어진 빈 줄을 한 줄로 줄인다 — Notion 마크다운 가져오기는 남는 빈 줄마다 빈
+ * 블록을 만든다(실측: 주석 한 줄을 지운 자리의 빈 줄 셋이 빈 블록 셋). 받으면 그 빈 블록이 `<br>` 줄이 된다.
+ *
+ * 노트의 빈 줄과, 앞 전처리가 지운 주석 · 지원하지 않는 블록이 남긴 빈 줄을 함께 줄인다. 그래서 내용을
+ * 지우거나 끼우는 전처리 뒤, 보존 마커 수집(70) 앞에 돈다. 예전에는 지원하지 않는 블록 제거(5)가 줄였다 —
+ * 주석 제거(11)보다 먼저라 주석 자리가 빈 블록이 됐고, 코드 속 빈 줄까지 줄였다(S-27).
+ */
+declare class BlankLineCollapser implements Processor {
+    readonly name = "BlankLineCollapser";
+    readonly order = 65;
+    process(input: ProcessorInput): ProcessorOutput;
+}
+
 declare class PropertiesTableInjector implements Processor {
     readonly name = "PropertiesTableInjector";
     readonly order = 15;
@@ -1591,7 +2933,7 @@ declare class PropertiesTableInjector implements Processor {
 }
 
 /**
- * 인라인 annotation(underline·color) 무손실 보존기 — push 전처리(order 5).
+ * 인라인 annotation(underline·color) 무손실 보존기 — push 전처리(order 13).
  *
  * 과거에는 underline/color 표기를 **제거**(strip)했으나, 그러면 Notion 으로 push 할 때
  * 서식이 영구 소실됐다(I3 손실점). Notion 의 Enhanced Markdown 은 underline/color 를
@@ -1610,7 +2952,7 @@ declare class PropertiesTableInjector implements Processor {
  */
 declare class InlineAnnotationPreserver implements Processor {
     readonly name = "InlineAnnotationPreserver";
-    readonly order = 5;
+    readonly order = 13;
     process(input: ProcessorInput): ProcessorOutput;
 }
 
@@ -1676,6 +3018,13 @@ declare class PropertiesTableRestorer implements Processor {
     readonly name = "PropertiesTableRestorer";
     readonly order = 5;
     process(input: ProcessorInput): ProcessorOutput;
+    /**
+     * DB 행 본문 첫머리의 속성 블록은 예전 push 가 행을 페이지로 밀며 잘못 끼운 것이다(S-02).
+     * 행의 속성은 Notion 속성이 정본이다 — 블록 값으로 덮으면 Notion 에서 고친 속성이 옛 값으로
+     * 보인다. 그래서 값은 버리고 블록만 걷어 낸다. Notion 쪽 블록은 이 행의 본문을 다음에
+     * push 할 때 사라진다.
+     */
+    private dropFromRow;
     private restoreFromYaml;
     private restoreFromTable;
 }
@@ -1766,13 +3115,19 @@ declare class FileWatcher {
     stop(): Promise<void>;
 }
 
+/** 한 번의 sync 가 무엇을 보나 — 바뀐 파일만(파일 변경) · 볼트 전체(주기 sync). */
+type WatchSyncScope = "changes" | "full";
 interface WatchSyncOptions {
     readonly debounceMs?: number;
-    readonly onSyncStart?: () => void;
-    readonly onSyncComplete?: (result: SyncResult) => void;
-    readonly onSyncError?: (error: Error) => void;
+    readonly onSyncStart?: (scope: WatchSyncScope) => void;
+    readonly onSyncComplete?: (result: SyncResult, scope: WatchSyncScope) => void;
+    /** 감시를 멈춰 도중에 취소한 sync — `result` 는 그때까지 처리한 것이다. */
+    readonly onSyncCancelled?: (result: SyncResult, scope: WatchSyncScope) => void;
+    readonly onSyncError?: (error: Error, scope: WatchSyncScope) => void;
     readonly onFileChange?: (event: WatchEvent, path: string) => void;
 }
+/** 마지막 변경 뒤 동기화까지 기다리는 시간 — CLI `watch` 와 플러그인 자동 동기화가 함께 쓴다. */
+declare const DEFAULT_WATCH_DEBOUNCE_MS = 2000;
 declare class WatchSyncService {
     private readonly rootPath;
     private readonly orchestrator;
@@ -1783,10 +3138,26 @@ declare class WatchSyncService {
     private pendingChanges;
     private syncing;
     private syncQueued;
+    private fullSyncQueued;
     private running;
+    private inFlight;
+    private stopping;
     constructor(rootPath: string, orchestrator: SyncOrchestrator, options?: WatchSyncOptions);
     start(): void;
+    /**
+     * 감시를 멈춘다. 도는 sync 는 취소하고 끝나기를 기다린다 — 예전에는 기다리지 않아, 부른 쪽이
+     * sync 도중에 상태 DB 를 닫았다(S-09).
+     */
     stop(): Promise<void>;
+    private halt;
+    /**
+     * 볼트 전체 sync 를 요청한다 — CLI `watch --interval` 의 주기 sync(S-09).
+     *
+     * 파일 변경 sync 와 같은 줄에 선다. 예전에는 주기 sync 가 이 서비스 밖에서 오케스트레이터를
+     * 불러, 도는 중에 들어온 파일 변경 sync · 다음 주기 sync 와 겹쳤다. 도는 sync 가 있으면 끝난 뒤
+     * 한 번만 돈다 — 요청이 쌓여도 한 번이다.
+     */
+    requestFullSync(): void;
     isRunning(): boolean;
     isSyncing(): boolean;
     getPendingCount(): number;
@@ -1794,6 +3165,7 @@ declare class WatchSyncService {
     private scheduleSync;
     private clearDebounce;
     private executeSync;
+    private runBatch;
 }
 
 interface DBEntry {
@@ -1841,6 +3213,7 @@ interface PropertyOption {
 declare class ViewDataProvider {
     private readonly vaultFs;
     constructor(vaultFs: VaultFS);
+    /** 파일이 없으면 빈 객체. 있는데 읽지 못하면 던진다 — 「보기 설정이 없다」 와 「읽지 못했다」 는 다른 말이다. */
     loadAllViewConfigs(): Promise<Record<string, DatabaseViewsConfig>>;
     getViewConfigs(databaseId: string): Promise<DatabaseViewsConfig | null>;
     collectEntries(folderPath: string): Promise<DBEntry[]>;
@@ -1858,37 +3231,45 @@ declare class EntryEditor {
     updateDate(entryPath: string, dateProperty: string, newDate: string): Promise<void>;
 }
 
-interface BasePropertySchema {
-    readonly id: string;
-    readonly type: string;
-    readonly options?: Array<{
-        name: string;
-        color?: string;
-    }>;
-    readonly groups?: Array<{
-        name: string;
-        color?: string;
-        optionIds?: string[];
-    }>;
-}
 interface BaseFileOptions {
     readonly databaseId: string;
     readonly databaseName: string;
     readonly schema: Record<string, BasePropertySchema>;
     readonly viewsConfig: DatabaseViewsConfig;
     readonly folderPath: string;
+    /**
+     * 날짜 속성 이름 → 기간의 끝을 적는 짝 키(`<이름>_end`). 행 노트는 기간을 두 키로 적으므로 표에 그 속성이
+     * 보이면 끝 열도 바로 뒤에 둔다(B13). 받은 행 가운데 기간이 있는 속성만 — 기간을 쓰지 않는 날짜 속성에
+     * 늘 빈 열을 두지 않는다.
+     */
+    readonly rangeEnds?: ReadonlyMap<string, string>;
 }
 type BasesViewType = "table" | "cards" | "list";
+/** Notion 뷰 하나를 Bases 로 옮길 때의 판정. */
+interface BasesViewMapping {
+    /** Bases 뷰 타입. `null` = 대응이 없어 `.base` 에 실을 수 없음. */
+    readonly type: BasesViewType | null;
+    /**
+     * 값이 있으면 **정확한 대응이 아니라 격하**라는 뜻(사람용 사유).
+     * 뷰 자체는 살아남지만 원래 뷰의 표현 일부(달력 격자·타임라인 축)는 재현되지 않는다.
+     */
+    readonly degradeReason?: string;
+}
 /**
- * Notion 뷰 타입 → Obsidian Bases 뷰 타입 매핑(SSOT).
+ * Notion 뷰 타입 → Obsidian Bases 뷰 매핑(SSOT).
  *
- * `null` = Bases 에 대응 뷰가 없어 `.base` 로 표현 불가. 이 경우 해당 뷰는 `.base` 에서
- * 누락되므로, 사이드카(`<db>.notion.json`)가 원본 뷰 설정을 무손실 보존한다.
  * 뷰는 현재 pull-authoritative — Notion API 가 2026-03-19 뷰 생성/수정/삭제를 열었지만
  * 본 프로젝트는 아직 뷰 write-back 을 구현하지 않았다(로드맵 항목). push 로 되돌릴 수
  * 없는 동안 "조용한 유실 금지"는 곧 "보존 + 정직한 degrade 리포트"를 의미한다.
+ *
+ * 달력·타임라인은 예전에 `null` 이었다 — 즉 `.base` 에서 **통째로 사라졌다**. 사이드카에는
+ * 남지만 Obsidian 을 여는 사람 눈에는 그 뷰가 애초에 없었던 것처럼 보인다. 격자·축은
+ * 못 살려도 "날짜 순으로 늘어놓은 목록"이라는 본래 의도는 표로 남길 수 있으므로,
+ * 버리는 대신 격하해 살리고 사유를 사이드카에 적는다.
  */
-declare const NOTION_TO_BASES_VIEW: Record<string, BasesViewType | null>;
+declare const NOTION_TO_BASES_VIEW: Record<string, BasesViewMapping>;
+/** Notion 뷰 타입의 Bases 매핑. 미상 타입은 표현 불가로 본다. */
+declare function basesViewMappingOf(notionType: string): BasesViewMapping;
 /** Notion 뷰 타입의 Bases 대응 타입을 돌려준다. 미지원/미상 타입은 `null`. */
 declare function basesViewTypeOf(notionType: string): BasesViewType | null;
 declare class BaseFileGenerator {
@@ -1898,6 +3279,19 @@ declare class BaseFileGenerator {
     private writeFormulas;
     private writePropertyDisplayNames;
     private writeViews;
+    /** `filters:` 키와 그 값을 쓴다. 단일 식이면 한 줄, 그룹이면 블록. */
+    private writeFilterValue;
+    /** 필터 노드를 시퀀스 항목(`- …`)으로 쓴다. 그룹이면 재귀적으로 중첩한다. */
+    private writeFilterItem;
+    /**
+     * 필터 식을 YAML 스칼라로 쓴다.
+     *
+     * 식은 대개 `note["상태"] == "진행 중"` 처럼 큰따옴표를 품는다. 평문 스칼라는 큰따옴표를
+     * 안에 담을 수 있으므로(선두만 아니면 된다) 기본은 평문으로 두어 기존 `file.ext == "md"`
+     * 라인과 모양을 맞춘다. 다만 `: `·` #`·선두 지시문자는 평문에서 의미가 달라지므로
+     * 그때만 작은따옴표로 감싼다(속성명에 콜론이나 해시가 들어갈 수 있다).
+     */
+    private yamlExpr;
     /**
      * 뷰 이름을 Bases 요구사항대로 유일화한다(in-place). 동명 충돌 시 ' 2',' 3'… 를 붙이되
      * 이미 존재하는 이름과 다시 충돌하지 않을 때까지 증가시킨다.
@@ -1912,11 +3306,72 @@ declare class BaseFileGenerator {
      */
     private propRef;
     private resolvePropertyName;
-    private decodeId;
     private yamlKey;
     private yamlValue;
 }
 
+/**
+ * 속성 id → 프론트매터 키 해소.
+ *
+ * Notion `views.retrieve` 는 RAW 속성 id(예: `[jiM`)를 주지만 `databases.retrieve` 스키마는
+ * URL-인코딩된 id(예: `%5BjiM`)를 준다. 디코드 후 비교하지 않으면 title 외 모든 속성
+ * (cover/order/sort/groupBy/filter)이 매칭에 실패해 조용히 사라진다.
+ *
+ * `.base` 생성기와 사이드카 생성기가 같은 규칙을 써야 하므로 여기 한 곳에 둔다.
+ */
+declare function resolvePropertyName(propertyId: string, schema: Record<string, BasePropertySchema>): string | undefined;
+
+/**
+ * Notion 뷰 필터식 → Obsidian Bases 필터식 번역기.
+ *
+ * ## 왜 필요한가
+ *
+ * Notion 뷰의 절반 가까이는 필터가 걸려 있다. 그런데 `.base` 는 폴더 필터만 내보냈고,
+ * 사이드카는 "Notion 필터식은 .base 로 표현되지 않음"이라 적어 두고 끝냈다. 그래서
+ * '시작전, 진행중' 이라는 이름의 뷰가 Obsidian 에서는 **완료된 행까지 전부** 보여 줬다 —
+ * 이름과 내용이 어긋나는, 사용자가 오해하기 딱 좋은 상태였다. Bases 는 뷰마다 `filters:`
+ * 를 지원하므로(공식 문서 `views[].filters`) 표현 가능한 조건은 실제로 옮길 수 있다.
+ *
+ * ## 부분 번역의 안전 규칙 — 이 파일의 핵심
+ *
+ * Notion 필터 문법은 Bases 보다 넓다(rollup any/every/none, 상대 날짜, formula 등).
+ * 못 옮기는 리프를 만났을 때 **어느 방향으로 틀릴지**는 논리 위치에 따라 다르다:
+ *
+ *   - `and` 안에서 리프 하나를 버리면 조건이 느슨해진다 → 결과는 **상위집합**.
+ *     Notion 보다 행이 더 보인다. 눈에 보이는 과다 표시이고, 데이터는 잃지 않는다.
+ *   - `or` 안에서 가지 하나를 버리면 조건이 조여진다 → 결과는 **부분집합**.
+ *     Notion 에 있던 행이 Obsidian 에서 **조용히 사라진다**. 이건 유실이다.
+ *   - `not` 은 안쪽을 버리면 부정의 의미 자체가 뒤집힌다.
+ *
+ * 그래서 `and` 는 번역 가능한 리프만 남기고, `or`/`not` 은 하나라도 못 옮기면 그룹
+ * 전체를 포기한다. 포기한 것은 전부 {@link TranslationResult.untranslated} 로 보고돼
+ * 사이드카 degrade 리포트에 실린다 — 조용히 넘어가는 경로는 없다.
+ */
+/** Bases 필터 노드 — 문자열 표현식이거나 and/or/not 그룹. */
+type BasesFilterNode = string | {
+    readonly and: BasesFilterNode[];
+} | {
+    readonly or: BasesFilterNode[];
+} | {
+    readonly not: BasesFilterNode[];
+};
+interface TranslationResult {
+    /** 번역된 필터. 옮길 수 있는 조건이 하나도 없으면 null. */
+    readonly node: BasesFilterNode | null;
+    /** 옮기지 못한 조건의 사람용 설명(중복 제거·정렬됨). */
+    readonly untranslated: string[];
+}
+/** 속성 id/이름 → 프론트매터 키. 스키마에서 못 찾으면 undefined. */
+type PropertyNameResolver = (idOrName: string) => string | undefined;
+/**
+ * Notion 필터 객체를 Bases 필터 노드로 옮긴다.
+ *
+ * @param filter Notion `views.retrieve` 가 준 필터 객체(`unknown` — 문법이 계속 늘어난다).
+ * @param schema DB 속성 스키마. 속성 id 해소와 status 그룹 전개에 쓴다.
+ * @param resolveName 속성 id(또는 이름) → 프론트매터 키 해소기.
+ */
+declare function translateNotionFilter(filter: unknown, schema: Record<string, BasePropertySchema>, resolveName: PropertyNameResolver): TranslationResult;
+
 /**
  * DB 사이드카(`<db>.notion.json`) — `.base` 로 표현할 수 없는 Notion DB 메타데이터를
  * 무손실 보존하는 단일 파일.
@@ -1968,7 +3423,12 @@ interface SidecarView {
 }
 interface DegradeNote {
     readonly view: string;
-    readonly kind: "view-unrepresentable" | "setting-dropped";
+    /**
+     * `view-unrepresentable` = 뷰가 `.base` 에서 통째로 누락.
+     * `view-degraded` = 뷰는 남지만 다른 타입으로 격하(달력→표 등).
+     * `setting-dropped` = 뷰는 그대로지만 설정 하나가 빠짐.
+     */
+    readonly kind: "view-unrepresentable" | "view-degraded" | "setting-dropped";
     readonly detail: string;
 }
 declare class SidecarGenerator {
@@ -1994,6 +3454,15 @@ declare class SidecarGenerator {
      * 미표현 뷰는 이미 view-unrepresentable 로 통째 보고됨).
      */
     private extractConfig;
+    /**
+     * 필터 손실을 **실제로 못 옮긴 것만** 보고한다.
+     *
+     * 예전엔 필터가 있기만 하면 "Notion 필터식은 .base 로 표현되지 않음"을 무조건 찍었다.
+     * 이제 `.base` 가 뷰별 `filters:` 를 내보내므로 그 문구는 대부분의 경우 거짓이다.
+     * 거짓 degrade 는 진짜 degrade 를 묻어 버리므로, `.base` 와 **같은 번역기**를 돌려
+     * 남은 것만 적는다(두 산출물이 어긋날 여지를 없앤다).
+     */
+    private noteFilterDegrade;
 }
 
 declare function sortEntries(entries: DBEntry[], sorts: NonNullable<ViewConfig["sorts"]>): DBEntry[];
@@ -2016,6 +3485,8 @@ interface FilterCondition {
 }
 declare function filterEntries(entries: DBEntry[], searchQuery?: string, filters?: FilterCondition[]): DBEntry[];
 
+/** Notion 이 쓰는 색 이름 전부(`default` 포함) — 색을 다루는 다른 곳은 이 목록을 읽는다. */
+declare const NOTION_COLOR_NAMES: readonly NotionColor[];
 declare function getNotionColor(color: NotionColor | string): string;
 declare function getNotionBgColor(color: NotionColor | string): string;
 declare function generateColorCSS(): string;
@@ -2097,21 +3568,131 @@ declare function summarizeFidelity(perFile: ReadonlyArray<{
     classification: FidelityClassification;
 }>): FidelitySummary;
 
+/** 한 줄만 보고 판정할 수 있는 렌더 결함. */
+interface RenderLineRule {
+    readonly code: string;
+    readonly label: string;
+    readonly re: RegExp;
+}
+declare const RENDER_LINE_RULES: readonly RenderLineRule[];
+/** 발견된 렌더 결함 하나. */
+interface RenderFinding {
+    readonly code: string;
+    readonly label: string;
+    readonly line: number;
+}
+/**
+ * 표 구분행 — 가로 공백만 허용한다. `\s` 를 쓰면 **줄바꿈까지 삼킨다**.
+ *
+ * 그러면 빈 표 행(`|  |  |  |`) 다음의 수평선(`---`)이 한 덩어리로 잡혀 구분행 하나가
+ * 날조되고, 데이터 행이 하나 줄어든 것처럼 보인다.
+ */
+declare const SEPARATOR_BODY = "[ \\t:|-]*-{3,}";
+/** 볼트에 실제로 쓰인 마크다운을 훑어 렌더 결함을 모은다. */
+declare function lintRenderedMarkdown(markdown: string): RenderFinding[];
+
 declare function computeHash(content: string): string;
 declare function computeBufferHash(buffer: Buffer): string;
 
 declare function generateId(): string;
 declare function normalizeNotionId(id: string): string;
+/**
+ * 사용자가 넣은 페이지 — ID(대시 있거나 없거나) 또는 Notion 주소(브라우저 주소창 · 「링크 복사」). 주소창에
+ * 보이는 것을 그대로 붙여 넣어도 되게 한다. 못 찾으면 null.
+ *
+ * 데이터베이스 보기에서 연 페이지 주소는 `…/<DB>?v=<보기>&p=<페이지>` 다 — 연 페이지는 `p` 이고, `v` 는 보기다.
+ */
+declare function notionIdFromInput(input: string): string | null;
 declare function notionIdsEqual(a: string, b: string): boolean;
 /**
  * 멘션 위키링크용 정규 id — 하이픈 제거 + 소문자. 오케스트레이터의 멘션 해소 정규식
- * (`[[notion:<32hex>]]`)이 인식하는 유일한 형태다. 블록 폴백 경로(formatMention)와
+ * (`[[notion:<32hex>]]`)이 인식하는 유일한 형태다. 블록 방식 받기(`blocks-to-nfm`)와
  * markdown-api 경로(convertPageMentions)가 동일 형태로 수렴하도록 한다(rank20/I3).
  */
 declare function compactNotionId(id: string): string;
 
 declare function sanitizeFileName(name: string): string;
 
+/** 노트(마크다운 파일)의 경로 · 이름인가. */
+declare function isMarkdownPath(path: string): boolean;
+/** 노트 확장자를 뗀다 — 노트가 아니면 그대로. */
+declare function stripMarkdownExtension(path: string): string;
+/** 경로의 노트 이름 — 마지막 조각에서 노트 확장자를 뗀다(`폴더/노트.MD` → `노트`). */
+declare function noteNameFromPath(path: string): string;
+
+/**
+ * 시각을 시간대의 벽시계 시각으로, 벽시계 시각을 오프셋이 붙은 시각으로 바꾼다(F-08).
+ *
+ * Obsidian 의 날짜시각 속성은 시간대가 없는 `YYYY-MM-DDTHH:mm` 이다 — 초 · 밀리초 · `Z` · `+09:00` 이
+ * 붙으면 글로 본다(2026-10-04 Obsidian 1.12.4 실측). Notion 은 오프셋 없는 시각을 UTC 로 읽는다(같은 날
+ * 실측: `2026-10-01T10:00` 을 보내면 `2026-10-01T10:00:00.000+00:00`). 그래서 pull 은 시각을 시간대의
+ * 벽시계 시각으로 적고, push 는 그 시간대의 오프셋을 붙여 보낸다 — 같은 순간이다.
+ */
+/**
+ * 이 컴퓨터의 시간대(IANA 이름). 부를 때마다 읽는다 — 앱이 켜진 채 시간대가 바뀔 수 있다.
+ */
+declare function systemTimeZone(): string;
+
+/**
+ * `--path` 범위 판정 — 볼트 상대경로가 사용자가 지정한 범위 안에 있는지.
+ *
+ * 단순 `startsWith` 는 **경로 조각 경계를 보지 않아** 범위를 넘겨 짚는다.
+ * `--path Notes` 가 `Notes-archive/비밀.md` · `Notes백업.md` 까지 끌어와, 사용자가
+ * 의도한 폴더 밖 파일을 push/pull 대상에 올린다(범위 지정의 의미가 무너진다).
+ *
+ * 규칙은 셋뿐이다.
+ *   1. 완전 일치        — `--path a/b.md` ↔ `a/b.md`
+ *   2. 폴더 하위        — `--path a` ↔ `a/b.md` (경계 `/` 를 반드시 소비)
+ *   3. 그 외는 불일치   — `--path a` ↔ `ab.md` ✗
+ *
+ * 사용자가 `--path a/` 처럼 슬래시를 붙여 쓰는 경우도 같은 범위로 본다.
+ */
+declare function matchesPathScope(path: string, scope: string): boolean;
+/** 범위 목록 중 하나라도 걸리면 true. 목록이 비어 있으면(범위 미지정) 항상 true. */
+declare function inAnyPathScope(path: string, scopes: readonly string[] | undefined): boolean;
+
+/** 줄 비교의 한 줄. 번호는 1부터 — 더한 줄은 옛 번호가, 지운 줄은 새 번호가 없다. */
+interface DiffLine {
+    readonly kind: "same" | "added" | "removed";
+    readonly text: string;
+    readonly oldNumber: number | null;
+    readonly newNumber: number | null;
+    /**
+     * 글 끝에 줄바꿈이 없는 줄. 바뀐 줄에만 붙인다 — 끝 줄바꿈만 다른 두 줄이 같은 줄을 지우고 다시 쓴 것처럼
+     * 보이지 않게. 같은 줄에 붙은 것은 양쪽 다 없다는 뜻이라 차이가 아니다.
+     */
+    readonly noNewlineAtEnd?: true;
+}
+/** 바뀐 줄과 그 앞뒤의 같은 줄 묶음 — Git 의 `@@ -oldStart,oldLines +newStart,newLines @@`. */
+interface DiffHunk {
+    /** 묶음의 첫 옛 줄 번호(1부터). 옛 줄이 없는 묶음(`oldLines` 0)도 1부터 센다. */
+    readonly oldStart: number;
+    readonly oldLines: number;
+    readonly newStart: number;
+    readonly newLines: number;
+    readonly lines: readonly DiffLine[];
+}
+/** 줄 종류마다 앞에 붙이는 부호 — Git 의 통합 diff 와 같다. 줄 비교를 글로 보이는 곳은 모두 이것을 쓴다. */
+declare const DIFF_SIGN: Readonly<Record<DiffLine["kind"], string>>;
+interface LineDiffOptions {
+    /** 바뀐 줄 앞뒤로 함께 보일 같은 줄 수. 기본 3 — Git 과 같다. */
+    readonly context?: number;
+}
+/**
+ * 두 글의 줄 비교 — 바뀐 곳과 그 앞뒤 몇 줄을 묶음으로 낸다. 같은 글이면 빈 배열.
+ *
+ * 예전의 충돌 비교는 같은 번호의 줄끼리 견줬다 — 한쪽 앞에 한 줄만 더해도 그 뒤의 모든 줄이 바뀐 것으로
+ * 보였다. 여기는 가장 긴 공통 줄을 맞춰 실제로 더하고 지운 줄만 가른다.
+ */
+declare function lineDiff(before: string, after: string, options?: LineDiffOptions): DiffHunk[];
+/**
+ * 통합 diff 글의 줄(Git 의 `diff -u` 와 같은 모양) — 옛 글 · 새 글 이름 두 줄, 묶음마다 `@@` 머리와 부호를
+ * 붙인 줄. 같은 글이면 이름 두 줄뿐이다. 끝 줄바꿈이 없다는 표시는 Git 과 달리 바뀐 줄 뒤에만 적는다
+ * (`DiffLine.noNewlineAtEnd`). 글로 보이는 곳(CLI `diff` · `resolve`)이 모두 이것을 쓴다 — 저마다 만들면
+ * 앞뒤 줄 수 · 큰 글 상한이 곳마다 달라진다.
+ */
+declare function formatUnifiedDiff(hunks: readonly DiffHunk[], oldName: string, newName: string): string[];
+
 interface Logger {
     warn(message: string, ...args: unknown[]): void;
     error(message: string, ...args: unknown[]): void;
@@ -2169,4 +3750,77 @@ declare function isInternalPath(path: string): boolean;
 /** 모든 보존 마커가 공유하는 브랜드 토큰. */
 declare const MARKER_BRAND = "im-nobsidian";
 
-export { BaseFileGenerator, type BaseFileOptions, type BasePropertySchema, type BaseSyncOptions, type BasesViewType, BlockConverter, CONFIG_FILE, type CalendarEntry, CalloutRestorer, CalloutTransformer, ChangeDetector, ColorAnnotator, type Config, ConfigManager, ConfigSchema, type Conflict, ConflictResolver, type ConflictStrategy, type ConversionContext, type ConversionPath, ConversionPipeline, type ConversionResult, type CoverConfig, type DBEntry, DB_VIEWS_FILE, DB_VIEWS_PATH, DEFAULT_CONFIG, type DatabaseSyncConfig, type DatabaseSyncResult, DatabaseSyncer, type DatabaseViewsConfig, type DegradeNote, EmbedResolver, EntryEditor, type FailedOperation, type FidelityClassification, type FidelityContext, type FidelityDefect, type FidelityDefectForm, type FidelitySummary, type FileDownloadResult, FileHandler, type FileInfo, type FileRegistryEntry, type FileStatInfo, type FileSystemEntry, type FileType, type FileUploadResult, FileWatcher, type FilterCondition, FrontmatterExtractor, FrontmatterGenerator, GITIGNORE_ENTRY, type GroupByConfig, type GroupedEntries, IGNORE_FILE, INTERNAL_DIR, INTERNAL_DIR_GLOB, type IStateDB, type ImageDownloadResult, ImageHandler, type ImageReference, InlineAnnotationPreserver, InlineDBParser, type LocalChange, LocalImageRestorer, type Logger, MARKER_BRAND, type MappingResult, type MappingType, MathNormalizer, MentionToWikilink, type MergeConflictRegion, type MergeResult, NOTION_TO_BASES_VIEW, NodeVaultFS, type NonMdFileInfo, type NotionBlock, NotionBlockBuilder, NotionClient, type NotionClientOptions, type NotionColor, type NotionPageNode, type NotionRichText, type RichTextItem as NotionRichTextItem, type NotionSidecar, type OperationType, type PageCover, type PageCreationPlan, type PageIcon, type PathFilterConfig, type PendingOperation, type PreserveMarker, PreserveMarkerCollector, PreserveMarkerInjector, type Processor, type ProcessorInput, type ProcessorMetadata, type ProcessorOutput, type ProgressCallback, type ProgressItem, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, type PropertyOption, type PropertySchema, type PropertyValue, type PullOptions, type PullResult, type PushOptions, type PushResult, type RecordPendingInput, type RegisterFileInput, type RemoteChange, type ResolutionChoice, type ResolutionResult, type RichTextSegment, STATE_DB_FILE, STATE_DB_PATH, SidecarGenerator, type SidecarProperty, type SidecarView, StateDB, type StatusResult, type SyncDirection, type SyncOptions, SyncOrchestrator, type SyncRecord, type SyncResult, type SyncStatus, TreeMapper, UnsupportedBlockStripper, type UpsertSyncRecord, type VaultFS, type ViewConfig, ViewDataProvider, type ViewPropertyConfig, type ViewRenderData, type ViewType, type WatchSyncOptions, WatchSyncService, type WikilinkEntry, WikilinkResolver, basesViewTypeOf, classifyBodyFidelity, compactNotionId, computeBufferHash, computeHash, createDefaultPipeline, extractCalendarEntries, filterByMonth, filterEntries, generateColorCSS, generateId, getLogger, getNotionBgColor, getNotionColor, getVisibleProperties, groupEntries, isInternalPath, normalizeNotionId, notionIdsEqual, sanitizeFileName, setLogger, sortEntries, summarizeFidelity, threeWayMerge };
+/**
+ * 디자인 마커 읽기 — 볼트 노트 한 줄에 실린 마커가 «무엇을 어디에» 칠하는지 (U-01).
+ *
+ * pull 은 Obsidian 에 문법이 없는 Notion 서식(글자색 · 밑줄 · 멘션 · 블록 색 · 콜아웃/토글 스타일 ·
+ * 표 속성)을 `%%…%%` 마커로 싣는다(ADR-008 · F-01 · F-04). 마커는 Obsidian 주석이라 읽기 보기에서는
+ * 지워지고, 편집 화면(Live Preview)에서는 글자로 보인다 — 서식은 어느 쪽에서도 보이지 않는다.
+ * 플러그인 렌더러가 이 결과로 칠한다. 마커 모양의 주인이 이 패키지(`constants/markers.ts`)라 읽기도
+ * 여기 둔다 — 모양을 바꾸면 이 파일과 그 시험이 같이 깨진다.
+ */
+/** Notion 색 하나 — `red` · `red_bg` · `red_background` 를 같은 값으로 읽는다. */
+interface DesignColor {
+    readonly name: Exclude<NotionColor, "default">;
+    readonly background: boolean;
+}
+/** 글 구간에 걸리는 서식. */
+type InlineStyle = {
+    readonly kind: "color";
+    readonly color: DesignColor;
+} | {
+    readonly kind: "underline";
+} | {
+    readonly kind: "mention";
+};
+/** 줄 안의 글자 위치 `[from, to)`. */
+interface LineRange {
+    readonly from: number;
+    readonly to: number;
+}
+interface StyledRange extends LineRange {
+    readonly style: InlineStyle;
+}
+/** 마커를 걷어 낸 글 조각과 그 조각에 걸린 서식 — 마커가 없는 글도 조각이 된다(서식 없음). */
+interface DesignSegment extends LineRange {
+    readonly text: string;
+    readonly styles: readonly InlineStyle[];
+}
+/**
+ * 콜아웃 · 토글 머리 줄의 스타일. `icon` 이 null 이면 Notion 에서 아이콘이 없는 콜아웃이다
+ * (마커에 icon 이 없다). 토글은 아이콘을 싣지 않는다(undefined).
+ */
+interface CalloutDesign {
+    readonly color?: DesignColor;
+    readonly icon?: string | null;
+}
+/** 표 한 줄(행)의 속성 — 셀 번호는 0 부터, 파이프 사이 칸 차례다. */
+interface TableLineDesign {
+    readonly headerRow?: boolean;
+    readonly headerColumn?: boolean;
+    readonly rowColor?: DesignColor;
+    /** 셀 번호 → 셀 색. */
+    readonly cellColors: ReadonlyMap<number, DesignColor>;
+    /** 셀 번호 → 열 색(머리 행의 `table-col` 마커가 그 열 전체에 건다). */
+    readonly columnColors: ReadonlyMap<number, DesignColor>;
+}
+interface DesignLine {
+    /** 줄에 있는 우리 마커 전부 — 편집 화면이 숨긴다. 짝이 맞은 닫는 토큰(`%%/color%%` 등)도 든다. */
+    readonly markers: readonly LineRange[];
+    /** 짝 마커 사이의 글 — 편집 화면이 칠한다. */
+    readonly styled: readonly StyledRange[];
+    /** 마커를 걷어 낸 차례대로의 글 조각 — 읽기 보기가 그려진 글과 맞춰 칠한다. */
+    readonly segments: readonly DesignSegment[];
+    readonly blockColor?: DesignColor;
+    /** 콜아웃 · 토글 머리 줄의 스타일. */
+    readonly callout?: CalloutDesign;
+    readonly table?: TableLineDesign;
+}
+/** 이 글에 우리 마커가 하나라도 있나 — 렌더러가 마커 없는 블록을 건너뛰는 데 쓴다. */
+declare function hasDesignMarker(text: string): boolean;
+/** Notion 색 토큰을 읽는다. `default` · 모르는 색은 칠할 것이 없다(undefined). */
+declare function parseDesignColor(token: string | undefined): DesignColor | undefined;
+/** 한 줄을 읽는다. 마커가 없는 줄은 글 조각 하나뿐인 결과를 돌려준다. */
+declare function readDesignLine(line: string): DesignLine;
+
+export { BaseFileGenerator, type BaseFileOptions, type BasePropertyOption, type BasePropertySchema, type BaseStatusGroup, type BaseSyncOptions, type BasesFilterNode, type BasesViewMapping, type BasesViewType, BlankLineCollapser, type BookmarkTarget, CONFIG_FILE, type CalendarEntry, type CalloutDesign, CalloutRestorer, CalloutTransformer, ChangeDetector, type ChangeDiff, ColorAnnotator, type CompletenessFailure, type CompletenessLocalSource, type CompletenessOptions, type CompletenessRemoteSource, type CompletenessReport, type Config, ConfigManager, ConfigSchema, type Conflict, ConflictResolver, type ConflictStrategy, type ConversionContext, type ConversionPath, ConversionPipeline, type ConversionResult, type CoverConfig, type DBEntry, DB_VIEWS_FILE, DB_VIEWS_PATH, DEFAULT_CONFIG, DEFAULT_TITLE_PROPERTY, DEFAULT_WATCH_DEBOUNCE_MS, DIFF_SIGN, type DatabaseCompleteness, type DatabaseSyncConfig, type DatabaseSyncResult, DatabaseSyncer, type DatabaseViewsConfig, type DeferredCode, type DegradeNote, type DesignColor, type DesignLine, type DesignSegment, type DiffHunk, type DiffLine, EmbedResolver, EntryEditor, type FailedOperation, type FidelityClassification, type FidelityContext, type FidelityDefect, type FidelityDefectForm, type FidelitySummary, type FileDownloadResult, FileHandler, type FileInfo, type FileRegistryEntry, type FileStatInfo, type FileSystemEntry, type FileType, type FileUploadResult, FileWatcher, type FilterCondition, type FolderMoveChange, FrontmatterExtractor, FrontmatterGenerator, type FullScanReason, GITIGNORE_ENTRY, type GatedOperation, type GroupByConfig, type GroupedEntries, IGNORE_FILE, INTERNAL_DIR, INTERNAL_DIR_GLOB, type IStateDB, type ImageDownloadResult, ImageHandler, type ImageReference, InlineAnnotationPreserver, InlineDBParser, type InlineStyle, type LineDiffOptions, type LineRange, type LocalChange, LocalImageRestorer, type LocalMoveAdoption, type LocalScan, type LocalScanOptions, type Logger, MARKER_BRAND, type MappingResult, type MappingType, MathNormalizer, MentionToWikilink, type MergeConflictRegion, type MergeResult, NOTION_COLOR_NAMES, NOTION_TOKEN_PREFIX, NOTION_TO_BASES_VIEW, NodeVaultFS, type NonMdFileInfo, type NotionBlock, NotionBlockBuilder, NotionClient, type NotionClientOptions, type NotionColor, type NotionPageNode, type NotionRichText, type RichTextItem as NotionRichTextItem, type NotionSidecar, type OperationType, type PageCompletenessRemoteSource, type PageCompletenessReport, type PageCover, type PageCreationPlan, type PageIcon, type PathFilterConfig, type PendingOperation, PendingWalError, type PlannedRow, type PreserveMarker, PreserveMarkerCollector, PreserveMarkerInjector, type Processor, type ProcessorInput, type ProcessorMetadata, type ProcessorOutput, type ProgressCallback, type ProgressItem, PropertiesTableInjector, PropertiesTableRestorer, PropertyMapper, type PropertyOption, type PropertySchema, type PropertyValue, type PullOptions, type PullResult, type PushOptions, type PushResult, RENDER_LINE_RULES, type RecordPendingInput, type RegisterFileInput, type RemoteChange, type RemoteObservation, type RemoteScanInfo, type RenameHints, type RenameKind, type RenderFinding, type RenderLineRule, type ResolutionChoice, type ResolutionResult, type RichTextSegment, type RowProgress, SAVED_STATE_TABLES_QUERY, SEPARATOR_BODY, STATE_DB_FILE, STATE_DB_MIGRATIONS, STATE_DB_PATH, SavedStateDbError, SidecarGenerator, type SidecarProperty, type SidecarView, StateDB, StateDbLockedError, type StateDbMigration, type StateDbTool, StateDbUnavailableError, StateLock, type StateLockClaim, type StateLockOwner, type StatusOptions, type StatusResult, type StyledRange, SyncBusyError, type SyncDirection, type SyncOptions, SyncOrchestrator, type SyncRecord, type SyncResult, type SyncStatus, type TableLineDesign, type TranslationResult, TreeMapper, UnsupportedBlockStripper, type UpsertSyncRecord, type VaultCompletenessReport, type VaultFS, type ViewConfig, ViewDataProvider, type ViewPropertyConfig, type ViewRenderData, type ViewType, WIKILINK_LOOKUPS, type WatchSyncOptions, type WatchSyncScope, WatchSyncService, type WikilinkEntry, type WikilinkLookup, WikilinkResolver, applicableChoices, assertNoPendingWal, basesViewMappingOf, basesViewTypeOf, choiceForStrategy, classifyBodyFidelity, compactNotionId, computeBufferHash, computeHash, createDefaultPipeline, extractCalendarEntries, filterByMonth, filterEntries, formatUnifiedDiff, generateColorCSS, generateId, getLogger, getNotionBgColor, getNotionColor, getVisibleProperties, groupEntries, hasDesignMarker, inAnyPathScope, isInternalPath, isMarkdownPath, isRemoteDeletion, lineDiff, lintRenderedMarkdown, matchesPathScope, normalizeNotionId, noteNameFromPath, notionIdFromInput, notionIdsEqual, operationLabel, parseDesignColor, pendingWalBytes, readDesignLine, resolvePropertyName, sanitizeFileName, setLogger, sortEntries, stateDbLockPath, stateDbWalPath, stripMarkdownExtension, summarizeFidelity, systemTimeZone, threeWayMerge, translateNotionFilter, verifyDatabaseCompleteness, verifyPageCompleteness };