@sanity/ailf 3.0.0 → 3.1.1

package/dist/artifact-capture/gcs-artifact-writer.d.ts

@@ -28,7 +28,8 @@
  * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md
  */
 import { Storage } from "@google-cloud/storage";
-import { type ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type AssociationValues, type RunId, type RunManifest } from "../_vendor/ailf-core/index.d.ts";
+import { type ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type ArtifactWriterProgressOptions, type AssociationValues, type RunId, type RunManifest } from "../_vendor/ailf-core/index.d.ts";
+import { type UploadMetricsSink } from "./upload-metrics.js";
 export interface GcsArtifactWriterOptions {
     /** GCS bucket name (e.g., "ailf-artifacts") */
     bucket: string;
@@ -38,12 +39,37 @@ export interface GcsArtifactWriterOptions {
      * supplies a fake here to avoid real network calls.
      */
     storage?: Storage;
+    /**
+     * Optional progress reporter + phaseId (W0053). When set, the writer
+     * publishes `phaseProgress` on every successful emit / appendNdjson /
+     * writeManifest so the CLI can render per-batch updates during the
+     * long artifact upload phase.
+     */
+    progress?: ArtifactWriterProgressOptions;
+    /**
+     * W0056 — optional metrics sink that receives per-phase timing events.
+     * Defaults to a no-op so the hot path stays free when metrics are off.
+     */
+    metrics?: UploadMetricsSink;
 }
 export declare class GcsArtifactWriter implements ArtifactWriter {
     private client;
     private readonly options;
     private readonly ndjsonStreams;
+    private readonly metrics;
+    /**
+     * Bounds concurrent GCS PUTs.
+     *
+     * Producers after W0058 fire all emits synchronously and `Promise.all`
+     * once at the end — without an internal limiter, a full-literacy run
+     * would fan ~1,500 concurrent `file.save` calls, saturating the client
+     * connection pool and GCS's per-prefix write quota. The limiter
+     * preserves the pre-W0058 effective concurrency (8) that Prototype A
+     * measured safe, without forcing the producer to own that knob.
+     */
+    private readonly limiter;
     constructor(options: GcsArtifactWriterOptions);
+    private reportProgress;
     emit<T extends ArtifactType>(type: T, association: AssociationValues, payload: unknown): Promise<ArtifactRef | null>;
     appendNdjson<T extends ArtifactType>(type: T, association: AssociationValues, rows: readonly unknown[]): Promise<ArtifactRef | null>;
     writeManifest(runId: RunId, manifest: RunManifest): Promise<ArtifactRef | null>;

package/dist/artifact-capture/gcs-artifact-writer.js

@@ -29,7 +29,9 @@
  */
 import { Storage } from "@google-cloud/storage";
 import { ARTIFACT_REGISTRY, buildManifestPreview, } from "../_vendor/ailf-core/index.js";
+import { resolveUploadConcurrency } from "./parallel-emit.js";
 import { redactArtifactData } from "./redact-artifact.js";
+import { NO_OP_UPLOAD_METRICS, } from "./upload-metrics.js";
 /**
  * GCS's object compose operation accepts at most 32 source objects per call
  * ([docs](https://cloud.google.com/storage/docs/composite-objects)). When an
@@ -42,11 +44,36 @@ export class GcsArtifactWriter {
     client = null;
     options;
     ndjsonStreams = new Map();
+    metrics;
+    /**
+     * Bounds concurrent GCS PUTs.
+     *
+     * Producers after W0058 fire all emits synchronously and `Promise.all`
+     * once at the end — without an internal limiter, a full-literacy run
+     * would fan ~1,500 concurrent `file.save` calls, saturating the client
+     * connection pool and GCS's per-prefix write quota. The limiter
+     * preserves the pre-W0058 effective concurrency (8) that Prototype A
+     * measured safe, without forcing the producer to own that knob.
+     */
+    limiter;
     constructor(options) {
         this.options = options;
+        this.metrics = options.metrics ?? NO_OP_UPLOAD_METRICS;
         if (options.storage) {
             this.client = options.storage;
         }
+        this.limiter = new ConcurrencyLimiter(resolveUploadConcurrency());
+    }
+    reportProgress(ref) {
+        const progress = this.options.progress;
+        if (!progress)
+            return;
+        progress.reporter.phaseProgress({
+            phaseId: progress.phaseId,
+            items: 1,
+            bytes: ref.bytes,
+            label: ref.path,
+        });
     }
     // ---- Canonical W0049 API ------------------------------------------------
     async emit(type, association, payload) {
@@ -68,18 +95,21 @@ export class GcsArtifactWriter {
                 layout: "bulk",
                 mime: descriptor.mime,
                 entryCount: entryCountOf(redacted),
+                type,
             });
             if (!ref)
                 return null;
-            return preview === undefined ? ref : { ...ref, preview };
+            const finalRef = preview === undefined ? ref : { ...ref, preview };
+            this.reportProgress(finalRef);
+            return finalRef;
         }
         // per-entry
         const entryKey = descriptor.formatEntryKey(association);
         const path = descriptor.objectPath(runId, entryKey);
-        const ref = await this.putBody(path, serializeForMime(redacted, descriptor.mime), { layout: "per-entry", mime: descriptor.mime });
+        const ref = await this.putBody(path, serializeForMime(redacted, descriptor.mime), { layout: "per-entry", mime: descriptor.mime, type });
         if (!ref)
             return null;
-        return {
+        const finalRef = {
             ...ref,
             path: `runs/${runId}/${descriptor.slug}`,
             entryCount: 1,
@@ -92,6 +122,8 @@ export class GcsArtifactWriter {
                 },
             ],
         };
+        this.reportProgress(finalRef);
+        return finalRef;
     }
     async appendNdjson(type, association, rows) {
         const descriptor = ARTIFACT_REGISTRY[type];
@@ -119,21 +151,39 @@ export class GcsArtifactWriter {
         const redactedRows = rows.map((r) => redactArtifactData(r));
         const body = redactedRows.map((r) => JSON.stringify(r)).join("\n") + "\n";
         const bytes = Buffer.byteLength(body, "utf-8");
-        try {
-            const storage = this.getClient();
-            await storage
-                .bucket(this.options.bucket)
-                .file(partPath)
-                .save(body, { contentType: "application/x-ndjson" });
-            state.partCount++;
-            state.totalBytes += bytes;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.warn(`  ⚠️  NDJSON part upload failed (non-blocking): ${partPath} — ${message}`);
+        const saveOutcome = await this.limiter.run(async () => {
+            const start = Date.now();
+            let success = false;
+            try {
+                const storage = this.getClient();
+                await storage
+                    .bucket(this.options.bucket)
+                    .file(partPath)
+                    .save(body, { contentType: "application/x-ndjson" });
+                success = true;
+                return { ok: true };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                console.warn(`  ⚠️  NDJSON part upload failed (non-blocking): ${partPath} — ${message}`);
+                return { ok: false };
+            }
+            finally {
+                this.metrics.record({
+                    phase: "put",
+                    writer: "GcsArtifactWriter",
+                    type: `${type}:ndjson-part`,
+                    ms: Date.now() - start,
+                    bytes,
+                    success,
+                });
+            }
+        });
+        if (!saveOutcome.ok)
             return null;
-        }
-        return {
+        state.partCount++;
+        state.totalBytes += bytes;
+        const ref = {
             store: "gcs",
             bucket: this.options.bucket,
             path: `runs/${runId}/${descriptor.slug}`,
@@ -148,14 +198,20 @@ export class GcsArtifactWriter {
                 },
             ],
         };
+        this.reportProgress(ref);
+        return ref;
     }
     async writeManifest(runId, manifest) {
         await this.finalizeNdjsonStreams();
         const path = `runs/${runId}/manifest.json`;
-        return this.putBody(path, JSON.stringify(manifest), {
+        const ref = await this.putBody(path, JSON.stringify(manifest), {
             layout: "bulk",
             mime: "application/json",
+            type: "manifest",
         });
+        if (ref)
+            this.reportProgress(ref);
+        return ref;
     }
     // ---- Deprecated legacy surface (W0052) ----------------------------------
     /** @deprecated Use `emit()` instead. Routes through the same GCS I/O. */
@@ -171,6 +227,7 @@ export class GcsArtifactWriter {
             layout: "bulk",
             mime: descriptor.mime,
             entryCount: entryCountOf(redacted),
+            type,
         });
     }
     /** @deprecated Use `emit()` per entry instead. */
@@ -197,6 +254,8 @@ export class GcsArtifactWriter {
             const redacted = redactArtifactData(entry.data);
             const body = serializeForMime(redacted, descriptor.mime);
             const bytes = Buffer.byteLength(body, "utf-8");
+            const start = Date.now();
+            let success = false;
             try {
                 await storage
                     .bucket(this.options.bucket)
@@ -204,11 +263,22 @@ export class GcsArtifactWriter {
                     .save(body, { contentType: descriptor.mime });
                 uploaded.push({ key: entry.key, bytes });
                 totalBytes += bytes;
+                success = true;
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 console.warn(`  ⚠️  Artifact entry upload failed (non-blocking): ${path} — ${message}`);
             }
+            finally {
+                this.metrics.record({
+                    phase: "put",
+                    writer: "GcsArtifactWriter",
+                    type,
+                    ms: Date.now() - start,
+                    bytes,
+                    success,
+                });
+            }
         }
         if (uploaded.length === 0)
             return null;
@@ -240,41 +310,69 @@ export class GcsArtifactWriter {
             const storage = this.getClient();
             const bucket = storage.bucket(this.options.bucket);
             const partPaths = Array.from({ length: state.partCount }, (_, i) => `${state.finalPath}.part-${String(i).padStart(4, "0")}`);
+            const start = Date.now();
+            let success = false;
             try {
                 const finalPath = await composeInGroups(bucket, partPaths, state.finalPath);
                 if (finalPath !== state.finalPath) {
                     console.warn(`  ⚠️  NDJSON compose produced "${finalPath}" (expected "${state.finalPath}")`);
                 }
+                success = true;
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 console.warn(`  ⚠️  NDJSON compose failed (non-blocking): ${state.finalPath} — ${message}`);
             }
+            finally {
+                this.metrics.record({
+                    phase: "compose",
+                    writer: "GcsArtifactWriter",
+                    type: `parts=${state.partCount}`,
+                    ms: Date.now() - start,
+                    bytes: state.totalBytes,
+                    success,
+                });
+            }
         }
         this.ndjsonStreams.clear();
     }
     async putBody(path, body, meta) {
         const bytes = Buffer.byteLength(body, "utf-8");
-        try {
-            const storage = this.getClient();
-            await storage
-                .bucket(this.options.bucket)
-                .file(path)
-                .save(body, { contentType: meta.mime });
-            return {
-                store: "gcs",
-                bucket: this.options.bucket,
-                path,
-                bytes,
-                entryCount: meta.entryCount,
-                layout: meta.layout,
-            };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.warn(`  ⚠️  Artifact upload failed (non-blocking): ${path} — ${message}`);
-            return null;
-        }
+        return this.limiter.run(async () => {
+            const start = Date.now();
+            let success = false;
+            try {
+                const storage = this.getClient();
+                await storage
+                    .bucket(this.options.bucket)
+                    .file(path)
+                    .save(body, { contentType: meta.mime });
+                success = true;
+                return {
+                    store: "gcs",
+                    bucket: this.options.bucket,
+                    path,
+                    bytes,
+                    entryCount: meta.entryCount,
+                    layout: meta.layout,
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                console.warn(`  ⚠️  Artifact upload failed (non-blocking): ${path} — ${message}`);
+                return null;
+            }
+            finally {
+                this.metrics.record({
+                    phase: "put",
+                    writer: "GcsArtifactWriter",
+                    type: meta.type,
+                    ms: Date.now() - start,
+                    bytes,
+                    success,
+                });
+            }
+        });
     }
     getClient() {
         if (this.client)
@@ -286,6 +384,38 @@ export class GcsArtifactWriter {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+/**
+ * Simple bounded-concurrency scheduler. Tasks beyond the limit queue
+ * FIFO; each completion wakes exactly one waiter. Stays FIFO-fair because
+ * no timer is involved. Used by `GcsArtifactWriter` to cap concurrent
+ * GCS I/O after producers stopped self-bounding via `parallelMap`.
+ */
+class ConcurrencyLimiter {
+    inflight = 0;
+    waiters = [];
+    limit;
+    constructor(limit) {
+        // Clamp at 1 so a misconfigured `resolveUploadConcurrency()` (0 or
+        // negative) cannot deadlock — the admission check in `run()` is
+        // `inflight >= limit`, so `limit=0` would wedge every caller.
+        this.limit = Math.max(1, Math.floor(limit));
+    }
+    async run(task) {
+        if (this.inflight >= this.limit) {
+            await new Promise((resolve) => this.waiters.push(resolve));
+        }
+        this.inflight++;
+        try {
+            return await task();
+        }
+        finally {
+            this.inflight--;
+            const next = this.waiters.shift();
+            if (next)
+                next();
+        }
+    }
+}
 function serializeForMime(payload, mime) {
     if (mime === "text/markdown" || mime === "application/yaml") {
         if (typeof payload === "string")

package/dist/artifact-capture/instrumented-artifact-writer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * InstrumentedArtifactWriter — decorator for W0056 spike instrumentation.
+ *
+ * Wraps any `ArtifactWriter` and records end-to-end `emit` / `appendNdjson` /
+ * `writeManifest` durations into an `UploadMetrics` sink. The writer-internal
+ * phase timings (sign vs. PUT, compose groups) are recorded by the concrete
+ * writers; this decorator records the caller-observed totals so the summary
+ * shows both views.
+ *
+ * Triggers `UploadMetrics.summarize()` from `writeManifest` (after delegation)
+ * — that is the natural end-of-run signal and avoids a separate lifecycle
+ * hook in the composition root.
+ */
+import type { ArtifactEntry, ArtifactRef, ArtifactType, ArtifactWriter, AssociationValues, RunId, RunManifest } from "../_vendor/ailf-core/index.d.ts";
+import type { UploadMetrics } from "./upload-metrics.js";
+export declare class InstrumentedArtifactWriter implements ArtifactWriter {
+    /**
+     * Exposed so `FinalizeRunStep` can walk decorator chains to reach the
+     * underlying `AccumulatingArtifactWriter` when `AILF_UPLOAD_METRICS=1`
+     * (which wraps the accumulator in this decorator). Mirrors the
+     * analogous field on `AccumulatingArtifactWriter`. Treat as read-only.
+     */
+    readonly inner: ArtifactWriter;
+    private readonly metrics;
+    private readonly writerName;
+    constructor(inner: ArtifactWriter, metrics: UploadMetrics);
+    emit<T extends ArtifactType>(type: T, association: AssociationValues, payload: unknown): Promise<ArtifactRef | null>;
+    appendNdjson<T extends ArtifactType>(type: T, association: AssociationValues, rows: readonly unknown[]): Promise<ArtifactRef | null>;
+    writeManifest(runId: RunId, manifest: RunManifest): Promise<ArtifactRef | null>;
+    writeBulk(type: ArtifactType, runId: RunId, data: unknown): Promise<ArtifactRef | null>;
+    writePerEntry(type: ArtifactType, runId: RunId, entries: readonly ArtifactEntry[]): Promise<ArtifactRef | null>;
+}

package/dist/artifact-capture/instrumented-artifact-writer.js

@@ -0,0 +1,151 @@
+/**
+ * InstrumentedArtifactWriter — decorator for W0056 spike instrumentation.
+ *
+ * Wraps any `ArtifactWriter` and records end-to-end `emit` / `appendNdjson` /
+ * `writeManifest` durations into an `UploadMetrics` sink. The writer-internal
+ * phase timings (sign vs. PUT, compose groups) are recorded by the concrete
+ * writers; this decorator records the caller-observed totals so the summary
+ * shows both views.
+ *
+ * Triggers `UploadMetrics.summarize()` from `writeManifest` (after delegation)
+ * — that is the natural end-of-run signal and avoids a separate lifecycle
+ * hook in the composition root.
+ */
+export class InstrumentedArtifactWriter {
+    /**
+     * Exposed so `FinalizeRunStep` can walk decorator chains to reach the
+     * underlying `AccumulatingArtifactWriter` when `AILF_UPLOAD_METRICS=1`
+     * (which wraps the accumulator in this decorator). Mirrors the
+     * analogous field on `AccumulatingArtifactWriter`. Treat as read-only.
+     */
+    inner;
+    metrics;
+    writerName;
+    constructor(inner, metrics) {
+        this.inner = inner;
+        this.metrics = metrics;
+        this.writerName = inner.constructor.name;
+    }
+    async emit(type, association, payload) {
+        const start = Date.now();
+        let success = false;
+        try {
+            const ref = await this.inner.emit(type, association, payload);
+            success = ref !== null;
+            this.metrics.record({
+                phase: "emit",
+                writer: this.writerName,
+                type,
+                ms: Date.now() - start,
+                bytes: ref?.bytes,
+                success,
+            });
+            return ref;
+        }
+        catch (err) {
+            this.metrics.record({
+                phase: "emit",
+                writer: this.writerName,
+                type,
+                ms: Date.now() - start,
+                success: false,
+            });
+            throw err;
+        }
+    }
+    async appendNdjson(type, association, rows) {
+        const start = Date.now();
+        try {
+            const ref = await this.inner.appendNdjson(type, association, rows);
+            this.metrics.record({
+                phase: "ndjson-part",
+                writer: this.writerName,
+                type,
+                ms: Date.now() - start,
+                bytes: ref?.bytes,
+                success: ref !== null,
+            });
+            return ref;
+        }
+        catch (err) {
+            this.metrics.record({
+                phase: "ndjson-part",
+                writer: this.writerName,
+                type,
+                ms: Date.now() - start,
+                success: false,
+            });
+            throw err;
+        }
+    }
+    async writeManifest(runId, manifest) {
+        const start = Date.now();
+        let ref = null;
+        try {
+            ref = await this.inner.writeManifest(runId, manifest);
+            this.metrics.record({
+                phase: "manifest",
+                writer: this.writerName,
+                type: "manifest",
+                ms: Date.now() - start,
+                bytes: ref?.bytes,
+                success: ref !== null,
+            });
+            return ref;
+        }
+        finally {
+            // Summarize once, after the manifest write resolves, regardless of outcome.
+            await this.metrics.summarize();
+        }
+    }
+    async writeBulk(type, runId, data) {
+        const start = Date.now();
+        try {
+            const ref = await this.inner.writeBulk(type, runId, data);
+            this.metrics.record({
+                phase: "emit",
+                writer: this.writerName,
+                type,
+                ms: Date.now() - start,
+                bytes: ref?.bytes,
+                success: ref !== null,
+            });
+            return ref;
+        }
+        catch (err) {
+            this.metrics.record({
+                phase: "emit",
+                writer: this.writerName,
+                type,
+                ms: Date.now() - start,
+                success: false,
+            });
+            throw err;
+        }
+    }
+    async writePerEntry(type, runId, entries) {
+        const start = Date.now();
+        try {
+            const ref = await this.inner.writePerEntry(type, runId, entries);
+            this.metrics.record({
+                phase: "emit",
+                writer: this.writerName,
+                type,
+                ms: Date.now() - start,
+                bytes: ref?.bytes,
+                success: ref !== null,
+            });
+            return ref;
+        }
+        catch (err) {
+            this.metrics.record({
+                phase: "emit",
+                writer: this.writerName,
+                type,
+                ms: Date.now() - start,
+                success: false,
+            });
+            throw err;
+        }
+    }
+}

package/dist/artifact-capture/local-fs-artifact-writer.d.ts

@@ -36,7 +36,7 @@
  * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md (§ M4)
  * @see packages/eval/src/artifact-capture/gcs-artifact-writer.ts (mirror)
  */
-import { type ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type AssociationValues, type RunId, type RunManifest } from "../_vendor/ailf-core/index.d.ts";
+import { type ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type ArtifactWriterProgressOptions, type AssociationValues, type RunId, type RunManifest } from "../_vendor/ailf-core/index.d.ts";
 export interface LocalFilesystemArtifactWriterOptions {
     /**
      * Absolute or cwd-relative root directory under which `runs/{runId}/…`
@@ -50,11 +50,18 @@ export interface LocalFilesystemArtifactWriterOptions {
      * `--capture-exclude=LIST` in W0050 Slice 4.
      */
     exclude?: readonly ArtifactType[];
+    /**
+     * Optional progress reporter + phaseId (W0053). When set, the writer
+     * publishes `phaseProgress` on every successful write so the CLI can
+     * render per-batch updates during long export phases.
+     */
+    progress?: ArtifactWriterProgressOptions;
 }
 export declare class LocalFilesystemArtifactWriter implements ArtifactWriter {
     private readonly options;
     private readonly excludeSet;
     constructor(options: LocalFilesystemArtifactWriterOptions);
+    private reportProgress;
     emit<T extends ArtifactType>(type: T, association: AssociationValues, payload: unknown): Promise<ArtifactRef | null>;
     appendNdjson<T extends ArtifactType>(type: T, association: AssociationValues, rows: readonly unknown[]): Promise<ArtifactRef | null>;
     writeManifest(runId: RunId, manifest: RunManifest): Promise<ArtifactRef | null>;

package/dist/artifact-capture/local-fs-artifact-writer.js

@@ -50,6 +50,17 @@ export class LocalFilesystemArtifactWriter {
         this.options = options;
         this.excludeSet = new Set(options.exclude ?? []);
     }
+    reportProgress(ref) {
+        const progress = this.options.progress;
+        if (!progress)
+            return;
+        progress.reporter.phaseProgress({
+            phaseId: progress.phaseId,
+            items: 1,
+            bytes: ref.bytes,
+            label: ref.path,
+        });
+    }
     // ---- Canonical W0049 API ------------------------------------------------
     async emit(type, association, payload) {
         if (this.excludeSet.has(type))
@@ -74,7 +85,7 @@ export class LocalFilesystemArtifactWriter {
             const wrote = await this.writeAtomic(absPath, body);
             if (!wrote)
                 return null;
-            return {
+            const ref = {
                 store: "local",
                 bucket: this.options.rootDir,
                 path: relPath,
@@ -83,6 +94,8 @@ export class LocalFilesystemArtifactWriter {
                 layout: "bulk",
                 ...(preview === undefined ? {} : { preview }),
             };
+            this.reportProgress(ref);
+            return ref;
         }
         // per-entry
         const entryKey = descriptor.formatEntryKey(association);
@@ -91,7 +104,7 @@ export class LocalFilesystemArtifactWriter {
         const wrote = await this.writeAtomic(absPath, body);
         if (!wrote)
             return null;
-        return {
+        const ref = {
             store: "local",
             bucket: this.options.rootDir,
             path: `runs/${runId}/${descriptor.slug}`,
@@ -107,6 +120,8 @@ export class LocalFilesystemArtifactWriter {
                 },
             ],
         };
+        this.reportProgress(ref);
+        return ref;
     }
     async appendNdjson(type, association, rows) {
         if (this.excludeSet.has(type))
@@ -149,7 +164,7 @@ export class LocalFilesystemArtifactWriter {
         catch {
             // If stat fails we still have the current batch's bytes — acceptable.
         }
-        return {
+        const ref = {
             store: "local",
             bucket: this.options.rootDir,
             path: `runs/${runId}/${descriptor.slug}`,
@@ -158,6 +173,8 @@ export class LocalFilesystemArtifactWriter {
             layout: "per-entry",
             entries: [{ key: entryKey, bytes: cumulative, association }],
         };
+        this.reportProgress(ref);
+        return ref;
     }
     async writeManifest(runId, manifest) {
         const relPath = `runs/${runId}/manifest.json`;
@@ -166,13 +183,15 @@ export class LocalFilesystemArtifactWriter {
         const wrote = await this.writeAtomic(absPath, body);
         if (!wrote)
             return null;
-        return {
+        const ref = {
             store: "local",
             bucket: this.options.rootDir,
             path: relPath,
             bytes: Buffer.byteLength(body, "utf-8"),
             layout: "bulk",
         };
+        this.reportProgress(ref);
+        return ref;
     }
     // ---- Deprecated legacy surface (W0052) ----------------------------------
     /** @deprecated Use `emit()` instead. */