@intentius/chant 0.71.1 → 0.72.0

package/dist/discovery/fold-import.d.ts

@@ -252,7 +252,20 @@ export declare function lexiconPackageName(lexiconName: string): string;
  *   fold may not import or invoke anything outside the trusted allowlist —
  *   see {@link FoldSession.sandbox}.
  */
-export declare function createFoldSession(intrinsics?: readonly IntrinsicDef[], buildParams?: Readonly<Record<string, BuildParamValue>>, lexicons?: readonly string[], sandbox?: boolean): FoldSession;
+export declare function createFoldSession(intrinsics?: readonly IntrinsicDef[], buildParams?: Readonly<Record<string, BuildParamValue>>, lexicons?: readonly string[], sandbox?: boolean, 
+/**
+ * chant#2438 — package specifiers to allow verbatim, alongside the ones
+ * derived from `lexicons`.
+ *
+ * A chant build's active packages are always `@intentius/chant-lexicon-*`,
+ * so naming lexicons is the whole story there. A caller embedding the fold
+ * path against a host that is not a chant lexicon has packages the naming
+ * convention cannot express: the specification's conformance harness supplies
+ * `@tsad/shapes`, which is its host's own specifier. The boundary is
+ * unchanged, an explicitly named package of this build, only now it can be
+ * named as a specifier rather than only as a lexicon.
+ */
+lexiconPackages?: readonly string[]): FoldSession;
 /**
  * What the fold pass actually EXECUTED, and what it interpreted instead — the
  * number chant #1023 is measured by, and the one the #1093/#1111
@@ -515,6 +528,20 @@ export interface FoldProjectOptions {
     readonly buildParams?: Readonly<Record<string, BuildParamValue>>;
     /** chant #1093: this build asked for the sandbox, so fold may not reach outside the trusted allowlist. */
     readonly sandbox?: boolean;
+    /**
+     * chant#2438 — package specifiers to follow a bare import into, verbatim,
+     * alongside whatever `lexicons` names.
+     *
+     * For a chant project this is never needed: an active package is always
+     * `@intentius/chant-lexicon-<name>`, which `lexicons` already expresses. It
+     * is here for a caller driving the fold path against a host of its own, where
+     * the package has a name chant's convention cannot spell. The specification's
+     * conformance harness is the first such caller, with `@tsad/shapes`.
+     *
+     * The boundary does not move. This is still an allowlist the caller states
+     * outright, matched by text, and absent it nothing bare resolves at all.
+     */
+    readonly lexiconPackages?: readonly string[];
 }
 /** One file's place in a whole-build fold, as {@link foldProject} reports it. */
 export interface FoldProjectVerdict {

package/dist/discovery/fold-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold-import.d.ts","sourceRoot":"","sources":["../../src/discovery/fold-import.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fold-import.d.ts","sourceRoot":"","sources":["../../src/discovery/fold-import.ts"],"names":[],"mappings":"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"}

package/dist/fold/fold.d.ts

@@ -411,6 +411,35 @@ export declare class FoldableFunction {
      */
     leakedIdentity: boolean;
 }
+/**
+ * True when a module-level `const` is (transitively) bound to a `new Type(...)`.
+ * Follows an identifier chain (`const a = new T(); const b = a;`) so aliasing
+ * cannot smuggle a module-level resource into a function body.
+ *
+ * chant#2436 moved this here from ../discovery/fold-import.ts so the two places
+ * that build {@link FoldableFunction}s share one implementation rather than two
+ * that can drift.
+ */
+export declare function constResolvesToResource(consts: ReadonlyMap<string, ts.Expression>, name: string, seen?: Set<string>): boolean;
+/**
+ * Every top-level function a file declares, exported or not, as a
+ * {@link FoldableFunction}: `function f(...) {...}` and `const f = (...) => …`.
+ *
+ * The markers carry `externals` BY REFERENCE, so the caller may keep filling it
+ * after this returns (which is how a sibling function, or a resource built
+ * later, becomes reachable from a body).
+ *
+ * `consts` drops every `new`-bound const, transitively through aliases: a body
+ * that mentions one must read the live instance out of `externals`, the same
+ * object the module's own fold registered, never re-fold the initializer and
+ * construct a duplicate of a resource discovery already has.
+ *
+ * chant#2436 — one implementation, called both by ../discovery/fold-import.ts
+ * during a build and by {@link fold} when a unit-level fold has no externals of
+ * its own. Getting the `new`-bound stripping wrong yields a wrong value rather
+ * than a fallback to run, which is why there is only one copy of it.
+ */
+export declare function collectSameFileFunctions(sourceFile: ts.SourceFile, consts: ReadonlyMap<string, ts.Expression>, file: string, externals: ReadonlyMap<string, unknown>, failures?: ReadonlyMap<string, string>): Map<string, FoldableFunction>;
 export declare function isFoldableFunction(value: unknown): value is FoldableFunction;
 /**
  * The SHAPE half of what makes a project-local function foldable (chant

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,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;gBAElB,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,YAAuB;CAU3F;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;;IAhB/C,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;IAGjD;;;;;;;;OAQG;IACH,cAAc,UAAS;CACxB;AAeD,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;AAuID;;;;;;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;AAgRD;;;;;;;;;;;;;;;;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,CAqdb;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/subset.d.ts

@@ -46,7 +46,16 @@ import { type IntrinsicDef } from "../lexicon.js";
  * expression, its operator, and (for keys) its literal-ness. It
  * deliberately does NOT resolve bindings or perform any evaluation, because
  * three things a full fold needs are inherently environment-dependent and
- * cannot be recovered from shape alone:
+ * cannot be recovered from shape alone.
+ *
+ * One thing it does read beyond the expression itself, since chant#2435: the
+ * enclosing file's top-level bindings, for `S-CallLocal`. A call to a
+ * project-local function is admitted by NAME (see
+ * {@link collectLocalCallables}), which is decidable from that file's syntax
+ * and needs no resolution. Before that, this module rejected all four shapes
+ * the build folds, which is the one direction `F-Direction` forbids, and it
+ * made `chant lint` report EVL001 on a file `chant build --fold` folds
+ * cleanly. The three genuinely environment-dependent cases are:
  *
  *   1. Identifier *resolution* — is a bare name actually a local `const`,
  *      vs. an unbound name? That needs the file's `consts` map. Both
@@ -196,6 +205,30 @@ export declare function isLiteralElementKey(node: ts.Expression): node is ts.Str
  * one-line reason either.
  */
 export declare function briefNodeText(node: ts.Node, maxLength?: number): string;
+/**
+ * Every name a file binds to something a project-local call can reach.
+ *
+ * Two bindings, both of which the specification's `S-LocalFunction` names and
+ * both decidable from this file's own syntax, which is all a shape classifier
+ * has:
+ *
+ *   - a top-level `function f(...) {...}`, or a `const f = (...) => ...`
+ *     (a function expression counts, and parentheses / `as` / `satisfies`
+ *     wrappers are unwrapped), exported or not;
+ *   - a name imported from a *project* specifier, one starting `./` or `../`.
+ *     A bare specifier is a package, and a package's function is not
+ *     project-local.
+ *
+ * Deliberately syntax-only, and deliberately not a judgment about the callee's
+ * body. Whether the body is admissible is `S-FnBody`'s question and the fold's
+ * to answer, exactly as it already is for a call this classifier admits by
+ * name (a registered authoring helper, an opted-in intrinsic).
+ *
+ * Mirrors `collectLocalFunctions` in ../discovery/fold-import.ts, which builds
+ * the real `FoldableFunction` for each of these during a build. This one only
+ * needs the names.
+ */
+export declare function collectLocalCallables(sourceFile: ts.SourceFile): ReadonlySet<string>;
 export declare function computedPropertyNameMessage(node: ts.PropertyName): string;
 export declare function dynamicElementAccessMessage(keyNode: ts.Expression): string;
 export declare const UNSUPPORTED_OBJECT_MEMBER_MESSAGE = "unsupported object member";

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+JG;AAEH;;;;;;GAMG;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;AAQD,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,CA6M7B"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwKG;AAEH;;;;;;GAMG;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"}

package/dist/index.d.ts

@@ -38,7 +38,7 @@ export * from "./graph-layout.js";
 export * from "./graph-lens.js";
 export * from "./detectLexicon.js";
 export * from "./fold/fold.js";
-export { findSubsetViolation, checkObjectMember, type SubsetViolation, type SubsetRuleId } from "./fold/subset.js";
+export { findSubsetViolation, checkObjectMember, collectLocalCallables, type SubsetViolation, type SubsetRuleId } from "./fold/subset.js";
 export { SPEC_VERSION } from "./fold/subset.js";
 export { foldProject, planFoldTaintWithEdges, type FoldProjectOptions, type FoldProjectVerdict, type TaintPlan, type TaintEdgeKind, } from "./discovery/fold-import.js";
 export * from "./lint/parser.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.71.1",
+  "version": "0.72.0",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/cli/commands/lint.test.ts

@@ -494,10 +494,42 @@ export const queue = new Queue({ name: Ref(environment) });
 
   test("an unregistered call is still flagged as EVL001 in the same project", async () => {
     await writeFile(join(testDir, "chant.config.json"), JSON.stringify({ lexicons: ["aws"] }));
+    // The call is to a name imported from a PACKAGE, which is what "unregistered"
+    // has to mean for this test to be about the registry. It used to be a
+    // same-file `function makeName()`, which chant#2435 established is
+    // `S-CallLocal` and admissible — the build folds that shape, so flagging it
+    // was the divergence, not the point being asserted here.
     await writeFile(
       join(testDir, "index.ts"),
       `
 import { Ref } from "@intentius/chant-lexicon-aws";
+import { randomUUID } from "node:crypto";
+
+class Queue {
+  constructor(_props: Record<string, unknown>) {}
+}
+
+export const queue = new Queue({ name: randomUUID() });
+      `,
+    );
+
+    const result = await lintCommand({ path: testDir, format: "stylish" });
+
+    const evl001 = result.diagnostics.filter((d) => d.ruleId === "EVL001");
+    expect(evl001).toHaveLength(1);
+    expect(evl001[0].message).toContain("statically evaluable");
+  });
+
+  test("a call to a project-local function is not flagged (chant#2435)", async () => {
+    await writeFile(join(testDir, "chant.config.json"), JSON.stringify({ lexicons: ["aws"] }));
+    // All three `S-LocalFunction` bindings in one file: a top-level function
+    // declaration, an arrow const, and a name imported from a project
+    // specifier. A build folds a call to each, so EVL001 must not flag one.
+    await writeFile(join(testDir, "helpers.ts"), `export function suffix(s: string): string { return s + "-x"; }\n`);
+    await writeFile(
+      join(testDir, "index.ts"),
+      `
+import { suffix } from "./helpers";
 
 class Queue {
   constructor(_props: Record<string, unknown>) {}
@@ -507,15 +539,17 @@ function makeName(): string {
   return "generated";
 }
 
-export const queue = new Queue({ name: makeName() });
+const label = (s: string): string => s.toUpperCase();
+
+export const a = new Queue({ name: makeName() });
+export const b = new Queue({ name: label("k") });
+export const c = new Queue({ name: suffix("q") });
       `,
     );
 
     const result = await lintCommand({ path: testDir, format: "stylish" });
 
-    const evl001 = result.diagnostics.filter((d) => d.ruleId === "EVL001");
-    expect(evl001).toHaveLength(1);
-    expect(evl001[0].message).toContain("statically evaluable");
+    expect(result.diagnostics.filter((d) => d.ruleId === "EVL001")).toHaveLength(0);
   });
 });
 

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

@@ -0,0 +1,89 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { foldProject } from "../index";
+
+/**
+ * chant#2438 — a host package that is not a chant lexicon.
+ *
+ * `FoldSession.lexiconPackages` is the entire allowlist a bare import is
+ * followed into, matched by text, and it has only ever been built from
+ * `@intentius/chant-lexicon-<name>`. That covers every chant project, because
+ * a chant project's active packages are exactly that.
+ *
+ * It does not cover a caller driving the fold path against a host of its own.
+ * The specification's conformance harness is the first: its `shapes` host owns
+ * `@tsad/shapes`, a name the convention cannot spell, so all twenty-five of its
+ * hosted whole-build fixtures were unanswerable at chant and reported skipped.
+ *
+ * `FoldProjectOptions.lexiconPackages` names such a package outright. The
+ * boundary is unchanged: still an allowlist the caller states, still matched by
+ * text, still empty by default.
+ */
+describe("foldProject — a host package outside the lexicon convention (chant#2438)", () => {
+  let root: string;
+
+  /** A project with a real `@tsad/shapes` in its own `node_modules`. */
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "chant-host-pkg-"));
+    const pkg = join(root, "node_modules", "@tsad", "shapes");
+    mkdirSync(pkg, { recursive: true });
+    writeFileSync(
+      join(pkg, "package.json"),
+      JSON.stringify({ name: "@tsad/shapes", version: "1.0.0", type: "module", main: "index.js" }),
+    );
+    writeFileSync(join(pkg, "index.js"), "export const SIZES = { small: 1, large: 3 };\n");
+  });
+
+  afterEach(() => rmSync(root, { recursive: true, force: true }));
+
+  const app = (source: string): string => {
+    const file = join(root, "app.ts");
+    writeFileSync(file, source);
+    return file;
+  };
+
+  test("is not followed without being named, which is the pre-#2438 answer", async () => {
+    const file = app('import { SIZES } from "@tsad/shapes";\nexport const s = SIZES.large;\n');
+    const verdict = (await foldProject([file])).get(file)!;
+
+    expect(verdict.verdict).toBe("run");
+    expect(verdict.reason).toContain("unresolved identifier: SIZES");
+  });
+
+  test("is followed when named, and the data export folds as a value", async () => {
+    const file = app('import { SIZES } from "@tsad/shapes";\nexport const s = SIZES.large;\n');
+    const verdict = (await foldProject([file], [], { lexiconPackages: ["@tsad/shapes"] })).get(file)!;
+
+    // The specification's `F-Host-DataExports/plain-data-export` fixture, and
+    // its `expect.json`, are exactly this.
+    expect(verdict.verdict).toBe("fold");
+    expect(Object.fromEntries(verdict.exports!)).toEqual({ s: 3 });
+  });
+
+  test("naming one package does not open any other", async () => {
+    const other = join(root, "node_modules", "@tsad", "elsewhere");
+    mkdirSync(other, { recursive: true });
+    writeFileSync(
+      join(other, "package.json"),
+      JSON.stringify({ name: "@tsad/elsewhere", version: "1.0.0", type: "module", main: "index.js" }),
+    );
+    writeFileSync(join(other, "index.js"), "export const OTHER = 9;\n");
+
+    const file = app('import { OTHER } from "@tsad/elsewhere";\nexport const s = OTHER;\n');
+    const verdict = (await foldProject([file], [], { lexiconPackages: ["@tsad/shapes"] })).get(file)!;
+
+    expect(verdict.verdict).toBe("run");
+  });
+
+  test("sits alongside `lexicons`, rather than replacing it", async () => {
+    const file = app('import { SIZES } from "@tsad/shapes";\nexport const s = SIZES.small;\n');
+    const verdict = (
+      await foldProject([file], [], { lexicons: ["aws"], lexiconPackages: ["@tsad/shapes"] })
+    ).get(file)!;
+
+    expect(verdict.verdict).toBe("fold");
+    expect(Object.fromEntries(verdict.exports!)).toEqual({ s: 1 });
+  });
+});

package/src/discovery/fold-import.ts

@@ -17,6 +17,8 @@ import {
   FoldableFunction,
   isFoldableFunction,
   locate,
+  collectSameFileFunctions,
+  constResolvesToResource,
   type FoldedResource,
   type FoldedValue,
   type FoldedIntrinsic,
@@ -307,6 +309,19 @@ export function createFoldSession(
   buildParams?: Readonly<Record<string, BuildParamValue>>,
   lexicons: readonly string[] = [],
   sandbox = false,
+  /**
+   * chant#2438 — package specifiers to allow verbatim, alongside the ones
+   * derived from `lexicons`.
+   *
+   * A chant build's active packages are always `@intentius/chant-lexicon-*`,
+   * so naming lexicons is the whole story there. A caller embedding the fold
+   * path against a host that is not a chant lexicon has packages the naming
+   * convention cannot express: the specification's conformance harness supplies
+   * `@tsad/shapes`, which is its host's own specifier. The boundary is
+   * unchanged, an explicitly named package of this build, only now it can be
+   * named as a specifier rather than only as a lexicon.
+   */
+  lexiconPackages: readonly string[] = [],
 ): FoldSession {
   return {
     intrinsics,
@@ -315,7 +330,7 @@ export function createFoldSession(
     importCache: new Map(),
     resolvePathCache: new Map(),
     buildParams,
-    lexiconPackages: new Set(lexicons.map(lexiconPackageName)),
+    lexiconPackages: new Set([...lexicons.map(lexiconPackageName), ...lexiconPackages]),
     sandbox,
     factoryModules: new Map(),
   };
@@ -764,14 +779,6 @@ function collectLocalBindings(sourceFile: ts.SourceFile): Map<string, LocalBindi
 }
 
 /** `(x) => …` / `function (x) {…}`, possibly wrapped in parens/`as`/`satisfies` — the initializer shapes that make a `const` a function binding. */
-function unwrapFunctionInitializer(node: ts.Expression): ts.ArrowFunction | ts.FunctionExpression | undefined {
-  let current = node;
-  while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isSatisfiesExpression(current)) {
-    current = current.expression;
-  }
-  return ts.isArrowFunction(current) || ts.isFunctionExpression(current) ? current : undefined;
-}
-
 /**
  * chant #1373 — every top-level function a file declares, exported or not, as
  * a {@link FoldableFunction}: `function f(...) {...}` and `const f = (...) =>
@@ -786,29 +793,10 @@ function unwrapFunctionInitializer(node: ts.Expression): ts.ArrowFunction | ts.F
  * module-level resource through `externals` only.
  */
 function collectLocalFunctions(sourceFile: ts.SourceFile, ctx: ResolveCtx): Map<string, FoldableFunction> {
-  const consts = new Map(ctx.consts);
-  for (const [name] of [...consts]) {
-    if (constResolvesToResource(ctx.consts, name, new Set())) consts.delete(name);
-  }
-  const functions = new Map<string, FoldableFunction>();
-  const add = (name: string, fn: ts.FunctionDeclaration | ts.ArrowFunction | ts.FunctionExpression): void => {
-    functions.set(name, new FoldableFunction(name, fn, ctx.file, consts, ctx.externals, ctx.crossFileFailures));
-  };
-
-  for (const statement of sourceFile.statements) {
-    if (ts.isFunctionDeclaration(statement)) {
-      if (statement.name && statement.body) add(statement.name.text, statement);
-      continue;
-    }
-    if (!ts.isVariableStatement(statement)) continue;
-    if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0) continue;
-    for (const decl of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(decl.name) || !decl.initializer) continue;
-      const fn = unwrapFunctionInitializer(decl.initializer);
-      if (fn) add(decl.name.text, fn);
-    }
-  }
-  return functions;
+  // chant#2436 — the walk itself, and the `new`-bound stripping that makes it
+  // correct, live in ../fold/fold.ts so a unit-level fold with no externals of
+  // its own binds exactly what a build binds.
+  return collectSameFileFunctions(sourceFile, ctx.consts, ctx.file, ctx.externals, ctx.crossFileFailures);
 }
 
 // ─────────────────────────────────────────────────────────────────────────
@@ -1939,27 +1927,6 @@ function factoryModuleScopeResolved(
   return scope.resolved;
 }
 
-/**
- * True when a module-level `const` is (transitively) bound to a
- * `new Type(...)`. Mirrors `fold()`'s own `resolvesToResource`, but follows an
- * identifier chain (`const a = new T(); const b = a;`) so aliasing can't smuggle
- * a module-level resource into a factory body — see
- * {@link FactoryModuleScope.consts}.
- */
-function constResolvesToResource(
-  consts: Map<string, ts.Expression>,
-  name: string,
-  seen: Set<string>,
-): boolean {
-  if (seen.has(name)) return false;
-  seen.add(name);
-  const init = consts.get(name);
-  if (init === undefined) return false;
-  if (ts.isNewExpression(init)) return true;
-  if (ts.isIdentifier(init)) return constResolvesToResource(consts, init.text, seen);
-  return false;
-}
-
 /**
  * Find `export const <exportName> = Composite(<fn>, "<name>")` at the top level
  * of `scope`'s module, verifying that `Composite` really is chant's own in that
@@ -4099,6 +4066,20 @@ export interface FoldProjectOptions {
   readonly buildParams?: Readonly<Record<string, BuildParamValue>>;
   /** chant #1093: this build asked for the sandbox, so fold may not reach outside the trusted allowlist. */
   readonly sandbox?: boolean;
+  /**
+   * chant#2438 — package specifiers to follow a bare import into, verbatim,
+   * alongside whatever `lexicons` names.
+   *
+   * For a chant project this is never needed: an active package is always
+   * `@intentius/chant-lexicon-<name>`, which `lexicons` already expresses. It
+   * is here for a caller driving the fold path against a host of its own, where
+   * the package has a name chant's convention cannot spell. The specification's
+   * conformance harness is the first such caller, with `@tsad/shapes`.
+   *
+   * The boundary does not move. This is still an allowlist the caller states
+   * outright, matched by text, and absent it nothing bare resolves at all.
+   */
+  readonly lexiconPackages?: readonly string[];
 }
 
 /** One file's place in a whole-build fold, as {@link foldProject} reports it. */
@@ -4146,6 +4127,7 @@ export async function foldProject(
     options.buildParams,
     options.lexicons ?? [],
     options.sandbox ?? false,
+    options.lexiconPackages ?? [],
   );
   const attempts = new Map<string, FoldFileResult>();
   for (const file of files) attempts.set(file, await tryFoldFile(file, intrinsics, session));

package/src/fold/fold.test.ts

@@ -688,11 +688,17 @@ describe("fold — registered call-form intrinsics (#1044)", () => {
     expect(() => fold(expr, consts, [REF])).toThrow(FoldError);
   });
 
-  test("a registered name SHADOWED by a local const is rejected — the local binding wins, and it isn't the lexicon's", () => {
+  test("a registered name SHADOWED by a local const folds as the LOCAL function, never the lexicon's", () => {
+    // chant#2436 — the local binding wins, which is what this has always
+    // asserted. It used to win by rejecting, because `fold()` had no way to
+    // call a local function; now it wins by being called, which is what a
+    // build does with this file. The registered meaning is still not applied:
+    // the lexicon's `Ref` produces `{ __intrinsic: "Ref" }`, this produces the
+    // arrow's own object.
     const consts = parseConsts(`const Ref = (n) => ({ mine: n }); const x = Ref("db");`);
     const expr = consts.get("x");
     if (!expr) throw new Error("fixture error");
-    expect(() => fold(expr, consts, [REF])).toThrow(FoldError);
+    expect(fold(expr, consts, [REF])).toEqual({ mine: "db" });
   });
 
   test("an unfoldable argument still rejects the whole call", () => {
@@ -765,11 +771,14 @@ describe("fold — registered authoring helpers (#1082)", () => {
     expect((error as FoldError).message).toContain("function call as a value is not foldable: compose(...)");
   });
 
-  test("a registered name SHADOWED by a local const is rejected — the local binding wins, and it isn't chant's", () => {
+  test("a registered name SHADOWED by a local const folds as the LOCAL function, never chant's", () => {
+    // chant#2436 — see the matching case under the intrinsic registry above.
+    // chant's own `phase(name, steps)` yields `{ phase, steps }`; the absence
+    // of `steps` here is what proves the shadowing arrow was the one called.
     const consts = parseConsts(`const phase = (n) => ({ phase: n }); const x = phase("Apply");`);
     const expr = consts.get("x");
     if (!expr) throw new Error("fixture error");
-    expect(() => fold(expr, consts)).toThrow(FoldError);
+    expect(fold(expr, consts)).toEqual({ phase: "Apply" });
   });
 
   test("a registered name used as a METHOD (`ns.phase(...)`) is rejected — only a bare identifier callee folds", () => {
@@ -835,11 +844,13 @@ describe("fold: the ConvergeOp rule builders are registered helpers (#2171)", ()
     }
   });
 
-  test("a rule builder SHADOWED by a local const is still rejected", () => {
+  test("a rule builder SHADOWED by a local const folds as the LOCAL function", () => {
+    // chant#2436 — the builder's own shape is `{ field, op, value }`; this
+    // yields the arrow's `{ f, v }`, so the shadowing binding is the one used.
     const consts = parseConsts(`const gt = (f, v) => ({ f, v }); const x = gt("updateCount", 0);`);
     const expr = consts.get("x");
     if (!expr) throw new Error("fixture error");
-    expect(() => fold(expr, consts)).toThrow(FoldError);
+    expect(fold(expr, consts)).toEqual({ f: "updateCount", v: 0 });
   });
 });
 
@@ -1244,3 +1255,85 @@ describe("constructions as values (chant #1169)", () => {
     });
   });
 });
+
+/**
+ * chant#2436 — a unit-level fold binds the file's own functions.
+ *
+ * The build has bound them since #1373: `fold-import.ts` puts a
+ * {@link FoldableFunction} in `externals` for every top-level declaration
+ * before folding anything. A caller with no module graph, and so no
+ * `externals`, had no way to call one, so `fold()` alone answered `run` for a
+ * shape the build folds. The spec's conformance adapter is exactly such a
+ * caller.
+ *
+ * The binding is derived from the node's own source file, and only when the
+ * caller passed no `externals` at all: a caller that passed one is managing
+ * its own bindings and may have left a name out on purpose.
+ */
+describe("fold — same-file functions without externals (chant#2436)", () => {
+  const foldSource = (src: string): unknown => {
+    const sourceFile = ts.createSourceFile("m.ts", src, ts.ScriptTarget.Latest, true);
+    const consts = collectConsts(sourceFile);
+    const expr = consts.get("x");
+    if (!expr) throw new Error("fixture has no `x`");
+    return fold(expr, consts);
+  };
+
+  test("a function declaration, exported or not", () => {
+    expect(foldSource("function twice(n) { return n * 2; } const x = twice(21);")).toBe(42);
+    expect(foldSource("export function twice(n) { return n * 2; } const x = twice(21);")).toBe(42);
+  });
+
+  test("an arrow const", () => {
+    expect(foldSource('const label = (s) => ({ label: s }); const x = label("k");')).toEqual({ label: "k" });
+  });
+
+  test("a sibling calling a sibling", () => {
+    expect(foldSource("function a(n) { return b(n) + 1; } function b(n) { return n * 2; } const x = a(10);")).toBe(21);
+  });
+
+  test("recursion terminates on its own base case", () => {
+    expect(foldSource("function down(n) { return n <= 0 ? 0 : down(n - 1); } const x = down(3);")).toBe(0);
+  });
+
+  describe("falls back to run rather than producing a value", () => {
+    const rejects = (src: string) => expect(() => foldSource(src)).toThrow(FoldError);
+
+    test("a body that reads a `new`-bound const, so no duplicate resource is built", () => {
+      // The stripping this relies on is why `collectSameFileFunctions` has one
+      // implementation: the body must read the live instance out of
+      // `externals`, never re-fold the initializer. With no externals there is
+      // no instance to read, so the only correct answer is to fall back.
+      rejects("class B { constructor(_p) {} } const b = new B({}); function f() { return b; } const x = f();");
+    });
+
+    test("through an alias of one, so aliasing cannot smuggle it in", () => {
+      rejects(
+        "class B { constructor(_p) {} } const b = new B({}); const alias = b; function f() { return alias; } const x = f();",
+      );
+    });
+
+    test("a body reading an import, which needs a module graph this entry does not have", () => {
+      rejects('import { thing } from "./other"; function f() { return thing; } const x = f();');
+    });
+
+    test("a body with a statement outside the subset", () => {
+      rejects("function f() { for (;;) {} } const x = f();");
+    });
+
+    test("a name the file never binds", () => {
+      rejects("const x = missing(1);");
+    });
+  });
+
+  test("an imported project-local function is still not called here — that needs the module graph", () => {
+    expect(() => foldSource('import { twice } from "./pure"; const x = twice(21);')).toThrow(FoldError);
+  });
+
+  test("an explicit `externals` is left alone, even when it omits the name", () => {
+    const sourceFile = ts.createSourceFile("m.ts", "function twice(n) { return n * 2; } const x = twice(21);", ts.ScriptTarget.Latest, true);
+    const consts = collectConsts(sourceFile);
+    // The caller said "these are the bindings" and did not include `twice`.
+    expect(() => fold(consts.get("x")!, consts, [], new Map())).toThrow(FoldError);
+  });
+});

package/src/fold/fold.ts

@@ -471,6 +471,131 @@ function carriesLiveObject(value: unknown, seen = new Set<unknown>()): boolean {
   return false;
 }
 
+/**
+ * True when a module-level `const` is (transitively) bound to a `new Type(...)`.
+ * Follows an identifier chain (`const a = new T(); const b = a;`) so aliasing
+ * cannot smuggle a module-level resource into a function body.
+ *
+ * chant#2436 moved this here from ../discovery/fold-import.ts so the two places
+ * that build {@link FoldableFunction}s share one implementation rather than two
+ * that can drift.
+ */
+export function constResolvesToResource(
+  consts: ReadonlyMap<string, ts.Expression>,
+  name: string,
+  seen: Set<string> = new Set(),
+): boolean {
+  if (seen.has(name)) return false;
+  seen.add(name);
+  const init = consts.get(name);
+  if (init === undefined) return false;
+  if (ts.isNewExpression(init)) return true;
+  if (ts.isIdentifier(init)) return constResolvesToResource(consts, init.text, seen);
+  return false;
+}
+
+/** `const f = (…) => …`, through parentheses / `as` / `satisfies`. */
+function unwrapFunctionInitializer(node: ts.Expression): ts.ArrowFunction | ts.FunctionExpression | undefined {
+  let current = node;
+  while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isSatisfiesExpression(current)) {
+    current = current.expression;
+  }
+  return ts.isArrowFunction(current) || ts.isFunctionExpression(current) ? current : undefined;
+}
+
+/**
+ * Every top-level function a file declares, exported or not, as a
+ * {@link FoldableFunction}: `function f(...) {...}` and `const f = (...) => …`.
+ *
+ * The markers carry `externals` BY REFERENCE, so the caller may keep filling it
+ * after this returns (which is how a sibling function, or a resource built
+ * later, becomes reachable from a body).
+ *
+ * `consts` drops every `new`-bound const, transitively through aliases: a body
+ * that mentions one must read the live instance out of `externals`, the same
+ * object the module's own fold registered, never re-fold the initializer and
+ * construct a duplicate of a resource discovery already has.
+ *
+ * chant#2436 — one implementation, called both by ../discovery/fold-import.ts
+ * during a build and by {@link fold} when a unit-level fold has no externals of
+ * its own. Getting the `new`-bound stripping wrong yields a wrong value rather
+ * than a fallback to run, which is why there is only one copy of it.
+ */
+export function collectSameFileFunctions(
+  sourceFile: ts.SourceFile,
+  consts: ReadonlyMap<string, ts.Expression>,
+  file: string,
+  externals: ReadonlyMap<string, unknown>,
+  failures?: ReadonlyMap<string, string>,
+): Map<string, FoldableFunction> {
+  const bodyConsts = new Map(consts);
+  for (const [name] of [...bodyConsts]) {
+    if (constResolvesToResource(consts, name, new Set())) bodyConsts.delete(name);
+  }
+
+  const functions = new Map<string, FoldableFunction>();
+  const add = (name: string, fn: ts.FunctionDeclaration | ts.ArrowFunction | ts.FunctionExpression): void => {
+    functions.set(name, new FoldableFunction(name, fn, file, bodyConsts, externals, failures));
+  };
+
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement)) {
+      if (statement.name && statement.body) add(statement.name.text, statement);
+      continue;
+    }
+    if (!ts.isVariableStatement(statement)) continue;
+    if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0) continue;
+    for (const decl of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(decl.name) || !decl.initializer) continue;
+      const fn = unwrapFunctionInitializer(decl.initializer);
+      if (fn) add(decl.name.text, fn);
+    }
+  }
+  return functions;
+}
+
+/**
+ * The same-file functions in scope at `node`, for a fold with no `externals`.
+ *
+ * Memoized per (source file, consts map), both of which are objects the caller
+ * holds for the duration of a fold, so a file with many calls walks its
+ * statements once. `undefined` when the node has no file to read, which is the
+ * pre-#2436 answer: the call is not foldable.
+ *
+ * The map is its own `externals`, so a function can call a sibling.
+ */
+function sameFileFunctions(
+  node: ts.Node,
+  consts: Map<string, ts.Expression>,
+): Map<string, FoldableFunction> | undefined {
+  let sourceFile: ts.SourceFile | undefined;
+  try {
+    sourceFile = node.getSourceFile();
+  } catch {
+    return undefined;
+  }
+  if (!sourceFile) return undefined;
+
+  let byConsts = sameFileFunctionCache.get(sourceFile);
+  if (!byConsts) {
+    byConsts = new WeakMap();
+    sameFileFunctionCache.set(sourceFile, byConsts);
+  }
+  const cached = byConsts.get(consts);
+  if (cached) return cached;
+
+  const scope = new Map<string, unknown>();
+  const functions = collectSameFileFunctions(sourceFile, consts, sourceFile.fileName, scope);
+  for (const [name, fn] of functions) scope.set(name, fn);
+  byConsts.set(consts, functions);
+  return functions;
+}
+
+const sameFileFunctionCache = new WeakMap<
+  ts.SourceFile,
+  WeakMap<Map<string, ts.Expression>, Map<string, FoldableFunction>>
+>();
+
 export function isFoldableFunction(value: unknown): value is FoldableFunction {
   return value instanceof FoldableFunction;
 }
@@ -1430,6 +1555,20 @@ export function fold(
       if (isFoldableFunction(callee)) {
         return callFoldableFunction(callee, node, consts, intrinsics, externals);
       }
+      // chant#2436 — the same shape, reached without a build. A caller that
+      // supplied no `externals` has no module graph and so no markers, and a
+      // same-file call fell through to the throw below even though a build
+      // folds it. Derive the file's own functions and call one.
+      //
+      // Only when `externals` is absent. A caller that passed one is managing
+      // its own bindings (a build, which already put the markers there before
+      // folding anything), and second-guessing it here could bind a name it
+      // deliberately left out. A same-file function only: an imported one needs
+      // module resolution, which this module does not do and will not start.
+      if (externals === undefined) {
+        const local = sameFileFunctions(node, consts)?.get(node.expression.text);
+        if (local) return callFoldableFunction(local, node, consts, intrinsics, local.externals);
+      }
     }
 
     // chant #1966 — the fourth call shape: a lexicon-package function its

package/src/fold/subset.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { fold, foldResource, collectConsts, FoldError } from "./fold";
-import { briefNodeText, callExpressionMessage, findSubsetViolation } from "./subset";
+import { briefNodeText, callExpressionMessage, findSubsetViolation, collectLocalCallables } from "./subset";
 import { evl001NonLiteralExpressionRule } from "../lint/rules/evl001-non-literal-expression";
 import { evl003DynamicPropertyAccessRule } from "../lint/rules/evl003-dynamic-property-access";
 import { evl004SpreadNonConstRule } from "../lint/rules/evl004-spread-non-const";
@@ -137,6 +137,38 @@ describe("subset equivalence — supported cases: fold succeeds AND EVL is clean
   }
 });
 
+/**
+ * chant#2436 closed a divergence that used to live in the block below.
+ *
+ * `phase` is a registered authoring helper, but shadowed by the file's own
+ * arrow the local binding wins — which is what #1082 asserted, and still
+ * true. It used to win by making `fold()` reject, because `fold()` had no way
+ * to call a local function; a build folded the same file. Now both fold it, so
+ * the two agree rather than diverging by design.
+ */
+describe("authoring-helper shadowing — now unified (chant#2436)", () => {
+  const source = `
+      const phase = (n) => ({ phase: n });
+      const good = new Thing({ x: phase("Apply") });
+    `;
+
+  test("fold calls the local arrow, and does not apply the registered meaning", () => {
+    const sourceFile = ts.createSourceFile("t.ts", source, ts.ScriptTarget.Latest, true);
+    const consts = collectConsts(sourceFile);
+    const folded = foldResource(consts.get("good") as ts.NewExpression, consts, []);
+
+    // chant's own `phase(name, steps)` yields `{ phase, steps }`; no `steps`
+    // here is what proves the shadowing binding was the one called.
+    expect((folded.props as { x: unknown }).x).toEqual({ phase: "Apply" });
+  });
+
+  test("and EVL001 is clean, as it always was", () => {
+    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);
+  });
+});
+
 describe("subset equivalence — unsupported cases: fold rejects AND EVL flags the same rule id + position", () => {
   for (const c of UNSUPPORTED_CASES) {
     test(c.name, () => {
@@ -241,25 +273,6 @@ describe("documented divergences — NOT unified by design (see subset.ts module
     expect(evl001NonLiteralExpressionRule.check(context)).toHaveLength(0);
   });
 
-  test("authoring-helper shadowing: fold rejects a registered name bound to a local const; EVL001 does not (shape-only, no binding resolution)", () => {
-    // chant #1082 — `phase` is registered, but here it's the file's own local
-    // arrow function, so the local binding wins and fold() rejects. EVL has no
-    // binding resolver (subset.ts module doc, point 1) and stays permissive —
-    // the same direction as every other divergence here.
-    const source = `
-      const phase = (n) => ({ phase: n });
-      const bad = new Thing({ x: phase("Apply") });
-    `;
-    const sourceFile = ts.createSourceFile("t.ts", source, ts.ScriptTarget.Latest, true);
-    const consts = collectConsts(sourceFile);
-    const badInit = consts.get("bad") as ts.NewExpression;
-
-    expect(() => foldResource(badInit, consts, [])).toThrow(FoldError);
-
-    const context: LintContext = { sourceFile, entities: [], filePath: "t.ts", lexicon: undefined };
-    expect(evl001NonLiteralExpressionRule.check(context)).toHaveLength(0);
-  });
-
   test("method call on an unresolved receiver: fold rejects; EVL001 accepts the shape (chant #1966, resolution-dependent)", () => {
     // `config.getName()` — chant #1966 widened `findSubsetViolation` to
     // accept a method call unconditionally (mirroring `.step` and a nested
@@ -550,3 +563,131 @@ describe("callExpressionMessage — one line regardless of the call's own argume
     expect(message).toBe("function call as a value is not foldable: GkeCluster(...)");
   });
 });
+
+/**
+ * chant#2435 — `S-CallLocal`.
+ *
+ * The classifier rejected every call to a project-local function while the
+ * build folds all of them, which is the one direction `F-Direction` forbids:
+ * this module may accept what the fold rejects, never the reverse. In practice
+ * it meant `chant lint` reported EVL001 on a file `chant build --fold` folds
+ * cleanly.
+ *
+ * The admission is by NAME and the names come from the node's own source file,
+ * so nothing a caller does changes the answer.
+ */
+describe("findSubsetViolation — project-local calls (chant#2435)", () => {
+  /** The initializer of `export const x = …` in `src`, with its file attached. */
+  const initializerOf = (src: string): ts.Expression => {
+    const sourceFile = ts.createSourceFile("m.ts", src, ts.ScriptTarget.Latest, true);
+    for (const statement of sourceFile.statements) {
+      if (!ts.isVariableStatement(statement)) continue;
+      for (const decl of statement.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name) && decl.name.text === "x" && decl.initializer) return decl.initializer;
+      }
+    }
+    throw new Error("fixture has no `x`");
+  };
+  const accepts = (src: string) => findSubsetViolation(initializerOf(src)) === undefined;
+
+  describe("admitted, because a build folds them", () => {
+    test("a same-file function declaration, exported or not", () => {
+      expect(accepts("function twice(n: number) { return n * 2; }\nexport const x = twice(21);")).toBe(true);
+      expect(accepts("export function twice(n: number) { return n * 2; }\nexport const x = twice(21);")).toBe(true);
+    });
+
+    test("a same-file arrow const, through parentheses and `as`", () => {
+      expect(accepts('const label = (s: string) => ({ label: s });\nexport const x = label("k");')).toBe(true);
+      expect(accepts('const label = ((s: string) => s) as (s: string) => string;\nexport const x = label("k");')).toBe(true);
+    });
+
+    test("a name imported from a project specifier", () => {
+      expect(accepts('import { twice } from "./pure";\nexport const x = twice(21);')).toBe(true);
+      expect(accepts('import { twice } from "../lib/pure";\nexport const x = twice(21);')).toBe(true);
+    });
+
+    test("a default import from a project specifier", () => {
+      expect(accepts('import make from "./make";\nexport const x = make(1);')).toBe(true);
+    });
+  });
+
+  describe("still rejected, so the diagnostic keeps its value", () => {
+    test("a call to a name imported from a package", () => {
+      expect(accepts('import { v4 } from "uuid";\nexport const x = v4();')).toBe(false);
+    });
+
+    test("a call to a name the file never binds", () => {
+      expect(accepts("export const x = getId();")).toBe(false);
+    });
+
+    test("a local name that shadows nothing local — the specifier decides, not the name", () => {
+      expect(accepts('import { twice } from "some-package";\nexport const x = twice(1);')).toBe(false);
+    });
+
+    test("a type-only import, which is erased before anything can call it", () => {
+      expect(accepts('import type { T } from "./t";\nexport const x = T();')).toBe(false);
+      expect(accepts('import { type T } from "./t";\nexport const x = T();')).toBe(false);
+    });
+
+    test("a `let`-bound arrow, which `S-LocalFunction` does not admit", () => {
+      expect(accepts("let f = (n: number) => n;\nexport const x = f(1);")).toBe(false);
+    });
+
+    test("a function nested inside another, so not a top-level binding", () => {
+      expect(accepts("function outer() { function inner() { return 1; } return inner; }\nexport const x = inner();")).toBe(false);
+    });
+
+    test("an argument outside the subset, even when the callee is local", () => {
+      const violation = findSubsetViolation(
+        initializerOf("function twice(n: number) { return n; }\nexport const x = twice(getId());"),
+      );
+      expect(violation?.ruleId).toBe("EVL001");
+      // The rejection points at the argument, not at the admitted call.
+      expect(violation?.node.getText()).toBe("getId()");
+    });
+  });
+
+  describe("collectLocalCallables", () => {
+    test("collects each binding kind, and nothing else", () => {
+      const sourceFile = ts.createSourceFile(
+        "m.ts",
+        [
+          'import { fromProject } from "./p";',
+          'import fromProjectDefault from "./d";',
+          'import { fromPackage } from "pkg";',
+          'import type { TypeOnly } from "./t";',
+          "export function declared() { return 1; }",
+          "const arrowConst = () => 1;",
+          "let notConst = () => 1;",
+          "const notAFunction = 1;",
+        ].join("\n"),
+        ts.ScriptTarget.Latest,
+        true,
+      );
+
+      expect([...collectLocalCallables(sourceFile)].sort()).toEqual([
+        "arrowConst",
+        "declared",
+        "fromProject",
+        "fromProjectDefault",
+      ]);
+    });
+
+    test("is memoized per source file, so a large file is walked once", () => {
+      const sourceFile = ts.createSourceFile("m.ts", "function f() { return 1; }", ts.ScriptTarget.Latest, true);
+      expect(collectLocalCallables(sourceFile)).toBe(collectLocalCallables(sourceFile));
+    });
+  });
+
+  test("the local-callable lookup is not a new failure mode for a node with no file", () => {
+    // A synthetic node has no parent chain, so `getSourceFile()` throws. That
+    // is pre-existing: `violation()` renders the offending node with
+    // `getText()`, which throws for the same reason, so this shape was never
+    // supported. What is asserted here is narrower and is what chant#2435
+    // could have broken: the lookup added in front of that rejection swallows
+    // the throw instead of turning it into a different error.
+    const synthetic = ts.factory.createCallExpression(ts.factory.createIdentifier("twice"), undefined, []);
+    expect(() => collectLocalCallables(synthetic.getSourceFile())).toThrow();
+    expect(() => findSubsetViolation(synthetic)).toThrow(/Cannot read|undefined|getSourceFile|getText/i);
+  });
+});

package/src/fold/subset.ts

@@ -48,7 +48,16 @@ import { intrinsicCallFolds, intrinsicCallFoldsEagerly, type IntrinsicDef } from
  * expression, its operator, and (for keys) its literal-ness. It
  * deliberately does NOT resolve bindings or perform any evaluation, because
  * three things a full fold needs are inherently environment-dependent and
- * cannot be recovered from shape alone:
+ * cannot be recovered from shape alone.
+ *
+ * One thing it does read beyond the expression itself, since chant#2435: the
+ * enclosing file's top-level bindings, for `S-CallLocal`. A call to a
+ * project-local function is admitted by NAME (see
+ * {@link collectLocalCallables}), which is decidable from that file's syntax
+ * and needs no resolution. Before that, this module rejected all four shapes
+ * the build folds, which is the one direction `F-Direction` forbids, and it
+ * made `chant lint` report EVL001 on a file `chant build --fold` folds
+ * cleanly. The three genuinely environment-dependent cases are:
  *
  *   1. Identifier *resolution* — is a bare name actually a local `const`,
  *      vs. an unbound name? That needs the file's `consts` map. Both
@@ -237,6 +246,111 @@ export function briefNodeText(node: ts.Node, maxLength = 60): string {
   return collapsed.length > maxLength ? `${collapsed.slice(0, maxLength - 3)}...` : collapsed;
 }
 
+// ---------------------------------------------------------------------------
+// Project-local callables (chant#2435, spec `S-CallLocal`)
+// ---------------------------------------------------------------------------
+
+/**
+ * Every name a file binds to something a project-local call can reach.
+ *
+ * Two bindings, both of which the specification's `S-LocalFunction` names and
+ * both decidable from this file's own syntax, which is all a shape classifier
+ * has:
+ *
+ *   - a top-level `function f(...) {...}`, or a `const f = (...) => ...`
+ *     (a function expression counts, and parentheses / `as` / `satisfies`
+ *     wrappers are unwrapped), exported or not;
+ *   - a name imported from a *project* specifier, one starting `./` or `../`.
+ *     A bare specifier is a package, and a package's function is not
+ *     project-local.
+ *
+ * Deliberately syntax-only, and deliberately not a judgment about the callee's
+ * body. Whether the body is admissible is `S-FnBody`'s question and the fold's
+ * to answer, exactly as it already is for a call this classifier admits by
+ * name (a registered authoring helper, an opted-in intrinsic).
+ *
+ * Mirrors `collectLocalFunctions` in ../discovery/fold-import.ts, which builds
+ * the real `FoldableFunction` for each of these during a build. This one only
+ * needs the names.
+ */
+export function collectLocalCallables(sourceFile: ts.SourceFile): ReadonlySet<string> {
+  const cached = localCallableCache.get(sourceFile);
+  if (cached) return cached;
+
+  const names = new Set<string>();
+  const unwrap = (node: ts.Expression): ts.Expression => {
+    let current = node;
+    while (
+      ts.isParenthesizedExpression(current) ||
+      ts.isAsExpression(current) ||
+      ts.isSatisfiesExpression(current)
+    ) {
+      current = current.expression;
+    }
+    return current;
+  };
+
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement)) {
+      if (statement.name && statement.body) names.add(statement.name.text);
+      continue;
+    }
+    if (ts.isImportDeclaration(statement)) {
+      const specifier = statement.moduleSpecifier;
+      if (!ts.isStringLiteral(specifier) || !/^\.\.?\//.test(specifier.text)) continue;
+      const clause = statement.importClause;
+      // `import type { T } from "./t"` is erased before anything runs, so `T`
+      // is not something a call can reach. Both spellings are skipped: the
+      // whole-clause one and the per-specifier `import { type T }`.
+      if (!clause || clause.isTypeOnly) continue;
+      if (clause.name) names.add(clause.name.text);
+      const bindings = clause.namedBindings;
+      if (bindings && ts.isNamedImports(bindings)) {
+        for (const element of bindings.elements) {
+          if (!element.isTypeOnly) names.add(element.name.text);
+        }
+      }
+      continue;
+    }
+    if (!ts.isVariableStatement(statement)) continue;
+    if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0) continue;
+    for (const decl of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(decl.name) || !decl.initializer) continue;
+      const initializer = unwrap(decl.initializer);
+      if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {
+        names.add(decl.name.text);
+      }
+    }
+  }
+
+  localCallableCache.set(sourceFile, names);
+  return names;
+}
+
+/** Per-file memo: the classifier asks this once per call expression, and a big file has many. */
+const localCallableCache = new WeakMap<ts.SourceFile, ReadonlySet<string>>();
+
+/**
+ * The project-local callables in scope at `node`, or an empty set when the node
+ * has no file to read.
+ *
+ * The guard is not a claim that a file-less node is supported: the rejection
+ * this sits in front of renders the node with `getText()`, which needs the same
+ * parent chain. It is here so that looking the names up never becomes a *new*
+ * way for this function to fail, and so the answer for a node whose file cannot
+ * be read is the pre-#2435 one, that every call is a violation.
+ */
+function localCallablesAt(node: ts.Node): ReadonlySet<string> {
+  try {
+    const sourceFile = node.getSourceFile();
+    return sourceFile ? collectLocalCallables(sourceFile) : EMPTY_NAMES;
+  } catch {
+    return EMPTY_NAMES;
+  }
+}
+
+const EMPTY_NAMES: ReadonlySet<string> = new Set<string>();
+
 // ---------------------------------------------------------------------------
 // Shared message builders — `fold()` and `findSubsetViolation` both call
 // these so the diagnostic text for the same violation kind is the same
@@ -547,6 +661,27 @@ export function findSubsetViolation(
       return undefined;
     }
 
+    // chant#2435 — a call to a project-local function. `fold-import.ts` binds
+    // every top-level function a file declares (and every one it imports from
+    // a project file) before folding it, so a build folds all four shapes the
+    // issue tabulates; this classifier rejected all four. That is the one
+    // direction `F-Direction` forbids, and it made `chant lint` report EVL001
+    // on a file `chant build --fold` folds cleanly.
+    //
+    // Name-only, like the authoring-helper case above and for the same reason:
+    // this module classifies shape and never resolves bindings. Whether the
+    // callee's body is admissible is `S-FnBody`'s question, which the fold
+    // answers. The set comes from the node's own source file, so every caller
+    // gets the corrected answer without passing anything — a caller holding a
+    // synthetic node with no file keeps the old, stricter one.
+    if (ts.isIdentifier(node.expression) && localCallablesAt(node).has(node.expression.text)) {
+      for (const arg of node.arguments) {
+        const v = findSubsetViolation(arg, intrinsics);
+        if (v) return v;
+      }
+      return undefined;
+    }
+
     return violation(node, callExpressionMessage(node));
   }
 

package/src/index.ts

@@ -43,7 +43,7 @@ export * from "./fold/fold";
 // fold?" of without running a fold (subset.ts module doc, point 2c), and the
 // half of the fold subset a conformance adapter needs that `fold()` alone
 // does not expose. INTENTIUS/typescript-as-data#11.
-export { findSubsetViolation, checkObjectMember, type SubsetViolation, type SubsetRuleId } from "./fold/subset";
+export { findSubsetViolation, checkObjectMember, collectLocalCallables, type SubsetViolation, type SubsetRuleId } from "./fold/subset";
 // The version of the TypeScript-as-Data specification chant implements
 // (INTENTIUS/typescript-as-data#18, chant#2424). The specification's
 // conformance adapter reads this off the public entry; without it a suite