orgnote-api 0.20.2 → 0.40.0

package/remote-api/base.js

@@ -12,7 +12,7 @@
  * Do not edit the class manually.
  */
 import globalAxios from 'axios';
-export const BASE_PATH = "http://org-note.com/api/v1".replace(/\/+$/, "");
+export const BASE_PATH = "http://localhost:8000/v1".replace(/\/+$/, "");
 /**
  *
  * @export

package/remote-api/common.d.ts

@@ -62,4 +62,4 @@ export declare const toPathString: (url: URL) => string;
  *
  * @export
  */
-export declare const createRequestFunction: (axiosArgs: RequestArgs, globalAxios: AxiosInstance, BASE_PATH: string, configuration?: Configuration) => <T = unknown, R = AxiosResponse<T, any>>(axios?: AxiosInstance, basePath?: string) => Promise<R>;
+export declare const createRequestFunction: (axiosArgs: RequestArgs, globalAxios: AxiosInstance, BASE_PATH: string, configuration?: Configuration) => <T = unknown, R = AxiosResponse<T>>(axios?: AxiosInstance, basePath?: string) => Promise<R>;

package/sync/__tests__/memory-state.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/sync/__tests__/memory-state.spec.js

@@ -0,0 +1,49 @@
+import { test, expect } from 'vitest';
+import { createMemorySyncState } from "../memory-state.js";
+test('initial state empty', async () => {
+    const state = createMemorySyncState();
+    const data = await state.get();
+    expect(data.files).toEqual({});
+});
+test('initial with values', async () => {
+    const state = createMemorySyncState({
+        files: { 'a.org': { mtime: 1000, size: 100, status: 'synced' } },
+    });
+    const data = await state.get();
+    expect(data.files['a.org'].mtime).toBe(1000);
+});
+test('setFile and getFile', async () => {
+    const state = createMemorySyncState();
+    await state.setFile('b.org', { mtime: 2000, size: 200, status: 'dirty' });
+    const file = await state.getFile('b.org');
+    expect(file?.mtime).toBe(2000);
+    expect(file?.status).toBe('dirty');
+});
+test('getFile returns null for missing', async () => {
+    const state = createMemorySyncState();
+    const file = await state.getFile('missing.org');
+    expect(file).toBeNull();
+});
+test('removeFile', async () => {
+    const state = createMemorySyncState();
+    await state.setFile('c.org', { mtime: 1000, size: 100, status: 'synced' });
+    await state.removeFile('c.org');
+    const file = await state.getFile('c.org');
+    expect(file).toBeNull();
+});
+test('clear removes all', async () => {
+    const state = createMemorySyncState();
+    await state.setFile('d.org', { mtime: 1000, size: 100, status: 'synced' });
+    await state.setFile('e.org', { mtime: 2000, size: 200, status: 'synced' });
+    await state.clear();
+    const data = await state.get();
+    expect(data.files).toEqual({});
+});
+test('get returns copy', async () => {
+    const state = createMemorySyncState();
+    await state.setFile('f.org', { mtime: 1000, size: 100, status: 'synced' });
+    const data1 = await state.get();
+    data1.files['g.org'] = { mtime: 2000, size: 200, status: 'synced' };
+    const data2 = await state.get();
+    expect(data2.files['g.org']).toBeUndefined();
+});

package/sync/__tests__/plan.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/sync/__tests__/plan.spec.js

@@ -0,0 +1,116 @@
+import { test, expect } from 'vitest';
+import { createPlan } from "../plan.js";
+const emptyState = { files: {} };
+const serverTime = '2024-01-01T00:00:00Z';
+test('new local file → upload', () => {
+    const localFiles = [{ path: 'a.org', mtime: 1000, size: 100 }];
+    const plan = createPlan({ localFiles, deletedLocally: [], remoteFiles: [], stateData: emptyState, serverTime });
+    expect(plan.toUpload).toHaveLength(1);
+    expect(plan.toUpload[0].path).toBe('a.org');
+});
+test('new remote file → download', () => {
+    const remoteFiles = [
+        { path: 'b.org', version: 1, deleted: false, updatedAt: '' },
+    ];
+    const plan = createPlan({ localFiles: [], deletedLocally: [], remoteFiles, stateData: emptyState, serverTime });
+    expect(plan.toDownload).toHaveLength(1);
+    expect(plan.toDownload[0].path).toBe('b.org');
+});
+test('unchanged file → skip', () => {
+    const localFiles = [{ path: 'c.org', mtime: 1000, size: 100 }];
+    const remoteFiles = [
+        { path: 'c.org', version: 1, deleted: false, updatedAt: '' },
+    ];
+    const stateData = {
+        files: { 'c.org': { mtime: 1000, size: 100, version: 1, status: 'synced' } },
+    };
+    const plan = createPlan({ localFiles, deletedLocally: [], remoteFiles, stateData, serverTime });
+    expect(plan.toUpload).toHaveLength(0);
+    expect(plan.toDownload).toHaveLength(0);
+});
+test('local changed → upload', () => {
+    const localFiles = [{ path: 'd.org', mtime: 2000, size: 100 }];
+    const remoteFiles = [
+        { path: 'd.org', version: 1, deleted: false, updatedAt: '' },
+    ];
+    const stateData = {
+        files: { 'd.org': { mtime: 1000, size: 100, version: 1, status: 'synced' } },
+    };
+    const plan = createPlan({ localFiles, deletedLocally: [], remoteFiles, stateData, serverTime });
+    expect(plan.toUpload).toHaveLength(1);
+});
+test('remote changed → download', () => {
+    const localFiles = [{ path: 'e.org', mtime: 1000, size: 100 }];
+    const remoteFiles = [
+        { path: 'e.org', version: 2, deleted: false, updatedAt: '' },
+    ];
+    const stateData = {
+        files: { 'e.org': { mtime: 1000, size: 100, version: 1, status: 'synced' } },
+    };
+    const plan = createPlan({ localFiles, deletedLocally: [], remoteFiles, stateData, serverTime });
+    expect(plan.toDownload).toHaveLength(1);
+});
+test('both changed → upload (conflict handled by server)', () => {
+    const localFiles = [{ path: 'f.org', mtime: 3000, size: 100 }];
+    const remoteFiles = [
+        { path: 'f.org', version: 2, deleted: false, updatedAt: '1970-01-01T00:00:02.000Z' },
+    ];
+    const stateData = {
+        files: { 'f.org': { mtime: 1000, size: 100, version: 1, status: 'synced' } },
+    };
+    const plan = createPlan({ localFiles, deletedLocally: [], remoteFiles, stateData, serverTime });
+    expect(plan.toUpload).toHaveLength(1);
+    expect(plan.toDownload).toHaveLength(0);
+});
+test('deleted locally → delete remote', () => {
+    const deletedLocally = ['g.org'];
+    const stateData = {
+        files: { 'g.org': { mtime: 1000, size: 100, version: 1, status: 'synced' } },
+    };
+    const plan = createPlan({ localFiles: [], deletedLocally, remoteFiles: [], stateData, serverTime });
+    expect(plan.toDeleteRemote).toContain('g.org');
+});
+test('deleted remotely → delete local', () => {
+    const localFiles = [{ path: 'h.org', mtime: 1000, size: 100 }];
+    const remoteFiles = [
+        { path: 'h.org', version: 2, deleted: true, updatedAt: '' },
+    ];
+    const stateData = {
+        files: { 'h.org': { mtime: 1000, size: 100, version: 1, status: 'synced' } },
+    };
+    const plan = createPlan({ localFiles, deletedLocally: [], remoteFiles, stateData, serverTime });
+    expect(plan.toDeleteLocal).toContain('h.org');
+});
+test('deleted locally but modified remotely → download', () => {
+    const deletedLocally = ['i.org'];
+    const remoteFiles = [
+        { path: 'i.org', version: 2, deleted: false, updatedAt: '' },
+    ];
+    const stateData = {
+        files: { 'i.org': { mtime: 1000, size: 100, version: 1, status: 'synced' } },
+    };
+    const plan = createPlan({ localFiles: [], deletedLocally, remoteFiles, stateData, serverTime });
+    expect(plan.toDownload).toHaveLength(1);
+    expect(plan.toDeleteRemote).toHaveLength(0);
+});
+test('deleted remotely but modified locally → upload (local changes win)', () => {
+    const localFiles = [{ path: 'j.org', mtime: 3000, size: 100 }];
+    const remoteFiles = [
+        { path: 'j.org', version: 2, deleted: true, updatedAt: '1970-01-01T00:00:02.000Z' },
+    ];
+    const stateData = {
+        files: { 'j.org': { mtime: 1000, size: 100, version: 1, status: 'synced' } },
+    };
+    const plan = createPlan({ localFiles, deletedLocally: [], remoteFiles, stateData, serverTime });
+    expect(plan.toUpload).toHaveLength(1);
+    expect(plan.toDeleteLocal).toHaveLength(0);
+});
+test('file with error status → retry upload', () => {
+    const localFiles = [{ path: 'k.org', mtime: 1000, size: 100 }];
+    const stateData = {
+        files: { 'k.org': { mtime: 1000, size: 100, version: 1, status: 'error', errorMessage: 'some error' } },
+    };
+    const plan = createPlan({ localFiles, deletedLocally: [], remoteFiles: [], stateData, serverTime });
+    expect(plan.toUpload).toHaveLength(1);
+    expect(plan.toUpload[0].path).toBe('k.org');
+});

package/sync/create-sync-plan.d.ts

@@ -0,0 +1,2 @@
+import type { CreateSyncPlanParams, SyncPlan } from './types.js';
+export declare function createSyncPlan(params: CreateSyncPlanParams): Promise<SyncPlan>;

package/sync/create-sync-plan.js

@@ -0,0 +1,13 @@
+import { scanLocalFiles, findDeletedLocally } from "./scan.js";
+import { fetchRemoteChanges } from "./fetch.js";
+import { createPlan } from "./plan.js";
+import { getOldestSyncedAt } from "./utils/oldest-synced-at.js";
+export async function createSyncPlan(params) {
+    const { fs, api, state, rootPath, ignorePatterns } = params;
+    const stateData = await state.get();
+    const localFiles = await scanLocalFiles(fs, rootPath, ignorePatterns);
+    const deletedLocally = findDeletedLocally(localFiles, stateData);
+    const since = getOldestSyncedAt(stateData);
+    const { files: remoteFiles, serverTime } = await fetchRemoteChanges(api, since);
+    return createPlan({ localFiles, deletedLocally, remoteFiles, stateData, serverTime });
+}

package/sync/fetch.d.ts

@@ -0,0 +1,8 @@
+import type { SyncChangesResponse } from '../remote-api/index.js';
+import type { SyncApi, RemoteFile } from './types.js';
+type ServerFields = Pick<SyncChangesResponse, 'serverTime' | 'cursor'>;
+export interface FetchResult extends ServerFields {
+    files: RemoteFile[];
+}
+export declare const fetchRemoteChanges: (api: SyncApi, since?: string) => Promise<FetchResult>;
+export {};

package/sync/fetch.js

@@ -0,0 +1,32 @@
+const DEFAULT_LIMIT = 100;
+export const fetchRemoteChanges = async (api, since) => fetchAllPages(api, since);
+const fetchAllPages = async (api, since, cursor, accumulated = []) => {
+    const page = await fetchPage(api, since, cursor);
+    const files = [...accumulated, ...page.files];
+    if (!page.cursor) {
+        return { files, serverTime: page.serverTime };
+    }
+    return fetchAllPages(api, since, page.cursor, files);
+};
+const toTimestamp = (isoString) => {
+    if (!isoString)
+        return undefined;
+    return new Date(isoString).getTime();
+};
+const fetchPage = async (api, since, cursor) => {
+    const sinceMs = toTimestamp(since);
+    const response = await api.syncChangesGet(sinceMs, DEFAULT_LIMIT, cursor);
+    const data = response.data.data;
+    return {
+        files: mapChangesToFiles(data.changes),
+        serverTime: data.serverTime,
+        cursor: data.hasMore ? data.cursor : undefined,
+    };
+};
+const mapChangesToFiles = (changes) => changes.map(toRemoteFile);
+const toRemoteFile = (change) => ({
+    path: change.path,
+    version: change.version,
+    deleted: change.deleted,
+    updatedAt: change.updatedAt,
+});

package/sync/index.d.ts

@@ -0,0 +1,10 @@
+export { createSyncPlan } from './create-sync-plan.js';
+export { createPlan } from './plan.js';
+export { createMemorySyncState } from './memory-state.js';
+export { scanLocalFiles, findDeletedLocally } from './scan.js';
+export { fetchRemoteChanges } from './fetch.js';
+export { recoverState } from './recovery.js';
+export { getOldestSyncedAt } from './utils/oldest-synced-at.js';
+export { processUpload, processDownload, processDeleteLocal, processDeleteRemote, handleConflict, generateConflictPath, hasConflict, } from './operations/index.js';
+export { SyncOperationType } from './types.js';
+export type { SyncState, SyncStateData, SyncedFile, SyncStatus, LocalFile, RemoteFile, UploadResult, SyncPlan, SyncTask, SyncExecutor, SyncContext, CreateSyncPlanParams, } from './types.js';

package/sync/index.js

@@ -0,0 +1,9 @@
+export { createSyncPlan } from "./create-sync-plan.js";
+export { createPlan } from "./plan.js";
+export { createMemorySyncState } from "./memory-state.js";
+export { scanLocalFiles, findDeletedLocally } from "./scan.js";
+export { fetchRemoteChanges } from "./fetch.js";
+export { recoverState } from "./recovery.js";
+export { getOldestSyncedAt } from "./utils/oldest-synced-at.js";
+export { processUpload, processDownload, processDeleteLocal, processDeleteRemote, handleConflict, generateConflictPath, hasConflict, } from "./operations/index.js";
+export { SyncOperationType } from "./types.js";

package/sync/memory-state.d.ts

@@ -0,0 +1,2 @@
+import type { SyncState, SyncStateData } from './types.js';
+export declare function createMemorySyncState(initial?: Partial<SyncStateData>): SyncState;

package/sync/memory-state.js

@@ -0,0 +1,22 @@
+export function createMemorySyncState(initial) {
+    const data = {
+        files: { ...initial?.files },
+    };
+    return {
+        async get() {
+            return { files: { ...data.files } };
+        },
+        async getFile(path) {
+            return data.files[path] ?? null;
+        },
+        async setFile(path, file) {
+            data.files[path] = { ...file };
+        },
+        async removeFile(path) {
+            delete data.files[path];
+        },
+        async clear() {
+            data.files = {};
+        },
+    };
+}

package/sync/operations/conflict.d.ts

@@ -0,0 +1,10 @@
+import type { SyncContext, UploadResult } from '../types.js';
+type ConflictUploadResult = Extract<UploadResult, {
+    status: 'conflict';
+}>;
+export declare const generateConflictPath: (path: string, deviceName?: string) => string;
+export declare const handleConflict: (path: string, conflictResult: ConflictUploadResult, ctx: SyncContext) => Promise<void>;
+export declare const hasConflict: (file: {
+    conflictPath?: string;
+}) => boolean;
+export {};

package/sync/operations/conflict.js

@@ -0,0 +1,56 @@
+import { createSyncedFile } from "./synced-file.js";
+export const generateConflictPath = (path, deviceName = 'device') => {
+    const lastDot = path.lastIndexOf('.');
+    const ext = lastDot >= 0 ? path.substring(lastDot) : '';
+    const base = lastDot >= 0 ? path.substring(0, lastDot) : path;
+    const timestamp = Date.now();
+    return `${base}.sync-conflict-${timestamp}-${deviceName}${ext}`;
+};
+const copyFile = async (fs, src, dest) => {
+    if (fs.copyFile) {
+        await fs.copyFile(src, dest);
+        return;
+    }
+    const content = await fs.readFile(src, 'binary');
+    await fs.writeFile(dest, content);
+};
+const isNotFoundError = (error) => {
+    if (typeof error !== 'object' || error === null)
+        return false;
+    const axiosError = error;
+    return axiosError.response?.status === 404;
+};
+const tryDownloadServerVersion = async (path, serverVersion, ctx) => {
+    try {
+        await ctx.executor.download({
+            path,
+            version: serverVersion,
+            deleted: false,
+            updatedAt: new Date().toISOString(),
+        });
+        return true;
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return false;
+        throw error;
+    }
+};
+export const handleConflict = async (path, conflictResult, ctx) => {
+    const conflictPath = generateConflictPath(path, ctx.deviceName);
+    await copyFile(ctx.fs, path, conflictPath);
+    const downloaded = await tryDownloadServerVersion(path, conflictResult.serverVersion, ctx);
+    if (!downloaded) {
+        await ctx.fs.deleteFile(path);
+        await ctx.state.removeFile(path);
+        return;
+    }
+    const fileInfo = await ctx.fs.fileInfo(path);
+    const meta = { mtime: fileInfo?.mtime ?? 0, size: fileInfo?.size ?? 0 };
+    await ctx.state.setFile(path, createSyncedFile(meta, {
+        version: conflictResult.serverVersion,
+        status: 'synced',
+        conflictPath,
+    }));
+};
+export const hasConflict = (file) => file.conflictPath !== undefined;

package/sync/operations/delete-local.d.ts

@@ -0,0 +1,2 @@
+import type { SyncContext } from '../types.js';
+export declare const processDeleteLocal: (path: string, ctx: SyncContext) => Promise<void>;

package/sync/operations/delete-local.js

@@ -0,0 +1,17 @@
+export const processDeleteLocal = async (path, ctx) => {
+    try {
+        await ctx.fs.deleteFile(path);
+        await ctx.state.removeFile(path);
+    }
+    catch (error) {
+        const stored = await ctx.state.getFile(path);
+        if (stored) {
+            await ctx.state.setFile(path, {
+                ...stored,
+                status: 'error',
+                errorMessage: String(error),
+            });
+        }
+        throw error;
+    }
+};

package/sync/operations/delete-remote.d.ts

@@ -0,0 +1,2 @@
+import type { SyncContext } from '../types.js';
+export declare const processDeleteRemote: (path: string, ctx: SyncContext) => Promise<void>;

package/sync/operations/delete-remote.js

@@ -0,0 +1,26 @@
+const isNotFoundError = (error) => {
+    if (!(error instanceof Error))
+        return false;
+    return error.message.includes('404') || error.message.includes('not found');
+};
+export const processDeleteRemote = async (path, ctx) => {
+    const stored = await ctx.state.getFile(path);
+    try {
+        await ctx.executor.deleteRemote(path, stored?.version ?? 0);
+        await ctx.state.removeFile(path);
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            await ctx.state.removeFile(path);
+            return;
+        }
+        if (stored) {
+            await ctx.state.setFile(path, {
+                ...stored,
+                status: 'error',
+                errorMessage: String(error),
+            });
+        }
+        throw error;
+    }
+};

package/sync/operations/download.d.ts

@@ -0,0 +1,2 @@
+import type { RemoteFile, SyncContext } from '../types.js';
+export declare const processDownload: (file: RemoteFile, ctx: SyncContext) => Promise<void>;

package/sync/operations/download.js

@@ -0,0 +1,20 @@
+import { createSyncedFile } from "./synced-file.js";
+const storedMeta = (stored) => ({
+    mtime: stored?.mtime ?? 0,
+    size: stored?.size ?? 0,
+});
+export const processDownload = async (file, ctx) => {
+    const stored = await ctx.state.getFile(file.path);
+    const meta = storedMeta(stored);
+    await ctx.state.setFile(file.path, createSyncedFile(meta, { version: stored?.version, status: 'downloading' }));
+    try {
+        await ctx.executor.download(file);
+        const fileInfo = await ctx.fs.fileInfo(file.path);
+        const downloadedMeta = { mtime: fileInfo?.mtime ?? 0, size: fileInfo?.size ?? 0 };
+        await ctx.state.setFile(file.path, createSyncedFile(downloadedMeta, { version: file.version, status: 'synced', syncedAt: ctx.serverTime }));
+    }
+    catch (error) {
+        await ctx.state.setFile(file.path, createSyncedFile(meta, { version: stored?.version, status: 'error', errorMessage: String(error) }));
+        throw error;
+    }
+};

package/sync/operations/index.d.ts

@@ -0,0 +1,5 @@
+export { processUpload } from './upload.js';
+export { processDownload } from './download.js';
+export { processDeleteLocal } from './delete-local.js';
+export { processDeleteRemote } from './delete-remote.js';
+export { handleConflict, generateConflictPath, hasConflict } from './conflict.js';

package/sync/operations/index.js

@@ -0,0 +1,5 @@
+export { processUpload } from "./upload.js";
+export { processDownload } from "./download.js";
+export { processDeleteLocal } from "./delete-local.js";
+export { processDeleteRemote } from "./delete-remote.js";
+export { handleConflict, generateConflictPath, hasConflict } from "./conflict.js";

package/sync/operations/synced-file.d.ts

@@ -0,0 +1,14 @@
+import type { SyncedFile, SyncStatus } from '../types.js';
+interface FileMeta {
+    mtime: number;
+    size: number;
+}
+export interface SyncedFileOptions {
+    version?: number;
+    status: SyncStatus;
+    syncedAt?: string;
+    errorMessage?: string;
+    conflictPath?: string;
+}
+export declare const createSyncedFile: (meta: FileMeta, options: SyncedFileOptions) => SyncedFile;
+export {};

package/sync/operations/synced-file.js

@@ -0,0 +1,5 @@
+export const createSyncedFile = (meta, options) => ({
+    mtime: meta.mtime,
+    size: meta.size,
+    ...options,
+});

package/sync/operations/upload.d.ts

@@ -0,0 +1,2 @@
+import type { LocalFile, SyncContext } from '../types.js';
+export declare const processUpload: (file: LocalFile, ctx: SyncContext) => Promise<void>;

package/sync/operations/upload.js

@@ -0,0 +1,30 @@
+import { handleConflict } from "./conflict.js";
+import { createSyncedFile } from "./synced-file.js";
+const executeUpload = async (file, expectedVersion, ctx) => {
+    const result = await ctx.executor.upload(file, expectedVersion);
+    if (result.status === 'ok') {
+        await ctx.state.setFile(file.path, createSyncedFile(file, {
+            version: result.version,
+            status: 'synced',
+            syncedAt: ctx.serverTime,
+        }));
+        return;
+    }
+    await handleConflict(file.path, result, ctx);
+};
+export const processUpload = async (file, ctx) => {
+    const stored = await ctx.state.getFile(file.path);
+    const expectedVersion = stored?.version;
+    await ctx.state.setFile(file.path, createSyncedFile(file, { version: expectedVersion, status: 'uploading' }));
+    try {
+        await executeUpload(file, expectedVersion, ctx);
+    }
+    catch (error) {
+        await ctx.state.setFile(file.path, createSyncedFile(file, {
+            version: expectedVersion,
+            status: 'error',
+            errorMessage: String(error),
+        }));
+        throw error;
+    }
+};

package/sync/plan.d.ts

@@ -0,0 +1,9 @@
+import type { LocalFile, RemoteFile, SyncPlan, SyncStateData } from './types.js';
+export interface CreatePlanParams {
+    localFiles: LocalFile[];
+    deletedLocally: string[];
+    remoteFiles: RemoteFile[];
+    stateData: SyncStateData;
+    serverTime: string;
+}
+export declare const createPlan: ({ localFiles, deletedLocally, remoteFiles, stateData, serverTime, }: CreatePlanParams) => SyncPlan;

package/sync/plan.js

@@ -0,0 +1,57 @@
+import { SyncOperationType } from "./types.js";
+export const createPlan = ({ localFiles, deletedLocally, remoteFiles, stateData, serverTime, }) => {
+    const index = buildFileIndex(localFiles, deletedLocally, remoteFiles);
+    const localActions = localFiles.map(local => resolveLocalFile(local, index.remoteByPath.get(local.path), stateData.files[local.path]));
+    const deletedActions = deletedLocally.map(path => resolveDeletedLocally(path, index.remoteByPath.get(path), stateData.files[path]));
+    const remoteActions = remoteFiles
+        .filter(remote => isNewRemote(remote, index))
+        .map(resolveNewRemote);
+    return buildPlanFromActions([...localActions, ...deletedActions, ...remoteActions], serverTime);
+};
+const buildFileIndex = (localFiles, deletedLocally, remoteFiles) => ({
+    remoteByPath: new Map(remoteFiles.map(f => [f.path, f])),
+    localByPath: new Map(localFiles.map(f => [f.path, f])),
+    deletedSet: new Set(deletedLocally),
+});
+const isNewRemote = (remote, index) => !index.localByPath.has(remote.path) && !index.deletedSet.has(remote.path);
+const buildPlanFromActions = (actions, serverTime) => actions.reduce((plan, action) => applyAction(plan, action), { toUpload: [], toDownload: [], toDeleteLocal: [], toDeleteRemote: [], serverTime });
+const actionHandlers = {
+    [SyncOperationType.Upload]: (plan, action) => ({ ...plan, toUpload: [...plan.toUpload, action.file] }),
+    [SyncOperationType.Download]: (plan, action) => ({ ...plan, toDownload: [...plan.toDownload, action.file] }),
+    [SyncOperationType.DeleteLocal]: (plan, action) => ({ ...plan, toDeleteLocal: [...plan.toDeleteLocal, action.path] }),
+    [SyncOperationType.DeleteRemote]: (plan, action) => ({ ...plan, toDeleteRemote: [...plan.toDeleteRemote, action.path] }),
+    none: (plan) => plan,
+};
+const applyAction = (plan, action) => actionHandlers[action.type](plan, action);
+const resolveLocalFile = (local, remote, stored) => {
+    const localChanged = isLocalChanged(local, stored);
+    if (!remote) {
+        return localChanged ? upload(local) : none();
+    }
+    if (remote.deleted) {
+        return localChanged ? upload(local) : deleteLocal(local.path);
+    }
+    const remoteChanged = isRemoteChanged(remote, stored);
+    if (localChanged && remoteChanged) {
+        return upload(local);
+    }
+    if (localChanged)
+        return upload(local);
+    if (remoteChanged)
+        return download(remote);
+    return none();
+};
+const resolveDeletedLocally = (path, remote, stored) => {
+    if (!remote || remote.deleted) {
+        return deleteRemote(path);
+    }
+    return isRemoteChanged(remote, stored) ? download(remote) : deleteRemote(path);
+};
+const resolveNewRemote = (remote) => remote.deleted ? none() : download(remote);
+const isLocalChanged = (local, stored) => !stored || local.mtime !== stored.mtime || stored.status === 'error';
+const isRemoteChanged = (remote, stored) => !stored || remote.version > (stored.version ?? 0);
+const upload = (file) => ({ type: SyncOperationType.Upload, file });
+const download = (file) => ({ type: SyncOperationType.Download, file });
+const deleteLocal = (path) => ({ type: SyncOperationType.DeleteLocal, path });
+const deleteRemote = (path) => ({ type: SyncOperationType.DeleteRemote, path });
+const none = () => ({ type: 'none' });

package/sync/recovery.d.ts

@@ -0,0 +1,2 @@
+import type { SyncState } from './types.js';
+export declare const recoverState: (state: SyncState) => Promise<void>;

package/sync/recovery.js

@@ -0,0 +1,6 @@
+const isInterruptedStatus = (status) => status === 'uploading' || status === 'downloading';
+export const recoverState = async (state) => {
+    const data = await state.get();
+    const interruptedFiles = Object.entries(data.files).filter(([, file]) => isInterruptedStatus(file.status));
+    await Promise.all(interruptedFiles.map(([path, file]) => state.setFile(path, { ...file, status: 'dirty' })));
+};

package/sync/scan.d.ts

@@ -0,0 +1,4 @@
+import type { FileSystem } from '../models/file-system.js';
+import type { LocalFile, SyncStateData } from './types.js';
+export declare function scanLocalFiles(fs: FileSystem, rootPath: string, ignorePatterns?: string[]): Promise<LocalFile[]>;
+export declare const findDeletedLocally: (localFiles: LocalFile[], stateData: SyncStateData) => string[];

package/sync/scan.js

@@ -0,0 +1,40 @@
+import { toAbsolutePath } from "../utils/to-absolute-path.js";
+const DEFAULT_IGNORE = [
+    '.git',
+    '.DS_Store',
+    'node_modules',
+    '.sync-state',
+    '.Trash',
+];
+export async function scanLocalFiles(fs, rootPath, ignorePatterns = []) {
+    const ignore = [...DEFAULT_IGNORE, ...ignorePatterns];
+    return scanDir(fs, rootPath, ignore);
+}
+async function scanDir(fs, path, ignore) {
+    const entries = await fs.readDir(path);
+    const filteredEntries = entries.filter((e) => !shouldIgnore(e.name, ignore));
+    const nestedResults = await Promise.all(filteredEntries.map((entry) => processEntry(fs, entry, ignore)));
+    return nestedResults.flat();
+}
+async function processEntry(fs, entry, ignore) {
+    if (entry.type === 'directory') {
+        return scanDir(fs, entry.path, ignore);
+    }
+    return [toLocalFile(entry)];
+}
+const toLocalFile = (entry) => ({
+    path: toAbsolutePath(entry.path),
+    mtime: entry.mtime,
+    size: entry.size,
+});
+const shouldIgnore = (name, patterns) => patterns.some((pattern) => matchPattern(pattern, name));
+const matchPattern = (pattern, name) => {
+    if (!pattern.includes('*'))
+        return name === pattern;
+    const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+    return regex.test(name);
+};
+export const findDeletedLocally = (localFiles, stateData) => {
+    const localPaths = new Set(localFiles.map((f) => f.path));
+    return Object.keys(stateData.files).filter((path) => !localPaths.has(path));
+};