@workflow/builders 5.0.0 → 5.0.2

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 (33) hide show
  1. package/dist/apply-swc-transform.d.ts.map +1 -1
  2. package/dist/apply-swc-transform.js +11 -6
  3. package/dist/base-builder.d.ts +2 -3
  4. package/dist/base-builder.d.ts.map +1 -1
  5. package/dist/base-builder.js +35 -3
  6. package/dist/fast-discovery.d.ts +8 -0
  7. package/dist/fast-discovery.d.ts.map +1 -1
  8. package/dist/fast-discovery.js +93 -147
  9. package/dist/fast-discovery.test.js +62 -2
  10. package/dist/flow-bundle-safety.build.test.d.ts +2 -0
  11. package/dist/flow-bundle-safety.build.test.d.ts.map +1 -0
  12. package/dist/flow-bundle-safety.build.test.js +239 -0
  13. package/dist/flow-bundle-safety.d.ts +149 -0
  14. package/dist/flow-bundle-safety.d.ts.map +1 -0
  15. package/dist/flow-bundle-safety.js +973 -0
  16. package/dist/flow-bundle-safety.test.d.ts +2 -0
  17. package/dist/flow-bundle-safety.test.d.ts.map +1 -0
  18. package/dist/flow-bundle-safety.test.js +495 -0
  19. package/dist/index.d.ts +1 -0
  20. package/dist/index.d.ts.map +1 -1
  21. package/dist/index.js +2 -1
  22. package/dist/json-import-attributes.test.d.ts +2 -0
  23. package/dist/json-import-attributes.test.d.ts.map +1 -0
  24. package/dist/json-import-attributes.test.js +140 -0
  25. package/dist/node-module-esbuild-plugin.d.ts +5 -0
  26. package/dist/node-module-esbuild-plugin.d.ts.map +1 -1
  27. package/dist/node-module-esbuild-plugin.js +8 -1
  28. package/dist/transform-utils.d.ts +24 -0
  29. package/dist/transform-utils.d.ts.map +1 -1
  30. package/dist/transform-utils.js +317 -26
  31. package/dist/transform-utils.test.js +284 -2
  32. package/dist/workflow-bundle-boundary.test.js +1 -2
  33. package/package.json +5 -4
@@ -0,0 +1,973 @@
1
+ /**
2
+ * Sandbox-safety checks for the workflow ("flow") bundle.
3
+ *
4
+ * The flow bundle is evaluated with `vm.runInContext()` inside a sandbox that
5
+ * deliberately has no `require`: `createContext()` in
6
+ * `packages/core/src/vm/index.ts` only shims `module` and `exports`. esbuild
7
+ * emits the flow bundle as CJS, which means:
8
+ *
9
+ * - every import that stays **external** turns into a literal
10
+ * `require("<specifier>")` call, and
11
+ * - every `require(...)` esbuild could not statically resolve is copied into
12
+ * the output verbatim.
13
+ *
14
+ * Both throw `ReferenceError: require is not defined` as soon as they are
15
+ * evaluated. External imports are the worst case: esbuild hoists them to the
16
+ * top level of the bundle, so the whole bundle fails to load and *every*
17
+ * workflow in the deployment breaks, not just the code path that needed the
18
+ * module.
19
+ *
20
+ * The exception is a `require()` inside a `try` block. That is how packages
21
+ * probe for an optional dependency (framer-motion ships one, and esbuild
22
+ * externalizes an unresolvable `require()` precisely when it is wrapped that
23
+ * way), and the sandbox's `ReferenceError` lands in the `catch`, so the bundle
24
+ * still loads. Those are left alone, as are calls behind a `typeof require`
25
+ * check (`if (typeof require !== "undefined") …`, esbuild's own ESM
26
+ * `__require` shim), which never run in the sandbox. Both are decided on the
27
+ * parsed syntax tree: a check only excuses the branches it provably skips.
28
+ *
29
+ * Those failures used to be silent at build time.
30
+ * `createNodeModuleErrorPlugin()` marks Node.js/Bun builtins as external and
31
+ * only reports the ones it can trace back to an `import … from "pkg"`
32
+ * statement inside user code, so transitively imported builtins (and
33
+ * re-exported ones, and side-effect-only imports) shipped a bundle that could
34
+ * never run. This module is the backstop that turns those into build errors.
35
+ */
36
+ import { ERROR_SLUGS, WorkflowBuildError } from '@workflow/errors';
37
+ import * as acorn from 'acorn';
38
+ import * as esbuild from 'esbuild';
39
+ import { isRuntimeBuiltinSpecifier } from './node-module-esbuild-plugin.js';
40
+ /**
41
+ * Set to `1` to downgrade flow bundle safety failures to warnings.
42
+ *
43
+ * The bundle still crashes at runtime if the offending code is reached; this
44
+ * only exists as an escape hatch for the rare case where the detection is
45
+ * wrong (for example a `require()` that is provably unreachable, or guarded in
46
+ * a way the `try`/`catch` and `typeof require` checks do not see).
47
+ */
48
+ export const ALLOW_UNSAFE_FLOW_BUNDLE_ENV = 'WORKFLOW_ALLOW_UNSAFE_FLOW_BUNDLE';
49
+ const DOCS_URL = `https://workflow-sdk.dev/err/${ERROR_SLUGS.NODE_JS_MODULE_IN_WORKFLOW}`;
50
+ /** Maximum number of violations of each kind included in the error message. */
51
+ const MAX_REPORTED = 10;
52
+ /** Placeholder esbuild substitutes for free `require` references. */
53
+ const FREE_REQUIRE_SENTINEL = '__workflow_free_require_probe__';
54
+ export function isFlowBundleSafetyReportEmpty(report) {
55
+ return (report.externalImports.length === 0 && report.dynamicRequires.length === 0);
56
+ }
57
+ const IDENTIFIER_CHAR = /[A-Za-z0-9_$]/;
58
+ /** Statements whose parenthesized head can be followed by a regex literal. */
59
+ const CONTROL_KEYWORDS = new Set(['if', 'while', 'for', 'with']);
60
+ /**
61
+ * Keywords after which a `/` starts a regex literal rather than a division.
62
+ * Everything else that ends in an identifier character (a name, a number) is
63
+ * treated as an operand, so `/` divides.
64
+ */
65
+ const KEYWORDS_BEFORE_REGEX = new Set([
66
+ 'await',
67
+ 'case',
68
+ 'delete',
69
+ 'do',
70
+ 'else',
71
+ 'in',
72
+ 'instanceof',
73
+ 'new',
74
+ 'of',
75
+ 'return',
76
+ 'throw',
77
+ 'typeof',
78
+ 'void',
79
+ 'yield',
80
+ ]);
81
+ function blankOut(text) {
82
+ // Keep newlines so line numbers still line up.
83
+ return text.replace(/[^\n]/g, ' ');
84
+ }
85
+ /** Reads the identifier that ends at `end` (exclusive). */
86
+ function identifierEndingAt(code, end) {
87
+ let start = end;
88
+ while (start > 0 && IDENTIFIER_CHAR.test(code[start - 1]))
89
+ start -= 1;
90
+ return code.slice(start, end);
91
+ }
92
+ /**
93
+ * Scans a quoted string starting at `start` (the quote). Returns the offset
94
+ * just past the closing quote, or `-1` when the literal is unterminated on its
95
+ * line (in which case the caller should not mask anything).
96
+ */
97
+ function scanQuoted(code, start) {
98
+ const quote = code[start];
99
+ for (let i = start + 1; i < code.length; i += 1) {
100
+ const ch = code[i];
101
+ if (ch === '\\') {
102
+ i += 1;
103
+ continue;
104
+ }
105
+ if (ch === '\n')
106
+ return -1;
107
+ if (ch === quote)
108
+ return i + 1;
109
+ }
110
+ return -1;
111
+ }
112
+ /**
113
+ * Scans a regex literal starting at `start` (the `/`). Returns the offset just
114
+ * past the trailing flags, or `-1` when the token is not a well-formed regex
115
+ * on a single line — which means it was really a division operator.
116
+ */
117
+ function scanRegex(code, start) {
118
+ let inClass = false;
119
+ for (let i = start + 1; i < code.length; i += 1) {
120
+ const ch = code[i];
121
+ if (ch === '\\') {
122
+ i += 1;
123
+ continue;
124
+ }
125
+ if (ch === '\n')
126
+ return -1;
127
+ if (ch === '[')
128
+ inClass = true;
129
+ if (ch === ']')
130
+ inClass = false;
131
+ if (ch === '/' && !inClass)
132
+ return scanRegexFlags(code, i + 1);
133
+ }
134
+ return -1;
135
+ }
136
+ function scanRegexFlags(code, start) {
137
+ let end = start;
138
+ while (end < code.length && /[a-z]/.test(code[end]))
139
+ end += 1;
140
+ return end;
141
+ }
142
+ /**
143
+ * Scans the literal portion of a template starting at `start`. Stops at the
144
+ * closing backtick or at a `${` substitution.
145
+ */
146
+ function scanTemplateChunk(code, start) {
147
+ for (let i = start; i < code.length; i += 1) {
148
+ const ch = code[i];
149
+ if (ch === '\\') {
150
+ i += 1;
151
+ continue;
152
+ }
153
+ if (ch === '`')
154
+ return { end: i, substitution: false };
155
+ if (ch === '$' && code[i + 1] === '{') {
156
+ return { end: i, substitution: true };
157
+ }
158
+ }
159
+ return { end: code.length, substitution: false };
160
+ }
161
+ /**
162
+ * Decides whether a `/` opens a regex literal or divides. Anything that ends
163
+ * an operand (a closing bracket, a literal, a non-keyword identifier) means
164
+ * division; everything else means a regex can start here.
165
+ */
166
+ function isRegexPosition(code, previousChar, previousIndex, closesControlHead) {
167
+ // `if (x) /re/.test(y)`: a `)` that closes a statement head is not an operand.
168
+ if (previousChar === ')')
169
+ return closesControlHead;
170
+ if (previousChar === ']' ||
171
+ previousChar === '"' ||
172
+ previousChar === "'" ||
173
+ previousChar === '`') {
174
+ return false;
175
+ }
176
+ if (!IDENTIFIER_CHAR.test(previousChar))
177
+ return true;
178
+ return KEYWORDS_BEFORE_REGEX.has(identifierEndingAt(code, previousIndex + 1));
179
+ }
180
+ /**
181
+ * Scans the non-code token starting at `i`, if there is one. Returns
182
+ * `undefined` for ordinary code, and for a `/` or quote that turned out not to
183
+ * open a literal (a division operator, an unterminated string).
184
+ */
185
+ function scanNonCodeToken(code, i, previousChar, previousIndex, closesControlHead) {
186
+ const ch = code[i];
187
+ if (ch === '/' && code[i + 1] === '/') {
188
+ const newline = code.indexOf('\n', i);
189
+ return {
190
+ end: newline === -1 ? code.length : newline,
191
+ isOperand: false,
192
+ isLineComment: true,
193
+ };
194
+ }
195
+ if (ch === '/' && code[i + 1] === '*') {
196
+ const close = code.indexOf('*/', i + 2);
197
+ return {
198
+ end: close === -1 ? code.length : close + 2,
199
+ isOperand: false,
200
+ isLineComment: false,
201
+ };
202
+ }
203
+ if (ch === '"' || ch === "'") {
204
+ const end = scanQuoted(code, i);
205
+ return end === -1
206
+ ? undefined
207
+ : { end, isOperand: true, isLineComment: false };
208
+ }
209
+ if (ch === '/' &&
210
+ isRegexPosition(code, previousChar, previousIndex, closesControlHead)) {
211
+ const end = scanRegex(code, i);
212
+ return end === -1
213
+ ? undefined
214
+ : { end, isOperand: true, isLineComment: false };
215
+ }
216
+ return undefined;
217
+ }
218
+ /**
219
+ * Tracks `(…)` and `{…}` nesting for {@link maskNonCodeRegions}, so a `/`
220
+ * after an `if (…)` head and the `}` that closes a template substitution are
221
+ * both recognized.
222
+ */
223
+ class BlockTracker {
224
+ code;
225
+ braceDepth = 0;
226
+ // Offsets of each open `(`, and the most recently closed `(…)` pair.
227
+ parens = [];
228
+ lastParen;
229
+ constructor(code) {
230
+ this.code = code;
231
+ }
232
+ get depth() {
233
+ return this.braceDepth;
234
+ }
235
+ /** The keyword before the `(…)` that closed at `index`, e.g. `if`. */
236
+ keywordBeforeParenClosingAt(index) {
237
+ const paren = this.lastParen;
238
+ if (paren === undefined || paren.end !== index)
239
+ return undefined;
240
+ return identifierEndingAt(this.code, skipWhitespaceBackward(this.code, paren.start));
241
+ }
242
+ /** Handles the code character at `index`. */
243
+ visit(ch, index) {
244
+ if (ch === '(') {
245
+ this.parens.push(index);
246
+ }
247
+ else if (ch === ')') {
248
+ const open = this.parens.pop();
249
+ this.lastParen =
250
+ open === undefined ? undefined : { start: open, end: index };
251
+ }
252
+ else if (ch === '{') {
253
+ this.braceDepth += 1;
254
+ }
255
+ else if (ch === '}') {
256
+ this.braceDepth = Math.max(0, this.braceDepth - 1);
257
+ }
258
+ }
259
+ }
260
+ /**
261
+ * Blanks out every non-code region of `code` so the result can be scanned with
262
+ * plain string matching without tripping over `require` inside comments,
263
+ * strings or regexes.
264
+ */
265
+ export function maskNonCodeRegions(code) {
266
+ const parts = [];
267
+ const banners = [];
268
+ const blocks = new BlockTracker(code);
269
+ let copyFrom = 0;
270
+ let i = 0;
271
+ let lastSignificantChar = '';
272
+ let lastSignificantIndex = -1;
273
+ let inTemplate = false;
274
+ // Brace depth recorded when entering each `${`, so the matching `}` can be
275
+ // told apart from ordinary object/block braces.
276
+ const templateBraceStack = [];
277
+ const mask = (start, end) => {
278
+ parts.push(code.slice(copyFrom, start), blankOut(code.slice(start, end)));
279
+ copyFrom = end;
280
+ };
281
+ while (i < code.length) {
282
+ if (inTemplate) {
283
+ const chunk = scanTemplateChunk(code, i);
284
+ mask(i, chunk.end);
285
+ if (chunk.substitution) {
286
+ inTemplate = false;
287
+ templateBraceStack.push(blocks.depth);
288
+ i = chunk.end + 2; // skip `${`
289
+ }
290
+ else {
291
+ inTemplate = false;
292
+ i = chunk.end + 1; // skip the closing backtick
293
+ lastSignificantChar = '`';
294
+ lastSignificantIndex = chunk.end;
295
+ }
296
+ continue;
297
+ }
298
+ const ch = code[i];
299
+ const token = scanNonCodeToken(code, i, lastSignificantChar, lastSignificantIndex, ch === '/' &&
300
+ lastSignificantChar === ')' &&
301
+ CONTROL_KEYWORDS.has(blocks.keywordBeforeParenClosingAt(lastSignificantIndex) ?? ''));
302
+ if (token) {
303
+ if (token.isLineComment && (i === 0 || code[i - 1] === '\n')) {
304
+ banners.push({ index: i, text: code.slice(i + 2, token.end).trim() });
305
+ }
306
+ mask(i, token.end);
307
+ if (token.isOperand) {
308
+ lastSignificantChar = code[token.end - 1];
309
+ lastSignificantIndex = token.end - 1;
310
+ }
311
+ i = token.end;
312
+ continue;
313
+ }
314
+ if (ch === '`') {
315
+ inTemplate = true;
316
+ i += 1;
317
+ continue;
318
+ }
319
+ if (ch === '}' &&
320
+ templateBraceStack[templateBraceStack.length - 1] === blocks.depth) {
321
+ templateBraceStack.pop();
322
+ inTemplate = true;
323
+ i += 1;
324
+ continue;
325
+ }
326
+ blocks.visit(ch, i);
327
+ if (!/\s/.test(ch)) {
328
+ lastSignificantChar = ch;
329
+ lastSignificantIndex = i;
330
+ }
331
+ i += 1;
332
+ }
333
+ parts.push(code.slice(copyFrom));
334
+ return { masked: parts.join(''), banners };
335
+ }
336
+ // ---------------------------------------------------------------------------
337
+ // Free `require` detection
338
+ // ---------------------------------------------------------------------------
339
+ /**
340
+ * Word-boundary match for the `require` identifier. The lookarounds also rule
341
+ * out esbuild's own helpers — `__require` (the `__commonJS` shim) and
342
+ * `require_<name>()` (a bundled CommonJS module wrapper) — because `_` counts
343
+ * as an identifier character.
344
+ */
345
+ const REQUIRE_TOKEN = /(?<![A-Za-z0-9_$])require(?![A-Za-z0-9_$])/g;
346
+ /** Preceding keywords that make the `require` token harmless or bound. */
347
+ const SAFE_PRECEDING_KEYWORDS = new Set([
348
+ // `typeof require` never throws; it is the standard UMD/CJS feature probe.
349
+ 'typeof',
350
+ // A declaration means references in scope are bound, not global.
351
+ 'class',
352
+ 'const',
353
+ 'function',
354
+ 'let',
355
+ 'var',
356
+ ]);
357
+ function computeLineStarts(text) {
358
+ const starts = [0];
359
+ for (let i = 0; i < text.length; i += 1) {
360
+ if (text[i] === '\n')
361
+ starts.push(i + 1);
362
+ }
363
+ return starts;
364
+ }
365
+ function locationOf(lineStarts, index) {
366
+ let low = 0;
367
+ let high = lineStarts.length - 1;
368
+ while (low < high) {
369
+ const mid = (low + high + 1) >> 1;
370
+ if (lineStarts[mid] <= index)
371
+ low = mid;
372
+ else
373
+ high = mid - 1;
374
+ }
375
+ return { line: low + 1, column: index - lineStarts[low] + 1 };
376
+ }
377
+ function skipWhitespaceForward(text, from) {
378
+ let i = from;
379
+ while (i < text.length && /\s/.test(text[i]))
380
+ i += 1;
381
+ return i;
382
+ }
383
+ function skipWhitespaceBackward(text, from) {
384
+ let i = from;
385
+ while (i > 0 && /\s/.test(text[i - 1]))
386
+ i -= 1;
387
+ return i;
388
+ }
389
+ /** Reads the string literal argument of a `require(` call, when there is one. */
390
+ function readLiteralArgument(code, openParen) {
391
+ const start = skipWhitespaceForward(code, openParen + 1);
392
+ const quote = code[start];
393
+ if (quote !== '"' && quote !== "'")
394
+ return undefined;
395
+ const end = scanQuoted(code, start);
396
+ if (end === -1)
397
+ return undefined;
398
+ const raw = code.slice(start + 1, end - 1);
399
+ // Specifiers are plain text in practice, so a JSON round-trip is enough to
400
+ // undo any escaping. Fall back to the raw text if it is not valid JSON.
401
+ const json = quote === '"'
402
+ ? code.slice(start, end)
403
+ : `"${raw.replace(/\\'/g, "'").replace(/"/g, '\\"')}"`;
404
+ try {
405
+ return JSON.parse(json);
406
+ }
407
+ catch {
408
+ return raw;
409
+ }
410
+ }
411
+ function moduleForIndex(banners, knownModules, index) {
412
+ let match;
413
+ for (const banner of banners) {
414
+ if (banner.index > index)
415
+ break;
416
+ if (knownModules && !knownModules.has(banner.text))
417
+ continue;
418
+ match = banner.text;
419
+ }
420
+ return match;
421
+ }
422
+ // ---------------------------------------------------------------------------
423
+ // Guards
424
+ // ---------------------------------------------------------------------------
425
+ /** String comparison operators a `typeof` test can use. */
426
+ function compareStrings(operator, left, right) {
427
+ switch (operator) {
428
+ case '==':
429
+ case '===':
430
+ return left === right;
431
+ case '!=':
432
+ case '!==':
433
+ return left !== right;
434
+ case '<':
435
+ return left < right;
436
+ case '<=':
437
+ return left <= right;
438
+ case '>':
439
+ return left > right;
440
+ case '>=':
441
+ return left >= right;
442
+ default:
443
+ return undefined;
444
+ }
445
+ }
446
+ /**
447
+ * The string value of `node` in the sandbox, where `identifier` is never
448
+ * declared and `typeof identifier` is therefore always `"undefined"`.
449
+ */
450
+ function sandboxStringValue(node, identifier) {
451
+ if (node.type === 'Literal') {
452
+ const { value } = node;
453
+ return typeof value === 'string' ? value : undefined;
454
+ }
455
+ if (node.type === 'UnaryExpression') {
456
+ const unary = node;
457
+ if (unary.operator === 'typeof' &&
458
+ unary.argument.type === 'Identifier' &&
459
+ unary.argument.name === identifier) {
460
+ return 'undefined';
461
+ }
462
+ }
463
+ return undefined;
464
+ }
465
+ /**
466
+ * The truthiness `node` has in the sandbox (see {@link sandboxStringValue}),
467
+ * or `undefined` when it does not follow from `identifier` being undeclared.
468
+ */
469
+ function sandboxTruthiness(node, identifier) {
470
+ switch (node.type) {
471
+ case 'Literal': {
472
+ const literal = node;
473
+ return 'regex' in literal ? true : Boolean(literal.value);
474
+ }
475
+ case 'UnaryExpression': {
476
+ const unary = node;
477
+ if (unary.operator === 'void')
478
+ return false;
479
+ if (unary.operator !== '!')
480
+ return undefined;
481
+ const argument = sandboxTruthiness(unary.argument, identifier);
482
+ return argument === undefined ? undefined : !argument;
483
+ }
484
+ case 'BinaryExpression': {
485
+ const binary = node;
486
+ const left = sandboxStringValue(binary.left, identifier);
487
+ const right = sandboxStringValue(binary.right, identifier);
488
+ if (left === undefined || right === undefined)
489
+ return undefined;
490
+ return compareStrings(binary.operator, left, right);
491
+ }
492
+ case 'LogicalExpression':
493
+ return logicalTruthiness(node, identifier);
494
+ case 'SequenceExpression': {
495
+ const { expressions } = node;
496
+ return sandboxTruthiness(expressions[expressions.length - 1], identifier);
497
+ }
498
+ default:
499
+ return undefined;
500
+ }
501
+ }
502
+ function logicalTruthiness(node, identifier) {
503
+ // `??` tests for nullishness, which a truthiness says nothing about.
504
+ if (node.operator === '??')
505
+ return undefined;
506
+ const left = sandboxTruthiness(node.left, identifier);
507
+ const right = sandboxTruthiness(node.right, identifier);
508
+ // `&&` is false as soon as one side is, `||` true as soon as one side is.
509
+ const decisive = node.operator === '||';
510
+ if (left === decisive || right === decisive)
511
+ return decisive;
512
+ return left === !decisive ? right : undefined;
513
+ }
514
+ /**
515
+ * Whether the `key` child of `node` cannot throw a `ReferenceError` for
516
+ * `identifier` in the sandbox: it is the body of a `try` with a `catch`, or a
517
+ * branch its `if`, `?:`, `&&` or `||` provably skips there.
518
+ */
519
+ function guardsChild(node, key, identifier) {
520
+ switch (node.type) {
521
+ case 'TryStatement':
522
+ // Without a `catch`, the error still escapes a `try … finally`.
523
+ return key === 'block' && node.handler != null;
524
+ case 'IfStatement':
525
+ case 'ConditionalExpression': {
526
+ if (key !== 'consequent' && key !== 'alternate')
527
+ return false;
528
+ const { test } = node;
529
+ // The consequent is skipped when the test is false, the alternate when
530
+ // it is true.
531
+ return sandboxTruthiness(test, identifier) === (key === 'alternate');
532
+ }
533
+ case 'LogicalExpression': {
534
+ if (key !== 'right')
535
+ return false;
536
+ const { operator, left } = node;
537
+ const truthiness = sandboxTruthiness(left, identifier);
538
+ if (operator === '&&')
539
+ return truthiness === false;
540
+ if (operator === '||')
541
+ return truthiness === true;
542
+ return false;
543
+ }
544
+ default:
545
+ return false;
546
+ }
547
+ }
548
+ function isNode(value) {
549
+ return (typeof value === 'object' &&
550
+ value !== null &&
551
+ typeof value.type === 'string');
552
+ }
553
+ function parseScript(code) {
554
+ try {
555
+ return acorn.parse(code, {
556
+ ecmaVersion: 'latest',
557
+ sourceType: 'script',
558
+ allowHashBang: true,
559
+ allowReturnOutsideFunction: true,
560
+ allowAwaitOutsideFunction: true,
561
+ });
562
+ }
563
+ catch {
564
+ return undefined;
565
+ }
566
+ }
567
+ /**
568
+ * Offsets of the `identifier` references in `code` that cannot throw in the
569
+ * sandbox (see {@link guardsChild}). The rule is lexical: a function defined
570
+ * inside a guarded region counts as guarded wherever it is later called.
571
+ *
572
+ * Returns `undefined` when `code` does not parse, so the caller treats every
573
+ * reference as unguarded.
574
+ */
575
+ function findGuardedReferences(code, identifier) {
576
+ const program = parseScript(code);
577
+ if (program === undefined)
578
+ return undefined;
579
+ const guarded = new Set();
580
+ // Iterative, because bundles nest deeply (long `a + b + …` chains).
581
+ const stack = [[program, false]];
582
+ for (let entry = stack.pop(); entry !== undefined; entry = stack.pop()) {
583
+ const [node, isGuarded] = entry;
584
+ if (isGuarded &&
585
+ node.type === 'Identifier' &&
586
+ node.name === identifier) {
587
+ guarded.add(node.start);
588
+ }
589
+ pushChildren(stack, node, isGuarded, identifier);
590
+ }
591
+ return guarded;
592
+ }
593
+ function pushChildren(stack, node, isGuarded, identifier) {
594
+ for (const [key, value] of Object.entries(node)) {
595
+ const childGuarded = isGuarded || guardsChild(node, key, identifier);
596
+ for (const child of Array.isArray(value) ? value : [value]) {
597
+ if (isNode(child))
598
+ stack.push([child, childGuarded]);
599
+ }
600
+ }
601
+ }
602
+ /**
603
+ * Reads the `require` token at `index` in masked code. Returns `undefined`
604
+ * when the token is not an evaluated reference to the identifier: a member
605
+ * access, a property key, or a position after a {@link SAFE_PRECEDING_KEYWORDS}
606
+ * keyword.
607
+ */
608
+ function readEvaluatedReference(masked, index) {
609
+ const beforeEnd = skipWhitespaceBackward(masked, index);
610
+ const previousChar = beforeEnd > 0 ? masked[beforeEnd - 1] : '';
611
+ const previousWord = IDENTIFIER_CHAR.test(previousChar)
612
+ ? identifierEndingAt(masked, beforeEnd)
613
+ : '';
614
+ const afterStart = skipWhitespaceForward(masked, index + 'require'.length);
615
+ const nextChar = masked[afterStart] ?? '';
616
+ const isMemberAccess = previousChar === '.' || previousChar === '#';
617
+ // `{ require: … }`, but not the ternary `cond ? require : fallback`.
618
+ const isPropertyKey = nextChar === ':' && (previousChar === '{' || previousChar === ',');
619
+ const isSafeKeyword = SAFE_PRECEDING_KEYWORDS.has(previousWord);
620
+ if (isMemberAccess || isPropertyKey || isSafeKeyword)
621
+ return undefined;
622
+ return { nextChar, afterStart };
623
+ }
624
+ /**
625
+ * Finds every `require` reference in `bundleText` that will be evaluated at
626
+ * runtime, flagging the ones a `try` block protects.
627
+ *
628
+ * This is a cheap pre-filter: it runs on every build, so it must be fast and
629
+ * must not flag the patterns that show up in ordinary bundled output
630
+ * (`typeof require`, `__require`, `require_pkg()`, `obj.require`). Anything it
631
+ * does flag is confirmed with esbuild's own scope analysis before it fails a
632
+ * build — see {@link probeFreeRequireReferences}.
633
+ */
634
+ export function findRequireSites(bundleText, knownModules) {
635
+ // Most bundles contain no bare `require` token at all (esbuild's helpers are
636
+ // `__require` and `require_<name>`), so skip the lexer entirely for them.
637
+ REQUIRE_TOKEN.lastIndex = 0;
638
+ if (!REQUIRE_TOKEN.test(bundleText))
639
+ return [];
640
+ const { masked, banners } = maskNonCodeRegions(bundleText);
641
+ const lineStarts = computeLineStarts(bundleText);
642
+ const sites = [];
643
+ // Parsing costs more than the scan, so only parse once a reference turns up.
644
+ let guardedReferences;
645
+ const isGuarded = (index) => {
646
+ guardedReferences ??=
647
+ findGuardedReferences(bundleText, 'require') ?? new Set();
648
+ return guardedReferences.has(index);
649
+ };
650
+ REQUIRE_TOKEN.lastIndex = 0;
651
+ let match = REQUIRE_TOKEN.exec(masked);
652
+ while (match !== null) {
653
+ const index = match.index;
654
+ const reference = readEvaluatedReference(masked, index);
655
+ if (reference) {
656
+ const { nextChar, afterStart } = reference;
657
+ const { line, column } = locationOf(lineStarts, index);
658
+ const lineText = bundleText.slice(lineStarts[line - 1], lineStarts[line] ?? bundleText.length);
659
+ sites.push({
660
+ module: moduleForIndex(banners, knownModules, index),
661
+ line,
662
+ column,
663
+ specifier: nextChar === '('
664
+ ? readLiteralArgument(bundleText, afterStart)
665
+ : undefined,
666
+ snippet: truncate(lineText.trim(), 160),
667
+ // `try { require("optional-dep") } catch {}` is how packages probe for
668
+ // an optional dependency — framer-motion ships exactly this, and
669
+ // esbuild itself externalizes unresolvable requires when they are
670
+ // wrapped this way. The sandbox's `ReferenceError` lands in the
671
+ // `catch`, so the bundle still loads. A `typeof require` check (UMD
672
+ // wrappers, esbuild's ESM `__require` shim) skips the call instead.
673
+ guarded: isGuarded(index),
674
+ });
675
+ }
676
+ match = REQUIRE_TOKEN.exec(masked);
677
+ }
678
+ return sites;
679
+ }
680
+ /** The unguarded subset of {@link findRequireSites}. */
681
+ export function findDynamicRequireCandidates(bundleText, knownModules) {
682
+ return findRequireSites(bundleText, knownModules).filter((site) => !site.guarded);
683
+ }
684
+ /**
685
+ * Specifiers whose every emitted `require("…")` call site is guarded (see
686
+ * {@link RequireSite.guarded}). esbuild leaves an unresolvable `require()` external when it is
687
+ * wrapped that way (it says so in the "Could not resolve" hint), so the
688
+ * metafile reports an external import for code that is designed to fail.
689
+ */
690
+ function findGuardedSpecifiers(sites) {
691
+ const guarded = new Set();
692
+ const unguarded = new Set();
693
+ for (const site of sites) {
694
+ if (site.specifier === undefined)
695
+ continue;
696
+ (site.guarded ? guarded : unguarded).add(site.specifier);
697
+ }
698
+ for (const specifier of unguarded)
699
+ guarded.delete(specifier);
700
+ return guarded;
701
+ }
702
+ /**
703
+ * Confirms candidates with esbuild's scope analysis.
704
+ *
705
+ * `define` only rewrites identifiers that resolve to the global scope, so any
706
+ * `require` that a surrounding function parameter or declaration shadows is
707
+ * left alone. `typeof require` survives as `typeof <sentinel>`, which we skip
708
+ * because it cannot throw.
709
+ *
710
+ * Returns `undefined` when the probe itself fails, in which case the caller
711
+ * keeps the candidates rather than silently dropping a real problem.
712
+ */
713
+ async function probeFreeRequireReferences(bundleText) {
714
+ let code;
715
+ try {
716
+ const result = await esbuild.transform(bundleText, {
717
+ loader: 'js',
718
+ define: { require: FREE_REQUIRE_SENTINEL },
719
+ legalComments: 'none',
720
+ sourcemap: false,
721
+ });
722
+ code = result.code;
723
+ }
724
+ catch {
725
+ return undefined;
726
+ }
727
+ const probe = { literals: new Set(), otherReferences: 0 };
728
+ const sentinel = new RegExp(`(?<![A-Za-z0-9_$])${FREE_REQUIRE_SENTINEL}(?![A-Za-z0-9_$])`, 'g');
729
+ const { masked } = maskNonCodeRegions(code);
730
+ const guardedReferences = findGuardedReferences(code, FREE_REQUIRE_SENTINEL) ?? new Set();
731
+ let match = sentinel.exec(masked);
732
+ while (match !== null) {
733
+ const beforeEnd = skipWhitespaceBackward(masked, match.index);
734
+ const previousWord = identifierEndingAt(masked, beforeEnd);
735
+ // Mirror the scan's exclusions so a `typeof` probe or a guarded optional
736
+ // require cannot confirm an unrelated candidate. `define` rewrote the
737
+ // `typeof require` checks too, so they now test the sentinel.
738
+ if (previousWord !== 'typeof' && !guardedReferences.has(match.index)) {
739
+ const afterStart = skipWhitespaceForward(masked, match.index + FREE_REQUIRE_SENTINEL.length);
740
+ const literal = masked[afterStart] === '('
741
+ ? readLiteralArgument(code, afterStart)
742
+ : undefined;
743
+ if (literal === undefined)
744
+ probe.otherReferences += 1;
745
+ else
746
+ probe.literals.add(literal);
747
+ }
748
+ match = sentinel.exec(masked);
749
+ }
750
+ return probe;
751
+ }
752
+ // ---------------------------------------------------------------------------
753
+ // External imports (metafile)
754
+ // ---------------------------------------------------------------------------
755
+ /** esbuild uses `<…>` for synthetic inputs (`<runtime>`, `<stdin>`). */
756
+ function isSyntheticPath(path) {
757
+ return path.startsWith('<') && path.endsWith('>');
758
+ }
759
+ /** Inputs nobody imports — the entry points, when the metafile omits them. */
760
+ function findRootInputs(metafile) {
761
+ const imported = new Set();
762
+ for (const input of Object.values(metafile.inputs)) {
763
+ for (const imp of input.imports) {
764
+ if (!imp.external)
765
+ imported.add(imp.path);
766
+ }
767
+ }
768
+ return Object.keys(metafile.inputs).filter((input) => !imported.has(input));
769
+ }
770
+ /**
771
+ * Walks the metafile input graph breadth-first from the bundle entry so each
772
+ * external import can be reported with the chain of modules that pulled it in.
773
+ */
774
+ function buildParentIndex(metafile) {
775
+ const entries = new Set();
776
+ for (const output of Object.values(metafile.outputs)) {
777
+ if (output.entryPoint)
778
+ entries.add(output.entryPoint);
779
+ }
780
+ if (entries.size === 0) {
781
+ for (const input of findRootInputs(metafile))
782
+ entries.add(input);
783
+ }
784
+ const parents = new Map();
785
+ const queue = [...entries];
786
+ const seen = new Set(queue);
787
+ for (let cursor = 0; cursor < queue.length; cursor += 1) {
788
+ const current = queue[cursor];
789
+ for (const imp of metafile.inputs[current]?.imports ?? []) {
790
+ if (imp.external || seen.has(imp.path))
791
+ continue;
792
+ seen.add(imp.path);
793
+ parents.set(imp.path, current);
794
+ queue.push(imp.path);
795
+ }
796
+ }
797
+ return { parents, entries };
798
+ }
799
+ function chainTo(parents, entries, module) {
800
+ const chain = [module];
801
+ const seen = new Set(chain);
802
+ let current = module;
803
+ while (!entries.has(current)) {
804
+ const parent = parents.get(current);
805
+ if (parent === undefined || seen.has(parent))
806
+ break;
807
+ seen.add(parent);
808
+ chain.unshift(parent);
809
+ current = parent;
810
+ }
811
+ // The virtual entry is generated by the builder, not written by the user.
812
+ return chain.filter((module) => !entries.has(module));
813
+ }
814
+ /** The specifiers esbuild emitted as external in any output chunk. */
815
+ function collectExternalSpecifiers(metafile) {
816
+ const specifiers = new Set();
817
+ for (const output of Object.values(metafile.outputs)) {
818
+ for (const imp of output.imports) {
819
+ if (imp.external && !isSyntheticPath(imp.path))
820
+ specifiers.add(imp.path);
821
+ }
822
+ }
823
+ return specifiers;
824
+ }
825
+ /** Attributes each external specifier to the inputs that imported it. */
826
+ function mapImporters(metafile, specifiers) {
827
+ const importersBySpecifier = new Map();
828
+ for (const [input, info] of Object.entries(metafile.inputs)) {
829
+ if (isSyntheticPath(input))
830
+ continue;
831
+ for (const imp of info.imports) {
832
+ if (!imp.external || !specifiers.has(imp.path))
833
+ continue;
834
+ const importers = importersBySpecifier.get(imp.path);
835
+ if (importers)
836
+ importers.push(input);
837
+ else
838
+ importersBySpecifier.set(imp.path, [input]);
839
+ }
840
+ }
841
+ return importersBySpecifier;
842
+ }
843
+ /**
844
+ * Collects the imports esbuild left external. In a CJS bundle each of these is
845
+ * emitted as a top-level `require("…")`.
846
+ */
847
+ export function collectExternalImports(metafile) {
848
+ const specifiers = collectExternalSpecifiers(metafile);
849
+ if (specifiers.size === 0)
850
+ return [];
851
+ const importersBySpecifier = mapImporters(metafile, specifiers);
852
+ const { parents, entries } = buildParentIndex(metafile);
853
+ return [...specifiers].sort().map((specifier) => {
854
+ const importers = (importersBySpecifier.get(specifier) ?? []).sort();
855
+ return {
856
+ specifier,
857
+ importers,
858
+ importChain: importers[0] ? chainTo(parents, entries, importers[0]) : [],
859
+ isRuntimeBuiltin: isRuntimeBuiltinSpecifier(specifier),
860
+ };
861
+ });
862
+ }
863
+ // ---------------------------------------------------------------------------
864
+ // Reporting
865
+ // ---------------------------------------------------------------------------
866
+ function truncate(value, max) {
867
+ return value.length > max ? `${value.slice(0, max - 1)}…` : value;
868
+ }
869
+ /**
870
+ * Inspects a finished flow bundle for constructs the workflow sandbox cannot
871
+ * evaluate.
872
+ */
873
+ export async function analyzeFlowBundleSafety({ bundleText, metafile, }) {
874
+ const knownModules = metafile
875
+ ? new Set(Object.keys(metafile.inputs))
876
+ : undefined;
877
+ const sites = findRequireSites(bundleText, knownModules);
878
+ const guardedSpecifiers = findGuardedSpecifiers(sites);
879
+ const externalImports = (metafile ? collectExternalImports(metafile) : []).filter((violation) => !guardedSpecifiers.has(violation.specifier));
880
+ const externalSpecifiers = new Set(externalImports.map((violation) => violation.specifier));
881
+ // External imports are emitted as `require("<specifier>")`, so drop the
882
+ // sites they account for: they are already reported above, with a much
883
+ // better import chain than a bundle line number.
884
+ const candidates = sites.filter((site) => !site.guarded &&
885
+ (site.specifier === undefined || !externalSpecifiers.has(site.specifier)));
886
+ if (candidates.length === 0) {
887
+ return { externalImports, dynamicRequires: [] };
888
+ }
889
+ const probe = await probeFreeRequireReferences(bundleText);
890
+ const dynamicRequires = probe === undefined
891
+ ? candidates
892
+ : candidates.filter((candidate) => candidate.specifier === undefined
893
+ ? probe.otherReferences > 0
894
+ : probe.literals.has(candidate.specifier));
895
+ return { externalImports, dynamicRequires };
896
+ }
897
+ function formatList(items) {
898
+ const shown = items.slice(0, MAX_REPORTED);
899
+ const rest = items.length - shown.length;
900
+ if (rest > 0)
901
+ shown.push(`…and ${rest} more`);
902
+ return shown.join('\n');
903
+ }
904
+ export function formatFlowBundleSafetyReport(report) {
905
+ const sections = [
906
+ 'Workflow bundle cannot run in the workflow sandbox.',
907
+ '',
908
+ 'Workflow functions are evaluated in a sandbox without `require`. The bundle below still contains',
909
+ '`require()` calls, which throw `ReferenceError: require is not defined` when the bundle is loaded.',
910
+ ];
911
+ if (report.externalImports.length > 0) {
912
+ const lines = report.externalImports.map((violation) => {
913
+ const detail = [` • "${violation.specifier}"`];
914
+ if (violation.importers.length > 0) {
915
+ detail.push(` imported by ${violation.importers[0]}`);
916
+ if (violation.importers.length > 1) {
917
+ detail.push(` (and ${violation.importers.length - 1} other ${violation.importers.length === 2 ? 'module' : 'modules'})`);
918
+ }
919
+ }
920
+ if (violation.importChain.length > 1) {
921
+ detail.push(` via ${violation.importChain.join(' → ')}`);
922
+ }
923
+ return detail.join('\n');
924
+ });
925
+ sections.push('', `Imports left external (${report.externalImports.length}):`, formatList(lines));
926
+ }
927
+ if (report.dynamicRequires.length > 0) {
928
+ const lines = report.dynamicRequires.map((violation) => {
929
+ const where = violation.module
930
+ ? `${violation.module} (bundle ${violation.line}:${violation.column})`
931
+ : `bundle ${violation.line}:${violation.column}`;
932
+ const what = violation.specifier
933
+ ? `require("${violation.specifier}")`
934
+ : 'dynamic require()';
935
+ return ` • ${what} in ${where}\n ${violation.snippet}`;
936
+ });
937
+ sections.push('', `Unresolved require() calls (${report.dynamicRequires.length}):`, formatList(lines));
938
+ }
939
+ sections.push('', `Learn more: ${DOCS_URL}`);
940
+ return sections.join('\n');
941
+ }
942
+ function buildHint(report) {
943
+ const parts = [];
944
+ if (report.externalImports.length > 0) {
945
+ parts.push(report.externalImports.some((violation) => violation.isRuntimeBuiltin)
946
+ ? 'Move the code that needs Node.js built-ins into a "use step" function, or import the package only from step files.'
947
+ : 'Import these modules from a "use step" function instead of from workflow code.');
948
+ }
949
+ if (report.dynamicRequires.length > 0) {
950
+ parts.push('Replace dynamic require() with a static import, or move the calling code into a "use step" function.');
951
+ }
952
+ parts.push(`Set ${ALLOW_UNSAFE_FLOW_BUNDLE_ENV}=1 to downgrade this to a warning (the bundle will still fail at runtime if the code runs).`);
953
+ return parts.join(' ');
954
+ }
955
+ /**
956
+ * Fails the build when the flow bundle contains anything the workflow sandbox
957
+ * cannot evaluate.
958
+ *
959
+ * @param warn - Sink for the downgraded message when the escape hatch is set.
960
+ */
961
+ export async function assertFlowBundleIsSandboxSafe({ bundleText, metafile, warn = (message) => console.warn(message), }) {
962
+ const report = await analyzeFlowBundleSafety({ bundleText, metafile });
963
+ if (isFlowBundleSafetyReportEmpty(report))
964
+ return report;
965
+ const message = formatFlowBundleSafetyReport(report);
966
+ const hint = buildHint(report);
967
+ if (process.env[ALLOW_UNSAFE_FLOW_BUNDLE_ENV] === '1') {
968
+ warn(`${message}\n${hint}`);
969
+ return report;
970
+ }
971
+ throw new WorkflowBuildError(message, { hint });
972
+ }
973
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-bundle-safety.js","sourceRoot":"","sources":["../src/flow-bundle-safety.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Sandbox-safety checks for the workflow (\"flow\") bundle.\n *\n * The flow bundle is evaluated with `vm.runInContext()` inside a sandbox that\n * deliberately has no `require`: `createContext()` in\n * `packages/core/src/vm/index.ts` only shims `module` and `exports`. esbuild\n * emits the flow bundle as CJS, which means:\n *\n * - every import that stays **external** turns into a literal\n *   `require(\"<specifier>\")` call, and\n * - every `require(...)` esbuild could not statically resolve is copied into\n *   the output verbatim.\n *\n * Both throw `ReferenceError: require is not defined` as soon as they are\n * evaluated. External imports are the worst case: esbuild hoists them to the\n * top level of the bundle, so the whole bundle fails to load and *every*\n * workflow in the deployment breaks, not just the code path that needed the\n * module.\n *\n * The exception is a `require()` inside a `try` block. That is how packages\n * probe for an optional dependency (framer-motion ships one, and esbuild\n * externalizes an unresolvable `require()` precisely when it is wrapped that\n * way), and the sandbox's `ReferenceError` lands in the `catch`, so the bundle\n * still loads. Those are left alone, as are calls behind a `typeof require`\n * check (`if (typeof require !== \"undefined\") …`, esbuild's own ESM\n * `__require` shim), which never run in the sandbox. Both are decided on the\n * parsed syntax tree: a check only excuses the branches it provably skips.\n *\n * Those failures used to be silent at build time.\n * `createNodeModuleErrorPlugin()` marks Node.js/Bun builtins as external and\n * only reports the ones it can trace back to an `import … from \"pkg\"`\n * statement inside user code, so transitively imported builtins (and\n * re-exported ones, and side-effect-only imports) shipped a bundle that could\n * never run. This module is the backstop that turns those into build errors.\n */\n\nimport { ERROR_SLUGS, WorkflowBuildError } from '@workflow/errors';\nimport * as acorn from 'acorn';\nimport * as esbuild from 'esbuild';\nimport { isRuntimeBuiltinSpecifier } from './node-module-esbuild-plugin.js';\n\n/**\n * Set to `1` to downgrade flow bundle safety failures to warnings.\n *\n * The bundle still crashes at runtime if the offending code is reached; this\n * only exists as an escape hatch for the rare case where the detection is\n * wrong (for example a `require()` that is provably unreachable, or guarded in\n * a way the `try`/`catch` and `typeof require` checks do not see).\n */\nexport const ALLOW_UNSAFE_FLOW_BUNDLE_ENV = 'WORKFLOW_ALLOW_UNSAFE_FLOW_BUNDLE';\n\nconst DOCS_URL = `https://workflow-sdk.dev/err/${ERROR_SLUGS.NODE_JS_MODULE_IN_WORKFLOW}`;\n\n/** Maximum number of violations of each kind included in the error message. */\nconst MAX_REPORTED = 10;\n\n/** Placeholder esbuild substitutes for free `require` references. */\nconst FREE_REQUIRE_SENTINEL = '__workflow_free_require_probe__';\n\n/** An import esbuild left external, which becomes a top-level `require()`. */\nexport interface ExternalImportViolation {\n  /** The externalized specifier, e.g. `node:fs`. */\n  specifier: string;\n  /** Bundle inputs that imported it, as metafile keys. */\n  importers: string[];\n  /**\n   * Import chain from the bundle entry down to the first importer, with the\n   * synthetic virtual entry removed. Empty when it cannot be reconstructed.\n   */\n  importChain: string[];\n  /** Whether the specifier names a Node.js or Bun built-in module. */\n  isRuntimeBuiltin: boolean;\n}\n\n/** A `require(...)` call left in the bundle that resolves to the global. */\nexport interface DynamicRequireViolation {\n  /** Bundle module the call belongs to, when esbuild labelled the section. */\n  module?: string;\n  /** 1-based line within the flow bundle. */\n  line: number;\n  /** 1-based column within the flow bundle. */\n  column: number;\n  /** The requested specifier when the call site passes a string literal. */\n  specifier?: string;\n  /** Trimmed source line, for context. */\n  snippet: string;\n}\n\nexport interface FlowBundleSafetyReport {\n  externalImports: ExternalImportViolation[];\n  dynamicRequires: DynamicRequireViolation[];\n}\n\nexport function isFlowBundleSafetyReportEmpty(\n  report: FlowBundleSafetyReport\n): boolean {\n  return (\n    report.externalImports.length === 0 && report.dynamicRequires.length === 0\n  );\n}\n\n// ---------------------------------------------------------------------------\n// Lexing\n// ---------------------------------------------------------------------------\n\n/** A `//` comment that starts at column 0 — esbuild's module section marker. */\nexport interface BannerComment {\n  /** Offset of the `//`. */\n  index: number;\n  /** Comment text with the leading `// ` removed. */\n  text: string;\n}\n\nexport interface MaskResult {\n  /**\n   * `code` with every comment, string literal, template literal chunk and\n   * regex literal replaced by spaces. Offsets and line breaks are preserved,\n   * so positions map 1:1 back onto the original text. Template *substitutions*\n   * (`${…}`) are left intact because they contain real code.\n   */\n  masked: string;\n  /** Column-0 line comments, in source order. */\n  banners: BannerComment[];\n}\n\nconst IDENTIFIER_CHAR = /[A-Za-z0-9_$]/;\n\n/** Statements whose parenthesized head can be followed by a regex literal. */\nconst CONTROL_KEYWORDS = new Set(['if', 'while', 'for', 'with']);\n\n/**\n * Keywords after which a `/` starts a regex literal rather than a division.\n * Everything else that ends in an identifier character (a name, a number) is\n * treated as an operand, so `/` divides.\n */\nconst KEYWORDS_BEFORE_REGEX = new Set([\n  'await',\n  'case',\n  'delete',\n  'do',\n  'else',\n  'in',\n  'instanceof',\n  'new',\n  'of',\n  'return',\n  'throw',\n  'typeof',\n  'void',\n  'yield',\n]);\n\nfunction blankOut(text: string): string {\n  // Keep newlines so line numbers still line up.\n  return text.replace(/[^\\n]/g, ' ');\n}\n\n/** Reads the identifier that ends at `end` (exclusive). */\nfunction identifierEndingAt(code: string, end: number): string {\n  let start = end;\n  while (start > 0 && IDENTIFIER_CHAR.test(code[start - 1])) start -= 1;\n  return code.slice(start, end);\n}\n\n/**\n * Scans a quoted string starting at `start` (the quote). Returns the offset\n * just past the closing quote, or `-1` when the literal is unterminated on its\n * line (in which case the caller should not mask anything).\n */\nfunction scanQuoted(code: string, start: number): number {\n  const quote = code[start];\n  for (let i = start + 1; i < code.length; i += 1) {\n    const ch = code[i];\n    if (ch === '\\\\') {\n      i += 1;\n      continue;\n    }\n    if (ch === '\\n') return -1;\n    if (ch === quote) return i + 1;\n  }\n  return -1;\n}\n\n/**\n * Scans a regex literal starting at `start` (the `/`). Returns the offset just\n * past the trailing flags, or `-1` when the token is not a well-formed regex\n * on a single line — which means it was really a division operator.\n */\nfunction scanRegex(code: string, start: number): number {\n  let inClass = false;\n  for (let i = start + 1; i < code.length; i += 1) {\n    const ch = code[i];\n    if (ch === '\\\\') {\n      i += 1;\n      continue;\n    }\n    if (ch === '\\n') return -1;\n    if (ch === '[') inClass = true;\n    if (ch === ']') inClass = false;\n    if (ch === '/' && !inClass) return scanRegexFlags(code, i + 1);\n  }\n  return -1;\n}\n\nfunction scanRegexFlags(code: string, start: number): number {\n  let end = start;\n  while (end < code.length && /[a-z]/.test(code[end])) end += 1;\n  return end;\n}\n\n/**\n * Scans the literal portion of a template starting at `start`. Stops at the\n * closing backtick or at a `${` substitution.\n */\nfunction scanTemplateChunk(\n  code: string,\n  start: number\n): { end: number; substitution: boolean } {\n  for (let i = start; i < code.length; i += 1) {\n    const ch = code[i];\n    if (ch === '\\\\') {\n      i += 1;\n      continue;\n    }\n    if (ch === '`') return { end: i, substitution: false };\n    if (ch === '$' && code[i + 1] === '{') {\n      return { end: i, substitution: true };\n    }\n  }\n  return { end: code.length, substitution: false };\n}\n\n/**\n * Decides whether a `/` opens a regex literal or divides. Anything that ends\n * an operand (a closing bracket, a literal, a non-keyword identifier) means\n * division; everything else means a regex can start here.\n */\nfunction isRegexPosition(\n  code: string,\n  previousChar: string,\n  previousIndex: number,\n  closesControlHead: boolean\n): boolean {\n  // `if (x) /re/.test(y)`: a `)` that closes a statement head is not an operand.\n  if (previousChar === ')') return closesControlHead;\n  if (\n    previousChar === ']' ||\n    previousChar === '\"' ||\n    previousChar === \"'\" ||\n    previousChar === '`'\n  ) {\n    return false;\n  }\n  if (!IDENTIFIER_CHAR.test(previousChar)) return true;\n  return KEYWORDS_BEFORE_REGEX.has(identifierEndingAt(code, previousIndex + 1));\n}\n\ninterface NonCodeToken {\n  /** Offset just past the token. */\n  end: number;\n  /** Comments do not terminate an operand; strings and regexes do. */\n  isOperand: boolean;\n  isLineComment: boolean;\n}\n\n/**\n * Scans the non-code token starting at `i`, if there is one. Returns\n * `undefined` for ordinary code, and for a `/` or quote that turned out not to\n * open a literal (a division operator, an unterminated string).\n */\nfunction scanNonCodeToken(\n  code: string,\n  i: number,\n  previousChar: string,\n  previousIndex: number,\n  closesControlHead: boolean\n): NonCodeToken | undefined {\n  const ch = code[i];\n\n  if (ch === '/' && code[i + 1] === '/') {\n    const newline = code.indexOf('\\n', i);\n    return {\n      end: newline === -1 ? code.length : newline,\n      isOperand: false,\n      isLineComment: true,\n    };\n  }\n\n  if (ch === '/' && code[i + 1] === '*') {\n    const close = code.indexOf('*/', i + 2);\n    return {\n      end: close === -1 ? code.length : close + 2,\n      isOperand: false,\n      isLineComment: false,\n    };\n  }\n\n  if (ch === '\"' || ch === \"'\") {\n    const end = scanQuoted(code, i);\n    return end === -1\n      ? undefined\n      : { end, isOperand: true, isLineComment: false };\n  }\n\n  if (\n    ch === '/' &&\n    isRegexPosition(code, previousChar, previousIndex, closesControlHead)\n  ) {\n    const end = scanRegex(code, i);\n    return end === -1\n      ? undefined\n      : { end, isOperand: true, isLineComment: false };\n  }\n\n  return undefined;\n}\n\n/**\n * Tracks `(…)` and `{…}` nesting for {@link maskNonCodeRegions}, so a `/`\n * after an `if (…)` head and the `}` that closes a template substitution are\n * both recognized.\n */\nclass BlockTracker {\n  private readonly code: string;\n  private braceDepth = 0;\n  // Offsets of each open `(`, and the most recently closed `(…)` pair.\n  private readonly parens: number[] = [];\n  private lastParen: { start: number; end: number } | undefined;\n\n  constructor(code: string) {\n    this.code = code;\n  }\n\n  get depth(): number {\n    return this.braceDepth;\n  }\n\n  /** The keyword before the `(…)` that closed at `index`, e.g. `if`. */\n  keywordBeforeParenClosingAt(index: number): string | undefined {\n    const paren = this.lastParen;\n    if (paren === undefined || paren.end !== index) return undefined;\n    return identifierEndingAt(\n      this.code,\n      skipWhitespaceBackward(this.code, paren.start)\n    );\n  }\n\n  /** Handles the code character at `index`. */\n  visit(ch: string, index: number): void {\n    if (ch === '(') {\n      this.parens.push(index);\n    } else if (ch === ')') {\n      const open = this.parens.pop();\n      this.lastParen =\n        open === undefined ? undefined : { start: open, end: index };\n    } else if (ch === '{') {\n      this.braceDepth += 1;\n    } else if (ch === '}') {\n      this.braceDepth = Math.max(0, this.braceDepth - 1);\n    }\n  }\n}\n\n/**\n * Blanks out every non-code region of `code` so the result can be scanned with\n * plain string matching without tripping over `require` inside comments,\n * strings or regexes.\n */\nexport function maskNonCodeRegions(code: string): MaskResult {\n  const parts: string[] = [];\n  const banners: BannerComment[] = [];\n  const blocks = new BlockTracker(code);\n  let copyFrom = 0;\n  let i = 0;\n  let lastSignificantChar = '';\n  let lastSignificantIndex = -1;\n  let inTemplate = false;\n  // Brace depth recorded when entering each `${`, so the matching `}` can be\n  // told apart from ordinary object/block braces.\n  const templateBraceStack: number[] = [];\n\n  const mask = (start: number, end: number): void => {\n    parts.push(code.slice(copyFrom, start), blankOut(code.slice(start, end)));\n    copyFrom = end;\n  };\n\n  while (i < code.length) {\n    if (inTemplate) {\n      const chunk = scanTemplateChunk(code, i);\n      mask(i, chunk.end);\n      if (chunk.substitution) {\n        inTemplate = false;\n        templateBraceStack.push(blocks.depth);\n        i = chunk.end + 2; // skip `${`\n      } else {\n        inTemplate = false;\n        i = chunk.end + 1; // skip the closing backtick\n        lastSignificantChar = '`';\n        lastSignificantIndex = chunk.end;\n      }\n      continue;\n    }\n\n    const ch = code[i];\n\n    const token = scanNonCodeToken(\n      code,\n      i,\n      lastSignificantChar,\n      lastSignificantIndex,\n      ch === '/' &&\n        lastSignificantChar === ')' &&\n        CONTROL_KEYWORDS.has(\n          blocks.keywordBeforeParenClosingAt(lastSignificantIndex) ?? ''\n        )\n    );\n    if (token) {\n      if (token.isLineComment && (i === 0 || code[i - 1] === '\\n')) {\n        banners.push({ index: i, text: code.slice(i + 2, token.end).trim() });\n      }\n      mask(i, token.end);\n      if (token.isOperand) {\n        lastSignificantChar = code[token.end - 1];\n        lastSignificantIndex = token.end - 1;\n      }\n      i = token.end;\n      continue;\n    }\n\n    if (ch === '`') {\n      inTemplate = true;\n      i += 1;\n      continue;\n    }\n\n    if (\n      ch === '}' &&\n      templateBraceStack[templateBraceStack.length - 1] === blocks.depth\n    ) {\n      templateBraceStack.pop();\n      inTemplate = true;\n      i += 1;\n      continue;\n    }\n    blocks.visit(ch, i);\n\n    if (!/\\s/.test(ch)) {\n      lastSignificantChar = ch;\n      lastSignificantIndex = i;\n    }\n    i += 1;\n  }\n\n  parts.push(code.slice(copyFrom));\n  return { masked: parts.join(''), banners };\n}\n\n// ---------------------------------------------------------------------------\n// Free `require` detection\n// ---------------------------------------------------------------------------\n\n/**\n * Word-boundary match for the `require` identifier. The lookarounds also rule\n * out esbuild's own helpers — `__require` (the `__commonJS` shim) and\n * `require_<name>()` (a bundled CommonJS module wrapper) — because `_` counts\n * as an identifier character.\n */\nconst REQUIRE_TOKEN = /(?<![A-Za-z0-9_$])require(?![A-Za-z0-9_$])/g;\n\n/** Preceding keywords that make the `require` token harmless or bound. */\nconst SAFE_PRECEDING_KEYWORDS = new Set([\n  // `typeof require` never throws; it is the standard UMD/CJS feature probe.\n  'typeof',\n  // A declaration means references in scope are bound, not global.\n  'class',\n  'const',\n  'function',\n  'let',\n  'var',\n]);\n\nfunction computeLineStarts(text: string): number[] {\n  const starts = [0];\n  for (let i = 0; i < text.length; i += 1) {\n    if (text[i] === '\\n') starts.push(i + 1);\n  }\n  return starts;\n}\n\nfunction locationOf(\n  lineStarts: number[],\n  index: number\n): { line: number; column: number } {\n  let low = 0;\n  let high = lineStarts.length - 1;\n  while (low < high) {\n    const mid = (low + high + 1) >> 1;\n    if (lineStarts[mid] <= index) low = mid;\n    else high = mid - 1;\n  }\n  return { line: low + 1, column: index - lineStarts[low] + 1 };\n}\n\nfunction skipWhitespaceForward(text: string, from: number): number {\n  let i = from;\n  while (i < text.length && /\\s/.test(text[i])) i += 1;\n  return i;\n}\n\nfunction skipWhitespaceBackward(text: string, from: number): number {\n  let i = from;\n  while (i > 0 && /\\s/.test(text[i - 1])) i -= 1;\n  return i;\n}\n\n/** Reads the string literal argument of a `require(` call, when there is one. */\nfunction readLiteralArgument(\n  code: string,\n  openParen: number\n): string | undefined {\n  const start = skipWhitespaceForward(code, openParen + 1);\n  const quote = code[start];\n  if (quote !== '\"' && quote !== \"'\") return undefined;\n  const end = scanQuoted(code, start);\n  if (end === -1) return undefined;\n  const raw = code.slice(start + 1, end - 1);\n  // Specifiers are plain text in practice, so a JSON round-trip is enough to\n  // undo any escaping. Fall back to the raw text if it is not valid JSON.\n  const json =\n    quote === '\"'\n      ? code.slice(start, end)\n      : `\"${raw.replace(/\\\\'/g, \"'\").replace(/\"/g, '\\\\\"')}\"`;\n  try {\n    return JSON.parse(json) as string;\n  } catch {\n    return raw;\n  }\n}\n\nfunction moduleForIndex(\n  banners: BannerComment[],\n  knownModules: Set<string> | undefined,\n  index: number\n): string | undefined {\n  let match: string | undefined;\n  for (const banner of banners) {\n    if (banner.index > index) break;\n    if (knownModules && !knownModules.has(banner.text)) continue;\n    match = banner.text;\n  }\n  return match;\n}\n\n// ---------------------------------------------------------------------------\n// Guards\n// ---------------------------------------------------------------------------\n\n/** String comparison operators a `typeof` test can use. */\nfunction compareStrings(\n  operator: acorn.BinaryOperator,\n  left: string,\n  right: string\n): boolean | undefined {\n  switch (operator) {\n    case '==':\n    case '===':\n      return left === right;\n    case '!=':\n    case '!==':\n      return left !== right;\n    case '<':\n      return left < right;\n    case '<=':\n      return left <= right;\n    case '>':\n      return left > right;\n    case '>=':\n      return left >= right;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * The string value of `node` in the sandbox, where `identifier` is never\n * declared and `typeof identifier` is therefore always `\"undefined\"`.\n */\nfunction sandboxStringValue(\n  node: acorn.Node,\n  identifier: string\n): string | undefined {\n  if (node.type === 'Literal') {\n    const { value } = node as acorn.Literal;\n    return typeof value === 'string' ? value : undefined;\n  }\n  if (node.type === 'UnaryExpression') {\n    const unary = node as acorn.UnaryExpression;\n    if (\n      unary.operator === 'typeof' &&\n      unary.argument.type === 'Identifier' &&\n      unary.argument.name === identifier\n    ) {\n      return 'undefined';\n    }\n  }\n  return undefined;\n}\n\n/**\n * The truthiness `node` has in the sandbox (see {@link sandboxStringValue}),\n * or `undefined` when it does not follow from `identifier` being undeclared.\n */\nfunction sandboxTruthiness(\n  node: acorn.Node,\n  identifier: string\n): boolean | undefined {\n  switch (node.type) {\n    case 'Literal': {\n      const literal = node as acorn.Literal;\n      return 'regex' in literal ? true : Boolean(literal.value);\n    }\n    case 'UnaryExpression': {\n      const unary = node as acorn.UnaryExpression;\n      if (unary.operator === 'void') return false;\n      if (unary.operator !== '!') return undefined;\n      const argument = sandboxTruthiness(unary.argument, identifier);\n      return argument === undefined ? undefined : !argument;\n    }\n    case 'BinaryExpression': {\n      const binary = node as acorn.BinaryExpression;\n      const left = sandboxStringValue(binary.left, identifier);\n      const right = sandboxStringValue(binary.right, identifier);\n      if (left === undefined || right === undefined) return undefined;\n      return compareStrings(binary.operator, left, right);\n    }\n    case 'LogicalExpression':\n      return logicalTruthiness(node as acorn.LogicalExpression, identifier);\n    case 'SequenceExpression': {\n      const { expressions } = node as acorn.SequenceExpression;\n      return sandboxTruthiness(expressions[expressions.length - 1], identifier);\n    }\n    default:\n      return undefined;\n  }\n}\n\nfunction logicalTruthiness(\n  node: acorn.LogicalExpression,\n  identifier: string\n): boolean | undefined {\n  // `??` tests for nullishness, which a truthiness says nothing about.\n  if (node.operator === '??') return undefined;\n  const left = sandboxTruthiness(node.left, identifier);\n  const right = sandboxTruthiness(node.right, identifier);\n  // `&&` is false as soon as one side is, `||` true as soon as one side is.\n  const decisive = node.operator === '||';\n  if (left === decisive || right === decisive) return decisive;\n  return left === !decisive ? right : undefined;\n}\n\n/**\n * Whether the `key` child of `node` cannot throw a `ReferenceError` for\n * `identifier` in the sandbox: it is the body of a `try` with a `catch`, or a\n * branch its `if`, `?:`, `&&` or `||` provably skips there.\n */\nfunction guardsChild(node: acorn.Node, key: string, identifier: string) {\n  switch (node.type) {\n    case 'TryStatement':\n      // Without a `catch`, the error still escapes a `try … finally`.\n      return key === 'block' && (node as acorn.TryStatement).handler != null;\n    case 'IfStatement':\n    case 'ConditionalExpression': {\n      if (key !== 'consequent' && key !== 'alternate') return false;\n      const { test } = node as acorn.IfStatement | acorn.ConditionalExpression;\n      // The consequent is skipped when the test is false, the alternate when\n      // it is true.\n      return sandboxTruthiness(test, identifier) === (key === 'alternate');\n    }\n    case 'LogicalExpression': {\n      if (key !== 'right') return false;\n      const { operator, left } = node as acorn.LogicalExpression;\n      const truthiness = sandboxTruthiness(left, identifier);\n      if (operator === '&&') return truthiness === false;\n      if (operator === '||') return truthiness === true;\n      return false;\n    }\n    default:\n      return false;\n  }\n}\n\nfunction isNode(value: unknown): value is acorn.Node {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as { type?: unknown }).type === 'string'\n  );\n}\n\nfunction parseScript(code: string): acorn.Program | undefined {\n  try {\n    return acorn.parse(code, {\n      ecmaVersion: 'latest',\n      sourceType: 'script',\n      allowHashBang: true,\n      allowReturnOutsideFunction: true,\n      allowAwaitOutsideFunction: true,\n    });\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Offsets of the `identifier` references in `code` that cannot throw in the\n * sandbox (see {@link guardsChild}). The rule is lexical: a function defined\n * inside a guarded region counts as guarded wherever it is later called.\n *\n * Returns `undefined` when `code` does not parse, so the caller treats every\n * reference as unguarded.\n */\nfunction findGuardedReferences(\n  code: string,\n  identifier: string\n): Set<number> | undefined {\n  const program = parseScript(code);\n  if (program === undefined) return undefined;\n\n  const guarded = new Set<number>();\n  // Iterative, because bundles nest deeply (long `a + b + …` chains).\n  const stack: [acorn.Node, boolean][] = [[program, false]];\n  for (let entry = stack.pop(); entry !== undefined; entry = stack.pop()) {\n    const [node, isGuarded] = entry;\n    if (\n      isGuarded &&\n      node.type === 'Identifier' &&\n      (node as acorn.Identifier).name === identifier\n    ) {\n      guarded.add(node.start);\n    }\n    pushChildren(stack, node, isGuarded, identifier);\n  }\n  return guarded;\n}\n\nfunction pushChildren(\n  stack: [acorn.Node, boolean][],\n  node: acorn.Node,\n  isGuarded: boolean,\n  identifier: string\n): void {\n  for (const [key, value] of Object.entries(node)) {\n    const childGuarded = isGuarded || guardsChild(node, key, identifier);\n    for (const child of Array.isArray(value) ? value : [value]) {\n      if (isNode(child)) stack.push([child, childGuarded]);\n    }\n  }\n}\n\n/**\n * Reads the `require` token at `index` in masked code. Returns `undefined`\n * when the token is not an evaluated reference to the identifier: a member\n * access, a property key, or a position after a {@link SAFE_PRECEDING_KEYWORDS}\n * keyword.\n */\nfunction readEvaluatedReference(\n  masked: string,\n  index: number\n): { nextChar: string; afterStart: number } | undefined {\n  const beforeEnd = skipWhitespaceBackward(masked, index);\n  const previousChar = beforeEnd > 0 ? masked[beforeEnd - 1] : '';\n  const previousWord = IDENTIFIER_CHAR.test(previousChar)\n    ? identifierEndingAt(masked, beforeEnd)\n    : '';\n  const afterStart = skipWhitespaceForward(masked, index + 'require'.length);\n  const nextChar = masked[afterStart] ?? '';\n\n  const isMemberAccess = previousChar === '.' || previousChar === '#';\n  // `{ require: … }`, but not the ternary `cond ? require : fallback`.\n  const isPropertyKey =\n    nextChar === ':' && (previousChar === '{' || previousChar === ',');\n  const isSafeKeyword = SAFE_PRECEDING_KEYWORDS.has(previousWord);\n  if (isMemberAccess || isPropertyKey || isSafeKeyword) return undefined;\n  return { nextChar, afterStart };\n}\n\n/** A `require` reference found in the bundle text. */\nexport interface RequireSite extends DynamicRequireViolation {\n  /**\n   * The reference sits inside a `try { … } catch` block, so the sandbox's\n   * `ReferenceError` is caught, or behind a `typeof require` check, so it never\n   * runs. Either way the bundle still loads.\n   */\n  guarded: boolean;\n}\n\n/**\n * Finds every `require` reference in `bundleText` that will be evaluated at\n * runtime, flagging the ones a `try` block protects.\n *\n * This is a cheap pre-filter: it runs on every build, so it must be fast and\n * must not flag the patterns that show up in ordinary bundled output\n * (`typeof require`, `__require`, `require_pkg()`, `obj.require`). Anything it\n * does flag is confirmed with esbuild's own scope analysis before it fails a\n * build — see {@link probeFreeRequireReferences}.\n */\nexport function findRequireSites(\n  bundleText: string,\n  knownModules?: Set<string>\n): RequireSite[] {\n  // Most bundles contain no bare `require` token at all (esbuild's helpers are\n  // `__require` and `require_<name>`), so skip the lexer entirely for them.\n  REQUIRE_TOKEN.lastIndex = 0;\n  if (!REQUIRE_TOKEN.test(bundleText)) return [];\n\n  const { masked, banners } = maskNonCodeRegions(bundleText);\n  const lineStarts = computeLineStarts(bundleText);\n  const sites: RequireSite[] = [];\n  // Parsing costs more than the scan, so only parse once a reference turns up.\n  let guardedReferences: Set<number> | undefined;\n  const isGuarded = (index: number): boolean => {\n    guardedReferences ??=\n      findGuardedReferences(bundleText, 'require') ?? new Set();\n    return guardedReferences.has(index);\n  };\n\n  REQUIRE_TOKEN.lastIndex = 0;\n  let match = REQUIRE_TOKEN.exec(masked);\n  while (match !== null) {\n    const index = match.index;\n    const reference = readEvaluatedReference(masked, index);\n\n    if (reference) {\n      const { nextChar, afterStart } = reference;\n      const { line, column } = locationOf(lineStarts, index);\n      const lineText = bundleText.slice(\n        lineStarts[line - 1],\n        lineStarts[line] ?? bundleText.length\n      );\n      sites.push({\n        module: moduleForIndex(banners, knownModules, index),\n        line,\n        column,\n        specifier:\n          nextChar === '('\n            ? readLiteralArgument(bundleText, afterStart)\n            : undefined,\n        snippet: truncate(lineText.trim(), 160),\n        // `try { require(\"optional-dep\") } catch {}` is how packages probe for\n        // an optional dependency — framer-motion ships exactly this, and\n        // esbuild itself externalizes unresolvable requires when they are\n        // wrapped this way. The sandbox's `ReferenceError` lands in the\n        // `catch`, so the bundle still loads. A `typeof require` check (UMD\n        // wrappers, esbuild's ESM `__require` shim) skips the call instead.\n        guarded: isGuarded(index),\n      });\n    }\n\n    match = REQUIRE_TOKEN.exec(masked);\n  }\n\n  return sites;\n}\n\n/** The unguarded subset of {@link findRequireSites}. */\nexport function findDynamicRequireCandidates(\n  bundleText: string,\n  knownModules?: Set<string>\n): DynamicRequireViolation[] {\n  return findRequireSites(bundleText, knownModules).filter(\n    (site) => !site.guarded\n  );\n}\n\n/**\n * Specifiers whose every emitted `require(\"…\")` call site is guarded (see\n * {@link RequireSite.guarded}). esbuild leaves an unresolvable `require()` external when it is\n * wrapped that way (it says so in the \"Could not resolve\" hint), so the\n * metafile reports an external import for code that is designed to fail.\n */\nfunction findGuardedSpecifiers(sites: RequireSite[]): Set<string> {\n  const guarded = new Set<string>();\n  const unguarded = new Set<string>();\n  for (const site of sites) {\n    if (site.specifier === undefined) continue;\n    (site.guarded ? guarded : unguarded).add(site.specifier);\n  }\n  for (const specifier of unguarded) guarded.delete(specifier);\n  return guarded;\n}\n\ninterface FreeRequireProbe {\n  /** Specifiers passed to a free `require(\"…\")`. */\n  literals: Set<string>;\n  /** Free `require` references that are not a call with a literal argument. */\n  otherReferences: number;\n}\n\n/**\n * Confirms candidates with esbuild's scope analysis.\n *\n * `define` only rewrites identifiers that resolve to the global scope, so any\n * `require` that a surrounding function parameter or declaration shadows is\n * left alone. `typeof require` survives as `typeof <sentinel>`, which we skip\n * because it cannot throw.\n *\n * Returns `undefined` when the probe itself fails, in which case the caller\n * keeps the candidates rather than silently dropping a real problem.\n */\nasync function probeFreeRequireReferences(\n  bundleText: string\n): Promise<FreeRequireProbe | undefined> {\n  let code: string;\n  try {\n    const result = await esbuild.transform(bundleText, {\n      loader: 'js',\n      define: { require: FREE_REQUIRE_SENTINEL },\n      legalComments: 'none',\n      sourcemap: false,\n    });\n    code = result.code;\n  } catch {\n    return undefined;\n  }\n\n  const probe: FreeRequireProbe = { literals: new Set(), otherReferences: 0 };\n  const sentinel = new RegExp(\n    `(?<![A-Za-z0-9_$])${FREE_REQUIRE_SENTINEL}(?![A-Za-z0-9_$])`,\n    'g'\n  );\n  const { masked } = maskNonCodeRegions(code);\n  const guardedReferences =\n    findGuardedReferences(code, FREE_REQUIRE_SENTINEL) ?? new Set<number>();\n  let match = sentinel.exec(masked);\n  while (match !== null) {\n    const beforeEnd = skipWhitespaceBackward(masked, match.index);\n    const previousWord = identifierEndingAt(masked, beforeEnd);\n    // Mirror the scan's exclusions so a `typeof` probe or a guarded optional\n    // require cannot confirm an unrelated candidate. `define` rewrote the\n    // `typeof require` checks too, so they now test the sentinel.\n    if (previousWord !== 'typeof' && !guardedReferences.has(match.index)) {\n      const afterStart = skipWhitespaceForward(\n        masked,\n        match.index + FREE_REQUIRE_SENTINEL.length\n      );\n      const literal =\n        masked[afterStart] === '('\n          ? readLiteralArgument(code, afterStart)\n          : undefined;\n      if (literal === undefined) probe.otherReferences += 1;\n      else probe.literals.add(literal);\n    }\n    match = sentinel.exec(masked);\n  }\n  return probe;\n}\n\n// ---------------------------------------------------------------------------\n// External imports (metafile)\n// ---------------------------------------------------------------------------\n\n/** esbuild uses `<…>` for synthetic inputs (`<runtime>`, `<stdin>`). */\nfunction isSyntheticPath(path: string): boolean {\n  return path.startsWith('<') && path.endsWith('>');\n}\n\n/** Inputs nobody imports — the entry points, when the metafile omits them. */\nfunction findRootInputs(metafile: esbuild.Metafile): string[] {\n  const imported = new Set<string>();\n  for (const input of Object.values(metafile.inputs)) {\n    for (const imp of input.imports) {\n      if (!imp.external) imported.add(imp.path);\n    }\n  }\n  return Object.keys(metafile.inputs).filter((input) => !imported.has(input));\n}\n\n/**\n * Walks the metafile input graph breadth-first from the bundle entry so each\n * external import can be reported with the chain of modules that pulled it in.\n */\nfunction buildParentIndex(metafile: esbuild.Metafile): {\n  parents: Map<string, string>;\n  entries: Set<string>;\n} {\n  const entries = new Set<string>();\n  for (const output of Object.values(metafile.outputs)) {\n    if (output.entryPoint) entries.add(output.entryPoint);\n  }\n  if (entries.size === 0) {\n    for (const input of findRootInputs(metafile)) entries.add(input);\n  }\n\n  const parents = new Map<string, string>();\n  const queue = [...entries];\n  const seen = new Set(queue);\n  for (let cursor = 0; cursor < queue.length; cursor += 1) {\n    const current = queue[cursor];\n    for (const imp of metafile.inputs[current]?.imports ?? []) {\n      if (imp.external || seen.has(imp.path)) continue;\n      seen.add(imp.path);\n      parents.set(imp.path, current);\n      queue.push(imp.path);\n    }\n  }\n  return { parents, entries };\n}\n\nfunction chainTo(\n  parents: Map<string, string>,\n  entries: Set<string>,\n  module: string\n): string[] {\n  const chain = [module];\n  const seen = new Set(chain);\n  let current = module;\n  while (!entries.has(current)) {\n    const parent = parents.get(current);\n    if (parent === undefined || seen.has(parent)) break;\n    seen.add(parent);\n    chain.unshift(parent);\n    current = parent;\n  }\n  // The virtual entry is generated by the builder, not written by the user.\n  return chain.filter((module) => !entries.has(module));\n}\n\n/** The specifiers esbuild emitted as external in any output chunk. */\nfunction collectExternalSpecifiers(metafile: esbuild.Metafile): Set<string> {\n  const specifiers = new Set<string>();\n  for (const output of Object.values(metafile.outputs)) {\n    for (const imp of output.imports) {\n      if (imp.external && !isSyntheticPath(imp.path)) specifiers.add(imp.path);\n    }\n  }\n  return specifiers;\n}\n\n/** Attributes each external specifier to the inputs that imported it. */\nfunction mapImporters(\n  metafile: esbuild.Metafile,\n  specifiers: Set<string>\n): Map<string, string[]> {\n  const importersBySpecifier = new Map<string, string[]>();\n  for (const [input, info] of Object.entries(metafile.inputs)) {\n    if (isSyntheticPath(input)) continue;\n    for (const imp of info.imports) {\n      if (!imp.external || !specifiers.has(imp.path)) continue;\n      const importers = importersBySpecifier.get(imp.path);\n      if (importers) importers.push(input);\n      else importersBySpecifier.set(imp.path, [input]);\n    }\n  }\n  return importersBySpecifier;\n}\n\n/**\n * Collects the imports esbuild left external. In a CJS bundle each of these is\n * emitted as a top-level `require(\"…\")`.\n */\nexport function collectExternalImports(\n  metafile: esbuild.Metafile\n): ExternalImportViolation[] {\n  const specifiers = collectExternalSpecifiers(metafile);\n  if (specifiers.size === 0) return [];\n\n  const importersBySpecifier = mapImporters(metafile, specifiers);\n  const { parents, entries } = buildParentIndex(metafile);\n  return [...specifiers].sort().map((specifier) => {\n    const importers = (importersBySpecifier.get(specifier) ?? []).sort();\n    return {\n      specifier,\n      importers,\n      importChain: importers[0] ? chainTo(parents, entries, importers[0]) : [],\n      isRuntimeBuiltin: isRuntimeBuiltinSpecifier(specifier),\n    };\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Reporting\n// ---------------------------------------------------------------------------\n\nfunction truncate(value: string, max: number): string {\n  return value.length > max ? `${value.slice(0, max - 1)}…` : value;\n}\n\n/**\n * Inspects a finished flow bundle for constructs the workflow sandbox cannot\n * evaluate.\n */\nexport async function analyzeFlowBundleSafety({\n  bundleText,\n  metafile,\n}: {\n  bundleText: string;\n  metafile?: esbuild.Metafile;\n}): Promise<FlowBundleSafetyReport> {\n  const knownModules = metafile\n    ? new Set(Object.keys(metafile.inputs))\n    : undefined;\n  const sites = findRequireSites(bundleText, knownModules);\n  const guardedSpecifiers = findGuardedSpecifiers(sites);\n\n  const externalImports = (\n    metafile ? collectExternalImports(metafile) : []\n  ).filter((violation) => !guardedSpecifiers.has(violation.specifier));\n  const externalSpecifiers = new Set(\n    externalImports.map((violation) => violation.specifier)\n  );\n\n  // External imports are emitted as `require(\"<specifier>\")`, so drop the\n  // sites they account for: they are already reported above, with a much\n  // better import chain than a bundle line number.\n  const candidates = sites.filter(\n    (site) =>\n      !site.guarded &&\n      (site.specifier === undefined || !externalSpecifiers.has(site.specifier))\n  );\n\n  if (candidates.length === 0) {\n    return { externalImports, dynamicRequires: [] };\n  }\n\n  const probe = await probeFreeRequireReferences(bundleText);\n  const dynamicRequires =\n    probe === undefined\n      ? candidates\n      : candidates.filter((candidate) =>\n          candidate.specifier === undefined\n            ? probe.otherReferences > 0\n            : probe.literals.has(candidate.specifier)\n        );\n\n  return { externalImports, dynamicRequires };\n}\n\nfunction formatList(items: string[]): string {\n  const shown = items.slice(0, MAX_REPORTED);\n  const rest = items.length - shown.length;\n  if (rest > 0) shown.push(`…and ${rest} more`);\n  return shown.join('\\n');\n}\n\nexport function formatFlowBundleSafetyReport(\n  report: FlowBundleSafetyReport\n): string {\n  const sections: string[] = [\n    'Workflow bundle cannot run in the workflow sandbox.',\n    '',\n    'Workflow functions are evaluated in a sandbox without `require`. The bundle below still contains',\n    '`require()` calls, which throw `ReferenceError: require is not defined` when the bundle is loaded.',\n  ];\n\n  if (report.externalImports.length > 0) {\n    const lines = report.externalImports.map((violation) => {\n      const detail: string[] = [`  • \"${violation.specifier}\"`];\n      if (violation.importers.length > 0) {\n        detail.push(`    imported by ${violation.importers[0]}`);\n        if (violation.importers.length > 1) {\n          detail.push(\n            `    (and ${violation.importers.length - 1} other ${\n              violation.importers.length === 2 ? 'module' : 'modules'\n            })`\n          );\n        }\n      }\n      if (violation.importChain.length > 1) {\n        detail.push(`    via ${violation.importChain.join(' → ')}`);\n      }\n      return detail.join('\\n');\n    });\n    sections.push(\n      '',\n      `Imports left external (${report.externalImports.length}):`,\n      formatList(lines)\n    );\n  }\n\n  if (report.dynamicRequires.length > 0) {\n    const lines = report.dynamicRequires.map((violation) => {\n      const where = violation.module\n        ? `${violation.module} (bundle ${violation.line}:${violation.column})`\n        : `bundle ${violation.line}:${violation.column}`;\n      const what = violation.specifier\n        ? `require(\"${violation.specifier}\")`\n        : 'dynamic require()';\n      return `  • ${what} in ${where}\\n    ${violation.snippet}`;\n    });\n    sections.push(\n      '',\n      `Unresolved require() calls (${report.dynamicRequires.length}):`,\n      formatList(lines)\n    );\n  }\n\n  sections.push('', `Learn more: ${DOCS_URL}`);\n  return sections.join('\\n');\n}\n\nfunction buildHint(report: FlowBundleSafetyReport): string {\n  const parts: string[] = [];\n  if (report.externalImports.length > 0) {\n    parts.push(\n      report.externalImports.some((violation) => violation.isRuntimeBuiltin)\n        ? 'Move the code that needs Node.js built-ins into a \"use step\" function, or import the package only from step files.'\n        : 'Import these modules from a \"use step\" function instead of from workflow code.'\n    );\n  }\n  if (report.dynamicRequires.length > 0) {\n    parts.push(\n      'Replace dynamic require() with a static import, or move the calling code into a \"use step\" function.'\n    );\n  }\n  parts.push(\n    `Set ${ALLOW_UNSAFE_FLOW_BUNDLE_ENV}=1 to downgrade this to a warning (the bundle will still fail at runtime if the code runs).`\n  );\n  return parts.join(' ');\n}\n\n/**\n * Fails the build when the flow bundle contains anything the workflow sandbox\n * cannot evaluate.\n *\n * @param warn - Sink for the downgraded message when the escape hatch is set.\n */\nexport async function assertFlowBundleIsSandboxSafe({\n  bundleText,\n  metafile,\n  warn = (message: string) => console.warn(message),\n}: {\n  bundleText: string;\n  metafile?: esbuild.Metafile;\n  warn?: (message: string) => void;\n}): Promise<FlowBundleSafetyReport> {\n  const report = await analyzeFlowBundleSafety({ bundleText, metafile });\n  if (isFlowBundleSafetyReportEmpty(report)) return report;\n\n  const message = formatFlowBundleSafetyReport(report);\n  const hint = buildHint(report);\n\n  if (process.env[ALLOW_UNSAFE_FLOW_BUNDLE_ENV] === '1') {\n    warn(`${message}\\n${hint}`);\n    return report;\n  }\n\n  throw new WorkflowBuildError(message, { hint });\n}\n"]}