@uipath/maestro-builder-sdk 6.56.0 → 6.57.0

package/dist/decompile.js

@@ -112,6 +112,38 @@ let runAbsorbed = new Map();
 let runFlowId = 'flow';
 /** `DecompileOptions.readSidecar` for the current run. */
 let runReadSidecar;
+/**
+ * A host's own say on decompile's default script form, beside the TypeScript
+ * hand-over in core/typescript-module.ts:
+ * `globalThis[Symbol.for('uipath.maestro-builder-sdk.scripts')] = 'string'`.
+ */
+const HOST_SCRIPTS = Symbol.for('uipath.maestro-builder-sdk.scripts');
+/**
+ * Function scripts by default only under Node. The exact text a function form
+ * stores is what the loader's `Function.prototype.toString()` returns, which is
+ * the author's own text under Node's type stripping (what `compile` and `uip`
+ * run) and a reprint under other loaders. A host that runs the SDK in a page has
+ * not been measured, so there a decompiled script stays a string unless asked.
+ */
+function defaultScripts() {
+    const host = globalThis[HOST_SCRIPTS];
+    if (host === 'function' || host === 'string')
+        return host;
+    // Real Node, tested as core/typescript-module.ts does: a page bundle may shim
+    // `process.versions.node` (cli-browser's banner sets it) but does not define
+    // `process.getBuiltinModule`.
+    return typeof globalThis.process?.getBuiltinModule === 'function' ? 'function' : 'string';
+}
+/** How this run prints scripts (`DecompileOptions.scripts`). */
+let runScripts = 'function';
+/** The module-level functions print hooks declared this run, in order. */
+let runModuleFunctions = [];
+/**
+ * Each step's reserved function name, by node: keyed by the node itself, not its
+ * id, because a root step and a subflow step may share an id, and two
+ * `function script_<id>` declarations would make the module unloadable.
+ */
+let runFunctionNames = new Map();
 function warnOnce(message) {
     if (runWarned.has(message))
         return;
@@ -336,6 +368,8 @@ class Imports {
     locals = new Set(['flow']);
     /** Names a package may not take bare: the SDK's helpers and every built-in factory. */
     reserved;
+    /** The SDK's type-only names (`FlowVars`): `import { type X }`, erased under type stripping. */
+    types = new Set();
     constructor() {
         this.reserved = new Set([
             ...SDK_HELPER_NAMES,
@@ -368,14 +402,25 @@ class Imports {
         this.locals.add(local);
         return local;
     }
+    /**
+     * A type-only name from the SDK: `import { type X }`, erased under type
+     * stripping, so it never needs a runtime export. Taken as a local, so no
+     * package factory binds the same name.
+     */
+    useType(name) {
+        this.types.add(name);
+        this.locals.add(name);
+        return name;
+    }
     /** One import per module: the SDK first, then the packages by name. */
     line(specifier) {
         const lines = [];
         for (const [module, names] of [...this.used].sort(([a], [b]) => (a === undefined ? -1 : b === undefined ? 1 : a.localeCompare(b)))) {
-            if (names.size === 0)
+            const types = module === undefined ? [...this.types].filter((t) => !names.has(t)).sort().map((t) => `type ${t}`) : [];
+            if (names.size === 0 && types.length === 0)
                 continue;
             const bindings = [...names].sort(([a], [b]) => a.localeCompare(b)).map(([name, local]) => (local === name ? name : `${name} as ${local}`));
-            lines.push(`import { ${bindings.join(', ')} } from ${tsLiteral(module ?? specifier)};`);
+            lines.push(`import { ${[...bindings, ...types].join(', ')} } from ${tsLiteral(module ?? specifier)};`);
         }
         return lines.join('\n');
     }
@@ -826,6 +871,11 @@ function emitRegisteredSpec(node, imp, inputNames, graph) {
         json: (v) => tsLiteral(v),
         key: (k) => key(k),
         helper: (name) => imp.use(name),
+        typeHelper: (name) => imp.useType(name),
+        warn: (message) => warnOnce(`step ${tsLiteral(node.id)}: ${message}`),
+        functionName: () => moduleFunctionName(node),
+        declareFunction: (source) => { runModuleFunctions.push(source); },
+        scripts: runScripts,
     };
     const call = impl.print?.(spec, print) ?? {
         factory: impl.factory,
@@ -2838,6 +2888,9 @@ function foldOutputBacking(flow) {
 }
 export function decompile(flow, options = {}) {
     flow = foldOutputBacking(flow);
+    runScripts = options.scripts ?? defaultScripts();
+    runModuleFunctions = [];
+    runFunctionNames = new Map();
     const importSpecifier = options.importSpecifier ?? './flow-sdk.js';
     runStrict = options.bestEffort === false;
     runWarn = options.warn;
@@ -2991,7 +3044,27 @@ export function decompile(flow, options = {}) {
     const hoisted = [...carriedConsts, ...runRawManifests]
         .map(([name, json]) => `const ${name} = ${json};`)
         .join('\n\n');
-    return [imp.line(importSpecifier), hoisted, chain].filter((p) => p.length > 0).join('\n\n') + '\n';
+    const functions = runModuleFunctions.join('\n\n');
+    return [imp.line(importSpecifier), hoisted, chain, functions].filter((p) => p.length > 0).join('\n\n') + '\n';
+}
+/**
+ * A step's module-level function name: `script_<id>`, with what an identifier
+ * cannot hold replaced by `_`, and a numeric suffix when two steps (in different
+ * scopes, or with ids that sanitize alike) would get the same one.
+ * The `script_` prefix keeps it clear of every SDK export (all camelCase) and of
+ * the hoisted constants.
+ */
+function moduleFunctionName(node) {
+    const have = runFunctionNames.get(node);
+    if (have)
+        return have;
+    const base = `script_${node.id.replace(/[^A-Za-z0-9_$]/g, '_')}`;
+    const taken = new Set(runFunctionNames.values());
+    let name = base;
+    for (let i = 2; taken.has(name); i++)
+        name = `${base}_${i}`;
+    runFunctionNames.set(node, name);
+    return name;
 }
 /**
  * Top-level nodes (no `parentId`) that no root trigger reaches over ANY edge —

package/dist/flow-node-type.d.ts

@@ -327,6 +327,27 @@ export interface FlowPrintContext {
     key(name: string): string;
     /** An authoring helper (`lit`, `input`, …) by name: imported into the printed source, and its identifier. */
     helper(name: string): string;
+    /** An exported TYPE (`FlowVars`) by name: imported as `type <name>`, and its identifier. */
+    typeHelper(name: string): string;
+    /**
+     * Report a finding about this step, printed once with the step named.
+     * Informational: it never fails `--strict`, so it is for a choice of spelling
+     * that loses nothing, not for something recompiling would drop.
+     */
+    warn(message: string): void;
+    /**
+     * The identifier of this step's module-level function: unique in the printed
+     * module, the same on every call for the step. Reserving it declares nothing;
+     * {@link declareFunction} does.
+     */
+    functionName(): string;
+    /** Add a declaration to the end of the printed module, after the flow, verbatim. */
+    declareFunction(source: string): void;
+    /**
+     * How scripts print: `function` (the default) as a TypeScript function where
+     * the body allows it, `string` always as `script({ code })`.
+     */
+    readonly scripts: 'function' | 'string';
 }
 /** What a node-local `check` may ask of the checker. */
 export interface FlowCheckContext {

package/dist/load.js

@@ -3,6 +3,8 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { basename, dirname, join, resolve } from 'node:path';
 import { statSync } from 'node:fs';
 import { useThisSdkForAuthoredSource } from './sdk-resolve.js';
+import { scriptFunctionLowerings } from './core/script-function.js';
+import { scriptFunctionScopeProblem } from './script-function-scope.js';
 /** Resolve a user argument (a `.ts` path or a BaseName) to a flow source file. */
 export function resolveFlowFile(arg) {
     const candidates = [arg, `${arg}.flow.ts`, `${arg}.ts`];
@@ -21,6 +23,7 @@ export function resolveFlowFile(arg) {
 }
 export async function loadBuiltFlow(file) {
     useThisSdkForAuthoredSource();
+    const firstLowering = scriptFunctionLowerings().length;
     let mod;
     try {
         mod = await import(pathToFileURL(file).href);
@@ -34,6 +37,16 @@ export async function loadBuiltFlow(file) {
     const built = typeof exp.build === 'function' ? exp.build() : exp;
     if (!built || !Array.isArray(built.steps))
         throw new Error(`${file} default export is not a built flow. Did you call .build()?`);
+    // A `script(fn)` function was lowered from its own text, which cannot show a
+    // name it takes from its module; this source can (script-function-scope.ts).
+    // Only a flow that lowered one pays for the program this builds.
+    // The functions this import lowered; see scriptFunctionLowerings.
+    const lowered = scriptFunctionLowerings().slice(firstLowering);
+    if (lowered.length > 0) {
+        const problem = scriptFunctionScopeProblem(file, lowered);
+        if (problem)
+            throw new Error(problem);
+    }
     return built;
 }
 /**

package/dist/nodes/script/flow/factories.d.ts

@@ -3,7 +3,48 @@
  * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; the package entry re-exports it.
  */
 import { type ActionSpec } from '../../../core/actions.js';
-import type { ScriptInputs } from './spec.js';
+import type { ScriptReturns } from '../../../core/script-return.js';
+import type { ScriptInputs, ScriptValue } from './spec.js';
+/**
+ * Declare an inline script action, as a TypeScript function the compiler checks.
+ *
+ * The function is never called. Its body, exactly as written, becomes the
+ * script; its parameter is an authoring-time name for the Flow runtime's own
+ * `$vars` global and is renamed to it. `returns` is the declaration that reaches
+ * the `.flow`, and tsc checks the function's return against it.
+ *
+ * The function may read only what the script runtime has (the ES2020 built-ins
+ * and `console`): a module constant, an import or a library throws here, because
+ * in the run it would be a `ReferenceError`.
+ *
+ * ```ts
+ * .step('post', script(parseMessage, { returns: { channel: 'string', threadTs: 'string' } }))
+ *
+ * function parseMessage(vars: FlowVars) {
+ *   const m = /archives\/([A-Z0-9]+)\/p(\d{10})(\d{6})/.exec(String(vars.start.output.message));
+ *   if (!m) throw new Error('not a Slack permalink');
+ *   return { channel: m[1], threadTs: m[2] + '.' + m[3] };
+ * }
+ * ```
+ *
+ * @param fn - The script, as a function of the variable scope (or of nothing).
+ * @param options - What the function returns (`returns`), as `script({ returns })` takes it.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export declare function script<V, const R extends ScriptReturns>(fn: (vars: V) => ScriptValue<R>, options: {
+    returns: R;
+}): ActionSpec;
+/**
+ * Declare an inline script action, as a TypeScript function, with no declared
+ * return: the body's type is inferred as it is for a string body.
+ *
+ * @param fn - The script, as a function of the variable scope (or of nothing).
+ * @param options - No `returns`; pass one to have tsc check the function against it.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export declare function script<V>(fn: (vars: V) => unknown, options?: {
+    returns?: never;
+}): ActionSpec;
 /**
  * Declare an inline script action.
  *

package/dist/nodes/script/flow/factories.js

@@ -3,13 +3,12 @@
  * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; the package entry re-exports it.
  */
 import { builtinActionSpec } from '../../../core/actions.js';
-/**
- * Declare an inline script action.
- *
- * @param inputs - The JavaScript body (`code`, which must `return`) and what it
- * returns (`returns`).
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function script(inputs) {
-    return builtinActionSpec({ kind: 'script', inputs });
+import { lowerScriptFunction } from '../../../core/script-function.js';
+import { FLOW_SCRIPT_RUNTIME } from './runtime.js';
+export function script(arg, options) {
+    if (typeof arg !== 'function')
+        return builtinActionSpec({ kind: 'script', inputs: arg });
+    const code = lowerScriptFunction(arg, FLOW_SCRIPT_RUNTIME, `script(${arg.name || 'function'})`);
+    const returns = options?.returns;
+    return builtinActionSpec({ kind: 'script', inputs: { code, ...(returns !== undefined ? { returns } : {}) } });
 }

package/dist/nodes/script/flow/node-type.js

@@ -6,6 +6,8 @@
  */
 import { declaredScriptShape, inferScriptShape } from '../../../core/script-return.js';
 import { jsonClone } from '../../../core/json-clone.js';
+import { scriptBodyEarlyError, scriptBodySyntaxError, scriptBodyTypeScriptSyntax, tryLowerScriptFunction } from '../../../core/script-function.js';
+import { FLOW_SCRIPT_RUNTIME } from './runtime.js';
 import { checkScript } from './check.js';
 /**
  * Declare what a `core.action.script` node actually publishes.
@@ -83,6 +85,72 @@ function liftReturns(node, code, definitionType) {
     }
     return declared;
 }
+/** The fallback reason for a body that parses alone but not as the printed function, or comes back changed. */
+const UNCHANGED = 'its text would not come back unchanged as a function body (a line comment on its last line, for one).';
+/**
+ * The function a script step prints as, declared after the flow, or undefined
+ * when the step keeps the string form (`script({ code })`), with a warning.
+ *
+ * A designer-edited flow may hold a half-written script, and decompile still has
+ * to produce a source that builds, so a body that cannot become a function is a
+ * reason to keep the string, never to fail. It becomes one only when all of
+ * these hold (docs/SCRIPT_FUNCTION_DESIGN.md, "Decompile"):
+ *
+ *   1. it parses;
+ *   2. it has no TypeScript-only syntax, which the loader would erase or reread
+ *      (`const n: number`, or `f<T>(x)`, which JavaScript reads as comparisons);
+ *   3. `script(fn)` would accept it: it reads only names on the runtime's list
+ *      (a function that failed this would throw when the source loads);
+ *   4. it comes back from compile byte for byte. The function is printed with
+ *      the body verbatim between its braces, which lowering returns exactly, so
+ *      this holds for nearly every body that passes the others; it is checked
+ *      because it is cheap, and a line comment on the last line is the case that
+ *      fails it (it would swallow the closing brace);
+ *   5. the engine compiles it as a strict function of `$vars`: an early error
+ *      (a duplicate `let`, a `const $vars`, an octal literal) that TypeScript's
+ *      parser does not report would make the whole module unloadable.
+ *
+ * The parameter is named `$vars`, so nothing is renamed and the body's text is
+ * the node's text.
+ */
+function printAsFunction(code, ctx) {
+    if (ctx.scripts !== 'function')
+        return undefined;
+    const keep = (why) => {
+        ctx.warn(`script kept as a string: ${why} Fix the script and decompile again to get a typed function.`);
+        return undefined;
+    };
+    const syntax = scriptBodySyntaxError(code);
+    if (syntax)
+        return keep(`its body does not parse (${syntax}).`);
+    const typed = scriptBodyTypeScriptSyntax(code);
+    if (typed)
+        return keep(`it contains ${typed}, which a TypeScript loader would erase or reread, changing the script.`);
+    const name = ctx.functionName();
+    // With authoring's own rules: the printed function is lowered by `script(fn)`
+    // when the source is compiled back, so a body that rule refuses (`$vars?.x`,
+    // `$vars['x']`, an alias) must stay a string here, or compile would refuse it.
+    const lowered = tryLowerScriptFunction(`function ${name}($vars) {${code}}`, FLOW_SCRIPT_RUNTIME, { scopeReadsOnly: true });
+    if (!lowered.ok) {
+        // Worded as the SDK's list, not as a fault: whether a string body that reads
+        // the name really fails in the run is what #1411 has yet to establish.
+        if (lowered.free.length > 0) {
+            return keep(`it reads ${lowered.free.join(', ')}, which is not on the SDK's list of names the Flow script runtime provides.`);
+        }
+        // The body parses on its own (checked above) but not between the braces.
+        if (lowered.syntax)
+            return keep(UNCHANGED);
+        return keep(lowered.problems.join(' '));
+    }
+    if (lowered.code !== code)
+        return keep(UNCHANGED);
+    // Last, on what will actually be printed: an early error makes the module unloadable.
+    const early = scriptBodyEarlyError(code, FLOW_SCRIPT_RUNTIME);
+    if (early)
+        return keep(`as a function in an ES module (strict code) it would not load: ${early}.`);
+    ctx.declareFunction(`function ${name}($vars: ${ctx.typeHelper('FlowVars')}) {${code}}`);
+    return name;
+}
 /** Key-sorted copy, so a property map compares by content and not by order. */
 function sortKeys(o) {
     return Object.fromEntries(Object.entries(o).sort(([a], [b]) => a.localeCompare(b)));
@@ -119,6 +187,9 @@ function scriptAt(version) {
             const returns = r === undefined ? undefined
                 : typeof r === 'string' ? ctx.string(r)
                     : `{ ${Object.entries(r).map(([k, t]) => `${ctx.key(k)}: ${ctx.string(String(t))}`).join(', ')} }`;
+            const fn = printAsFunction(inputs.code, ctx);
+            if (fn !== undefined)
+                return { factory: 'script', positional: [fn], options: [['returns', returns]] };
             return { factory: 'script', options: [['code', ctx.string(inputs.code)], ['returns', returns]] };
         },
         check: ({ inputs }, ctx) => checkScript(inputs, ctx),

package/dist/nodes/script/flow/runtime.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The Flow script runtime, as `script(fn)` lowers for it. Not part of the public
+ * surface: `index.ts` does not re-export this file.
+ */
+import type { ScriptRuntime } from '../../../core/script-function.js';
+/**
+ * What a Flow script body can read: the language's ES2020 built-ins, `console`,
+ * and the runtime's `$vars`. From the Flow skill's `references/script.md` ("The
+ * JavaScript runtime"), which also lists what reads `undefined` in a real run and
+ * is therefore absent here: `Intl`, `URL`, `TextEncoder`, `Buffer`, `fetch`,
+ * `require`, `structuredClone`. Change this when the runtime changes.
+ *
+ * Annex B's `escape`/`unescape` are left off on purpose: they URL-encode, and
+ * `escape` is the likeliest name for an author's own HTML-escape helper, which
+ * the runtime's global would silently replace.
+ *
+ * Only `script(fn)` checks against it. A string body is not checked, until
+ * there is evidence the list is complete (#1411).
+ */
+export declare const FLOW_SCRIPT_RUNTIME: ScriptRuntime;

package/dist/nodes/script/flow/runtime.js

@@ -0,0 +1,29 @@
+/**
+ * What a Flow script body can read: the language's ES2020 built-ins, `console`,
+ * and the runtime's `$vars`. From the Flow skill's `references/script.md` ("The
+ * JavaScript runtime"), which also lists what reads `undefined` in a real run and
+ * is therefore absent here: `Intl`, `URL`, `TextEncoder`, `Buffer`, `fetch`,
+ * `require`, `structuredClone`. Change this when the runtime changes.
+ *
+ * Annex B's `escape`/`unescape` are left off on purpose: they URL-encode, and
+ * `escape` is the likeliest name for an author's own HTML-escape helper, which
+ * the runtime's global would silently replace.
+ *
+ * Only `script(fn)` checks against it. A string body is not checked, until
+ * there is evidence the list is complete (#1411).
+ */
+export const FLOW_SCRIPT_RUNTIME = {
+    scopeGlobal: '$vars',
+    name: 'the Flow script runtime',
+    globals: new Set([
+        'undefined', 'NaN', 'Infinity', 'globalThis', 'console',
+        'Object', 'Function', 'Array', 'Number', 'Boolean', 'String', 'Symbol', 'BigInt', 'Date', 'RegExp', 'Math', 'JSON',
+        'Promise', 'Proxy', 'Reflect', 'Map', 'Set', 'WeakMap', 'WeakSet',
+        'Error', 'EvalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError',
+        'ArrayBuffer', 'SharedArrayBuffer', 'DataView', 'Atomics',
+        'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array',
+        'Float32Array', 'Float64Array', 'BigInt64Array', 'BigUint64Array',
+        'parseInt', 'parseFloat', 'isNaN', 'isFinite',
+        'encodeURI', 'encodeURIComponent', 'decodeURI', 'decodeURIComponent', 'eval',
+    ]),
+};

package/dist/nodes/script/flow/spec.d.ts

@@ -3,7 +3,7 @@
  * in `FlowActionSpecs`. Moved from core/actions.ts in Phase 4 of
  * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md.
  */
-import type { ScriptReturns } from '../../../core/script-return.js';
+import type { ScriptReturns, ScriptReturnType } from '../../../core/script-return.js';
 export interface ScriptInputs {
     /** JavaScript body. Must `return` its result. Referenced via out('<step>'). */
     code: string;
@@ -42,6 +42,37 @@ export interface ScriptInputs {
      */
     returns?: ScriptReturns;
 }
+/**
+ * The runtime's variable scope, as a script function's parameter sees it.
+ *
+ * `$vars` is the Flow script runtime's own global, not something the SDK
+ * provides: the SDK never calls a script function, and `script(fn)` renames the
+ * parameter to `$vars` in the body it emits. This type is a loose name for what
+ * that global holds, so `vars.start.output.message` type-checks. Any other
+ * parameter type works too; the SDK cannot check it against the runtime.
+ *
+ * ```ts
+ * .step('parse', script(parse, { returns: { amount: 'number' } }))
+ *
+ * function parse(vars: FlowVars) {
+ *   return { amount: Number(vars.start.output.amount) };
+ * }
+ * ```
+ */
+export type FlowVars = Record<string, any>;
+/** The TypeScript type one of {@link ScriptReturnType}'s names stands for. */
+export type ScriptValueOf<T extends ScriptReturnType> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'array' ? readonly unknown[] : T extends 'object' ? object : unknown;
+/**
+ * What a script function must return for a given `returns`: the type a name
+ * stands for, or, for a field map, an object with those fields.
+ *
+ * This is how `script(fn, { returns })` makes tsc check the function against the
+ * declaration that reaches the `.flow`: `returns: { total: 'number' }` over a
+ * function that returns a string `total` does not compile.
+ */
+export type ScriptValue<R extends ScriptReturns> = R extends ScriptReturnType ? ScriptValueOf<R> : {
+    [F in keyof R]: R[F] extends ScriptReturnType ? ScriptValueOf<R[F]> : never;
+};
 declare module '../../../core/actions.js' {
     interface FlowActionSpecs {
         /** The spec {@link script} builds. */

package/dist/script-function-scope.d.ts

@@ -0,0 +1,57 @@
+/** One name a script function reads from outside itself. */
+export interface ScriptFunctionCapture {
+    /** How the call is named in messages: `script(renderSafe)`. */
+    call: string;
+    /** The name read. */
+    name: string;
+    /** Where the binding it resolves to is declared, `file:line`. */
+    declaredAt: string;
+    /** Where the read is, `file:line`. */
+    readAt: string;
+}
+/** What the pass found in a source: the captures, and what it could not check. */
+export interface ScriptFunctionScope {
+    captures: ScriptFunctionCapture[];
+    /** `script(<arg>)` calls whose function-typed argument it could not follow, `file:line` each. */
+    unfollowed: string[];
+    /**
+     * `script(<arg>)` calls whose argument it could not follow and whose type is
+     * `any` or `unknown` (`fns.check` on an `any` object, a function from a `.js`
+     * file): a function or a string script's options, the pass cannot tell which.
+     */
+    untyped: string[];
+    /** How many distinct script functions it followed to a declaration. */
+    followed: number;
+    /**
+     * Each followed function's text as Node's type stripping leaves it, whitespace
+     * removed: what `Function.prototype.toString()` returns for it under that
+     * loader, so a lowered function can be matched to its declaration. Empty when
+     * this Node has no `module.stripTypeScriptTypes`.
+     */
+    followedTexts: Set<string>;
+}
+/**
+ * Every name a `script(fn)` function in `file` (or a file it imports) reads from
+ * outside itself, and every call whose function it could not follow.
+ *
+ * It follows a bare identifier (through `const`, a function declaration and
+ * imports between the author's files) and an inline function. Any other
+ * function-typed argument (`script(h.check)`, `script(fns.check)`, a wrapper's
+ * parameter) is `unfollowed`, and the caller refuses it rather than let a capture
+ * through unchecked. An argument that is not a function (`script({ code })`, or
+ * options passed by name) is the string form and is not a script function.
+ */
+export declare function scriptFunctionScope(file: string): ScriptFunctionScope;
+/** A whitespace-free key for comparing function texts. */
+export declare function functionTextKey(text: string): string;
+/**
+ * Why a loaded flow cannot be trusted with its script functions, or undefined.
+ *
+ * Fails closed: a function the pass could not follow, or fewer functions found in
+ * the source than `script(fn)` lowered (a call made through `const sc = script`,
+ * a re-exporting module, or a function from a file outside the program), is
+ * refused like a capture, because what it reads was not checked.
+ */
+export declare function scriptFunctionScopeProblem(file: string, lowered: readonly string[]): string | undefined;
+/** The message a load refuses with, one line per capture. */
+export declare function scriptFunctionCaptureMessage(captures: readonly ScriptFunctionCapture[]): string;