@scriptc/compiler 0.2.5 → 0.2.7

package/dist/frontend/program-analysis.js

@@ -5,10 +5,12 @@ export class ProgramAnalysis {
     createRequireReasons = new Map();
     nodeEsmFiles = new Map();
     prunedNpmReexports = new Set();
+    moduleSourceCandidates = new Map();
     clear() {
         this.createRequireReasons.clear();
         this.nodeEsmFiles.clear();
         this.prunedNpmReexports.clear();
+        this.moduleSourceCandidates.clear();
     }
 }
 //# sourceMappingURL=program-analysis.js.map

package/dist/frontend/program-analysis.js.map

@@ -1 +1 @@
-{"version":3,"file":"program-analysis.js","sourceRoot":"","sources":["../../src/frontend/program-analysis.ts"],"names":[],"mappings":"AAEA;;6EAE6E;AAC7E,MAAM,OAAO,eAAe;IACjB,oBAAoB,GAAG,IAAI,GAAG,EAAsC,CAAC;IACrE,YAAY,GAAG,IAAI,GAAG,EAAuB,CAAC;IAC9C,kBAAkB,GAAG,IAAI,GAAG,EAAqB,CAAC;IAE3D,KAAK;QACH,IAAI,CAAC,oBAAoB,CAAC,KAAK,EAAE,CAAC;QAClC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAC1B,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;IAClC,CAAC;CACF"}
+{"version":3,"file":"program-analysis.js","sourceRoot":"","sources":["../../src/frontend/program-analysis.ts"],"names":[],"mappings":"AAGA;;6EAE6E;AAC7E,MAAM,OAAO,eAAe;IACjB,oBAAoB,GAAG,IAAI,GAAG,EAAsC,CAAC;IACrE,YAAY,GAAG,IAAI,GAAG,EAAuB,CAAC;IAC9C,kBAAkB,GAAG,IAAI,GAAG,EAAqB,CAAC;IAClD,sBAAsB,GAAG,IAAI,GAAG,EAAsC,CAAC;IAEhF,KAAK;QACH,IAAI,CAAC,oBAAoB,CAAC,KAAK,EAAE,CAAC;QAClC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAC1B,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;QAChC,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,CAAC;IACtC,CAAC;CACF"}

package/dist/frontend/program.d.ts

@@ -139,17 +139,53 @@ export interface CycleEdge {
  * e.dep already mid-initialization in a depth-first walk), answers null
  * to ADMIT the cycle — the guarded %init calls reproduce Node's cache-hit
  * order and nothing can observe the partial initialization — or the
- * human-readable reason it keeps the SC1016 fence. Two admission chances:
+ * human-readable reason it keeps the SC1016 fence. Three admission chances:
  *  - the CHEAP PER-EDGE rule: the closing statement binds nothing (a
  *    side-effect import) or binds only namespace objects whose every use
  *    is a bare expression statement — no read crosses the edge at all;
  *  - the DECLARATION-ONLY INIT WINDOW rule (the admission block above):
  *    every cluster member is an ES module with an inert top level, and
- *    the closing edge's bindings are used only in deferred positions.
+ *    the closing edge's bindings are used only in deferred positions;
+ *  - the EXACT INITIALIZATION rule (exactCycleRefusal7): partial
+ *    initialization is observable, but every observation is modeled —
+ *    the lowering checks each binding cycleEarlyBindings reports.
  * Tarjan SCCs (lazy, rooted at each queried importer) and cluster
  * verdicts are memoized across calls, so `edgesOf` must answer the same
  * edges for the same file every time. */
 export declare function makeCycleAdmission(program: ts.Program, edgesOf: (sf: ts.SourceFile) => readonly CycleEdge[]): (importer: ts.SourceFile, e: CycleEdge) => string | null;
+/** The modules of `program` whose import cycles were admitted by the
+ * exact initialization rule (not the declaration-only rule). */
+export declare function exactCycleMembers(program: ts.Program): ReadonlySet<ts.SourceFile>;
+/** A module-scope binding of an exactly-initialized cycle that some read
+ * or write can reach before its declaration ran. */
+export interface CycleEarlyBinding {
+    symbol: ts.Symbol;
+    /** The declaration's name. */
+    name: ts.Identifier;
+    kind: "lexical" | "var" | "class";
+    module: ts.SourceFile;
+    /** One reference that can run before the declaration. */
+    reference: ts.Identifier;
+    /** A reference in a position the lowering may resolve at compile time
+     * from the binding's type (a property key, a `typeof` operand). */
+    folded?: ts.Identifier;
+    /** Modules whose TOP-LEVEL code runs only after the declaration ran:
+     * modules outside the cycle and cycle members evaluated later. */
+    settled: ReadonlySet<ts.SourceFile>;
+}
+/** Every binding of the program's exactly-initialized cycles that can be
+ * observed before its declaration executes. `order` is the compiled module
+ * order; `singleRoot` is false when more than one module graph root runs
+ * (fork or worker entries), so a cycle can be entered at different
+ * members. With one root and a purely ES-module graph the evaluation order
+ * is static and the analysis is precise up to "user code may run": a
+ * binding needs its check when its declaration completes after some
+ * top-level code that can call user functions and a deferred position
+ * (function body, parameter default, instance field) references it, or
+ * when the top level of a cycle member evaluated before it reads it.
+ * Otherwise every deferred reference and every top-level reference from
+ * another member counts. */
+export declare function cycleEarlyBindings(program: ts.Program, entry: ts.SourceFile, order: readonly ts.SourceFile[], singleRoot: boolean): CycleEarlyBinding[];
 /** Resolves an import specifier from `from` to a source file of the
  * program, or null (unresolvable / outside the program). Exported (as
  * resolveImport) for the lowering: CommonJS require statements lower to