alinea 2.0.0-preview.9 → 2.0.0-rc2

package/dist/core/Validation.d.ts

@@ -0,0 +1,60 @@
+import type { Config } from './Config.js';
+import { Field, type FieldOptions } from './Field.js';
+import type { RootI18n } from './Root.js';
+import type { Policy, Resource } from './Role.js';
+import { type FieldGetter } from './Tracker.js';
+import { Type } from './Type.js';
+/** Keys into the entry data, list rows and rich text blocks by index */
+export type FieldPath = Array<string | number>;
+export interface FieldValidationError {
+    path: FieldPath;
+    /** Labels of the fields (and row types) along the path */
+    labels: Array<string>;
+    message: string;
+}
+/** Adjusts the options of a field before it is validated, eg. for policies */
+export interface FieldOptionsResolver {
+    (field: Field, options: FieldOptions<unknown>): FieldOptions<unknown>;
+}
+export interface ValidationScope {
+    type: Type;
+    value: Record<string, unknown>;
+}
+export interface FieldValidationContext {
+    path: FieldPath;
+    labels: Array<string>;
+    /** The records enclosing the field, outermost first, to resolve trackers */
+    scopes: Array<ValidationScope>;
+    fieldOptions?: FieldOptionsResolver;
+    /** The locales of a root that translates fields, see `Field.localised` */
+    fieldI18n?: RootI18n;
+}
+export interface ValidateEntryOptions {
+    /** @deprecated Unused, validation does not depend on the locale */
+    locale?: string | null;
+    fieldOptions?: FieldOptionsResolver;
+    /** The locales of the entry's root, if it translates fields */
+    fieldI18n?: RootI18n;
+}
+/**
+ * The error message for a single field value, or undefined if it is valid.
+ * Nested fields (list rows, object fields, blocks) are not checked here.
+ */
+export declare function fieldError(field: Field, options: FieldOptions<unknown>, value: unknown): string | undefined;
+/** A getter for option trackers, reading from the innermost scope first */
+export declare function scopeGetter(scopes: Array<ValidationScope>): FieldGetter;
+/** Field options with tracked options applied */
+export declare function trackedFieldOptions(field: Field, getter: FieldGetter): FieldOptions<unknown>;
+/**
+ * Hides fields the policy does not allow reading and makes fields read-only
+ * which the policy does not allow updating, like the dashboard shows them.
+ */
+export declare function policyFieldOptions(config: Config, policy: Policy, resource: Resource): FieldOptionsResolver;
+/**
+ * Validate the fields of a type. Hidden and read-only fields (and anything
+ * nested in them) are skipped: editors cannot see or change them.
+ */
+export declare function validateType(type: Type, value: unknown, context: FieldValidationContext): Array<FieldValidationError>;
+/** Validate entry data: required, min, max and validate options */
+export declare function validateEntry(type: Type, data: unknown, options?: ValidateEntryOptions): Array<FieldValidationError>;
+export declare function formatFieldPath(path: FieldPath): string;

package/dist/core/Validation.js

@@ -0,0 +1,116 @@
+import "../chunks/chunk-CQ52GEHY.js";
+
+// src/core/Validation.ts
+import { Field } from "./Field.js";
+import { getScope } from "./Scope.js";
+import { optionTrackerOf } from "./Tracker.js";
+import { Type } from "./Type.js";
+import { entries, isRecord } from "./util/Objects.js";
+function fieldError(field, options, value) {
+  if (Field.hasValueErrors(field)) return void 0;
+  const { min, max } = options;
+  if (Array.isArray(value)) {
+    if (typeof min === "number" && value.length < min)
+      return `Add at least ${min} ${min === 1 ? "item" : "items"}`;
+    if (typeof max === "number" && value.length > max)
+      return `Add at most ${max} ${max === 1 ? "item" : "items"}`;
+  }
+  if (options.validate) {
+    let result;
+    try {
+      result = options.validate(value);
+    } catch (error) {
+      return error instanceof Error ? error.message : String(error);
+    }
+    if (result === false) return "Field is invalid";
+    if (typeof result === "string") return result;
+  }
+  if (options.required && Field.isEmpty(field, value))
+    return "Field is required";
+  return void 0;
+}
+function scopeGetter(scopes) {
+  return ((field) => {
+    const ref = Field.ref(field);
+    for (let i = scopes.length - 1; i >= 0; i--) {
+      const { type, value } = scopes[i];
+      for (const [key, candidate] of entries(Type.fields(type)))
+        if (Field.ref(candidate) === ref) return value[key];
+    }
+    return void 0;
+  });
+}
+function trackedFieldOptions(field, getter) {
+  const options = Field.options(field);
+  const tracker = optionTrackerOf(field);
+  if (!tracker) return options;
+  return { ...options, ...tracker(getter) };
+}
+function policyFieldOptions(config, policy, resource) {
+  const scope = getScope(config);
+  return (field, options) => {
+    const location = scope.fieldOf(field);
+    if (!location || location[0] !== resource.type) return options;
+    const fieldResource = { ...resource, field: location[1] };
+    return {
+      ...options,
+      hidden: options.hidden || !policy.canRead(fieldResource),
+      readOnly: options.readOnly || !policy.canUpdate(fieldResource)
+    };
+  };
+}
+function validateType(type, value, context) {
+  const record = isRecord(value) ? value : {};
+  const scopes = [...context.scopes, { type, value: record }];
+  const getter = scopeGetter(scopes);
+  const result = Array();
+  for (const [key, field] of entries(Type.fields(type))) {
+    const tracked = trackedFieldOptions(field, getter);
+    const options = context.fieldOptions?.(field, tracked) ?? tracked;
+    if (options.hidden || options.readOnly) continue;
+    const path = [...context.path, key];
+    const labels = [...context.labels, options.label];
+    const fieldValue = record[key];
+    const fieldContext = { ...context, path, labels, scopes };
+    const valueErrors = Field.valueErrors(
+      field,
+      fieldValue,
+      options,
+      fieldContext
+    );
+    if (valueErrors) {
+      result.push(...valueErrors);
+      continue;
+    }
+    const message = fieldError(field, options, fieldValue);
+    if (message) result.push({ path, labels, message });
+    result.push(...Field.nestedErrors(field, fieldValue, fieldContext));
+  }
+  return result;
+}
+function validateEntry(type, data, options = {}) {
+  return validateType(type, data, {
+    path: [],
+    labels: [],
+    scopes: [],
+    fieldOptions: options.fieldOptions,
+    fieldI18n: options.fieldI18n
+  });
+}
+function formatFieldPath(path) {
+  let result = "";
+  for (const segment of path) {
+    if (typeof segment === "number") result += `[${segment}]`;
+    else result += result ? `.${segment}` : segment;
+  }
+  return result;
+}
+export {
+  fieldError,
+  formatFieldPath,
+  policyFieldOptions,
+  scopeGetter,
+  trackedFieldOptions,
+  validateEntry,
+  validateType
+};

package/dist/core/Workspace.d.ts

@@ -29,6 +29,7 @@ export declare namespace Workspace {
     function preview(workspace: Workspace): Preview | undefined;
     function isWorkspace(value: any): value is Workspace;
     function defaultMediaRoot(workspace: Workspace): string;
+    /** The first root marked `openByDefault`, or the first root */
     function defaultRoot(workspace: Workspace): string;
     function validate(workspace: Workspace, schema: Schema): void;
     function referencedViews(workspace: Workspace): string[];

package/dist/core/Workspace.js

@@ -2,6 +2,7 @@ import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Workspace.ts
 import {
+  getRoot,
   getWorkspace,
   hasWorkspace,
   internalWorkspace
@@ -40,7 +41,10 @@ var Workspace;
   }
   Workspace2.defaultMediaRoot = defaultMediaRoot;
   function defaultRoot(workspace2) {
-    return Object.keys(getWorkspace(workspace2).roots)[0];
+    const { roots: roots2 } = getWorkspace(workspace2);
+    for (const [name, root] of entries(roots2))
+      if (getRoot(root).openByDefault) return name;
+    return Object.keys(roots2)[0];
   }
   Workspace2.defaultRoot = defaultRoot;
   function validate(workspace2, schema) {

package/dist/core/db/EntryReference.d.ts

@@ -5,6 +5,8 @@ export interface EntryReferenceTarget {
     targetId: string;
     fieldPath: string;
     fieldLabel?: string;
+    /** Labels of the fields (and row types) along the path to the field */
+    fieldLabels?: Array<string>;
     linkId?: string;
     linkType?: EntryReferenceLinkType;
 }
@@ -19,11 +21,14 @@ export interface EntryReference {
     sourceMain: boolean;
     fieldPath: string;
     fieldLabel?: string;
+    /** Labels of the fields (and row types) along the path to the field */
+    fieldLabels?: Array<string>;
     linkId?: string;
     linkType?: EntryReferenceLinkType;
 }
 export interface EntryReferenceQuery {
-    targetId: string;
+    /** The entry, or entries, the references point to */
+    targetId: string | Array<string>;
     status?: Status;
     locale?: string | null;
 }
@@ -34,5 +39,7 @@ export interface EntryReferenceResult {
 export interface FieldReferenceContext {
     path: Array<string>;
     label?: string;
+    /** Labels of the fields (and row types) along the path, ending in label */
+    labels: Array<string>;
 }
 export declare function referenceFieldPath(path: Array<string>): string;

package/dist/core/db/LinkResolver.d.ts

@@ -1,5 +1,6 @@
 import type { InferProjection, Projection } from 'alinea/core/Graph';
 import type { Config } from 'alinea/core/Config';
+import type { RootI18n } from 'alinea/core/Root';
 export interface LinkTarget {
     entryId: string;
     locale?: string;
@@ -8,6 +9,8 @@ export interface LinkTarget {
 export interface LinkResolver {
     config: Config;
     locale: string | null;
+    /** The locales of the root of the entry being read, if it translates fields */
+    fieldI18n?: RootI18n;
     includedAtBuild(filePath: string): boolean | Promise<boolean>;
     resolveLinks<P extends Projection>(projection: P, entryIds: ReadonlyArray<string>, locale?: string | null): Promise<Array<InferProjection<P>>>;
     resolveTargets<P extends Projection & {

package/dist/core/db/LocalStore.d.ts

@@ -6,6 +6,25 @@ import type { WriteableGraph } from './WriteableGraph.js';
 export interface SyncOptions {
     /** Skip entry validation for a remote whose entries were already validated. */
     validate?: boolean;
+    /** Called as files arrive from the remote, once there are files to fetch. */
+    onProgress?(progress: SyncProgress): void;
+    /** Filled in with where the sync spent its time, see `loggedSync`. */
+    stats?: SyncStats;
+}
+/** Files fetched from the remote during a sync. */
+export interface SyncProgress {
+    loaded: number;
+    total: number;
+}
+export type SyncStep = 'tree' | 'blobs' | 'parse' | 'write' | 'derive' | 'analyze';
+/** Where a sync spent its time and how much it changed. */
+export interface SyncStats {
+    /** Milliseconds per step: tree and blobs wait for the remote. */
+    steps: Partial<Record<SyncStep, number>>;
+    /** Files fetched from the remote */
+    files: number;
+    /** Entry versions derived again */
+    versions: number;
 }
 /**
  * A locally available entry store: a writeable graph backed by a source that

package/dist/core/db/Operation.d.ts

@@ -1,6 +1,8 @@
 import type { CreateInputRow, StoredRow } from '../Infer.js';
 import type { ImagePreviewDetails } from '../media/CreatePreview.js';
+import { type ImageEdit, type ImageTransform } from '../media/ImageTransform.js';
 import { Type } from '../Type.js';
+import type { User } from '../User.js';
 import type { Mutation } from './Mutation.js';
 import type { WriteableGraph } from './WriteableGraph.js';
 type Awaitable<T> = T | Promise<T>;
@@ -20,6 +22,8 @@ export interface CreateQuery<Fields> {
     set: Partial<CreateInputRow<Fields>>;
     insertOrder?: 'first' | 'last';
     overwrite?: boolean;
+    /** Recorded as the creator, or the last editor of an overwritten entry */
+    user?: User | null;
 }
 export declare class CreateOp<Fields> extends Operation {
     id: string;
@@ -43,6 +47,8 @@ export interface UpdateQuery<Fields> {
     set: Partial<StoredRow<Fields>>;
     status?: 'draft' | 'published' | 'archived';
     locale?: string | null;
+    /** Recorded as the last editor */
+    user?: User | null;
 }
 export declare class UpdateOperation<Definition> extends Operation {
     constructor(query: UpdateQuery<Definition>);
@@ -83,9 +89,30 @@ export interface UploadQuery {
     workspace?: string;
     root?: string;
     parentId?: string | null;
-    createPreview?(blob: Blob): Promise<ImagePreviewDetails>;
+    /**
+     * The file type the upload becomes, one of those the location contains.
+     * Defaults to the first of them that accepts the file, a replaced file
+     * keeps its type.
+     */
+    type?: string;
+    createPreview?(blob: Blob): Promise<ImagePreviewDetails | undefined>;
+    /** Rotate and crop the image before it is uploaded */
+    edit?: ImageEdit;
+    /**
+     * Applies the edit and scales down images larger than the resizeImages
+     * option of the config: `alinea/core/media/TransformImage` does so in the
+     * browser or with sharp
+     */
+    transformImage?(blob: Blob, fileName: string, transform: ImageTransform): Promise<Blob>;
+    /**
+     * Recompresses the images of a pdf: `alinea/core/media/CompressPdf` does
+     * so in the browser or with sharp
+     */
+    compressPdf?(blob: Blob): Promise<Blob>;
     onProgress?(progress: UploadProgress): void;
     replaceId?: string;
+    /** Recorded as the creator, or the last editor of a replaced file */
+    user?: User | null;
 }
 export interface UploadProgress {
     loaded: number;

package/dist/core/db/Operation.js

@@ -1,16 +1,26 @@
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/db/Operation.ts
+import { Config } from "../Config.js";
+import { Entry } from "../Entry.js";
 import { Field } from "../Field.js";
 import { HttpError } from "../HttpError.js";
 import { createId } from "../Id.js";
+import {
+  hasImageEdit,
+  imageResizeOptions,
+  isTransformableImage
+} from "../media/ImageTransform.js";
 import { isImage } from "../media/IsImage.js";
+import { isPdf } from "../media/Pdf.js";
 import { MediaLocation } from "../media/MediaLocation.js";
+import { fileTypeAccepts } from "../media/MediaTypes.js";
 import { assertUploadSize } from "../media/UploadLimits.js";
+import { assert } from "../util/Assert.js";
 import { Schema } from "../Schema.js";
 import { Type } from "../Type.js";
 import { createFileHash } from "../util/ContentHash.js";
-import { keys } from "../util/Objects.js";
+import { entries, fromEntries, keys } from "../util/Objects.js";
 import { basename, extname } from "../util/Paths.js";
 import { slugify } from "../util/Slugs.js";
 import { Workspace } from "../Workspace.js";
@@ -39,7 +49,11 @@ var CreateOp = class extends Operation {
           locale: op.locale ?? null,
           parentId: op.parentId ?? null,
           type: typeName(config, op.type),
-          data: initializeSet(op.type, op.set),
+          data: Type.beforeSave(op.type, initializeSet(op.type, op.set), {
+            action: !op.overwrite ? "create" : (op.status ?? "published") === "published" ? "publish" : "update",
+            user: op.user,
+            now: /* @__PURE__ */ new Date()
+          }),
           insertOrder: op.insertOrder,
           status: op.status,
           overwrite: op.overwrite,
@@ -87,7 +101,7 @@ var DiscardOp = class extends Operation {
 };
 var UpdateOperation = class extends Operation {
   constructor(query) {
-    super(() => {
+    super(async (db) => {
       const { status = "published", locale = null, id, set } = query;
       return [
         {
@@ -95,12 +109,32 @@ var UpdateOperation = class extends Operation {
           id,
           locale,
           status,
-          set
+          set: await beforeUpdate(db, query)
         }
       ];
     });
   }
 };
+async function beforeUpdate(db, { status = "published", locale = null, id, set, user }) {
+  const current = await db.first({
+    select: { type: Entry.type, data: Entry.data },
+    id,
+    locale,
+    status
+  });
+  const type = current && db.config.schema[current.type];
+  if (!type) return set;
+  const updated = { ...current.data, ...set };
+  const saved = Type.beforeSave(type, updated, {
+    action: status === "published" ? "publish" : "update",
+    user,
+    now: /* @__PURE__ */ new Date()
+  });
+  const changed = entries(saved).filter(([key, value]) => {
+    return value !== updated[key];
+  });
+  return { ...set, ...fromEntries(changed) };
+}
 var MoveOperation = class extends Operation {
   constructor(query) {
     super(() => {
@@ -134,15 +168,45 @@ var UploadOperation = class extends Operation {
   constructor(query) {
     super(async (db) => {
       const entryId = this.id;
-      const { file, createPreview } = query;
+      const { file, createPreview, edit, transformImage, compressPdf } = query;
       const { workspace: _workspace, root: _root, parentId: _parentId } = query;
       const fileName = Array.isArray(file) ? file[0] : file.name;
       const workspace = _workspace ?? Object.keys(db.config.workspaces)[0];
       const root = _root ?? Workspace.defaultMediaRoot(db.config.workspaces[workspace]);
-      const fileSize = Array.isArray(file) ? file[1].byteLength : file.size;
+      let blob = Array.isArray(file) ? new Blob([file[1]]) : file;
+      let contentType = file instanceof Blob ? file.type : "application/octet-stream";
+      const typeName2 = await uploadType(db, query, {
+        workspace,
+        root,
+        fileName,
+        mimeType: file instanceof Blob ? file.type : void 0
+      });
+      const source = blob;
+      const edited = hasImageEdit(edit);
+      assert(
+        !edited || transformImage,
+        "Editing an upload needs transformImage"
+      );
+      const resize = imageResizeOptions(db.config.resizeImages);
+      const bytes = new Uint8Array(await source.arrayBuffer());
+      if (transformImage && (edited || resize) && isTransformableImage(fileName, bytes)) {
+        const transformed = await transformImage(blob, fileName, { edit, resize });
+        if (edited || transformed.size < blob.size) {
+          blob = transformed;
+          contentType = transformed.type;
+        }
+      }
+      if (compressPdf && isPdf(fileName)) {
+        const compressed = await compressPdf(blob);
+        if (compressed.size < blob.size) {
+          blob = compressed;
+          contentType = "application/pdf";
+        }
+      }
+      const sourceHash = blob !== source && !edited ? await createFileHash(bytes) : void 0;
+      const fileSize = blob.size;
       assertUploadSize(fileName, fileSize, db.config.maxUploadSize);
-      const body = Array.isArray(file) ? file[1] : await file.arrayBuffer();
-      const contentType = file instanceof Blob ? file.type : "application/octet-stream";
+      const body = await blob.arrayBuffer();
       const originalExtension = extname(fileName);
       const title = basename(fileName, originalExtension);
       const extension = originalExtension.toLowerCase();
@@ -155,10 +219,12 @@ var UploadOperation = class extends Operation {
       const info = await db.prepareUpload(uploadLocation, {
         size: fileSize
       });
-      const previewData = isImage(fileName) ? await createPreview?.(
-        file instanceof Blob ? file : new Blob([body])
+      const previewData = isImage(fileName) ? await createPreview?.(blob) : isPdf(fileName) ? (
+        // A pdf uploads without a preview when its page can't be read
+        pagePreview(await createPreview?.(blob).catch(() => void 0))
       ) : void 0;
       await sendUpload(info.url, info.method ?? "POST", contentType, body, {
+        headers: info.headers,
         onProgress: query.onProgress
       });
       const hash = await createFileHash(new Uint8Array(body));
@@ -172,23 +238,39 @@ var UploadOperation = class extends Operation {
         url: info.previewUrl,
         location: MediaLocation.storagePath(db.config, workspace, fileLocation)
       };
+      const fileType = db.config.schema[typeName2];
+      const uploaded = {
+        title,
+        location: fileLocation,
+        // Local uploads have no preview url, leave the empty value out
+        ...info.previewUrl ? { previewUrl: info.previewUrl } : {},
+        extension,
+        size: body.byteLength,
+        hash,
+        ...sourceHash ? { sourceHash } : {},
+        ...previewData
+      };
       const createEntry = {
         op: "create",
         id: entryId,
         locale: null,
         parentId: _parentId ?? null,
-        type: "MediaFile",
+        type: typeName2,
         root,
         workspace,
-        data: {
-          title,
-          location: fileLocation,
-          previewUrl: info.previewUrl,
-          extension,
-          size: body.byteLength,
-          hash,
-          ...previewData
-        },
+        data: Type.beforeSave(
+          fileType,
+          // A replaced file keeps the fields stored with it, see overwrite
+          query.replaceId ? uploaded : Type.withInitialValue(fileType, uploaded, {
+            fieldI18n: Config.fieldI18n(db.config, workspace, root)
+          }),
+          {
+            action: query.replaceId ? "update" : "create",
+            user: query.user,
+            now: /* @__PURE__ */ new Date()
+          }
+        ),
+        // The server keeps the stored details of the file this replaces
         overwrite: query.replaceId !== void 0
       };
       return [uploadFile, createEntry];
@@ -196,26 +278,80 @@ var UploadOperation = class extends Operation {
     this.id = query.replaceId ?? createId();
   }
 };
+async function uploadType(db, query, { workspace, root, fileName, mimeType }) {
+  const { config } = db;
+  if (query.replaceId) {
+    const current = await db.first({
+      id: query.replaceId,
+      select: Entry.type,
+      status: "preferDraft"
+    });
+    if (current) {
+      const type = config.schema[current];
+      if (type && !fileTypeAccepts(type, fileName, mimeType))
+        throw new HttpError(400, `"${current}" does not accept ${fileName}`);
+      return current;
+    }
+  }
+  const parentType = query.parentId ? await db.first({
+    id: query.parentId,
+    select: Entry.type,
+    status: "preferDraft"
+  }) : void 0;
+  const location = { workspace, root, parentType: parentType ?? void 0 };
+  const types = Config.uploadCandidates(config, location);
+  const accepting = types.filter(
+    (name) => fileTypeAccepts(config.schema[name], fileName, mimeType)
+  );
+  if (query.type) {
+    if (!types.includes(query.type))
+      throw new HttpError(
+        400,
+        `"${query.type}" can't be uploaded here, use one of ${types.join(", ")}`
+      );
+    if (!accepting.includes(query.type))
+      throw new HttpError(400, `"${query.type}" does not accept ${fileName}`);
+    return query.type;
+  }
+  if (accepting.length === 0)
+    throw new HttpError(
+      400,
+      `No file type here accepts ${fileName}, the types are ${types.join(", ")}`
+    );
+  return accepting[0];
+}
+function pagePreview(preview) {
+  if (!preview) return void 0;
+  const { preview: image, thumbHash, averageColor } = preview;
+  return { preview: image, thumbHash, averageColor };
+}
 async function sendUpload(url, method, contentType, body, options) {
-  const { onProgress } = options;
+  const { headers = {}, onProgress } = options;
   if (onProgress && typeof XMLHttpRequest !== "undefined") {
-    await uploadFileWithProgress(url, method, contentType, body, onProgress);
+    await uploadFileWithProgress(
+      url,
+      method,
+      { ...headers, "Content-Type": contentType },
+      body,
+      onProgress
+    );
     return;
   }
   await fetch(url, {
     method,
-    headers: { "Content-Type": contentType },
+    headers: { ...headers, "Content-Type": contentType },
     body
   }).then((result) => {
     if (!result.ok)
       throw new HttpError(result.status, "Could not reach server for upload");
   });
 }
-function uploadFileWithProgress(url, method, contentType, body, onProgress) {
+function uploadFileWithProgress(url, method, headers, body, onProgress) {
   return new Promise((resolve, reject) => {
     const request = new XMLHttpRequest();
     request.open(method, url);
-    request.setRequestHeader("Content-Type", contentType);
+    for (const [name, value] of Object.entries(headers))
+      request.setRequestHeader(name, value);
     request.upload.addEventListener("progress", (event) => {
       onProgress({
         loaded: event.loaded,

package/dist/core/db/SyncStats.d.ts

@@ -0,0 +1,16 @@
+import type { RemoteSource } from 'alinea/core/source/Source';
+import type { LocalStore, SyncOptions, SyncStats, SyncStep } from './LocalStore.js';
+export declare const syncSteps: Array<SyncStep>;
+export declare function syncStats(): SyncStats;
+/** Add the time `run` takes to a step, when the sync is measured. */
+export declare function timeStep<T>(stats: SyncStats | undefined, step: SyncStep, run: () => T | Promise<T>): Promise<T>;
+/**
+ * Sync and log why, between which revisions and where the time went, also
+ * when it fails: slow syncs are found in the server logs.
+ */
+export declare function loggedSync(store: Pick<LocalStore, 'sha' | 'syncWith'>, remote: RemoteSource, reason: string, options?: SyncOptions): Promise<string>;
+/**
+ * Such as `Alinea synced 1a2b3c4 → 5d6e7f8 (interval) in 812 ms: tree 80 ms,
+ * blobs 410 ms, …, 1 file, 4 versions derived`.
+ */
+export declare function describeSync(reason: string, from: string, to: string | undefined, durationMs: number, stats: SyncStats): string;