@elaraai/e3-cloud-cli 1.0.93 → 1.0.97

package/dist/src/files-local.d.ts

@@ -2,24 +2,121 @@
  * Copyright (c) 2025 Elara AI Pty Ltd
  * Licensed under BSL 1.1. See LICENSE for details.
  */
-import { ArrayType, DictType, OptionType, StringType, StructType, type ValueTypeOf } from '@elaraai/east';
-import { type FilesBinding, type FilesManifest, type FilesProblem, type FilesStatus, type FilesSyncReport } from '@elaraai/e3-cloud-types';
+import { ArrayType, DictType, IntegerType, OptionType, StringType, StructType, type ValueTypeOf } from '@elaraai/east';
+import { type TaskRunner } from '@elaraai/e3-core';
+import { type FilesBinding, type FilesManifest, type FilesProblem, type FilesPushPlan, type FilesStatus, type FilesSyncReport, type FilesTarget } from '@elaraai/e3-cloud-types';
 import { type FilesLedger, type FilesReader } from '@elaraai/e3-cloud-files/sync';
+import type { OfferedFile } from './files-push.js';
+/** The version of the state file this CLI writes. */
+export declare const LOCAL_FILES_VERSION = 2n;
 /** What a local repository keeps of one workspace's Files. */
 export declare const LocalFilesStateType: StructType<{
+    /** The state file's version: {@link LOCAL_FILES_VERSION} */
+    readonly version: IntegerType;
     /** The declarations deployed to the workspace */
     readonly manifest: OptionType<StructType<{
         readonly sources: ArrayType<StringType>;
         readonly mappings: ArrayType<StructType<{
-            readonly input: StringType;
+            readonly target: import("@elaraai/east").VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
             readonly source: StringType;
             readonly shape: import("@elaraai/east").VariantType<{
                 readonly file: StructType<{
                     readonly key: StringType;
+                    readonly type: OptionType<import("@elaraai/east").RecursiveType<import("@elaraai/east").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: import("@elaraai/east").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 latest: StructType<{
                     readonly prefix: StringType;
                     readonly include: OptionType<StringType>;
+                    readonly type: OptionType<import("@elaraai/east").RecursiveType<import("@elaraai/east").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: import("@elaraai/east").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 folder: StructType<{
                     readonly prefix: StringType;
@@ -38,16 +135,26 @@ export declare const LocalFilesStateType: StructType<{
         readonly url: StringType;
         readonly region: OptionType<StringType>;
         readonly profile: OptionType<StringType>;
-        readonly latest: OptionType<import("@elaraai/east").IntegerType>;
+        readonly latest: OptionType<IntegerType>;
     }>>;
-    /** What each input took last, by input */
+    /** What each target took last, by its ledger key */
     readonly ledgers: DictType<StringType, StructType<{
         readonly entries: DictType<StringType, StructType<{
             readonly etag: StringType;
-            readonly size: import("@elaraai/east").IntegerType;
+            readonly size: IntegerType;
+            readonly sha256: OptionType<StringType>;
+            readonly modified: OptionType<import("@elaraai/east").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>;
+        }>>;
     }>>;
     /** The last sync's report; a dry run's is never kept */
     readonly lastSync: OptionType<StructType<{
@@ -55,17 +162,180 @@ export declare const LocalFilesStateType: StructType<{
         readonly finished: import("@elaraai/east").DateTimeType;
         readonly dryRun: import("@elaraai/east").BooleanType;
         readonly mappings: ArrayType<StructType<{
-            readonly input: StringType;
-            readonly added: import("@elaraai/east").IntegerType;
-            readonly changed: import("@elaraai/east").IntegerType;
-            readonly removed: import("@elaraai/east").IntegerType;
-            readonly unchanged: import("@elaraai/east").IntegerType;
+            readonly target: import("@elaraai/east").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: StringType;
+                readonly reason: import("@elaraai/east").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<import("@elaraai/east").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: import("@elaraai/east").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<import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").IntegerType;
+            readonly bytes: IntegerType;
             readonly updated: import("@elaraai/east").BooleanType;
+            readonly taken: OptionType<StructType<{
+                readonly key: StringType;
+                readonly type: import("@elaraai/east").RecursiveType<import("@elaraai/east").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: import("@elaraai/east").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: import("@elaraai/east").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>;
         }>>;
     }>>;
 }>;
@@ -85,11 +355,11 @@ export declare function openLocalRepository(repoArg: string): Promise<string>;
  * @throws {Error} When the name is no workspace's
  */
 export declare function statePath(repoPath: string, ws: string): string;
-/** What a repository keeps of a workspace's Files: nothing yet, before its first deploy. */
+/** What a repository keeps of a workspace's Files: nothing yet, before its first deploy; a first-version file lifted. */
 export declare function readState(repoPath: string, ws: string): LocalFilesState;
 /** Keeps a workspace's Files, replacing the file whole so a reader never sees half of it. */
 export declare function writeState(repoPath: string, ws: string, state: LocalFilesState): void;
-/** The ledger over the repository's file: each write keeps what an input took the moment it is written. */
+/** The ledger over the repository's file: each write keeps what a target took the moment it is written. */
 export declare function stateLedger(repoPath: string, ws: string): FilesLedger;
 /**
  * Reads each bound source's bucket with the developer's credentials: the
@@ -109,18 +379,18 @@ export interface LocalDeployResult {
     };
     /** Why the declarations do not fit it; none when they were deployed */
     readonly problems: readonly FilesProblem[];
-    /** The inputs whose declaration changed, which the next sync takes again whole */
-    readonly retaken: readonly string[];
+    /** The targets whose declaration changed, which the next sync takes again whole */
+    readonly retaken: readonly FilesTarget[];
 }
 /**
  * Deploys declarations to a workspace, checked against the package it runs.
- * An input whose declaration changed is taken again whole by the next sync.
+ * A target whose declaration changed is taken again whole by the next sync.
  *
  * @param repoPath - The repository ({@link openLocalRepository})
  * @param ws - The workspace
  * @param manifest - The declarations
  * @param options - `dryRun`: check them, and keep nothing
- * @returns The package, every problem, and the inputs taken again
+ * @returns The package, every problem, and the targets taken again
  */
 export declare function deployLocal(repoPath: string, ws: string, manifest: FilesManifest, options?: {
     dryRun?: boolean;
@@ -129,48 +399,84 @@ export declare function deployLocal(repoPath: string, ws: string, manifest: File
 export interface LocalBindResult {
     /** Why the binding does not fit the declarations; none when it was kept */
     readonly problems: readonly FilesProblem[];
-    /** The inputs the source fills, which the next sync takes again whole when the binding moved */
-    readonly retaken: readonly string[];
+    /** The targets the source fills, which the next sync takes again whole when the binding moved */
+    readonly retaken: readonly FilesTarget[];
 }
 /**
  * Binds a source to where its files are, for a workspace. A binding moved to
- * another URL has its inputs taken again whole by the next sync.
+ * another URL has its targets taken again whole by the next sync.
  *
  * @param repoPath - The repository
  * @param ws - The workspace
  * @param binding - The binding
- * @returns Every problem, and the inputs taken again
+ * @returns Every problem, and the targets taken again
  * @throws {Error} When the workspace has no declarations deployed
  */
 export declare function bindLocal(repoPath: string, ws: string, binding: FilesBinding): LocalBindResult;
 /** What a local sync is given. */
 export interface LocalSyncOptions {
-    /** Only these inputs; every declared input when absent */
-    readonly inputs?: readonly string[];
+    /** Only these targets; every declared target when absent */
+    readonly targets?: readonly FilesTarget[];
+    /** Records whose file is taken as their state again, whatever has mutated them since their seed */
+    readonly reset?: readonly string[];
     /** List what a sync would take, and take nothing */
     readonly dryRun?: boolean;
     /** Reads a bound source: its bucket, with the developer's credentials, when absent ({@link s3Readers}) */
     readonly reader?: (binding: FilesBinding) => FilesReader;
+    /** The runner that takes a typed collection in and runs a fed mutation: this machine's, when absent */
+    readonly runner?: TaskRunner;
 }
 /**
- * Syncs a workspace's inputs with their sources' files. The declarations are
+ * Syncs a workspace's targets with their sources' files. The declarations are
  * checked again first, against the package the workspace runs now.
  *
  * @param repoPath - The repository
  * @param ws - The workspace
- * @param options - Which inputs, whether a dry run, and the reader
- * @returns What it did, per input
+ * @param options - Which targets, whether a dry run, the reader and the runner
+ * @returns What it did, per target
  * @throws {FilesSyncError} When the declarations no longer fit the package, or
  *   a source is not bound, before anything is read
  * @throws {Error} When the workspace has no declarations deployed
  */
 export declare function syncLocal(repoPath: string, ws: string, options?: LocalSyncOptions): Promise<FilesSyncReport>;
 /**
- * A workspace's Files: its declarations, its bindings and its last sync.
+ * A workspace's Files: its declarations, its bindings, its last sync, and
+ * what each mapping holds (a pending record among them).
  *
  * @param repoPath - The repository
  * @param ws - The workspace
  * @returns Its status
  */
-export declare function statusLocal(repoPath: string, ws: string): FilesStatus;
+export declare function statusLocal(repoPath: string, ws: string): Promise<FilesStatus>;
+/** What a local push is given. */
+export interface LocalPushOptions {
+    /** The target every file is for; null to match each by its name */
+    readonly as?: string;
+    /** Records whose file is taken as their state again */
+    readonly reset?: readonly string[];
+    /** Plan, and put nothing */
+    readonly dryRun?: boolean;
+    /** The profile to put with, over each binding's */
+    readonly profile?: string;
+    /** Reads a bound source, when not its bucket with the developer's credentials ({@link s3Readers}) */
+    readonly reader?: (binding: FilesBinding) => FilesReader;
+    /** Puts a file to a binding, when not through the developer's credentials (a test's) */
+    readonly put?: (binding: FilesBinding, key: string, file: OfferedFile) => Promise<void>;
+    /** The runner that takes a typed collection in and runs a fed mutation */
+    readonly runner?: TaskRunner;
+}
+/**
+ * Plans a push on a local repository: the same plan a deployed workspace's
+ * route makes, over the repository's declarations, bindings and ledgers,
+ * a `latest` prefix listed and a key read through the developer's own
+ * credentials; every put is the client's own (`external`).
+ *
+ * @param repoPath - The repository
+ * @param ws - The workspace
+ * @param files - The files offered
+ * @param options - The target named, and the reader
+ * @returns The plan, as the route answers one
+ * @throws {Error} When the workspace has no declarations deployed
+ */
+export declare function planLocal(repoPath: string, ws: string, files: readonly OfferedFile[], options?: Pick<LocalPushOptions, 'as' | 'reader'>): Promise<FilesPushPlan>;
 //# sourceMappingURL=files-local.d.ts.map

package/dist/src/files-local.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"files-local.d.ts","sourceRoot":"","sources":["../../src/files-local.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"files-local.d.ts","sourceRoot":"","sources":["../../src/files-local.ts"],"names":[],"mappings":"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"}