@intentius/chant 0.49.0 → 0.50.0

package/src/discovery/param-deps.test.ts

@@ -0,0 +1,118 @@
+import * as ts from "typescript";
+import { describe, expect, test } from "vitest";
+import { collectConsts } from "../fold/fold";
+import { collectParamDependencies } from "./param-deps";
+import type { PathOrigin } from "../provenance";
+
+/**
+ * Collect dependencies for the props of the file's single
+ * `export const x = new Type({...})`, which is the shape every case here uses.
+ */
+function depsOf(source: string, paramLocals = ["params"]): Record<string, PathOrigin> {
+  const file = ts.createSourceFile("fixture.ts", source, ts.ScriptTarget.Latest, true);
+  const consts = collectConsts(file);
+  let props: ts.ObjectLiteralExpression | undefined;
+  for (const statement of file.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    for (const decl of statement.declarationList.declarations) {
+      if (decl.name.getText() !== "x" || !decl.initializer) continue;
+      if (!ts.isNewExpression(decl.initializer)) continue;
+      for (const argument of decl.initializer.arguments ?? []) {
+        if (ts.isObjectLiteralExpression(argument)) {
+          props = argument;
+          break;
+        }
+      }
+    }
+  }
+  if (!props) throw new Error("fixture has no `const x = new Type({...})`");
+  return collectParamDependencies(props, consts, new Set(paramLocals));
+}
+
+const param = (...names: string[]): PathOrigin => ({ kind: "build-param", params: names });
+
+describe("collectParamDependencies", () => {
+  test("a direct read is attributed to its own path", () => {
+    expect(depsOf(`export const x = new Thing({ replicas: params.replicas, name: "fixed" });`)).toEqual({
+      replicas: param("replicas"),
+    });
+  });
+
+  test("nested object literals are descended into, dotted", () => {
+    const source = `export const x = new Thing({ spec: { template: { image: params.image } } });`;
+    expect(depsOf(source)).toEqual({ "spec.template.image": param("image") });
+  });
+
+  test("an expression is attributed to every parameter it can read, not to its value", () => {
+    const source = `export const x = new Thing({ replicas: params.tier === "prod" ? params.big : 1 });`;
+    expect(depsOf(source)).toEqual({ replicas: param("big", "tier") });
+  });
+
+  test("a parameter hoisted into a const is followed to the field that uses it", () => {
+    const source = [
+      `const replicas = params.tier === "prod" ? 5 : 1;`,
+      `export const x = new Thing({ replicas });`,
+    ].join("\n");
+    expect(depsOf(source)).toEqual({ replicas: param("tier") });
+  });
+
+  test("const chains are followed transitively, and a cycle terminates", () => {
+    const source = [
+      `const a = b;`,
+      `const b = \`\${params.region}-\${a}\`;`,
+      `export const x = new Thing({ zone: a });`,
+    ].join("\n");
+    expect(depsOf(source)).toEqual({ zone: param("region") });
+  });
+
+  test("template literals and calls are walked", () => {
+    const source = `export const x = new Thing({ bucket: \`\${params.env}-assets\`.toLowerCase() });`;
+    expect(depsOf(source)).toEqual({ bucket: param("env") });
+  });
+
+  test("an array is attributed whole, never per index", () => {
+    const source = `export const x = new Thing({ containers: [{ image: params.image }, { image: "sidecar" }] });`;
+    expect(depsOf(source)).toEqual({ containers: param("image") });
+  });
+
+  test("a spread is attributed to the object it spreads into", () => {
+    const source = [
+      `const base = { region: params.region };`,
+      `export const x = new Thing({ ...base, spec: { ...base, replicas: 1 } });`,
+    ].join("\n");
+    expect(depsOf(source)).toEqual({ "": param("region"), spec: param("region") });
+  });
+
+  test("bracket access with a literal key names the parameter", () => {
+    expect(depsOf(`export const x = new Thing({ zone: params["region"] });`)).toEqual({ zone: param("region") });
+  });
+
+  test("a property KEY that happens to match a const is not a reference", () => {
+    const source = [`const tier = params.tier;`, `export const x = new Thing({ spec: { tier: "fixed" } });`].join("\n");
+    expect(depsOf(source)).toEqual({});
+  });
+
+  test("a bare reference to the whole params object records nothing", () => {
+    // It names no single parameter; under-reporting is the safe direction.
+    expect(depsOf(`export const x = new Thing({ all: params });`)).toEqual({});
+  });
+
+  test("a file that never imported params records nothing", () => {
+    expect(depsOf(`export const x = new Thing({ replicas: params.replicas });`, [])).toEqual({});
+  });
+
+  test("the local name the import bound is what counts, not the word 'params'", () => {
+    const source = `export const x = new Thing({ replicas: p.replicas, other: params.replicas });`;
+    expect(depsOf(source, ["p"])).toEqual({ replicas: param("replicas") });
+  });
+
+  test("parameter names are sorted and de-duplicated", () => {
+    const source = `export const x = new Thing({ n: params.z + params.a + params.z });`;
+    expect(depsOf(source)).toEqual({ n: param("a", "z") });
+  });
+
+  test("a computed key is skipped rather than guessed at", () => {
+    const source = `export const x = new Thing({ [params.key]: 1, name: params.name });`;
+    expect(depsOf(source)).toEqual({ name: param("name") });
+  });
+});

package/src/discovery/param-deps.ts

@@ -0,0 +1,170 @@
+import * as ts from "typescript";
+import type { PathOrigin } from "../provenance";
+
+/**
+ * Which build parameters an authored props expression READS, per path (chant
+ * #1443) — the declared-side counterpart of `managed-fields.ts`'s per-path live
+ * `owners`.
+ *
+ * This is a syntactic dependency, not a value taint. Fold substitutes
+ * `params.<name>` before anything is emitted, so by output time the value is a
+ * literal and indistinguishable from one typed by hand; tainting the value
+ * through fold's evaluator would mean propagating a tag through every operator
+ * it supports, and one operator that forgot would produce silently wrong
+ * provenance. Recording which parameters the *expression* mentions cannot
+ * degrade that way: a shape this walk does not follow drops a dependency, it
+ * never invents one.
+ *
+ * It also answers the more useful question. For
+ * `replicas: params.tier === "prod" ? 5 : 1`, a taint reports that the value
+ * came from the literal `5` — true, and no help to anyone about to edit the
+ * field. The dependency reports that the field is governed by `tier`.
+ *
+ * Known under-reporting, all in the safe direction: destructured parameters
+ * (`const { tier } = params`) are not tracked, because `collectConsts` only
+ * records identifier bindings; a bare reference to the whole `params` object
+ * names no single parameter and records nothing; and the run path has no
+ * expression to walk at all.
+ *
+ * The one direction it can over-report is a local binding that shadows a
+ * top-level `const` of the same name, since names resolve against the file's
+ * consts without scope tracking. That reports a parameter the field could
+ * plausibly be governed by rather than one it definitely is, which is the
+ * failure the "could affect" reading is written to absorb.
+ */
+
+/** The property name a member declares, when it is a literal one. */
+function literalName(name: ts.PropertyName | undefined): string | undefined {
+  if (!name) return undefined;
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+  return undefined;
+}
+
+/** Strip the wrappers that do not change what an initializer reads. */
+function unwrap(expr: ts.Expression): ts.Expression {
+  let current = expr;
+  for (;;) {
+    if (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isNonNullExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    return current;
+  }
+}
+
+/**
+ * Every parameter name `expr` reads, following this file's own top-level
+ * `const` bindings so a value hoisted into a local is still attributed
+ * (`const replicas = params.tier === "prod" ? 5 : 1` used as `replicas`).
+ */
+function readParams(
+  expr: ts.Expression,
+  consts: ReadonlyMap<string, ts.Expression>,
+  paramLocals: ReadonlySet<string>,
+  out: Set<string>,
+): void {
+  const followed = new Set<string>();
+
+  const visit = (node: ts.Node): void => {
+    if (ts.isPropertyAccessExpression(node)) {
+      if (ts.isIdentifier(node.expression) && paramLocals.has(node.expression.text)) {
+        out.add(node.name.text);
+        return;
+      }
+      visit(node.expression);
+      return;
+    }
+
+    if (ts.isElementAccessExpression(node)) {
+      if (ts.isIdentifier(node.expression) && paramLocals.has(node.expression.text)) {
+        if (ts.isStringLiteralLike(node.argumentExpression)) out.add(node.argumentExpression.text);
+      } else {
+        visit(node.expression);
+      }
+      visit(node.argumentExpression);
+      return;
+    }
+
+    if (ts.isIdentifier(node)) {
+      // A bare `params` names no single parameter — see the under-reporting
+      // note above.
+      if (paramLocals.has(node.text)) return;
+      const initializer = consts.get(node.text);
+      if (initializer && !followed.has(node.text)) {
+        followed.add(node.text);
+        visit(initializer);
+      }
+      return;
+    }
+
+    // A property KEY is not a reference; without this a nested `{ tier: 1 }`
+    // would resolve `tier` against `consts` and manufacture a dependency.
+    if (ts.isPropertyAssignment(node)) {
+      visit(node.initializer);
+      return;
+    }
+
+    ts.forEachChild(node, visit);
+  };
+
+  visit(expr);
+}
+
+/**
+ * Path → build-parameter origin for one resource's props object literal.
+ *
+ * Paths are dotted property names only, per `EntityProvenance.paths`: an object
+ * literal is descended into, and anything else — an array literal included — is
+ * attributed whole at its own path. An array's elements are deliberately not
+ * indexed, because an index-shaped key would not survive an element moving and
+ * would not match the `[#key]` addressing a diff uses.
+ *
+ * A spread is attributed to the object it spreads INTO, at that object's own
+ * path (the entity root for a top-level spread), since which keys it
+ * contributes is not knowable here.
+ */
+export function collectParamDependencies(
+  props: ts.ObjectLiteralExpression,
+  consts: ReadonlyMap<string, ts.Expression>,
+  paramLocals: ReadonlySet<string>,
+): Record<string, PathOrigin> {
+  const out: Record<string, PathOrigin> = {};
+  if (paramLocals.size === 0) return out;
+
+  const record = (path: string, expr: ts.Expression): void => {
+    const found = new Set<string>();
+    readParams(expr, consts, paramLocals, found);
+    if (found.size === 0) return;
+    const existing = out[path];
+    const merged =
+      existing && existing.kind === "build-param" ? new Set([...existing.params, ...found]) : found;
+    out[path] = { kind: "build-param", params: [...merged].sort() };
+  };
+
+  const walk = (object: ts.ObjectLiteralExpression, prefix: string): void => {
+    for (const member of object.properties) {
+      if (ts.isSpreadAssignment(member)) {
+        record(prefix, member.expression);
+        continue;
+      }
+      if (ts.isShorthandPropertyAssignment(member)) {
+        const key = member.name.text;
+        record(prefix ? `${prefix}.${key}` : key, member.name);
+        continue;
+      }
+      if (!ts.isPropertyAssignment(member)) continue;
+      const key = literalName(member.name);
+      if (key === undefined) continue;
+      const path = prefix ? `${prefix}.${key}` : key;
+      const initializer = unwrap(member.initializer);
+      if (ts.isObjectLiteralExpression(initializer)) {
+        walk(initializer, path);
+        continue;
+      }
+      record(path, member.initializer);
+    }
+  };
+
+  walk(props, "");
+  return out;
+}

package/src/fold/fold.test.ts

@@ -435,7 +435,11 @@ describe("fold — registered call-form intrinsics (#1044)", () => {
     expect(() => fold(expr, consts, [REF])).toThrow(FoldError);
   });
 
-  test("an array method taking a closure is rejected — .map is arbitrary JS, not a registered intrinsic", () => {
+  test("an array method taking a closure is rejected — the closure argument, not .map itself, is what fails (chant #1966)", () => {
+    // chant #1966 — `.map` is now attempted (a real method on a real folded
+    // array), so the rejection moves from "no case for this call" to the
+    // closure argument itself: a function used as a value is never foldable,
+    // with or without a registered intrinsic inside it.
     const consts = parseConsts(`const cidrs = ["10.0.0.0/24"]; const x = cidrs.map((c) => Ref(c));`);
     const expr = consts.get("x");
     if (!expr) throw new Error("fixture error");
@@ -446,7 +450,7 @@ describe("fold — registered call-form intrinsics (#1044)", () => {
       error = e;
     }
     expect(error).toBeInstanceOf(FoldError);
-    expect((error as FoldError).message).toContain("cidrs.map(...)");
+    expect((error as FoldError).message).toContain("a function used as a value is not foldable");
   });
 
   test("a user-defined function is rejected however it's named", () => {

package/src/fold/fold.ts

@@ -1,6 +1,6 @@
 import * as ts from "typescript";
 import { relative } from "node:path";
-import { intrinsicCallFolds, intrinsicTagFolds, type IntrinsicDef } from "../lexicon";
+import { intrinsicCallFolds, intrinsicCallFoldsEagerly, intrinsicTagFolds, type IntrinsicDef } from "../lexicon";
 import {
   SUPPORTED_BINARY_OPERATORS,
   SUPPORTED_UNARY_OPERATORS,
@@ -67,7 +67,27 @@ import { isFoldableHelperName } from "./foldable-helpers";
  * folds its body against the defining module's scope with the folded
  * arguments bound. Still nothing is imported or run.
  *
- * Everything else — a package's function, a method call, an array `.map`, a
+ * A bare composite factory call (`Checkout({...})` on its own) is still out
+ * of scope (epic Phase 5, #1023 covers only interpreting a factory's OWN
+ * body, not consuming its result as a value elsewhere). chant #1174 adds one
+ * narrow exception at the PROPERTY-ACCESS level rather than here: the
+ * `<Identifier>(...).step` idiom — see {@link FoldedCompositeStepCall} on the
+ * property-access branch below. A call with no `.step` narrowing, or any
+ * other member, still throws from this branch exactly as before.
+ *
+ * chant #1966 adds a fourth call shape, and a method call on top of any of
+ * the four: a lexicon-package function its lexicon registered with
+ * {@link intrinsicCallFoldsEagerly} (../lexicon.ts) evaluates eagerly —
+ * unlike the other three, which envelope for later revival — because its
+ * usual use (`` `${matrix("os")}` ``) coerces the result via `String()` at
+ * fold time, before any revival would run. A `CallExpression` whose callee is
+ * a property access — `github.actor.toString()`, `[...].join(",")`,
+ * `matrix("os").toString()` — folds its receiver and calls the named method
+ * on it directly, PROVIDED the receiver is a real value and not one of
+ * fold's own symbolic envelopes (see {@link isFoldSymbolicEnvelope}); nothing
+ * about the method name is otherwise restricted.
+ *
+ * Everything else — an ordinary package function, an array `.map`, a
  * registered name shadowed by a local binding — still throws.
  *
  * Cross-file identifier resolution (chant #1020): `consts` alone is always
@@ -105,7 +125,8 @@ export type FoldedValue =
   | FoldedIntrinsic
   | FoldedHelperCall
   | SymbolicValue
-  | FoldedResource;
+  | FoldedResource
+  | FoldedCompositeStepCall;
 
 /**
  * Symbolic reference produced when a property/element access resolves to an
@@ -225,6 +246,40 @@ export interface FoldedResource {
   args?: FoldedValue[];
 }
 
+/**
+ * The result of folding the `<Identifier>(...).step` composite-consumer
+ * idiom (chant #1174) — `Checkout({...}).step`, `SetupNode({...}).step`,
+ * every lexicon's single-action `Composite()` wrapper embedded inline in a
+ * `Job`'s `steps` array, exactly as composites.mdx documents it. This is the
+ * SAME shape chant #1544 already carved out of EVL001 as a documented,
+ * correct fallback rather than a lint error
+ * ({@link "./subset"}'s `allowCompositeStepAccess`) — `fold()` never set
+ * that flag, so before this it fell back to run every time, as designed.
+ * This is the fold-side counterpart that actually reduces it instead.
+ *
+ * Symbolic, exactly like {@link FoldedIntrinsic}/{@link FoldedHelperCall}:
+ * `fold()` executes nothing here. It records which composite factory the
+ * source named, its folded arguments (in source order), and that the result
+ * was immediately narrowed to `.step`. ../discovery/fold-import.ts's bridge
+ * resolves the callee through the folding file's own imports — a
+ * project-file registered `Composite` is interpreted (chant #1023's existing
+ * machinery), anything else (every lexicon-package composite, which is what
+ * `Checkout`/`SetupNode` are) is imported and invoked for real, exactly as a
+ * top-level `export const x = Checkout({...})` already does via
+ * `resolveCallExpression` — and then reads `.step` off the REAL result.
+ *
+ * Deliberately narrower than "any call, any member access": the member name
+ * is fixed to `"step"`, matching the one idiom ../fold/subset.ts's EVL
+ * carve-out already permits. `fold()` may never accept a shape EVL doesn't
+ * (see that module's doc, point 2c, for the direction it is not allowed to
+ * be wrong in) — widening past `.step` here without widening the shared
+ * predicate in lockstep would open exactly that gap.
+ */
+export interface FoldedCompositeStepCall {
+  __compositeStep: string;
+  args: FoldedValue[];
+}
+
 /**
  * One entry per exported `const` resource declaration in {@link foldModule}'s
  * result. The `ok: false` case surfaces the same located, rule-id-tagged
@@ -648,11 +703,57 @@ function resolvesToResource(consts: Map<string, ts.Expression>, ident: ts.Identi
   return init !== undefined && ts.isNewExpression(init);
 }
 
+/**
+ * True when `node` is a call through a bare identifier that isn't ALREADY
+ * one of `fold()`'s other three call shapes — a registered authoring helper,
+ * a registered call-form intrinsic, or a project-local {@link FoldableFunction}
+ * — i.e. exactly the callee the `CallExpression` branch below would
+ * otherwise throw {@link callExpressionMessage} for. Used only by the
+ * `.step` narrowing in the property-access branch (chant #1174,
+ * {@link FoldedCompositeStepCall}): checked from the OUTSIDE, at the
+ * property-access node, so `Checkout({...})` alone (no `.step`) still falls
+ * through to the ordinary `CallExpression` throw, unchanged.
+ */
+function isUnclaimedBareCall(
+  node: ts.Expression,
+  consts: Map<string, ts.Expression>,
+  intrinsics: readonly IntrinsicDef[],
+  externals?: ReadonlyMap<string, unknown>,
+): node is ts.CallExpression {
+  if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) return false;
+  const name = node.expression.text;
+  if (consts.has(name)) return false;
+  if (isFoldableHelperName(name)) return false;
+  if (intrinsics.some((i) => i.name === name && intrinsicCallFolds(i))) return false;
+  if (isFoldableFunction(externals?.get(name))) return false;
+  return true;
+}
+
 /** True when a folded value is a {@link FoldedResource} envelope (a `new Type(...)` that nothing constructed yet). */
 function isFoldedResource(value: FoldedValue): value is FoldedResource {
   return typeof value === "object" && value !== null && !Array.isArray(value) && "__resource" in value;
 }
 
+/**
+ * True when `value` is one of `fold()`'s own symbolic envelope shapes — a
+ * stand-in for a value nothing has constructed or revived yet, not the value
+ * itself. A method call (see the `CallExpression` branch's property-access
+ * case below) must refuse one rather than silently falling through to
+ * `Object.prototype`'s own inherited methods — `toString` chief among them —
+ * which would answer with the placeholder's shape instead of what the real,
+ * eventually-revived value would produce.
+ */
+function isFoldSymbolicEnvelope(value: FoldedValue): boolean {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  return (
+    "__attrRef" in value ||
+    "__intrinsic" in value ||
+    "__helper" in value ||
+    "__resource" in value ||
+    "__compositeStep" in value
+  );
+}
+
 /**
  * chant #1535 — an attribute read whose object folded to a resource ENVELOPE
  * rather than resolving through {@link resolvesToResource}. That happens when
@@ -892,6 +993,15 @@ export function fold(
         if (isFoldableFunction(external)) {
           throw foldError(node, `function "${node.text}" used as a value is not foldable`);
         }
+        // chant #1966 — a registered eager-fold lexicon helper (see the
+        // CallExpression branch below) is callable, never a bare value:
+        // nothing downstream can serialize a function.
+        if (
+          typeof external === "function" &&
+          intrinsics.some((i) => i.name === node.text && intrinsicCallFoldsEagerly(i))
+        ) {
+          throw foldError(node, `function "${node.text}" used as a value is not foldable — call it instead`);
+        }
         return external as FoldedValue;
       }
       // chant #1064 — a bare `process` reference is ALWAYS an ambient
@@ -948,6 +1058,21 @@ export function fold(
     if (ts.isIdentifier(node.expression) && resolvesToResource(consts, node.expression)) {
       return { __attrRef: { entity: node.expression.text, attribute: node.name.text } };
     }
+    // chant #1174 — `<Identifier>(...).step`, the composite-consumer idiom
+    // (`Checkout({...}).step`) — see FoldedCompositeStepCall's doc. Checked
+    // here, at the property-access node, rather than inside the
+    // CallExpression branch: a bare `Checkout({...})` with no `.step` still
+    // has no case there and throws exactly as before.
+    if (node.name.text === "step" && isUnclaimedBareCall(node.expression, consts, intrinsics, externals)) {
+      const call = node.expression;
+      const calleeName = (call.expression as ts.Identifier).text;
+      const inside = insideFunctionBody(node, `composite call \`${calleeName}(...).step\``);
+      if (inside) throw inside;
+      return {
+        __compositeStep: calleeName,
+        args: call.arguments.map((arg) => fold(arg, consts, intrinsics, externals)),
+      };
+    }
     const obj = fold(node.expression, consts, intrinsics, externals);
     if (obj === null || obj === undefined) return undefined;
     if (isFoldedResource(obj)) return attrRefOnFoldedResource(node, node.name.text);
@@ -1146,6 +1271,62 @@ export function fold(
       }
     }
 
+    // chant #1966 — the fourth call shape: a lexicon-package function its
+    // lexicon registered with {@link intrinsicCallFoldsEagerly} (../lexicon.ts),
+    // resolved into `externals` by ../discovery/fold-import.ts's
+    // `resolveActiveLexiconExport` exactly like a plain data export
+    // (`Azure.ResourceGroupLocation`, chant #1063), except callable. Unlike
+    // the intrinsic-call shape above, this one is EVALUATED right here rather
+    // than enveloped: a lexicon's own string-building helper (`matrix("os")`,
+    // github lexicon) is typically embedded directly in a template literal
+    // (`` `${matrix("os")}` ``), which coerces its result via native
+    // `String()` at fold time — an envelope deferred to later revival would
+    // stringify as "[object Object]" there. Evaluating eagerly, with the
+    // folded arguments, produces the real, already-live return value instead
+    // — the same guarantee a live external's own getter execution already
+    // gives {@link fold}'s property-access branch.
+    if (
+      ts.isIdentifier(node.expression) &&
+      !consts.has(node.expression.text) &&
+      intrinsics.some((i) => i.name === (node.expression as ts.Identifier).text && intrinsicCallFoldsEagerly(i))
+    ) {
+      const callee = externals?.get(node.expression.text);
+      if (typeof callee !== "function") {
+        throw foldError(node, `"${node.expression.text}" did not resolve to a function — falls back to run`);
+      }
+      const args = node.arguments.map((arg) => fold(arg, consts, intrinsics, externals));
+      return (callee as (...callArgs: unknown[]) => unknown)(...args) as FoldedValue;
+    }
+
+    // chant #1966 — a method call whose RECEIVER is itself foldable: property
+    // access on a live external (`github.actor.toString()`), a call folded by
+    // one of the shapes above (`matrix("os").toString()`), or fold's own
+    // array/object literal (`[...].join(",")`). The method is never checked
+    // by name — only that the receiver is a REAL value (not one of fold's own
+    // symbolic envelopes, see {@link isFoldSymbolicEnvelope}) and that the
+    // named property on it is actually a function. Calling it with the folded
+    // arguments is then no different from what running the file would do:
+    // the receiver is the same real object either way.
+    if (ts.isPropertyAccessExpression(node.expression)) {
+      const methodName = node.expression.name.text;
+      const receiver = fold(node.expression.expression, consts, intrinsics, externals);
+      if (receiver === null || receiver === undefined) {
+        throw foldError(node, `cannot call ".${methodName}(...)" on ${String(receiver)}`);
+      }
+      if (isFoldSymbolicEnvelope(receiver)) {
+        throw foldError(
+          node,
+          `method call \`.${methodName}(...)\` on an unresolved value is not foldable — falls back to run`,
+        );
+      }
+      const method = (receiver as Record<string, unknown>)[methodName];
+      if (typeof method !== "function") {
+        throw foldError(node, `"${methodName}" is not a callable method on the folded value — falls back to run`);
+      }
+      const args = node.arguments.map((arg) => fold(arg, consts, intrinsics, externals));
+      return (method as (...methodArgs: unknown[]) => unknown).apply(receiver, args) as FoldedValue;
+    }
+
     throw foldError(node, callExpressionMessage(node));
   }