@fuzdev/fuz_gitops 0.71.0 → 0.72.0

package/dist/gitops_publish.task.d.ts

@@ -20,6 +20,7 @@ export declare const Args: z.ZodObject<{
     'no-plan': z.ZodDefault<z.ZodBoolean>;
     max_wait: z.ZodDefault<z.ZodNumber>;
     skip_install: z.ZodDefault<z.ZodBoolean>;
+    emit_json: z.ZodDefault<z.ZodBoolean>;
     outfile: z.ZodOptional<z.ZodString>;
     verbose: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;

package/dist/gitops_publish.task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gitops_publish.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_publish.task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AActB,cAAc;AACd,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;kBAkCf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA0F3B,CAAC"}
+{"version":3,"file":"gitops_publish.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gitops_publish.task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAetB,cAAc;AACd,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;kBAsCf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA+F3B,CAAC"}

package/dist/gitops_publish.task.js

@@ -3,6 +3,7 @@ import { createInterface } from 'node:readline/promises';
 import { styleText as st } from 'node:util';
 import { get_gitops_ready } from './gitops_task_helpers.js';
 import { publish_repos, } from './multi_repo_publisher.js';
+import { stdout_handler } from './publishing_event_handler.js';
 import { generate_publishing_plan, log_publishing_plan } from './publishing_plan.js';
 import { format_and_output } from './output_helpers.js';
 import { GITOPS_CONFIG_PATH_DEFAULT, GITOPS_NPM_WAIT_TIMEOUT_DEFAULT } from './gitops_constants.js';
@@ -39,6 +40,10 @@ export const Args = z.strictObject({
         .boolean()
         .meta({ description: 'skip npm install after dependency updates' })
         .default(false),
+    emit_json: z
+        .boolean()
+        .meta({ description: 'stream structured publishing events as JSON-lines to stdout' })
+        .default(false),
     outfile: z.string().meta({ description: 'write output to file instead of logging' }).optional(),
     verbose: z.boolean().meta({ description: 'show additional details in plan output' }).default(false),
 });
@@ -47,7 +52,7 @@ export const task = {
     summary: 'publish all repos in dependency order',
     Args,
     run: async ({ args, log }) => {
-        const { config, dir, peer_strategy, wetrun, format, deploy, plan, max_wait, skip_install, outfile, verbose, } = args;
+        const { config, dir, peer_strategy, wetrun, format, deploy, plan, max_wait, skip_install, emit_json, outfile, verbose, } = args;
         // Load repos
         const { local_repos: repos } = await get_gitops_ready({
             config,
@@ -81,6 +86,8 @@ export const task = {
             max_wait,
             skip_install,
             log,
+            // Live JSON-lines stream when requested; events also surface on the result.
+            events: emit_json ? stdout_handler() : undefined,
         };
         // Execute publishing (may throw on fatal errors like circular dependencies)
         let result;
@@ -97,6 +104,8 @@ export const task = {
                 // Note: FATAL_ERROR is a placeholder - only fatal_error.message is displayed in output
                 failed: [{ name: 'FATAL_ERROR', error: fatal_error }],
                 duration: 0,
+                events: [],
+                summary: { total: 0, published: 0, failed: 1, skipped: 0, duration: 0 },
             };
         }
         // Format and output result (always runs, even on fatal errors)

package/dist/multi_repo_publisher.d.ts

@@ -2,6 +2,8 @@ import type { Logger } from '@fuzdev/fuz_util/log.js';
 import type { LocalRepo } from './local_repo.js';
 import { type VersionStrategy } from './dependency_updater.js';
 import type { GitopsOperations } from './operations.js';
+import { type PublishingEvent, type PublishingRunSummary } from './publishing_event.js';
+import { type PublishingEventHandler } from './publishing_event_handler.js';
 export interface PublishingOptions {
     wetrun: boolean;
     update_deps: boolean;
@@ -11,6 +13,8 @@ export interface PublishingOptions {
     skip_install?: boolean;
     log?: Logger;
     ops?: GitopsOperations;
+    /** Structured event sink; defaults to capture-only (events surface on the result). */
+    events?: PublishingEventHandler;
 }
 export interface PublishedVersion {
     name: string;
@@ -29,6 +33,10 @@ export interface PublishingResult {
         error: Error;
     }>;
     duration: number;
+    /** The structured event stream for this run, in emission order. */
+    events: Array<PublishingEvent>;
+    /** Tallied outcome, derived from `events`. */
+    summary: PublishingRunSummary;
 }
 export declare const publish_repos: (repos: Array<LocalRepo>, options: PublishingOptions) => Promise<PublishingResult>;
 //# sourceMappingURL=multi_repo_publisher.d.ts.map

package/dist/multi_repo_publisher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multi_repo_publisher.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/multi_repo_publisher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAKpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAsB,KAAK,eAAe,EAAC,MAAM,yBAAyB,CAAC;AAIlF,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAQtD,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,CAAC,EAAE,eAAe,CAAC;IACnC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,gBAAgB,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAChC,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;IACnC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAC,CAAC,CAAC;IAC5C,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,aAAa,GACzB,OAAO,KAAK,CAAC,SAAS,CAAC,EACvB,SAAS,iBAAiB,KACxB,OAAO,CAAC,gBAAgB,CAqU1B,CAAC"}
+{"version":3,"file":"multi_repo_publisher.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/multi_repo_publisher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAKpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAsB,KAAK,eAAe,EAAC,MAAM,yBAAyB,CAAC;AAIlF,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAOtD,OAAO,EACN,KAAK,eAAe,EACpB,KAAK,oBAAoB,EAEzB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACN,KAAK,sBAAsB,EAG3B,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,CAAC,EAAE,eAAe,CAAC;IACnC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,gBAAgB,CAAC;IACvB,sFAAsF;IACtF,MAAM,CAAC,EAAE,sBAAsB,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAChC,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;IACnC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAC,CAAC,CAAC;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,MAAM,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;IAC/B,8CAA8C;IAC9C,OAAO,EAAE,oBAAoB,CAAC;CAC9B;AAED,eAAO,MAAM,aAAa,GACzB,OAAO,KAAK,CAAC,SAAS,CAAC,EACvB,SAAS,iBAAiB,KACxB,OAAO,CAAC,gBAAgB,CA2Z1B,CAAC"}

package/dist/multi_repo_publisher.js

@@ -7,9 +7,17 @@ import { needs_update, is_breaking_change, detect_bump_type } from './version_ut
 import { default_gitops_operations } from './operations_defaults.js';
 import { GITOPS_MAX_ITERATIONS_DEFAULT, GITOPS_NPM_WAIT_TIMEOUT_DEFAULT, } from './gitops_constants.js';
 import { install_with_cache_healing } from './npm_install_helpers.js';
+import { summarize_events, } from './publishing_event.js';
+import { capture_handler, multi_handler, } from './publishing_event_handler.js';
 export const publish_repos = async (repos, options) => {
     const start_time = Date.now();
     const { wetrun, update_deps, log, ops = default_gitops_operations } = options;
+    // Capture every event for the result; also forward to the caller's sink if provided.
+    const capture = capture_handler();
+    const events_handler = options.events ? multi_handler([options.events, capture]) : capture;
+    const emit = (event) => {
+        events_handler.emit(event);
+    };
     // Preflight checks (skip for dry runs since we're not actually publishing)
     if (wetrun) {
         const preflight_options = {
@@ -39,16 +47,19 @@ export const publish_repos = async (repos, options) => {
         log_cycles: true,
         log_order: true,
     });
+    emit({ event: 'run_started', wetrun, total: order.length });
     const published = new Map();
     const failed = new Map();
     const changed_repos = new Set(); // Track repos with any changes for selective deployment
+    const skipped_packages = new Set(); // dedupe the package_skipped event across iterations
     // Fixed-point iteration: keep publishing until no new changesets are created
     // This handles transitive dependency updates (auto-generated changesets)
     let iteration = 0;
     let converged = false;
     while (!converged && iteration < GITOPS_MAX_ITERATIONS_DEFAULT) {
         iteration++;
-        log?.info(st('cyan', `\n🚀 Publishing iteration ${iteration}/${GITOPS_MAX_ITERATIONS_DEFAULT}...\n`));
+        emit({ event: 'iteration_started', iteration, max: GITOPS_MAX_ITERATIONS_DEFAULT });
+        log?.info(st('cyan', `\n🚀 ${wetrun ? 'Publishing' : 'Dry run'} iteration ${iteration}/${GITOPS_MAX_ITERATIONS_DEFAULT}...\n`));
         // Track if any packages were published in this iteration
         let published_in_iteration = false;
         let published_count = 0;
@@ -70,6 +81,7 @@ export const publish_repos = async (repos, options) => {
                 // Failed to check changesets
                 const err = new Error(`Failed to check changesets: ${has_result.message}`);
                 failed.set(pkg_name, err);
+                emit({ event: 'package_failed', name: pkg_name, error: err.message, code: 'dependency' });
                 log?.error(st('red', `  ❌ ${err.message}`));
                 break;
             }
@@ -77,6 +89,11 @@ export const publish_repos = async (repos, options) => {
                 // Skip packages without changesets
                 // In real publish: They might get auto-changesets during dependency updates
                 // In dry run: We can't simulate auto-changesets, so just skip
+                // Emit once per package — the loop revisits no-changeset packages each iteration
+                if (!skipped_packages.has(pkg_name)) {
+                    skipped_packages.add(pkg_name);
+                    emit({ event: 'package_skipped', name: pkg_name, reason: 'no changesets' });
+                }
                 if (!wetrun) {
                     // Silent skip in dry run - plan shows which packages get auto-changesets
                     continue;
@@ -88,7 +105,7 @@ export const publish_repos = async (repos, options) => {
             }
             try {
                 // 1. Publish this package
-                log?.info(st('dim', `  [${i + 1}/${order.length}] Publishing ${pkg_name}...`));
+                log?.info(st('dim', `  [${i + 1}/${order.length}] ${wetrun ? 'Publishing' : 'Would publish'} ${pkg_name}...`));
                 const version = await publish_single_repo(repo, options, ops);
                 published.set(pkg_name, version);
                 changed_repos.add(pkg_name); // Mark as changed for deployment
@@ -96,7 +113,19 @@ export const publish_repos = async (repos, options) => {
                 // (their dependencies didn't change, only their version)
                 published_in_iteration = true;
                 published_count++;
-                log?.info(st('green', `  ✅ Published ${pkg_name}@${version.new_version}`));
+                emit({
+                    event: 'package_completed',
+                    name: pkg_name,
+                    old_version: version.old_version,
+                    new_version: version.new_version,
+                    bump_type: version.bump_type,
+                    breaking: version.breaking,
+                    commit: version.commit,
+                    tag: version.tag,
+                });
+                log?.info(wetrun
+                    ? st('green', `  ✅ Published ${pkg_name}@${version.new_version}`)
+                    : st('cyan', `  ◇ Would publish ${pkg_name}@${version.new_version}`));
                 if (wetrun) {
                     // 2. Wait for this package to be available on NPM
                     log?.info(`  ⏳ Waiting for ${pkg_name}@${version.new_version} on NPM...`);
@@ -112,7 +141,14 @@ export const publish_repos = async (repos, options) => {
                         log,
                     });
                     if (!wait_result.ok) {
-                        throw new Error(`Failed to wait for package: ${wait_result.message}${wait_result.timeout ? ' (timeout)' : ''}`);
+                        // Handle inline (don't throw into the generic catch): the npm-wait failure
+                        // carries a typed `timeout` signal, so we know this is a network failure
+                        // without sniffing the message.
+                        const err = new Error(`Failed to wait for package: ${wait_result.message}${wait_result.timeout ? ' (timeout)' : ''}`);
+                        failed.set(pkg_name, err);
+                        emit({ event: 'package_failed', name: pkg_name, error: err.message, code: 'network' });
+                        log?.error(st('red', `  ❌ Failed to publish ${pkg_name}: ${err.message}`));
+                        break; // fail fast
                     }
                     // 3. Update all repos that have prod/peer deps on this package
                     if (update_deps) {
@@ -135,6 +171,12 @@ export const publish_repos = async (repos, options) => {
                             // Apply updates if any
                             if (updates.size > 0) {
                                 log?.info(`    Updating ${dependent_repo.library.name}'s dependency on ${pkg_name}`);
+                                emit({
+                                    event: 'dependency_updated',
+                                    dependent: dependent_repo.library.name,
+                                    dependency: pkg_name,
+                                    version: version.new_version,
+                                });
                                 changed_repos.add(dependent_repo.library.name); // Mark as changed for deployment
                                 changed_in_iteration.add(dependent_repo.library.name); // Track for batch install
                                 await update_package_json(dependent_repo, updates, {
@@ -151,6 +193,15 @@ export const publish_repos = async (repos, options) => {
             catch (error) {
                 const err = error instanceof Error ? error : new Error(String(error));
                 failed.set(pkg_name, err);
+                emit({
+                    event: 'package_failed',
+                    name: pkg_name,
+                    error: err.message,
+                    // TODO: emit a precise code once the npm/process ops return typed errors —
+                    // today a publish-step cause lives in unstructured stderr, so use the honest
+                    // coarse bucket rather than guessing 'auth'/'network'/'build' from the message.
+                    code: 'publish',
+                });
                 log?.error(st('red', `  ❌ Failed to publish ${pkg_name}: ${err.message}`));
                 break; // Always fail fast on error
             }
@@ -159,31 +210,26 @@ export const publish_repos = async (repos, options) => {
         // This ensures workspace stays consistent before next iteration
         if (wetrun && !options.skip_install && changed_in_iteration.size > 0) {
             log?.info(st('cyan', '\n📦 Installing dependencies for updated repos...\n'));
-            for (const pkg_name of changed_in_iteration) {
-                const repo = repos.find((r) => r.library.name === pkg_name);
-                if (!repo)
-                    continue;
-                try {
-                    log?.info(`  Installing ${pkg_name}...`);
-                    await install_with_cache_healing(repo, ops, log);
-                    log?.info(st('green', `  ✅ Installed ${pkg_name}`));
-                }
-                catch (error) {
-                    const err = error instanceof Error ? error : new Error(String(error));
-                    failed.set(pkg_name, err);
-                    log?.error(st('red', `  ❌ Failed to install ${pkg_name}: ${err.message}`));
-                    // Continue with other installs instead of breaking
-                }
+            for (const [name, err] of await install_repos(changed_in_iteration, repos, ops, emit, log)) {
+                failed.set(name, err);
             }
         }
         // Log iteration summary
         if (published_count > 0) {
-            log?.info(st('dim', `\nIteration ${iteration}: ${published_count} package(s) published\n`));
+            log?.info(st('dim', `\nIteration ${iteration}: ${published_count} package(s) ${wetrun ? 'published' : 'would be published'}\n`));
         }
+        emit({
+            event: 'iteration_finished',
+            iteration,
+            published_count,
+            converged: !published_in_iteration,
+        });
         // Check for convergence: no packages published in this iteration
         if (!published_in_iteration) {
             converged = true;
-            log?.info(st('green', `\n✓ Converged after ${iteration} iteration(s) - no new changesets\n`));
+            log?.info(st('green', wetrun
+                ? `\n✓ Converged after ${iteration} iteration(s) - no new changesets\n`
+                : `\n✓ Dry run complete after ${iteration} iteration(s)\n`));
         }
         else if (iteration === GITOPS_MAX_ITERATIONS_DEFAULT) {
             // Count packages that still have changesets (not yet published)
@@ -212,6 +258,14 @@ export const publish_repos = async (repos, options) => {
             }
             if (dev_updates.size > 0) {
                 log?.info(`  Updating ${dev_updates.size} dev dependencies in ${repo.library.name}`);
+                for (const [dep_name, dep_version] of dev_updates) {
+                    emit({
+                        event: 'dependency_updated',
+                        dependent: repo.library.name,
+                        dependency: dep_name,
+                        version: dep_version,
+                    });
+                }
                 changed_repos.add(repo.library.name); // Mark as changed for deployment
                 dev_updated_repos.add(repo.library.name); // Track for batch install
                 await update_package_json(repo, dev_updates, {
@@ -226,21 +280,8 @@ export const publish_repos = async (repos, options) => {
     // Phase 2b: Install dev dependencies for repos with dev dep updates
     if (wetrun && !options.skip_install && dev_updated_repos.size > 0) {
         log?.info(st('cyan', '\n📦 Installing dev dependencies for updated repos...\n'));
-        for (const pkg_name of dev_updated_repos) {
-            const repo = repos.find((r) => r.library.name === pkg_name);
-            if (!repo)
-                continue;
-            try {
-                log?.info(`  Installing ${pkg_name}...`);
-                await install_with_cache_healing(repo, ops, log);
-                log?.info(st('green', `  ✅ Installed ${pkg_name}`));
-            }
-            catch (error) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                failed.set(pkg_name, err);
-                log?.error(st('red', `  ❌ Failed to install ${pkg_name}: ${err.message}`));
-                // Continue with other installs instead of breaking
-            }
+        for (const [name, err] of await install_repos(dev_updated_repos, repos, ops, emit, log)) {
+            failed.set(name, err);
         }
     }
     // Phase 3: Deploy repos with changes (optional)
@@ -250,6 +291,7 @@ export const publish_repos = async (repos, options) => {
         log?.info(st('cyan', `\n🚢 Deploying ${repos_to_deploy.length}/${repos.length} repos with changes...\n`));
         for (const repo of repos_to_deploy) {
             try {
+                emit({ event: 'deploy_started', name: repo.library.name });
                 log?.info(`  Deploying ${repo.library.name}...`);
                 const deploy_result = await ops.process.spawn({
                     cmd: 'gro',
@@ -257,37 +299,49 @@ export const publish_repos = async (repos, options) => {
                     cwd: repo.repo_dir,
                 });
                 if (deploy_result.ok) {
+                    emit({ event: 'deploy_completed', name: repo.library.name });
                     log?.info(st('green', `  ✅ Deployed ${repo.library.name}`));
                 }
                 else {
+                    emit({ event: 'deploy_failed', name: repo.library.name, error: deploy_result.message });
                     log?.warn(st('yellow', `  ⚠️  Failed to deploy ${repo.library.name}`));
                 }
             }
             catch (error) {
-                log?.error(st('red', `  ❌ Error deploying ${repo.library.name}: ${error}`));
+                const err = error instanceof Error ? error : new Error(String(error));
+                emit({ event: 'deploy_failed', name: repo.library.name, error: err.message });
+                log?.error(st('red', `  ❌ Error deploying ${repo.library.name}: ${err.message}`));
             }
         }
     }
     // Summary
     const duration = Date.now() - start_time;
     const ok = failed.size === 0;
-    log?.info(st('cyan', '\n📋 Publishing Summary\n'));
+    const summary = summarize_events(capture.events, duration);
+    log?.info(st('cyan', `\n📋 ${wetrun ? 'Publishing' : 'Dry Run'} Summary\n`));
     log?.info(`  Duration: ${(duration / 1000).toFixed(1)}s`);
-    log?.info(`  Published: ${published.size} packages`);
+    log?.info(`  ${wetrun ? 'Published' : 'Would publish'}: ${published.size} packages`);
     if (failed.size > 0) {
         log?.info(`  Failed: ${failed.size} packages`);
     }
     if (ok) {
-        log?.info(st('green', '\n✨ All packages published successfully!\n'));
+        log?.info(st('green', wetrun
+            ? '\n✨ All packages published successfully!\n'
+            : `\n✨ Dry run complete — ${published.size} package(s) would be published. Re-run with --wetrun to publish.\n`));
     }
     else {
-        log?.error(st('red', '\n❌ Some packages failed to publish\n'));
+        log?.error(st('red', wetrun
+            ? '\n❌ Some packages failed to publish\n'
+            : '\n❌ Some packages failed during dry run\n'));
     }
+    emit({ event: 'run_finished', summary });
     return {
         ok,
         published: Array.from(published.values()),
         failed: Array.from(failed.entries()).map(([name, error]) => ({ name, error })),
         duration,
+        events: capture.events,
+        summary,
     };
 };
 /**
@@ -361,3 +415,31 @@ const publish_single_repo = async (repo, options, ops = default_gitops_operation
         tag: `v${new_version}`,
     };
 };
+/**
+ * Installs dependencies for each named repo (with cache healing), emitting install
+ * events and logging progress. A failed install doesn't stop the batch — failures are
+ * collected and returned so the caller can fold them into the run's failures.
+ */
+const install_repos = async (names, repos, ops, emit, log) => {
+    const failures = new Map();
+    for (const name of names) {
+        const repo = repos.find((r) => r.library.name === name);
+        if (!repo)
+            continue;
+        try {
+            emit({ event: 'install_started', name });
+            log?.info(`  Installing ${name}...`);
+            await install_with_cache_healing(repo, ops, log);
+            emit({ event: 'install_completed', name });
+            log?.info(st('green', `  ✅ Installed ${name}`));
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            failures.set(name, err);
+            emit({ event: 'install_failed', name, error: err.message });
+            log?.error(st('red', `  ❌ Failed to install ${name}: ${err.message}`));
+            // continue with other installs instead of breaking
+        }
+    }
+    return failures;
+};

package/dist/publishing_event.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Structured events for multi-repo publishing.
+ *
+ * Publishing emits a stream of tagged events alongside its human-readable logging,
+ * so machine consumers (CI, dashboards) can follow a run step by step. Every run
+ * opens with a `run_started` event carrying `wetrun`: when `false`, the run is a dry
+ * run and every `package_completed` is a prediction (its `commit` is `'simulated'`)
+ * rather than an applied change. A run's `run_finished` summary is derived from the
+ * same event list via `summarize_events`, so the stream and the summary never drift.
+ *
+ * Events are consumed through a `PublishingEventHandler` sink (see
+ * `publishing_event_handler.ts`).
+ *
+ * @module
+ */
+import { z } from 'zod';
+/**
+ * Coarse triage classification for a failed package. Lets consumers branch on
+ * failure kind without parsing the message.
+ */
+export declare const PublishingErrorCode: z.ZodEnum<{
+    other: "other";
+    build: "build";
+    publish: "publish";
+    network: "network";
+    auth: "auth";
+    dependency: "dependency";
+}>;
+export type PublishingErrorCode = z.infer<typeof PublishingErrorCode>;
+/** Tallied outcome of a publishing run, derived from its events via `summarize_events`. */
+export declare const PublishingRunSummary: z.ZodObject<{
+    total: z.ZodNumber;
+    published: z.ZodNumber;
+    failed: z.ZodNumber;
+    skipped: z.ZodNumber;
+    duration: z.ZodNumber;
+}, z.core.$strict>;
+export type PublishingRunSummary = z.infer<typeof PublishingRunSummary>;
+/**
+ * A single structured event emitted during a publishing run. Tagged on `event` so the
+ * union serializes as one self-describing JSON object per event (JSON-lines on the wire).
+ */
+export declare const PublishingEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    event: z.ZodLiteral<"run_started">;
+    wetrun: z.ZodBoolean;
+    total: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"iteration_started">;
+    iteration: z.ZodNumber;
+    max: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"iteration_finished">;
+    iteration: z.ZodNumber;
+    published_count: z.ZodNumber;
+    converged: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"package_skipped">;
+    name: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"package_completed">;
+    name: z.ZodString;
+    old_version: z.ZodString;
+    new_version: z.ZodString;
+    bump_type: z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+    }>;
+    breaking: z.ZodBoolean;
+    commit: z.ZodString;
+    tag: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"package_failed">;
+    name: z.ZodString;
+    error: z.ZodString;
+    code: z.ZodEnum<{
+        other: "other";
+        build: "build";
+        publish: "publish";
+        network: "network";
+        auth: "auth";
+        dependency: "dependency";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"dependency_updated">;
+    dependent: z.ZodString;
+    dependency: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"install_started">;
+    name: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"install_completed">;
+    name: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"install_failed">;
+    name: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"deploy_started">;
+    name: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"deploy_completed">;
+    name: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"deploy_failed">;
+    name: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"run_finished">;
+    summary: z.ZodObject<{
+        total: z.ZodNumber;
+        published: z.ZodNumber;
+        failed: z.ZodNumber;
+        skipped: z.ZodNumber;
+        duration: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>], "event">;
+export type PublishingEvent = z.infer<typeof PublishingEvent>;
+/**
+ * Derives a run summary from the captured event list — the single canonical path from
+ * events to summary, so the `run_finished` summary always agrees with the stream.
+ * Call before emitting `run_finished` (which is not itself counted).
+ *
+ * @param events - the events captured so far this run
+ * @param duration - wall-clock duration in milliseconds
+ */
+export declare const summarize_events: (events: Array<PublishingEvent>, duration: number) => PublishingRunSummary;
+//# sourceMappingURL=publishing_event.d.ts.map

package/dist/publishing_event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publishing_event.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/publishing_event.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;EAO9B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,2FAA2F;AAC3F,eAAO,MAAM,oBAAoB;;;;;;kBAM/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA2E1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAC5B,QAAQ,KAAK,CAAC,eAAe,CAAC,EAC9B,UAAU,MAAM,KACd,oBAwBF,CAAC"}