@typesol/cli 0.23.0 → 0.24.0

package/dist/compiler/emit/cpi.js

@@ -1526,6 +1526,8 @@ export class CpiEmitter extends CallEmitter {
                 this.line(`static const uint8_t ${name}[${f.bytes.length}] = ${cBytes(f.bytes)};`);
                 put(name, String(f.bytes.length), f.bytes.length);
             }
+            else if ("c" in f)
+                put(f.c, f.n);
             else
                 this.serialize(this.expect(this.expr(f.value, f.type), f.type, f.value), f.value, put);
         }
@@ -1829,8 +1831,237 @@ export class CpiEmitter extends CallEmitter {
                 this.cpi(p, metas, data.buf, data.len, seedsAt(4));
                 return undefined;
             }
+            case "addExternalPlugin":
+            case "removeExternalPlugin":
+            case "writeExternalPluginData": {
+                // Add/RemoveExternalPluginAdapterV1: asset, collection, payer, authority, systemProgram, logWrapper;
+                // WriteExternalPluginAdapterDataV1 has a buffer account (left out: the data is in the instruction) before systemProgram.
+                const write = method === "writeExternalPluginData";
+                const n = write ? 7 : 6;
+                if (a.length !== n && a.length !== n + 1)
+                    this.fail(node, `${method}(asset, collection | null, payer, authority | null, systemProgram, ${method === "addExternalPlugin" ? "plugin" : write ? "key, data" : "key"}, signerSeeds?)`);
+                const metas = [
+                    this.mplMeta(a[0], core, "the asset", true, false),
+                    this.mplMeta(a[1], core, "the collection", true, false),
+                    this.mplMeta(a[2], core, "the payer", true, true),
+                    this.mplMeta(a[3], core, "the authority", false, true),
+                    ...(write ? [self] : []),
+                    this.mplMeta(a[4], core, "the system program", false, false),
+                    self,
+                ];
+                const body = method === "addExternalPlugin"
+                    ? this.coreExternalPlugin(a[5])
+                    : write
+                        ? [...this.coreExternalKey(a[5]), ...this.coreExternalData(a[6])]
+                        : this.coreExternalKey(a[5]);
+                const data = this.mplData(node, 1024, [{ bytes: [{ addExternalPlugin: 22, removeExternalPlugin: 24, writeExternalPluginData: 28 }[method]] }, ...body]);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(n));
+                return undefined;
+            }
+            case "addCollectionExternalPlugin":
+            case "removeCollectionExternalPlugin":
+            case "writeCollectionExternalPluginData": {
+                // The same on a collection: collection, payer, authority, (buffer,) systemProgram, logWrapper.
+                const write = method === "writeCollectionExternalPluginData";
+                const n = write ? 6 : 5;
+                if (a.length !== n && a.length !== n + 1)
+                    this.fail(node, `${method}(collection, payer, authority | null, systemProgram, ${method === "addCollectionExternalPlugin" ? "plugin" : write ? "key, data" : "key"}, signerSeeds?)`);
+                const metas = [
+                    this.mplMeta(a[0], core, "the collection", true, false),
+                    this.mplMeta(a[1], core, "the payer", true, true),
+                    this.mplMeta(a[2], core, "the authority", false, true),
+                    ...(write ? [self] : []),
+                    this.mplMeta(a[3], core, "the system program", false, false),
+                    self,
+                ];
+                const body = method === "addCollectionExternalPlugin"
+                    ? this.coreExternalPlugin(a[4])
+                    : write
+                        ? [...this.coreExternalKey(a[4]), ...this.coreExternalData(a[5])]
+                        : this.coreExternalKey(a[4]);
+                const data = this.mplData(node, 1024, [
+                    { bytes: [{ addCollectionExternalPlugin: 23, removeCollectionExternalPlugin: 25, writeCollectionExternalPluginData: 29 }[method]] },
+                    ...body,
+                ]);
+                this.cpi(p, metas, data.buf, data.len, seedsAt(n));
+                return undefined;
+            }
+        }
+        this.fail(node.expression, `Metaplex Core supports createAsset, createCollection, addPlugin, updatePlugin, removePlugin, addExternalPlugin, removeExternalPlugin, writeExternalPluginData (and the Collection forms), transferAsset and burnAsset, not ${method}`);
+    }
+    /** The fields of a Core object literal (`{ kind: "AppData", … }`) by name. */
+    coreProps(node, what) {
+        let n = node;
+        while (ts.isParenthesizedExpression(n) || ts.isAsExpression(n) || ts.isSatisfiesExpression(n))
+            n = n.expression;
+        if (!ts.isObjectLiteralExpression(n))
+            this.fail(n, `${what} is an object literal: { kind: "…", … }`);
+        const props = new Map();
+        for (const q of n.properties) {
+            if (ts.isPropertyAssignment(q) && ts.isIdentifier(q.name))
+                props.set(q.name.text, q.initializer);
+            else if (ts.isShorthandPropertyAssignment(q))
+                props.set(q.name.text, q.name);
+            else
+                this.fail(q, "write the fields as name: value");
+        }
+        return props;
+    }
+    /** PluginAuthority: "none" | "owner" | "updateAuthority" (literals), or an address. */
+    coreAuthority(n) {
+        if (ts.isStringLiteral(n)) {
+            const i = ["none", "owner", "updateAuthority"].indexOf(n.text);
+            if (i < 0)
+                this.fail(n, 'an authority is "none", "owner", "updateAuthority" or a Pubkey');
+            return [{ bytes: [i] }];
+        }
+        return [{ bytes: [3] }, { value: n, type: PUBKEY }];
+    }
+    coreOption(n, inner) {
+        return n ? [{ bytes: [1] }, ...inner(n)] : [{ bytes: [0] }];
+    }
+    coreSchema(n) {
+        const i = ts.isStringLiteral(n) ? ["binary", "json", "msgpack"].indexOf(n.text) : -1;
+        if (i < 0)
+            this.fail(n, 'schema is "binary", "json" or "msgpack"');
+        return [{ bytes: [i] }];
+    }
+    /** Vec<(HookableLifecycleEvent, ExternalCheckResult)>: `[{ event: "transfer", canReject: true }, …]`. */
+    coreChecks(n, at) {
+        if (!n || !ts.isArrayLiteralExpression(n))
+            this.fail(n ?? at, 'checks is a list: [{ event: "transfer", canApprove: true, canReject: true }]');
+        const out = [{ bytes: [n.elements.length & 0xff, 0, 0, 0] }];
+        for (const e of n.elements) {
+            const p = this.coreProps(e, "a lifecycle check");
+            const ev = p.get("event");
+            const i = ev && ts.isStringLiteral(ev) ? ["create", "transfer", "burn", "update", "execute"].indexOf(ev.text) : -1;
+            if (i < 0)
+                this.fail(ev ?? e, 'event is "create", "transfer", "burn", "update" or "execute"');
+            let flags = 0;
+            for (const [k, bit] of [
+                ["canListen", 1],
+                ["canApprove", 2],
+                ["canReject", 4],
+            ]) {
+                const v = p.get(k);
+                if (v && v.kind !== ts.SyntaxKind.TrueKeyword && v.kind !== ts.SyntaxKind.FalseKeyword)
+                    this.fail(v, `${k} is true or false`);
+                if (v?.kind === ts.SyntaxKind.TrueKeyword)
+                    flags |= bit;
+            }
+            for (const k of p.keys())
+                if (!["event", "canListen", "canApprove", "canReject"].includes(k))
+                    this.fail(e, `a lifecycle check has event, canListen, canApprove and canReject, not ${k}`);
+            out.push({ bytes: [i, flags, 0, 0, 0] });
+        }
+        return out;
+    }
+    /** ExtraAccount: `{ kind: "address", address, isSigner?, isWritable? }` or a preconfigured one (`{ kind: "owner" }`, …). */
+    coreExtraAccount(n) {
+        const p = this.coreProps(n, "an extra account");
+        const kind = p.get("kind");
+        const kinds = ["program", "collection", "owner", "recipient", "asset", "customPda", "address"];
+        const i = kind && ts.isStringLiteral(kind) ? kinds.indexOf(kind.text) : -1;
+        if (i < 0 || i === 5)
+            this.fail(kind ?? n, 'an extra account is { kind: "address", address } or "program", "collection", "owner", "recipient", "asset"');
+        const flag = (k) => {
+            const v = p.get(k);
+            if (v && v.kind !== ts.SyntaxKind.TrueKeyword && v.kind !== ts.SyntaxKind.FalseKeyword)
+                this.fail(v, `${k} is true or false`);
+            return v?.kind === ts.SyntaxKind.TrueKeyword ? 1 : 0;
+        };
+        if (i === 6) {
+            const addr = p.get("address");
+            if (!addr)
+                this.fail(n, "an address extra account needs address");
+            return [{ bytes: [6] }, { value: addr, type: PUBKEY }, { bytes: [flag("isSigner"), flag("isWritable")] }];
+        }
+        return [{ bytes: [i, flag("isSigner"), flag("isWritable")] }];
+    }
+    /**
+     * ExternalPluginAdapterInitInfo from a literal: `{ kind: "AppData", dataAuthority, schema? }`, `{ kind: "Oracle",
+     * baseAddress, checks, resultsOffset?, baseAddressConfig? }`, `{ kind: "LifecycleHook", hookedProgram, checks,
+     * extraAccounts?, dataAuthority?, schema? }` and the Linked forms (collections); `authority?` is the plugin's own.
+     */
+    coreExternalPlugin(n) {
+        const p = this.coreProps(n, "a Core external plugin");
+        const kind = p.get("kind");
+        const kinds = ["LifecycleHook", "Oracle", "AppData", "LinkedLifecycleHook", "LinkedAppData"];
+        const i = kind && ts.isStringLiteral(kind) ? kinds.indexOf(kind.text) : -1;
+        if (i < 0)
+            this.fail(kind ?? n, `a Core external plugin is ${kinds.join(", ")}`);
+        const allowed = {
+            0: ["hookedProgram", "checks", "extraAccounts", "dataAuthority", "schema"],
+            1: ["baseAddress", "checks", "baseAddressConfig", "resultsOffset"],
+            2: ["dataAuthority", "schema"],
+            3: ["hookedProgram", "checks", "extraAccounts", "dataAuthority", "schema"],
+            4: ["dataAuthority", "schema"],
+        };
+        for (const k of p.keys())
+            if (k !== "kind" && k !== "authority" && !allowed[i].includes(k))
+                this.fail(n, `${kinds[i]} takes ${allowed[i].join(", ")} and authority, not ${k}`);
+        const need = (k) => p.get(k) ?? this.fail(n, `${kinds[i]} needs ${k}`);
+        const auth = this.coreOption(p.get("authority"), (x) => this.coreAuthority(x));
+        const schema = this.coreOption(p.get("schema"), (x) => this.coreSchema(x));
+        if (i === 2 || i === 4)
+            return [{ bytes: [i] }, ...this.coreAuthority(need("dataAuthority")), ...auth, ...schema];
+        if (i === 1) {
+            const offset = p.get("resultsOffset");
+            const off = !offset
+                ? [{ bytes: [0] }]
+                : ts.isStringLiteral(offset) && (offset.text === "none" || offset.text === "anchor")
+                    ? [{ bytes: [1, offset.text === "none" ? 0 : 1] }]
+                    : [{ bytes: [1, 2] }, { value: offset, type: U64 }];
+            return [
+                { bytes: [1] },
+                { value: need("baseAddress"), type: PUBKEY },
+                ...auth,
+                ...this.coreChecks(need("checks"), n),
+                ...this.coreOption(p.get("baseAddressConfig"), (x) => this.coreExtraAccount(x)),
+                ...off,
+            ];
+        }
+        const extras = p.get("extraAccounts");
+        if (extras && !ts.isArrayLiteralExpression(extras))
+            this.fail(extras, "extraAccounts is a list of extra accounts");
+        return [
+            { bytes: [i] },
+            { value: need("hookedProgram"), type: PUBKEY },
+            ...auth,
+            ...this.coreChecks(need("checks"), n),
+            ...(extras ? [{ bytes: [1, extras.elements.length & 0xff, 0, 0, 0] }, ...extras.elements.flatMap((e) => this.coreExtraAccount(e))] : [{ bytes: [0] }]),
+            ...this.coreOption(p.get("dataAuthority"), (x) => this.coreAuthority(x)),
+            ...schema,
+        ];
+    }
+    /** ExternalPluginAdapterKey: `{ kind: "AppData", dataAuthority }`, `{ kind: "Oracle", address }`, `{ kind: "LifecycleHook", address }`, … */
+    coreExternalKey(n) {
+        const p = this.coreProps(n, "a Core external plugin key");
+        const kind = p.get("kind");
+        const kinds = ["LifecycleHook", "Oracle", "AppData", "LinkedLifecycleHook", "LinkedAppData"];
+        const i = kind && ts.isStringLiteral(kind) ? kinds.indexOf(kind.text) : -1;
+        if (i < 0)
+            this.fail(kind ?? n, `a Core external plugin key is ${kinds.join(", ")}`);
+        if (i === 2 || i === 4)
+            return [{ bytes: [i] }, ...this.coreAuthority(p.get("dataAuthority") ?? this.fail(n, `${kinds[i]}'s key is its dataAuthority`))];
+        return [
+            { bytes: [i] },
+            { value: p.get("address") ?? this.fail(n, `${kinds[i]}'s key is its address (the oracle's base address or the hooked program)`), type: PUBKEY },
+        ];
+    }
+    /** The data written: Option<Vec<u8>> from a string, a Vec<u8> argument, or null (clears it). */
+    coreExternalData(n) {
+        if (n.kind === ts.SyntaxKind.NullKeyword)
+            return [{ bytes: [0] }];
+        const l = ts.isIdentifier(n) ? this.lookup(n.text) : undefined;
+        if (l?.type.kind === "vecArg") {
+            if (l.type.elem.kind !== "int" || l.type.elem.name !== "u8")
+                this.fail(n, "data is a string, a Vec<u8> argument or null");
+            const t = this.tmp("dl");
+            this.line(`uint32_t ${t} = (uint32_t)${l.c}.len;`);
+            return [{ bytes: [1] }, { c: `&${t}`, n: "4" }, { c: `${l.c}.ptr`, n: `(uint64_t)${t}` }];
         }
-        this.fail(node.expression, `Metaplex Core supports createAsset, createCollection, addPlugin, updatePlugin, removePlugin (and the Collection forms), transferAsset and burnAsset, not ${method}`);
+        return [{ bytes: [1] }, { value: n, type: STRING }];
     }
     /** PluginType (u8) from a kind string literal: removePlugin(…, "FreezeDelegate"). */
     corePluginType(n) {

package/dist/compiler/emit/expressions.d.ts

@@ -32,17 +32,25 @@ export declare abstract class ExpressionEmitter extends StorageEmitter {
         text: string;
         arr?: undefined;
         n?: undefined;
+        only?: undefined;
     } | {
         text?: undefined;
         arr: string;
         n: number;
+        only?: undefined;
+    } | {
+        only: string;
+        text?: undefined;
     };
     /**
      * The text of `${e}` when it is known at compile time: a string literal or constant, a non-negative integer
      * literal, a boolean literal, or a Pubkey constant (its base58). Undefined otherwise.
      */
     protected constantText(e: ts.Expression): string | undefined;
-    protected toText(node: ts.Expression): string;
+    /** `${node}`'s text; `converted.yes` when it was made from a non-string value (new text, not a view of other text). */
+    protected toText(node: ts.Expression, converted?: {
+        yes: boolean;
+    }): string;
     /** C statement writing the decimal text of an integer into the TS_Str `out`. */
     protected textOfInt(name: IntName, c: string, out: string): string;
     /** `c ? a : b` on values: only the chosen branch runs (its checks and side effects included). */

package/dist/compiler/emit/expressions.js

@@ -128,7 +128,7 @@ export class ExpressionEmitter extends StorageEmitter {
         if (ts.isNonNullExpression(node)) {
             const v = this.expr(node.expression, hint && hint.kind !== "option" ? { kind: "option", inner: hint } : hint);
             if (v.type.kind !== "option")
-                this.fail(node, "! works on Option values; check optional accounts with `x !== null`");
+                this.fail(node, "! works on Option values and optional accounts (acct!.field); check other values with `x !== null`");
             return this.unwrap(v, node);
         }
         if (ts.isPropertyAccessExpression(node) && node.questionDotToken)
@@ -154,6 +154,8 @@ export class ExpressionEmitter extends StorageEmitter {
         if (ts.isTemplateExpression(node)) {
             // `a${x}b${y}c`: one join on the heap (or a literal when every piece is known at compile time).
             const pieces = this.templatePieces(node);
+            if (pieces.only !== undefined)
+                return { c: pieces.only, type: STRING };
             if (pieces.text !== undefined)
                 return { c: `ts_str((const uint8_t *)${cString(pieces.text)}, ${Buffer.byteLength(pieces.text, "utf8")})`, type: STRING, stringLiteral: pieces.text };
             const t = this.tmp("tpl");
@@ -171,7 +173,7 @@ export class ExpressionEmitter extends StorageEmitter {
             const l = this.lookup(node.text);
             if (l) {
                 if (l.closure)
-                    this.fail(node, `"${node.text}" is a function: TypeSOL functions are called (${node.text}(…)), not passed around or stored`);
+                    this.fail(node, `"${node.text}" is a function: call it (${node.text}(…)), bind it with const, or pass it to a helper or list method; it cannot be stored or returned as a value`);
                 if (l.type.kind === "array")
                     this.fail(node, `"${node.text}" is an array; use .get(i)`);
                 if (l.type.kind === "vec")
@@ -204,7 +206,7 @@ export class ExpressionEmitter extends StorageEmitter {
             if (this.accounts.has(node.text))
                 this.fail(node, `"${node.text}" is an account; use ${node.text}.key for its address`);
             if (calleeName(node, this.model.helperDecls, this.checker) || this.model.helpers.has(node.text))
-                this.fail(node, `"${node.text}" is a function: TypeSOL functions are called (${node.text}(…)), not passed around or stored`);
+                this.fail(node, `"${node.text}" is a function: call it (${node.text}(…)), bind it with const, or pass it to a helper or list method; it cannot be stored or returned as a value`);
             this.fail(node, `unknown name "${node.text}"`);
         }
         if (ts.isPropertyAccessExpression(node))
@@ -455,16 +457,20 @@ export class ExpressionEmitter extends StorageEmitter {
                 lit(known);
             else {
                 const mark = this.lines.length;
-                const c = this.toText(span.expression);
+                const converted = { yes: false };
+                const c = this.toText(span.expression, converted);
                 for (const p of parts)
                     if (p.c !== undefined)
                         p.c = this.settle({ c: p.c, type: STRING }, mark).c;
-                parts.push({ c });
+                parts.push({ c, converted: converted.yes });
             }
             lit(span.literal.text);
         }
         if (parts.every((p) => p.text !== undefined))
             return { text: parts.map((p) => p.text).join("") };
+        // `${n}` alone: the text a conversion just made (or a constant one) is already a string of its own; no join.
+        if (parts.length === 1 && parts[0].converted)
+            return { only: parts[0].c };
         const strOf = (text) => `ts_str((const uint8_t *)${cString(text)}, ${Buffer.byteLength(text, "utf8")})`;
         const arr = this.tmp("parts");
         this.line(`TS_Str ${arr}[${parts.length}] = {${parts.map((p) => (p.text !== undefined ? strOf(p.text) : p.c)).join(", ")}};`);
@@ -494,10 +500,13 @@ export class ExpressionEmitter extends StorageEmitter {
         }
         return undefined;
     }
-    toText(node) {
+    /** `${node}`'s text; `converted.yes` when it was made from a non-string value (new text, not a view of other text). */
+    toText(node, converted) {
         const v = this.expr(node);
         if (v.type.kind === "string")
             return v.c;
+        if (converted)
+            converted.yes = true;
         if (v.type.kind === "option" && (v.type.inner.kind === "int" || v.type.inner.kind === "bool")) {
             // `${opt}`: the value, or "null" like JS.
             const inner = v.type.inner;
@@ -557,12 +566,7 @@ export class ExpressionEmitter extends StorageEmitter {
             (ts.isBigIntLiteral(node.whenFalse) || ts.isPrefixUnaryExpression(node.whenFalse));
         if (!type && !bothLiteral && (ts.isBigIntLiteral(node.whenTrue) || node.whenTrue.kind === ts.SyntaxKind.NullKeyword)) {
             // Type the non-literal branch first, without emitting it, to give the literal its type.
-            const saved = { lines: this.lines.length, hoisted: this.hoisted.length, temp: this.temp, diagnostics: this.reporter.diagnostics.length };
-            const probe = this.reporter.guard(() => this.expr(node.whenFalse));
-            this.lines.length = saved.lines;
-            this.hoisted.length = saved.hoisted; // a probed helper call may hoist declarations
-            this.temp = saved.temp;
-            this.reporter.diagnostics.length = saved.diagnostics;
+            const probe = this.probe(() => this.expr(node.whenFalse));
             if (probe && probe.literal === undefined && !probe.isNull)
                 type = probe.type;
         }

package/dist/compiler/emit/function.js

@@ -150,14 +150,16 @@ export class FunctionEmitter extends StatementEmitter {
         // The loader passes each account once and marks repeats as duplicates, which share its record (ts_deserialize),
         // so two parameters name the same account exactly when their pointers are equal.
         const writable = ix.accounts.filter((a) => isWritable(a.kind));
+        const pairs = [];
         for (let i = 0; i < writable.length; i++)
             for (let j = i + 1; j < writable.length; j++) {
                 const present = [writable[i], writable[j]]
                     .filter((a) => a.optional)
                     .map((a) => `a_${a.name} && `)
                     .join("");
-                head.push(`  if (${present}a_${writable[i].name} == a_${writable[j].name}) TS_FAIL(TS_ERR_DUPLICATE_MUT, "TypeSOL: ${writable[i].name} and ${writable[j].name} must be different accounts");`);
+                pairs.push(`if (${present}a_${writable[i].name} == a_${writable[j].name}) TS_FAIL(TS_ERR_DUPLICATE_MUT, "TypeSOL: ${writable[i].name} and ${writable[j].name} must be different accounts");`);
             }
+        head.push(...pairs.map((p) => `  ${p}`));
         // Arguments: Borsh, read sequentially (strings make later offsets dynamic).
         if (ix.args.length)
             head.push(`  uint64_t off = ${ix.discriminator.length};`);

package/dist/compiler/emit/shared.d.ts

@@ -75,7 +75,7 @@ export interface Local {
     readonly?: boolean;
     /** For struct / data-enum references: the storage paths they alias (e.g. "book.asks[]"), and the declaration. */
     paths?: string[];
-    decl?: ts.VariableDeclaration;
+    decl?: ts.VariableDeclaration | ts.ParameterDeclaration;
     /** A local closure (`const f = (…) => …` reading the enclosing function's variables), expanded where it is called. */
     closure?: Closure;
 }
@@ -85,6 +85,16 @@ export interface Closure {
     node: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration;
     name: string;
     scopes: Map<string, Local>[];
+    /**
+     * The instruction arguments and accounts its body may name: those where it was written for a closure, none for a
+     * helper or a function a helper made (they see only their parameters and the module).
+     */
+    env: {
+        args: Map<string, Local>;
+        accounts: Map<string, AccountParam>;
+    };
+    /** The `typesol` imports of the file it is written in: its type names mean what they mean there. */
+    imports: Map<string, string>;
 }
 export declare const cBytes: (bytes: number[]) => string;
 /** C expressions that nothing in a TypeSOL expression can change: temporaries, locals, arguments, account keys, constants. */

package/dist/compiler/emit/statements.d.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 import { type FieldType } from "../model.js";
-import { type Value, type Closure } from "./shared.js";
+import { type Value, type Closure, type Ref } from "./shared.js";
 import { CpiEmitter } from "./cpi.js";
 /**
  * Statements: variables, assignment, control flow and return.
@@ -18,6 +18,8 @@ export declare abstract class StatementEmitter extends CpiEmitter {
      * As in JS, the length is read again before every step, so a body that pushes or pops sees the new length.
      */
     protected forOf(stmt: ts.ForOfStatement): void;
+    /** The function an identifier names (a closure, a local function or a helper), as something to expand; else undefined. */
+    protected functionNamed(id: ts.Identifier): Closure | undefined;
     /** `xs.map(…)` / `xs.filter(…)` (or a chain of them): a list built element by element, not stored anywhere yet. */
     protected isPipeline(e: ts.Expression): e is ts.CallExpression;
     /** The list under a chain of map / filter calls, and the calls in the order they run. */
@@ -65,7 +67,7 @@ export declare abstract class StatementEmitter extends CpiEmitter {
      * was declared with, so a block around the call that declares the same name does not change what it reads, and
      * writes to captured `let`s are seen by the enclosing function. Returns the result (undefined for no value).
      */
-    protected expandClosure(c: Closure, args: readonly ts.Expression[], node: ts.Node): Value | undefined;
+    protected expandClosure(c: Closure, args: readonly ts.Expression[], node: ts.Node, into?: Ref): Value | undefined;
     /**
      * `xs.forEach / some / every / find / findIndex / reduce / includes / indexOf` on a Vec, FixedArray, FixedVec or Vec
      * argument: an index loop (the length read each step, as `for … of`), the callback (an arrow written at the call)