@elaraai/e3-cloud-files 1.1.0 → 1.1.2

package/dist/src/compat.d.ts

@@ -3,29 +3,31 @@
  * Licensed under BSL 1.1. See LICENSE for details.
  */
 /**
- * `@elaraai/e3-cloud-files/compat`: Files' stored values as the first
- * version wrote them, and their lift into the current types.
+ * `@elaraai/e3-cloud-files/compat`: Files' stored values as earlier versions
+ * wrote them, and their lift into the current types.
  *
  * The first version mapped a source's files to inputs alone: a mapping was
  * `{input, source, shape}`, a `file` or `latest` shape named no type, a
  * refusal's reason was a string, a sync was asked for `inputs`, and a ledger
- * entry held an ETag and a size. The current types map to a target (an
- * input, a record or a mutation), may name a type, tell refusals apart, ask
- * for `targets` and `reset`, and remember a file's hash and the commit a
- * seed or feed made.
+ * entry held an ETag and a size. The second maps to a target (an input, a
+ * record or a mutation), may name a type, tells refusals apart, asks for
+ * `targets` and `reset`, and remembers a file's hash and the commit a seed or
+ * feed made. The current also counts a record's seeds: a
+ * record's ledger keeps how many Files has made (`seeds`), and a mapping's
+ * report names a seed's commit and its number (`seed`).
  *
  * A store reads a stored value through {@link readFilesManifest},
  * {@link readFilesSyncReport}, {@link readFilesLedger},
  * {@link readFilesSyncJob} or {@link readFilesHistoryManifest}: each reads
  * the root type the bytes' beast2 header declares, decodes a current value as
- * it is, and decodes a first-version value with its own type and lifts it
- * (`input` → `target: input(name)`, each `file`/`latest` shape `type: none`,
- * a refusal's string `other(reason)`, the new fields none). A value is
- * written at the current version on its next write. The lifts are pure, so
- * the CLI lifts a local repository's state file through them too.
+ * it is, and decodes an older value with its own type and lifts it (`input`
+ * → `target: input(name)`, each `file`/`latest` shape `type: none`, a
+ * refusal's string `other(reason)`, the new fields none). A value is written
+ * at the current version on its next write. The lifts are pure, so the CLI
+ * lifts a local repository's state file through them too.
  *
- * The first version's types are kept here, and nowhere else, under their
- * `V1` names.
+ * The older versions' types are kept here, and nowhere else, under their
+ * `V1` and `V2` names.
  *
  * @packageDocumentation
  */
@@ -183,6 +185,592 @@ export declare const FilesSyncJobTypeV1: StructType<{
     }>>;
 }>;
 export type FilesSyncJobV1 = ValueTypeOf<typeof FilesSyncJobTypeV1>;
+/** A mapping's report of the second version: no seed's number. */
+export declare const FilesMappingReportTypeV2: StructType<{
+    readonly target: VariantType<{
+        readonly input: StringType;
+        readonly record: StringType;
+        readonly mutation: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+        }>;
+    }>;
+    readonly added: IntegerType;
+    readonly changed: IntegerType;
+    readonly removed: IntegerType;
+    readonly unchanged: IntegerType;
+    readonly refused: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly reason: VariantType<{
+            readonly too_large: StructType<{
+                readonly size: IntegerType;
+                readonly limit: IntegerType;
+            }>;
+            readonly segment_too_large: StructType<{
+                readonly bytes: IntegerType;
+                readonly limit: IntegerType;
+            }>;
+            readonly unreadable: StringType;
+            readonly not_beast2: StringType;
+            readonly type_mismatch: StructType<{
+                readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: import("@elaraai/east").NullType;
+                    readonly Null: import("@elaraai/east").NullType;
+                    readonly Boolean: import("@elaraai/east").NullType;
+                    readonly Integer: import("@elaraai/east").NullType;
+                    readonly Float: import("@elaraai/east").NullType;
+                    readonly String: import("@elaraai/east").NullType;
+                    readonly DateTime: import("@elaraai/east").NullType;
+                    readonly Blob: import("@elaraai/east").NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: import("@elaraai/east").NullType;
+                    readonly Null: import("@elaraai/east").NullType;
+                    readonly Boolean: import("@elaraai/east").NullType;
+                    readonly Integer: import("@elaraai/east").NullType;
+                    readonly Float: import("@elaraai/east").NullType;
+                    readonly String: import("@elaraai/east").NullType;
+                    readonly DateTime: import("@elaraai/east").NullType;
+                    readonly Blob: import("@elaraai/east").NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+            }>;
+            readonly mutation: StructType<{
+                readonly outcome: StringType;
+                readonly message: StringType;
+            }>;
+            readonly missing: StringType;
+            readonly other: StringType;
+        }>;
+    }>>;
+    readonly bytes: IntegerType;
+    readonly updated: BooleanType;
+    readonly taken: OptionType<StructType<{
+        readonly key: StringType;
+        readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: import("@elaraai/east").NullType;
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").NullType;
+            readonly Integer: import("@elaraai/east").NullType;
+            readonly Float: import("@elaraai/east").NullType;
+            readonly String: import("@elaraai/east").NullType;
+            readonly DateTime: import("@elaraai/east").NullType;
+            readonly Blob: import("@elaraai/east").NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly rows: OptionType<IntegerType>;
+        readonly how: VariantType<{
+            readonly carried: import("@elaraai/east").NullType;
+            readonly split: import("@elaraai/east").NullType;
+        }>;
+    }>>;
+    readonly commit: OptionType<StringType>;
+    readonly kept: OptionType<StringType>;
+    readonly waiting: OptionType<StringType>;
+}>;
+export type FilesMappingReportV2 = ValueTypeOf<typeof FilesMappingReportTypeV2>;
+/** A sync's report of the second version. */
+export declare const FilesSyncReportTypeV2: StructType<{
+    readonly started: DateTimeType;
+    readonly finished: DateTimeType;
+    readonly dryRun: BooleanType;
+    readonly mappings: ArrayType<StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+        readonly added: IntegerType;
+        readonly changed: IntegerType;
+        readonly removed: IntegerType;
+        readonly unchanged: IntegerType;
+        readonly refused: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly reason: VariantType<{
+                readonly too_large: StructType<{
+                    readonly size: IntegerType;
+                    readonly limit: IntegerType;
+                }>;
+                readonly segment_too_large: StructType<{
+                    readonly bytes: IntegerType;
+                    readonly limit: IntegerType;
+                }>;
+                readonly unreadable: StringType;
+                readonly not_beast2: StringType;
+                readonly type_mismatch: StructType<{
+                    readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: import("@elaraai/east").NullType;
+                        readonly Null: import("@elaraai/east").NullType;
+                        readonly Boolean: import("@elaraai/east").NullType;
+                        readonly Integer: import("@elaraai/east").NullType;
+                        readonly Float: import("@elaraai/east").NullType;
+                        readonly String: import("@elaraai/east").NullType;
+                        readonly DateTime: import("@elaraai/east").NullType;
+                        readonly Blob: import("@elaraai/east").NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: import("@elaraai/east").NullType;
+                        readonly Null: import("@elaraai/east").NullType;
+                        readonly Boolean: import("@elaraai/east").NullType;
+                        readonly Integer: import("@elaraai/east").NullType;
+                        readonly Float: import("@elaraai/east").NullType;
+                        readonly String: import("@elaraai/east").NullType;
+                        readonly DateTime: import("@elaraai/east").NullType;
+                        readonly Blob: import("@elaraai/east").NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                }>;
+                readonly mutation: StructType<{
+                    readonly outcome: StringType;
+                    readonly message: StringType;
+                }>;
+                readonly missing: StringType;
+                readonly other: StringType;
+            }>;
+        }>>;
+        readonly bytes: IntegerType;
+        readonly updated: BooleanType;
+        readonly taken: OptionType<StructType<{
+            readonly key: StringType;
+            readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: import("@elaraai/east").NullType;
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").NullType;
+                readonly Integer: import("@elaraai/east").NullType;
+                readonly Float: import("@elaraai/east").NullType;
+                readonly String: import("@elaraai/east").NullType;
+                readonly DateTime: import("@elaraai/east").NullType;
+                readonly Blob: import("@elaraai/east").NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly rows: OptionType<IntegerType>;
+            readonly how: VariantType<{
+                readonly carried: import("@elaraai/east").NullType;
+                readonly split: import("@elaraai/east").NullType;
+            }>;
+        }>>;
+        readonly commit: OptionType<StringType>;
+        readonly kept: OptionType<StringType>;
+        readonly waiting: OptionType<StringType>;
+    }>>;
+}>;
+export type FilesSyncReportV2 = ValueTypeOf<typeof FilesSyncReportTypeV2>;
+/** A ledger of the second version: no count of a record's seeds. */
+export declare const FilesLedgerTypeV2: StructType<{
+    readonly entries: DictType<StringType, StructType<{
+        readonly etag: StringType;
+        readonly size: IntegerType;
+        readonly sha256: OptionType<StringType>;
+        readonly modified: OptionType<DateTimeType>;
+    }>>;
+    readonly value: OptionType<StringType>;
+    readonly under: OptionType<StringType>;
+    readonly commit: OptionType<StringType>;
+    readonly tried: OptionType<StringType>;
+    readonly taking: OptionType<StructType<{
+        readonly key: StringType;
+        readonly etag: StringType;
+        readonly sha256: OptionType<StringType>;
+        readonly staging: OptionType<StringType>;
+    }>>;
+}>;
+export type FilesLedgerValueV2 = ValueTypeOf<typeof FilesLedgerTypeV2>;
+/** A sync of the second version: its report of the second version. */
+export declare const FilesSyncJobTypeV2: StructType<{
+    readonly id: StringType;
+    readonly workspace: StringType;
+    readonly by: StringType;
+    readonly dryRun: BooleanType;
+    readonly targets: OptionType<ArrayType<VariantType<{
+        readonly input: StringType;
+        readonly record: StringType;
+        readonly mutation: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+        }>;
+    }>>>;
+    readonly reset: ArrayType<StringType>;
+    readonly state: VariantType<{
+        readonly running: import("@elaraai/east").NullType;
+        readonly succeeded: import("@elaraai/east").NullType;
+        readonly failed: StringType;
+    }>;
+    readonly startedAt: DateTimeType;
+    readonly finishedAt: OptionType<DateTimeType>;
+    readonly report: OptionType<StructType<{
+        readonly started: DateTimeType;
+        readonly finished: DateTimeType;
+        readonly dryRun: BooleanType;
+        readonly mappings: ArrayType<StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+            readonly added: IntegerType;
+            readonly changed: IntegerType;
+            readonly removed: IntegerType;
+            readonly unchanged: IntegerType;
+            readonly refused: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly reason: VariantType<{
+                    readonly too_large: StructType<{
+                        readonly size: IntegerType;
+                        readonly limit: IntegerType;
+                    }>;
+                    readonly segment_too_large: StructType<{
+                        readonly bytes: IntegerType;
+                        readonly limit: IntegerType;
+                    }>;
+                    readonly unreadable: StringType;
+                    readonly not_beast2: StringType;
+                    readonly type_mismatch: StructType<{
+                        readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                            readonly Never: import("@elaraai/east").NullType;
+                            readonly Null: import("@elaraai/east").NullType;
+                            readonly Boolean: import("@elaraai/east").NullType;
+                            readonly Integer: import("@elaraai/east").NullType;
+                            readonly Float: import("@elaraai/east").NullType;
+                            readonly String: import("@elaraai/east").NullType;
+                            readonly DateTime: import("@elaraai/east").NullType;
+                            readonly Blob: import("@elaraai/east").NullType;
+                            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Dict: StructType<{
+                                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Struct: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Variant: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Recursive: VariantType<{
+                                readonly ref: IntegerType;
+                                readonly wrapper: StructType<{
+                                    readonly id: IntegerType;
+                                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                            }>;
+                            readonly Function: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly AsyncFunction: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                            readonly Never: import("@elaraai/east").NullType;
+                            readonly Null: import("@elaraai/east").NullType;
+                            readonly Boolean: import("@elaraai/east").NullType;
+                            readonly Integer: import("@elaraai/east").NullType;
+                            readonly Float: import("@elaraai/east").NullType;
+                            readonly String: import("@elaraai/east").NullType;
+                            readonly DateTime: import("@elaraai/east").NullType;
+                            readonly Blob: import("@elaraai/east").NullType;
+                            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Dict: StructType<{
+                                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Struct: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Variant: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Recursive: VariantType<{
+                                readonly ref: IntegerType;
+                                readonly wrapper: StructType<{
+                                    readonly id: IntegerType;
+                                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                            }>;
+                            readonly Function: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly AsyncFunction: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                    }>;
+                    readonly mutation: StructType<{
+                        readonly outcome: StringType;
+                        readonly message: StringType;
+                    }>;
+                    readonly missing: StringType;
+                    readonly other: StringType;
+                }>;
+            }>>;
+            readonly bytes: IntegerType;
+            readonly updated: BooleanType;
+            readonly taken: OptionType<StructType<{
+                readonly key: StringType;
+                readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: import("@elaraai/east").NullType;
+                    readonly Null: import("@elaraai/east").NullType;
+                    readonly Boolean: import("@elaraai/east").NullType;
+                    readonly Integer: import("@elaraai/east").NullType;
+                    readonly Float: import("@elaraai/east").NullType;
+                    readonly String: import("@elaraai/east").NullType;
+                    readonly DateTime: import("@elaraai/east").NullType;
+                    readonly Blob: import("@elaraai/east").NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly rows: OptionType<IntegerType>;
+                readonly how: VariantType<{
+                    readonly carried: import("@elaraai/east").NullType;
+                    readonly split: import("@elaraai/east").NullType;
+                }>;
+            }>>;
+            readonly commit: OptionType<StringType>;
+            readonly kept: OptionType<StringType>;
+            readonly waiting: OptionType<StringType>;
+        }>>;
+    }>>;
+}>;
+export type FilesSyncJobV2 = ValueTypeOf<typeof FilesSyncJobTypeV2>;
 /**
  * A first-version shape as the current one: a `file` or `latest` names no type.
  *
@@ -233,6 +821,34 @@ export declare function liftFilesLedgerV1(ledger: FilesLedgerValueV1): FilesLedg
  * @returns The current sync
  */
 export declare function liftFilesSyncJobV1(job: FilesSyncJobV1): FilesSyncJob;
+/**
+ * A second-version mapping's report as the current one: no seed's number.
+ *
+ * @param report - The report
+ * @returns The current report
+ */
+export declare function liftFilesMappingReportV2(report: FilesMappingReportV2): FilesMappingReport;
+/**
+ * A second-version sync's report as the current one.
+ *
+ * @param report - The report
+ * @returns The current report
+ */
+export declare function liftFilesSyncReportV2(report: FilesSyncReportV2): FilesSyncReport;
+/**
+ * A second-version ledger as the current one: its record's seeds not counted.
+ *
+ * @param ledger - The ledger
+ * @returns The current ledger
+ */
+export declare function liftFilesLedgerV2(ledger: FilesLedgerValueV2): FilesLedgerValue;
+/**
+ * A second-version sync as the current one.
+ *
+ * @param job - The sync
+ * @returns The current sync
+ */
+export declare function liftFilesSyncJobV2(job: FilesSyncJobV2): FilesSyncJob;
 /** Reads stored declarations, at any version, as the current ones. */
 export declare const readFilesManifest: (bytes: Uint8Array) => FilesManifest;
 /** Reads a stored sync's report, at any version, as the current one. */