@intellectual-frontiers/libraries 0.1.1 → 0.4.0
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.
- package/dist/affected.d.ts +15 -2
- package/dist/affected.js +51 -20
- package/dist/dev.d.ts +81 -0
- package/dist/dev.js +347 -0
- package/dist/family.d.ts +58 -0
- package/dist/family.js +124 -0
- package/dist/generate-ontology.d.ts +2 -0
- package/dist/generate-ontology.js +33 -1
- package/dist/generate-workflows.js +2 -10
- package/dist/libraries.d.ts +8 -0
- package/dist/libraries.js +30 -4
- package/dist/link.d.ts +12 -0
- package/dist/link.js +98 -0
- package/dist/oscal-register.d.ts +2 -1
- package/dist/oscal-register.js +112 -88
- package/dist/pack-library.js +6 -1
- package/dist/plan.d.ts +28 -0
- package/dist/plan.js +135 -0
- package/dist/releasing.d.ts +176 -0
- package/dist/releasing.js +680 -0
- package/dist/versions.js +4 -7
- package/dist/workflows/definitions.d.ts +33 -30
- package/dist/workflows/definitions.js +200 -272
- package/dist/workflows/model.d.ts +15 -3
- package/dist/workflows/render.js +10 -2
- package/package.json +24 -4
- package/src/affected.ts +56 -17
- package/src/dev.ts +368 -0
- package/src/family.ts +143 -0
- package/src/generate-ontology.ts +34 -1
- package/src/generate-workflows.ts +3 -11
- package/src/libraries.ts +35 -3
- package/src/link.ts +97 -0
- package/src/oscal-register.ts +139 -117
- package/src/pack-library.ts +6 -1
- package/src/plan.ts +143 -0
- package/src/releasing.ts +735 -0
- package/src/versions.ts +3 -7
- package/src/workflows/definitions.ts +260 -387
- package/src/workflows/model.ts +11 -3
- package/src/workflows/render.ts +10 -2
|
@@ -3,9 +3,8 @@
|
|
|
3
3
|
* are written once, the workflow of each library of commons is made from its manifest, and the rest are written here as values. Nothing is read from a file but the manifests, and nothing is written.
|
|
4
4
|
*
|
|
5
5
|
* @remarks
|
|
6
|
-
* `workflows(
|
|
7
|
-
*
|
|
8
|
-
* The workflows run on the same triggers, with the same jobs and steps and the same names as the hand-written ones they replaced, so that the names of their checks do not change.
|
|
6
|
+
* `workflows()` gives every workflow, in the order of their files' names; the libraries are proved by one workflow, `ci`, whose plan reads which libraries a change affects and runs a matrix of those (the folder, the
|
|
7
|
+
* name and the `verify` command of a manifest, 0027-commons-libraries FR-012, and what else the library needs from `LIBRARY_CI`, the facts of CI that a manifest does not hold: a library without a record has `verify` on Linux and nothing else).
|
|
9
8
|
*
|
|
10
9
|
* @limits
|
|
11
10
|
* It does not run a workflow or read one; a library that registers needs no entry of `LIBRARY_CI` unless its CI is more than `verify`.
|
|
@@ -60,239 +59,181 @@ const lines = (...l: readonly string[]): string => `${l.join("\n")}\n`;
|
|
|
60
59
|
const BUN_ACTION = ".github/actions/bun/**";
|
|
61
60
|
const own = (file: string): string => `.github/workflows/${file}.auto.yml`;
|
|
62
61
|
|
|
63
|
-
/**
|
|
64
|
-
export type
|
|
65
|
-
readonly name: string;
|
|
66
|
-
readonly verify: string;
|
|
67
|
-
/** The paths whose change affects it, which the library's workflow runs on (0027-commons-libraries FR-022). */
|
|
68
|
-
readonly paths: readonly string[];
|
|
69
|
-
/** Where it is published (0027-commons-libraries FR-015 to FR-017): the registries, `github` and, where a decision says so, `npm`. */
|
|
70
|
-
readonly distribution: readonly string[];
|
|
71
|
-
};
|
|
62
|
+
/** The systems other than Linux that a library's CI may ask for: only a library with code of its own for one of them (paths, processes, sockets, scheduled jobs) names it. */
|
|
63
|
+
export type OtherSystem = "windows-latest" | "macos-latest";
|
|
72
64
|
|
|
73
|
-
/** What a library's CI needs that its manifest does not say. */
|
|
65
|
+
/** What a library's CI needs that its manifest does not say: Linux and `verify` are for every library, and these are the rest. */
|
|
74
66
|
export type LibraryCi = {
|
|
75
|
-
/** The
|
|
76
|
-
readonly comment: string;
|
|
77
|
-
/** The steps after `verify`, in the job `verify`. */
|
|
78
|
-
readonly afterVerify?: readonly Step[];
|
|
79
|
-
/** The command that runs the tests on Node 26, the backup runtime, in a job of its own. */
|
|
67
|
+
/** The command that runs the tests on Node 26, the backup runtime, in the same job as `verify`. */
|
|
80
68
|
readonly nodeTests?: string;
|
|
81
|
-
/**
|
|
82
|
-
readonly
|
|
69
|
+
/** A command that runs after `verify`, in the same job. */
|
|
70
|
+
readonly after?: string;
|
|
71
|
+
/** The systems besides Linux where `verify` and the tests on Node run too, because the library has code of its own for them. */
|
|
72
|
+
readonly systems?: readonly OtherSystem[];
|
|
83
73
|
};
|
|
84
74
|
|
|
85
|
-
|
|
75
|
+
const NODE_TESTS = 'node --test "suite/**/*.test.ts"';
|
|
76
|
+
const ALL_OTHER: readonly OtherSystem[] = ["windows-latest", "macos-latest"];
|
|
77
|
+
const node: LibraryCi = { nodeTests: NODE_TESTS };
|
|
78
|
+
|
|
79
|
+
/** The facts of CI of the libraries that have more than `verify` on Linux, by the library's name; a library with no record has `verify` on Linux only. */
|
|
86
80
|
export const LIBRARY_CI: Readonly<Record<string, LibraryCi>> = {
|
|
87
|
-
data: {
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
comment: lines(
|
|
127
|
-
"Net, the network as one typed library (downloads, an HTTP server and clients, TCP and TLS, DNS and ACME), a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the specification checker, the trace, its tests and the",
|
|
128
|
-
"packing of its package with the inspection of its declarations) on Bun and its tests on Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
129
|
-
).trimEnd(),
|
|
130
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
131
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
132
|
-
},
|
|
133
|
-
grc: {
|
|
134
|
-
comment: lines(
|
|
135
|
-
"GRC, governance, risk and compliance as code as one typed library, a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the specification checker, the trace, its tests and the",
|
|
136
|
-
"packing of its package with the inspection of its declarations) on Bun and its tests on Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
137
|
-
).trimEnd(),
|
|
138
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
139
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
140
|
-
},
|
|
141
|
-
test: {
|
|
142
|
-
comment: lines(
|
|
143
|
-
"Test, tests that run unchanged under `bun test` and `node --test` and are recorded as evidence by their own code, a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the specification checker, the trace, its tests and the",
|
|
144
|
-
"packing of its package with the inspection of its declarations) on Bun and its tests on Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
145
|
-
).trimEnd(),
|
|
146
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
147
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
148
|
-
},
|
|
149
|
-
lint: {
|
|
150
|
-
comment: lines(
|
|
151
|
-
"Lint, the lint plugin of Intellectual Frontiers, a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the pinned linter's canary, the compiler, the specification checker, the trace, its tests, which run",
|
|
152
|
-
"the real `bun lint`, and the packing of its package with the inspection of its declarations) on Bun and its tests on Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
153
|
-
).trimEnd(),
|
|
154
|
-
nodeTests: `bun x bun@${BUN_LINT_VERSION} --version && node --test "suite/**/*.test.ts"`,
|
|
155
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
156
|
-
},
|
|
157
|
-
githost: {
|
|
158
|
-
comment: lines(
|
|
159
|
-
"Githost, the Git hosts behind one typed interface (GitHub, GitLab and plain Git) and the reading of a remote, a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the specification checker, the trace, its tests and the",
|
|
160
|
-
"packing of its package with the inspection of its declarations) on Bun and its tests on Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
161
|
-
).trimEnd(),
|
|
162
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
163
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
164
|
-
},
|
|
165
|
-
ontology: {
|
|
166
|
-
comment: lines(
|
|
167
|
-
"Ontology, the ontologies of commons as typed values (Mizan, IFCCM, IFQS, IFR, the audit of packaging and the software supply chain), a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the spec checker, the trace, its tests and the packing of its package with the inspection of its declarations) on Bun and its tests on",
|
|
168
|
-
"Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
169
|
-
).trimEnd(),
|
|
170
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
171
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
172
|
-
},
|
|
173
|
-
mizan: {
|
|
174
|
-
comment: lines(
|
|
175
|
-
"Mizan, the harness and the rules of the IF Spec Profile as plugins, with the change-control and release rules, the levels, the integrations and the trace, a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the spec checker, the trace, its tests and the packing of its package with the inspection of its declarations) on Bun and its tests on",
|
|
176
|
-
"Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
177
|
-
).trimEnd(),
|
|
178
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
179
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
180
|
-
},
|
|
181
|
-
libraries: {
|
|
182
|
-
comment: lines(
|
|
183
|
-
"Libraries, the tools that manage the libraries of a repository of commons and hold it to Mizan (the manifest, the affected libraries, the typed workflows and their generator, the pinned Bun, the packer and the",
|
|
184
|
-
"commands of the repository), a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the specification checker, the trace, its tests and the packing of its package with",
|
|
185
|
-
"the inspection of its declarations) on Bun and its tests on Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
186
|
-
).trimEnd(),
|
|
187
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
188
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
189
|
-
},
|
|
190
|
-
headless: {
|
|
191
|
-
comment: lines(
|
|
192
|
-
"Headless, the contract of a program with no window in layers (governance, logical, the command-line surface), a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the specification checker, the layers and trace checks, its tests and the",
|
|
193
|
-
"packing of its package with the inspection of its declarations) on Bun and its tests on Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
194
|
-
).trimEnd(),
|
|
195
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
196
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
197
|
-
},
|
|
198
|
-
telemetry: {
|
|
199
|
-
comment: lines(
|
|
200
|
-
"Telemetry, OpenTelemetry-native signals as one typed library, a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the specification checker, the trace, its tests and the",
|
|
201
|
-
"packing of its package with the inspection of its declarations) on Bun and its tests on Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
202
|
-
).trimEnd(),
|
|
203
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
204
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
205
|
-
},
|
|
206
|
-
system: {
|
|
207
|
-
comment: lines(
|
|
208
|
-
"System, the host as one typed library (files, paths, processes, Git, scheduled jobs and the terminal's streams), a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the specification checker, the trace, its tests and the",
|
|
209
|
-
"package with the inspection of its declarations) on Bun and its tests on Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
210
|
-
).trimEnd(),
|
|
211
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
212
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
213
|
-
},
|
|
214
|
-
formats: {
|
|
215
|
-
comment: lines(
|
|
216
|
-
"Formats, a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the specification checker, the trace, its tests and the packing of its",
|
|
217
|
-
"package with the inspection of its declarations) on Bun and its tests on Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
218
|
-
).trimEnd(),
|
|
219
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
220
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
221
|
-
},
|
|
222
|
-
crypto: {
|
|
223
|
-
comment: lines(
|
|
224
|
-
"Crypto, a library lifted out of `commons/ts` (commons 0032-lifting-libraries): its own `verify` (the compiler, the specification checker, the trace, its tests and the packing of its",
|
|
225
|
-
"package with the inspection of its declarations) on Bun and its tests on Node 26, on Windows, macOS and Linux, because the package runs on all three.",
|
|
226
|
-
).trimEnd(),
|
|
227
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
228
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
229
|
-
},
|
|
230
|
-
quality: {
|
|
231
|
-
comment: lines(
|
|
232
|
-
"Quality, the quality system of commons (the record of a run as evidence, the quality branch, the ladder, the ledger, the Trust page and the assessor pack), a library lifted out of `commons/ts`",
|
|
233
|
-
"(commons 0032-lifting-libraries): its own `verify` on Bun and its tests, which run a real Git, on Node 26, on Linux.",
|
|
234
|
-
).trimEnd(),
|
|
235
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
236
|
-
},
|
|
237
|
-
ergonex: {
|
|
238
|
-
comment: lines(
|
|
239
|
-
"Ergonex, the workspaces management of Intellectual Frontiers, a library of commons (commons 0027-commons-libraries FR-010): its own `verify` on Bun and its tests on Node 26, the backup runtime,",
|
|
240
|
-
"on Windows first, then macOS and Linux (ergonex 0004-onboarding): a person on any of them installs the command from npm and runs it.",
|
|
241
|
-
).trimEnd(),
|
|
242
|
-
nodeTests: 'node --test "suite/**/*.test.ts"',
|
|
243
|
-
systems: ["windows-latest", "macos-latest", "ubuntu-latest"],
|
|
244
|
-
},
|
|
81
|
+
data: { nodeTests: NODE_TESTS, after: "bun tools/generate-dpv.ts --check" },
|
|
82
|
+
core: node,
|
|
83
|
+
rdf: node,
|
|
84
|
+
terminal: node,
|
|
85
|
+
net: { nodeTests: NODE_TESTS, systems: ALL_OTHER },
|
|
86
|
+
grc: node,
|
|
87
|
+
test: node,
|
|
88
|
+
lint: { nodeTests: `bun x bun@${BUN_LINT_VERSION} --version && ${NODE_TESTS}` },
|
|
89
|
+
githost: node,
|
|
90
|
+
ontology: node,
|
|
91
|
+
mizan: node,
|
|
92
|
+
libraries: { nodeTests: NODE_TESTS, systems: ALL_OTHER },
|
|
93
|
+
headless: { nodeTests: NODE_TESTS, systems: ALL_OTHER },
|
|
94
|
+
kanon: node,
|
|
95
|
+
telemetry: node,
|
|
96
|
+
system: { nodeTests: NODE_TESTS, systems: ALL_OTHER },
|
|
97
|
+
formats: node,
|
|
98
|
+
crypto: node,
|
|
99
|
+
quality: node,
|
|
100
|
+
ergonex: { nodeTests: NODE_TESTS, systems: ALL_OTHER },
|
|
101
|
+
"integrations-github": node,
|
|
102
|
+
"integrations-fhir": node,
|
|
103
|
+
"integrations-x12": node,
|
|
104
|
+
integrations: node,
|
|
105
|
+
};
|
|
106
|
+
|
|
107
|
+
/** A cell of the matrix of a job of `ci`: a library, and where it runs where it is not on Linux. */
|
|
108
|
+
export type Cell = {
|
|
109
|
+
readonly name: string;
|
|
110
|
+
readonly folder: string;
|
|
111
|
+
readonly verify: string;
|
|
112
|
+
/** The command that runs the tests on Node 26, or the empty string. */
|
|
113
|
+
readonly node: string;
|
|
114
|
+
/** The command that runs after `verify`, or the empty string. */
|
|
115
|
+
readonly after: string;
|
|
116
|
+
/** Whether the packing is checked in this cell: the library changed its `exports` (or the packer changed), or the run is of everything. A push does not pack otherwise; the release does. */
|
|
117
|
+
readonly pack: boolean;
|
|
118
|
+
/** The runner, for a cell that is not on Linux. */
|
|
119
|
+
readonly os?: OtherSystem;
|
|
245
120
|
};
|
|
246
121
|
|
|
247
|
-
/** The
|
|
248
|
-
export function
|
|
249
|
-
const folder = `commons/${l.name}`;
|
|
122
|
+
/** The cell of a library on a system (`ubuntu-latest`, where it names none), from its manifest and its record of CI; `pack` says whether the packing is checked in it. */
|
|
123
|
+
export function cellOf(l: { readonly name: string; readonly folder: string; readonly verify: string }, os?: OtherSystem, pack = false): Cell {
|
|
250
124
|
const ci = LIBRARY_CI[l.name];
|
|
251
|
-
const paths = l.paths;
|
|
252
|
-
const systems = ci?.systems;
|
|
253
|
-
const onSystems =
|
|
254
|
-
systems === undefined
|
|
255
|
-
? { runsOn: "ubuntu-latest" as const }
|
|
256
|
-
: { runsOn: expr("matrix.os"), strategy: { failFast: false, matrix: { os: systems } } };
|
|
257
|
-
const verify = job({
|
|
258
|
-
...onSystems,
|
|
259
|
-
timeoutMinutes: 15,
|
|
260
|
-
steps: [
|
|
261
|
-
checkout(),
|
|
262
|
-
bun(),
|
|
263
|
-
tools(folder, "The development tools, from bun.lock (the kernel is linked from commons/ts)"),
|
|
264
|
-
run(l.verify, { name: "verify", workingDirectory: folder }),
|
|
265
|
-
...(ci?.afterVerify ?? []),
|
|
266
|
-
],
|
|
267
|
-
});
|
|
268
|
-
const node =
|
|
269
|
-
ci?.nodeTests === undefined
|
|
270
|
-
? {}
|
|
271
|
-
: {
|
|
272
|
-
node: job({
|
|
273
|
-
...onSystems,
|
|
274
|
-
timeoutMinutes: 15,
|
|
275
|
-
steps: [
|
|
276
|
-
checkout(),
|
|
277
|
-
bun(),
|
|
278
|
-
setupNode(),
|
|
279
|
-
tools(folder),
|
|
280
|
-
run(ci.nodeTests, { name: "The tests on Node 26", workingDirectory: folder }),
|
|
281
|
-
],
|
|
282
|
-
}),
|
|
283
|
-
};
|
|
284
125
|
return {
|
|
285
|
-
file: l.name,
|
|
286
126
|
name: l.name,
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
127
|
+
folder: l.folder,
|
|
128
|
+
verify: l.verify,
|
|
129
|
+
pack,
|
|
130
|
+
node: ci?.nodeTests ?? "",
|
|
131
|
+
after: ci?.after ?? "",
|
|
132
|
+
...(os === undefined ? {} : { os }),
|
|
293
133
|
};
|
|
294
134
|
}
|
|
295
135
|
|
|
136
|
+
/** The paths a push or a pull request is run for by `ci`: the libraries and what they share. What a change affects within them is the plan's to say (0001-libraries FR-012), not a filter's. */
|
|
137
|
+
const CI_PATHS = ["commons/**", "package.json", "bun.lock", BUN_ACTION, own("ci")];
|
|
138
|
+
|
|
139
|
+
/** The steps that prove one library of a cell: install its tools, `verify`, what comes after, and its tests on Node 26. */
|
|
140
|
+
const cellSteps = (): readonly [Step, ...Step[]] => [
|
|
141
|
+
checkout(),
|
|
142
|
+
bun(),
|
|
143
|
+
tools(expr("matrix.folder"), "The development tools, from bun.lock (the kernel is linked from commons/ts)"),
|
|
144
|
+
run(expr("matrix.verify"), { name: "verify (its packing is checked where the exports changed, and by the release)", workingDirectory: expr("matrix.folder"), env: { IFC_SKIP_PACK: expr("matrix.pack == false && '1' || ''") } }),
|
|
145
|
+
run(expr("matrix.after"), { name: "After verify", when: "matrix.after != ''", workingDirectory: expr("matrix.folder"), shell: "bash" }),
|
|
146
|
+
run(expr("matrix.node"), { name: "The tests on Node 26", when: "matrix.node != ''", workingDirectory: expr("matrix.folder"), shell: "bash" }),
|
|
147
|
+
];
|
|
148
|
+
|
|
149
|
+
/**
|
|
150
|
+
* The one workflow that proves the libraries (0001-libraries FR-012): a job `plan` asks `plan.ts` which libraries the push or the pull request affects (the code of the `affected` command, from the commit the
|
|
151
|
+
* change starts at), and a matrix of those libraries and nothing else runs `verify` and the tests on Node 26 on Linux. A library whose record says it has code of its own for Windows or macOS runs there too;
|
|
152
|
+
* the others are not run there. The job `ci` is the one result to require: it fails where a job it needs failed, and passes where nothing was affected. A push to main has a group of its own for each commit, so that no commit's
|
|
153
|
+
* run is replaced by a later one: each plan starts at the commit main was at, and a replaced run would leave what it was to prove unproved.
|
|
154
|
+
*/
|
|
155
|
+
const ci: Workflow = {
|
|
156
|
+
file: "ci",
|
|
157
|
+
name: "ci",
|
|
158
|
+
comment: lines(
|
|
159
|
+
"The libraries of commons (commons 0001-libraries FR-012, 0027-commons-libraries FR-019 to FR-022): one workflow for every library. The job `plan` reads what the push or pull request changed, from the commit it starts at,",
|
|
160
|
+
"and the libraries that change affects (their folders, what they import and what depends on them); `verify` and the tests on Node 26 run for those libraries on Linux, and on Windows and macOS only for the libraries whose",
|
|
161
|
+
"record of CI (`LIBRARY_CI`) names them, because they have code of their own for those systems. Nothing else is run. The job `ci` is the one result to require.",
|
|
162
|
+
).trimEnd(),
|
|
163
|
+
on: { push: { paths: CI_PATHS }, pullRequest: { paths: CI_PATHS }, workflowDispatch: true },
|
|
164
|
+
permissions: { contents: "read" },
|
|
165
|
+
env: { NODE_VERSION },
|
|
166
|
+
concurrency: {
|
|
167
|
+
group: `${expr("github.workflow")}-${expr("github.ref == 'refs/heads/main' && github.sha || github.ref")}`,
|
|
168
|
+
cancelInProgress: expr("github.ref != 'refs/heads/main'"),
|
|
169
|
+
},
|
|
170
|
+
jobs: {
|
|
171
|
+
plan: job({
|
|
172
|
+
runsOn: "ubuntu-latest",
|
|
173
|
+
timeoutMinutes: 10,
|
|
174
|
+
outputs: {
|
|
175
|
+
"has-linux": expr("steps.plan.outputs.has-linux"),
|
|
176
|
+
linux: expr("steps.plan.outputs.linux"),
|
|
177
|
+
"has-systems": expr("steps.plan.outputs.has-systems"),
|
|
178
|
+
systems: expr("steps.plan.outputs.systems"),
|
|
179
|
+
},
|
|
180
|
+
steps: [
|
|
181
|
+
checkout({ fetchDepth: 0, comment: "the whole history: the plan compares the head with the commit the change starts at" }),
|
|
182
|
+
bun(),
|
|
183
|
+
run("bun install --frozen-lockfile", { name: "The packages the plan reads, from the root's bun.lock" }),
|
|
184
|
+
run("bun commons/libraries/src/link.ts", { name: "The libraries, linked by name before any of them is imported (the root's packages are old copies from npm)" }),
|
|
185
|
+
run(
|
|
186
|
+
lines(
|
|
187
|
+
"# a pull request starts at its base; a push to main at the commit main was at; any other branch at main, so a push that replaced a run that was stopped still carries what that run was to prove",
|
|
188
|
+
'if [ "$GITHUB_EVENT_NAME" = pull_request ]; then base="${{ github.event.pull_request.base.sha }}"',
|
|
189
|
+
'elif [ "$GITHUB_REF" = refs/heads/main ]; then base="${{ github.event.before }}"',
|
|
190
|
+
"else base=origin/main; fi",
|
|
191
|
+
'case "$base" in ""|0000000000000000000000000000000000000000) base=origin/main ;; esac',
|
|
192
|
+
'if [ "$GITHUB_EVENT_NAME" = workflow_dispatch ]; then scope=--all; else scope="--base $base"; fi',
|
|
193
|
+
'bun commons/libraries/src/plan.ts $scope --github-output "$GITHUB_OUTPUT"',
|
|
194
|
+
),
|
|
195
|
+
{ name: "The libraries this change affects, and the systems each runs on", id: "plan", shell: "bash" },
|
|
196
|
+
),
|
|
197
|
+
],
|
|
198
|
+
}),
|
|
199
|
+
verify: job({
|
|
200
|
+
name: "verify (${{ matrix.name }})",
|
|
201
|
+
needs: ["plan"],
|
|
202
|
+
when: "needs.plan.outputs.has-linux == 'true'",
|
|
203
|
+
runsOn: "ubuntu-latest",
|
|
204
|
+
timeoutMinutes: 20,
|
|
205
|
+
strategy: { failFast: false, matrix: expr("fromJSON(needs.plan.outputs.linux)") },
|
|
206
|
+
steps: cellSteps(),
|
|
207
|
+
}),
|
|
208
|
+
systems: job({
|
|
209
|
+
name: "verify (${{ matrix.name }}, ${{ matrix.os }})",
|
|
210
|
+
needs: ["plan"],
|
|
211
|
+
when: "needs.plan.outputs.has-systems == 'true'",
|
|
212
|
+
runsOn: expr("matrix.os"),
|
|
213
|
+
timeoutMinutes: 20,
|
|
214
|
+
strategy: { failFast: false, matrix: expr("fromJSON(needs.plan.outputs.systems)") },
|
|
215
|
+
steps: cellSteps(),
|
|
216
|
+
}),
|
|
217
|
+
ci: job({
|
|
218
|
+
comment: "The one result to require: every job it needs passed or had nothing to run.",
|
|
219
|
+
needs: ["plan", "verify", "systems"],
|
|
220
|
+
when: "always()",
|
|
221
|
+
runsOn: "ubuntu-latest",
|
|
222
|
+
timeoutMinutes: 5,
|
|
223
|
+
steps: [
|
|
224
|
+
run(
|
|
225
|
+
lines(
|
|
226
|
+
'for r in "${{ needs.plan.result }}" "${{ needs.verify.result }}" "${{ needs.systems.result }}"; do',
|
|
227
|
+
' case "$r" in success|skipped) ;; *) echo "a job of ci ended $r"; exit 1 ;; esac',
|
|
228
|
+
"done",
|
|
229
|
+
),
|
|
230
|
+
{ name: "No job failed", shell: "bash" },
|
|
231
|
+
),
|
|
232
|
+
],
|
|
233
|
+
}),
|
|
234
|
+
},
|
|
235
|
+
};
|
|
236
|
+
|
|
296
237
|
const ifcTypescriptPaths = [
|
|
297
238
|
"commons/ts/**",
|
|
298
239
|
"commons/docs/**",
|
|
@@ -598,7 +539,10 @@ const tests: Workflow = {
|
|
|
598
539
|
name: "Independent validators of the exports (rdflib, pySHACL, jsonschema), which the Mizan test uses where they are installed",
|
|
599
540
|
},
|
|
600
541
|
),
|
|
601
|
-
run("bun test ./tests
|
|
542
|
+
run("bun test ./tests/*.test.ts", {
|
|
543
|
+
name: "The tests on Bun (tests/release/ is the release's: it packs, installs and type-checks every library)",
|
|
544
|
+
when: "matrix.runtime == 'bun'",
|
|
545
|
+
}),
|
|
602
546
|
run('node --test "tests/*.test.ts"', { name: "The tests on Node 26", when: "matrix.runtime == 'node'" }),
|
|
603
547
|
],
|
|
604
548
|
}),
|
|
@@ -648,177 +592,106 @@ const tests: Workflow = {
|
|
|
648
592
|
},
|
|
649
593
|
};
|
|
650
594
|
|
|
651
|
-
/**
|
|
652
|
-
const
|
|
653
|
-
lines(
|
|
654
|
-
`pkg=$(tar -xzOf ./*.tgz package/package.json)`,
|
|
655
|
-
`name=$(printf '%s' "$pkg" | node -p "JSON.parse(require('fs').readFileSync(0,'utf8')).name")`,
|
|
656
|
-
`version=$(printf '%s' "$pkg" | node -p "JSON.parse(require('fs').readFileSync(0,'utf8')).version")`,
|
|
657
|
-
`if npm view "$name@$version" version${registry} >/dev/null 2>&1; then`,
|
|
658
|
-
' echo "$name@$version is already there"',
|
|
659
|
-
' echo "have=true" >> "$GITHUB_OUTPUT"',
|
|
660
|
-
"else",
|
|
661
|
-
' echo "have=false" >> "$GITHUB_OUTPUT"',
|
|
662
|
-
"fi",
|
|
663
|
-
);
|
|
664
|
-
const HAVE_NPM = HAVE("");
|
|
665
|
-
const HAVE_GITHUB = HAVE(" --registry https://npm.pkg.github.com");
|
|
595
|
+
/** The folder of a library's package that the release workflow packs: the cell of the matrix, `matrix.folder`. */
|
|
596
|
+
const PUBLISH_COMMAND = "bun commons/libraries/src/releasing.ts publish --dir package";
|
|
666
597
|
|
|
667
598
|
/**
|
|
668
|
-
* The workflow that
|
|
669
|
-
*
|
|
599
|
+
* The one workflow that releases (0001-libraries FR-014, FR-015): run by hand from main, never by a push. It reads the release record that `release apply` wrote (`commons/generated/release.auto.json`: the libraries
|
|
600
|
+
* whose version is to be published and tagged, in dependency order), proves and packs each of them in a matrix, and, where the run is asked to publish, sends them in that order to npm (trusted publishing with provenance, or
|
|
601
|
+
* the token `INFRO_NPMJS_TOKEN` where the repository has one) and to the GitHub package registry, and makes the tag of each with the runner's token. A run that is not asked to publish stops after the packing.
|
|
670
602
|
*/
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
on: { push: { tags: [`${l.name}-v*`] }, workflowDispatch: true },
|
|
684
|
-
permissions: { contents: "read" },
|
|
685
|
-
jobs: {
|
|
686
|
-
build: job({
|
|
687
|
-
runsOn: "ubuntu-latest",
|
|
688
|
-
timeoutMinutes: 15,
|
|
689
|
-
steps: [
|
|
690
|
-
checkout(),
|
|
691
|
-
bun(),
|
|
692
|
-
setupNode(),
|
|
693
|
-
tools(folder),
|
|
694
|
-
run(
|
|
695
|
-
lines(
|
|
696
|
-
`version=$(node -p "require('./package.json').version")`,
|
|
697
|
-
`if [ "$GITHUB_REF_TYPE" = tag ]; then`,
|
|
698
|
-
` test "$GITHUB_REF_NAME" = "${l.name}-v$version" || { echo "the tag $GITHUB_REF_NAME is not ${l.name}-v$version"; exit 1; }`,
|
|
699
|
-
`else`,
|
|
700
|
-
` test "$GITHUB_REF" = refs/heads/main || { echo "a run by hand publishes only from main, not $GITHUB_REF"; exit 1; }`,
|
|
701
|
-
`fi`,
|
|
702
|
-
),
|
|
703
|
-
{
|
|
704
|
-
name: "The tag, or main for a run by hand, is the version of the package",
|
|
705
|
-
workingDirectory: folder,
|
|
706
|
-
shell: "bash",
|
|
707
|
-
},
|
|
708
|
-
),
|
|
709
|
-
run("bun run verify", { name: "verify", workingDirectory: folder }),
|
|
710
|
-
run("bun tools/pack.ts", { name: "The package that is published", workingDirectory: folder }),
|
|
711
|
-
use(PIN.uploadArtifact, {
|
|
712
|
-
name: "The tarball, kept for the jobs that publish it",
|
|
713
|
-
with: { name: `${l.name}-package`, path: `${folder}/dist/*.tgz`, "if-no-files-found": "error" },
|
|
714
|
-
}),
|
|
715
|
-
],
|
|
716
|
-
}),
|
|
717
|
-
...(sendNpm
|
|
718
|
-
? {
|
|
719
|
-
"publish-npm": job({
|
|
720
|
-
needs: ["build"],
|
|
721
|
-
runsOn: "ubuntu-latest",
|
|
722
|
-
timeoutMinutes: 10,
|
|
723
|
-
permissions: { contents: "read", "id-token": "write" },
|
|
724
|
-
environment: { name: "npm" },
|
|
725
|
-
steps: [
|
|
726
|
-
use(PIN.downloadArtifact, { name: "The tarball", with: { name: `${l.name}-package`, path: "package" } }),
|
|
727
|
-
use(PIN.setupNode, { with: { "node-version": expr("env.NODE_VERSION"), "registry-url": "https://registry.npmjs.org" } }),
|
|
728
|
-
run(HAVE_NPM, {
|
|
729
|
-
name: "Is the version already on npm (published by hand, or by an earlier run)?",
|
|
730
|
-
id: "have",
|
|
731
|
-
shell: "bash",
|
|
732
|
-
workingDirectory: "package",
|
|
733
|
-
}),
|
|
734
|
-
run(tarball + " --access public --provenance", {
|
|
735
|
-
name: "Published to npm, with provenance and no token",
|
|
736
|
-
when: "steps.have.outputs.have != 'true'",
|
|
737
|
-
workingDirectory: "package",
|
|
738
|
-
shell: "bash",
|
|
739
|
-
}),
|
|
740
|
-
],
|
|
741
|
-
}),
|
|
742
|
-
}
|
|
743
|
-
: {}),
|
|
744
|
-
"publish-github": job({
|
|
745
|
-
needs: ["build"],
|
|
746
|
-
runsOn: "ubuntu-latest",
|
|
747
|
-
timeoutMinutes: 10,
|
|
748
|
-
permissions: { contents: "read", packages: "write" },
|
|
749
|
-
steps: [
|
|
750
|
-
use(PIN.downloadArtifact, { name: "The tarball", with: { name: `${l.name}-package`, path: "package" } }),
|
|
751
|
-
use(PIN.setupNode, {
|
|
752
|
-
with: {
|
|
753
|
-
"node-version": expr("env.NODE_VERSION"),
|
|
754
|
-
"registry-url": "https://npm.pkg.github.com",
|
|
755
|
-
scope: "@intellectual-frontiers",
|
|
756
|
-
},
|
|
757
|
-
}),
|
|
758
|
-
run(HAVE_GITHUB, {
|
|
759
|
-
name: "Is the version already on the GitHub package registry?",
|
|
760
|
-
id: "have",
|
|
761
|
-
shell: "bash",
|
|
762
|
-
workingDirectory: "package",
|
|
763
|
-
env: { NODE_AUTH_TOKEN: expr("secrets.GITHUB_TOKEN") },
|
|
764
|
-
}),
|
|
765
|
-
run(tarball, {
|
|
766
|
-
name: "Published to the GitHub package registry",
|
|
767
|
-
when: "steps.have.outputs.have != 'true'",
|
|
768
|
-
workingDirectory: "package",
|
|
769
|
-
shell: "bash",
|
|
770
|
-
env: { NODE_AUTH_TOKEN: expr("secrets.GITHUB_TOKEN") },
|
|
771
|
-
}),
|
|
772
|
-
],
|
|
773
|
-
}),
|
|
774
|
-
// a run by hand from main makes the tag that a push of one would have, where the runner's token may and a person's sandbox may not; it tags a version that is on its registry,
|
|
775
|
-
// however it got there (this workflow's jobs, or a person's first publish of a package that has no trusted publisher yet), and never fails on a tag that is there
|
|
776
|
-
tag: job({
|
|
777
|
-
needs: ["build", ...(sendNpm ? ["publish-npm"] : []), "publish-github"],
|
|
778
|
-
when: "always() && needs.build.result == 'success' && github.ref_type == 'branch'",
|
|
779
|
-
runsOn: "ubuntu-latest",
|
|
780
|
-
timeoutMinutes: 5,
|
|
781
|
-
permissions: { contents: "write" },
|
|
782
|
-
steps: [
|
|
783
|
-
checkout(),
|
|
784
|
-
use(PIN.setupNode, {
|
|
785
|
-
with: {
|
|
786
|
-
"node-version": expr("env.NODE_VERSION"),
|
|
787
|
-
...(sendNpm ? {} : { "registry-url": "https://npm.pkg.github.com", scope: "@intellectual-frontiers" }),
|
|
788
|
-
},
|
|
789
|
-
}),
|
|
790
|
-
run(
|
|
791
|
-
lines(
|
|
792
|
-
`version=$(node -p "require('./package.json').version")`,
|
|
793
|
-
`tag="${l.name}-v$version"`,
|
|
794
|
-
sendNpm
|
|
795
|
-
? `npm view "@intellectual-frontiers/${l.name}@$version" version >/dev/null 2>&1 || { echo "$version is not on npm: no tag"; exit 1; }`
|
|
796
|
-
: `npm view "@intellectual-frontiers/${l.name}@$version" version >/dev/null 2>&1 || { echo "$version is not on the GitHub package registry: no tag"; exit 1; }`,
|
|
797
|
-
'if gh api "repos/$GITHUB_REPOSITORY/git/ref/tags/$tag" >/dev/null 2>&1; then',
|
|
798
|
-
' echo "$tag is already there"',
|
|
799
|
-
"else",
|
|
800
|
-
' gh api "repos/$GITHUB_REPOSITORY/git/refs" -f "ref=refs/tags/$tag" -f "sha=$GITHUB_SHA"',
|
|
801
|
-
"fi",
|
|
802
|
-
),
|
|
803
|
-
{
|
|
804
|
-
name: "The tag of the version that is published, made once",
|
|
805
|
-
shell: "bash",
|
|
806
|
-
workingDirectory: folder,
|
|
807
|
-
env: { GH_TOKEN: expr("secrets.GITHUB_TOKEN"), ...(sendNpm ? {} : { NODE_AUTH_TOKEN: expr("secrets.GITHUB_TOKEN") }) },
|
|
808
|
-
},
|
|
809
|
-
),
|
|
810
|
-
],
|
|
811
|
-
}),
|
|
603
|
+
const release: Workflow = {
|
|
604
|
+
file: "release",
|
|
605
|
+
name: "release",
|
|
606
|
+
comment: lines(
|
|
607
|
+
"The release of the libraries (commons 0001-libraries FR-014, FR-015): by hand, from main, after `bun run release apply` (commons/libraries/src/releasing.ts) has written the versions and the record `commons/generated/release.auto.json` and they are pushed.",
|
|
608
|
+
"`plan` reads the record and leaves out what is tagged; `build` proves and packs each library (`verify`, `tools/pack.ts`); `publish`, where asked, sends the tarballs in dependency order to npm with provenance, by npm's trusted",
|
|
609
|
+
"publishing (the owner sets a trusted publisher once for each package on npmjs.com: this repository, this workflow's file, the environment `npm`) or, where the repository has the secret INFRO_NPMJS_TOKEN, by that token,",
|
|
610
|
+
"and to the GitHub package registry, and makes the tag of each. A version that is on a registry is skipped and a tag that is there is kept, so a run again continues where one stopped.",
|
|
611
|
+
).trimEnd(),
|
|
612
|
+
on: {
|
|
613
|
+
workflowDispatch: {
|
|
614
|
+
inputs: { publish: { description: "Publish and tag; without it the run only plans, proves and packs", type: "boolean", default: false } },
|
|
812
615
|
},
|
|
813
|
-
|
|
814
|
-
}
|
|
815
|
-
}
|
|
616
|
+
},
|
|
617
|
+
permissions: { contents: "read" },
|
|
618
|
+
env: { NODE_VERSION },
|
|
619
|
+
concurrency: { group: "release", cancelInProgress: false },
|
|
620
|
+
jobs: {
|
|
621
|
+
plan: job({
|
|
622
|
+
runsOn: "ubuntu-latest",
|
|
623
|
+
timeoutMinutes: 10,
|
|
624
|
+
outputs: {
|
|
625
|
+
"has-build": expr("steps.plan.outputs.has-build"),
|
|
626
|
+
build: expr("steps.plan.outputs.build"),
|
|
627
|
+
sequence: expr("steps.plan.outputs.sequence"),
|
|
628
|
+
},
|
|
629
|
+
steps: [
|
|
630
|
+
checkout({ fetchDepth: 0, comment: "the whole history and its tags: the plan leaves out what is tagged" }),
|
|
631
|
+
bun(),
|
|
632
|
+
run("bun install --frozen-lockfile", { name: "The packages the plan reads, from the root's bun.lock" }),
|
|
633
|
+
run("bun commons/libraries/src/link.ts", { name: "The libraries, linked by name before any of them is imported (the root's packages are old copies from npm)" }),
|
|
634
|
+
run(
|
|
635
|
+
lines(
|
|
636
|
+
'test "$GITHUB_REF" = refs/heads/main || { echo "a release is made from main, not $GITHUB_REF"; exit 1; }',
|
|
637
|
+
'bun commons/libraries/src/releasing.ts matrix --github-output "$GITHUB_OUTPUT"',
|
|
638
|
+
),
|
|
639
|
+
{ name: "The libraries to release, in dependency order, from the record", id: "plan", shell: "bash" },
|
|
640
|
+
),
|
|
641
|
+
],
|
|
642
|
+
}),
|
|
643
|
+
build: job({
|
|
644
|
+
name: "build (${{ matrix.slug }} ${{ matrix.version }})",
|
|
645
|
+
needs: ["plan"],
|
|
646
|
+
when: "needs.plan.outputs.has-build == 'true'",
|
|
647
|
+
runsOn: "ubuntu-latest",
|
|
648
|
+
timeoutMinutes: 20,
|
|
649
|
+
strategy: { failFast: true, matrix: expr("fromJSON(needs.plan.outputs.build)") },
|
|
650
|
+
steps: [
|
|
651
|
+
checkout(),
|
|
652
|
+
bun(),
|
|
653
|
+
tools(expr("matrix.folder")),
|
|
654
|
+
run("bun run verify", { name: "verify, which includes the packing", workingDirectory: expr("matrix.folder") }),
|
|
655
|
+
run("bun tools/pack.ts", { name: "The package that is published", workingDirectory: expr("matrix.folder") }),
|
|
656
|
+
use(PIN.uploadArtifact, {
|
|
657
|
+
name: "The tarball, kept for the job that publishes it",
|
|
658
|
+
with: { name: "package-${{ matrix.slug }}", path: "${{ matrix.folder }}/dist/*.tgz", "if-no-files-found": "error" },
|
|
659
|
+
}),
|
|
660
|
+
],
|
|
661
|
+
}),
|
|
662
|
+
publish: job({
|
|
663
|
+
needs: ["plan", "build"],
|
|
664
|
+
when: "inputs.publish && needs.plan.outputs.has-build == 'true'",
|
|
665
|
+
runsOn: "ubuntu-latest",
|
|
666
|
+
timeoutMinutes: 60,
|
|
667
|
+
permissions: { contents: "write", "id-token": "write", packages: "write" },
|
|
668
|
+
environment: { name: "npm" },
|
|
669
|
+
steps: [
|
|
670
|
+
checkout({ fetchDepth: 0, comment: "the tags: what is tagged is left out" }),
|
|
671
|
+
bun(),
|
|
672
|
+
run("bun install --frozen-lockfile", { name: "The packages the command reads, from the root's bun.lock" }),
|
|
673
|
+
run("bun commons/libraries/src/link.ts", { name: "The libraries, linked by name before any of them is imported" }),
|
|
674
|
+
use(PIN.setupNode, { with: { "node-version": expr("env.NODE_VERSION"), "registry-url": "https://registry.npmjs.org" } }),
|
|
675
|
+
use(PIN.downloadArtifact, { name: "The tarballs", with: { pattern: "package-*", path: "package" } }),
|
|
676
|
+
run(PUBLISH_COMMAND, {
|
|
677
|
+
name: "Published in dependency order to npm and to the GitHub package registry, and tagged: each release by itself, a version already on npm is only tagged",
|
|
678
|
+
shell: "bash",
|
|
679
|
+
env: {
|
|
680
|
+
NPM_TOKEN: expr("secrets.INFRO_NPMJS_TOKEN"),
|
|
681
|
+
GITHUB_TOKEN: expr("secrets.GITHUB_TOKEN"),
|
|
682
|
+
GH_TOKEN: expr("secrets.GITHUB_TOKEN"),
|
|
683
|
+
},
|
|
684
|
+
}),
|
|
685
|
+
],
|
|
686
|
+
}),
|
|
687
|
+
},
|
|
688
|
+
};
|
|
816
689
|
|
|
817
690
|
/** Every workflow, the libraries'' made from their manifests, in the order of their files' names. */
|
|
818
|
-
export function workflows(
|
|
691
|
+
export function workflows(): readonly Workflow[] {
|
|
819
692
|
return [
|
|
820
|
-
|
|
821
|
-
|
|
693
|
+
ci,
|
|
694
|
+
release,
|
|
822
695
|
docs,
|
|
823
696
|
ifcTypescript,
|
|
824
697
|
tests,
|