@intentius/chant 0.124.100 → 0.124.101

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (223) hide show
  1. package/dist/action-pins.d.ts +2 -0
  2. package/dist/action-pins.js +3 -0
  3. package/dist/ci-detect.d.ts +13 -0
  4. package/dist/ci-detect.js +12 -0
  5. package/dist/ci-system.d.ts +66 -0
  6. package/dist/ci-system.js +61 -0
  7. package/dist/cli/handlers/build.js +27 -0
  8. package/dist/cli/handlers/release-doctor.d.ts +12 -0
  9. package/dist/cli/handlers/release-doctor.js +118 -0
  10. package/dist/cli/handlers/release-init.d.ts +10 -0
  11. package/dist/cli/handlers/release-init.js +342 -0
  12. package/dist/cli/handlers/release.d.ts +42 -1
  13. package/dist/cli/handlers/release.js +656 -31
  14. package/dist/cli/handlers/run-generate.js +11 -0
  15. package/dist/cli/main.d.ts +2 -0
  16. package/dist/cli/main.js +44 -101
  17. package/dist/cli/parse-args.js +48 -0
  18. package/dist/cli/registry.d.ts +16 -0
  19. package/dist/cli/release-commands/artifacts.d.ts +3 -0
  20. package/dist/cli/release-commands/artifacts.js +14 -0
  21. package/dist/cli/release-commands/candidates.d.ts +3 -0
  22. package/dist/cli/release-commands/candidates.js +16 -0
  23. package/dist/cli/release-commands/changed.d.ts +3 -0
  24. package/dist/cli/release-commands/changed.js +14 -0
  25. package/dist/cli/release-commands/compose.d.ts +3 -0
  26. package/dist/cli/release-commands/compose.js +16 -0
  27. package/dist/cli/release-commands/cut.d.ts +3 -0
  28. package/dist/cli/release-commands/cut.js +49 -0
  29. package/dist/cli/release-commands/doctor.d.ts +3 -0
  30. package/dist/cli/release-commands/doctor.js +14 -0
  31. package/dist/cli/release-commands/export.d.ts +3 -0
  32. package/dist/cli/release-commands/export.js +12 -0
  33. package/dist/cli/release-commands/images.d.ts +3 -0
  34. package/dist/cli/release-commands/images.js +13 -0
  35. package/dist/cli/release-commands/index.d.ts +8 -0
  36. package/dist/cli/release-commands/index.js +52 -0
  37. package/dist/cli/release-commands/init.d.ts +3 -0
  38. package/dist/cli/release-commands/init.js +16 -0
  39. package/dist/cli/release-commands/list.d.ts +3 -0
  40. package/dist/cli/release-commands/list.js +10 -0
  41. package/dist/cli/release-commands/next.d.ts +3 -0
  42. package/dist/cli/release-commands/next.js +13 -0
  43. package/dist/cli/release-commands/publish.d.ts +3 -0
  44. package/dist/cli/release-commands/publish.js +22 -0
  45. package/dist/cli/release-commands/stamp.d.ts +3 -0
  46. package/dist/cli/release-commands/stamp.js +15 -0
  47. package/dist/cli/release-commands/status.d.ts +3 -0
  48. package/dist/cli/release-commands/status.js +17 -0
  49. package/dist/cli/release-commands/tag.d.ts +3 -0
  50. package/dist/cli/release-commands/tag.js +12 -0
  51. package/dist/cli/release-commands/types.d.ts +20 -0
  52. package/dist/cli/release-commands/types.js +1 -0
  53. package/dist/cli/release-commands/verify.d.ts +3 -0
  54. package/dist/cli/release-commands/verify.js +15 -0
  55. package/dist/cli/release-commands/workflow.d.ts +3 -0
  56. package/dist/cli/release-commands/workflow.js +13 -0
  57. package/dist/components/cli-support.d.ts +1 -1
  58. package/dist/components/cli-support.js +1 -1
  59. package/dist/config-environments.d.ts +8 -1
  60. package/dist/config-environments.js +2 -0
  61. package/dist/config.d.ts +294 -9
  62. package/dist/config.js +100 -5
  63. package/dist/floor-table.data.js +15 -1
  64. package/dist/forge-remote.d.ts +13 -0
  65. package/dist/forge-remote.js +15 -0
  66. package/dist/lexicon.d.ts +41 -2
  67. package/dist/lifecycle/__fixtures__/publish-fakes.d.ts +62 -0
  68. package/dist/lifecycle/__fixtures__/publish-fakes.js +270 -3
  69. package/dist/lifecycle/publish-attachments.d.ts +2 -1
  70. package/dist/lifecycle/publish-attachments.js +19 -2
  71. package/dist/lifecycle/publish-cargo.d.ts +99 -0
  72. package/dist/lifecycle/publish-cargo.js +412 -0
  73. package/dist/lifecycle/publish-credentials.d.ts +1 -1
  74. package/dist/lifecycle/publish-credentials.js +8 -0
  75. package/dist/lifecycle/publish-declaration.d.ts +199 -4
  76. package/dist/lifecycle/publish-declaration.js +200 -9
  77. package/dist/lifecycle/publish-forge.d.ts +45 -2
  78. package/dist/lifecycle/publish-forge.js +434 -34
  79. package/dist/lifecycle/publish-git-ssh.d.ts +15 -0
  80. package/dist/lifecycle/publish-git-ssh.js +30 -4
  81. package/dist/lifecycle/publish-github.d.ts +40 -2
  82. package/dist/lifecycle/publish-github.js +100 -3
  83. package/dist/lifecycle/publish-homebrew.d.ts +7 -9
  84. package/dist/lifecycle/publish-homebrew.js +34 -197
  85. package/dist/lifecycle/publish-index.d.ts +141 -0
  86. package/dist/lifecycle/publish-index.js +719 -0
  87. package/dist/lifecycle/publish-marketplace.js +77 -0
  88. package/dist/lifecycle/publish-mcp-registry.d.ts +66 -0
  89. package/dist/lifecycle/publish-mcp-registry.js +306 -0
  90. package/dist/lifecycle/publish-npm.js +165 -2
  91. package/dist/lifecycle/publish-oci.d.ts +34 -1
  92. package/dist/lifecycle/publish-oci.js +246 -7
  93. package/dist/lifecycle/publish-pypi.d.ts +136 -0
  94. package/dist/lifecycle/publish-pypi.js +657 -0
  95. package/dist/lifecycle/publish-record.d.ts +6 -3
  96. package/dist/lifecycle/publish-record.js +6 -3
  97. package/dist/lifecycle/publish-signing.d.ts +147 -0
  98. package/dist/lifecycle/publish-signing.js +257 -0
  99. package/dist/lifecycle/publish-targets.d.ts +27 -1
  100. package/dist/lifecycle/publish-targets.js +80 -0
  101. package/dist/lifecycle/publish-tauri.js +43 -0
  102. package/dist/lifecycle/publish-train-names.d.ts +54 -0
  103. package/dist/lifecycle/publish-train-names.js +118 -0
  104. package/dist/lifecycle/publish-verify.d.ts +121 -0
  105. package/dist/lifecycle/publish-verify.js +130 -0
  106. package/dist/lifecycle/query.js +8 -0
  107. package/dist/lifecycle/release-artifacts.d.ts +212 -0
  108. package/dist/lifecycle/release-artifacts.js +571 -0
  109. package/dist/lifecycle/release-changelog.d.ts +13 -1
  110. package/dist/lifecycle/release-changelog.js +35 -2
  111. package/dist/lifecycle/release-cut.d.ts +58 -3
  112. package/dist/lifecycle/release-cut.js +132 -34
  113. package/dist/lifecycle/release-doctor.d.ts +113 -0
  114. package/dist/lifecycle/release-doctor.js +996 -0
  115. package/dist/lifecycle/release-green.d.ts +86 -0
  116. package/dist/lifecycle/release-green.js +286 -0
  117. package/dist/lifecycle/release-init.d.ts +255 -0
  118. package/dist/lifecycle/release-init.js +859 -0
  119. package/dist/lifecycle/release-intents.d.ts +73 -0
  120. package/dist/lifecycle/release-intents.js +128 -0
  121. package/dist/lifecycle/release-next.d.ts +111 -0
  122. package/dist/lifecycle/release-next.js +252 -0
  123. package/dist/lifecycle/release-prerelease.d.ts +19 -0
  124. package/dist/lifecycle/release-prerelease.js +30 -0
  125. package/dist/lifecycle/release-publish.d.ts +256 -10
  126. package/dist/lifecycle/release-publish.js +246 -34
  127. package/dist/lifecycle/release-status-change.d.ts +226 -0
  128. package/dist/lifecycle/release-status-change.js +478 -0
  129. package/dist/lifecycle/release-status.d.ts +11 -0
  130. package/dist/lifecycle/release-status.js +1 -1
  131. package/dist/lifecycle/release-store.d.ts +73 -2
  132. package/dist/lifecycle/release-store.js +32 -1
  133. package/dist/lifecycle/release-tag.d.ts +142 -0
  134. package/dist/lifecycle/release-tag.js +323 -0
  135. package/dist/lifecycle/release-verify.d.ts +73 -1
  136. package/dist/lifecycle/release-verify.js +117 -2
  137. package/dist/lifecycle/release-version-formats.d.ts +73 -0
  138. package/dist/lifecycle/release-version-formats.js +570 -0
  139. package/dist/lifecycle/release-version.d.ts +58 -10
  140. package/dist/lifecycle/release-version.js +164 -36
  141. package/dist/lifecycle/release-workstation.d.ts +3 -2
  142. package/dist/lifecycle/release-workstation.js +3 -2
  143. package/dist/op/generate-pipeline.js +1 -1
  144. package/dist/pr-forge-base.js +4 -2
  145. package/dist/pr-forge.d.ts +20 -2
  146. package/dist/pr-forge.js +46 -10
  147. package/dist/release-floors.d.ts +8 -1
  148. package/dist/release-floors.js +9 -2
  149. package/dist/tool-pins.d.ts +38 -0
  150. package/dist/tool-pins.js +54 -0
  151. package/dist/wave-runtime.mjs +337 -334
  152. package/dist/workspace/ci-forge.d.ts +17 -0
  153. package/dist/workspace/ci-forge.js +17 -0
  154. package/dist/workspace/ci-init.js +1 -1
  155. package/dist/workspace/composites.schema.json +1 -0
  156. package/dist/workspace/declaration.d.ts +8 -0
  157. package/dist/workspace/declaration.js +12 -0
  158. package/dist/workspace/declaration.schema.json +8 -0
  159. package/dist/workspace/environments.d.ts +2 -0
  160. package/dist/workspace/environments.js +1 -1
  161. package/dist/workspace/identity-gate-rule.d.ts +61 -5
  162. package/dist/workspace/identity-gate-rule.js +81 -12
  163. package/dist/workspace/member-pipeline.d.ts +2 -1
  164. package/dist/workspace/member-pipeline.js +5 -2
  165. package/dist/workspace/reason-codes.d.ts +2 -0
  166. package/dist/workspace/reason-codes.js +3 -1
  167. package/dist/workspace/release-changed.d.ts +75 -4
  168. package/dist/workspace/release-changed.js +205 -34
  169. package/dist/workspace/release-changed.schema.json +20 -2
  170. package/dist/workspace/release-steps/artifacts.d.ts +7 -0
  171. package/dist/workspace/release-steps/artifacts.js +45 -0
  172. package/dist/workspace/release-steps/builds.d.ts +12 -0
  173. package/dist/workspace/release-steps/builds.js +38 -0
  174. package/dist/workspace/release-steps/doctor.d.ts +8 -0
  175. package/dist/workspace/release-steps/doctor.js +14 -0
  176. package/dist/workspace/release-steps/goreleaser.d.ts +16 -0
  177. package/dist/workspace/release-steps/goreleaser.js +36 -0
  178. package/dist/workspace/release-steps/green.d.ts +3 -0
  179. package/dist/workspace/release-steps/green.js +6 -0
  180. package/dist/workspace/release-steps/images.d.ts +22 -0
  181. package/dist/workspace/release-steps/images.js +59 -0
  182. package/dist/workspace/release-steps/index.d.ts +9 -0
  183. package/dist/workspace/release-steps/index.js +46 -0
  184. package/dist/workspace/release-steps/pypi.d.ts +15 -0
  185. package/dist/workspace/release-steps/pypi.js +21 -0
  186. package/dist/workspace/release-steps/qemu.d.ts +21 -0
  187. package/dist/workspace/release-steps/qemu.js +35 -0
  188. package/dist/workspace/release-steps/signing.d.ts +18 -0
  189. package/dist/workspace/release-steps/signing.js +30 -0
  190. package/dist/workspace/release-steps/stamp.d.ts +3 -0
  191. package/dist/workspace/release-steps/stamp.js +4 -0
  192. package/dist/workspace/release-steps/targets.d.ts +31 -0
  193. package/dist/workspace/release-steps/targets.js +40 -0
  194. package/dist/workspace/release-steps/types.d.ts +104 -0
  195. package/dist/workspace/release-steps/types.js +2 -0
  196. package/dist/workspace/release-steps/verify.d.ts +3 -0
  197. package/dist/workspace/release-steps/verify.js +4 -0
  198. package/dist/workspace/release-toolchains.d.ts +59 -0
  199. package/dist/workspace/release-toolchains.js +133 -0
  200. package/dist/workspace/release-train-workflow.d.ts +29 -0
  201. package/dist/workspace/release-train-workflow.js +85 -0
  202. package/dist/workspace/release-train.d.ts +3 -1
  203. package/dist/workspace/release-train.js +20 -3
  204. package/dist/workspace/release-workflow.d.ts +160 -61
  205. package/dist/workspace/release-workflow.js +539 -193
  206. package/dist/workspace/releases.schema.json +70 -1
  207. package/dist/workspace/search-contract.d.ts +1 -1
  208. package/dist/workspace/security.js +9 -2
  209. package/dist/workspace/train-cut.d.ts +182 -0
  210. package/dist/workspace/train-cut.js +482 -0
  211. package/dist/workspace/train-prepare.d.ts +61 -0
  212. package/dist/workspace/train-prepare.js +267 -0
  213. package/dist/workspace/train-publish.d.ts +177 -0
  214. package/dist/workspace/train-publish.js +575 -0
  215. package/dist/workspace/train-range-labels.d.ts +33 -0
  216. package/dist/workspace/train-range-labels.js +109 -0
  217. package/dist/workspace/trust/seal.d.ts +13 -3
  218. package/dist/workspace/trust/seal.js +14 -4
  219. package/dist/workspace/work-cli.d.ts +3 -2
  220. package/dist/workspace/work-cli.js +3 -2
  221. package/dist/workspace/workspace-ledger.d.ts +14 -1
  222. package/dist/workspace/workspace-ledger.js +33 -7
  223. package/package.json +1 -1
@@ -0,0 +1,575 @@
1
+ /**
2
+ * Publishing a release train as one set (#5136, design #5132 decision 5):
3
+ * `chant workspace train publish <env> [<train>] [--yes]`.
4
+ *
5
+ * A train pins one release of every `chant` member. Its publish runs in a
6
+ * checkout of the commit the train's new releases were cut from, and splits
7
+ * the members in two:
8
+ *
9
+ * - a member whose release was cut from this commit is published by this run;
10
+ * - a member pinned at a release cut from another commit must already be
11
+ * published: its publish record (`_releases/publishes.jsonl`) shows every
12
+ * target revealed, or each target that is not says its destination already
13
+ * serves the release's label (`PublishTarget.published`). Otherwise the
14
+ * publish refuses before anything stages.
15
+ *
16
+ * Every member it publishes is prepared as `chant release publish` prepares
17
+ * one (`preparePublish`: revocation, signatures, provenance, a clean checkout
18
+ * of the release's commit), and every target is planned, before anything
19
+ * stages. The members are put in dependency layers from the names their
20
+ * targets publish and need (`PublishTarget.names`, #5165), each qualified by
21
+ * its kind (./lifecycle/publish-train-names.ts): npm package names and their
22
+ * dependency, peer and optional keys; an image's repository; PyPI projects and
23
+ * their `Requires-Dist`; crates and their dependencies; an extension and its
24
+ * `extensionDependencies`; an MCP Registry entry and the packages and images
25
+ * its `server.json` lists. A member's `release.dependsOn` adds the members a
26
+ * manifest doesn't show. Members of one layer go in name order, so core
27
+ * comes first.
28
+ *
29
+ * Then two passes, as `runPublish` does for one release (#4048), across the
30
+ * whole train:
31
+ *
32
+ * 1. Stage every member's targets, layer by layer, so a failure leaves no
33
+ * member visible to a consumer.
34
+ * 2. Run each member's `release.verify` commands (#5157), in layer order,
35
+ * with the whole train's staged references, unless a record shows a
36
+ * reveal. A failure is recorded in the member's record and stops the
37
+ * publish before the first layer reveals.
38
+ * 3. Reveal layer by layer. Before the next layer, wait until each revealed
39
+ * target of this one resolves for a consumer (`PublishTarget.visible`:
40
+ * npm's `dist-tags.latest` names the version, an image's tags name its
41
+ * digest, an index or registry lists the version), so nothing is visible
42
+ * before what it needs is.
43
+ *
44
+ * Within a member, targets reveal in `revealOrder`: uploads at reveal after
45
+ * the rest, and the MCP Registry last.
46
+ *
47
+ * A target whose stage is already visible (npm under `stage: false`) is not
48
+ * staged up front: it publishes in pass 2, in its layer's turn, after the
49
+ * layers before it are visible.
50
+ *
51
+ * Every step is recorded in the member's own publish record, so running the
52
+ * same command after a failure resumes across members without publishing
53
+ * again what went out, and `chant release publish` in one member reads the
54
+ * same record.
55
+ */
56
+ import { execFileSync } from "node:child_process";
57
+ import { resolve } from "node:path";
58
+ import { PublishTargetError, revealOrder } from "../lifecycle/release-publish.js";
59
+ import { readDeclaration } from "./declaration.js";
60
+ import { findTrain, readReleaseTrains } from "./release-train.js";
61
+ import { locateWorkspace } from "./which-chant.js";
62
+ import { NEXT_RELEASE } from "../release-floors.js";
63
+ /** The first chant whose `chant workspace train publish` orders and resumes members of every target kind (#5165): the oci, forge, homebrew, index, marketplace, pypi, cargo, mcp-registry and tauri-updater targets name what they publish and need, say whether a pinned release is published, and wait until a reveal is served before the next layer; a member's `release.dependsOn` names members a manifest doesn't show. */
64
+ export const TRAIN_PUBLISH_TARGETS_FLOOR = NEXT_RELEASE;
65
+ /** A train publish that stopped, with what it left staged and revealed (`<member>: <target>`), so a run of the same command resumes. */
66
+ export class TrainPublishRunError extends PublishTargetError {
67
+ constructor(code, message, fix, member, step, staged, revealed) {
68
+ super(code, message, fix);
69
+ this.member = member;
70
+ this.step = step;
71
+ this.staged = staged;
72
+ this.revealed = revealed;
73
+ this.name = "TrainPublishRunError";
74
+ }
75
+ }
76
+ const refuse = (code, message, fix) => ({ kind: "refused", code, message, ...(fix ? { fix } : {}) });
77
+ function headOf(cwd) {
78
+ try {
79
+ return execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
80
+ }
81
+ catch {
82
+ return null;
83
+ }
84
+ }
85
+ /**
86
+ * Dependency layers over `members` (pure): a member needs another when one
87
+ * of the names it needs is one the other provides. Members of a cycle share
88
+ * a layer. Each layer is sorted by name.
89
+ */
90
+ export function trainLayers(members) {
91
+ const owner = new Map();
92
+ for (const m of members)
93
+ for (const n of m.provides)
94
+ owner.set(n, m.member);
95
+ const deps = new Map(members.map((m) => [m.member, new Set(m.needs.map((n) => owner.get(n)).filter((o) => o !== undefined && o !== m.member))]));
96
+ const left = new Set(members.map((m) => m.member));
97
+ const layers = [];
98
+ while (left.size > 0) {
99
+ let ready = [...left].filter((m) => [...deps.get(m)].every((d) => !left.has(d)));
100
+ // A cycle can't be ordered; what is left shares the layer.
101
+ if (ready.length === 0)
102
+ ready = [...left];
103
+ ready.sort((a, b) => a.localeCompare(b));
104
+ for (const m of ready)
105
+ left.delete(m);
106
+ layers.push(ready);
107
+ }
108
+ return layers;
109
+ }
110
+ /** Each member's direct dependencies among `members` (pure), by the same rule as {@link trainLayers}. */
111
+ export function trainDependencies(members) {
112
+ const owner = new Map();
113
+ for (const m of members)
114
+ for (const n of m.provides)
115
+ owner.set(n, m.member);
116
+ return new Map(members.map((m) => [m.member, [...new Set(m.needs.map((n) => owner.get(n)).filter((o) => o !== undefined && o !== m.member))].sort()]));
117
+ }
118
+ /** The name a member provides for `release.dependsOn` (#5165). */
119
+ const memberName = (member) => `member:${member}`;
120
+ /**
121
+ * The paths (as `git status --porcelain` prints them) that are a member's
122
+ * `release.version` file stamped with its label in `train` (#5154), across
123
+ * the members this checkout publishes.
124
+ */
125
+ async function trainStamps(root, head, train, here) {
126
+ const out = new Set();
127
+ if (head === null || here.length === 0)
128
+ return out;
129
+ let status;
130
+ let top;
131
+ try {
132
+ status = execFileSync("git", ["status", "--porcelain", "--untracked-files=normal"], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
133
+ top = execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
134
+ }
135
+ catch {
136
+ return out;
137
+ }
138
+ if (status.trim() === "")
139
+ return out;
140
+ const { loadChantConfig } = await import("../config.js");
141
+ const { stampedChanges } = await import("../lifecycle/release-version.js");
142
+ const { trainPackageLabels } = await import("./train-range-labels.js");
143
+ let labels;
144
+ for (const m of here) {
145
+ const version = (await loadChantConfig(m.dir).catch(() => null))?.config.release?.version;
146
+ if (!version || m.label === null)
147
+ continue;
148
+ labels ?? (labels = await trainPackageLabels(train, root).catch(() => ({})));
149
+ for (const p of stampedChanges({ cwd: m.dir, top, commit: head, config: version, label: m.label, status, trains: [labels] }))
150
+ out.add(p);
151
+ }
152
+ return out;
153
+ }
154
+ /** Plan, and with `yes` publish, a release train (#5136). */
155
+ export async function publishTrain(query) {
156
+ const { preparePublish, publishContext, releasePublishTargets, detectProvenance } = await import("../lifecycle/release-publish.js");
157
+ const { createRedactor } = await import("../lifecycle/publish-credentials.js");
158
+ const { publishProgress, progressOf, readPublishRecords } = await import("../lifecycle/publish-record.js");
159
+ const { resolveRelease } = await import("../lifecycle/release-store.js");
160
+ const env = query.processEnv ?? process.env;
161
+ const say = query.say ?? (() => undefined);
162
+ const log = query.log ?? (() => undefined);
163
+ const located = locateWorkspace(query.cwd);
164
+ const root = located.rootOnDisk;
165
+ const { records } = await readReleaseTrains(root, query.env);
166
+ const train = findTrain(records, query.train);
167
+ if (!train) {
168
+ return query.train === undefined
169
+ ? refuse("train-not-found", `no release train is recorded for ${query.env}`, `Record one with: chant workspace train ${query.env}`)
170
+ : refuse("train-not-found", `no release train ${query.train} is recorded for ${query.env}`, `List them with: chant workspace train list ${query.env}`);
171
+ }
172
+ const across = train.members.filter((m) => m.repo !== undefined);
173
+ if (across.length > 0) {
174
+ return refuse("train-repo-members", `release train ${train.id} pins repo members (${across.map((m) => m.member).join(", ")}), and a train publish publishes chant members from this checkout`, "Publish each repo member in its own repository.");
175
+ }
176
+ const declaration = readDeclaration(located.tree, "");
177
+ const dirOf = new Map(declaration.members.map((d) => [d.name, resolve(root, d.dir)]));
178
+ const missing = train.members.filter((m) => !dirOf.has(m.member));
179
+ if (missing.length > 0)
180
+ return refuse("train-member-unknown", `release train ${train.id} pins ${missing.map((m) => m.member).join(", ")}, which the declaration does not list`);
181
+ const head = headOf(root);
182
+ const provenance = detectProvenance(env);
183
+ const memberLog = (member, redactor) => (line) => log(redactor.redact(`${member}: ${line}`));
184
+ // Pinned at an earlier commit: already published, or the publish refuses before anything stages.
185
+ const members = [];
186
+ const credentialEnv = [];
187
+ for (const m of train.members.filter((x) => x.commit !== head)) {
188
+ const dir = dirOf.get(m.member);
189
+ let targets;
190
+ try {
191
+ targets = await releasePublishTargets(dir, query.deps);
192
+ }
193
+ catch (err) {
194
+ return refuse("publish-config-invalid", `${m.member}: the publish targets can't be read: ${err instanceof Error ? err.message : String(err)}`, "Fix release.publish in the member's chant.config.ts.");
195
+ }
196
+ credentialEnv.push(...targets.flatMap((t) => t.credentialEnv));
197
+ const progress = publishProgress(await readPublishRecords(m.releaseDigest, { cwd: dir }).catch(() => []));
198
+ const name = `${m.member} ${m.label ?? m.releaseDigest}`;
199
+ const unrevealed = targets.filter((t) => !progress.revealed.has(t.key));
200
+ if (unrevealed.length > 0) {
201
+ const found = await resolveRelease(m.releaseDigest, { cwd: dir });
202
+ if (!found)
203
+ return refuse("release-not-found", `${name}: the train pins release ${m.releaseDigest}, which no cut in the member names`);
204
+ const redactor = createRedactor(env, targets.flatMap((t) => t.credentialEnv));
205
+ const label = m.label ?? found.label;
206
+ // #5165: the tag the cut made, which a forge release is named by.
207
+ const releaseTag = label !== null ? await pinnedReleaseTag(dir, label) : null;
208
+ const ctx = { release: found.release, label, releaseTag, provenance, cwd: dir, tag: null, env, redactor, log: memberLog(m.member, redactor) };
209
+ for (const t of unrevealed) {
210
+ const there = t.published ? await t.published(ctx).catch(() => null) : null;
211
+ if (there !== true) {
212
+ return refuse("train-member-unpublished", `${name} was cut from commit ${m.commit.slice(0, 12)}, not this checkout's ${head ? head.slice(0, 12) : "commit"}, so this publish does not publish it, and it is not published: ${t.name} ${there === false ? "does not hold it" : "can't say whether it holds it"}, and its publish record shows no reveal. Nothing was published.`, `Publish it first from a checkout of ${m.commit.slice(0, 12)}: chant release publish ${m.label ?? m.releaseDigest} --yes, in ${m.member}. Or record a train that pins a published release of it.`);
213
+ }
214
+ }
215
+ }
216
+ members.push({ member: m.member, label: m.label, releaseDigest: m.releaseDigest, commit: m.commit, role: "pinned", layer: null, targets: [] });
217
+ }
218
+ // Cut from this commit: prepared and planned, every one, before anything stages.
219
+ const prepared = [];
220
+ const warnings = [];
221
+ // #5154: `chant workspace train prepare` stamps every member cut here in one checkout; each takes the others' stamps as the commit's.
222
+ const stampedHere = await trainStamps(root, head, train, train.members.filter((x) => x.commit === head).map((m) => ({ member: m.member, label: m.label, dir: dirOf.get(m.member) })));
223
+ for (const m of train.members.filter((x) => x.commit === head)) {
224
+ const dir = dirOf.get(m.member);
225
+ const plan = await preparePublish({ cwd: dir, ref: m.releaseDigest, env, ...(query.deps ? { deps: query.deps } : {}), allowUnsigned: query.allowUnsigned === true, requireProvenance: query.requireProvenance === true, alsoStamped: stampedHere });
226
+ if ("refusal" in plan)
227
+ return refuse(plan.refusal.code, `${m.member}: ${plan.refusal.message}. Nothing was published.`, plan.refusal.fix);
228
+ credentialEnv.push(...plan.targets.flatMap((t) => t.credentialEnv));
229
+ for (const w of [plan.signatureWarning, plan.warning])
230
+ if (w && !warnings.includes(`${m.member}: ${w}`))
231
+ warnings.push(`${m.member}: ${w}`);
232
+ const ctx = publishContext(plan, { cwd: dir, env, tag: plan.channel, log: memberLog(m.member, plan.redactor) });
233
+ prepared.push({ m, dir, plan, ctx });
234
+ }
235
+ const redactor = createRedactor(env, credentialEnv);
236
+ if (prepared.length === 0) {
237
+ return refuse("train-nothing-cut-here", `release train ${train.id} has no release cut from this checkout's commit ${head ? head.slice(0, 12) : "(none)"}, so there is nothing for it to publish here`, "Run the publish in a checkout of the commit the train's new releases were cut from, as the job on its release-train tag does.");
238
+ }
239
+ // Layers from what each member's targets publish and need, and the members release.dependsOn names (#5165).
240
+ const named = [];
241
+ for (const p of prepared) {
242
+ const unknown = (p.plan.dependsOn ?? []).filter((d) => !dirOf.has(d));
243
+ if (unknown.length > 0) {
244
+ return refuse("train-depends-on-unknown", `${p.m.member}: release.dependsOn names ${unknown.join(", ")}, which the declaration does not list. Nothing was published.`, `Name members of this workspace: ${[...dirOf.keys()].sort().join(", ")}.`);
245
+ }
246
+ const provides = [memberName(p.m.member)];
247
+ const needs = (p.plan.dependsOn ?? []).map(memberName);
248
+ for (const t of p.plan.targets) {
249
+ if (!t.names)
250
+ continue;
251
+ try {
252
+ const n = await t.names(p.ctx);
253
+ provides.push(...n.provides);
254
+ needs.push(...n.needs);
255
+ }
256
+ catch {
257
+ // A target that can't name what it publishes orders nothing; its plan below says why it can't publish.
258
+ }
259
+ }
260
+ named.push({ member: p.m.member, provides, needs });
261
+ }
262
+ const layers = trainLayers(named);
263
+ const afterOf = trainDependencies(named);
264
+ const layerOf = new Map(layers.flatMap((l, i) => l.map((m) => [m, i])));
265
+ const ordered = layers.flat().map((member) => ({ ...prepared.find((p) => p.m.member === member), layer: layerOf.get(member) }));
266
+ const progressOfMember = new Map();
267
+ for (const p of ordered) {
268
+ const progress = publishProgress(await readPublishRecords(p.m.releaseDigest, { cwd: p.dir }).catch(() => []));
269
+ progressOfMember.set(p.m.member, progress);
270
+ const targets = [];
271
+ for (const t of p.plan.targets) {
272
+ try {
273
+ targets.push({ name: t.name, kind: t.kind, destination: t.destination, progress: progressOf(progress, t), items: await t.plan(p.ctx) });
274
+ }
275
+ catch (err) {
276
+ const e = err instanceof PublishTargetError ? err : new PublishTargetError("publish-failed", err instanceof Error ? err.message : String(err));
277
+ return refuse(e.code, redactor.redact(`nothing was published: ${p.m.member}: ${t.name}: ${e.message}`), e.fix);
278
+ }
279
+ }
280
+ const after = afterOf.get(p.m.member) ?? [];
281
+ members.push({ member: p.m.member, label: p.m.label, releaseDigest: p.m.releaseDigest, commit: p.m.commit, role: "publish", layer: p.layer, ...(after.length > 0 ? { after } : {}), targets });
282
+ }
283
+ members.sort((a, b) => (a.layer ?? -1) - (b.layer ?? -1) || a.member.localeCompare(b.member));
284
+ // #5157: each member's release.verify, after the whole train has staged; a target whose stage is visible is out of its reach.
285
+ const verify = ordered.filter((p) => (p.plan.verify ?? []).length > 0 && p.plan.targets.length > 0).map((p) => ({ member: p.m.member, steps: p.plan.verify }));
286
+ if (verify.length > 0) {
287
+ const { unstagedForVerify, unstagedWarning } = await import("../lifecycle/publish-verify.js");
288
+ const unstaged = ordered.flatMap((p) => unstagedForVerify(p.plan.targets).map((n) => `${p.m.member}: ${n}`));
289
+ if (unstaged.length > 0)
290
+ warnings.push(unstagedWarning(unstaged));
291
+ }
292
+ if (!query.yes)
293
+ return { kind: "planned", train, members, warnings, redactor, verify };
294
+ const ran = await runTrain({ ordered, layers: layers.length, progressOfMember, verify, say: (l) => say(redactor.redact(l)), record: query.record ?? true, now: query.now ?? (() => new Date()), ...(query.runVerify ? { runVerify: query.runVerify } : {}) });
295
+ // #5150: each member's floating tag moves once the whole train has revealed, unless one of its targets refused.
296
+ const floatingWarnings = [];
297
+ const { moveFloatingTag } = await import("../lifecycle/release-publish.js");
298
+ for (const p of ordered) {
299
+ const f = p.plan.floating;
300
+ if (!f?.move)
301
+ continue;
302
+ const refused = ran.published.find((x) => x.member === p.m.member)?.targets.some((t) => t.warning);
303
+ const w = refused ? `the floating tag ${f.name} was not moved, since a target refused the release` : moveFloatingTag(p.dir, f);
304
+ if (w)
305
+ floatingWarnings.push(`${p.m.member}: ${w}`);
306
+ }
307
+ return { kind: "published", train, members, warnings, redactor, verify, ...ran, floatingWarnings };
308
+ }
309
+ /** The tag `release.tag` gives `label` in the member at `dir`, or null when it can't be told. */
310
+ async function pinnedReleaseTag(dir, label) {
311
+ try {
312
+ const { memberTags, renderReleaseTag } = await import("../lifecycle/release-tag.js");
313
+ const tags = await memberTags(dir);
314
+ return renderReleaseTag(tags.template, tags.place, label);
315
+ }
316
+ catch {
317
+ return null;
318
+ }
319
+ }
320
+ /** The two passes over the prepared members (#5136). Throws {@link TrainPublishRunError}. */
321
+ async function runTrain(req) {
322
+ const { appendPublishRecord } = await import("../lifecycle/publish-record.js");
323
+ const { pushLifecycleReport } = await import("../lifecycle/git.js");
324
+ const { resolveRunId } = await import("../lifecycle/release-ledger.js");
325
+ const { ordered, say } = req;
326
+ let recordWarning = null;
327
+ const stagedNames = [];
328
+ const revealedNames = [];
329
+ const resumed = [];
330
+ const staged = new Map();
331
+ const keyOf = (p, t) => `${p.m.member}\u0000${t.key}`;
332
+ const shown = (p, t) => `${p.m.member}: ${t.name}`;
333
+ const write = async (p, target, step, items, state) => {
334
+ if (!req.record)
335
+ return;
336
+ try {
337
+ const runId = resolveRunId(undefined, p.ctx.env).runId;
338
+ await appendPublishRecord({ version: 1, releaseDigest: p.m.releaseDigest, label: p.plan.label, target: target.key, kind: target.kind, name: target.name, step, items, state, runId, timestamp: req.now().toISOString() }, p.plan.redactor, { cwd: p.dir });
339
+ const push = await pushLifecycleReport({ cwd: p.dir });
340
+ if (push.pushWarning && recordWarning === null)
341
+ recordWarning = push.pushWarning;
342
+ }
343
+ catch (err) {
344
+ recordWarning ?? (recordWarning = `the publish record was not written: ${err instanceof Error ? err.message : String(err)}`);
345
+ }
346
+ };
347
+ const fail = (err, p, target, step) => {
348
+ const e = err instanceof PublishTargetError ? err : new PublishTargetError("publish-failed", err instanceof Error ? err.message : String(err));
349
+ throw new TrainPublishRunError(e.code, p.plan.redactor.redact(`${shown(p, target)}: ${e.message}`), e.fix, p.m.member, step, [...stagedNames], [...revealedNames]);
350
+ };
351
+ // #5158: a target whose refusals are warnings, refused: reported with its warning, not revealed, not recorded.
352
+ const refused = new Map();
353
+ const refusal = (p, t, err) => {
354
+ const why = p.plan.redactor.redact(err instanceof Error ? err.message : String(err));
355
+ say(` warning: ${shown(p, t)}: ${why}`);
356
+ return { target: t.name, destination: t.destination, items: [{ name: t.name, destination: t.destination, refused: true }], warning: why };
357
+ };
358
+ const stage = async (p, t) => {
359
+ say(` ${p.m.member}: staging to ${t.destination}`);
360
+ let s;
361
+ try {
362
+ s = await t.stage(p.ctx);
363
+ }
364
+ catch (err) {
365
+ if (t.refusalWarns) {
366
+ refused.set(keyOf(p, t), refusal(p, t, err));
367
+ return;
368
+ }
369
+ return fail(err, p, t, "stage");
370
+ }
371
+ staged.set(keyOf(p, t), s);
372
+ stagedNames.push(shown(p, t));
373
+ await write(p, t, "staged", s.items, s.state);
374
+ };
375
+ // Pass 1: stage every target that holds back what it stages, before any reveal.
376
+ for (const p of ordered) {
377
+ const progress = req.progressOfMember.get(p.m.member);
378
+ for (const t of p.plan.targets) {
379
+ if (progress.revealed.has(t.key))
380
+ continue;
381
+ const earlier = progress.staged.get(t.key);
382
+ if (earlier) {
383
+ resumed.push({ member: p.m.member, target: t.name, step: "staged" });
384
+ say(` ${shown(p, t)}: staged by an earlier run; not staged again`);
385
+ staged.set(keyOf(p, t), { ...earlier, target: t.name, destination: t.destination });
386
+ stagedNames.push(shown(p, t));
387
+ continue;
388
+ }
389
+ if (t.stagesVisibly)
390
+ continue;
391
+ await stage(p, t);
392
+ }
393
+ }
394
+ // #5157: every member's release.verify, before the first layer reveals; not once any reveal is recorded.
395
+ let verified;
396
+ const anyUnrevealed = ordered.some((p) => p.plan.targets.some((t) => !req.progressOfMember.get(p.m.member).revealed.has(t.key)));
397
+ if (req.verify.length > 0 && anyUnrevealed) {
398
+ if (ordered.some((p) => req.progressOfMember.get(p.m.member).revealed.size > 0)) {
399
+ say(" verify: skipped, since an earlier run began revealing");
400
+ verified = "skipped";
401
+ }
402
+ else {
403
+ const { runVerifySteps, stagedReference, verifyKey } = await import("../lifecycle/publish-verify.js");
404
+ const refs = ordered.flatMap((p) => p.plan.targets.filter((t) => staged.has(keyOf(p, t))).map((t) => stagedReference(t, staged.get(keyOf(p, t)), p.m.member)));
405
+ for (const v of req.verify) {
406
+ const p = ordered.find((x) => x.m.member === v.member);
407
+ const outcome = runVerifySteps({ cwd: p.dir, steps: v.steps, env: p.ctx.env, release: p.plan.release, label: p.plan.label, releaseTag: p.plan.releaseTag, staged: refs, say: (l) => say(l.replace(/^ /, ` ${p.m.member}: `)), ...(req.runVerify ? { run: req.runVerify } : {}) });
408
+ const key = { key: verifyKey(v.steps), kind: "verify", name: "verify" };
409
+ if (!outcome.passed) {
410
+ await write(p, key, "verify-failed", [], { step: outcome.step.name, exitCode: String(outcome.exitCode) });
411
+ throw new TrainPublishRunError("publish-verify-failed", p.plan.redactor.redact(`${p.m.member}: verify: ${outcome.step.name} exited ${outcome.exitCode ?? "on a signal"}`), "Nothing was revealed. Fix what it found and run the same command again: what staged is not staged again, and the verify commands run again before any reveal.", p.m.member, "verify", [...stagedNames], []);
412
+ }
413
+ await write(p, key, "verified", [], {});
414
+ }
415
+ verified = "passed";
416
+ }
417
+ }
418
+ // Pass 2: layer by layer, reveal; then wait until the layer resolves before the next one.
419
+ const published = [];
420
+ for (let layer = 0; layer < req.layers; layer++) {
421
+ const inLayer = ordered.filter((p) => p.layer === layer);
422
+ const waits = [];
423
+ for (const p of inLayer) {
424
+ const progress = req.progressOfMember.get(p.m.member);
425
+ const out = [];
426
+ for (const t of revealOrder(p.plan.targets)) {
427
+ const done = progress.revealed.get(t.key);
428
+ if (done) {
429
+ resumed.push({ member: p.m.member, target: t.name, step: "revealed" });
430
+ say(` ${shown(p, t)}: published by an earlier run; skipped`);
431
+ const was = { ...done, target: t.name, destination: t.destination, items: done.items.map((i) => ({ ...i, present: true })) };
432
+ out.push(was);
433
+ revealedNames.push(shown(p, t));
434
+ waits.push({ p, t, done: was });
435
+ continue;
436
+ }
437
+ if (!staged.has(keyOf(p, t)) && !refused.has(keyOf(p, t)))
438
+ await stage(p, t);
439
+ const wasRefused = refused.get(keyOf(p, t));
440
+ if (wasRefused) {
441
+ out.push(wasRefused);
442
+ continue;
443
+ }
444
+ say(` ${p.m.member}: revealing ${t.name}`);
445
+ let r;
446
+ try {
447
+ r = await t.reveal(p.ctx, staged.get(keyOf(p, t)));
448
+ }
449
+ catch (err) {
450
+ if (t.refusalWarns) {
451
+ out.push(refusal(p, t, err));
452
+ continue;
453
+ }
454
+ return fail(err, p, t, "reveal");
455
+ }
456
+ out.push(r);
457
+ if (r.warning) {
458
+ say(` warning: ${shown(p, t)}: ${r.warning}`);
459
+ continue;
460
+ }
461
+ revealedNames.push(shown(p, t));
462
+ await write(p, t, "revealed", r.items, {});
463
+ waits.push({ p, t, done: r });
464
+ }
465
+ published.push({ member: p.m.member, targets: out });
466
+ }
467
+ if (layer === req.layers - 1)
468
+ continue;
469
+ for (const { p, t, done } of waits) {
470
+ if (!t.visible)
471
+ continue;
472
+ try {
473
+ await t.visible(p.ctx, done);
474
+ }
475
+ catch (err) {
476
+ return fail(err, p, t, "wait");
477
+ }
478
+ }
479
+ }
480
+ return { published, resumed, recordWarning, ...(verified ? { verified } : {}) };
481
+ }
482
+ const USAGE = "chant workspace train publish <env> [<train id|digest>] [--yes] [--allow-unsigned] [--require-provenance] [--json]";
483
+ /** `chant workspace train publish <env> [<train>] [--yes]` (#5136). */
484
+ export async function runTrainPublish(ctx, words) {
485
+ const { formatError, formatSuccess, formatWarning } = await import("../cli/format.js");
486
+ const { WorkspaceReadError } = await import("./declaration.js");
487
+ const { fetchLifecycle } = await import("../lifecycle/git.js");
488
+ const { args } = ctx;
489
+ const [env, ref] = words;
490
+ if (!env) {
491
+ console.error(formatError({ message: "chant workspace train publish needs an environment", hint: USAGE }));
492
+ return 1;
493
+ }
494
+ const cwd = resolve(".");
495
+ const json = args.json === true;
496
+ await fetchLifecycle({ cwd }).catch(() => false);
497
+ let outcome;
498
+ try {
499
+ outcome = await publishTrain({
500
+ cwd,
501
+ env,
502
+ ...(ref !== undefined ? { train: ref } : {}),
503
+ yes: args.yes === true,
504
+ allowUnsigned: args.allowUnsigned === true,
505
+ requireProvenance: args.requireProvenance === true,
506
+ say: (line) => (json ? undefined : console.error(line)),
507
+ log: (line) => (json ? undefined : console.error(` ${line}`)),
508
+ });
509
+ }
510
+ catch (err) {
511
+ if (err instanceof WorkspaceReadError) {
512
+ console.error(formatError({ message: `${err.code}: ${err.describe()}`, hint: USAGE }));
513
+ return 1;
514
+ }
515
+ if (err instanceof TrainPublishRunError) {
516
+ const where = (err.step === "stage" || err.step === "verify") && err.revealed.length === 0
517
+ ? `nothing is visible yet${err.staged.length > 0 ? `; staged: ${err.staged.join(", ")}` : ""}`
518
+ : `revealed: ${err.revealed.length > 0 ? err.revealed.join(", ") : "none"}; staged and not yet revealed: ${err.staged.filter((t) => !err.revealed.includes(t)).join(", ") || "none"}`;
519
+ if (json)
520
+ console.log(JSON.stringify({ status: "failed", code: err.code, message: err.message, member: err.member, step: err.step, staged: err.staged, revealed: err.revealed }, null, 2));
521
+ console.error(formatError({ message: `${err.message}; ${where} [${err.code}]`, hint: `${err.fix ? `${err.fix} ` : ""}Run the same command again to resume; what went out is not published again.` }));
522
+ return 1;
523
+ }
524
+ throw err;
525
+ }
526
+ if (outcome.kind === "refused") {
527
+ if (json)
528
+ console.log(JSON.stringify({ status: "refused", code: outcome.code, message: outcome.message }, null, 2));
529
+ console.error(formatError({ message: `${outcome.message} [${outcome.code}]`, ...(outcome.fix ? { hint: outcome.fix } : {}) }));
530
+ return 1;
531
+ }
532
+ const { redactor } = outcome;
533
+ for (const w of outcome.warnings)
534
+ console.error(formatWarning({ message: w }));
535
+ const base = { train: outcome.train.id, trainDigest: outcome.train.trainDigest, env, members: outcome.members };
536
+ if (outcome.kind === "planned") {
537
+ if (json) {
538
+ console.log(redactor.redact(JSON.stringify({ dryRun: true, ...base, ...(outcome.verify.length > 0 ? { verify: outcome.verify } : {}) }, null, 2)));
539
+ return 0;
540
+ }
541
+ const out = (line) => console.log(redactor.redact(line));
542
+ out(`Dry run: publish release train ${outcome.train.id} (${outcome.train.trainDigest}) for ${env}`);
543
+ for (const m of outcome.members) {
544
+ if (m.role === "pinned") {
545
+ out(` ${m.member} ${m.label ?? m.releaseDigest}: pinned at commit ${m.commit.slice(0, 12)}, already published`);
546
+ continue;
547
+ }
548
+ out(` layer ${m.layer}: ${m.member} ${m.label ?? m.releaseDigest}${m.after ? `, after ${m.after.join(", ")}` : ""}`);
549
+ for (const t of m.targets) {
550
+ const earlier = t.progress === "revealed" ? " (published by an earlier run; skipped)" : t.progress === "staged" ? " (staged by an earlier run; only revealed)" : "";
551
+ out(` ${t.name}${earlier}:`);
552
+ for (const i of t.items)
553
+ out(` ${i.name} to ${i.destination}`);
554
+ }
555
+ }
556
+ for (const v of outcome.verify) {
557
+ out(` verify ${v.member}, after every member has staged and before the first layer reveals:`);
558
+ for (const s of v.steps)
559
+ out(` ${s.name === s.run ? s.run : `${s.name}: ${s.run}`}`);
560
+ }
561
+ console.error(`Dry run: nothing was published. Run again with --yes to publish.`);
562
+ return 0;
563
+ }
564
+ if (outcome.recordWarning)
565
+ console.error(formatWarning({ message: redactor.redact(`${outcome.recordWarning}. A resume asks the registries what is already there.`) }));
566
+ for (const w of outcome.floatingWarnings ?? [])
567
+ console.error(formatWarning({ message: redactor.redact(w) }));
568
+ if (json) {
569
+ console.log(redactor.redact(JSON.stringify({ dryRun: false, ...base, published: outcome.published, resumed: outcome.resumed, ...(outcome.verified ? { verified: outcome.verified } : {}) }, null, 2)));
570
+ return 0;
571
+ }
572
+ const count = outcome.members.filter((m) => m.role === "publish").length;
573
+ console.error(formatSuccess(`Published release train ${outcome.train.id}: ${count} member release(s), layer by layer`));
574
+ return 0;
575
+ }
@@ -0,0 +1,33 @@
1
+ /**
2
+ * The labels a release train gives workspace packages (#5155), for
3
+ * `release.version.ranges: "train"`: `chant release stamp <label> --train
4
+ * <id|digest>` rewrites each workspace dependency's range to `^` and the
5
+ * label the train pins for the member that owns that package.
6
+ *
7
+ * A package belongs to the member whose `release.version.packages` names its
8
+ * directory. A member that declares no `release.version` owns no package a
9
+ * range can follow, so a dependency on it keeps its committed range.
10
+ */
11
+ import type { RangeLabels } from "../lifecycle/release-version.js";
12
+ import { type ReadTrain } from "./release-train.js";
13
+ /** A train problem with a stable code, shown as the stamp's refusal. */
14
+ export declare class TrainLabelsError extends Error {
15
+ readonly code: string;
16
+ readonly fix?: string | undefined;
17
+ constructor(code: string, message: string, fix?: string | undefined);
18
+ }
19
+ /** Package name to the train's label for the member that owns it. */
20
+ export declare function trainPackageLabels(train: ReadTrain, rootOnDisk: string): Promise<RangeLabels>;
21
+ /**
22
+ * The labels train `ref` (an id or a digest) gives workspace packages, for
23
+ * the release of `own` (the package names the member stamps) at `label`.
24
+ * Refuses a train that does not exist and one that pins none of the member's
25
+ * packages at the release's label.
26
+ */
27
+ export declare function trainLabels(cwd: string, ref: string, own: readonly string[], label: string): Promise<RangeLabels>;
28
+ /**
29
+ * The label tables of every train that pins a release at `label`, newest
30
+ * first, for the publish's check that a stamped tree is the release's. A
31
+ * train that cannot be read is left out.
32
+ */
33
+ export declare function trainLabelCandidates(cwd: string, label: string): Promise<RangeLabels[]>;