@im-nobsidian/core 0.3.2 → 0.9.0

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,47 +85,59 @@ 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>;
+        createDatabases: z.ZodDefault<z.ZodBoolean>;
+        notifications: z.ZodDefault<z.ZodEnum<["silent", "default"]>>;
     }, "strip", z.ZodTypeAny, {
-        direction: "push" | "pull" | "both";
-        conflictStrategy: "local-first" | "remote-first" | "manual" | "duplicate";
+        notifications: "silent" | "default";
+        direction: "push" | "both" | "pull";
+        conflictStrategy: "manual" | "local-first" | "remote-first" | "duplicate";
         autoSync: boolean;
         autoSyncInterval: number;
+        fullReconcileInterval: number;
         deleteSync: boolean;
         syncFiles: boolean;
+        createDatabases: boolean;
     }, {
-        direction?: "push" | "pull" | "both" | undefined;
-        conflictStrategy?: "local-first" | "remote-first" | "manual" | "duplicate" | undefined;
+        notifications?: "silent" | "default" | 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;
+        createDatabases?: boolean | undefined;
     }>;
     paths: z.ZodObject<{
         include: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         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;
@@ -144,6 +160,7 @@ declare const ConfigSchema: z.ZodObject<{
         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;
@@ -161,6 +178,7 @@ declare const ConfigSchema: z.ZodObject<{
         maxFileSizeBytes: number;
         mediaDownloadTimeoutMs: number;
         itemTimeoutMs: number;
+        markdownCompletionMaxBlocks: number;
     }, {
         concurrency?: number | undefined;
         timeoutMs?: number | undefined;
@@ -178,6 +196,7 @@ declare const ConfigSchema: z.ZodObject<{
         maxFileSizeBytes?: number | undefined;
         mediaDownloadTimeoutMs?: number | undefined;
         itemTimeoutMs?: number | undefined;
+        markdownCompletionMaxBlocks?: number | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     version: 1;
@@ -196,23 +215,27 @@ declare const ConfigSchema: z.ZodObject<{
         workspaceId?: string | undefined;
     };
     sync: {
-        direction: "push" | "pull" | "both";
-        conflictStrategy: "local-first" | "remote-first" | "manual" | "duplicate";
+        notifications: "silent" | "default";
+        direction: "push" | "both" | "pull";
+        conflictStrategy: "manual" | "local-first" | "remote-first" | "duplicate";
         autoSync: boolean;
         autoSyncInterval: number;
+        fullReconcileInterval: number;
         deleteSync: boolean;
         syncFiles: boolean;
+        createDatabases: 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;
@@ -231,6 +254,7 @@ declare const ConfigSchema: z.ZodObject<{
         maxFileSizeBytes: number;
         mediaDownloadTimeoutMs: number;
         itemTimeoutMs: number;
+        markdownCompletionMaxBlocks: number;
     };
 }, {
     version: 1;
@@ -249,19 +273,23 @@ declare const ConfigSchema: z.ZodObject<{
         }[] | undefined;
     };
     sync: {
-        direction?: "push" | "pull" | "both" | undefined;
-        conflictStrategy?: "local-first" | "remote-first" | "manual" | "duplicate" | undefined;
+        notifications?: "silent" | "default" | 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;
+        createDatabases?: 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;
@@ -284,6 +312,7 @@ declare const ConfigSchema: z.ZodObject<{
         maxFileSizeBytes?: number | undefined;
         mediaDownloadTimeoutMs?: number | undefined;
         itemTimeoutMs?: number | undefined;
+        markdownCompletionMaxBlocks?: number | undefined;
     };
 }>;
 type Config = z.infer<typeof ConfigSchema>;
@@ -301,6 +330,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;
@@ -312,6 +347,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";
@@ -319,12 +371,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;
@@ -336,7 +410,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 가 공통으로 받는 동기화 옵션. */
@@ -347,18 +430,68 @@ 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 {
+    /** 사이드카로 만든(dry-run 은 만들) Notion DB 수(ADR-036). 없으면 0. */
+    readonly createdDatabases?: number;
     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;
@@ -376,6 +509,8 @@ interface PullResult {
     readonly imageCount: number;
     readonly fileCount: number;
     readonly linkCount: number;
+    /** 원격을 얼마나 훑었나. 원격을 보지 않은 실행(받기 방향이 아님 · 취소)에는 없다. */
+    readonly remoteScan?: RemoteScanInfo;
 }
 interface SyncResult {
     readonly push: PushResult;
@@ -383,13 +518,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;
@@ -397,6 +561,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;
@@ -418,6 +593,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 {
@@ -436,6 +628,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;
@@ -494,6 +707,22 @@ interface ViewConfig {
     readonly datePropertyId?: string;
     readonly datePropertyName?: string;
     readonly viewRange?: "week" | "month";
+    /**
+     * 보기 설정 원본(`views.retrieve` 의 `configuration`) — push 가 새 DB 에 같은 보기를 만들 때 속성 id 만
+     * 바꿔 그대로 보낸다(ADR-036). 위의 낱낱 항목은 `.base` 와 격하 보고가 읽는다.
+     */
+    readonly configuration?: Readonly<Record<string, unknown>>;
+    /** 빠른 필터 — 속성 id → 조건. */
+    readonly quickFilters?: Readonly<Record<string, unknown>>;
+}
+/** `views.create` 에 보낼 보기 — `database_id` · `data_source_id` 는 보내는 쪽이 붙인다. */
+interface ViewRequest {
+    readonly name: string;
+    readonly type: string;
+    readonly filter?: unknown;
+    readonly sorts?: unknown[];
+    readonly quick_filters?: Record<string, unknown>;
+    readonly configuration?: Record<string, unknown>;
 }
 interface DatabaseViewsConfig {
     readonly databaseId: string;
@@ -531,6 +760,8 @@ interface BasePropertySchema {
     readonly type: string;
     readonly options?: BasePropertyOption[];
     readonly groups?: BaseStatusGroup[];
+    /** 이 속성을 다시 만드는 데 드는 타입별 설정(`view/property-definition.ts`) — 사이드카가 적는다. */
+    readonly definition?: Readonly<Record<string, unknown>>;
 }
 interface PageCover {
     readonly type: "file" | "external";
@@ -538,7 +769,7 @@ interface PageCover {
     readonly expiryTime?: string;
 }
 interface PageIcon {
-    readonly type: "emoji" | "external" | "file" | "icon";
+    readonly type: "emoji" | "external" | "file" | "icon" | "custom_emoji";
     readonly value: string;
     readonly color?: string;
 }
@@ -562,7 +793,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[];
@@ -570,13 +802,18 @@ 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 추적용). */
     updatePath(id: string, newPath: string): void;
     delete(id: string): void;
     resolveWikilink(text: string): WikilinkEntry | null;
+    /** relation 값의 위키링크 — 대상 DB(`parentIds`)의 행 가운데서만 찾는다(`wikilinkLookupsIn`). */
+    resolveWikilinkIn(text: string, parentIds: readonly string[]): WikilinkEntry | null;
     resolvePageId(pageId: string): WikilinkEntry | null;
     upsertWikilink(entry: WikilinkEntry): void;
     /** 레코드 삭제 시 해당 경로의 wikilink 항목을 제거한다 (stale 링크 방지). */
@@ -600,11 +837,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;
@@ -613,12 +858,14 @@ 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;
     delete(id: string): void;
     resolveWikilink(text: string): WikilinkEntry | null;
+    resolveWikilinkIn(text: string, parentIds: readonly string[]): WikilinkEntry | null;
     resolvePageId(pageId: string): WikilinkEntry | null;
     upsertWikilink(entry: WikilinkEntry): void;
     deleteWikilink(obsidianPath: string): void;
@@ -649,6 +896,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"];
@@ -694,26 +944,413 @@ 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[];
+/**
+ * relation 값의 위키링크 → 대상 DB(`parentIds` — DB id · data source id)의 행만 보는 조회들.
+ *
+ * - 대상 DB 밖 페이지는 고르지 않는다. Notion 은 relation 에 다른 DB 의 페이지를 넣으면 오류 없이 빼 버린다
+ *   (2026-10-23 실측: 200 응답 · 값만 빠짐) — 제목이 같은 다른 DB 의 행으로 풀리면 relation 이 조용히 사라졌다.
+ * - 파일 이름 → 제목 → 별칭 차례. pull 은 relation 값을 파일 이름으로 적는다. 제목을 먼저 보면 제목이 같은
+ *   두 행(한쪽 파일 이름에 `(id)` 가 붙은) 가운데 엉뚱한 행을 걸었다.
+ */
+declare function wikilinkLookupsIn(parentIds: readonly string[]): 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;
+
+/** DB 속성 스키마 한 칸 — {@link NotionClient.getDatabaseSchema} 가 내는 꼴. */
+interface DatabasePropertySchema {
+    readonly id: string;
+    readonly type: string;
+    /** relation 이 가리키는 DB — DB id · data source id. */
+    readonly relationTargets?: readonly string[];
+}
 type NotionPropertyValue = Record<string, unknown>;
 interface WikilinkResolver$1 {
     resolve(title: string): string | null;
+    /** 대상 DB(`parentIds`)의 행 가운데서만 — relation 값. 없으면 {@link resolve} 로 찾는다. */
+    resolveIn?(title: string, parentIds: readonly string[]): string | null;
     resolvePageId(pageId: string): string | null;
 }
+/** 이름으로 적힌 사람의 사용자 id — 워크스페이스에 없거나 같은 이름이 여럿이면 null. */
+type PeopleResolver = (name: 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>>;
+    /**
+     * 파일 속성의 볼트 첨부(`[[attachments/…]]` 의 경로)를 올린 것 — 있으면 그 첨부를 올린 파일로 보낸다
+     * ({@link PropertyMapper.localFileTargets}). 없는 첨부가 섞인 값은 보내지 않는다.
+     */
+    readonly uploads?: ReadonlyMap<string, UploadedFile>;
+}
+/** Notion 에 올린 볼트 파일 — 파일 속성 값으로 보낸다. */
+interface UploadedFile {
+    readonly fileUploadId: string;
+    /** Notion 에 보일 이름 — 받을 때 붙인 내용 해시를 뗀 것. */
+    readonly name: string;
+}
 declare class PropertyMapper {
+    private readonly options;
     private schema;
     private wikilinkResolver;
+    private peopleResolver;
+    constructor(options?: PropertyMapperOptions);
+    /** 설정의 변환 옵션으로 만든다 — 시간대를 이 한 곳에서 읽는다. */
+    static fromConfig(config: Pick<Config, "conversion">): PropertyMapper;
     setWikilinkResolver(resolver: WikilinkResolver$1): void;
-    loadSchema(properties: Record<string, {
-        id: string;
-        type: string;
-    }>): void;
+    setPeopleResolver(resolver: PeopleResolver): void;
+    /** 스키마에 사람 속성이 있는가 — 있을 때만 사용자 목록을 읽는다. */
+    hasPeopleProperty(): boolean;
+    loadSchema(properties: Record<string, DatabasePropertySchema>): 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[];
+    };
+    /** Notion 이 값을 정하는 속성(수식 · 롤업 · ID · 생성일 …)이 스키마에 있는가 — 버튼은 값이 없다. */
+    hasComputedProperties(): boolean;
+    /**
+     * 바뀐 값 가운데 파일 속성이 가리키는 볼트 첨부의 경로 — 호출측이 올려 {@link PropertyChangeContext.uploads} 로 준다.
+     *
+     * pull 은 Notion 에 올라간 파일을 받아 `[[attachments/…]]` 로 적는다. 그 값을 새 행이나 바뀐 값으로 보낼 때
+     * 첨부를 다시 올리지 않으면 보낼 수가 없다 — 다른 페이지로 옮겨 올린 행의 파일 속성이 비었다(2026-10-23 E2E 9건).
+     */
+    localFileTargets(changed: Readonly<Record<string, unknown>>): string[];
+    /** relation 값(위키링크 · 페이지 id 목록)이 가리키는 페이지 가운데 알아본 것. */
+    relationTargets(value: unknown): string[];
+    /**
+     * @param targets relation 이 가리키는 DB. 알면 그 DB 의 행으로만 푼다 — 다른 DB 의 페이지는 Notion 이 오류
+     *   없이 빼 버리므로, 못 찾은 것으로 두어 보내지 않고 알린다.
+     */
+    private relationTargetOf;
+    /**
+     * 이 속성들 가운데 relation. 보내지 못한 relation 은 대상 노트가 아직 Notion 에 없었을 수 있다 —
+     * 호출측이 기준에서 빼 두고 다시 보낸다.
+     */
+    relationKeys(keys: readonly string[]): 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;
 }
 
+/**
+ * 동기화가 쓴 페이지가 사람에게 알림을 보내나(2026-10-08 changelog «Control notifications from page writes»).
+ *
+ * - `silent` — 페이지 수정 · @멘션 · 사람 속성 알림을 보내지 않는다. DB 자동화 · 리마인더 · 웹훅은 그대로다
+ * - `default` — Notion 이 정한 대로 보낸다
+ */
+declare const NOTIFICATION_MODES: readonly ["silent", "default"];
+type NotificationMode = (typeof NOTIFICATION_MODES)[number];
+
+/**
+ * 취소 신호. `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>>;
+    /** 페이지 본문 안에 놓인 인라인 DB 인가. */
+    readonly isInline: boolean;
+    /** DB 의 아이콘 · 커버 · 설명 · 제목 표시 — 받은 그대로. */
+    readonly appearance?: DatabaseAppearance;
+}
+/** DB 자체의 꾸밈 — 행이 아니라 DB 의 것이다. 값은 Notion 이 준 그대로(`icon` · `cover` 는 페이지와 같은 꼴). */
+interface DatabaseAppearance {
+    readonly icon: unknown;
+    readonly cover: unknown;
+    readonly description: readonly unknown[];
+    /** 보기 위에 DB 제목을 보이나(2026-10-20 changelog). */
+    readonly showTitle: boolean;
+}
 interface NotionClientOptions {
     readonly token: string;
     readonly concurrency?: number;
@@ -724,6 +1361,12 @@ interface NotionClientOptions {
     readonly retryBackoffFactor?: number;
     readonly pageSize?: number;
     readonly batchSize?: number;
+    /** 잘린 Markdown 을 채우려고 다시 받는 블록 수 상한 (S-06) */
+    readonly markdownCompletionMaxBlocks?: number;
+    /** 페이지 속성의 날짜시각을 적을 시간대(`conversion.timeZone`) — 없으면 이 컴퓨터의 시간대. */
+    readonly timeZone?: string;
+    /** 쓰기가 알림을 보내나(`sync.notifications`). */
+    readonly notifications?: NotificationMode;
     readonly fetch?: typeof globalThis.fetch;
 }
 declare class NotionClient {
@@ -736,10 +1379,42 @@ 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;
+    /**
+     * {@link getDatabaseSyncability} 가 읽은 DB — 바로 뒤 {@link getDatabaseMeta} 가 한 번 쓰고 버린다.
+     * 발견한 DB 는 곧장 행을 받으므로 같은 두 요청(DB · data source)을 되풀이하지 않는다.
+     */
+    private readonly checkedDatabases;
+    /** 보낸 요청 수(재시도는 세지 않는다) — 순회 예산을 잰다. */
+    private requestsSent;
     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>>;
+    /** 워크스페이스 사용자 전부(사람 · 봇) — 손님은 API 가 돌려주지 않는다. */
+    listUsers(): Promise<Array<{
+        id: string;
+        name?: string | null;
+    }>>;
     getPage(pageId: string): Promise<PageObjectResponse>;
     createPage(params: {
         parentId: string;
@@ -748,6 +1423,33 @@ declare class NotionClient {
         properties?: Record<string, unknown>;
         children?: BlockObjectResponse[];
     }): Promise<PageObjectResponse>;
+    /**
+     * 페이지 아래에 DB 를 만든다(ADR-036). 같은 요청이 두 번 적용되면 DB 가 둘이 된다 — 다시 보내지 않는다.
+     * 부른 쪽이 만들기 전에 자리를 적어 두고, 응답을 잃으면 다음 push 가 부모에서 찾는다.
+     *
+     * @returns 만든 DB 와 그 data source(DB 를 만들면 하나 생긴다)
+     */
+    createDatabase(params: {
+        parentPageId: string;
+        title: string;
+        isInline: boolean;
+        properties: Record<string, unknown>;
+        /** 아이콘 · 커버 · 설명 · 제목 표시 — 요청 꼴 그대로(`databases.create` 의 같은 이름 칸). */
+        appearance?: Readonly<Record<string, unknown>>;
+    }): Promise<{
+        databaseId: string;
+        dataSourceId: string;
+    }>;
+    /** DB 의 첫 data source — 행 · 스키마가 사는 곳. 없으면 null. */
+    primaryDataSourceId(databaseId: string): Promise<string | null>;
+    /**
+     * data source 에 속성을 더하거나 바꾼다. 같은 이름이면 그 속성을 바꾼다 — 다시 보내도 결과가 같다.
+     *
+     * @returns 바꾼 뒤의 속성 전체(이름 → 정의)
+     */
+    updateDataSourceProperties(dataSourceId: string, properties: Record<string, unknown>): Promise<Record<string, Record<string, unknown>>>;
+    /** data source 의 속성(이름 → 정의). */
+    getDataSourceProperties(dataSourceId: string): Promise<Record<string, Record<string, unknown>>>;
     createPageWithMarkdown(params: {
         parentId: string;
         parentType: "page" | "database";
@@ -755,27 +1457,75 @@ 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>;
+    /**
+     * 페이지의 아이콘 · 커버만 바꾼다 — `null` 은 지운다. 값은 `notion/decoration-values.ts` 가 만든 객체다.
+     * 모르는 아이콘 이름 · 색이면 Notion 이 `validation_error` 로 거절하고 아무것도 바꾸지 않는다.
+     */
+    updatePageDecorations(pageId: string, decorations: {
+        readonly icon?: unknown;
+        readonly cover?: unknown;
+    }): Promise<PageObjectResponse>;
+    /** 워크스페이스 사용자 이모지의 id — 이름이 꼭 같은 것. 없으면 null. */
+    findCustomEmojiId(name: string): Promise<string | null>;
+    /**
+     * 페이지 마크다운. 블록이 많아 잘린 부분은 블록 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>;
+    /** DB 와 그 data source 들을 읽는다 — `owners` 는 data source 마다 그 부모 DB(읽지 못했으면 undefined). */
+    private readDatabase;
+    /** `from` 이 이 DB 를 받은 것이면 그것을, 아니면 새로 받는다. */
+    private metaOf;
+    /** @param from 이미 받은 이 DB — 주면 다시 받지 않는다. */
+    getDatabaseTitle(databaseId: string, from?: DatabaseMeta): Promise<string>;
     /**
      * 발견된 DB 가 **동기화 가능한지**(접근 가능한 data source 가 있는지) 판별한다.
      * 신 모델(2025-09-03)에서 링크드 DB·미공유 데이터 소스·삭제 DB 는 `data_sources` 가
@@ -804,10 +1554,8 @@ declare class NotionClient {
         originalDbId: string;
         viewName: string;
     } | null>;
-    getDatabaseSchema(databaseId: string): Promise<Record<string, {
-        id: string;
-        type: string;
-    }>>;
+    /** @param from 이미 받은 이 DB — 주면 다시 받지 않는다. */
+    getDatabaseSchema(databaseId: string, from?: DatabaseMeta): Promise<Record<string, DatabasePropertySchema>>;
     /**
      * DB 속성 스키마 전체(선택지·status 그룹 포함).
      *
@@ -815,10 +1563,20 @@ declare class NotionClient {
      * 옵션명이 아니라 **그룹명**(`To-do` 등)으로 오기 때문에 `groups[].optionIds` 를
      * 옵션명으로 되돌리려면 이 id 가 있어야 한다. 예전엔 여기서 id 를 떨궈,
      * 그룹으로 필터링된 뷰를 Bases 로 옮길 방법이 아예 없었다.
+     *
+     * @param from 이미 받은 이 DB — 주면 다시 받지 않는다.
      */
-    getDatabaseSchemaFull(databaseId: string): Promise<Record<string, BasePropertySchema>>;
+    getDatabaseSchemaFull(databaseId: string, from?: DatabaseMeta): Promise<Record<string, BasePropertySchema>>;
     /** 특정 data source 1개를 직접 쿼리한다(저수준). 다중 data source 순회의 빌딩블록. */
     private queryDataSource;
+    /**
+     * data source 하나의 행을 모두 읽는다. 조회 하나는 결과 10,000건에서 멈추고 `request_status.incomplete` 를
+     * 단다(API 2026-04-20) — 그러면 만든 시각 차례로 처음부터 다시 읽되, 한도에 걸릴 때마다 마지막 행의 만든 시각부터
+     * 새 조회를 연다(SDK `iterateAllDataSourceRows` 와 같은 방법 — 그 도우미는 속도 제한을 거치지 않는다).
+     * 한도 밑이면 예전처럼 정렬 없이 한 번 읽는다 — 행 차례(같은 제목의 파일 이름)가 그대로다.
+     */
+    private queryAllRowsOf;
+    private queryRowsByCreatedTime;
     /**
      * database 의 1차 data source 1페이지를 쿼리한다(증분 detect 등 단일 소스 경로용).
      * 전 행을 빠짐없이 받으려면 {@link queryAllDatabasePages} 를 쓴다(전 data source 순회).
@@ -837,8 +1595,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>;
     /**
@@ -850,7 +1610,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;
@@ -862,6 +1634,13 @@ declare class NotionClient {
     fetchAllChildren(blockId: string): Promise<BlockObjectResponse[]>;
     private static readonly CONTAINER_BLOCK_TYPES;
     fetchAllChildrenDeep(blockId: string): Promise<BlockObjectResponse[]>;
+    /**
+     * 블록 트리 — 자식이 있는 블록은 `children` 에 자식을 담는다. 자식 페이지 · DB 는 열지 않는다. 동기화
+     * 참조 블록은 Notion 이 원본의 자식을 돌려주므로 그대로 담는다(Markdown API 도 원본 내용을 싣는다).
+     *
+     * 블록 하나라도 읽지 못하면 던진다 — 빠진 채로 노트를 쓰면 다음 push 가 그 블록을 Notion 에서 지운다.
+     */
+    getBlockTree(blockId: string): Promise<BlockTreeNode[]>;
     /**
      * 자식 블록을 덧붙인다. `options.after` 를 주면 그 블록 **바로 뒤**에 삽입한다
      * (기본은 맨 끝). 자리표시자를 실제 미디어 블록으로 제자리 교체할 때 필요하다.
@@ -873,7 +1652,33 @@ declare class NotionClient {
     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 고정 사용 */
@@ -893,29 +1698,35 @@ 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 순회해 하위 페이지를 모두 수집한다(중첩 깊이 무관·무손실).
      * 비용은 서브트리 전체 블록 수에 비례한다.
      *
-     * @param opts.deadlineMs `Date.now()` 기준 마감 시각. 각 페이지 처리 전 초과를 검사해
+     * @param opts.maxRequests 이 순회가 쓸 요청 수. 각 페이지 처리 전 초과를 검사해
      *   초과 시 {@link DiscoveryTooLargeError}를 던진다(대규모 서브트리 → search 폴백 유도).
      *   **그때까지 찾은 페이지는 에러의 `partial` 에 실어 보낸다** — 버리면 호출측이 두
      *   경로를 경합시키게 되고, 어느 쪽이 이기는지를 벽시계가 정하게 된다(R12-A).
      *   미지정 시 무제한(기존 동작 유지 — 테스트 mock 경로는 영향 없음).
+     * @param opts.signal 취소되면 다음 페이지로 가기 전에 `OperationAbortedError` 로 멈춘다.
      */
     getChildPagesRecursive(parentId: string, opts?: {
-        deadlineMs?: number;
+        maxRequests?: number;
+        signal?: AbortLike;
     }): Promise<PageObjectResponse[]>;
     /** 워크스페이스에서 통합에 공유된 모든 페이지를 bulk search 로 열거한다(100/요청). */
-    searchAllPages(): Promise<PageObjectResponse[]>;
+    searchAllPages(signal?: AbortLike): Promise<PageObjectResponse[]>;
     /**
      * root 하위 페이지를 **search 기반**으로 디스커버리한다(대규모 서브트리용 폴백).
      *
@@ -930,11 +1741,20 @@ 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[]>;
+    /** DB 에 보기를 만든다. 다시 보내면 같은 보기가 둘 생긴다 — 재시도하지 않는다. @returns 만든 보기 id */
+    createView(params: {
+        databaseId: string;
+        dataSourceId: string;
+        request: ViewRequest;
+    }): Promise<string>;
+    /** 보기를 지운다. DB 의 마지막 보기는 지우지 못한다(400). */
+    deleteView(viewId: string): Promise<void>;
     getView(viewId: string): Promise<ViewConfig | null>;
     getDatabaseViewsConfig(databaseId: string): Promise<DatabaseViewsConfig>;
     extractCover(page: PageObjectResponse): PageCover | null;
+    /** 페이지 아이콘 — `value` 는 frontmatter 에 적는 꼴이다(`notion/decoration-values.ts`). */
     extractIcon(page: PageObjectResponse): PageIcon | null;
     extractTitle(page: PageObjectResponse): string;
     /**
@@ -965,6 +1785,13 @@ declare class NotionClient {
      * 268페이지 pull 이 진행 로그가 멈춘 채 수 분씩 정지하는 것으로 나타났다(R9).
      * 그래서 (1) 대기 중에는 슬롯을 반납하고, (2) 429 는 {@link cooldownUntil} 전역
      * 게이트로 함께 쉬고, (3) 모든 재시도를 경고로 남긴다.
+     *
+     * `idempotent: false` 는 두 번 적용되면 결과가 달라지는 쓰기다(페이지 생성 · 블록
+     * 덧붙이기 · 부분 치환). 이런 요청은 서버가 «처리하지 않았다» 고 분명히 말한 실패만
+     * 다시 보낸다. 타임아웃 · 연결 끊김 · 5xx 는 요청이 이미 적용됐을 수 있고 Notion 은
+     * 멱등 키를 받지 않으므로, 다시 보내면 같은 페이지 · 같은 블록이 두 벌 생긴다.
+     * 그런 실패는 호출측으로 올린다 — 페이지 생성은 WAL(pending_operations)이 부모에서
+     * 제목으로 찾아 입양한다.
      */
     private withRateLimit;
     /** 슬롯을 쥔 뒤의 발사 대기 — 전역 쿨다운(429)과 최소 요청 간격을 함께 지킨다. */
@@ -1214,17 +2041,49 @@ interface VaultCompletenessReport {
  */
 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 {
@@ -1250,15 +2109,41 @@ interface VaultFS {
     listMarkdownFileStats(): Promise<FileStatInfo[]>;
     listNonMarkdownFiles(): Promise<NonMdFileInfo[]>;
     getFileStat(path: string): Promise<FileStatInfo | null>;
+    /**
+     * 이 볼트(연결)가 맡은 경로인가 — 볼트 안의 다른 연결 폴더(ADR-038)는 false. 없으면 전부 맡는다.
+     */
+    ownsPath?(path: string): boolean;
 }
 
 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;
@@ -1266,39 +2151,335 @@ 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;
 }
 
+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).
+ *
+ * 뷰는 현재 pull-authoritative — Notion API 가 2026-03-19 뷰 생성/수정/삭제를 열었지만
+ * 본 프로젝트는 아직 뷰 write-back 을 구현하지 않았다(로드맵 항목). push 로 되돌릴 수
+ * 없는 동안 "조용한 유실 금지"는 곧 "보존 + 정직한 degrade 리포트"를 의미한다.
+ *
+ * 달력·타임라인은 예전에 `null` 이었다 — 즉 `.base` 에서 **통째로 사라졌다**. 사이드카에는
+ * 남지만 Obsidian 을 여는 사람 눈에는 그 뷰가 애초에 없었던 것처럼 보인다. 격자·축은
+ * 못 살려도 "날짜 순으로 늘어놓은 목록"이라는 본래 의도는 표로 남길 수 있으므로,
+ * 버리는 대신 격하해 살리고 사유를 사이드카에 적는다.
+ */
+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 {
+    generate(options: BaseFileOptions): string;
+    private writeFilters;
+    private needsContentCoverFormula;
+    private writeFormulas;
+    private writePropertyDisplayNames;
+    private writeViews;
+    /** `filters:` 키와 그 값을 쓴다. 단일 식이면 한 줄, 그룹이면 블록. */
+    private writeFilterValue;
+    /** 필터 노드를 시퀀스 항목(`- …`)으로 쓴다. 그룹이면 재귀적으로 중첩한다. */
+    private writeFilterItem;
+    /**
+     * 필터 식을 YAML 스칼라로 쓴다.
+     *
+     * 식은 대개 `note["상태"] == "진행 중"` 처럼 큰따옴표를 품는다. 평문 스칼라는 큰따옴표를
+     * 안에 담을 수 있으므로(선두만 아니면 된다) 기본은 평문으로 두어 기존 `file.ext == "md"`
+     * 라인과 모양을 맞춘다. 다만 `: `·` #`·선두 지시문자는 평문에서 의미가 달라지므로
+     * 그때만 작은따옴표로 감싼다(속성명에 콜론이나 해시가 들어갈 수 있다).
+     */
+    private yamlExpr;
+    /**
+     * 뷰 이름을 Bases 요구사항대로 유일화한다(in-place). 동명 충돌 시 ' 2',' 3'… 를 붙이되
+     * 이미 존재하는 이름과 다시 충돌하지 않을 때까지 증가시킨다.
+     */
+    private dedupeViewNames;
+    private convertView;
+    private toNoteRef;
+    /**
+     * 속성 참조(order/sort/groupBy/image)를 YAML로 안전하게 출력한다.
+     * `file.name`·`formula.coverImage`·`note.cover` 같은 접두사 식별자와 공백 포함 일반 속성명은
+     * 평문 스칼라로 안전하므로 그대로 두고, 콜론·해시·따옴표 등 YAML 메타문자가 있을 때만 인용한다.
+     */
+    private propRef;
+    private resolvePropertyName;
+    private yamlKey;
+    private yamlValue;
+}
+
+/**
+ * DB 사이드카(`<db>.notion.json`) — `.base` 로 표현할 수 없는 Notion DB 메타데이터를
+ * 무손실 보존하는 단일 파일.
+ *
+ * ## 왜 필요한가 (I4·I7 "조용한 유실 금지")
+ *
+ * Obsidian Bases(`.base`)는 Notion DB 뷰의 일부만 표현한다:
+ *   · 미지원 뷰(calendar/timeline/form/chart/map/dashboard)는 `.base` 에서 통째 누락.
+ *   · 표현되는 뷰도 Notion **필터식·커버 크기/비율·컬럼 width/wrap·빈그룹 숨김** 등은
+ *     Bases 문법에 대응이 없어 손실된다.
+ *
+ * 사이드카는 DB 스키마의 원본이기도 하다(ADR-036, v2) — 새 루트로 올린 DB 폴더를 push 가 이것으로
+ * Notion DB 로 다시 만든다. 그래서 속성마다 다시 만드는 데 드는 설정(`definition`)과 인라인 여부를 적는다.
+ * v1(옵션 이름만)도 읽는다(`sync/database-schema.ts`). `.base` 와 같은 폴더에 두어 사람이 발견할 수 있고
+ * 도구가 다시 쓸 수 있다.
+ *
+ * ## 멱등성
+ *
+ * 매 pull 마다 재생성되므로 **결정적**이어야 한다(타임스탬프·실행시각 금지, 키 정렬).
+ * 동일 DB 상태 → 동일 바이트 → drift 0 / churn 0.
+ */
+/** 이 도구가 쓴 사이드카의 표지 — 읽는 쪽은 이 값으로 사용자가 만든 JSON 과 가린다. */
+declare const SIDECAR_GENERATOR = "im-nobsidian";
+/** 지금 쓰는 사이드카 형식 판. 판이 적히지 않은 옛 파일은 1 로 읽는다. */
+declare const SIDECAR_SCHEMA_VERSION = 2;
+interface NotionSidecar {
+    readonly generator: typeof SIDECAR_GENERATOR;
+    readonly schemaVersion: typeof SIDECAR_SCHEMA_VERSION;
+    readonly databaseId: string;
+    readonly databaseName: string;
+    /** 페이지 본문 안에 놓인 인라인 DB 인가 — 다시 만들 때 같게. */
+    readonly isInline: boolean;
+    /** 속성 스키마 — 이름 정렬. `.base` displayName 만으로는 잃는 타입/옵션을 보존. */
+    readonly properties: SidecarProperty[];
+    /** 모든 뷰(표현/미표현 공통) — Notion 순서 유지. */
+    readonly views: SidecarView[];
+    /** 정직한 손실 리포트 — 무엇이 `.base` 에서 누락/degrade 됐는가. */
+    readonly degraded: DegradeNote[];
+    /** DB 자체의 꾸밈 — 있는 것만. 없으면 키가 없다(꾸밈 없는 DB 의 사이드카는 예전과 같은 바이트). */
+    readonly appearance?: SidecarAppearance;
+}
+/**
+ * DB 의 아이콘 · 커버 · 설명 · 제목 표시. `icon` · `cover` 는 페이지 frontmatter 와 같은 꼴
+ * (`notion/decoration-values.ts`), `description` 은 NFM 한 줄.
+ */
+interface SidecarAppearance {
+    readonly icon?: string;
+    readonly cover?: string;
+    readonly description?: string;
+    /** 보기 위에 DB 제목을 숨겼으면 false. 보이면(기본) 없다. */
+    readonly showTitle?: false;
+}
+interface SidecarProperty {
+    readonly name: string;
+    readonly id: string;
+    readonly type: string;
+    /** select/multi_select/status 옵션명(있으면). */
+    readonly options?: string[];
+    /** 다시 만드는 데 드는 타입별 설정(`view/property-definition.ts`). 타입 이름만으로 되면 없다. */
+    readonly definition?: Readonly<Record<string, unknown>>;
+}
+interface SidecarView {
+    readonly id: string;
+    readonly name: string;
+    readonly notionType: string;
+    /** Bases 대응 타입. `null` = `.base` 미표현(사이드카가 유일 보존처). */
+    readonly basesType: BasesViewType | null;
+    /** 원본 뷰 설정 중 의미 있는 항목(키 정렬). 빈 값은 생략. */
+    readonly config: Record<string, unknown>;
+}
+interface DegradeNote {
+    readonly view: string;
+    /**
+     * `view-unrepresentable` = 뷰가 `.base` 에서 통째로 누락.
+     * `view-degraded` = 뷰는 남지만 다른 타입으로 격하(달력→표 등).
+     * `setting-dropped` = 뷰는 그대로지만 설정 하나가 빠짐.
+     */
+    readonly kind: "view-unrepresentable" | "view-degraded" | "setting-dropped";
+    readonly detail: string;
+}
+declare class SidecarGenerator {
+    /**
+     * 사이드카 객체를 빌드한다(순수 — I/O 없음). 직렬화는 {@link serialize} 가 담당.
+     */
+    build(options: {
+        databaseId: string;
+        databaseName: string;
+        schema: Record<string, BasePropertySchema>;
+        viewsConfig: DatabaseViewsConfig;
+        isInline?: boolean;
+        appearance?: SidecarAppearance;
+    }): NotionSidecar;
+    /**
+     * 사이드카를 결정적 JSON 문자열로 직렬화한다(키 재귀 정렬 + 말미 개행).
+     * 동일 입력 → 동일 바이트 → 멱등(drift/churn 0).
+     */
+    serialize(sidecar: NotionSidecar): string;
+    private buildProperties;
+    private buildView;
+    /**
+     * 뷰 설정 중 의미 있는 항목을 추출한다. `.base` 가 표현 못하는 항목(필터·커버크기 등)은
+     * config 에 보존하면서 동시에 degrade 리포트에 1줄씩 기록한다(표현되는 뷰에 한해 —
+     * 미표현 뷰는 이미 view-unrepresentable 로 통째 보고됨).
+     */
+    private extractConfig;
+    /**
+     * 필터 손실을 **실제로 못 옮긴 것만** 보고한다.
+     *
+     * 예전엔 필터가 있기만 하면 "Notion 필터식은 .base 로 표현되지 않음"을 무조건 찍었다.
+     * 이제 `.base` 가 뷰별 `filters:` 를 내보내므로 그 문구는 대부분의 경우 거짓이다.
+     * 거짓 degrade 는 진짜 degrade 를 묻어 버리므로, `.base` 와 **같은 번역기**를 돌려
+     * 남은 것만 적는다(두 산출물이 어긋날 여지를 없앤다).
+     */
+    private noteFilterDegrade;
+}
+
+/** 속성 하나를 어떻게 정했나. */
+interface InferredProperty {
+    readonly name: string;
+    readonly type: string;
+    /** 사람이 읽는 까닭 — `Obsidian 속성 타입 number` · `값 12개가 모두 날짜` … */
+    readonly reason: string;
+}
+interface FolderDatabaseDraft {
+    readonly sidecar: NotionSidecar;
+    readonly properties: readonly InferredProperty[];
+    /** 옮긴 보기 이름. */
+    readonly views: readonly string[];
+    /** 옮기지 않은 것과 까닭 — 키 · 보기 · 필터. */
+    readonly skipped: ReadonlyArray<{
+        readonly what: string;
+        readonly reason: string;
+    }>;
+}
+interface FolderDatabaseReport extends FolderDatabaseDraft {
+    readonly folder: string;
+    readonly sidecarPath: string;
+    readonly rows: number;
+}
+
+/**
+ * 한 오케스트레이터의 작업은 한 번에 하나만 돈다(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" | "prepare-database";
+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 readonly claimedPaths;
-    private static readonly DISCOVERY_RECURSIVE_BUDGET_MS;
+    /** DB 행 push 용 — DB 마다 스키마를 읽은 매퍼. 실행마다 비운다(S-01). */
+    private readonly rowSchemas;
+    private readonly observation;
+    private readonly placement;
+    private readonly databaseCreator;
+    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>;
+    /**
+     * 다른 연결 폴더 안의 노트를 추적하고 있으면 아무것도 하지 않고 멈춘다(ADR-038) — 그 노트들은 이 연결의
+     * 목록에 없으므로, 그대로 돌리면 「볼트에서 지움」 으로 보고 Notion 페이지를 지우거나 되살리려 한다.
+     */
+    private assertConnectionScope;
+    private executePush;
+    /**
+     * 만든 DB 에 relation · rollup · formula 를 붙이고, 행 스키마를 다시 읽게 한 뒤 보기를 만든다. 실패는
+     * 다음 push 가 이어 붙인다 — 행은 그대로 올린다.
+     */
+    private completeDatabaseSchemas;
+    /** 볼트의 노트가 마지막으로 올린 내용 그대로인가 — 읽지 못하면(지움 · 옮김) 아니다. */
+    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).
      *
@@ -1307,8 +2488,8 @@ declare class SyncOrchestrator {
      * 그렇게 침묵 유실됐다. 여기서만 "빠짐없다"를 본다.
      *
      * 대조 대상 database id 는 이 클래스가 조립한다: 설정에 적힌 것 + 디스커버리 캐시가
-     * 아는 것 + DB 모드의 루트 DB. `discovered_dbs` 메타 키를 아는 곳을 이 파일 하나로
-     * 유지해, 호출부(CLI·E2E)가 캐시 표현을 각자 다시 해석하지 않게 한다.
+     * 아는 것 + DB 모드의 루트 DB. 캐시 표현(`discovered_dbs` 메타 키)은 `discovered-databases.ts`
+     * 한 곳이 정하고 여기서 조립한다 — 호출부(CLI·E2E)가 그 표현을 각자 다시 해석하지 않게.
      *
      * 페이지(R12-C)는 pull 이 쓴 경로가 아니라 **search 열거**로 대조한다. 페이지는 열거
      * 경로가 둘이고 둘이 같은 집합을 내지 않는 게 애초의 결함이므로(R12-A), 독립된 두 번째
@@ -1321,210 +2502,45 @@ declare class SyncOrchestrator {
         modifiedPages: number;
         duration: number;
     }>;
-    /**
-     * @param options.fullRender 원격 본문을 pull 과 동일한 파이프라인으로 렌더할지.
-     *   기본(false)은 화면 미리보기용 경량 렌더 — 첨부를 내려받지 않으므로 `status` 처럼
-     *   읽기만 하는 경로가 쓴다. 볼트에 덮어쓸 본문이 필요한 해소 경로는 반드시 켠다.
-     */
-    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;
-    /**
-     * 노트에 박힌 로컬 미디어를 Notion 에 올린다(R1).
-     *
-     * 먼저 본문 자리표시자를 실제 image/file 블록으로 **제자리** 교체한다. 그러고도 남은
-     * 이미지만 페이지 끝에 덧붙이는 예전 경로로 흘린다 — 자리표시자가 없는 경우는 본문
-     * push 가 통째로 스킵됐을 때(pageHasLiveChildren) 정도이고, 그때도 이미지 자체는
-     * 올라가야 하므로 폴백을 남긴다.
-     */
-    private syncEmbeddedMedia;
-    private pushUpdate;
     /**
-     * 해소 대상 충돌 목록 — 원격 본문을 pull 과 **같은 파이프라인**으로 렌더해 담는다.
-     *
-     * 해소는 실제로 볼트 파일을 덮어쓰므로 `status()` 의 경량 미리보기 렌더를 쓰면 안 된다
-     * (프론트매터·첨부가 빠진 반쪽 본문이 덮인다). 반대로 전체 pull 을 먼저 돌려 목록을
-     * 얻는 것도 안 된다 — 해소하겠다고 볼트를 먼저 원격으로 덮어쓰는 셈이라 순서가 거꾸로다.
-     * 그래서 충돌 레코드만 좁혀 그 페이지들만 읽어 온다.
+     * 해소 대상 충돌 목록 — 원격 본문을 pull 과 같은 파이프라인으로 렌더해 담는다. 렌더가 첨부를 볼트에
+     * 내려받고 경로를 고르므로 다른 작업과 겹치지 않게 돌린다 — 도는 sync 와 같은 첨부 · 경로를 두고 다툰다.
      */
     listConflicts(): Promise<Conflict[]>;
     /**
-     * 추적 파일의 **현재 원격 본문**을 pull 과 같은 변환으로 렌더한다 — 표시 전용.
-     *
-     * 첨부는 내려받지 않는다: 비교를 보려다 볼트에 파일이 생기면 안 된다. 그 대가로 아직
-     * 내려받지 않은 미디어는 원격 URL 로 남아 비교 화면에만 차이로 보인다.
-     *
-     * @returns 추적되지 않았거나 원격 페이지가 없으면 null.
+     * 추적 파일의 현재 원격 본문을 pull 과 같은 변환으로 렌더한다 — 표시 전용이라 첨부를 내려받지
+     * 않는다. 추적되지 않았거나 원격 페이지가 없으면 null.
      */
     renderRemoteSnapshot(path: string): Promise<string | null>;
-    /**
-     * 해소할 게 남지 않은 충돌 레코드를 `synced` 로 되돌리고, 되돌린 경로를 반환한다.
-     *
-     * 충돌로 표시된 파일은 push 대상에서 통째로 빠진다(양쪽 덮어쓰기 방지). 그래서 사용자가
-     * 손으로 양쪽을 맞춰 둬 이미 같은 내용이 됐는데도 레코드만 남으면, 그 파일의 이후 편집이
-     * **영원히 Notion 에 올라가지 않는다** — 아무 경고 없이 정체된다. 내용이 이미 동일한
-     * 건만 골라 상태를 되돌린다(진짜 충돌은 손대지 않는다).
-     */
+    /** 로컬 변경 하나의 두 글 — 지난 동기화 때의 글과 지금 볼트의 글. 표시 전용이라 잠그지 않는다. */
+    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;
-    /**
-     * 추적 중(sync_state)인데 디스크에서 사라진 파일을 찾는다.
-     *
-     * 원격 변경 감지(detectRemoteChanges*)는 "Notion 에서 바뀐 것"만 본다. 로컬에서 파일이
-     * 지워진 경우는 어느 경로로도 잡히지 않아, 재pull 해도 `--force` 로도 되살아나지 않고
-     * 영구히 발산했다. push 는 deleteSync=false 면 원격을 지우지 않으므로 사용자에겐 복구
-     * 수단이 볼트 전체 초기화밖에 남지 않는다 — 이 스캔이 그 마지막 구멍을 막는다.
-     *
-     * 레코드마다 stat 을 던지면 1000건 규모에서 수 초가 든다. 볼트 워크 1회로 실재 목록을
-     * 만든 뒤 차집합을 취한다(md). md 가 아닌 추적 레코드는 수가 적어 개별 확인으로 남긴다.
-     *
-     * 로컬 이름변경·이동은 "사라짐" 과 구별해야 한다 — 되살리면 원본과 새 이름의 사본이
-     * 둘 다 남는다. push 의 detectMoves 와 같은 기준(내용 해시 일치)을 쓰되, 볼트 전체를
-     * 해시하지 않도록 크기가 같은 미추적 파일만 후보로 좁혀 확인한다.
-     */
-    private detectMissingLocalFiles;
-    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;
-    /**
-     * 원격 페이지를 **pull 과 동일한 파이프라인**으로 볼트에 쓸 수 있는 본문까지 렌더한다.
-     * (본문 변환 → 이미지/첨부 내려받기 → 속성 주입 → preserve marker → 압축형 간격 판정)
-     *
-     * pull 경로와 충돌 해소 경로가 이 한 곳을 공유해야 한다. 예전엔 충돌 목록만
-     * {@link fetchPageMarkdown} 원문을 그대로 담아, `nobsi resolve` 에서 "원격 유지"를 고르면
-     * 프론트매터도 첨부도 없는 반쪽 본문이 볼트에 덮여 썼다 — 해소가 곧 손실이었다.
-     *
-     * @returns 렌더된 본문과 함께, 호출자가 위키링크 레지스트리 등에 쓰는 제목·속성.
-     *          여기서 이미 읽은 값을 되돌려 줘야 호출자가 같은 페이지를 다시 파싱하지 않는다.
-     */
-    private renderRemotePage;
-    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;
-    /**
-     * 신규 pull 페이지가 쓸 파일 경로를 충돌 없이 결정하고 **그 자리에서 선점**한다.
-     *
-     * DB 행과 **같은 규칙**({@link pagePathCandidates})을 쓴다. 예전에는 `(1)`, `(2)` …
-     * 순번을 99 까지 훑고 고갈되면 **원본 경로를 그대로 돌려줬는데**, 그러면 남의 노트를
-     * 조용히 덮어써 내용이 사라진다. 순번은 그때의 볼트 상태로 정해져 실행마다 페이지끼리
-     * 접미사가 뒤바뀔 수도 있었다(pull 마다 파일이 갈아엎히는 churn).
-     *
-     * 점유 판정은 세 가지를 모두 본다:
-     *   · 이번 실행의 선점 장부 — 아래 참조.
-     *   · 추적 레코드 — 다른 페이지가 소유한 경로면 피하고, 자기 소유면 그대로 재사용한다.
-     *   · 볼트 파일 — 추적되지 않는 사용자 노트가 놓여 있으면 피한다.
+     * 로컬 변경 하나를 지난 동기화 때의 글로 되돌린다 — Git 의 `restore` 와 같다. Notion 은 건드리지
+     * 않는다. 되돌릴 원본이 없는 것은 이유와 함께 거절한다.
+     */
+    discardLocalChange(path: string): Promise<void>;
+    /**
+     * 볼트에서 만든 노트 폴더를 Notion DB 로 올릴 준비 — frontmatter · `.base` 로 사이드카를 써 둔다(#75).
+     * Notion 에는 쓰지 않는다. 다음 push 가 DB 를 만들고 노트를 행으로 올린다(ADR-036 · ADR-037).
      *
-     * 선점 장부가 필요한 이유는 pull 이 워커 풀로 **동시 실행**되기 때문이다. 조회와 기록
-     * 사이에 await 가 끼면 동명 페이지 여럿이 나란히 "비어 있음"을 보고 같은 경로를 고른다.
-     * 그러면 마지막에 쓴 페이지만 남고 나머지 본문이 사라진다(실측 재현: 동명 3페이지 →
-     * 파일 1개·레코드 1건). 그래서 마지막 확인과 등록을 **await 없는 동기 구간**에 묶는다 —
-     * 그 사이에는 다른 작업이 끼어들 수 없으므로 두 페이지가 같은 경로를 얻는 일이 없다.
-     */
-    private resolveUniqueFilePath;
+     * @param configDir Obsidian 설정 폴더 — 속성 타입(`types.json`)을 읽는다.
+     */
+    prepareFolderDatabase(folder: string, configDir?: string): Promise<FolderDatabaseReport>;
+    /** 충돌 미리보기용 줄 비교(로컬 vs 원격). 해소 없이 표시 전용. */
+    generateConflictDiff(conflict: Conflict): string;
 }
 
 interface PathFilterConfig {
@@ -1556,6 +2572,32 @@ 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;
@@ -1570,6 +2612,10 @@ interface ImageDownloadResult {
     readonly localPath: string;
     readonly hash: string;
     readonly size: number;
+    /** 받은 파일의 전체 sha256 — 받은 미디어 기록에 적어 push 가 그 파일이 그대로인지 본다. */
+    readonly fileHash?: string;
+    /** 임베드 별칭으로 쓸 이름 — 받은 이름에서 이 볼트가 붙인 내용 해시를 뗀 것({@link withoutOwnHash}). */
+    readonly name?: string;
 }
 interface ImageUploadResult {
     readonly localPath: string;
@@ -1578,11 +2624,23 @@ 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;
@@ -1600,6 +2658,7 @@ declare class ImageHandler {
     /** 상한 로직은 첨부 경로와 공유한다 — 한쪽만 빠뜨리지 않도록(utils/download-fetch). */
     private fetchForDownload;
     downloadImage(url: string, pageTitle: string): Promise<ImageDownloadResult>;
+    /** @param uploadedName Notion 에 올라간 파일 이름 — 받은 파일의 이름이 된다({@link imageStemOf}). */
     private fetchImage;
     /**
      * 캡션이 push 가 적어 둔 원본 임베드 대상인지 판정한다(R1). 맞으면 그 문자열을
@@ -1614,12 +2673,70 @@ declare class ImageHandler {
      */
     private resolveOriginalTarget;
     private persistImage;
-    downloadAllImages(markdown: string, pageTitle: string, pageId?: string, notePath?: string): Promise<{
+    /**
+     * 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[];
     }>;
     uploadLocalImage(localPath: string, noteFolder?: string): Promise<ImageUploadResult>;
+    /**
+     * 노트가 가리키는 볼트 첨부 하나를 올린다 — 파일 속성 값으로 보낼 것.
+     *
+     * @returns 보일 이름은 받을 때 붙인 내용 해시를 뗀 것이다 — 다시 받으면 같은 이름 · 같은 경로가 된다.
+     */
+    uploadNoteAttachment(target: string, notePath: string): Promise<UploadedFile>;
     uploadAndAppendImages(pageId: string, images: ImageReference[], notePath?: string): Promise<ImageUploadResult[]>;
+    /**
+     * 본문을 보내기 전에, 다시 올리지 않아도 되는 미디어 자리표시자를 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).
      *
@@ -1629,13 +2746,20 @@ declare class ImageHandler {
      * 텍스트로 새고 있었고 그중 964건(98.6%)이 이 미디어 쌍이었다. 사용자가 Notion 에서
      * 보는 화면이 깨질 뿐 아니라 이미지가 본문 흐름에서 이탈한다.
      *
-     * 캡션에는 원본 임베드 대상을 그대로 적는다. pull 이 경로(와 `|별칭`)를 되찾는
-     * 진실원이 되고, 사용자에게도 출처가 보인다.
+     * 캡션에는 사람이 적은 설명만 단다({@link captionOfEmbed}). 어느 임베드였는지는 Notion 이
+     * 그 파일을 저장한 id 와 함께 적어 두고({@link rememberUploadedMedia}), pull 이 그것으로
+     * 임베드를 되찾는다(S-05). 예전에는 캡션에 임베드 대상을 그대로 적어 Notion 에 경로 · 크기 ·
+     * 파일 이름이 보였다.
      *
      * 볼트에서 파일을 못 찾으면 자리표시자를 그대로 둔다 — 마커가 남아야 pull 이
      * 임베드를 복원할 수 있으므로, 반쯤 지우는 것보다 안전하다.
      */
-    materializeLocalMedia(pageId: string, pushedMarkdown: string, notePath?: string): Promise<MaterializeResult>;
+    materializeLocalMedia(pageId: string, pushedMarkdown: string, notePath?: string, kept?: readonly UploadedMedia[]): Promise<MaterializeResult>;
+    /**
+     * 방금 만든 미디어 블록의 파일을 Notion 이 저장한 id. 만든 응답에 파일 URL 이 실려 오고,
+     * 없으면 블록을 한 번 조회한다. 끝내 모르면 null — 던지지 않는다(블록은 이미 제자리에 있다).
+     */
+    private storedFileIdOf;
     /**
      * 페이지 블록 트리를 훑어 자리표시자를 부모와 함께 모은다. 콜아웃·토글·목록 안에
      * 들어간 임베드도 제자리 교체하려면 부모 id 가 필요하다(append 의 after_block 은
@@ -1648,6 +2772,17 @@ declare class ImageHandler {
      * 재업로드하는 중복을 공유 레지스트리로 차단한다.
      */
     private registerUploads;
+    /**
+     * 올린 미디어를 임베드와 함께 적어 둔다(S-05). 적지 못해도 push 는 깨뜨리지 않는다 — 블록은
+     * 이미 제자리에 있고, 다음 pull 이 그 파일을 알아보지 못해 사본을 받을 뿐이다.
+     */
+    private rememberUploads;
+    /**
+     * 받은 미디어를 그 페이지의 미디어 기록에 더한다 — 그 노트를 고쳐 push 할 때 Notion 의 원래 블록을
+     * 둔다({@link keepUploadedMedia}). 적지 못해도 pull 은 깨뜨리지 않는다 — 그 노트를 push 하면 예전처럼
+     * 다시 올릴 뿐이다.
+     */
+    private rememberReceived;
     /**
      * 임베드 경로가 가리킬 수 있는 볼트 실제 파일 후보를 우선순위대로 만든다(F23).
      * Obsidian 위키링크 임베드는 노트 옆 파일을 파일명만으로 참조하는 게 관례라
@@ -1664,7 +2799,7 @@ declare class ImageHandler {
      * 폴백은 조용히 진행하고, 전부 실패했을 때만 마지막 오류를 던진다.
      */
     private readImageFromVault;
-    downloadAllFiles(markdown: string, pageTitle: string, notePath?: string): Promise<{
+    downloadAllFiles(markdown: string, pageTitle: string, pageId?: string): Promise<{
         content: string;
         downloads: ImageDownloadResult[];
     }>;
@@ -1743,10 +2878,15 @@ declare class FileHandler {
      */
     private pushSingleFile;
     /**
-     * 업로드 후보 목록 — 도구 내부 산출물(`.base`/`.notion.json`)은 제외한다.
-     * node 측 VaultFS 는 과거 `.base` 를 워커에서 빼는 식으로 우회했지만, Obsidian
-     * 어댑터는 모든 파일을 반환하므로 플러그인 push 가 사이드카를 Notion 첨부로
-     * 오염시켰다. 소비자인 여기서 일괄 차단해 구현체 간 동작을 통일한다.
+     * 업로드 후보 목록 — 도구 내부 산출물(`.base`/`.notion.json`)은 아예 빼고, Notion 이 받지 않는
+     * 형식은 따로 모은다.
+     *
+     * 내부 산출물: node 측 VaultFS 는 과거 `.base` 를 워커에서 빼는 식으로 우회했지만, Obsidian
+     * 어댑터는 모든 파일을 반환하므로 플러그인 push 가 사이드카를 Notion 첨부로 오염시켰다.
+     * 소비자인 여기서 일괄 차단해 구현체 간 동작을 통일한다.
+     *
+     * 받지 않는 형식(S-14): 올리면 업로드를 만들 때 400 으로 거절된다. 등록되지 않으니 push 할
+     * 때마다 같은 요청을 다시 보내 같은 이유로 실패했다(실볼트 `.ipynb` 22개).
      */
     private listUploadableFiles;
     pushAllFiles(): Promise<FileUploadResult[]>;
@@ -1771,17 +2911,112 @@ 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[];
     /**
@@ -1797,6 +3032,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;
@@ -1804,23 +3055,54 @@ declare class DatabaseSyncer {
     private readonly vaultFs;
     private readonly pipeline;
     private readonly imageHandler;
+    /**
+     * 이번 동기화가 원격을 보는 기준(N-05) — 오케스트레이터가 실행마다 정한다. 따로 쓰면(시험)
+     * 아무것도 가라앉았다고 보지 않는다 — 수정 시각이 같은 행도 받아서 견준다.
+     */
+    private readonly observation;
+    /**
+     * 받은 행 본문(Notion 원문)을 알린다 — 감지가 행의 하위 페이지를 빠뜨렸을 때 그 본문의 자식 태그로
+     * 채운다({@link RemoteDetector.noteBodyChildren}).
+     */
+    private readonly noteRowBody;
     private readonly propertyMapper;
+    private decorationsCache?;
+    /**
+     * 받은 DB 마다 사이드카에 적을 꾸밈 — 한 pull 이 같은 DB 의 사이드카를 여러 번 다시 만든다(임베드 재작성).
+     * 올린 파일 아이콘 · 커버를 그때마다 내려받지 않는다.
+     */
+    private readonly appearances;
     private readonly baseFileGenerator;
+    /** 사용자가 만든 `.base` 라 덮어쓰지 않았다고 이미 알린 경로 — 한 pull 이 같은 DB 를 여러 번 다시 쓴다. */
+    private readonly keptUserBases;
     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;
+    private get decorations();
+    constructor(config: Config, stateDb: IStateDB, notionClient: NotionClient, vaultFs: VaultFS, pipeline: ConversionPipeline, imageHandler: ImageHandler, 
+    /**
+     * 이번 동기화가 원격을 보는 기준(N-05) — 오케스트레이터가 실행마다 정한다. 따로 쓰면(시험)
+     * 아무것도 가라앉았다고 보지 않는다 — 수정 시각이 같은 행도 받아서 견준다.
+     */
+    observation?: () => ObservationContext, 
+    /**
+     * 받은 행 본문(Notion 원문)을 알린다 — 감지가 행의 하위 페이지를 빠뜨렸을 때 그 본문의 자식 태그로
+     * 채운다({@link RemoteDetector.noteBodyChildren}).
+     */
+    noteRowBody?: (pageId: string, rawMarkdown: string) => void);
+    pullAll(opts?: {
+        readonly paths?: readonly string[];
+        readonly progress?: RowProgress;
+        /** 조회할 DB 와 DB 마다의 결과(ADR-027). 없으면 모든 DB 를 조회한다. */
+        readonly ledger?: DatabasePullLedger;
+        /** 취소하면 다음 DB 를 조회하지 않는다 — 닿지 못한 DB 는 다음 pull 이 조회한다. */
+        readonly signal?: AbortLike;
+        /** {@link pullDatabase} 의 같은 이름 옵션. */
+        readonly rescanRowChildren?: boolean;
+    }): Promise<DatabaseSyncResult>;
     pullDatabase(dbConfig: DatabaseSyncConfig, opts?: {
         /**
          * F25: database id(하이픈 유무 무관) → 그 DB 행이 사는 로컬 폴더. 디스커버리 캐시가
@@ -1828,9 +3110,126 @@ declare class DatabaseSyncer {
          * 경우에만 행 소유를 양보한다 — 원본이 미발견이면 이 컨테이너가 유일한 접근 통로다.
          */
         resolveDbFolder?: (databaseId: string) => string | null;
+        /**
+         * 이 범위의 행만 받고 지운다(`pull --path` · 변경 패널의 항목별 받기). 없으면 모든 행.
+         * 새 행은 DB 폴더 전체가 범위일 때만 만든다 — 받기 전에는 어느 경로에 쓸지 모른다.
+         */
+        paths?: readonly string[];
+        /** 받은 행 · 지운 행을 하나씩 알린다. 예전에는 pull 진행 표시에 행이 하나도 보이지 않았다. */
+        progress?: RowProgress;
+        /**
+         * `--force` — 그대로라 받지 않는 행도 본문을 읽어 하위 페이지를 알린다({@link noteRowBody}). 감지가 빠뜨린
+         * 행의 하위 페이지는 행 본문으로만 보이는데, 이미 받은 행은 바뀌기 전까지 본문을 다시 읽지 않는다.
+         * 행 파일은 쓰지 않는다.
+         */
+        rescanRowChildren?: boolean;
     }): Promise<DatabaseSyncResult>;
+    /**
+     * 받지 않는 행의 본문을 읽어 하위 페이지만 알린다(`--force`). 읽지 못한 행은 경고만 남긴다 — 그 행은 받을 것이
+     * 없었고, 하위 페이지는 다음 `--force` 가 다시 찾는다.
+     */
+    private noteUnchangedRowBodies;
+    /**
+     * 받을 행을 세기만 한다(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;
+    /**
+     * DB 의 보기를 Notion 에서 다시 읽어 `db-views.json` 에 적는다. DB 를 통째로 받을 때(행이 바뀐 DB · 전체 대조)
+     * 마다 부른다 — 보기만 고친 것은 DB 의 수정 시각을 바꾸지 않아(2026-10-23 실측) 다음 전체 대조가 받는다.
+     * 예전에는 처음 받은 보기를 끝까지 썼다 — Notion 에서 더하거나 고친 보기가 `.base` 에 오지 않았다.
+     * 읽지 못하면 받아 둔 보기를 쓴다 — 보기가 빠진 `.base` 를 쓰지 않는다.
+     */
     private pullDatabaseViews;
+    /** 행들 가운데 한 번이라도 기간인 날짜 속성 → 그 짝 키. */
+    private rangeEndsOf;
     private generateBaseFile;
+    /**
+     * DB 의 아이콘 · 커버 · 설명 · 제목 표시 — push 가 DB 를 다시 만들 때 쓴다(ADR-036). 아이콘 · 커버는 페이지와
+     * 같은 꼴로 적고 올린 파일은 볼트로 내려받는다 — 서명 주소를 적으면 pull 마다 사이드카가 바뀐다.
+     */
+    private appearanceOf;
+    private readAppearance;
+    /** pull 이 쓰지 않은 `.base` · 사이드카가 이미 있는가 — 없거나 읽지 못하면 false. */
+    private isUserFile;
     /**
      * DB 제목이 바뀌면 `.base`/`.notion.json` 파일명(safeName)이 바뀌어 옛 이름의 산출물이
      * 같은 폴더에 고아로 잔존한다(drift·부활 원인). DB 폴더 **직속**의 산출물 중 현재 이름이
@@ -1852,119 +3251,51 @@ 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) — 제목과 보낼 수 있는 속성, 아이콘 · 커버.
+     * push 는 원격을 덮어써도 되는지, pull 은 받을
+     * 것이 있는지를 이 규칙으로 가른다. 읽기 전용 속성(수식 · 롤업 · 수정 시각)은 보지 않는다 —
+     * 로컬에서 고칠 수 없고 push 가 보내지 않는다.
+     *
+     * @param mapper 그 행의 DB 스키마를 읽은 매퍼.
+     * @param base 지난 동기화 시점의 frontmatter.
+     * @param path 지난 동기화 시점의 경로 — 파일 이름을 따르던 제목을 가른다.
+     */
+    rowOutsideBodyUnchanged(mapper: PropertyMapper, page: PageObjectResponse, base: Readonly<Record<string, unknown>>, path: string): boolean;
+    /** 레코드가 지난번에 본 원격 행과 지금 행을 견준다 — 이번 동기화의 기준으로(N-05). */
+    private remoteVerdict;
+    /**
+     * 행 경로 후보의 주인 — 상태 DB 의 레코드, 없으면 볼트에 이미 있는 파일(주인 모름). 추적하지 않는 로컬 파일
+     * (아직 push 하지 않은 노트)을 새 행이 덮어쓰면 그 글이 사라졌다. 일반 페이지 받기(`claimFilePath`)처럼 피한다.
+     */
+    private rowPathOwners;
     private pullDatabasePage;
-    private pushDatabase;
-    /**
-     * db-row 파일 1건을 Notion 으로 밀어 올린다 — 생성·갱신·rename 재매핑·스킵을 모두 담당.
-     *
-     * 호출부의 루프에서 떼어낸 이유는 상한(`withDeadline`)을 걸 단위가 필요해서다(R9e).
-     * 그래서 결과는 카운터를 직접 건드리지 않고 {@link PushRowOutcome} 으로 돌려준다 —
-     * 상한에 걸린 행이 카운터를 절반만 올린 채 끊기는 일이 구조적으로 불가능해진다.
-     *
-     * 본문 push 실패만 `failed` 를 **반환**하고 나머지 예외는 그대로 던진다. 둘의 차이는
-     * 상태 처리에 있다: 전자는 레코드를 `error` 로 내려 해시 전진을 막아야 하므로 여기서
-     * 처리하고, 후자는 호출부의 catch 가 일괄 기록한다(기존 동작 그대로).
-     */
-    private pushDatabaseRow;
-    /**
-     * 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 {
@@ -1994,6 +3325,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;
@@ -2004,6 +3357,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 {
@@ -2018,6 +3375,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;
@@ -2025,7 +3396,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 를
@@ -2044,7 +3415,7 @@ declare class PropertiesTableInjector implements Processor {
  */
 declare class InlineAnnotationPreserver implements Processor {
     readonly name = "InlineAnnotationPreserver";
-    readonly order = 5;
+    readonly order = 13;
     process(input: ProcessorInput): ProcessorOutput;
 }
 
@@ -2110,6 +3481,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;
 }
@@ -2200,13 +3578,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;
@@ -2217,10 +3601,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;
@@ -2228,6 +3628,7 @@ declare class WatchSyncService {
     private scheduleSync;
     private clearDebounce;
     private executeSync;
+    private runBatch;
 }
 
 interface DBEntry {
@@ -2275,6 +3676,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[]>;
@@ -2292,79 +3694,6 @@ declare class EntryEditor {
     updateDate(entryPath: string, dateProperty: string, newDate: string): Promise<void>;
 }
 
-interface BaseFileOptions {
-    readonly databaseId: string;
-    readonly databaseName: string;
-    readonly schema: Record<string, BasePropertySchema>;
-    readonly viewsConfig: DatabaseViewsConfig;
-    readonly folderPath: string;
-}
-type BasesViewType = "table" | "cards" | "list";
-/** Notion 뷰 하나를 Bases 로 옮길 때의 판정. */
-interface BasesViewMapping {
-    /** Bases 뷰 타입. `null` = 대응이 없어 `.base` 에 실을 수 없음. */
-    readonly type: BasesViewType | null;
-    /**
-     * 값이 있으면 **정확한 대응이 아니라 격하**라는 뜻(사람용 사유).
-     * 뷰 자체는 살아남지만 원래 뷰의 표현 일부(달력 격자·타임라인 축)는 재현되지 않는다.
-     */
-    readonly degradeReason?: string;
-}
-/**
- * Notion 뷰 타입 → Obsidian Bases 뷰 매핑(SSOT).
- *
- * 뷰는 현재 pull-authoritative — Notion API 가 2026-03-19 뷰 생성/수정/삭제를 열었지만
- * 본 프로젝트는 아직 뷰 write-back 을 구현하지 않았다(로드맵 항목). push 로 되돌릴 수
- * 없는 동안 "조용한 유실 금지"는 곧 "보존 + 정직한 degrade 리포트"를 의미한다.
- *
- * 달력·타임라인은 예전에 `null` 이었다 — 즉 `.base` 에서 **통째로 사라졌다**. 사이드카에는
- * 남지만 Obsidian 을 여는 사람 눈에는 그 뷰가 애초에 없었던 것처럼 보인다. 격자·축은
- * 못 살려도 "날짜 순으로 늘어놓은 목록"이라는 본래 의도는 표로 남길 수 있으므로,
- * 버리는 대신 격하해 살리고 사유를 사이드카에 적는다.
- */
-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 {
-    generate(options: BaseFileOptions): string;
-    private writeFilters;
-    private needsContentCoverFormula;
-    private writeFormulas;
-    private writePropertyDisplayNames;
-    private writeViews;
-    /** `filters:` 키와 그 값을 쓴다. 단일 식이면 한 줄, 그룹이면 블록. */
-    private writeFilterValue;
-    /** 필터 노드를 시퀀스 항목(`- …`)으로 쓴다. 그룹이면 재귀적으로 중첩한다. */
-    private writeFilterItem;
-    /**
-     * 필터 식을 YAML 스칼라로 쓴다.
-     *
-     * 식은 대개 `note["상태"] == "진행 중"` 처럼 큰따옴표를 품는다. 평문 스칼라는 큰따옴표를
-     * 안에 담을 수 있으므로(선두만 아니면 된다) 기본은 평문으로 두어 기존 `file.ext == "md"`
-     * 라인과 모양을 맞춘다. 다만 `: `·` #`·선두 지시문자는 평문에서 의미가 달라지므로
-     * 그때만 작은따옴표로 감싼다(속성명에 콜론이나 해시가 들어갈 수 있다).
-     */
-    private yamlExpr;
-    /**
-     * 뷰 이름을 Bases 요구사항대로 유일화한다(in-place). 동명 충돌 시 ' 2',' 3'… 를 붙이되
-     * 이미 존재하는 이름과 다시 충돌하지 않을 때까지 증가시킨다.
-     */
-    private dedupeViewNames;
-    private convertView;
-    private toNoteRef;
-    /**
-     * 속성 참조(order/sort/groupBy/image)를 YAML로 안전하게 출력한다.
-     * `file.name`·`formula.coverImage`·`note.cover` 같은 접두사 식별자와 공백 포함 일반 속성명은
-     * 평문 스칼라로 안전하므로 그대로 두고, 콜론·해시·따옴표 등 YAML 메타문자가 있을 때만 인용한다.
-     */
-    private propRef;
-    private resolvePropertyName;
-    private yamlKey;
-    private yamlValue;
-}
-
 /**
  * 속성 id → 프론트매터 키 해소.
  *
@@ -2427,99 +3756,6 @@ type PropertyNameResolver = (idOrName: string) => string | undefined;
  */
 declare function translateNotionFilter(filter: unknown, schema: Record<string, BasePropertySchema>, resolveName: PropertyNameResolver): TranslationResult;
 
-/**
- * DB 사이드카(`<db>.notion.json`) — `.base` 로 표현할 수 없는 Notion DB 메타데이터를
- * 무손실 보존하는 단일 파일.
- *
- * ## 왜 필요한가 (I4·I7 "조용한 유실 금지")
- *
- * Obsidian Bases(`.base`)는 Notion DB 뷰의 일부만 표현한다:
- *   · 미지원 뷰(calendar/timeline/form/chart/map/dashboard)는 `.base` 에서 통째 누락.
- *   · 표현되는 뷰도 Notion **필터식·커버 크기/비율·컬럼 width/wrap·빈그룹 숨김** 등은
- *     Bases 문법에 대응이 없어 손실된다.
- *
- * Notion API 는 뷰 생성/수정을 지원하지 않으므로(뷰는 pull-authoritative) 이 메타데이터는
- * push 로 Notion 에 되돌릴 수 없다. 따라서 "무손실"의 의미는 **로컬에 완전·정직하게
- * 보존하고, 무엇이 degrade 됐는지 명시 리포트**하는 것이다. 사이드카는 이를 `.base` 와
- * 같은 폴더에 co-locate 해 사람이 발견 가능하고 도구가 재사용 가능하게 만든다.
- *
- * ## 멱등성
- *
- * 매 pull 마다 재생성되므로 **결정적**이어야 한다(타임스탬프·실행시각 금지, 키 정렬).
- * 동일 DB 상태 → 동일 바이트 → drift 0 / churn 0.
- */
-interface NotionSidecar {
-    readonly generator: "im-nobsidian";
-    readonly schemaVersion: 1;
-    readonly databaseId: string;
-    readonly databaseName: string;
-    /** 속성 스키마 — 이름 정렬. `.base` displayName 만으로는 잃는 타입/옵션을 보존. */
-    readonly properties: SidecarProperty[];
-    /** 모든 뷰(표현/미표현 공통) — Notion 순서 유지. */
-    readonly views: SidecarView[];
-    /** 정직한 손실 리포트 — 무엇이 `.base` 에서 누락/degrade 됐는가. */
-    readonly degraded: DegradeNote[];
-}
-interface SidecarProperty {
-    readonly name: string;
-    readonly id: string;
-    readonly type: string;
-    /** select/multi_select/status 옵션명(있으면). */
-    readonly options?: string[];
-}
-interface SidecarView {
-    readonly id: string;
-    readonly name: string;
-    readonly notionType: string;
-    /** Bases 대응 타입. `null` = `.base` 미표현(사이드카가 유일 보존처). */
-    readonly basesType: BasesViewType | null;
-    /** 원본 뷰 설정 중 의미 있는 항목(키 정렬). 빈 값은 생략. */
-    readonly config: Record<string, unknown>;
-}
-interface DegradeNote {
-    readonly view: string;
-    /**
-     * `view-unrepresentable` = 뷰가 `.base` 에서 통째로 누락.
-     * `view-degraded` = 뷰는 남지만 다른 타입으로 격하(달력→표 등).
-     * `setting-dropped` = 뷰는 그대로지만 설정 하나가 빠짐.
-     */
-    readonly kind: "view-unrepresentable" | "view-degraded" | "setting-dropped";
-    readonly detail: string;
-}
-declare class SidecarGenerator {
-    /**
-     * 사이드카 객체를 빌드한다(순수 — I/O 없음). 직렬화는 {@link serialize} 가 담당.
-     */
-    build(options: {
-        databaseId: string;
-        databaseName: string;
-        schema: Record<string, BasePropertySchema>;
-        viewsConfig: DatabaseViewsConfig;
-    }): NotionSidecar;
-    /**
-     * 사이드카를 결정적 JSON 문자열로 직렬화한다(키 재귀 정렬 + 말미 개행).
-     * 동일 입력 → 동일 바이트 → 멱등(drift/churn 0).
-     */
-    serialize(sidecar: NotionSidecar): string;
-    private buildProperties;
-    private buildView;
-    /**
-     * 뷰 설정 중 의미 있는 항목을 추출한다. `.base` 가 표현 못하는 항목(필터·커버크기 등)은
-     * config 에 보존하면서 동시에 degrade 리포트에 1줄씩 기록한다(표현되는 뷰에 한해 —
-     * 미표현 뷰는 이미 view-unrepresentable 로 통째 보고됨).
-     */
-    private extractConfig;
-    /**
-     * 필터 손실을 **실제로 못 옮긴 것만** 보고한다.
-     *
-     * 예전엔 필터가 있기만 하면 "Notion 필터식은 .base 로 표현되지 않음"을 무조건 찍었다.
-     * 이제 `.base` 가 뷰별 `filters:` 를 내보내므로 그 문구는 대부분의 경우 거짓이다.
-     * 거짓 degrade 는 진짜 degrade 를 묻어 버리므로, `.base` 와 **같은 번역기**를 돌려
-     * 남은 것만 적는다(두 산출물이 어긋날 여지를 없앤다).
-     */
-    private noteFilterDegrade;
-}
-
 declare function sortEntries(entries: DBEntry[], sorts: NonNullable<ViewConfig["sorts"]>): DBEntry[];
 declare function groupEntries(entries: DBEntry[], groupByProperty: string, options?: {
     sort?: "ascending" | "descending";
@@ -2540,6 +3776,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;
@@ -2621,20 +3859,6 @@ declare function summarizeFidelity(perFile: ReadonlyArray<{
     classification: FidelityClassification;
 }>): FidelitySummary;
 
-/**
- * 렌더 감사 — "볼트에 쓰인 마크다운이 Obsidian 에서 깨져 보이는가"를 코드로 고정한다.
- *
- * {@link classifyBodyFidelity} 가 **내용이 남았는가**를 보고 {@link verifyPageCompleteness}
- * 가 **빠짐없이 왔는가**를 본다면, 여기는 **사람 눈에 어떻게 보이는가**를 본다. 셋은 서로의
- * 사각지대를 맡는다 — 실제로 이 트랙의 결함은 내용도 다 있고 개수도 맞는데 콜아웃이
- * 코드블록으로 오파싱되거나 표 구분행만 덩그러니 남는 형태였다.
- *
- * 원본 대조가 필요 없는 것만 담는다. 한 파일만 보고 판정할 수 있어야 동기화 하니스가
- * 볼트를 훑는 데 쓸 수 있다. 원본 NFM 과 견주는 지표(구조 드리프트·코드블록 경계)는
- * 회귀 코퍼스를 쥔 테스트 쪽에 남는다.
- *
- * 규칙 번호(①~⑧)는 트랙 초기 실측 조사에서 붙인 결함 분류를 그대로 잇는다.
- */
 /** 한 줄만 보고 판정할 수 있는 렌더 결함. */
 interface RenderLineRule {
     readonly code: string;
@@ -2663,16 +3887,43 @@ 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` 범위 판정 — 볼트 상대경로가 사용자가 지정한 범위 안에 있는지.
  *
@@ -2691,6 +3942,48 @@ 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;
@@ -2700,6 +3993,84 @@ interface Logger {
 declare function setLogger(logger: Logger): void;
 declare function getLogger(): Logger;
 
+/**
+ * 볼트 하나에 연결 여럿 (ADR-038) — 연결마다 볼트 안의 폴더 하나를 맡는다.
+ *
+ * 연결 폴더는 자기 `.im-nobsidian/`(설정 · 상태 DB · 보기 설정)를 둔다. 엔진은 그 폴더를 볼트처럼 다루고
+ * ({@link ScopedVaultFS}), 바깥 연결은 안쪽 연결 폴더를 읽어 올리지도 쓰지도 않는다. 볼트 맨 위의 연결은
+ * 폴더 `""` 이다 — 예전부터 쓰던 단일 연결이 그대로 그것이다.
+ */
+
+/** 이 연결이 맡지 않은 곳에 쓰려 했다 — 폴더 밖이거나 다른 연결 폴더 안이다. */
+declare class ConnectionBoundaryError extends Error {
+    readonly path: string;
+    readonly folder: string;
+    readonly where: "inside" | "outside";
+    /**
+     * @param folder 막은 연결 폴더 — `inside` 면 안쪽의 다른 연결, `outside` 면 이 연결.
+     */
+    constructor(path: string, folder: string, where: "inside" | "outside");
+}
+/**
+ * 이 연결의 상태 DB 가 다른 연결 폴더 안의 노트를 추적하고 있다 — 이미 동기화하던 폴더를 따로 연결했다.
+ *
+ * 그대로 돌리면 바깥 연결은 그 노트들을 「볼트에서 지움」 으로 보고(목록에 없으므로) Notion 페이지를 지우거나,
+ * 되살리려고 그 폴더에 쓰려 한다. 둘 다 사용자가 바란 것이 아니므로 아무것도 하지 않고 멈춘다.
+ */
+declare class ConnectionScopeError extends Error {
+    readonly paths: readonly string[];
+    constructor(paths: readonly string[]);
+}
+/** 앞뒤 `/` 를 떼고 `.` · `..` 를 푼 POSIX 경로. 볼트 맨 위를 벗어나면 null. */
+declare function normalizeVaultPath(path: string): string | null;
+/** `path` 를 맡은 연결 폴더 — 가장 깊은 것. 어느 것도 아니면 null(`""` 연결이 있으면 그것). */
+declare function connectionFolderOf(path: string, folders: readonly string[]): string | null;
+/** 한 연결 폴더에서 Obsidian 설정 폴더까지의 상대 경로 — `Work/Team` 이면 `../../.obsidian`. */
+declare function configDirFrom(folder: string, configDir: string): string;
+/**
+ * 볼트의 한 연결 폴더를 볼트처럼 보이는 VaultFS. 경로는 그 폴더 기준이다.
+ *
+ * - 목록은 폴더 안 · 안쪽 연결 폴더 밖의 파일만, 이 연결의 내부 폴더(`.im-nobsidian/`)는 빼고 낸다
+ * - 쓰기(쓰기 · 지우기 · 옮기기 · 폴더 만들기)는 폴더를 벗어나거나 안쪽 연결 폴더에 닿으면
+ *   {@link ConnectionBoundaryError} 로 거절한다 — pull 이 다른 연결의 노트를 덮어쓰지 않는다
+ * - 읽기는 볼트 안이면 폴더 밖도 된다(`../.obsidian/types.json` — Obsidian 설정은 볼트 맨 위에 하나다)
+ */
+declare class ScopedVaultFS implements VaultFS {
+    private readonly base;
+    private readonly folder;
+    private readonly nested;
+    /**
+     * @param folder 이 연결의 폴더(볼트 상대). `""` 이면 볼트 맨 위.
+     * @param connections 볼트의 연결 폴더 전부 — 이 폴더 안쪽 것만 골라 비켜 간다.
+     */
+    constructor(base: VaultFS, folder: string, connections: readonly string[]);
+    ownsPath(path: string): boolean;
+    /** 이 연결의 경로 → 볼트 경로. */
+    private toBase;
+    /** 볼트 경로 → 이 연결의 경로. 이 연결이 맡지 않으면 null. */
+    private fromBase;
+    readFile(path: string): Promise<string>;
+    readBinary(path: string): Promise<Buffer>;
+    writeFile(path: string, content: string): Promise<void>;
+    writeBinary(path: string, data: Buffer): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    moveFile(from: string, to: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    ensureFolder(path: string): Promise<void>;
+    /** 맡은 노트만 읽는다 — 볼트 전체의 본문을 읽지 않는다. */
+    listMarkdownFiles(): Promise<FileInfo[]>;
+    listMarkdownFileStats(): Promise<FileStatInfo[]>;
+    listNonMarkdownFiles(): Promise<NonMdFileInfo[]>;
+    getFileStat(path: string): Promise<FileStatInfo | null>;
+    private rebase;
+}
+
+/**
+ * 볼트의 연결 폴더(ADR-038) — 자기 `.im-nobsidian/` 를 둔 폴더. 볼트 맨 위(`""`)는 그 폴더가 있으면 든다.
+ * 점으로 시작하는 폴더(`.obsidian` · `.git` · `.trash` 등)는 들여다보지 않는다 — 노트 목록도 그렇게 걷는다.
+ */
+declare function findConnectionFolders(vaultRoot: string): Promise<string[]>;
+
 interface PipelineOptions {
     readonly wikilinkResolver?: WikilinkResolverFn;
 }
@@ -2729,6 +4100,8 @@ declare const DB_VIEWS_PATH = ".im-nobsidian/db-views.json";
 declare const STATE_DB_PATH = ".im-nobsidian/sync.db";
 /** 파일 감시에서 제외할 내부 디렉터리 glob. */
 declare const INTERNAL_DIR_GLOB = "**/.im-nobsidian/**";
+/** Obsidian 설정 폴더 기본 이름(볼트 맨 위). 사용자가 바꿀 수 있어 플러그인은 `vault.configDir` 를 쓴다. */
+declare const OBSIDIAN_CONFIG_DIR = ".obsidian";
 /**
  * 주어진 vault 상대 경로(POSIX)가 내부 메타데이터 디렉터리에 속하는지 판별한다.
  */
@@ -2748,4 +4121,109 @@ declare function isInternalPath(path: string): boolean;
 /** 모든 보존 마커가 공유하는 브랜드 토큰. */
 declare const MARKER_BRAND = "im-nobsidian";
 
-export { BaseFileGenerator, type BaseFileOptions, type BasePropertyOption, type BasePropertySchema, type BaseStatusGroup, type BaseSyncOptions, type BasesFilterNode, type BasesViewMapping, type BasesViewType, BlockConverter, CONFIG_FILE, type CalendarEntry, CalloutRestorer, CalloutTransformer, ChangeDetector, 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, type DatabaseCompleteness, 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 PageCompletenessRemoteSource, type PageCompletenessReport, 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, RENDER_LINE_RULES, type RecordPendingInput, type RegisterFileInput, type RemoteChange, type RenderFinding, type RenderLineRule, type ResolutionChoice, type ResolutionResult, type RichTextSegment, SEPARATOR_BODY, 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, type TranslationResult, TreeMapper, UnsupportedBlockStripper, type UpsertSyncRecord, type VaultCompletenessReport, type VaultFS, type ViewConfig, ViewDataProvider, type ViewPropertyConfig, type ViewRenderData, type ViewType, type WatchSyncOptions, WatchSyncService, type WikilinkEntry, WikilinkResolver, basesViewMappingOf, basesViewTypeOf, classifyBodyFidelity, compactNotionId, computeBufferHash, computeHash, createDefaultPipeline, extractCalendarEntries, filterByMonth, filterEntries, generateColorCSS, generateId, getLogger, getNotionBgColor, getNotionColor, getVisibleProperties, groupEntries, inAnyPathScope, isInternalPath, lintRenderedMarkdown, matchesPathScope, normalizeNotionId, notionIdsEqual, resolvePropertyName, sanitizeFileName, setLogger, sortEntries, summarizeFidelity, threeWayMerge, translateNotionFilter, verifyDatabaseCompleteness, verifyPageCompleteness };
+/**
+ * 디자인 마커 읽기 — 볼트 노트 한 줄에 실린 마커가 «무엇을 어디에» 칠하는지 (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;
+
+/**
+ * Notion 컬럼이 볼트 노트의 어느 줄에 걸치나 (#74).
+ *
+ * pull 은 컬럼을 위아래로 펼치고 경계를 마커 줄로 남긴다(ADR-008) — `column-list:start` · 열마다
+ * `column[:ratio=N]` · `column-list:end`. Obsidian 은 마크다운을 옆으로 나란히 그리지 못하므로, 플러그인은
+ * 이 결과로 열의 경계를 보이게 칠한다. 마커 모양의 주인이 이 패키지라 읽기도 여기 둔다.
+ *
+ * 컨테이너(콜아웃 · 토글) 안의 컬럼은 pull 이 마커를 지우고 펼친다 — 마커 줄은 맨 앞 들여쓰기만 받는다.
+ */
+/** 컬럼 마커가 있을 수 있는가 — 없으면 줄을 나누어 읽지 않아도 된다. */
+declare function hasColumnLayout(text: string): boolean;
+/** 컬럼 안의 줄 하나가 놓인 자리. */
+interface ColumnPlace {
+    /** 노트 안에서 몇 번째 컬럼 묶음인가 — 0 부터. */
+    readonly group: number;
+    /** 묶음 안에서 몇 번째 열인가 — 0 부터. */
+    readonly index: number;
+    /** 묶음의 열 수. */
+    readonly count: number;
+    /** 열 너비(%) — Notion 이 비율을 주지 않았으면 undefined. */
+    readonly ratio?: number;
+    /** 이 열의 첫 줄인가 — 열 구분 마커 줄이다. */
+    readonly head: boolean;
+}
+/**
+ * 줄마다 놓인 컬럼 자리 — 컬럼 밖 줄 · 묶음의 시작/끝 마커 줄은 undefined. 닫히지 않은 묶음은 노트 끝까지다.
+ * 코드 블록 안의 마커 모양 글은 마커가 아니다.
+ */
+declare function readColumnLayout(lines: readonly string[]): (ColumnPlace | undefined)[];
+/** 열 이름표 — `열 2/3 · 50%`. 비율이 없으면 `열 2/3`. */
+declare function columnLabel(place: ColumnPlace): string;
+
+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 ColumnPlace, type CompletenessFailure, type CompletenessLocalSource, type CompletenessOptions, type CompletenessRemoteSource, type CompletenessReport, type Config, ConfigManager, ConfigSchema, type Conflict, ConflictResolver, type ConflictStrategy, ConnectionBoundaryError, ConnectionScopeError, 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 FolderDatabaseReport, 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, type InferredProperty, 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, OBSIDIAN_CONFIG_DIR, 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, ScopedVaultFS, 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, columnLabel, compactNotionId, computeBufferHash, computeHash, configDirFrom, connectionFolderOf, createDefaultPipeline, extractCalendarEntries, filterByMonth, filterEntries, findConnectionFolders, formatUnifiedDiff, generateColorCSS, generateId, getLogger, getNotionBgColor, getNotionColor, getVisibleProperties, groupEntries, hasColumnLayout, hasDesignMarker, inAnyPathScope, isInternalPath, isMarkdownPath, isRemoteDeletion, lineDiff, lintRenderedMarkdown, matchesPathScope, normalizeNotionId, normalizeVaultPath, noteNameFromPath, notionIdFromInput, notionIdsEqual, operationLabel, parseDesignColor, pendingWalBytes, readColumnLayout, readDesignLine, resolvePropertyName, sanitizeFileName, setLogger, sortEntries, stateDbLockPath, stateDbWalPath, stripMarkdownExtension, summarizeFidelity, systemTimeZone, threeWayMerge, translateNotionFilter, verifyDatabaseCompleteness, verifyPageCompleteness, wikilinkLookupsIn };