@mnemonica/tactica 0.1.12 → 0.1.15

package/lib/analyzer.d.ts

@@ -11,6 +11,10 @@ export declare class MnemonicaAnalyzer {
     private usages;
     private edsUsages;
     private flowUsages;
+    private edsScopeByNode;
+    private functionBindings;
+    private nestedWrapVia;
+    private wrapEntryByNode;
     private typeAliases;
     private variableToTypeMap;
     private moduleObjectVariables;
@@ -343,8 +347,43 @@ export declare class MnemonicaAnalyzer {
      * Resolve type from EDS call argument (best effort)
      */
     private resolveEDSArgumentType;
+    /**
+     * Resolve the enclosing mnemonica scope of an EDS call site by walking
+     * up the parent chain: nearest define()/lazy() call whose handler holds
+     * the node, or nearest @decorate()-ed class declaration. Best effort —
+     * returns undefined for calls outside any type scope (module top level).
+     */
+    private resolveEDSScope;
+    /**
+     * Resolve a wrap() argument to its function node without the type
+     * checker: direct function expressions/arrows, or same-file bindings
+     * (`const fn = () => ...`, `function fn() ...`). Best effort — method
+     * references, .bind() products and cross-file identifiers stay
+     * unresolved; the callsite entry itself is still recorded.
+     */
+    private resolveFunctionArgument;
+    /**
+     * Analyse a wrapped function's body for guaranteed runtime paths:
+     * dive wraps returned functions as well (recursively), so each
+     * function-valued return is a nested wrap site, and each `new Type()`
+     * inside the body means the path hits that type's constructor (which
+     * attachHooks wraps too). Both facts are 100% ensured, so they are
+     * recorded AoT. Nested function bodies are NOT walked here — they
+     * belong to their own wrap analysis, reached via the return chain.
+     * Depth-capped and cycle-guarded.
+     */
+    private analyzeWrappedBody;
+    /**
+     * Record one function-valued return of a wrapped body as a nested wrap
+     * site (`via` = the site whose wrapping caused it) and recurse into
+     * its own returns. Returns through identifiers resolve through the
+     * same-file bindings table; unresolvable returns are simply skipped.
+     */
+    private recordWrappedReturn;
     /**
      * Add an EDS usage to the collection
+     * Returns the stored entry (the existing one when this is a duplicate),
+     * so callers can enrich it after nested body analysis.
      */
     private addEDS;
     /**