@elaraai/e3-cloud-cli 1.1.0 → 1.1.2

package/dist/src/files-push.js

@@ -3,34 +3,46 @@
  * Licensed under BSL 1.1. See LICENSE for details.
  */
 /**
- * `e3-cloud files push`: files from disk into a source, and taken in.
+ * `e3-cloud files push`: files from disk, and a repository's datasets as the
+ * files of their values, into a source, and taken in.
  *
  * Each file offered is read for its size, its SHA-256 (streamed) and the
  * root type its beast2 header declares (through ranged reads of its head; a
  * file that is no beast2 offers no type); a directory is walked, its
  * `.`-prefixed entries skipped, each file offered at its path relative to
- * the directory, with the directory's name. The plan comes from the
- * platform (`POST …/files/push`) for a repository URL, or from the same
- * engine over the local repository's declarations, bindings and ledgers for
- * a path; it says, per file, its target and key and how to put it. A `put`
- * is uploaded: `single` by one PUT with the plan's headers; `multipart` part
- * by part (four in flight, each read from the file by range), then
- * completed through the API; `external` through the bucket's own client
- * with the developer's own credentials (`--profile`, the binding's, or the
- * ambient chain), in parts past 64 MiB. Then one sync of the targets put, waited
- * on, and each file's row completed from the sync's report. Nothing is put
- * for a dry run.
+ * the directory, with the directory's name. A dataset (`dataset:<ws>.<name>`)
+ * is read from its repository, local or deployed, for the same, as the file
+ * of its value (`./dataset-source.ts`); one unassigned, not in its workspace
+ * or named twice there is refused in its own row and never planned. Rows keep
+ * the order the paths were given.
+ *
+ * The plan comes from the platform (`POST …/files/push`) for a repository
+ * URL, or from the same engine over the local repository's declarations,
+ * bindings and ledgers for a path; it says, per file, its target and key and
+ * how to put it. A `put` is uploaded: `single` by one PUT with the plan's
+ * headers, or `multipart` part by part then completed through the API, both
+ * by the client's `uploadFilesPush` (a file's parts four in flight, each read
+ * by range; a dataset's one after another from one read); `external` through
+ * the bucket's own client with the developer's own credentials (`--profile`,
+ * the binding's, or the ambient chain), in parts past 64 MiB, a dataset's
+ * file with the metadata naming it, which its seed's or feed's history
+ * records. Then one sync of the targets put, waited on, and each row
+ * completed from the sync's report. Nothing is put for a dry run.
+ *
+ * A push to a local repository is {@link pushLocal} whole: the plan, the puts
+ * and the sync, over the repository's own declarations, bindings and ledgers.
  */
 import { createHash } from 'node:crypto';
-import { createReadStream, openSync, closeSync, readSync, statSync, readdirSync, fstatSync } from 'node:fs';
+import { createReadStream, openSync, closeSync, readSync, statSync, readdirSync } from 'node:fs';
 import { basename, join, relative, resolve, sep } from 'node:path';
-import { Readable } from 'node:stream';
 import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CreateMultipartUploadCommand, PutObjectCommand, S3Client, UploadPartCommand, } from '@aws-sdk/client-s3';
 import { none, some } from '@elaraai/east';
-import { FILES_PUSH_PART_BYTES, filesPushRefusalText, filesTargetText, filesTypeWords, sameFilesTarget, } from '@elaraai/e3-cloud-types';
+import { FILES_PUSH_PART_BYTES, filesDatasetMetadata, filesPushRefusalText, filesTargetText, filesTypeWords, sameFilesTarget, } from '@elaraai/e3-cloud-types';
 import { parseBucketUrl } from '@elaraai/e3-cloud-files/check';
 import { beast2HeaderTypeOf } from '@elaraai/e3-cloud-files/sync';
-/** Parts of a multipart upload in flight at once. */
+import { DatasetMovedError, datasetArgOf, measuredDataset } from './dataset-source.js';
+import { planLocal, syncLocal } from './files-local.js';
+/** Uploads of an external multipart upload's parts in flight at once. */
 const PARTS_IN_FLIGHT = 4;
 /**
  * The root type a file's beast2 header declares, through reads of its head
@@ -70,6 +82,15 @@ async function sha256Of(path) {
         hash.update(chunk);
     return hash.digest('hex');
 }
+/** A file's bytes from an offset to its end. */
+async function* fileFrom(path, start) {
+    for await (const chunk of createReadStream(path, { start }))
+        yield chunk;
+}
+/** A file's bytes as an upload reads them: from any offset, for nothing. */
+function fileBytes(path, size) {
+    return { size, ranged: true, read: (start) => fileFrom(path, start) };
+}
 /** The files under a directory, walked, `.`-prefixed entries skipped, each path relative to it. */
 function walk(dir) {
     const files = [];
@@ -105,7 +126,12 @@ export async function offeredFiles(paths) {
         const one = async (file, name, directory) => {
             const size = statSync(file).size;
             const type = await fileBeast2Type(file, size);
-            offered.push({ path: file, offered: { name, directory: directory === null ? none : some(directory), size: BigInt(size), sha256: await sha256Of(file), type: type === null ? none : some(type) } });
+            offered.push({
+                label: directory === null ? name : `${directory}/${name}`,
+                offered: { name, directory: directory === null ? none : some(directory), size: BigInt(size), sha256: await sha256Of(file), type: type === null ? none : some(type), dataset: none },
+                bytes: fileBytes(file, size),
+                origin: null,
+            });
         };
         if (stat.isDirectory()) {
             for (const name of walk(path))
@@ -120,50 +146,84 @@ export async function offeredFiles(paths) {
     }
     return offered;
 }
-/** A file's bytes as a web stream, for a PUT. */
-function body(path, start, end) {
-    return Readable.toWeb(createReadStream(path, start === undefined ? {} : { start, end }));
+/**
+ * A dataset found, as a push offers it: its value read once for its size,
+ * its SHA-256 and its type, and named by its path and what it is.
+ *
+ * @param found - The dataset
+ * @returns The file of its value
+ * @throws {DatasetMovedError} When it moves while it is read
+ */
+export async function offeredDataset(found) {
+    const measured = await measuredDataset(found);
+    return {
+        label: `${found.arg.arg} (${found.kind})`,
+        offered: {
+            name: found.arg.arg,
+            directory: none,
+            size: BigInt(measured.size),
+            sha256: measured.sha256,
+            type: some(measured.type),
+            dataset: some({ workspace: found.arg.workspace, name: found.arg.name, hash: found.hash }),
+        },
+        bytes: measured.bytes,
+        origin: measured.origin,
+    };
 }
-/** One PUT of a file to a presigned URL, with the plan's headers. */
-async function putSingle(path, size, url, headers) {
-    const response = await fetch(url, {
-        method: 'PUT',
-        headers: { ...Object.fromEntries(headers), 'content-length': String(size) },
-        body: body(path),
-        // A streamed request body
-        duplex: 'half',
-    });
-    if (!response.ok)
-        throw new Error(`the upload answered HTTP ${response.status}: ${(await response.text()).slice(0, 200)}`);
+/** A row refusing what was offered before any plan. */
+function refusedRow(label, size, put) {
+    return { label, size, target: null, kind: '', put, sync: '' };
 }
-/** A multipart upload part by part, each read from the file by range; answers each part's ETag. */
-async function putParts(path, size, partBytes, parts) {
-    const etags = [];
-    let next = 0;
-    const worker = async () => {
-        for (;;) {
-            const i = next++;
-            if (i >= parts.length)
-                return;
-            const part = parts[i];
-            const start = i * partBytes;
-            const end = Math.min(size, start + partBytes) - 1;
-            const response = await fetch(part.url, {
-                method: 'PUT',
-                headers: { 'content-length': String(end - start + 1) },
-                body: body(path, start, end),
-                duplex: 'half',
-            });
-            if (!response.ok)
-                throw new Error(`part ${part.number} answered HTTP ${response.status}: ${(await response.text()).slice(0, 200)}`);
-            const etag = response.headers.get('etag');
-            if (etag === null)
-                throw new Error(`part ${part.number} answered no ETag`);
-            etags.push({ number: part.number, etag: etag.replace(/^"|"$/g, '') });
+/**
+ * What a push offers, in the order its paths were given: each file, each
+ * directory's files, and each dataset (`dataset:<ws>.<name>`) read from the
+ * repository `--from` names; a dataset that is unassigned, not in its
+ * workspace or named twice there, or that moves while it is read, refused in
+ * its own row.
+ *
+ * @param paths - Files, directories and datasets
+ * @param repository - Where datasets are read, opened once, only when a path names one
+ * @returns Each offering, in order
+ * @throws {Error} When a path is neither a file, a directory nor a dataset's name
+ */
+export async function offerings(paths, repository) {
+    let opened = null;
+    const found = [];
+    for (const given of paths) {
+        const arg = datasetArgOf(given);
+        if (arg === null) {
+            for (const file of await offeredFiles([given]))
+                found.push({ file });
+            continue;
         }
-    };
-    await Promise.all(Array.from({ length: Math.min(PARTS_IN_FLIGHT, parts.length) }, worker));
-    return etags.sort((a, b) => (a.number < b.number ? -1 : a.number > b.number ? 1 : 0));
+        opened ??= await repository();
+        const [lookup] = await opened.find([arg]);
+        if ('refused' in lookup) {
+            found.push({ refused: refusedRow(given, null, `refused: ${lookup.message}`) });
+            continue;
+        }
+        try {
+            found.push({ file: await offeredDataset(lookup.found) });
+        }
+        catch (err) {
+            if (!(err instanceof DatasetMovedError))
+                throw err;
+            found.push({ refused: refusedRow(`${given} (${lookup.found.kind})`, null, `failed: ${err.message}`) });
+        }
+    }
+    return found;
+}
+/**
+ * Each offering's row, in the order the paths were given: a planned file's
+ * from the plan's rows, in turn; a refused dataset's its own.
+ *
+ * @param offered - The offerings
+ * @param planned - The rows of the files planned, in the plan's order
+ * @returns The rows
+ */
+export function rowsInOrder(offered, planned) {
+    let next = 0;
+    return offered.map((o) => ('file' in o ? planned[next++] : o.refused));
 }
 /**
  * A client of the developer's own credentials for a bucket: the profile
@@ -178,88 +238,129 @@ export function ownClient(binding, profile) {
     const chosen = profile ?? (binding.profile.type === 'some' ? binding.profile.value : undefined);
     return new S3Client({ ...(chosen !== undefined && { profile: chosen }), ...(region !== undefined && { region }), followRegionRedirects: true });
 }
+/** Bytes, one after another, in one buffer. */
+function joined(parts, length) {
+    const out = new Uint8Array(length);
+    let at = 0;
+    for (const part of parts) {
+        out.set(part, at);
+        at += part.length;
+    }
+    return out;
+}
+/**
+ * A source's bytes in parts of `partBytes` (the last the rest), in order, from
+ * one read: each part whole, for its checksum. A whole part is given once the
+ * byte after it has come, so the last is given only after the read has ended,
+ * and a source that checks its bytes as they end (a dataset's) is heard
+ * before an upload of them is completed.
+ *
+ * @throws {Error} When the bytes are not as many as planned: a file that changed while it was read
+ */
+async function* partsOf(bytes, partBytes) {
+    let held = [];
+    let heldBytes = 0;
+    let total = 0;
+    for await (const chunk of bytes.read(0)) {
+        total += chunk.length;
+        if (total > bytes.size)
+            throw new Error(`the bytes run past the ${bytes.size} planned: it changed while it was read`);
+        let at = 0;
+        while (at < chunk.length) {
+            if (heldBytes === partBytes) {
+                // A whole part, with more to come
+                yield joined(held, heldBytes);
+                held = [];
+                heldBytes = 0;
+            }
+            const take = Math.min(chunk.length - at, partBytes - heldBytes);
+            held.push(chunk.subarray(at, at + take));
+            heldBytes += take;
+            at += take;
+        }
+    }
+    if (total !== bytes.size)
+        throw new Error(`the bytes end ${bytes.size - total} short of the ${bytes.size} planned: it changed while it was read`);
+    if (heldBytes > 0 || bytes.size === 0)
+        yield joined(held, heldBytes);
+}
+/** A SHA-256 as the bucket's checksum takes it: base64. */
+const checksumOf = (sha256) => Buffer.from(sha256, 'hex').toString('base64');
 /**
  * A put with the developer's own credentials: one PUT up to the part size,
- * else a multipart upload in parts, the file read by range.
+ * its bytes held to the SHA-256 the plan was given; else a multipart upload in
+ * parts, each with its own checksum, read from one read and four sent at once.
+ * A dataset's file carries the metadata naming the dataset.
  *
  * @param client - The client
  * @param bucket - The bucket
  * @param key - The object's key
- * @param path - The file
- * @param size - Its size
+ * @param file - The file or dataset
  */
-export async function putExternal(client, bucket, key, path, size) {
+export async function putExternal(client, bucket, key, file) {
+    const size = file.bytes.size;
+    const metadata = file.origin === null ? undefined : filesDatasetMetadata(file.origin);
     if (size <= FILES_PUSH_PART_BYTES) {
-        const bytes = new Uint8Array(size);
-        const fd = openSync(path, 'r');
-        try {
-            let done = 0;
-            while (done < size) {
-                const read = readSync(fd, bytes, done, size - done, done);
-                if (read === 0)
-                    break;
-                done += read;
-            }
-            if (fstatSync(fd).size !== size)
-                throw new Error(`${path} changed while it was read`);
-        }
-        finally {
-            closeSync(fd);
-        }
-        await client.send(new PutObjectCommand({ Bucket: bucket, Key: key, Body: bytes, ContentLength: size, ChecksumAlgorithm: 'SHA256' }));
+        let body = null;
+        for await (const part of partsOf(file.bytes, Math.max(size, 1)))
+            body = part;
+        await client.send(new PutObjectCommand({
+            Bucket: bucket, Key: key, Body: body, ContentLength: size, ChecksumSHA256: checksumOf(file.offered.sha256),
+            ...(metadata !== undefined && { Metadata: metadata }),
+        }));
         return;
     }
-    const created = await client.send(new CreateMultipartUploadCommand({ Bucket: bucket, Key: key, ChecksumAlgorithm: 'SHA256' }));
+    const created = await client.send(new CreateMultipartUploadCommand({ Bucket: bucket, Key: key, ChecksumAlgorithm: 'SHA256', ...(metadata !== undefined && { Metadata: metadata }) }));
     const uploadId = created.UploadId;
+    const sent = [];
+    const inFlight = new Set();
+    let failure = null;
     try {
-        const count = Math.ceil(size / FILES_PUSH_PART_BYTES);
-        const sent = new Map();
-        let next = 0;
-        const worker = async () => {
-            for (;;) {
-                const i = next++;
-                if (i >= count)
-                    return;
-                const start = i * FILES_PUSH_PART_BYTES;
-                const end = Math.min(size, start + FILES_PUSH_PART_BYTES) - 1;
-                const chunks = [];
-                for await (const chunk of createReadStream(path, { start, end }))
-                    chunks.push(chunk);
-                const part = Buffer.concat(chunks);
-                // An upload created with a checksum algorithm completes with each part's checksum
-                const checksum = createHash('sha256').update(part).digest('base64');
-                const uploaded = await client.send(new UploadPartCommand({ Bucket: bucket, Key: key, UploadId: uploadId, PartNumber: i + 1, Body: part, ContentLength: part.length, ChecksumSHA256: checksum }));
-                sent.set(i + 1, { ETag: uploaded.ETag, ChecksumSHA256: checksum });
-            }
-        };
-        await Promise.all(Array.from({ length: Math.min(PARTS_IN_FLIGHT, count) }, worker));
+        let number = 0;
+        for await (const part of partsOf(file.bytes, FILES_PUSH_PART_BYTES)) {
+            if (failure !== null)
+                break;
+            const partNumber = ++number;
+            // An upload created with a checksum algorithm completes with each part's checksum
+            const checksum = createHash('sha256').update(part).digest('base64');
+            const sending = client.send(new UploadPartCommand({
+                Bucket: bucket, Key: key, UploadId: uploadId, PartNumber: partNumber, Body: part, ContentLength: part.length, ChecksumSHA256: checksum,
+            })).then((uploaded) => { sent.push({ PartNumber: partNumber, ETag: uploaded.ETag, ChecksumSHA256: checksum }); }, (err) => { failure ??= err; })
+                .finally(() => { inFlight.delete(sending); });
+            inFlight.add(sending);
+            // A part read only while fewer than four are being sent: four parts held at most
+            if (inFlight.size >= PARTS_IN_FLIGHT)
+                await Promise.race(inFlight);
+        }
+        await Promise.all(inFlight);
+        if (failure !== null)
+            throw failure;
         await client.send(new CompleteMultipartUploadCommand({
             Bucket: bucket, Key: key, UploadId: uploadId,
-            MultipartUpload: { Parts: [...sent].sort(([a], [b]) => a - b).map(([PartNumber, part]) => ({ PartNumber, ...part })) },
+            MultipartUpload: { Parts: sent.sort((a, b) => a.PartNumber - b.PartNumber) },
         }));
     }
     catch (err) {
+        await Promise.allSettled(inFlight);
         await client.send(new AbortMultipartUploadCommand({ Bucket: bucket, Key: key, UploadId: uploadId })).catch(() => undefined);
         throw err;
     }
 }
-/** The kind a mapping fills, as a row says it: the type, `seed`, the mutation, or the shape. */
-function kindOf(plan, outcome) {
-    const { target } = outcome.value;
-    if (target.type === 'record')
-        return 'seed';
-    if (target.type === 'mutation')
-        return target.value.mutation;
-    void plan;
-    return 'input';
+/** The kind a mapping fills, as a row says it: the type, `seed`, or the mutation. */
+function kindOf(file, target) {
+    switch (target.type) {
+        case 'input': return typeOfOffered(file);
+        case 'record': return 'seed';
+        case 'mutation': return target.value.mutation;
+    }
 }
 /**
- * Uploads each planned put, four parts in flight, and answers a row per
- * file: put, unchanged, refused or failed.
+ * Uploads each planned put and answers a row per file: put, unchanged,
+ * refused or failed.
  *
  * @param plan - The plan
  * @param files - The files offered, in the plan's order
- * @param uploads - The completion, and the profile for external puts
+ * @param uploads - The platform's uploads, and the credentials for external puts
  * @param dryRun - Put nothing
  * @returns A row per file, and the targets put
  */
@@ -269,30 +370,30 @@ export async function uploadPlanned(plan, files, uploads, dryRun) {
     const bindingOf = (source) => plan.bindings.find((b) => b.source === source);
     for (const [i, planned] of plan.files.entries()) {
         const file = files[i];
+        const row = (target, kind, put) => ({ label: file.label, size: file.offered.size, target, kind, put, sync: '' });
         const { outcome } = planned;
         if (outcome.type === 'refused') {
-            rows.push({ file, target: null, kind: '', put: `refused: ${filesPushRefusalText(outcome.value)}`, sync: '' });
+            rows.push(row(null, '', `refused: ${filesPushRefusalText(outcome.value)}`));
             continue;
         }
         const { target } = outcome.value;
-        const kind = outcome.value.target.type === 'input' ? typeOfOffered(file) : kindOf(plan, outcome);
+        const kind = kindOf(file, target);
         if (outcome.type === 'unchanged') {
-            rows.push({ file, target, kind, put: 'unchanged', sync: '' });
+            rows.push(row(target, kind, 'unchanged'));
             continue;
         }
         if (dryRun) {
-            rows.push({ file, target, kind, put: 'would put', sync: '' });
+            rows.push(row(target, kind, 'would put'));
             continue;
         }
-        const size = Number(file.offered.size);
         try {
-            await upload(outcome.value.upload, outcome.value.key, bindingOf(outcome.value.source), file.path, size, uploads);
-            rows.push({ file, target, kind, put: 'put', sync: '' });
+            await upload(plan, outcome.value, bindingOf(outcome.value.source), file, uploads);
+            rows.push(row(target, kind, 'put'));
             if (!targets.some((t) => sameFilesTarget(t, target)))
                 targets.push(target);
         }
         catch (err) {
-            rows.push({ file, target, kind, put: `failed: ${err instanceof Error ? err.message : String(err)}`, sync: '' });
+            rows.push(row(target, kind, `failed: ${err instanceof Error ? err.message : String(err)}`));
         }
     }
     return { rows, targets };
@@ -305,27 +406,36 @@ function typeOfOffered(file) {
     return words.length <= 40 ? words : `${words.slice(0, 39)}…`;
 }
 /** One put, as the plan says to upload it. */
-async function upload(how, key, binding, path, size, uploads) {
-    switch (how.type) {
+async function upload(plan, put, binding, file, uploads) {
+    switch (put.upload.type) {
         case 'single':
-            await putSingle(path, size, how.value.url, how.value.headers);
-            return;
-        case 'multipart': {
-            const etags = await putParts(path, size, Number(how.value.partBytes), how.value.parts);
-            await uploads.complete(key, how.value.uploadId, etags);
+        case 'multipart':
+            if (uploads.signed === undefined)
+                throw new Error('the plan signed an upload, which only a deployed repository\'s push makes');
+            await uploads.signed(plan, put, file.bytes);
             return;
-        }
         case 'external': {
             if (binding === undefined)
                 throw new Error('the plan names no binding to put to');
+            if (uploads.external !== undefined) {
+                await uploads.external(binding, put.key, file);
+                return;
+            }
             const location = parseBucketUrl(binding.url);
             if ('problem' in location)
                 throw new Error(`${binding.url} ${location.problem}`);
-            await putExternal(ownClient(binding, uploads.profile), location.bucket, `${location.prefix}${key}`, path, size);
+            await putExternal(ownClient(binding, uploads.profile), location.bucket, `${location.prefix}${put.key}`, file);
             return;
         }
     }
 }
+/** A seed's commit as a row says it: `$init #1`, `$seed #2`; `$seed` where its ledger did not count. */
+function seedWords(m) {
+    if (m.seed.type === 'none')
+        return null;
+    const { commit, number } = m.seed.value;
+    return number.type === 'some' ? `${commit} #${number.value}` : commit;
+}
 /** What a sync did to a row's target, in words. */
 export function syncWords(report, target) {
     const m = report?.mappings.find((r) => sameFilesTarget(r.target, target));
@@ -337,13 +447,61 @@ export function syncWords(report, target) {
         return `waiting: ${m.waiting.value}`;
     if (m.kept.type === 'some')
         return `kept: ${m.kept.value}`;
-    const rows = m.taken.type === 'some' && m.taken.value.rows.type === 'some' ? `  ${m.taken.value.rows.value.toLocaleString('en-US')} rows` : '';
+    const count = m.taken.type === 'some' && m.taken.value.rows.type === 'some' ? m.taken.value.rows.value : null;
+    const rows = count === null ? '' : `  ${count.toLocaleString('en-US')} ${count === 1n ? 'row' : 'rows'}`;
+    const seed = seedWords(m);
+    if (seed !== null)
+        return `${seed}${rows}`;
     if (m.commit.type === 'some')
         return `committed ${m.commit.value.slice(0, 12)}${rows}`;
     if (m.updated)
         return `taken in${rows}`;
     return 'unchanged';
 }
+/**
+ * Each offering's row, in the order the paths were given, each put's with
+ * what the sync did to its target.
+ *
+ * @param offered - The offerings
+ * @param planned - The rows of the files planned, in the plan's order
+ * @param report - The sync of what was put; null when nothing was
+ * @returns The rows
+ */
+export function completedRows(offered, planned, report) {
+    const rows = rowsInOrder(offered, planned);
+    for (const row of rows)
+        if (row.target !== null && row.put === 'put')
+            row.sync = syncWords(report, row.target);
+    return rows;
+}
+/**
+ * A push to a local repository's workspace: the plan over its declarations,
+ * bindings and ledgers ({@link planLocal}), each put with the developer's own
+ * credentials, then one sync of the targets put ({@link syncLocal}), as a
+ * deployed workspace's push does through its API.
+ *
+ * @param repoPath - The repository, opened (`openLocalRepository`)
+ * @param ws - The workspace
+ * @param offered - What the push offers ({@link offerings})
+ * @param options - The target named, the records reset, a dry run, the credentials
+ * @returns The bindings, the rows and the sync's report
+ * @throws {Error} When the workspace has no declarations deployed
+ */
+export async function pushLocal(repoPath, ws, offered, options = {}) {
+    const files = offered.flatMap((o) => ('file' in o ? [o.file] : []));
+    if (files.length === 0)
+        return { bindings: [], rows: completedRows(offered, [], null), report: null };
+    const plan = await planLocal(repoPath, ws, files, { ...(options.as !== undefined && { as: options.as }), ...(options.reader !== undefined && { reader: options.reader }) });
+    const dryRun = options.dryRun === true;
+    const { rows, targets } = await uploadPlanned(plan, files, {
+        ...(options.profile !== undefined && { profile: options.profile }),
+        ...(options.external !== undefined && { external: options.external }),
+    }, dryRun);
+    const report = !dryRun && targets.length > 0
+        ? await syncLocal(repoPath, ws, { targets, ...(options.reset !== undefined && { reset: options.reset }), ...(options.reader !== undefined && { reader: options.reader }) })
+        : null;
+    return { bindings: plan.bindings, rows: completedRows(offered, rows, report), report };
+}
 /** A count of bytes, as the rows show it. */
 function sizeWords(bytes) {
     const n = Number(bytes);
@@ -358,22 +516,22 @@ function sizeWords(bytes) {
 }
 /**
  * A push's rows, as the CLI prints them: the sources' bucket lines, a row
- * per file, and the dataflow hint when anything was taken.
+ * per file or dataset, and the dataflow hint when anything was taken.
  *
- * @param plan - The plan
- * @param rows - The rows
+ * @param bindings - The bindings the plan put to; none when nothing was planned
+ * @param rows - The rows, in the order the paths were given
  * @param next - The dataflow run hint's command, when anything changed; null for none
  * @returns The lines
  */
-export function pushText(plan, rows, next) {
+export function pushText(bindings, rows, next) {
     const lines = [];
-    for (const binding of plan.bindings)
+    for (const binding of bindings)
         lines.push(`${binding.source}  ${binding.url}`);
     const cells = rows.map((row) => [
-        row.file.offered.directory.type === 'some' ? `${row.file.offered.directory.value}/${row.file.offered.name}` : row.file.offered.name,
+        row.label,
         row.target === null ? '' : `→ ${filesTargetText(row.target)}`,
         row.kind,
-        sizeWords(row.file.offered.size),
+        row.size === null ? '' : sizeWords(row.size),
         row.put,
         row.sync,
     ]);