zx-bulk-release 3.1.5 → 3.1.7

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [3.1.7](https://github.com/semrel-extra/zx-bulk-release/compare/v3.1.6...v3.1.7) (2026-04-13)
+
+### Fixes & improvements
+* perf: apply traverseQueue to delivery phase ([6f1ba58](https://github.com/semrel-extra/zx-bulk-release/commit/6f1ba58885e7739b23de1d895f80ea4680645347))
+* perf: let `--verify` accept out dir ([80015bb](https://github.com/semrel-extra/zx-bulk-release/commit/80015bb067306892bbcc969c5ee2700a256b22f4))
+
+## [3.1.6](https://github.com/semrel-extra/zx-bulk-release/compare/v3.1.5...v3.1.6) (2026-04-13)
+
+### Fixes & improvements
+* fix: pack uses channel list from context instead of re-evaluating ([0fecefa](https://github.com/semrel-extra/zx-bulk-release/commit/0fecefab3549da98e24d42a2e1b4c7bb1b24b4c9))
+
 ## [3.1.5](https://github.com/semrel-extra/zx-bulk-release/compare/v3.1.4...v3.1.5) (2026-04-13)
 
 ### Fixes & improvements

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zx-bulk-release",
   "alias": "bulk-release",
-  "version": "3.1.5",
+  "version": "3.1.7",
   "description": "zx-based alternative for multi-semantic-release",
   "type": "module",
   "exports": {

package/src/main/js/cli.js

@@ -15,7 +15,7 @@ Modes:
   (no flags)              All-in-one: analyze, build, test, pack, deliver
   --receive               Analyze & preflight, write zbr-context.json. Run BEFORE deps install
   --pack [dir]            Build, test, pack tars to dir                           [default: parcels]
-  --verify [input-dir]    Validate parcels against context, copy valid to parcels/ [default: parcels]
+  --verify [in:out]       Validate parcels against context, copy to out dir         [default: parcels]
   --deliver [dir]         Deliver parcels through channels                        [default: parcels]
 
 Options:

package/src/main/js/post/courier/index.js

@@ -2,6 +2,7 @@ import {$, tempy, within, path, semver, fs} from 'zx-extra'
 import {unpackTar} from '../tar.js'
 import {log} from '../log.js'
 import {pool} from '../../util.js'
+import {traverseQueue} from '../depot/deps.js'
 import {scanDirectives, invalidateOrphans} from '../parcel/directive.js'
 import {tryLock, unlock, signalRebuild} from './semaphore.js'
 import gitTag from './channels/git-tag.js'
@@ -160,43 +161,38 @@ const deliverParcel = async (tarPath, channelName, pkgName, version, env, {dryRu
   return res === 'duplicate' ? 'duplicate' : 'ok'
 }
 
-const deliverDirective = async (directive, tarMap, env, {dryRun, cwd}) => {
+const deliverPkg = async (pkgName, pkg, tarMap, env, {dryRun, cwd}) => {
   const entries = []
   const conflicts = []
   const skipped = []
 
-  for (const pkgName of directive.queue) {
-    const pkg = directive.packages[pkgName]
-    if (!pkg) continue
-
-    let pkgConflict = false
+  let pkgConflict = false
 
-    for (const step of pkg.deliver) {
-      if (pkgConflict) break
+  for (const step of pkg.deliver) {
+    if (pkgConflict) break
 
-      const results = await Promise.all(step.map(async (channelName) => {
-        const parcelName = (pkg.parcels || []).find(p => p.includes(`.${channelName}.`))
-        const tarPath = parcelName && tarMap.get(parcelName)
-        if (!tarPath) return 'missing'
+    const results = await Promise.all(step.map(async (channelName) => {
+      const parcelName = (pkg.parcels || []).find(p => p.includes(`.${channelName}.`))
+      const tarPath = parcelName && tarMap.get(parcelName)
+      if (!tarPath) return 'missing'
 
-        return deliverParcel(tarPath, channelName, pkgName, pkg.version, env, {dryRun, cwd})
-      }))
+      return deliverParcel(tarPath, channelName, pkgName, pkg.version, env, {dryRun, cwd})
+    }))
 
-      for (let i = 0; i < step.length; i++) {
-        const r = results[i]
-        if (r === 'skip') skipped.push({channelName: step[i], pkg: pkgName})
-        else if (r !== 'missing' && r !== 'already') entries.push({channel: step[i], name: pkgName, version: pkg.version})
-      }
+    for (let i = 0; i < step.length; i++) {
+      const r = results[i]
+      if (r === 'skip') skipped.push({channelName: step[i], pkg: pkgName})
+      else if (r !== 'missing' && r !== 'already') entries.push({channel: step[i], name: pkgName, version: pkg.version})
+    }
 
-      if (results.includes('conflict')) {
-        pkgConflict = true
-        conflicts.push(pkgName)
-        for (const p of pkg.parcels || []) {
-          const tp = tarMap.get(p)
-          if (!tp) continue
-          const c = await fs.readFile(tp, 'utf8').catch(() => null)
-          if (c !== 'released') await fs.writeFile(tp, 'conflict')
-        }
+    if (results.includes('conflict')) {
+      pkgConflict = true
+      conflicts.push(pkgName)
+      for (const p of pkg.parcels || []) {
+        const tp = tarMap.get(p)
+        if (!tp) continue
+        const c = await fs.readFile(tp, 'utf8').catch(() => null)
+        if (c !== 'released') await fs.writeFile(tp, 'conflict')
       }
     }
   }
@@ -204,6 +200,25 @@ const deliverDirective = async (directive, tarMap, env, {dryRun, cwd}) => {
   return {entries, conflicts, skipped}
 }
 
+const deliverDirective = async (directive, tarMap, env, {dryRun, cwd}) => {
+  const entries = []
+  const conflicts = []
+  const skipped = []
+
+  const prev = new Map(Object.entries(directive.prev || {}))
+
+  await traverseQueue({queue: directive.queue, prev, cb: async (pkgName) => {
+    const pkg = directive.packages[pkgName]
+    if (!pkg) return
+    const r = await deliverPkg(pkgName, pkg, tarMap, env, {dryRun, cwd})
+    entries.push(...r.entries)
+    conflicts.push(...r.conflicts)
+    skipped.push(...r.skipped)
+  }})
+
+  return {entries, conflicts, skipped}
+}
+
 // --- Main entry point ---
 
 export const deliver = async (tars, env = process.env, {concurrency = 4, dryRun = false, cwd} = {}) => {

package/src/main/js/post/depot/steps/pack.js

@@ -10,7 +10,8 @@ import {packTar, hashFile} from '../../tar.js'
 export const pack = memoizeBy(async (pkg, ctx = pkg.ctx) => {
   const {channels: channelNames = [], flags} = ctx
   const snapshot = !!flags.snapshot
-  const active = getActiveChannels(pkg, channelNames, snapshot)
+  // In split pipeline, receive already decided which channels are active
+  const active = pkg.contextChannels || getActiveChannels(pkg, channelNames, snapshot)
 
   await prepare(active, pkg)
   await api.npm.npmPersist(pkg)

package/src/main/js/post/modes/pack.js

@@ -10,8 +10,8 @@ import {publish} from '../depot/steps/publish.js'
 import {clean} from '../depot/steps/clean.js'
 import {test} from '../depot/steps/test.js'
 import {preflight} from '../depot/reconcile.js'
-import {buildDirective, PARCELS_DIR} from '../parcel/index.js'
 import {CONTEXT_FILE, readContext} from '../depot/context.js'
+import {buildDirective, PARCELS_DIR} from '../parcel/index.js'
 
 export const runPack = async ({cwd, env, flags}, ctx) => {
   const {report, packages, queue, prev} = ctx
@@ -54,6 +54,7 @@ export const runPack = async ({cwd, env, flags}, ctx) => {
         pkg.version = ctxPkg.version
         pkg.tag = ctxPkg.tag
         pkg.manifest.version = ctxPkg.version
+        pkg.contextChannels = ctxPkg.channels
         if (!pkg.releaseType) pkg.releaseType = 'patch'
       } else {
         // Standalone: own analysis decides

package/src/main/js/post/modes/verify.js

@@ -4,9 +4,9 @@ import {PARCELS_DIR, verifyParcels} from '../parcel/index.js'
 import {CONTEXT_FILE, readContext} from '../depot/context.js'
 
 export const runVerify = async ({cwd, flags}) => {
-  const inputDir = typeof flags.verify === 'string' ? flags.verify : PARCELS_DIR
+  const [inputDir = PARCELS_DIR, outputDir_ = PARCELS_DIR] = typeof flags.verify === 'string' ? flags.verify.split(':') : []
+  const outputDir = path.resolve(cwd, outputDir_)
   const contextPath = typeof flags.context === 'string' ? flags.context : path.resolve(cwd, CONTEXT_FILE)
-  const outputDir = path.resolve(cwd, PARCELS_DIR)
 
   log.info(`verifying parcels in ${inputDir} against ${contextPath}`)
 

package/src/main/js/post/parcel/directive.js

@@ -17,6 +17,7 @@ export const buildDirective = async (ctx, packedPkgs, outputDir) => {
   const {sha, timestamp} = packedPkgs[0].ctx.git
   const packages = {}
   const parcels = []
+  const packedNames = new Set(packedPkgs.map(p => p.name))
 
   for (const pkg of packedPkgs) {
     const pkgParcels = (pkg.tars || []).map(t => path.basename(t))
@@ -29,12 +30,21 @@ export const buildDirective = async (ctx, packedPkgs, outputDir) => {
     parcels.push(...pkgParcels)
   }
 
+  // Store dependency graph for parallel delivery in topo order
+  const prev = {}
+  if (ctx.prev) {
+    for (const name of packedNames) {
+      const deps = (ctx.prev.get(name) || []).filter(d => packedNames.has(d))
+      if (deps.length) prev[name] = deps
+    }
+  }
+
   const sha7 = sha.slice(0, 7)
   const manifest = {
     channel: 'directive',
     sha, timestamp: Number(timestamp),
     queue: packedPkgs.map(p => p.name),
-    packages, parcels,
+    packages, parcels, prev,
   }
 
   const tarPath = path.join(outputDir, `parcel.${sha7}.directive.${timestamp}.tar`)