@intentius/chant 0.124.31 → 0.124.33

package/src/components/wave-plan.ts

@@ -13,6 +13,14 @@
  * (`componentPlanDigest`, ./gate-plan.ts, #2574), so a wave mixing roots and
  * other components still has one digest that moves when any of them does.
  *
+ * The files a step without a `plan` deploys from are bound too (#4155,
+ * ./deploy-inputs.ts). A component with no plannable step folds them into its
+ * composition digest. A component with one gets a member more,
+ * `<component>#inputs`, over its other steps' files, so a `lambda-deploy`
+ * source or a Helm chart beside a `cfn-deploy` moves the wave's digest. A step
+ * whose content chant can't name is a hole on that member, so the plan note
+ * lists it as unbound.
+ *
  * Known limit: a step input that reads an earlier step of the same
  * component (`@Phase.field`) has no value before the component runs, so it
  * plans as `undefined`. Cross-component wiring (`stackOutput()`,
@@ -21,7 +29,9 @@
 
 import { resolveStepInput, unresolvedWiringSources, type DriverComponent, type DriverPhase, type DriverStep } from "./driver";
 import { componentPlanDigest } from "./gate-plan";
-import type { CapabilityRegistry, DeployContext } from "./capability";
+import { componentDeployInputs, type ComponentDeployInputs } from "./deploy-inputs";
+import { computePlanDigest } from "../lifecycle/plan-digest";
+import type { CapabilityRegistry, DeployContext, PlannedOutputs } from "./capability";
 import type { WaveMember } from "../gated-waves";
 import type { ChangeSetPart } from "../change-set";
 
@@ -29,20 +39,26 @@ import type { ChangeSetPart } from "../change-set";
  * What planning one component produced: its members, what its steps hand to
  * `run`, and each member's change-set part (#3183), or why it could not plan.
  * A member whose capability returns no part gets one with no entries, so the
- * parts always cover the members.
+ * parts always cover the members. `outputs` is what its steps' plans say the
+ * component will expose once applied (#3999), merged the way the driver
+ * merges a run's outputs; absent when no step's plan says.
  */
 export type WaveComponentPlan =
-  | { component: string; members: WaveMember[]; plans: Record<string, unknown>; parts: ChangeSetPart[] }
+  | { component: string; members: WaveMember[]; plans: Record<string, unknown>; parts: ChangeSetPart[]; outputs?: PlannedOutputs }
   | { component: string; error: string };
 
-/** A part with no entries, for a member whose planner describes no changes. */
-function emptyPart(member: WaveMember): ChangeSetPart {
+/** A part with no entries, for a member whose planner describes no changes. `unbound` steps become its holes (#4155). */
+function emptyPart(member: WaveMember, unbound: ComponentDeployInputs["unbound"] = []): ChangeSetPart {
+  const holes = unbound.map((u) => ({ address: `${u.phase}/${u.kind}`, type: u.kind, reason: `unbound: ${u.reason}` }));
   return {
-    member: { member: member.member, lexicon: "chant", planner: "chant", status: "planned", planDigest: member.planDigest, holes: [] },
+    member: { member: member.member, lexicon: "chant", planner: "chant", status: "planned", planDigest: member.planDigest, holes },
     entries: [],
   };
 }
 
+/** The member a planning component's other steps add (#4155): their files, under the component's name. */
+export const inputsMemberName = (component: string): string => `${component}#inputs`;
+
 /** Every capability step in a composition, nested phases included, gates left out. */
 export function capabilitySteps(phases: readonly DriverPhase[]): DriverStep[] {
   const out: DriverStep[] = [];
@@ -84,6 +100,7 @@ export async function planWaveComponent(
     const members: WaveMember[] = [];
     const plans: Record<string, unknown> = {};
     const parts: ChangeSetPart[] = [];
+    let outputs: PlannedOutputs | undefined;
     for (const step of capabilitySteps(component.deploy)) {
       const capability = registry.resolve(step.kind);
       if (!capability.plan) continue;
@@ -94,25 +111,48 @@ export async function planWaveComponent(
       members.push(member);
       parts.push(planned.changeSet ?? emptyPart(member));
       if (planned.artifact !== undefined) plans[planned.member] = planned.artifact;
+      if (planned.outputs) outputs = mergePlannedOutputs(outputs, planned.outputs);
     }
+    // #4155: the steps without a plan, which no member above covers.
+    const planless = (step: DriverStep): boolean => !registry.has(step.kind) || registry.resolve(step.kind).plan === undefined;
     if (members.length === 0) {
+      const read = componentDeployInputs(component.deploy, process.cwd());
       const member = {
         member: component.name,
         planDigest: componentPlanDigest({
           environment: ctx.env,
           component,
           ...(ctx.vars ? { vars: ctx.vars } : {}),
+          inputs: read.inputs,
         }),
       };
       members.push(member);
-      parts.push(emptyPart(member));
+      parts.push(emptyPart(member, read.unbound));
+    } else {
+      const read = componentDeployInputs(component.deploy, process.cwd(), planless);
+      if (read.inputs.length > 0 || read.unbound.length > 0) {
+        const member = {
+          member: inputsMemberName(component.name),
+          planDigest: computePlanDigest("component-inputs", { environment: ctx.env, component: component.name, inputs: read.inputs }),
+        };
+        members.push(member);
+        parts.push(emptyPart(member, read.unbound));
+      }
     }
-    return { component: component.name, members, plans, parts };
+    return { component: component.name, members, plans, parts, ...(outputs ? { outputs } : {}) };
   } catch (err) {
     return { component: component.name, error: err instanceof Error ? err.message : String(err) };
   }
 }
 
+/** `next` over `prior`, as a later step's outputs win over an earlier one's in a run. */
+function mergePlannedOutputs(prior: PlannedOutputs | undefined, next: PlannedOutputs): PlannedOutputs {
+  const known = { ...(prior?.known ?? {}), ...next.known };
+  const unknown = new Set([...(prior?.unknown ?? []).filter((n) => !(n in next.known)), ...next.unknown]);
+  for (const n of unknown) delete known[n];
+  return { known, unknown: [...unknown].sort() };
+}
+
 /**
  * The outputs `component` exposes now, read from each step whose capability
  * has `outputs` (#3183), merged the way the driver merges a run's outputs.

package/src/discovery/fold-host-method.test.ts

@@ -0,0 +1,87 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { foldProject } from "../index";
+
+/**
+ * chant#4011 — a method call reached `Function`, so a file reporting
+ * `[fold:fold]` could put the clock, `process.env` or `Math.random()` in its
+ * output. The issue's repro and its variants now get a `run` verdict, and a
+ * file of listed host methods folds to the same bytes whatever the
+ * environment says.
+ */
+describe("a folded file cannot reach host behaviour through a method call (chant#4011)", () => {
+  let root: string;
+  const saved = { HOME: process.env.HOME, TZ: process.env.TZ };
+
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "chant-4011-"));
+  });
+
+  afterEach(() => {
+    process.env.HOME = saved.HOME;
+    if (saved.TZ === undefined) delete process.env.TZ;
+    else process.env.TZ = saved.TZ;
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  async function verdictOf(source: string) {
+    const file = join(root, "c.ts");
+    writeFileSync(file, source);
+    return (await foldProject([file], [], {})).get(file)!;
+  }
+
+  const cases: Record<string, string> = {
+    "the issue's repro": [
+      "export const cfg = {",
+      '  stamp: [].constructor.constructor("return String(Date.now())").call(),',
+      '  home: `${[].constructor.constructor("return process.env.HOME").call()}`,',
+      "};",
+    ].join("\n"),
+    "Math.random": 'export const cfg = { r: [].constructor.constructor("return Math.random()").call() };',
+    "process.env": 'export const cfg = { h: [].constructor.constructor("return process.env.HOME").call() };',
+    "new Date(...).toString()":
+      'export const cfg = { d: [].constructor.constructor("return new Date(0).toString()").call() };',
+    toLocaleString: "export const cfg = { n: (1234567.891).toLocaleString() };",
+    "Function through a prototype chain":
+      'export const cfg = { p: "".__proto__.constructor.constructor("return String(Date.now())").call() };',
+    "Function under an unlisted name":
+      'const o = { f: [].constructor.constructor };\nexport const cfg = { q: o.f("return 1") };',
+  };
+
+  for (const [name, source] of Object.entries(cases)) {
+    test(`${name}: run, not fold`, async () => {
+      const verdict = await verdictOf(source);
+      expect(verdict.verdict).toBe("run");
+      expect(verdict.reason).toBeDefined();
+    });
+  }
+
+  test("listed host methods fold to identical output under a different HOME and TZ", async () => {
+    const source = [
+      "const parts = ['a', 'b', 'c'];",
+      "export const cfg = {",
+      "  name: parts.join('-'),",
+      "  tail: 'x.y.z'.split('.').slice(1).join('/'),",
+      "  pi: (3.14159).toFixed(2),",
+      "  upper: 'chant'.toUpperCase(),",
+      "};",
+    ].join("\n");
+
+    process.env.HOME = "/tmp/h1";
+    process.env.TZ = "UTC";
+    const first = await verdictOf(source);
+    process.env.HOME = "/tmp/h2";
+    process.env.TZ = "Asia/Kolkata";
+    const second = await verdictOf(source);
+
+    expect(first.verdict).toBe("fold");
+    expect(second.verdict).toBe("fold");
+    const bytes = (v: typeof first) => JSON.stringify(Object.fromEntries(v.exports!));
+    expect(bytes(first)).toBe(bytes(second));
+    expect(JSON.parse(bytes(first))).toEqual({
+      cfg: { name: "a-b-c", tail: "y/z", pi: "3.14", upper: "CHANT" },
+    });
+  });
+});

package/src/discovery/fold-import.ts

@@ -28,6 +28,7 @@ import {
 } from "../fold/fold";
 import { isChantOwnedSpecifier, isFoldableHelperName } from "../fold/foldable-helpers";
 import { lexiconModulePath, lexiconModuleRoot } from "../lexicon-module";
+import { compiledModuleSource } from "../module-source";
 import {
   isFile,
   packageExportsTarget,
@@ -2050,10 +2051,11 @@ function isUnfoldableSameFileCall(name: string, ctx: ResolveCtx): boolean {
 //     specifier, or its package root for a subpath, against
 //     {@link FoldSession.lexiconPackages}, exactly as
 //     {@link isTrustedExecutableBinding}'s arm 1 matches it — and only then
-//     resolved; a module that resolves to compiled JavaScript or a declaration
-//     file is not interpreted, so a package that ships only `dist` keeps
-//     invoking. Every chant lexicon routes its exports at `./src/*.ts`
-//     (check-lexicon tier 1), so in practice the source is always there.
+//     resolved; a module that resolves to a declaration file, or to compiled
+//     JavaScript with no `src/` source beside its `dist/`, is not interpreted,
+//     so a package that ships only `dist` keeps invoking. Every chant lexicon
+//     publishes `src/` beside the `dist/*.js` its exports name (#3981), and
+//     a compiled module is read from that source.
 //     Interpreting buys provenance: the run path cannot say which parameter
 //     fed a field, and interpretation can (#2161, #3246).
 //
@@ -2478,7 +2480,15 @@ function factoryOrigin(specifier: string, fromFile: string, ctx: ResolveCtx): Fa
   } catch {
     return undefined;
   }
-  if (!isTypeScriptSource(modulePath)) return undefined;
+  if (!isTypeScriptSource(modulePath)) {
+    // #3981 — a lexicon's exports resolve to the compiled dist/*.js it
+    // publishes, beside the src/ it was built from. The source is what is
+    // read; an import the body makes still loads the compiled module, since
+    // the compiled CLI points a lexicon's src/*.ts at its dist/*.js.
+    const source = compiledModuleSource(modulePath);
+    if (source === undefined || !isFile(source)) return undefined;
+    modulePath = source;
+  }
   const packageRoot = lexiconPackageDirectory(modulePath, packageName);
   return packageRoot === undefined ? undefined : { modulePath, packageRoot };
 }

package/src/discovery/fold-package-composite.test.ts

@@ -238,6 +238,33 @@ describe("lexicon-package and re-exported composites are interpreted (chant#3247
     expect(foldExecutionCounts().factoryInterpretations).toBe(0);
   });
 
+  test("a package whose exports name compiled JavaScript is interpreted from the src/ it ships beside dist/ (#3981)", async () => {
+    // As a chant lexicon publishes: exports on dist/*.js, the source under src/.
+    await installFakeLexicon(
+      "fakedist3981",
+      {
+        "dist/index.js": `export * from "./composites/index.js";\n`,
+        "dist/composites/index.js": `export * from "./web.js";\n`,
+        "dist/composites/web.js": `throw new Error("the compiled module is not read");\n`,
+        "src/index.ts": `export * from "./composites/index";\n`,
+        "src/composites/index.ts": `export * from "./web";\n`,
+        "src/composites/web.ts": WEBAPP_DEFINITION,
+      },
+      "./dist/index.js",
+    );
+    await writeFile(
+      join(srcDir, "main.ts"),
+      `import { WebApp } from "@intentius/chant-lexicon-fakedist3981";\nexport const web = WebApp({ name: "data" });\n`,
+    );
+
+    const result = await discover(srcDir, { fold: true, lexicons: ["aws", "fakedist3981"] });
+
+    expect(result.errors).toEqual([]);
+    expect(moduleRan(), "the defining module was read, never imported").toBeUndefined();
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 1, factoryInvocations: 0 });
+    expect([...result.entities.keys()]).toEqual(["webBucket"]);
+  });
+
   test("a package re-export that leaves the package's directory is not followed", async () => {
     await mkdir(join(testDir, "shared"), { recursive: true });
     await writeFile(join(testDir, "shared", "web.ts"), WEBAPP_DEFINITION);

package/src/discovery/fold-specifiers.test.ts

@@ -188,4 +188,12 @@ describe("packageExportsTarget (chant#3090)", () => {
     expect(packageExportsTarget("./index.js", "./sub")).toBeUndefined();
     expect(packageExportsTarget({ import: "./index.js" }, "./sub")).toBeUndefined();
   });
+  test("from source, a lexicon's development export wins over the dist/*.js its default names (#3981)", () => {
+    const lexicon = {
+      ".": { development: "./src/index.ts", types: "./dist/index.d.ts", default: "./dist/index.js" },
+      "./*": { development: "./src/*.ts", types: "./dist/*.d.ts", default: "./dist/*.js" },
+    };
+    expect(packageExportsTarget(lexicon, ".")).toBe("./src/index.ts");
+    expect(packageExportsTarget(lexicon, "./generated/index")).toBe("./src/generated/index.ts");
+  });
 });

package/src/discovery/sandbox/bundle.ts

@@ -3,6 +3,7 @@ import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync,
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve as resolvePath } from "node:path";
+import { SOURCE_EXPORT_CONDITIONS } from "../../module-source";
 
 /**
  * chant #1045 Phase 2 — bundles the generated sandbox driver (`./driver.ts`)
@@ -219,6 +220,11 @@ export async function bundleDriver(driverSource: string): Promise<BundleResult>
       format: "esm",
       absWorkingDir: bundleDir,
       logLevel: "silent",
+      // #3981 — from source, a lexicon bundles from its src/*.ts, as the
+      // unsandboxed build imports it; compiled, from the dist/*.js it ships.
+      // Setting `conditions` replaces esbuild's default ["module"], so it is
+      // kept, and compiled the option is left out as before.
+      ...(SOURCE_EXPORT_CONDITIONS.length > 0 ? { conditions: ["module", ...SOURCE_EXPORT_CONDITIONS] } : {}),
       plugins: [plugin],
     });
   } catch (err) {

package/src/discovery/specifier-resolve.ts

@@ -24,6 +24,7 @@
 import * as ts from "typescript";
 import { readFileSync, statSync } from "node:fs";
 import { dirname, extname, isAbsolute, join, resolve as resolvePath } from "node:path";
+import { SOURCE_EXPORT_CONDITIONS } from "../module-source";
 
 /** True when `path` is an existing regular file. */
 export function isFile(path: string): boolean {
@@ -89,8 +90,13 @@ export function splitBareSpecifier(specifier: string): { name: string; subpath:
   return { name, subpath: rest === "" ? "." : `./${rest}` };
 }
 
-/** The conditions an ESM import in Node matches, which is what the run path does. */
-const EXPORT_CONDITIONS: ReadonlySet<string> = new Set(["import", "node", "default"]);
+/**
+ * The conditions an ESM import in Node matches, which is what the run path
+ * does. From source, `development` too (#3981): the run path there resolves a
+ * chant package to its `src/*.ts`, not to the compiled `dist/*.js` its
+ * `default` names.
+ */
+const EXPORT_CONDITIONS: ReadonlySet<string> = new Set(["import", "node", "default", ...SOURCE_EXPORT_CONDITIONS]);
 
 /**
  * The target an `exports` value selects, with `star` substituted for each `*`

package/src/fold/fold.test.ts

@@ -1375,3 +1375,75 @@ describe("fold — same-file functions without externals (chant#2436)", () => {
     expect(() => fold(consts.get("x")!, consts, [], new Map())).toThrow(FoldError);
   });
 });
+
+// chant#4011 — since #1966 a method call folded whenever the receiver was real
+// and the property was a function, so `.constructor.constructor` reached
+// `Function` and a folded file could read the clock, the environment or a
+// random number. Each case below folded to a value before the fix.
+describe("fold — a method call cannot reach Function or other host behaviour (#4011)", () => {
+  const refuses = (src: string) => expect(() => foldConst(src, "x")).toThrow(FoldError);
+
+  test("Date.now() through [].constructor.constructor", () => {
+    refuses(`const x = [].constructor.constructor("return String(Date.now())").call();`);
+  });
+
+  test("process.env through [].constructor.constructor", () => {
+    refuses("const x = `${[].constructor.constructor(\"return process.env.HOME\").call()}`;");
+  });
+
+  test("Math.random() through [].constructor.constructor", () => {
+    refuses(`const x = [].constructor.constructor("return Math.random()").call();`);
+  });
+
+  test("Function reached through a prototype chain on a string", () => {
+    refuses(`const x = "".__proto__.constructor.constructor("return Date.now()").call();`);
+  });
+
+  test("Function stored under a name the table does not list", () => {
+    // No refused name appears in the call: `f` is a plain property whose value
+    // is Function, read by property access. The host-method table catches it.
+    refuses(`const o = { f: [].constructor.constructor }; const x = o.f("return 1");`);
+  });
+
+  test("Function stored under a listed name is still refused: the table checks identity", () => {
+    refuses(`const o = { toString: [].constructor.constructor }; const x = o.toString("return 1");`);
+  });
+
+  test("a static method on a host constructor has no row", () => {
+    refuses(`const A = [].constructor; const x = A.of(1, 2);`);
+  });
+
+  test("a function passed to a listed host method is refused", () => {
+    refuses(`const x = "abc".replace("b", [].constructor);`);
+  });
+
+  test("toLocaleString follows the host locale and is refused", () => {
+    refuses(`const x = (1234567.891).toLocaleString();`);
+  });
+
+  test("the error names the refused method", () => {
+    expect(() => foldConst(`const x = [].constructor.constructor("return 1");`, "x")).toThrow(
+      /`\.constructor\(\.\.\.\)` is not foldable/,
+    );
+  });
+
+  test("listed host methods still fold", () => {
+    expect(foldConst(`const x = ["a", "b"].join(",");`, "x")).toBe("a,b");
+    expect(foldConst(`const x = "a.b.c".split(".").slice(1).join("-");`, "x")).toBe("b-c");
+    expect(foldConst(`const x = (3.14159).toFixed(2);`, "x")).toBe("3.14");
+    expect(foldConst(`const x = "Abc".toUpperCase();`, "x")).toBe("ABC");
+    expect(foldConst(`const x = true.toString();`, "x")).toBe("true");
+  });
+
+  test("a method written in package code is not a host method and still folds", () => {
+    // The github lexicon's `Expression.prototype.toString` is this shape.
+    class Expr {
+      toString(): string {
+        return "${{ github.actor }}";
+      }
+    }
+    const consts = parseConsts(`const x = actor.toString();`);
+    const externals = new Map<string, unknown>([["actor", new Expr()]]);
+    expect(fold(consts.get("x") as ts.Expression, consts, [], externals)).toBe("${{ github.actor }}");
+  });
+});

package/src/fold/fold.ts

@@ -6,12 +6,15 @@ import {
   SUPPORTED_UNARY_OPERATORS,
   UNSUPPORTED_OBJECT_MEMBER_MESSAGE,
   UNSUPPORTED_UNARY_MESSAGE,
+  FOLDABLE_HOST_METHODS,
+  REFUSED_METHOD_NAMES,
   briefNodeText,
   callExpressionMessage,
   computedPropertyNameMessage,
   dynamicElementAccessMessage,
   isLiteralElementKey,
   isLiteralPropertyName,
+  refusedMethodMessage,
   unsupportedBinaryMessage,
   unsupportedExpressionMessage,
   type SubsetRuleId,
@@ -1700,8 +1703,15 @@ export function fold(
     // 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.
+    //
+    // chant#4011 — "never checked by name" let `[].constructor.constructor`
+    // reach `Function`, so a folded file could run any code. A name in
+    // REFUSED_METHOD_NAMES is refused on every receiver, before the receiver
+    // is folded, exactly as EVL001 refuses it; a host (native) method must be
+    // in FOLDABLE_HOST_METHODS for its receiver's type ({@link hostMethodRefusal}).
     if (ts.isPropertyAccessExpression(node.expression)) {
       const methodName = node.expression.name.text;
+      if (REFUSED_METHOD_NAMES.has(methodName)) throw foldError(node, refusedMethodMessage(methodName));
       const receiver = fold(node.expression.expression, consts, intrinsics, externals);
       // chant #2328 — a call is a link of an optional chain like any other:
       // `a?.b()` and `a?.b.c()` on a nullish `a` are `undefined` in
@@ -1722,7 +1732,22 @@ export function fold(
       if (typeof method !== "function") {
         throw foldError(node, `"${methodName}" is not a callable method on the folded value — falls back to run`);
       }
+      // The arguments fold first, so `list.map((n) => …)` keeps refusing on
+      // its callback, the reason the docs give for it.
       const args = node.arguments.map((arg) => fold(arg, consts, intrinsics, externals));
+      if (isNativeFunction(method)) {
+        const refusal = hostMethodRefusal(receiver, methodName, method);
+        if (refusal) throw foldError(node, refusal);
+        // A host method handed a function calls it (`"x".replace("x", fn)`),
+        // and the only functions a fold produces as values are host ones read
+        // by property access (`[].constructor`), so none is passed in.
+        if (args.some((arg) => typeof arg === "function")) {
+          throw foldError(
+            node,
+            `a function passed to the host method \`.${methodName}(...)\` is not foldable — falls back to run`,
+          );
+        }
+      }
       return (method as (...methodArgs: unknown[]) => unknown).apply(receiver, args) as FoldedValue;
     }
 
@@ -1732,6 +1757,52 @@ export function fold(
   throw foldError(node, unsupportedExpressionMessage(node));
 }
 
+/**
+ * chant#4011 — true when `fn` is provided by the JavaScript engine rather than
+ * written in JavaScript. A lexicon's own method (`Expression.prototype.toString`)
+ * is JavaScript source; `Function`, `Date.now` and `Array.prototype.join` are
+ * not. `Function.prototype.toString` prints a native function's body as
+ * `[native code]` (ECMA-262, NativeFunction), and is read off the prototype so
+ * a receiver cannot override it.
+ */
+function isNativeFunction(fn: unknown): boolean {
+  return typeof fn === "function" && /\{\s*\[native code\]\s*\}\s*$/.test(Function.prototype.toString.call(fn));
+}
+
+const HOST_PROTOTYPES = {
+  string: String.prototype,
+  number: Number.prototype,
+  boolean: Boolean.prototype,
+  array: Array.prototype,
+  object: Object.prototype,
+} as const;
+
+/**
+ * chant#4011 — why a host method `method`, read as `receiver[methodName]`,
+ * does not fold, or `undefined` when it does. It folds only when the
+ * receiver's type has a row in {@link FOLDABLE_HOST_METHODS} listing the name
+ * and `method` is the function that type's prototype carries under it. A
+ * function receiver (`[].constructor.from(...)`) has no row; neither does a
+ * host object such as a `Date`, which has its own prototype.
+ */
+function hostMethodRefusal(receiver: unknown, methodName: string, method: unknown): string | undefined {
+  let kind: keyof typeof HOST_PROTOTYPES | undefined;
+  if (typeof receiver === "string") kind = "string";
+  else if (typeof receiver === "number") kind = "number";
+  else if (typeof receiver === "boolean") kind = "boolean";
+  else if (Array.isArray(receiver)) kind = "array";
+  else if (typeof receiver === "object" && receiver !== null) kind = "object";
+  const listed =
+    kind !== undefined &&
+    FOLDABLE_HOST_METHODS[kind].has(methodName) &&
+    (HOST_PROTOTYPES[kind] as unknown as Record<string, unknown>)[methodName] === method;
+  if (listed) return undefined;
+  return (
+    `the host method \`.${methodName}(...)\` is not in the foldable table for a ${kind ?? typeof receiver} ` +
+    "receiver (chant#4011) — falls back to run"
+  );
+}
+
 /**
  * Fold a resource constructor call to its spec.
  *

package/src/fold/subset.test.ts

@@ -691,3 +691,34 @@ describe("findSubsetViolation — project-local calls (chant#2435)", () => {
     expect(() => findSubsetViolation(synthetic)).toThrow(/Cannot read|undefined|getSourceFile|getText/i);
   });
 });
+
+// chant#4011 — a refused method name is decidable from syntax, so EVL001 and
+// fold() refuse it together. Before the fix both accepted every case here.
+describe("subset — method names that reach Function or the host locale (#4011)", () => {
+  const cases = [
+    `[].constructor.constructor("return Date.now()").call()`,
+    `[].constructor.constructor("return process.env.HOME").call()`,
+    `"".__proto__.constructor.constructor("return Math.random()").call()`,
+    `(1234.5).toLocaleString()`,
+  ];
+  for (const expr of cases) {
+    test(expr, () => {
+      const source = `const bad = new Thing({ x: ${expr} });`;
+      const sourceFile = ts.createSourceFile("t.ts", source, ts.ScriptTarget.Latest, true);
+      const consts = collectConsts(sourceFile);
+      expect(() => foldResource(consts.get("bad") as ts.NewExpression, consts, [])).toThrow(FoldError);
+
+      const context: LintContext = { sourceFile, entities: [], filePath: "t.ts", lexicon: undefined };
+      expect(evl001NonLiteralExpressionRule.check(context)).toHaveLength(1);
+      const violation = findSubsetViolation((consts.get("bad") as ts.NewExpression).arguments![0]);
+      expect(violation?.message).toContain("chant#4011");
+    });
+  }
+
+  test("a listed method keeps passing EVL001", () => {
+    const source = `const ok = new Thing({ x: ["a", "b"].join(",") });`;
+    const sourceFile = ts.createSourceFile("t.ts", source, ts.ScriptTarget.Latest, true);
+    const context: LintContext = { sourceFile, entities: [], filePath: "t.ts", lexicon: undefined };
+    expect(evl001NonLiteralExpressionRule.check(context)).toHaveLength(0);
+  });
+});