@uipath/maestro-builder-sdk 6.56.0 → 6.58.0

package/dist/core/script-function.js

@@ -0,0 +1,511 @@
+import { typescript } from './typescript-module.js';
+import { CompileRefusal } from './compile-refusal.js';
+/**
+ * The body a script node carries for `fn`, or a thrown error naming every
+ * reason it cannot be one.
+ *
+ * @param fn - The function, or its source text (what `fn.toString()` returns).
+ * @param runtime - The runtime the body will run in.
+ * @param label - How errors name the call, e.g. `script(parseMessage)`.
+ */
+export function lowerScriptFunction(fn, runtime, label) {
+    const source = typeof fn === 'string' ? fn : Function.prototype.toString.call(fn);
+    const result = tryLowerScriptFunction(source, runtime, { scopeReadsOnly: true });
+    if (result.ok) {
+        lowered.push(source);
+        return result.code;
+    }
+    const name = label ?? `script(${functionName(fn) ?? 'function'})`;
+    throw new CompileRefusal('SCRIPT_FUNCTION_UNLOWERABLE', `${name} cannot be a script: ${result.problems.join(' ')}`);
+}
+const lowered = [];
+/**
+ * The source of every function {@link lowerScriptFunction} has lowered in this
+ * process, in order, one entry per call.
+ *
+ * The CLIs that load a `.flow.ts` take the entries added while it imported,
+ * twice over: to decide whether the module-scope pass
+ * (`script-function-scope.ts`) has anything to look at, so a flow with no
+ * function scripts pays nothing for it; and to fail closed, by matching each
+ * lowered text to a declaration that pass followed, so a function it could not
+ * see is refused. Taken per load because one process may load two sources
+ * (`merge --baseline-from`).
+ */
+export function scriptFunctionLowerings() {
+    return lowered;
+}
+/**
+ * {@link lowerScriptFunction} without the throw, for a caller that falls back
+ * when the source cannot be lowered (decompile's function-form gate).
+ */
+export function tryLowerScriptFunction(source, runtime, options = {}) {
+    if (/\{\s*\[native code\]\s*\}\s*$/.test(source)) {
+        return { ok: false, problems: ['it is a native or bound function, which has no source to lower.'], free: [] };
+    }
+    const ts = typescript();
+    const text = `(${source}\n)`;
+    const sf = ts.createSourceFile('script-function.ts', text, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    const syntax = sf.parseDiagnostics ?? [];
+    const fn = functionOf(ts, sf);
+    if (syntax.length > 0 || !fn) {
+        const first = syntax[0];
+        const why = first ? `: ${ts.flattenDiagnosticMessageText(first.messageText, '\n')}` : '';
+        return {
+            ok: false,
+            problems: [`its source does not parse as a function expression or arrow function${why}. `
+                    + 'A method (`{ m(vars) {…} }`) or a class is not one; pass a function declaration, expression or arrow.'],
+            free: [],
+            syntax: true,
+        };
+    }
+    return new Lowering(ts, sf, fn, runtime, options).run();
+}
+/**
+ * The first syntax error in a script BODY (the text a script node carries), as
+ * `line N: message`, or undefined when it parses. Lines are the body's own.
+ */
+export function scriptBodySyntaxError(code) {
+    const ts = typescript();
+    const sf = ts.createSourceFile('script-body.ts', `function __body() {\n${code}\n}`, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    const first = (sf.parseDiagnostics ?? [])[0];
+    if (!first)
+        return undefined;
+    // The wrapper's first line is the `{`, so a 0-based line in it is the body's
+    // 1-based line; an error found at the closing brace is reported on the last.
+    const line = Math.min(Math.max(1, sf.getLineAndCharacterOfPosition(first.start ?? 0).line), code.split('\n').length);
+    return `line ${line}: ${ts.flattenDiagnosticMessageText(first.messageText, '\n').replace(/\.$/, '')}`;
+}
+/**
+ * The JavaScript engine's early error for a body run as
+ * `function (<scopeGlobal>) { "use strict"; <code> }`, or undefined when it has
+ * none.
+ *
+ * TypeScript's parser does not report early errors (a duplicate `let`, a
+ * `const $vars` that clashes with the parameter, an octal literal in strict
+ * code), and the printed function lives in an ES module, which is strict. A body
+ * with one would make the whole module unloadable, so decompile asks the engine.
+ * The body is compiled, never called. A host without the `Function`
+ * constructor (a strict content-security policy) cannot answer, which is
+ * reported as an error too, so the caller keeps the string form.
+ */
+export function scriptBodyEarlyError(code, runtime) {
+    // Compiled for their early errors only; neither is invoked. Module code also
+    // reserves `await`, which no synchronous constructor reports: an async
+    // function reserves it the same way, so a body must compile as both. (A
+    // body that uses `await` as an operator fails the first, as it would fail in
+    // the module's plain function.)
+    const AsyncFunction = (async () => { }).constructor;
+    try {
+        new Function(runtime.scopeGlobal, `"use strict";\n${code}`);
+        new AsyncFunction(runtime.scopeGlobal, `"use strict";\n${code}`);
+        return undefined;
+    }
+    catch (e) {
+        return e instanceof Error ? e.message : String(e);
+    }
+}
+/**
+ * The first piece of TypeScript-only syntax in a body, described, or undefined.
+ *
+ * A string body is JavaScript, but the printed function is read by a TypeScript
+ * loader, which erases type syntax before the runtime ever sees it: a body with
+ * `const n: number = 1` would come back from compile as `const n         = 1`,
+ * and `f<T>(x)`, which JavaScript reads as two comparisons, would come back as a
+ * call. Either silently changes the stored script, so such a body keeps the
+ * string form.
+ */
+export function scriptBodyTypeScriptSyntax(code) {
+    const ts = typescript();
+    const sf = ts.createSourceFile('script-body.ts', `function __body() {\n${code}\n}`, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    const TS_MODIFIERS = new Set([ts.SyntaxKind.PublicKeyword, ts.SyntaxKind.PrivateKeyword, ts.SyntaxKind.ProtectedKeyword,
+        ts.SyntaxKind.ReadonlyKeyword, ts.SyntaxKind.AbstractKeyword, ts.SyntaxKind.DeclareKeyword, ts.SyntaxKind.OverrideKeyword]);
+    let found;
+    const visit = (n) => {
+        if (found)
+            return;
+        const extendsClause = ts.isExpressionWithTypeArguments(n) && !n.typeArguments
+            && ts.isHeritageClause(n.parent) && n.parent.token === ts.SyntaxKind.ExtendsKeyword;
+        if (ts.isTypeNode(n) && !extendsClause)
+            found = 'a type annotation or type argument';
+        else if (ts.isTypeParameterDeclaration(n))
+            found = 'a type parameter';
+        else if (ts.isAsExpression(n) || ts.isSatisfiesExpression(n) || ts.isTypeAssertionExpression(n))
+            found = 'a type assertion';
+        else if (ts.isNonNullExpression(n))
+            found = 'a non-null assertion';
+        else if (ts.isInterfaceDeclaration(n) || ts.isTypeAliasDeclaration(n) || ts.isEnumDeclaration(n)
+            || ts.isModuleDeclaration(n) || ts.isImportEqualsDeclaration(n) || ts.isIndexSignatureDeclaration(n))
+            found = 'a TypeScript declaration';
+        else if (ts.isHeritageClause(n) && n.token === ts.SyntaxKind.ImplementsKeyword)
+            found = 'an `implements` clause';
+        else if ((ts.getModifiers(n) ?? []).some((m) => TS_MODIFIERS.has(m.kind)))
+            found = 'a TypeScript modifier';
+        else if ((ts.isParameter(n) || ts.isPropertyDeclaration(n) || ts.isMethodDeclaration(n)) && n.questionToken)
+            found = 'an optional marker';
+        else if ((ts.isVariableDeclaration(n) || ts.isPropertyDeclaration(n)) && n.exclamationToken)
+            found = 'a definite-assignment assertion';
+        else if ((ts.isFunctionDeclaration(n) || ts.isMethodDeclaration(n)) && !n.body)
+            found = 'an overload signature';
+        else
+            ts.forEachChild(n, visit);
+    };
+    ts.forEachChild(sf, (n) => (ts.isFunctionDeclaration(n) && n.body ? ts.forEachChild(n.body, visit) : visit(n)));
+    return found;
+}
+/** The one function expression or arrow `(<source>)` parses to, or undefined. */
+function functionOf(ts, sf) {
+    if (sf.statements.length !== 1)
+        return undefined;
+    const stmt = sf.statements[0];
+    if (!ts.isExpressionStatement(stmt) || !ts.isParenthesizedExpression(stmt.expression))
+        return undefined;
+    const inner = stmt.expression.expression;
+    return ts.isFunctionExpression(inner) || ts.isArrowFunction(inner) ? inner : undefined;
+}
+function functionName(fn) {
+    if (typeof fn !== 'string')
+        return fn.name || undefined;
+    return /^\s*(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/.exec(fn)?.[1];
+}
+class Lowering {
+    ts;
+    sf;
+    fn;
+    runtime;
+    options;
+    checker;
+    problems = [];
+    edits = [];
+    free = new Set();
+    aliased = new Set();
+    param;
+    paramSymbol;
+    ownNameSymbol;
+    constructor(ts, sf, fn, runtime, options) {
+        this.ts = ts;
+        this.sf = sf;
+        this.fn = fn;
+        this.runtime = runtime;
+        this.options = options;
+        this.checker = oneFileChecker(ts, sf);
+    }
+    run() {
+        const { ts, fn } = this;
+        this.checkShape();
+        if (this.problems.length > 0)
+            return { ok: false, problems: this.problems, free: [] };
+        if (ts.isFunctionExpression(fn) && fn.name)
+            this.ownNameSymbol = this.checker.getSymbolAtLocation(fn.name);
+        const renaming = this.param !== undefined && this.param.text !== this.runtime.scopeGlobal;
+        if (renaming) {
+            this.checkNoCapture();
+            this.checkNoRedeclaredParameter();
+        }
+        this.visit(fn.body, 0);
+        if (this.aliased.size > 0) {
+            const name = [...this.aliased][0];
+            this.problems.push(`it uses its parameter \`${name}\` other than as a dotted read (\`${name}.start.output.x\`): an alias, a computed or optional read, `
+                + `or passing \`${name}\` on hides the step it reads from the step renaming and reference checks, which see only \`${this.runtime.scopeGlobal}.<step>\`. `
+                + 'Read each step with dots.');
+        }
+        const free = [...this.free].sort();
+        if (free.length > 0) {
+            this.problems.push(`it reads ${free.join(', ')}, which ${this.runtime.name} does not have. `
+                + 'A script runs alone: move the value inside the function, or declare it with `.var()` and read it from the scope.');
+        }
+        if (this.problems.length > 0)
+            return { ok: false, problems: this.problems, free };
+        return { ok: true, code: this.body() };
+    }
+    /** The function forms that cannot become a body at all. */
+    checkShape() {
+        const { ts, fn } = this;
+        const mods = ts.getModifiers(fn) ?? [];
+        if (mods.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword))
+            this.problems.push('it is `async`; a script body runs synchronously.');
+        if (ts.isFunctionExpression(fn) && fn.asteriskToken)
+            this.problems.push('it is a generator; a script body returns one value.');
+        if (fn.parameters.length > 1) {
+            this.problems.push(`it takes ${fn.parameters.length} parameters; a script function takes one, the runtime's variable scope (${this.runtime.scopeGlobal}), or none.`);
+            return;
+        }
+        const p = fn.parameters[0];
+        if (!p)
+            return;
+        if (p.dotDotDotToken)
+            this.problems.push('its parameter is a rest parameter; take the variable scope as one plain parameter.');
+        else if (p.initializer)
+            this.problems.push('its parameter has a default value; the runtime always supplies the variable scope.');
+        else if (!ts.isIdentifier(p.name)) {
+            this.problems.push('its parameter is destructured. Take the variable scope as one plain parameter and read it with dots '
+                + `(\`vars.start.output.x\`): a destructured read is invisible to the step renaming and reference checks that read \`${this.runtime.scopeGlobal}.<step>\`.`);
+        }
+        else {
+            this.param = p.name;
+            this.paramSymbol = this.checker.getSymbolAtLocation(p.name);
+        }
+    }
+    /**
+     * Refuse a binding named like the scope global anywhere in the function: once
+     * the parameter's references are rewritten to that name, the binding would
+     * capture them (`const $vars = {…}; return vars.x` would read the local).
+     */
+    checkNoCapture() {
+        const { ts } = this;
+        const target = this.runtime.scopeGlobal;
+        let found = false;
+        const visit = (n) => {
+            if (found)
+                return;
+            if (ts.isIdentifier(n) && n.text === target && isDeclarationName(ts, n))
+                found = true;
+            else
+                ts.forEachChild(n, visit);
+        };
+        visit(this.fn.body);
+        if (found) {
+            this.problems.push(`it declares its own \`${target}\`, which would capture the renamed parameter. `
+                + `Rename the inner binding, or name the parameter \`${target}\` so nothing is renamed.`);
+        }
+    }
+    /**
+     * Refuse a `var vars` or `function vars() {}` in the body: either binds the
+     * parameter's own name in the function's scope, so the rename would rewrite the
+     * reads but not the declaration, and `var vars = {x: 1}; return vars.x` would
+     * read the runtime's scope instead of the local. Judged by scope, not by
+     * symbol: the checker gives a function declaration a symbol of its own while
+     * still resolving the reads to the parameter. A nested function (arrows
+     * included) has its own `var` scope, so its declarations are its own.
+     */
+    checkNoRedeclaredParameter() {
+        const { ts } = this;
+        const name = this.param.text;
+        let found = false;
+        const visit = (n) => {
+            if (found)
+                return;
+            if (ts.isFunctionDeclaration(n) && n.name?.text === name) {
+                found = true;
+                return;
+            }
+            // A `var` list, with every name its pattern binds (`var { vars } = …`,
+            // `var [vars]`, `for (var { vars } of …)`); `let`/`const` and a catch binding
+            // are block-scoped and their own.
+            if (ts.isVariableDeclaration(n) && ts.isVariableDeclarationList(n.parent)
+                && (n.parent.flags & ts.NodeFlags.BlockScoped) === 0 && bindsName(ts, n.name, name)) {
+                found = true;
+                return;
+            }
+            if (ts.isFunctionLike(n) || ts.isClassLike(n))
+                return;
+            ts.forEachChild(n, visit);
+        };
+        visit(this.fn.body);
+        if (found) {
+            this.problems.push(`it redeclares its parameter \`${name}\` (a \`var\` or a function declaration), which the rename to \`${this.runtime.scopeGlobal}\` would split from its reads. `
+                + 'Give the local a name of its own.');
+        }
+    }
+    /**
+     * Walk the body: queue the renames and `__name` removals, and collect the
+     * names the runtime would not have. `fnDepth` counts the non-arrow functions
+     * entered, inside which `this`, `arguments` and `new.target` are their own.
+     */
+    visit(n, fnDepth) {
+        const { ts } = this;
+        if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === '__name' && !this.resolves(n.expression)) {
+            this.removeKeepNames(n, fnDepth);
+            return;
+        }
+        if (n.kind === ts.SyntaxKind.ThisKeyword && fnDepth === 0)
+            this.problems.push('it reads `this`, which a script body does not have.');
+        if (ts.isMetaProperty(n)) {
+            if (n.keywordToken === ts.SyntaxKind.ImportKeyword)
+                this.problems.push('it reads `import.meta`, which a script body does not have.');
+            else if (fnDepth === 0)
+                this.problems.push('it reads `new.target`, which a script body does not have.');
+        }
+        if (ts.isCallExpression(n) && n.expression.kind === ts.SyntaxKind.ImportKeyword)
+            this.problems.push('it calls `import()`; a script cannot load modules.');
+        if (n.kind === ts.SyntaxKind.SuperKeyword && !hasHomeObject(ts, n, this.fn))
+            this.problems.push('it reads `super`, which a script body does not have.');
+        if (ts.isIdentifier(n))
+            this.identifier(n, fnDepth);
+        // A scope with its own `this` and `arguments`. Its name, when computed, is
+        // evaluated in the ENCLOSING scope (`{ [arguments.length]() {} }` reads the
+        // outer function's), so the name is walked at the outer depth.
+        if (n !== this.fn && ownsThis(ts, n)) {
+            const name = n.name;
+            ts.forEachChild(n, (c) => this.visit(c, c === name ? fnDepth : fnDepth + 1));
+            return;
+        }
+        ts.forEachChild(n, (c) => this.visit(c, fnDepth));
+    }
+    identifier(id, fnDepth) {
+        const { ts } = this;
+        if (!isReference(ts, id))
+            return;
+        const parent = id.parent;
+        const shorthand = ts.isShorthandPropertyAssignment(parent) && parent.name === id;
+        const symbol = shorthand ? this.checker.getShorthandAssignmentValueSymbol(parent) : this.checker.getSymbolAtLocation(id);
+        if (symbol && symbol === this.paramSymbol) {
+            if (this.options.scopeReadsOnly && !(ts.isPropertyAccessExpression(parent) && parent.expression === id && !parent.questionDotToken)) {
+                this.aliased.add(id.text);
+            }
+            if (this.param.text !== this.runtime.scopeGlobal) {
+                this.edits.push(shorthand
+                    ? [id.getStart(), id.end, `${id.text}: ${this.runtime.scopeGlobal}`]
+                    : [id.getStart(), id.end, this.runtime.scopeGlobal]);
+            }
+            return;
+        }
+        if (symbol && symbol === this.ownNameSymbol) {
+            // The name is bound by the function itself, and only the body reaches the
+            // artifact: the runtime has no such name, so it is as free as any other.
+            this.free.add(id.text);
+            return;
+        }
+        // The checker binds a synthetic `arguments` in every function, so it resolves
+        // whether or not a body would have one: only a nested non-arrow function does.
+        if (id.text === 'arguments' && (symbol?.declarations?.length ?? 0) === 0) {
+            if (fnDepth === 0)
+                this.problems.push('it reads `arguments`, which a script body does not have.');
+            return;
+        }
+        if (symbol && !isUndefinedSymbol(symbol))
+            return;
+        if (id.text === this.runtime.scopeGlobal || this.runtime.globals.has(id.text))
+            return;
+        // `typeof x` of a bare name does not throw when `x` is absent, so it is a
+        // legitimate probe. A compound operand (`typeof x.y`, `typeof f()`) is
+        // evaluated first and does throw, so its names are checked as usual.
+        if (ts.isTypeOfExpression(parent) && parent.expression === id)
+            return;
+        this.free.add(id.text);
+    }
+    /** Whether an identifier resolves to a declaration in the function (as opposed to an ambient global). */
+    resolves(id) {
+        const s = this.checker.getSymbolAtLocation(id);
+        return s !== undefined && !isUndefinedSymbol(s);
+    }
+    /**
+     * esbuild `keepNames` output: `__name(x, "x")` around an expression becomes
+     * `x`, and a `__name(inner, "inner");` statement is dropped.
+     */
+    removeKeepNames(call, fnDepth) {
+        const { ts } = this;
+        const [target, nameArg] = call.arguments;
+        if (!target || !nameArg || call.arguments.length !== 2 || !ts.isStringLiteral(nameArg)) {
+            this.free.add('__name');
+            return;
+        }
+        if (ts.isExpressionStatement(call.parent)) {
+            this.edits.push([call.parent.getStart(), call.parent.end, '']);
+            return;
+        }
+        this.edits.push([call.getStart(), target.getStart(), '']);
+        this.edits.push([target.end, call.end, '']);
+        this.visit(target, fnDepth);
+    }
+    /** The body text with the queued edits applied. */
+    body() {
+        const { ts, fn, sf } = this;
+        const text = sf.text;
+        const block = ts.isBlock(fn.body);
+        // Between the braces, exactly; an expression body becomes `return <expr>;`.
+        const start = block ? fn.body.getStart() + 1 : fn.body.getStart();
+        const end = block ? fn.body.end - 1 : fn.body.end;
+        let out = text.slice(start, end);
+        for (const [s, e, t] of [...this.edits].sort((a, b) => b[0] - a[0])) {
+            out = out.slice(0, s - start) + t + out.slice(e - start);
+        }
+        return block ? out : `return ${out};`;
+    }
+}
+/** The checker of a one-file program over `sf`, with no default library: globals resolve to nothing. */
+function oneFileChecker(ts, sf) {
+    const options = { noLib: true, noResolve: true, types: [], target: ts.ScriptTarget.ES2020 };
+    const host = {
+        getSourceFile: (name) => (name === sf.fileName ? sf : undefined),
+        getDefaultLibFileName: () => 'lib.d.ts',
+        writeFile: () => { },
+        getCurrentDirectory: () => '',
+        getCanonicalFileName: (f) => f,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => '\n',
+        fileExists: (name) => name === sf.fileName,
+        readFile: (name) => (name === sf.fileName ? sf.text : undefined),
+    };
+    return ts.createProgram({ rootNames: [sf.fileName], options, host }).getTypeChecker();
+}
+/** The checker's own symbol for `undefined`, which a no-lib program still binds. */
+function isUndefinedSymbol(s) {
+    return s.escapedName === 'undefined' && (s.declarations?.length ?? 0) === 0;
+}
+/** Whether `id` is read as a value, not a property name, label, or type. */
+export function isReference(ts, id) {
+    const p = id.parent;
+    if (ts.isPropertyAccessExpression(p) && p.name === id)
+        return false;
+    if (ts.isQualifiedName(p))
+        return false;
+    if ((ts.isPropertyAssignment(p) || ts.isMethodDeclaration(p) || ts.isPropertyDeclaration(p)
+        || ts.isGetAccessor(p) || ts.isSetAccessor(p) || ts.isPropertySignature(p) || ts.isEnumMember(p)) && p.name === id)
+        return false;
+    if (ts.isBindingElement(p) && p.propertyName === id)
+        return false;
+    if (ts.isLabeledStatement(p) || ts.isBreakOrContinueStatement(p))
+        return false;
+    if (ts.isMetaProperty(p))
+        return false;
+    if (isDeclarationName(ts, id))
+        return false;
+    // Inside a type annotation (a source that kept its types): not a runtime read.
+    for (let n = p; n && !ts.isSourceFile(n); n = n.parent) {
+        if (ts.isTypeNode(n) && !ts.isExpressionWithTypeArguments(n))
+            return false;
+    }
+    return true;
+}
+/** Whether a binding name or pattern binds `name` anywhere in it. */
+function bindsName(ts, n, name) {
+    if (ts.isIdentifier(n))
+        return n.text === name;
+    return n.elements.some((e) => !ts.isOmittedExpression(e) && bindsName(ts, e.name, name));
+}
+/** Whether `id` is the name a declaration binds. */
+function isDeclarationName(ts, id) {
+    const p = id.parent;
+    return (ts.isVariableDeclaration(p) || ts.isParameter(p) || ts.isFunctionDeclaration(p) || ts.isFunctionExpression(p)
+        || ts.isClassDeclaration(p) || ts.isClassExpression(p) || ts.isBindingElement(p)) && p.name === id;
+}
+/**
+ * Whether a node starts a scope with its own `this` and `arguments`: a non-arrow
+ * function, a method, accessor or constructor (of a class or an object literal),
+ * a class field's initializer, or a static block.
+ */
+function ownsThis(ts, n) {
+    return ts.isFunctionDeclaration(n) || ts.isFunctionExpression(n) || ts.isMethodDeclaration(n)
+        || ts.isConstructorDeclaration(n) || ts.isGetAccessor(n) || ts.isSetAccessor(n)
+        || ts.isPropertyDeclaration(n) || ts.isClassStaticBlockDeclaration(n);
+}
+/**
+ * Whether `super` at `n` has a home object inside `fn`: the nearest enclosing
+ * method, accessor, constructor, class field or static block, of a class or of an
+ * object literal, with arrows transparent between. A computed member name is
+ * evaluated outside its member, so it does not count; a plain function does not
+ * give `super` one at all.
+ */
+function hasHomeObject(ts, n, fn) {
+    let prev = n;
+    for (let p = n.parent; p && p !== fn; prev = p, p = p.parent) {
+        if (ts.isFunctionDeclaration(p) || ts.isFunctionExpression(p))
+            return false;
+        if (ownsThis(ts, p)) {
+            if (p.name === prev)
+                continue;
+            return true;
+        }
+    }
+    return false;
+}

package/dist/core/typescript-module.js

@@ -1,3 +1,4 @@
+import { CompileRefusal } from './compile-refusal.js';
 const HOST_TYPESCRIPT = Symbol.for('uipath.maestro-builder-sdk.typescript');
 let typescriptModule;
 export function typescript() {
@@ -6,7 +7,7 @@ export function typescript() {
 function fromNode() {
     const getBuiltinModule = globalThis.process?.getBuiltinModule;
     if (getBuiltinModule === undefined) {
-        throw new Error("no TypeScript compiler: outside Node, set globalThis[Symbol.for('uipath.maestro-builder-sdk.typescript')] to the 'typescript' module before checking a flow");
+        throw new CompileRefusal('TYPESCRIPT_UNAVAILABLE', "no TypeScript compiler: outside Node, set globalThis[Symbol.for('uipath.maestro-builder-sdk.typescript')] to the 'typescript' module before checking a flow");
     }
     const { createRequire } = getBuiltinModule('node:module');
     return createRequire(import.meta.url)('typescript');

package/dist/decompile-cli.js

@@ -3,7 +3,7 @@
  * decompile-cli — <original>.flow → <Name>.flow.ts (bin `flow-decompile`)
  *
  * Usage:
- *   flow-decompile <original.flow> [-o Name.flow.ts] [--import <specifier>] [--strict]
+ *   flow-decompile <original.flow> [-o Name.flow.ts] [--import <specifier>] [--strict] [--scripts function|string]
  *
  * The reverse of compile-cli: reads a `.flow` JSON and emits Flow SDK builder
  * source whose default export re-serializes to the same graph (same node ids,
@@ -11,6 +11,8 @@
  * `import { flow, … }` line (default the published package) so the file resolves
  * wherever you place it. `--strict` turns off best-effort mode, so an
  * unsupported construct is a hard error instead of a `// TODO` marker.
+ * `--scripts string` prints every script step as `script({ code })` instead of
+ * as a TypeScript function (the default, where the body allows it).
  *
  * Besides the `.flow.ts`, this also emits a per-flow pipeline wrapper
  * (`<Name>.pipeline.mjs`) that chains decompile → [edit] → compile → merge, so an
@@ -40,15 +42,20 @@ function baseName(flow) {
 }
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
-        console.error('usage: flow-decompile <original.flow> [-o Name.flow.ts] [--import <specifier>] [--package <name>]... [--strict]');
+        console.error('usage: flow-decompile <original.flow> [-o Name.flow.ts] [--import <specifier>] [--package <name>]... [--strict] [--scripts function|string]');
         return 2;
     }
-    const flags = new Set(['-o', '--import', '--package']);
+    const flags = new Set(['-o', '--import', '--package', '--scripts']);
     const pos = argv.find((a, i) => !flags.has(a) && !flags.has(argv[i - 1]) && !a.startsWith('--'));
     if (!pos) {
         console.error('flow-decompile: missing <original.flow>');
         return 2;
     }
+    const scripts = flagValue(argv, '--scripts') ?? 'function';
+    if (scripts !== 'function' && scripts !== 'string') {
+        console.error(`flow-decompile: --scripts takes "function" or "string", got ${JSON.stringify(scripts)}`);
+        return 2;
+    }
     // A `.flow` may be SPLIT across sibling files with JSON Reference — resolve
     // those into one object model before decompiling (design §5; the format's own
     // read path does the same). A single-file flow walks through untouched.
@@ -68,6 +75,7 @@ export async function run(argv) {
     const ts = decompile(flow, {
         importSpecifier: flagValue(argv, '--import') ?? PACKAGE_NAME,
         bestEffort: !argv.includes('--strict'),
+        scripts,
         // Findings the source cannot carry on its own (a node no trigger reaches, a
         // pinned core version this SDK lacks, a file-format version outside the
         // writable band) go to stderr, where the agent running the brownfield loop

package/dist/decompile.d.ts

@@ -151,6 +151,15 @@ export interface DecompileOptions {
      * reported through `warn` (an error when `bestEffort` is false).
      */
     readSidecar?: (relativePath: string) => string | undefined;
+    /**
+     * How a script step prints. `function` prints it as a TypeScript function,
+     * `script(script_<step>, …)` with `function script_<step>($vars: FlowVars)
+     * {…}` after the flow, whenever its body passes decompile's gate; any other
+     * body keeps the string form with a warning. `string` always prints
+     * `script({ code })`. The default is `function` under Node and `string`
+     * elsewhere, where the loader's `toString()` has not been measured.
+     */
+    scripts?: 'function' | 'string';
 }
 /**
  * Tracks which identifiers the emitted source uses, per module, so each import