@intentius/chant 0.124.31 → 0.124.32

package/dist/discovery/sandbox/bundle.js

@@ -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.js";
 /**
  * chant #1045 Phase 2 — bundles the generated sandbox driver (`./driver.ts`)
  * into one self-contained ESM file with esbuild, so the sandboxed child never
@@ -201,6 +202,11 @@ export async function bundleDriver(driverSource) {
             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],
         });
     }

package/dist/discovery/specifier-resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"specifier-resolve.d.ts","sourceRoot":"","sources":["../../src/discovery/specifier-resolve.ts"],"names":[],"mappings":"AA2BA,oDAAoD;AACpD,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAM5C;AAmBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAmBhE;AAED,kGAAkG;AAClG,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAOnG;AA8BD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA0B/F;AA+ID;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GAAG,SAAS,CAiCzD;AAED,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE3F"}
+{"version":3,"file":"specifier-resolve.d.ts","sourceRoot":"","sources":["../../src/discovery/specifier-resolve.ts"],"names":[],"mappings":"AA4BA,oDAAoD;AACpD,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAM5C;AAmBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAmBhE;AAED,kGAAkG;AAClG,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAOnG;AAmCD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA0B/F;AA+ID;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GAAG,SAAS,CAiCzD;AAED,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE3F"}

package/dist/discovery/specifier-resolve.js

@@ -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.js";
 /** True when `path` is an existing regular file. */
 export function isFile(path) {
     try {
@@ -87,8 +88,13 @@ export function splitBareSpecifier(specifier) {
     const rest = segments.slice(nameLength).join("/");
     return { name, subpath: rest === "" ? "." : `./${rest}` };
 }
-/** The conditions an ESM import in Node matches, which is what the run path does. */
-const EXPORT_CONDITIONS = 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 = new Set(["import", "node", "default", ...SOURCE_EXPORT_CONDITIONS]);
 /**
  * The target an `exports` value selects, with `star` substituted for each `*`
  * when it came from a pattern key. A string is the target; an array yields its

package/dist/fold/fold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../src/fold/fold.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAoE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AACjH,OAAO,EAaL,KAAK,YAAY,EAClB,MAAM,UAAU,CAAC;AAGlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkGG;AAEH;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,WAAW,EAAE,GACb;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAA;CAAE,GAC9B,YAAY,GACZ,eAAe,GACf,gBAAgB,GAChB,aAAa,GACb,cAAc,GACd,uBAAuB,CAAC;AAE5B;;;;;;;;;;;;GAYG;AACH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAuBvE;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAClD;AAED;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,kBAAkB,GAAG,mBAAmB,CAAC;AAEvE,+EAA+E;AAC/E,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,yGAAyG;IACzG,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,WAAW,EAAE,CAAC;CACrB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,WAAW,EAAE,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAA;KAAE,CAAC;IACtC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAA;KAAE,CAAC;IAC5C;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,WAAW,EAAE,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,uBAAuB;IACtC,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,WAAW,EAAE,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GAClC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,SAAU,SAAQ,KAAK;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IAEjC,YAAY,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,YAAuB,EAAE,cAAc,UAAQ,EAUjH;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,gBAAgB;IAEzB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,mBAAmB,GAAG,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,kBAAkB;IAC9E,6DAA6D;IAC7D,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC;IAC3C,iNAAiN;IACjN,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC;IAChD,iIAAiI;IACjI,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC;IAjBjD;IACE,yCAAyC;IAChC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,EAAE,CAAC,mBAAmB,GAAG,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,kBAAkB;IAC9E,6DAA6D;IACpD,IAAI,EAAE,MAAM;IACrB;;;;;;OAMG;IACM,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC;IAC3C,iNAAiN;IACxM,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC;IAChD,iIAAiI;IACxH,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,YAAA,EAC7C;IAEJ;;;;;;;;OAQG;IACH,cAAc,UAAS;CACxB;AAeD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,EAC1C,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,GAAG,CAAC,MAAM,CAAa,GAC5B,OAAO,CAQT;AAWD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,EAAE,CAAC,UAAU,EACzB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,EAC1C,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACrC,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAyB/B;AA4CD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAE5E;AAUD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACzC,EAAE,EAAE,EAAE,CAAC,mBAAmB,GAAG,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,kBAAkB,GACpE,MAAM,GAAG,SAAS,CAmDpB;AA2ID;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAItE;AAOD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,CAYnF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,YAAY,GAAG,MAAM,CAGtD;AAwUD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAClB,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,EAClC,UAAU,GAAE,SAAS,YAAY,EAAO,EACxC,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GACvC,WAAW,CAmfb;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,EAAE,CAAC,aAAa,EACtB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,EAClC,UAAU,GAAE,SAAS,YAAY,EAAO,EACxC,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GACvC,cAAc,CA6BhB;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,QAAQ,SAAc,EACtB,UAAU,GAAE,SAAS,YAAY,EAAO,GACvC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CA6BjC"}
+{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../src/fold/fold.ts"],"names":[],"mappings":"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"}

package/dist/fold/fold.js

@@ -1,7 +1,7 @@
 import * as ts from "typescript";
 import { relative } from "node:path";
 import { intrinsicCallFolds, intrinsicCallFoldsEagerly, intrinsicTagFolds } from "../lexicon.js";
-import { SUPPORTED_BINARY_OPERATORS, SUPPORTED_UNARY_OPERATORS, UNSUPPORTED_OBJECT_MEMBER_MESSAGE, UNSUPPORTED_UNARY_MESSAGE, briefNodeText, callExpressionMessage, computedPropertyNameMessage, dynamicElementAccessMessage, isLiteralElementKey, isLiteralPropertyName, unsupportedBinaryMessage, unsupportedExpressionMessage, } from "./subset.js";
+import { SUPPORTED_BINARY_OPERATORS, 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, } from "./subset.js";
 import { isFoldableHelperName } from "./foldable-helpers.js";
 /**
  * Symbolic reference produced when a property/element access resolves to an
@@ -1310,8 +1310,16 @@ export function fold(node, consts, intrinsics = [], externals) {
         // 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
@@ -1331,13 +1339,72 @@ export function fold(node, consts, intrinsics = [], externals) {
             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.apply(receiver, args);
         }
         throw foldError(node, callExpressionMessage(node));
     }
     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) {
+    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,
+};
+/**
+ * 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, methodName, method) {
+    let kind;
+    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][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/dist/fold/subset.d.ts

@@ -316,6 +316,43 @@ export declare function unsupportedBinaryMessage(opKind: ts.SyntaxKind): string;
  */
 export declare function callExpressionMessage(node: ts.CallExpression): string;
 export declare function unsupportedExpressionMessage(node: ts.Node): string;
+/**
+ * chant#4011 — S-CallMethod's closed table of HOST methods, by receiver type.
+ * PROVISIONAL until typescript-as-data narrows F-Eval-CallMethod to the same
+ * table (INTENTIUS/typescript-as-data#264; see the module doc's provisional path).
+ *
+ * Since #1966 `fold()` called any function-valued property on a real
+ * receiver, so `[].constructor.constructor("return Date.now()")` reached
+ * `Function` and a `[fold:fold]` file could put the clock, `process.env` or
+ * `Math.random()` in its output. A method the JavaScript engine provides
+ * (a native function) now folds only when it is listed here for the
+ * receiver's type AND is the very function that type's prototype carries, so
+ * an own property cannot shadow a listed name. Every entry is deterministic
+ * given its receiver and arguments: no callbacks (`map`, `filter`), no
+ * mutation (`push`, `sort`), and no `toLocale*` or `localeCompare`, whose
+ * answer follows the host's locale and time zone.
+ *
+ * A method defined by a lexicon package's own code (the github lexicon's
+ * `Expression.prototype.toString`) is not a host method and is not looked up
+ * here; it is the same class of package code as an eager intrinsic call.
+ */
+export declare const FOLDABLE_HOST_METHODS: {
+    readonly string: ReadonlySet<string>;
+    readonly number: ReadonlySet<string>;
+    readonly boolean: ReadonlySet<string>;
+    readonly array: ReadonlySet<string>;
+    readonly object: ReadonlySet<string>;
+};
+/**
+ * chant#4011 — method names `fold()` refuses on every receiver, lexicon
+ * objects included. These are the names that reach `Function` (`constructor`,
+ * and `call`/`apply`/`bind` on whatever it returns) or read the host locale.
+ * Unlike {@link FOLDABLE_HOST_METHODS}, which needs the receiver's runtime
+ * type, a name in this set is decidable from syntax, so EVL001 refuses it too.
+ */
+export declare const REFUSED_METHOD_NAMES: ReadonlySet<string>;
+/** The refusal for a method name in {@link REFUSED_METHOD_NAMES}, shared by `fold()` and EVL001. */
+export declare function refusedMethodMessage(methodName: string): string;
 /**
  * Classify one object-literal member (`{ a: 1 }`'s `a: 1`, `{ ...x }`'s
  * `...x`, or a shorthand `{ a }`). Checks the key's shape before the

package/dist/fold/subset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subset.d.ts","sourceRoot":"","sources":["../../src/fold/subset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAiD,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0KG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,eAAO,MAAM,YAAY,QAAQ,CAAC;AAElC,mEAAmE;AACnE,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE/C,uGAAuG;AACvG,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACd,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAMD,0FAA0F;AAC1F,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,EAAE,CAAC,UAAU,CAchE,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,EAAE,CAAC,UAAU,CAG/D,CAAC;AAEH,gHAAgH;AAChH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,EAAE,CAAC,YAAY,GACpB,IAAI,IAAI,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,cAAc,CAE9D;AAED,6GAA6G;AAC7G,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,cAAc,CAErG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,SAAS,SAAK,GAAG,MAAM,CAGnE;AAMD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,WAAW,CAAC,MAAM,CAAC,CAoDpF;AAgCD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,EAAE,CAAC,YAAY,GAAG,MAAM,CAEzE;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,CAE1E;AAED,eAAO,MAAM,iCAAiC,8BAA8B,CAAC;AAE7E,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAE7D,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,CAEtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,GAAG,MAAM,CAErE;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAElE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,EAAE,CAAC,wBAAwB,EACjC,UAAU,CAAC,EAAE,SAAS,YAAY,EAAE,GACnC,eAAe,GAAG,SAAS,CAc7B;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,UAAU,CAAC,EAAE,SAAS,YAAY,EAAE,GACnC,eAAe,GAAG,SAAS,CAkO7B"}
+{"version":3,"file":"subset.d.ts","sourceRoot":"","sources":["../../src/fold/subset.ts"],"names":[],"mappings":"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"}

package/dist/fold/subset.js

@@ -432,6 +432,87 @@ export function callExpressionMessage(node) {
 export function unsupportedExpressionMessage(node) {
     return `unsupported expression: ${ts.SyntaxKind[node.kind]}`;
 }
+/**
+ * chant#4011 — S-CallMethod's closed table of HOST methods, by receiver type.
+ * PROVISIONAL until typescript-as-data narrows F-Eval-CallMethod to the same
+ * table (INTENTIUS/typescript-as-data#264; see the module doc's provisional path).
+ *
+ * Since #1966 `fold()` called any function-valued property on a real
+ * receiver, so `[].constructor.constructor("return Date.now()")` reached
+ * `Function` and a `[fold:fold]` file could put the clock, `process.env` or
+ * `Math.random()` in its output. A method the JavaScript engine provides
+ * (a native function) now folds only when it is listed here for the
+ * receiver's type AND is the very function that type's prototype carries, so
+ * an own property cannot shadow a listed name. Every entry is deterministic
+ * given its receiver and arguments: no callbacks (`map`, `filter`), no
+ * mutation (`push`, `sort`), and no `toLocale*` or `localeCompare`, whose
+ * answer follows the host's locale and time zone.
+ *
+ * A method defined by a lexicon package's own code (the github lexicon's
+ * `Expression.prototype.toString`) is not a host method and is not looked up
+ * here; it is the same class of package code as an eager intrinsic call.
+ */
+export const FOLDABLE_HOST_METHODS = {
+    string: new Set([
+        "at",
+        "charAt",
+        "charCodeAt",
+        "codePointAt",
+        "concat",
+        "endsWith",
+        "includes",
+        "indexOf",
+        "lastIndexOf",
+        "padEnd",
+        "padStart",
+        "repeat",
+        "replace",
+        "replaceAll",
+        "slice",
+        "split",
+        "startsWith",
+        "substring",
+        "toLowerCase",
+        "toString",
+        "toUpperCase",
+        "trim",
+        "trimEnd",
+        "trimStart",
+        "valueOf",
+    ]),
+    number: new Set(["toExponential", "toFixed", "toPrecision", "toString", "valueOf"]),
+    boolean: new Set(["toString", "valueOf"]),
+    array: new Set(["at", "concat", "flat", "includes", "indexOf", "join", "lastIndexOf", "slice", "toString"]),
+    object: new Set(["hasOwnProperty", "toString", "valueOf"]),
+};
+/**
+ * chant#4011 — method names `fold()` refuses on every receiver, lexicon
+ * objects included. These are the names that reach `Function` (`constructor`,
+ * and `call`/`apply`/`bind` on whatever it returns) or read the host locale.
+ * Unlike {@link FOLDABLE_HOST_METHODS}, which needs the receiver's runtime
+ * type, a name in this set is decidable from syntax, so EVL001 refuses it too.
+ */
+export const REFUSED_METHOD_NAMES = new Set([
+    "constructor",
+    "call",
+    "apply",
+    "bind",
+    "toLocaleString",
+    "toLocaleDateString",
+    "toLocaleTimeString",
+    "toLocaleUpperCase",
+    "toLocaleLowerCase",
+    "localeCompare",
+    "__defineGetter__",
+    "__defineSetter__",
+    "__lookupGetter__",
+    "__lookupSetter__",
+]);
+/** The refusal for a method name in {@link REFUSED_METHOD_NAMES}, shared by `fold()` and EVL001. */
+export function refusedMethodMessage(methodName) {
+    return (`method call \`.${methodName}(...)\` is not foldable: it reaches \`Function\` or the host locale, ` +
+        "so its result is not determined by the source (chant#4011) — falls back to run");
+}
 /**
  * Classify one object-literal member (`{ a: 1 }`'s `a: 1`, `{ ...x }`'s
  * `...x`, or a shorthand `{ a }`). Checks the key's shape before the
@@ -660,7 +741,14 @@ export function findSubsetViolation(node, intrinsics) {
         // a same-file `new` used as a value (#1169). Accepted here regardless of
         // the intrinsics registry, unlike the two cases just above: nothing about
         // whether a method call folds depends on a lexicon's registration.
+        //
+        // chant#4011 — except a name `fold()` refuses on every receiver, which is
+        // decidable here. The per-type host table needs the receiver's value, so
+        // it stays on `fold()`'s side, in the direction F-Direction allows.
         if (ts.isPropertyAccessExpression(node.expression)) {
+            if (REFUSED_METHOD_NAMES.has(node.expression.name.text)) {
+                return violation(node, refusedMethodMessage(node.expression.name.text));
+            }
             const v = findSubsetViolation(node.expression.expression, intrinsics);
             if (v)
                 return v;

package/dist/lexicon-module.d.ts

@@ -97,6 +97,9 @@ export declare function resetLexiconModules(): void;
  * `typeScript: false` imports it with plain node, without registering tsx
  * (#3276): tsx's ESM hooks run on a thread of their own, which costs the
  * compiled CLI about 200 MB, so a caller whose module is JavaScript says so.
+ * Left out, the module's extension decides (#3981): a `.js` or `.mjs` module
+ * imports with plain node, and anything else (`.ts`, or no extension, which
+ * only tsx's resolver completes) registers tsx first.
  */
 export declare function importLexiconModule(name: string, options?: {
     typeScript?: boolean;
@@ -133,6 +136,13 @@ export declare function resolveFromProject(spec: string, fromDir?: string): stri
  * that installs its lexicons in its own node_modules, it is resolved from
  * `fromDir` (the project) and imported from there. Any other failure, and a
  * package the project doesn't have either, rethrows the first error.
+ *
+ * #3981 — tsx is registered only when the module resolves to TypeScript. A
+ * lexicon that ships compiled JS imports with plain node. The module is
+ * resolved before it is imported, because a failed import is cached: one
+ * tried without tsx cannot be tried again with it. A resolution that fails
+ * for any reason but a missing package registers tsx, whose resolver may
+ * still complete it.
  */
 export declare function importLexiconPackage(spec: string, fromDir?: string): Promise<Record<string, unknown>>;
 //# sourceMappingURL=lexicon-module.d.ts.map

package/dist/lexicon-module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lexicon-module.d.ts","sourceRoot":"","sources":["../src/lexicon-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAQH;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1F,mEAAmE;AACnE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAExE;AAED,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,MAAM,EAAE,CAAC;AAC/E,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;AAiBvG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EACxC,OAAO,EAAE,MAAM,EACf,SAAS,SAAM,GACd;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAgBrC;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,SAAS,EAClD,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgBxB;AAMD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAM3G;AAED,2DAA2D;AAC3D,wBAAgB,sBAAsB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAE5D;AAED,sGAAsG;AACtG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAElE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAElE;AAED,6CAA6C;AAC7C,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAO,GACrC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAY9C;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,MAAsB,EAC/B,KAAK,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAe,GAC/C,MAAM,CAKR;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAe,GAC/C,MAAM,EAAE,CAEV;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI9D;AAUD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAsB,GAAG,MAAM,GAAG,SAAS,CAMpG;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAW1H"}
+{"version":3,"file":"lexicon-module.d.ts","sourceRoot":"","sources":["../src/lexicon-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AASH;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1F,mEAAmE;AACnE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAExE;AAED,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,MAAM,EAAE,CAAC;AAC/E,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;AAiBvG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EACxC,OAAO,EAAE,MAAM,EACf,SAAS,SAAM,GACd;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAgBrC;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,SAAS,kBAAkB,EAAE,GAAG,SAAS,EAClD,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgBxB;AAMD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAM3G;AAED,2DAA2D;AAC3D,wBAAgB,sBAAsB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAE5D;AAED,sGAAsG;AACtG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAElE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAElE;AAED,6CAA6C;AAC7C,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAO,GACrC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAa9C;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,MAAsB,EAC/B,KAAK,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAe,GAC/C,MAAM,CAKR;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,GAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAe,GAC/C,MAAM,EAAE,CAEV;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI9D;AAUD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAsB,GAAG,MAAM,GAAG,SAAS,CAMpG;AAcD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAqB1H"}

package/dist/lexicon-module.js

@@ -26,8 +26,9 @@
 import { createRequire } from "node:module";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
-import { ensureTypeScriptLoader } from "./ts-loader.js";
+import { ensureTypeScriptLoader, ensureTypeScriptLoaderFor, typeScriptLoaderPending } from "./ts-loader.js";
 import { esModuleNamespace } from "./module-interop.js";
+import { isJavaScriptModule } from "./module-source.js";
 /** The lexicon name an entry declares, whichever form it takes. */
 export function lexiconDeclarationName(entry) {
     return typeof entry === "string" ? entry : entry.name;
@@ -154,13 +155,17 @@ export function resetLexiconModules() {
  * `typeScript: false` imports it with plain node, without registering tsx
  * (#3276): tsx's ESM hooks run on a thread of their own, which costs the
  * compiled CLI about 200 MB, so a caller whose module is JavaScript says so.
+ * Left out, the module's extension decides (#3981): a `.js` or `.mjs` module
+ * imports with plain node, and anything else (`.ts`, or no extension, which
+ * only tsx's resolver completes) registers tsx first.
  */
 export async function importLexiconModule(name, options = {}) {
     const path = modulePaths.get(name);
     if (path === undefined)
         return undefined;
     try {
-        if (options.typeScript !== false)
+        const typeScript = options.typeScript ?? !isJavaScriptModule(path);
+        if (typeScript)
             ensureTypeScriptLoader();
         return esModuleNamespace((await import(path)));
     }
@@ -221,6 +226,19 @@ export function resolveFromProject(spec, fromDir = process.cwd()) {
         return undefined;
     }
 }
+/**
+ * #3981 — where `spec` resolves from this module, as `import(spec)` here
+ * would resolve it. Throws as the import would when it cannot be resolved.
+ * An absolute path is its own file URL.
+ */
+function resolveImport(spec) {
+    if (isAbsolute(spec))
+        return pathToFileURL(spec).href;
+    const resolveMeta = import.meta.resolve;
+    if (typeof resolveMeta === "function")
+        return resolveMeta(spec);
+    return pathToFileURL(createRequire(import.meta.url).resolve(spec)).href;
+}
 /**
  * chant#2845 — import a lexicon package, or one of its subpaths, by its bare
  * specifier. chant's own install is tried first, as a bare `import()` always
@@ -229,19 +247,46 @@ export function resolveFromProject(spec, fromDir = process.cwd()) {
  * that installs its lexicons in its own node_modules, it is resolved from
  * `fromDir` (the project) and imported from there. Any other failure, and a
  * package the project doesn't have either, rethrows the first error.
+ *
+ * #3981 — tsx is registered only when the module resolves to TypeScript. A
+ * lexicon that ships compiled JS imports with plain node. The module is
+ * resolved before it is imported, because a failed import is cached: one
+ * tried without tsx cannot be tried again with it. A resolution that fails
+ * for any reason but a missing package registers tsx, whose resolver may
+ * still complete it.
  */
 export async function importLexiconPackage(spec, fromDir = process.cwd()) {
+    const pkg = packageNameOf(spec);
+    if (typeScriptLoaderPending()) {
+        let resolved;
+        try {
+            resolved = resolveImport(spec);
+        }
+        catch (err) {
+            if (pkg === undefined || !isPackageNotFound(err, pkg)) {
+                ensureTypeScriptLoader();
+            }
+            else {
+                return importFromProject(spec, fromDir, err);
+            }
+        }
+        if (resolved !== undefined)
+            ensureTypeScriptLoaderFor(resolved);
+    }
     try {
-        ensureTypeScriptLoader();
         return esModuleNamespace((await import(spec)));
     }
     catch (err) {
-        const pkg = packageNameOf(spec);
         if (pkg === undefined || !isPackageNotFound(err, pkg))
             throw err;
-        const resolved = resolveFromProject(spec, fromDir);
-        if (resolved === undefined)
-            throw err;
-        return esModuleNamespace((await import(pathToFileURL(resolved).href)));
+        return importFromProject(spec, fromDir, err);
     }
 }
+/** The project's copy of `spec`, for {@link importLexiconPackage}. Rethrows `err` when the project has none. */
+async function importFromProject(spec, fromDir, err) {
+    const resolved = resolveFromProject(spec, fromDir);
+    if (resolved === undefined)
+        throw err;
+    ensureTypeScriptLoaderFor(resolved);
+    return esModuleNamespace((await import(pathToFileURL(resolved).href)));
+}

package/dist/lexicon-plugin-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lexicon-plugin-helpers.d.ts","sourceRoot":"","sources":["../src/lexicon-plugin-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAI/C;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,GAAG;IAC7D,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,aAAa,EAAE,GACrB,MAAM,eAAe,EAAE,CAYzB;AAID;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,mBAAmB,CAsBrB;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,GAClB,uBAAuB,CAmBzB"}
+{"version":3,"file":"lexicon-plugin-helpers.d.ts","sourceRoot":"","sources":["../src/lexicon-plugin-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAI/C;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,GAAG;IAC7D,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,aAAa,EAAE,GACrB,MAAM,eAAe,EAAE,CAazB;AAID;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,mBAAmB,CAsBrB;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,GAClB,uBAAuB,CAoBzB"}

package/dist/lexicon-plugin-helpers.js

@@ -6,8 +6,8 @@
  * MCP diff tool, and MCP catalog resource.
  */
 import { readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { join } from "path";
+import { moduleSourceDir } from "./module-source.js";
 /**
  * Create a skills loader that reads .md files from a lexicon's skills directory.
  *
@@ -25,7 +25,8 @@ import { fileURLToPath } from "url";
  */
 export function createSkillsLoader(importMetaUrl, specs) {
     return () => {
-        const skillsDir = join(dirname(fileURLToPath(importMetaUrl)), "skills");
+        // Skills are markdown beside the source; a compiled plugin finds them under src/ (#3981).
+        const skillsDir = join(moduleSourceDir(importMetaUrl), "skills");
         return specs.map(({ file, ...meta }) => {
             try {
                 const content = readFileSync(join(skillsDir, file), "utf-8");
@@ -91,7 +92,8 @@ export function createCatalogResource(importMetaUrl, name, description, lexiconJ
         description,
         mimeType: "application/json",
         async handler() {
-            const dir = dirname(fileURLToPath(importMetaUrl));
+            // Generated JSON sits beside the source; a compiled plugin finds it under src/ (#3981).
+            const dir = moduleSourceDir(importMetaUrl);
             const lexicon = JSON.parse(readFileSync(join(dir, "generated", lexiconJsonFile), "utf-8"));
             const entries = Object.entries(lexicon).map(([className, entry]) => ({
                 className,

package/dist/lexicon.d.ts

@@ -470,6 +470,8 @@ export interface ComponentPipelineOptions {
      * `wave-<k>` runs `chant components fan-out --wave-gate <gate> --wave <k>`
      * and hands the attempt record to the next job. See
      * `components/gated-wave-pipeline.ts`. Unset, the pipeline is unchanged.
+     * Beside `prLoop` (#4003) it gives the pull request's apply a gate per
+     * wave instead: one apply job per wave (`prLoopWithWaves`).
      */
     gatedWaves?: GatedWavePipelineOptions;
     /**