veoflow 0.5.2 → 0.5.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/veo.mjs CHANGED
@@ -3420,7 +3420,7 @@ var init_catalog = __esm({
3420
3420
  init_src();
3421
3421
  init_project_store();
3422
3422
  init_sqlite();
3423
- DEFAULT_PROJECT_SETTINGS = { maxFileMB: 10 };
3423
+ DEFAULT_PROJECT_SETTINGS = { maxFileMB: 10, closedWorld: false };
3424
3424
  SCHEMA2 = `
3425
3425
  CREATE TABLE IF NOT EXISTS projects (id TEXT PRIMARY KEY, name TEXT NOT NULL, created_at TEXT NOT NULL);
3426
3426
  CREATE TABLE IF NOT EXISTS sources (
@@ -4446,6 +4446,7 @@ async function runNow(request) {
4446
4446
  view: run2.view().withStages(request.stages.slice(0, index + 1).map((s) => s.name)),
4447
4447
  evidence: request.evidence,
4448
4448
  entitlements,
4449
+ settings: request.settings ?? {},
4449
4450
  progress
4450
4451
  });
4451
4452
  const facts = write2.facts.length;
@@ -5665,10 +5666,18 @@ var init_engine = __esm({
5665
5666
  throw new VeoError("invalid-arguments", `maxFileMB must be a number between 0 and ${MAX_FILE_MB_CAP}`, {
5666
5667
  fields: ["maxFileMB"]
5667
5668
  });
5669
+ const closedWorld = args.settings?.closedWorld;
5670
+ if (closedWorld !== void 0 && typeof closedWorld !== "boolean")
5671
+ throw new VeoError("invalid-arguments", "closedWorld must be true or false", {
5672
+ fields: ["closedWorld"]
5673
+ });
5668
5674
  const project2 = this.resolveProject(args, cwd);
5669
5675
  return {
5670
5676
  project: project2.id,
5671
- settings: this.catalog.setProjectSettings(project2.id, mb === void 0 ? {} : { maxFileMB: mb })
5677
+ settings: this.catalog.setProjectSettings(project2.id, {
5678
+ ...mb === void 0 ? {} : { maxFileMB: mb },
5679
+ ...closedWorld === void 0 ? {} : { closedWorld }
5680
+ })
5672
5681
  };
5673
5682
  }
5674
5683
  /**
@@ -5738,6 +5747,7 @@ var init_engine = __esm({
5738
5747
  ...options2.coalesce ? { coalesce: options2.coalesce } : {},
5739
5748
  ...options2.ref ? { ref: options2.ref } : {},
5740
5749
  planOptions: { maxFileBytes: this.catalog.projectSettings(project2.id).maxFileMB * MB },
5750
+ settings: { closedWorld: this.catalog.projectSettings(project2.id).closedWorld },
5741
5751
  signal: controller.signal,
5742
5752
  ...this.killableRuns ? { killable: true } : {},
5743
5753
  onEvent: (e) => {
@@ -7999,7 +8009,7 @@ function completenessOf(reader, inScope, withinFiles, acrossFiles) {
7999
8009
  else exits2.named++;
8000
8010
  if (x.byType) exits2.byType++;
8001
8011
  };
8002
- for (const site of reader.facts("UnresolvedCallSite")) {
8012
+ for (const site of visibleSites(reader.facts("UnresolvedCallSite"), reader)) {
8003
8013
  if (!inScope(site.file)) continue;
8004
8014
  const r = resolutions.get(site.id);
8005
8015
  if (r?.status === "linked" || !r && (site.status === "linked" || site.status === "runtime-confirmed"))
@@ -8044,6 +8054,7 @@ var init_totals = __esm({
8044
8054
  "packages/query-imports/src/totals.ts"() {
8045
8055
  "use strict";
8046
8056
  init_src();
8057
+ init_src6();
8047
8058
  init_reads();
8048
8059
  TOTALS_TOP_MAX = 100;
8049
8060
  }
@@ -8102,6 +8113,7 @@ function findingsIn(reader, groupOf, files) {
8102
8113
  line: fact.evidence.span.start.line,
8103
8114
  text: oneLine(text),
8104
8115
  reason,
8116
+ stage: fact.type !== "UnresolvedCallSite" ? "stage2" : fact.component ? "template-link" : "stage1",
8105
8117
  ...candidates ? { candidates } : {},
8106
8118
  ...exhaustive === false ? { exhaustive } : {},
8107
8119
  ...builtins.length ? { mayBe: { builtins, projectFunctions: functionsNamed(reader, calledMember(text)) } } : {},
@@ -8404,12 +8416,13 @@ function getGroup(engine, args, cwd) {
8404
8416
  }
8405
8417
  const callEdges = /* @__PURE__ */ new Map();
8406
8418
  const callStubs = /* @__PURE__ */ new Map();
8407
- const call = (map2, from, to, kind, evidence) => {
8419
+ const call = (map2, from, to, kind, evidence, byStage2) => {
8408
8420
  const id = `calls|${from}->${to}`;
8409
8421
  let e = map2.get(id);
8410
- if (!e) map2.set(id, e = { id, from, to, count: 0, calls: 0, references: 0, evidence });
8422
+ if (!e) map2.set(id, e = { id, from, to, count: 0, calls: 0, references: 0, stage2: 0, evidence });
8411
8423
  e.count++;
8412
8424
  e[kind]++;
8425
+ if (byStage2) e.stage2++;
8413
8426
  if (byEvidence({ evidence, id }, { evidence: e.evidence, id }) < 0) e.evidence = evidence;
8414
8427
  };
8415
8428
  const fileOfFn2 = (fn) => fn.slice(0, fn.indexOf(":", fn.indexOf(":") + 1));
@@ -8417,14 +8430,19 @@ function getGroup(engine, args, cwd) {
8417
8430
  const from = nodeOf.get(f.id);
8418
8431
  if (!kept.has(from)) continue;
8419
8432
  const ends = [
8420
- ...reader.facts("CALLS_CROSS_FILE", f.id).map((e) => [e.to, "calls", e.evidence]),
8421
- ...reader.facts("REFERENCES", f.id).filter((r) => !r.exit).map((r) => [r.to, "references", r.evidence])
8433
+ ...reader.facts("CALLS_CROSS_FILE", f.id).map((e) => [
8434
+ e.to,
8435
+ "calls",
8436
+ e.evidence,
8437
+ e.via !== "template-link"
8438
+ ]),
8439
+ ...reader.facts("REFERENCES", f.id).filter((r) => !r.exit).map((r) => [r.to, "references", r.evidence, true])
8422
8440
  ];
8423
- for (const [fn, kind, evidence] of ends) {
8441
+ for (const [fn, kind, evidence, byStage2] of ends) {
8424
8442
  const file2 = fileOfFn2(fn);
8425
8443
  if (members2.has(file2)) {
8426
8444
  const to = nodeOf.get(file2);
8427
- if (to !== from) call(callEdges, from, to, kind, evidence);
8445
+ if (to !== from) call(callEdges, from, to, kind, evidence, byStage2);
8428
8446
  continue;
8429
8447
  }
8430
8448
  const g = groupOf.get(file2);
@@ -8432,7 +8450,7 @@ function getGroup(engine, args, cwd) {
8432
8450
  const id = `stub|${g.id}`;
8433
8451
  if (!stubs.has(id))
8434
8452
  stubs.set(id, { kind: "group", id, group: g.id, name: g.name, source: g.source, count: 0 });
8435
- call(callStubs, from, id, kind, evidence);
8453
+ call(callStubs, from, id, kind, evidence, byStage2);
8436
8454
  }
8437
8455
  }
8438
8456
  const packages = stubs.get("stub|packages");
@@ -8970,7 +8988,7 @@ function explainSite(reader, s, r, stage22) {
8970
8988
  return {
8971
8989
  ...at,
8972
8990
  outcome: "linked",
8973
- summary: `${s.expression} calls ${target2.name} in ${target2.path}${r.hops?.length ? `, through ${r.hops.length} re-export${r.hops.length > 1 ? "s" : ""}` : ""}.`,
8991
+ summary: `${s.expression} calls ${target2.name} in ${target2.path}${r.hops?.length ? `, through ${r.hops.length} re-export${r.hops.length > 1 ? "s" : ""}` : ""}${r.via === "injection" ? ", the class the framework injects" : r.via === "flow" ? ", the only function its receiver's value can run" : r.via === "closed-world" ? ", assuming the analyzed code is the whole program (closed world)" : ""}.`,
8974
8992
  steps: r.steps,
8975
8993
  target: target2
8976
8994
  };
@@ -8995,14 +9013,15 @@ function explainSite(reader, s, r, stage22) {
8995
9013
  ...pkg ? { target: pkg } : {},
8996
9014
  ...exit
8997
9015
  };
9016
+ const injection = r.candidates?.length && last?.kind === "injection" ? last.detail : null;
8998
9017
  if (r.candidates?.length)
8999
9018
  return {
9000
9019
  ...at,
9001
9020
  outcome: "ambiguous",
9002
- summary: typed ? `${s.expression}: ${typed}; ${last?.detail ?? ""}, so none is linked.` : r.exhaustive === false ? `${s.expression} could call ${r.candidates.length === 1 ? "the 1 known function" : `any of ${r.candidates.length} known functions`}, or a method of any other object of the right shape, so none is linked.` : `${s.expression} could call ${r.candidates.length === 1 ? "only 1 function" : `any of ${r.candidates.length} functions`}, so none is linked.`,
9021
+ summary: injection ? `${s.expression} could call ${r.candidates.length === 1 ? "the 1 known function" : `any of ${r.candidates.length} known functions`}: it is injected, but ${injection}, so none is linked.` : typed ? `${s.expression}: ${typed}; ${last?.detail ?? ""}, so none is linked.` : r.exhaustive === false ? `${s.expression} could call ${r.candidates.length === 1 ? "the 1 known function" : `any of ${r.candidates.length} known functions`}, or a method of any other object of the right shape, so none is linked.` : `${s.expression} could call ${r.candidates.length === 1 ? "only 1 function" : `any of ${r.candidates.length} functions`}, so none is linked.`,
9003
9022
  steps: r.steps,
9004
9023
  candidates: r.candidates.map((c) => end(reader, c.function)),
9005
- toResolve: CALL_FIXES.candidates,
9024
+ toResolve: injection ? CALL_FIXES.injection : CALL_FIXES.candidates,
9006
9025
  ...r.exhaustive === false ? { exhaustive: false } : {}
9007
9026
  };
9008
9027
  const stop = r.steps.at(-1);
@@ -9274,6 +9293,7 @@ var init_explain = __esm({
9274
9293
  "no-body": "It calls whatever function is passed in: see what reaches this function, and what it passes.",
9275
9294
  "bodies-unknown": "A class reaching the type isn't in the project: add the source that holds it.",
9276
9295
  default: "Callers pass what runs: see what calls this function.",
9296
+ injection: "Let the framework's wiring fix the class: provide the token as one class, set the field only from the constructor, and construct the class only through the framework.",
9277
9297
  candidates: "One of the known functions runs, and nothing in the code fixes which (a type doesn't, D72): calling the function itself would.",
9278
9298
  "dynamic-dispatch": "Write the receiver's type, or call the function by name.",
9279
9299
  "computed-member": "Call the member by name, or narrow the key to known names.",
@@ -9501,6 +9521,7 @@ function graphOf(reader, candidates) {
9501
9521
  from: id,
9502
9522
  to: e.to,
9503
9523
  kind: e.type === "CALLS" ? "call" : "cross-file",
9524
+ stage: callStage(e),
9504
9525
  trust: "exact",
9505
9526
  evidence: e.evidence
9506
9527
  });
@@ -9517,7 +9538,14 @@ function graphOf(reader, candidates) {
9517
9538
  continue;
9518
9539
  }
9519
9540
  if (fnOf(r.to))
9520
- out.edges.push({ from: id, to: r.to, kind: "reference", trust: "exact", evidence: r.evidence });
9541
+ out.edges.push({
9542
+ from: id,
9543
+ to: r.to,
9544
+ kind: "reference",
9545
+ stage: "stage2",
9546
+ trust: "exact",
9547
+ evidence: r.evidence
9548
+ });
9521
9549
  }
9522
9550
  const linked = new Set(out.edges.map((e) => e.to));
9523
9551
  for (const { child, exact } of inlineChildren(id))
@@ -9526,6 +9554,7 @@ function graphOf(reader, candidates) {
9526
9554
  from: id,
9527
9555
  to: child,
9528
9556
  kind: "inline",
9557
+ stage: "stage1",
9529
9558
  trust: exact ? "exact" : "candidate",
9530
9559
  evidence: evidenceOfFn(child)
9531
9560
  });
@@ -9547,6 +9576,7 @@ function graphOf(reader, candidates) {
9547
9576
  from: id,
9548
9577
  to: c.function,
9549
9578
  kind: "candidate",
9579
+ stage: "stage2",
9550
9580
  trust: "candidate",
9551
9581
  ...r.exhaustive === false ? { exhaustive: false } : {},
9552
9582
  evidence: s.evidence
@@ -9585,18 +9615,27 @@ function graphOf(reader, candidates) {
9585
9615
  from: e.from,
9586
9616
  to: id,
9587
9617
  kind: e.type === "CALLS" ? "call" : "cross-file",
9618
+ stage: callStage(e),
9588
9619
  trust: "exact",
9589
9620
  evidence: e.evidence
9590
9621
  });
9591
9622
  for (const r of reader.factsTo("REFERENCES", id))
9592
9623
  if (fnOf(r.from))
9593
- out.edges.push({ from: r.from, to: id, kind: "reference", trust: "exact", evidence: r.evidence });
9624
+ out.edges.push({
9625
+ from: r.from,
9626
+ to: id,
9627
+ kind: "reference",
9628
+ stage: "stage2",
9629
+ trust: "exact",
9630
+ evidence: r.evidence
9631
+ });
9594
9632
  const nest = inlineParent(id);
9595
9633
  if (nest && !out.edges.some((e) => e.from === nest.parent))
9596
9634
  out.edges.push({
9597
9635
  from: nest.parent,
9598
9636
  to: id,
9599
9637
  kind: "inline",
9638
+ stage: "stage1",
9600
9639
  trust: nest.exact ? "exact" : "candidate",
9601
9640
  evidence: evidenceOfFn(id)
9602
9641
  });
@@ -9605,6 +9644,7 @@ function graphOf(reader, candidates) {
9605
9644
  from,
9606
9645
  to: id,
9607
9646
  kind: "candidate",
9647
+ stage: "stage2",
9608
9648
  trust: "candidate",
9609
9649
  ...r.exhaustive === false ? { exhaustive: false } : {},
9610
9650
  evidence: r.evidence
@@ -9625,12 +9665,13 @@ function graphOf(reader, candidates) {
9625
9665
  };
9626
9666
  return { forward, backward, describe: describe4 };
9627
9667
  }
9628
- var REACH_DEPTH, REACH_FUNCTIONS, REACH_WORK, cmp4, pathOf4, byEvidence2, candidateIndexes;
9668
+ var callStage, REACH_DEPTH, REACH_FUNCTIONS, REACH_WORK, cmp4, pathOf4, byEvidence2, candidateIndexes;
9629
9669
  var init_reach = __esm({
9630
9670
  "packages/query-imports/src/reach.ts"() {
9631
9671
  "use strict";
9632
9672
  init_src();
9633
9673
  init_nesting();
9674
+ callStage = (e) => e.type === "CALLS" ? "stage1" : e.via === "template-link" ? "template-link" : "stage2";
9634
9675
  REACH_DEPTH = { default: 8, max: 64 };
9635
9676
  REACH_FUNCTIONS = { default: 500, max: 5e3 };
9636
9677
  REACH_WORK = { default: 5e4, max: 5e5 };
@@ -10065,6 +10106,49 @@ var init_check = __esm({
10065
10106
  }
10066
10107
  });
10067
10108
 
10109
+ // packages/query-imports/src/file-summary.ts
10110
+ function outcomes(reader, file2) {
10111
+ const c = completenessOf(
10112
+ reader,
10113
+ (f) => f === file2,
10114
+ reader.facts("CALLS", file2).length,
10115
+ reader.facts("CALLS_CROSS_FILE", file2).length
10116
+ );
10117
+ return {
10118
+ sites: c.sites,
10119
+ withinFile: c.withinFiles,
10120
+ intoOtherFiles: c.acrossFiles,
10121
+ leaveProject: c.external,
10122
+ candidates: c.candidates.one + c.candidates.several,
10123
+ open: c.open
10124
+ };
10125
+ }
10126
+ function fileSummary(engine, args, cwd) {
10127
+ if (typeof args.file !== "string" || !args.file)
10128
+ throw new VeoError("invalid-arguments", "file is required", { fields: ["file"] });
10129
+ const { meta: meta3, reader } = engine.readAllStages(args, cwd);
10130
+ const f = reader.fact(args.file);
10131
+ if (!f || f.type !== "File")
10132
+ throw new VeoError("not-found", `no file ${args.file}`, { kind: "file", id: f?.id ?? args.file });
10133
+ const alone = outcomes(reader.withStages(R1_STAGES), f.id);
10134
+ if (!reader.writtenStages().includes("stage2"))
10135
+ return { ...meta3, file: f.id, path: f.path, alone, acrossFiles: null };
10136
+ const imports = { files: 0, packages: 0, unresolved: 0 };
10137
+ for (const e of reader.facts("IMPORTS", f.id))
10138
+ if (reader.fact(e.to)?.type === "ExternalPackage") imports.packages++;
10139
+ else imports.files++;
10140
+ imports.unresolved = reader.facts("UnresolvedImport", f.id).filter((u) => u.reason !== "asset").length;
10141
+ return { ...meta3, file: f.id, path: f.path, alone, acrossFiles: { ...outcomes(reader, f.id), imports } };
10142
+ }
10143
+ var init_file_summary = __esm({
10144
+ "packages/query-imports/src/file-summary.ts"() {
10145
+ "use strict";
10146
+ init_src();
10147
+ init_src6();
10148
+ init_totals();
10149
+ }
10150
+ });
10151
+
10068
10152
  // packages/query-imports/src/report.ts
10069
10153
  import { arch, platform, release } from "node:os";
10070
10154
  function spanOf(f) {
@@ -10635,6 +10719,7 @@ var init_src7 = __esm({
10635
10719
  init_exits();
10636
10720
  init_check();
10637
10721
  init_totals();
10722
+ init_file_summary();
10638
10723
  init_impact();
10639
10724
  init_report();
10640
10725
  init_symbols();
@@ -14691,6 +14776,2821 @@ var init_candidates = __esm({
14691
14776
  }
14692
14777
  });
14693
14778
 
14779
+ // packages/stage2/src/di.ts
14780
+ function makeInjection(graph, s, together = () => true) {
14781
+ if (!s?.checker || !s.program) return null;
14782
+ const { ts, checker, program, fileIdOf: fileIdOf2 } = s;
14783
+ const pathOf9 = (file2) => file2.slice(file2.indexOf(":") + 1);
14784
+ const where = (node2) => {
14785
+ const sf = node2.getSourceFile();
14786
+ const file2 = fileIdOf2(sf);
14787
+ return `${file2 ? pathOf9(file2) : sf.fileName}:${sf.getLineAndCharacterOfPosition(node2.getStart(sf)).line + 1}`;
14788
+ };
14789
+ const resolved = (node2) => {
14790
+ const sym = checker.getSymbolAtLocation(node2);
14791
+ return sym && sym.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
14792
+ };
14793
+ const declOfClass = (node2) => {
14794
+ if (!node2 || !ts.isClassDeclaration(node2) || !node2.name || !ts.isSourceFile(node2.parent)) return null;
14795
+ const file2 = fileIdOf2(node2.getSourceFile());
14796
+ const d = file2 ? { file: file2, name: node2.name.text } : null;
14797
+ return d && graph.declared(d) ? d : null;
14798
+ };
14799
+ const classOf = (node2) => {
14800
+ while (ts.isParenthesizedExpression(node2) || ts.isAsExpression(node2) || ts.isSatisfiesExpression(node2) || ts.isNonNullExpression(node2) || ts.isTypeAssertionExpression(node2))
14801
+ node2 = node2.expression;
14802
+ const sym = resolved(node2);
14803
+ const d = sym?.valueDeclaration ?? sym?.declarations?.find((x) => ts.isClassDeclaration(x));
14804
+ let decl = declOfClass(d);
14805
+ if (!decl && ts.isExpression(node2)) {
14806
+ const made = checker.getTypeAtLocation(node2).getConstructSignatures()[0]?.getReturnType().getSymbol();
14807
+ const md = made?.valueDeclaration ?? made?.declarations?.[0];
14808
+ decl = declOfClass(md);
14809
+ if (decl) return { decl, node: md };
14810
+ }
14811
+ return decl ? { decl, node: d } : null;
14812
+ };
14813
+ const isAbstract = (c) => (ts.getCombinedModifierFlags(c) & ts.ModifierFlags.Abstract) !== 0;
14814
+ const classNode = (d) => s.sourceFile(d.file)?.statements.find((x) => ts.isClassDeclaration(x) && x.name?.text === d.name);
14815
+ const importedAs = (callee) => {
14816
+ if (!ts.isIdentifier(callee)) return null;
14817
+ const sym = checker.getSymbolAtLocation(callee);
14818
+ const spec = sym?.declarations?.[0];
14819
+ if (!spec || !ts.isImportSpecifier(spec)) return null;
14820
+ const decl = spec.parent.parent.parent;
14821
+ if (!ts.isImportDeclaration(decl) || !ts.isStringLiteral(decl.moduleSpecifier)) return null;
14822
+ return { pkg: decl.moduleSpecifier.text, name: (spec.propertyName ?? spec.name).text };
14823
+ };
14824
+ const fromPackage = (node2) => {
14825
+ let root = node2;
14826
+ while (ts.isPropertyAccessExpression(root)) root = root.expression;
14827
+ if (!ts.isIdentifier(root)) return false;
14828
+ const from = importedAs(root);
14829
+ if (from) return !from.pkg.startsWith(".") && !from.pkg.startsWith("/");
14830
+ const d = checker.getSymbolAtLocation(root)?.declarations?.[0];
14831
+ const imp = d && ts.findAncestor(d, ts.isImportDeclaration);
14832
+ if (imp) return ts.isStringLiteral(imp.moduleSpecifier) && !/^[./]/.test(imp.moduleSpecifier.text);
14833
+ const v = d && ts.findAncestor(d, ts.isVariableDeclaration);
14834
+ let init = v?.initializer;
14835
+ while (init && (ts.isPropertyAccessExpression(init) || ts.isParenthesizedExpression(init)))
14836
+ init = init.expression;
14837
+ return !!init && ts.isCallExpression(init) && ts.isIdentifier(init.expression) && init.expression.text === "require" && !!init.arguments[0] && ts.isStringLiteral(init.arguments[0]) && !/^[./]/.test(init.arguments[0].text);
14838
+ };
14839
+ const fromWriterLibrary = (callee) => {
14840
+ let root = callee;
14841
+ while (ts.isPropertyAccessExpression(root)) root = root.expression;
14842
+ if (!ts.isIdentifier(root)) return false;
14843
+ const d = checker.getSymbolAtLocation(root)?.declarations?.[0];
14844
+ const imp = d && ts.findAncestor(d, ts.isImportDeclaration);
14845
+ const spec = imp && ts.isStringLiteral(imp.moduleSpecifier) ? imp.moduleSpecifier.text : null;
14846
+ return !!spec && /^(lodash(-es)?|lodash[./].*|underscore|es-toolkit(\/.*)?)$/.test(spec);
14847
+ };
14848
+ const readableToken = (node2) => {
14849
+ if (ts.isStringLiteralLike(node2) || ts.isNumericLiteral(node2)) return true;
14850
+ if (!ts.isIdentifier(node2) && !ts.isPropertyAccessExpression(node2)) return false;
14851
+ let root = node2;
14852
+ while (ts.isPropertyAccessExpression(root)) root = root.expression;
14853
+ const d = resolved(node2)?.valueDeclaration;
14854
+ if (!d) {
14855
+ const from = importedAs(root);
14856
+ return !!from && !from.pkg.startsWith(".") && !from.pkg.startsWith("/");
14857
+ }
14858
+ if (ts.isEnumMember(d)) return true;
14859
+ const init = ts.isVariableDeclaration(d) && ts.getCombinedNodeFlags(d) & ts.NodeFlags.Const ? d.initializer : ts.isPropertyAssignment(d) ? d.initializer : void 0;
14860
+ return !!init && (ts.isStringLiteralLike(init) || ts.isNumericLiteral(init) || ts.isTemplateExpression(init) || ts.isNewExpression(init) || ts.isCallExpression(init) && ts.isIdentifier(init.expression) && init.expression.text === "Symbol");
14861
+ };
14862
+ const decorators = (node2) => (ts.getDecorators(node2) ?? []).map((d) => {
14863
+ const call = ts.isCallExpression(d.expression) ? d.expression : null;
14864
+ return { call, from: importedAs(call ? call.expression : d.expression) };
14865
+ });
14866
+ const diDecorator = (c) => {
14867
+ for (const { from } of decorators(c))
14868
+ if (from && DI_DECORATORS[from.pkg]?.includes(from.name)) return `@${from.name} from ${from.pkg}`;
14869
+ return null;
14870
+ };
14871
+ const onlyDiDecorators = (c) => decorators(c).every(({ from }) => !!from && !!DI_DECORATORS[from.pkg]?.includes(from.name));
14872
+ let wiring;
14873
+ const nameOf = (n2) => n2 && (ts.isIdentifier(n2) || ts.isStringLiteralLike(n2)) ? n2.text : null;
14874
+ const enclosingClass = (node2) => declOfClass(ts.findAncestor(node2.parent, ts.isClassDeclaration));
14875
+ const wired = () => {
14876
+ if (wiring) return wiring;
14877
+ const w = {
14878
+ provides: /* @__PURE__ */ new Map(),
14879
+ listed: /* @__PURE__ */ new Set(),
14880
+ unreadable: [],
14881
+ news: /* @__PURE__ */ new Map(),
14882
+ mixins: /* @__PURE__ */ new Map(),
14883
+ writes: /* @__PURE__ */ new Map(),
14884
+ wholesale: [],
14885
+ borrowed: /* @__PURE__ */ new Map(),
14886
+ givenNews: [],
14887
+ handed: /* @__PURE__ */ new Map()
14888
+ };
14889
+ const push = (m, k, v) => {
14890
+ const list = m.get(k);
14891
+ if (list) list.push(v);
14892
+ else m.set(k, [v]);
14893
+ };
14894
+ const valueOf = (p) => ts.isPropertyAssignment(p) ? p.initializer : ts.isShorthandPropertyAssignment(p) ? p.name : void 0;
14895
+ const providerOf = (o, token) => {
14896
+ for (const p of o.properties) {
14897
+ const kind = PROVIDER_KINDS.find((k) => k === nameOf(p.name));
14898
+ if (!kind) continue;
14899
+ const v = valueOf(p);
14900
+ const target2 = kind === "useClass" && v ? classOf(v) : null;
14901
+ if (target2 && declKey(target2.decl) === declKey(token)) w.listed.add(declKey(token));
14902
+ else push(w.provides, declKey(token), { kind, target: target2?.decl ?? null, at: p });
14903
+ }
14904
+ };
14905
+ const written2 = (node2) => {
14906
+ let at = node2;
14907
+ while (ts.isParenthesizedExpression(at.parent) || ts.isPropertyAssignment(at.parent) || ts.isShorthandPropertyAssignment(at.parent) || ts.isSpreadAssignment(at.parent) || ts.isSpreadElement(at.parent) || ts.isObjectLiteralExpression(at.parent) || ts.isArrayLiteralExpression(at.parent)) {
14908
+ if (ts.isPropertyAssignment(at.parent) && at.parent.initializer !== at) return false;
14909
+ at = at.parent;
14910
+ }
14911
+ const parent = at.parent;
14912
+ if (ts.isDeleteExpression(parent) || ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent))
14913
+ return ts.isDeleteExpression(parent) || parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken;
14914
+ if (ts.isBinaryExpression(parent))
14915
+ return parent.left === at && parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
14916
+ return (ts.isForOfStatement(parent) || ts.isForInStatement(parent)) && parent.initializer === at;
14917
+ };
14918
+ const handedOut = (node2) => {
14919
+ let at = node2;
14920
+ while (ts.isParenthesizedExpression(at.parent) || ts.isNonNullExpression(at.parent) || ts.isConditionalExpression(at.parent) && at.parent.condition !== at || ts.isBinaryExpression(at.parent) && [
14921
+ ts.SyntaxKind.BarBarToken,
14922
+ ts.SyntaxKind.QuestionQuestionToken,
14923
+ ts.SyntaxKind.AmpersandAmpersandToken
14924
+ ].includes(at.parent.operatorToken.kind))
14925
+ at = at.parent;
14926
+ const p = at.parent;
14927
+ if ((ts.isCallExpression(p) || ts.isNewExpression(p)) && p.expression === at) return false;
14928
+ if (ts.isTaggedTemplateExpression(p) && p.tag === at) return false;
14929
+ if ((ts.isPropertyAccessExpression(p) || ts.isElementAccessExpression(p)) && p.expression === at) {
14930
+ const key = ts.isPropertyAccessExpression(p) ? p.name.text : ts.isStringLiteralLike(p.argumentExpression) ? p.argumentExpression.text : null;
14931
+ return key === null || ["call", "apply", "bind"].includes(key);
14932
+ }
14933
+ if (ts.isTypeOfExpression(p) || ts.isVoidExpression(p) || ts.isDeleteExpression(p)) return false;
14934
+ if (ts.isPrefixUnaryExpression(p) && p.operator === ts.SyntaxKind.ExclamationToken) return false;
14935
+ if (ts.isBinaryExpression(p) && [
14936
+ ts.SyntaxKind.EqualsEqualsEqualsToken,
14937
+ ts.SyntaxKind.ExclamationEqualsEqualsToken,
14938
+ ts.SyntaxKind.EqualsEqualsToken,
14939
+ ts.SyntaxKind.ExclamationEqualsToken,
14940
+ ts.SyntaxKind.InstanceOfKeyword,
14941
+ ts.SyntaxKind.InKeyword
14942
+ ].includes(p.operatorToken.kind))
14943
+ return false;
14944
+ if ((ts.isIfStatement(p) || ts.isWhileStatement(p) || ts.isDoStatement(p)) && p.expression === at)
14945
+ return false;
14946
+ if (ts.isConditionalExpression(p) && p.condition === at) return false;
14947
+ if (ts.isExpressionStatement(p)) return false;
14948
+ return true;
14949
+ };
14950
+ const descriptorHandedOut = (call) => {
14951
+ const fnHandedOut = (d) => {
14952
+ let at = d;
14953
+ while (ts.isParenthesizedExpression(at.parent) || ts.isNonNullExpression(at.parent)) at = at.parent;
14954
+ const p2 = at.parent;
14955
+ if (ts.isPropertyAccessExpression(p2) && p2.expression === at)
14956
+ return ["value", "get", "set"].includes(p2.name.text) ? handedOut(p2) || calledOn(p2) : false;
14957
+ if (ts.isElementAccessExpression(p2) && p2.expression === at) return true;
14958
+ return handedOut(d);
14959
+ };
14960
+ const calledOn = (m) => ts.isCallExpression(m.parent) && m.parent.expression === m;
14961
+ const p = call.parent;
14962
+ if (ts.isVariableDeclaration(p) && p.initializer === call && ts.isIdentifier(p.name)) {
14963
+ const sym = checker.getSymbolAtLocation(p.name);
14964
+ const scope2 = ts.findAncestor(p, (n2) => ts.isFunctionLike(n2) || ts.isSourceFile(n2));
14965
+ if (!sym || !scope2) return true;
14966
+ let out = false;
14967
+ const visit2 = (n2) => {
14968
+ if (out) return;
14969
+ if (ts.isIdentifier(n2) && n2 !== p.name && checker.getSymbolAtLocation(n2) === sym)
14970
+ out = fnHandedOut(n2);
14971
+ else ts.forEachChild(n2, visit2);
14972
+ };
14973
+ visit2(scope2);
14974
+ return out;
14975
+ }
14976
+ return fnHandedOut(call);
14977
+ };
14978
+ const projectFiles = program.getSourceFiles().filter((sf) => !!fileIdOf2(sf));
14979
+ const methodNames = /* @__PURE__ */ new Set();
14980
+ for (const sf of projectFiles) {
14981
+ const look = (node2) => {
14982
+ if ((ts.isMethodDeclaration(node2) || ts.isGetAccessorDeclaration(node2) || ts.isSetAccessorDeclaration(node2)) && ts.isClassLike(node2.parent)) {
14983
+ const n2 = nameOf(node2.name);
14984
+ if (n2) methodNames.add(n2);
14985
+ }
14986
+ ts.forEachChild(node2, look);
14987
+ };
14988
+ look(sf);
14989
+ }
14990
+ for (const sf of projectFiles) {
14991
+ const test = isTestPath(pathOf9(fileIdOf2(sf)));
14992
+ const file2 = fileIdOf2(sf);
14993
+ const visit2 = (node2) => {
14994
+ if (test) {
14995
+ } else if (ts.isObjectLiteralExpression(node2)) {
14996
+ const provide = node2.properties.find((p) => nameOf(p.name) === "provide");
14997
+ const uses = node2.properties.some((p) => PROVIDER_KINDS.some((k) => k === nameOf(p.name)));
14998
+ const value = provide && valueOf(provide);
14999
+ const token = value && classOf(value);
15000
+ const hidden = node2.properties.some(
15001
+ (p) => ts.isSpreadAssignment(p) || p.name !== void 0 && ts.isComputedPropertyName(p.name)
15002
+ );
15003
+ if ((provide || uses) && hidden) w.unreadable.push(node2);
15004
+ else if (token) providerOf(node2, token.decl);
15005
+ else if (value && !readableToken(value)) w.unreadable.push(node2);
15006
+ } else if (ts.isArrayLiteralExpression(node2)) {
15007
+ for (const e of node2.elements) {
15008
+ const c = ts.isIdentifier(e) || ts.isPropertyAccessExpression(e) ? classOf(e) : null;
15009
+ if (c) w.listed.add(declKey(c.decl));
15010
+ }
15011
+ } else if (ts.isClassDeclaration(node2) || ts.isClassExpression(node2)) {
15012
+ const self2 = ts.isClassDeclaration(node2) ? declOfClass(node2) : null;
15013
+ for (const { call, from } of ts.isClassDeclaration(node2) ? decorators(node2) : []) {
15014
+ const arg = call?.arguments[0];
15015
+ if (!self2 || !arg || !ts.isObjectLiteralExpression(arg) || from?.name !== "Injectable") continue;
15016
+ if (arg.properties.some((p) => nameOf(p.name) === "providedIn")) w.listed.add(declKey(self2));
15017
+ providerOf(arg, self2);
15018
+ }
15019
+ for (const h of node2.heritageClauses ?? [])
15020
+ for (const t of h.types)
15021
+ if (ts.isCallExpression(t.expression))
15022
+ for (const a of t.expression.arguments) {
15023
+ const c = classOf(a);
15024
+ if (c) w.mixins.set(declKey(c.decl), t);
15025
+ }
15026
+ } else if (ts.isNewExpression(node2)) {
15027
+ const c = classOf(node2.expression);
15028
+ if (c)
15029
+ push(w.news, declKey(c.decl), { at: node2, args: node2.arguments ?? ts.factory.createNodeArray() });
15030
+ else {
15031
+ const d = resolved(node2.expression)?.valueDeclaration;
15032
+ if (d && ts.isParameter(d) || checker.getTypeAtLocation(node2).flags & ts.TypeFlags.TypeParameter || checker.getTypeAtLocation(node2.expression).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown) && !fromPackage(node2.expression))
15033
+ w.givenNews.push(node2);
15034
+ }
15035
+ } else if (ts.isCallExpression(node2) && ts.isPropertyAccessExpression(node2.expression) && ts.isIdentifier(node2.expression.expression)) {
15036
+ const target2 = `${node2.expression.expression.text}.${node2.expression.name.text}`;
15037
+ const first = node2.arguments[0];
15038
+ if (target2 === "Reflect.construct" && first) {
15039
+ const c = classOf(first);
15040
+ if (c) push(w.news, declKey(c.decl), { at: node2, args: "all" });
15041
+ }
15042
+ }
15043
+ if (ts.isCallExpression(node2)) {
15044
+ const callee = node2.expression;
15045
+ const [first, second] = node2.arguments;
15046
+ const target2 = ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) ? `${callee.expression.text}.${callee.name.text}` : null;
15047
+ if (target2 === "Object.assign" && first) {
15048
+ for (const src of node2.arguments.slice(1)) {
15049
+ if (ts.isObjectLiteralExpression(src) && !src.properties.some((p) => !nameOf(p.name)))
15050
+ for (const p of src.properties)
15051
+ push(w.writes, nameOf(p.name), { at: p, obj: first, test, file: file2 });
15052
+ else w.wholesale.push({ at: node2, obj: first, test, file: file2, whole: true });
15053
+ }
15054
+ } else if ((target2 === "Reflect.set" || target2 === "Object.defineProperty" || target2 === "Reflect.defineProperty") && first && second) {
15055
+ if (ts.isStringLiteralLike(second))
15056
+ push(w.writes, second.text, { at: node2, obj: first, test, file: file2 });
15057
+ else w.wholesale.push({ at: node2, obj: first, test, file: file2, computed: true });
15058
+ } else if ((target2 === "Object.getOwnPropertyDescriptor" || target2 === "Reflect.getOwnPropertyDescriptor") && first) {
15059
+ if (!descriptorHandedOut(node2)) {
15060
+ } else if (second && ts.isStringLiteralLike(second))
15061
+ push(w.borrowed, second.text, { at: node2, obj: first, test, file: file2, borrow: true });
15062
+ else push(w.borrowed, "", { at: node2, obj: first, test, file: file2, borrow: true, computed: true });
15063
+ } else if (target2 === "Object.getOwnPropertyDescriptors" && first) {
15064
+ push(w.borrowed, "", { at: node2, obj: first, test, file: file2, borrow: true, computed: true });
15065
+ } else if ((target2 === "Object.defineProperties" || target2 === "Object.setPrototypeOf" || target2 === "Reflect.setPrototypeOf") && first) {
15066
+ w.wholesale.push({ at: node2, obj: first, test, file: file2, whole: true });
15067
+ } else if (first) {
15068
+ const name = ts.isPropertyAccessExpression(callee) ? callee.name.text : ts.isIdentifier(callee) ? callee.text : null;
15069
+ if (name && LIBRARY_WRITERS.has(name) && fromWriterLibrary(callee)) {
15070
+ const byPath = ["set", "setWith", "update", "updateWith", "unset"].includes(name);
15071
+ const path = byPath && second && ts.isStringLiteralLike(second) ? second.text.split(/[.[]/)[0] : null;
15072
+ if (path) push(w.writes, path, { at: node2, obj: first, test, file: file2 });
15073
+ else
15074
+ w.wholesale.push({
15075
+ at: node2,
15076
+ obj: first,
15077
+ test,
15078
+ file: file2,
15079
+ ...byPath ? { computed: true } : { whole: true }
15080
+ });
15081
+ }
15082
+ }
15083
+ }
15084
+ const handedOn = (a) => {
15085
+ const c = a && (ts.isIdentifier(a) || ts.isPropertyAccessExpression(a)) ? classOf(a) : null;
15086
+ if (c && !w.handed.has(declKey(c.decl)) && !ts.findAncestor(a, ts.isDecorator))
15087
+ w.handed.set(declKey(c.decl), a);
15088
+ };
15089
+ if (test) {
15090
+ } else if (ts.isCallExpression(node2) || ts.isNewExpression(node2))
15091
+ for (const a of node2.arguments ?? []) handedOn(a);
15092
+ else if (ts.isPropertyAssignment(node2) && !["provide", ...PROVIDER_KINDS].includes(nameOf(node2.name) ?? ""))
15093
+ handedOn(node2.initializer);
15094
+ else if (ts.isShorthandPropertyAssignment(node2)) handedOn(node2.name);
15095
+ else if (ts.isBinaryExpression(node2) && node2.operatorToken.kind === ts.SyntaxKind.EqualsToken)
15096
+ handedOn(node2.right);
15097
+ else if (ts.isVariableDeclaration(node2) && node2.initializer) handedOn(node2.initializer);
15098
+ if (ts.isPropertyAccessExpression(node2) || ts.isElementAccessExpression(node2)) {
15099
+ if (written2(node2)) {
15100
+ const key = ts.isPropertyAccessExpression(node2) ? node2.name.text : ts.isStringLiteralLike(node2.argumentExpression) ? node2.argumentExpression.text : null;
15101
+ if (key !== null) push(w.writes, key, { at: node2, obj: node2.expression, test, file: file2 });
15102
+ else w.wholesale.push({ at: node2, obj: node2.expression, test, file: file2, computed: true });
15103
+ } else {
15104
+ const key = ts.isPropertyAccessExpression(node2) ? node2.name.text : ts.isStringLiteralLike(node2.argumentExpression) ? node2.argumentExpression.text : null;
15105
+ if (key !== null && methodNames.has(key) && node2.expression.kind !== ts.SyntaxKind.SuperKeyword && handedOut(node2))
15106
+ push(w.borrowed, key, { at: node2, obj: node2.expression, test, file: file2, borrow: true });
15107
+ }
15108
+ }
15109
+ if (ts.isBindingElement(node2) && ts.isObjectBindingPattern(node2.parent) && !node2.dotDotDotToken) {
15110
+ const key = nameOf(node2.propertyName ?? (ts.isIdentifier(node2.name) ? node2.name : void 0));
15111
+ if (key && methodNames.has(key))
15112
+ push(w.borrowed, key, {
15113
+ at: node2,
15114
+ obj: node2.parent,
15115
+ test,
15116
+ file: file2,
15117
+ borrow: true
15118
+ });
15119
+ }
15120
+ ts.forEachChild(node2, visit2);
15121
+ };
15122
+ visit2(sf);
15123
+ }
15124
+ return wiring = w;
15125
+ };
15126
+ const subclassesOf = (c) => {
15127
+ const out = [];
15128
+ const seen = /* @__PURE__ */ new Set([declKey(c)]);
15129
+ const queue = [c];
15130
+ while (queue.length) {
15131
+ const at = queue.shift();
15132
+ for (const sub of graph.subtypes.get(declKey(at)) ?? []) {
15133
+ if (sub.kind !== "class" || seen.has(declKey(sub.decl))) continue;
15134
+ if (graph.parentOf.get(declKey(sub.decl))?.base?.name !== at.name) continue;
15135
+ seen.add(declKey(sub.decl));
15136
+ out.push(sub.decl);
15137
+ queue.push(sub.decl);
15138
+ }
15139
+ }
15140
+ return out;
15141
+ };
15142
+ const bodyCtor = (c) => c.members.find((m) => ts.isConstructorDeclaration(m) && !!m.body);
15143
+ const suppliedBy = (c, index, param, seen) => {
15144
+ if (seen.has(declKey(c))) return `${c.name}'s classes extend each other in a cycle`;
15145
+ seen.add(declKey(c));
15146
+ for (const n2 of wired().news.get(declKey(c)) ?? []) {
15147
+ const args = n2.args;
15148
+ if (args === "all" || args.length > index || args.slice(0, index + 1).some((a) => ts.isSpreadElement(a)))
15149
+ return `${c.name} is constructed at ${where(n2.at)}, which may pass its own ${param}`;
15150
+ }
15151
+ const handed = wired().handed.get(declKey(c));
15152
+ const given = wired().givenNews.find(
15153
+ (n2) => fileIdOf2(n2.getSourceFile())?.startsWith(`${graph.sourceOf(c.file)}:`)
15154
+ );
15155
+ if (handed && given)
15156
+ return `${c.name} is handed on as a value at ${where(handed)}, and the project constructs classes it is given (${where(given)})`;
15157
+ const mixin = wired().mixins.get(declKey(c));
15158
+ if (mixin) return `${c.name} is extended through a mixin at ${where(mixin)}`;
15159
+ for (const sub of graph.subtypes.get(declKey(c)) ?? []) {
15160
+ if (sub.kind !== "class" || graph.parentOf.get(declKey(sub.decl))?.base?.name !== c.name) continue;
15161
+ const node2 = classNode(sub.decl);
15162
+ if (!node2) return `${sub.decl.name} (${pathOf9(sub.decl.file)}) can't be read`;
15163
+ const ctor = bodyCtor(node2);
15164
+ if (!ctor) {
15165
+ const why = suppliedBy(sub.decl, index, param, seen);
15166
+ if (why) return why;
15167
+ continue;
15168
+ }
15169
+ let sup;
15170
+ const find2 = (node3) => {
15171
+ if (sup) return;
15172
+ if (ts.isCallExpression(node3) && node3.expression.kind === ts.SyntaxKind.SuperKeyword) sup = node3;
15173
+ else ts.forEachChild(node3, find2);
15174
+ };
15175
+ find2(ctor.body);
15176
+ const args = sup?.arguments ?? [];
15177
+ const arg = args[index];
15178
+ if (!sup || args.slice(0, index + 1).some((a) => ts.isSpreadElement(a)))
15179
+ return `${sub.decl.name}'s constructor doesn't pass ${param} on to ${c.name}`;
15180
+ if (!arg) continue;
15181
+ const p = ts.isIdentifier(arg) ? resolved(arg)?.valueDeclaration : void 0;
15182
+ const from = p && ts.isParameter(p) && p.parent === ctor ? fromParameter(p, seen) : null;
15183
+ const own2 = tokenOfParam(c, index);
15184
+ if (!from || "why" in from || !own2 || declKey(from.token) !== declKey(own2))
15185
+ return `${sub.decl.name} passes its own ${param} to ${c.name} (${where(arg)})`;
15186
+ }
15187
+ return null;
15188
+ };
15189
+ const tokenOfParam = (c, index) => {
15190
+ const node2 = classNode(c);
15191
+ const t = node2 && bodyCtor(node2)?.parameters[index]?.type;
15192
+ return t && ts.isTypeReferenceNode(t) ? classOf(t.typeName)?.decl ?? null : null;
15193
+ };
15194
+ const fromParameter = (p, seen = /* @__PURE__ */ new Set()) => {
15195
+ const ctor = p.parent;
15196
+ if (!ts.isConstructorDeclaration(ctor) || !ctor.body) return null;
15197
+ const holder = ctor.parent;
15198
+ if (!ts.isClassDeclaration(holder) || !holder.name) return null;
15199
+ const holderDecl = declOfClass(holder);
15200
+ const deco = diDecorator(holder);
15201
+ if (!holderDecl || !deco || !p.type || !ts.isTypeReferenceNode(p.type) || !ts.isIdentifier(p.name))
15202
+ return null;
15203
+ const token = classOf(p.type.typeName);
15204
+ if (!token) return null;
15205
+ const name = p.name.text;
15206
+ for (const { call, from } of decorators(p)) {
15207
+ if (from && LOOKUP_DECORATORS.has(from.name)) continue;
15208
+ if (from?.name === "Inject" && call) {
15209
+ let arg = call.arguments[0];
15210
+ if (arg && ts.isCallExpression(arg) && importedAs(arg.expression)?.name === "forwardRef") {
15211
+ const fn = arg.arguments[0];
15212
+ arg = fn && ts.isArrowFunction(fn) && !ts.isBlock(fn.body) ? fn.body : void 0;
15213
+ }
15214
+ const named = arg && classOf(arg);
15215
+ if (named && declKey(named.decl) === declKey(token.decl)) continue;
15216
+ return { why: `${name} is injected by the token ${call.arguments[0]?.getText() ?? "(none)"}` };
15217
+ }
15218
+ return { why: `${name} has the decorator ${call?.expression.getText() ?? "(unknown)"}` };
15219
+ }
15220
+ const why = suppliedBy(holderDecl, ctor.parameters.indexOf(p), name, seen);
15221
+ if (why) return { why };
15222
+ return {
15223
+ token: token.decl,
15224
+ detail: `${name} is injected into ${holder.name.text}'s constructor (${deco})`
15225
+ };
15226
+ };
15227
+ const under = (obj) => {
15228
+ while (ts.isParenthesizedExpression(obj) || ts.isNonNullExpression(obj) || ts.isAsExpression(obj) || ts.isTypeAssertionExpression(obj) || ts.isSatisfiesExpression(obj))
15229
+ obj = obj.expression;
15230
+ return obj;
15231
+ };
15232
+ const objectClass = /* @__PURE__ */ new Map();
15233
+ const classOfObject = (obj, at) => {
15234
+ if (obj.kind === ts.SyntaxKind.ThisKeyword) return enclosingClass(at);
15235
+ const hit = objectClass.get(obj);
15236
+ if (hit !== void 0) return hit;
15237
+ const t = checker.getTypeAtLocation(obj).getSymbol();
15238
+ const c = declOfClass(t?.valueDeclaration ?? t?.declarations?.[0]);
15239
+ objectClass.set(obj, c);
15240
+ return c;
15241
+ };
15242
+ const heldLiteral = (obj) => {
15243
+ if (!ts.isIdentifier(obj)) return void 0;
15244
+ const d = resolved(obj)?.valueDeclaration;
15245
+ if (!d || !ts.isVariableDeclaration(d) || !d.initializer) return void 0;
15246
+ let init = d.initializer;
15247
+ while (ts.isParenthesizedExpression(init) || ts.isAsExpression(init) || ts.isSatisfiesExpression(init))
15248
+ init = init.expression;
15249
+ return ts.isObjectLiteralExpression(init) ? init : void 0;
15250
+ };
15251
+ const freshClass = (e) => {
15252
+ const c = classOf(e);
15253
+ if (!c) return false;
15254
+ const seen = /* @__PURE__ */ new Set();
15255
+ for (let at = c.decl; at; at = graph.parentOf.get(declKey(at))?.base) {
15256
+ if (seen.has(declKey(at))) return false;
15257
+ seen.add(declKey(at));
15258
+ const node2 = classNode(at);
15259
+ const parent = graph.parentOf.get(declKey(at));
15260
+ if (!node2 || ts.getDecorators(node2)?.length || parent && !parent.base) return false;
15261
+ const ctor = node2.members.find((m) => ts.isConstructorDeclaration(m) && m.body);
15262
+ const returns = (n2) => n2 !== ctor && ts.isFunctionLike(n2) ? false : ts.isReturnStatement(n2) && !!n2.expression || !!ts.forEachChild(n2, (x) => returns(x) || void 0);
15263
+ if (ctor && returns(ctor)) return false;
15264
+ }
15265
+ return true;
15266
+ };
15267
+ const packageObject = (obj) => {
15268
+ if (!fromPackage(obj)) return false;
15269
+ let root = obj;
15270
+ while (ts.isPropertyAccessExpression(root)) root = root.expression;
15271
+ const decls = resolved(root)?.declarations ?? [];
15272
+ return !decls.some((d) => !!fileIdOf2(d.getSourceFile()));
15273
+ };
15274
+ const freshLocal = (obj) => {
15275
+ let root = obj;
15276
+ while (ts.isPropertyAccessExpression(root) || ts.isElementAccessExpression(root)) root = root.expression;
15277
+ if (!ts.isIdentifier(root) || root !== obj) return false;
15278
+ const d = resolved(root)?.valueDeclaration;
15279
+ if (!d || !ts.isVariableDeclaration(d) || !(ts.getCombinedNodeFlags(d) & ts.NodeFlags.Const) || !d.initializer)
15280
+ return false;
15281
+ let init = d.initializer;
15282
+ while (ts.isParenthesizedExpression(init) || ts.isAsExpression(init) || ts.isSatisfiesExpression(init))
15283
+ init = init.expression;
15284
+ const callee = ts.isCallExpression(init) ? init.expression : void 0;
15285
+ const made = callee ? ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) ? `${callee.expression.text}.${callee.name.text}` : ts.isIdentifier(callee) ? callee.text : null : null;
15286
+ if (made === "Object.create") {
15287
+ const proto = init.kind === ts.SyntaxKind.CallExpression ? init.arguments[0] : void 0;
15288
+ return !!proto && (proto.kind === ts.SyntaxKind.NullKeyword || ts.isObjectLiteralExpression(proto));
15289
+ }
15290
+ if (made && FRESH_MAKERS.has(made) && !fileIdOf2(resolved(callee)?.valueDeclaration?.getSourceFile() ?? obj.getSourceFile()))
15291
+ return true;
15292
+ if (ts.isObjectLiteralExpression(init))
15293
+ return !init.properties.some(
15294
+ (p) => ts.isPropertyAssignment(p) && nameOf(p.name) === "__proto__" && !ts.isComputedPropertyName(p.name)
15295
+ );
15296
+ return ts.isArrayLiteralExpression(init) || ts.isNewExpression(init) && ts.isIdentifier(init.expression) && (freshClass(init.expression) || ["Map", "Set", "WeakMap", "WeakSet", "Array", "Object"].includes(init.expression.text) && !fileIdOf2(resolved(init.expression)?.valueDeclaration?.getSourceFile() ?? obj.getSourceFile()));
15297
+ };
15298
+ const thisOwner = (node2) => {
15299
+ let at = node2.parent;
15300
+ while (at && !ts.isSourceFile(at)) {
15301
+ if (ts.isFunctionLike(at) && !ts.isArrowFunction(at) || ts.isPropertyDeclaration(at)) break;
15302
+ at = at.parent;
15303
+ }
15304
+ if (!at || ts.isSourceFile(at) || !at.parent || !ts.isClassDeclaration(at.parent)) return null;
15305
+ return ts.isMethodDeclaration(at) || ts.isConstructorDeclaration(at) || ts.isGetAccessorDeclaration(at) || ts.isSetAccessorDeclaration(at) || ts.isPropertyDeclaration(at) ? declOfClass(at.parent) : null;
15306
+ };
15307
+ const instanceTypes = /* @__PURE__ */ new Map();
15308
+ const instanceType = (key) => {
15309
+ if (instanceTypes.has(key)) return instanceTypes.get(key);
15310
+ const [file2, name] = key.split("\0");
15311
+ const node2 = classNode({ file: file2, name });
15312
+ const sym = node2?.name ? checker.getSymbolAtLocation(node2.name) : void 0;
15313
+ const t = sym ? checker.getDeclaredTypeOfSymbol(sym) : null;
15314
+ instanceTypes.set(key, t);
15315
+ return t;
15316
+ };
15317
+ let byText;
15318
+ const references = (name) => {
15319
+ if (!byText) {
15320
+ byText = /* @__PURE__ */ new Map();
15321
+ for (const sf of program.getSourceFiles()) {
15322
+ if (!fileIdOf2(sf)) continue;
15323
+ const visit2 = (n2) => {
15324
+ if (ts.isIdentifier(n2)) {
15325
+ const list = byText.get(n2.text);
15326
+ if (list) list.push(n2);
15327
+ else byText.set(n2.text, [n2]);
15328
+ }
15329
+ ts.forEachChild(n2, visit2);
15330
+ };
15331
+ visit2(sf);
15332
+ }
15333
+ }
15334
+ return byText.get(name) ?? [];
15335
+ };
15336
+ const argsSeen = /* @__PURE__ */ new Map();
15337
+ const argumentsFor = (obj) => {
15338
+ if (!ts.isIdentifier(obj)) return null;
15339
+ const p = resolved(obj)?.valueDeclaration;
15340
+ if (!p || !ts.isParameter(p) || !ts.isIdentifier(p.name) || p.dotDotDotToken) return null;
15341
+ const hit = argsSeen.get(p);
15342
+ if (hit !== void 0) return hit;
15343
+ argsSeen.set(p, null);
15344
+ const fn = p.parent;
15345
+ const holder = ts.isFunctionDeclaration(fn) && fn.name ? fn.name : (ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) && ts.isVariableDeclaration(fn.parent) && fn.parent.initializer === fn && ts.isIdentifier(fn.parent.name) && ts.getCombinedNodeFlags(fn.parent) & ts.NodeFlags.Const ? fn.parent.name : null;
15346
+ if (!ts.isExternalModule(fn.getSourceFile())) return null;
15347
+ const index = fn.parameters.filter((x) => !(ts.isIdentifier(x.name) && x.name.text === "this")).indexOf(p);
15348
+ const sym = holder && resolved(holder);
15349
+ if (!holder || !sym || index < 0) return null;
15350
+ const out = [];
15351
+ for (const id of references(holder.text)) {
15352
+ if (id === holder || resolved(id) !== sym) continue;
15353
+ const parent = id.parent;
15354
+ if (ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent)) {
15355
+ if (parent.propertyName) return null;
15356
+ continue;
15357
+ }
15358
+ if (ts.isImportClause(parent)) return null;
15359
+ if (ts.findAncestor(id, (n2) => ts.isTypeNode(n2))) continue;
15360
+ if (!ts.isCallExpression(parent) || parent.expression !== id) return null;
15361
+ const args = parent.arguments;
15362
+ if (args.slice(0, index + 1).some((a) => ts.isSpreadElement(a))) return null;
15363
+ const arg = args[index];
15364
+ if (arg && !(ts.isIdentifier(arg) && arg.text === "undefined")) out.push(arg);
15365
+ else if (p.initializer) out.push(p.initializer);
15366
+ }
15367
+ let written2 = false;
15368
+ const look = (n2) => {
15369
+ if (written2) return;
15370
+ if (ts.isIdentifier(n2) && n2 !== p.name && resolved(n2) === resolved(p.name) && assigned(n2))
15371
+ written2 = true;
15372
+ else ts.forEachChild(n2, look);
15373
+ };
15374
+ if (fn.body) look(fn.body);
15375
+ if (written2) return null;
15376
+ const exported = ts.getCombinedModifierFlags(
15377
+ fn.kind === ts.SyntaxKind.FunctionDeclaration ? fn : fn.parent.parent.parent
15378
+ ) & ts.ModifierFlags.Default;
15379
+ if (exported) return null;
15380
+ argsSeen.set(p, out);
15381
+ return out;
15382
+ };
15383
+ const assigned = (n2) => {
15384
+ let at = n2;
15385
+ while (ts.isParenthesizedExpression(at.parent) || ts.isShorthandPropertyAssignment(at.parent) || ts.isPropertyAssignment(at.parent) && at.parent.initializer === at || ts.isObjectLiteralExpression(at.parent) || ts.isArrayLiteralExpression(at.parent) || ts.isSpreadElement(at.parent) || ts.isSpreadAssignment(at.parent))
15386
+ at = at.parent;
15387
+ const parent = at.parent;
15388
+ if (ts.isBinaryExpression(parent))
15389
+ return parent.left === at && parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
15390
+ if (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent))
15391
+ return parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken;
15392
+ return (ts.isForOfStatement(parent) || ts.isForInStatement(parent)) && parent.initializer === at;
15393
+ };
15394
+ const infos = /* @__PURE__ */ new WeakMap();
15395
+ const writeInfo = (x) => {
15396
+ const hit = infos.get(x);
15397
+ if (hit) return hit;
15398
+ const obj = under(x.obj);
15399
+ let type;
15400
+ const info = obj.kind === ts.SyntaxKind.ThisKeyword ? {
15401
+ obj,
15402
+ thisOwner: thisOwner(obj),
15403
+ fresh: false,
15404
+ cls: null,
15405
+ target: () => checker.getTypeAtLocation(obj)
15406
+ } : {
15407
+ obj,
15408
+ fresh: freshLocal(obj),
15409
+ holds: heldLiteral(obj),
15410
+ cls: classOfObject(obj, x.at),
15411
+ target: () => type ??= checker.getTypeAtLocation(obj)
15412
+ };
15413
+ infos.set(x, info);
15414
+ return info;
15415
+ };
15416
+ const fitsSeen = /* @__PURE__ */ new Map();
15417
+ const assignable = (from, to) => {
15418
+ let row = fitsSeen.get(to);
15419
+ if (!row) fitsSeen.set(to, row = /* @__PURE__ */ new Map());
15420
+ let hit = row.get(from);
15421
+ if (hit === void 0) row.set(from, hit = checker.isTypeAssignableTo(from, to));
15422
+ return hit;
15423
+ };
15424
+ const mayBeIn = (x, chain, types, literal2, depth = 0) => {
15425
+ const info = writeInfo(x);
15426
+ if (literal2 && info.holds === literal2) return true;
15427
+ if (info.thisOwner !== void 0) return !info.thisOwner || chain.has(declKey(info.thisOwner));
15428
+ if (info.cls && chain.has(declKey(info.cls))) return true;
15429
+ if (info.fresh) return false;
15430
+ const obj = info.obj;
15431
+ if (!x.computed && !x.whole && !x.borrow) return true;
15432
+ if (x.borrow && packageObject(obj)) return false;
15433
+ const target2 = info.target();
15434
+ const subjects = types ?? [...chain].map(instanceType).filter((t) => !!t);
15435
+ const fits = () => subjects.some((t) => t === target2 || assignable(t, target2));
15436
+ const loose = !!(target2.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter | ts.TypeFlags.NonPrimitive));
15437
+ if (loose && (x.computed || x.whole) && depth < 3) {
15438
+ const passed = argumentsFor(obj);
15439
+ if (passed)
15440
+ return passed.some(
15441
+ (a) => mayBeIn(
15442
+ { at: a, obj: a, ...x.computed ? { computed: true } : { whole: true } },
15443
+ chain,
15444
+ types,
15445
+ literal2,
15446
+ depth + 1
15447
+ )
15448
+ );
15449
+ }
15450
+ if (x.computed) {
15451
+ if (subjects.some((t) => t === target2)) return true;
15452
+ if (target2.flags & ts.TypeFlags.Any || checker.getIndexInfosOfType(target2).length > 0) return false;
15453
+ if (target2.flags & (ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter | ts.TypeFlags.NonPrimitive))
15454
+ return true;
15455
+ return target2.getProperties().length > 0 && fits();
15456
+ }
15457
+ if (target2.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter)) return true;
15458
+ return fits();
15459
+ };
15460
+ const writeTo = (name, chain, options2 = {}) => {
15461
+ const w = wired();
15462
+ const files = options2.file ? [options2.file] : filesOfChain(chain);
15463
+ const ok = (x) => (options2.tests || !x.test) && files.some((f) => together(x.file, f)) && !options2.except?.(x.at) && mayBeIn(x, chain, options2.types, options2.literal);
15464
+ if (name !== null) {
15465
+ const byName = (w.writes.get(name) ?? []).find(ok);
15466
+ if (byName) return byName.at;
15467
+ }
15468
+ if (options2.except) return w.wholesale.find(ok)?.at ?? null;
15469
+ if (options2.literal) return w.wholesale.find(ok)?.at ?? null;
15470
+ const key = `${options2.tests}\0${options2.file ?? ""}\0${[...chain].sort().join("\0")}`;
15471
+ if (wholeSeen.has(key)) return wholeSeen.get(key);
15472
+ const found = w.wholesale.find(ok)?.at ?? null;
15473
+ wholeSeen.set(key, found);
15474
+ return found;
15475
+ };
15476
+ const wholeSeen = /* @__PURE__ */ new Map();
15477
+ const borrowedSeen = /* @__PURE__ */ new Map();
15478
+ const borrowedAt = (name, chain, tests = false) => {
15479
+ const key = `${tests}\0${name}\0${[...chain].sort().join("\0")}`;
15480
+ if (borrowedSeen.has(key)) return borrowedSeen.get(key);
15481
+ const files = filesOfChain(chain);
15482
+ const found = [...wired().borrowed.get(name) ?? [], ...wired().borrowed.get("") ?? []].find(
15483
+ (x) => (tests || !x.test) && files.some((f) => together(x.file, f)) && mayBeIn(x, chain)
15484
+ )?.at ?? null;
15485
+ borrowedSeen.set(key, found);
15486
+ return found;
15487
+ };
15488
+ const filesOfChain = (chain) => [
15489
+ ...new Set([...chain].map((k) => k.split("\0")[0]))
15490
+ ];
15491
+ const thisBorrowed = (thisNode, tests = false) => {
15492
+ let at = thisNode.parent;
15493
+ while (at && !ts.isSourceFile(at) && !(ts.isFunctionLike(at) && !ts.isArrowFunction(at))) at = at.parent;
15494
+ if (!at || !(ts.isMethodDeclaration(at) || ts.isGetAccessorDeclaration(at) || ts.isSetAccessorDeclaration(at)) || !ts.isClassDeclaration(at.parent))
15495
+ return null;
15496
+ const name = nameOf(at.name);
15497
+ const owner = declOfClass(at.parent);
15498
+ if (!name || !owner) return null;
15499
+ const chain = new Set([owner, ...subclassesOf(owner)].map(declKey));
15500
+ for (let up = graph.parentOf.get(declKey(owner))?.base; up && !chain.has(declKey(up)); up = graph.parentOf.get(declKey(up))?.base)
15501
+ chain.add(declKey(up));
15502
+ return borrowedAt(name, chain, tests);
15503
+ };
15504
+ const fromField = (sym, tests = false) => {
15505
+ const decls = sym.declarations ?? [];
15506
+ if (decls.length !== 1) return null;
15507
+ const d = decls[0];
15508
+ const name = sym.name;
15509
+ const holder = ts.isParameter(d) ? d.parent.parent : d.parent;
15510
+ if (!holder || !ts.isClassDeclaration(holder) || !diDecorator(holder)) return null;
15511
+ const holderDecl = declOfClass(holder);
15512
+ if (!holderDecl) return null;
15513
+ let source = null;
15514
+ const fromCtor = /* @__PURE__ */ new Set();
15515
+ if (ts.isParameter(d)) source = fromParameter(d);
15516
+ else if (ts.isPropertyDeclaration(d)) {
15517
+ if (d.initializer) {
15518
+ const init = d.initializer;
15519
+ const from = ts.isCallExpression(init) ? importedAs(init.expression) : null;
15520
+ const arg = ts.isCallExpression(init) ? init.arguments[0] : void 0;
15521
+ const token = from?.pkg === "@angular/core" && from.name === "inject" && arg ? classOf(arg) : null;
15522
+ if (!token) return null;
15523
+ source = {
15524
+ token: token.decl,
15525
+ detail: `${name} is inject(${token.decl.name}) in ${holder.name?.text} (${diDecorator(holder)})`
15526
+ };
15527
+ } else {
15528
+ const ctor = bodyCtor(holder);
15529
+ for (const st of ctor?.body?.statements ?? []) {
15530
+ const e = ts.isExpressionStatement(st) ? st.expression : void 0;
15531
+ if (!e || !ts.isBinaryExpression(e) || e.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !ts.isPropertyAccessExpression(e.left) || e.left.expression.kind !== ts.SyntaxKind.ThisKeyword || e.left.name.text !== name || !ts.isIdentifier(e.right))
15532
+ continue;
15533
+ const p = resolved(e.right)?.valueDeclaration;
15534
+ if (!p || !ts.isParameter(p) || p.parent !== ctor) return null;
15535
+ const from = fromParameter(p);
15536
+ if (!from) return null;
15537
+ if ("why" in from) return from;
15538
+ if (source && "token" in source && declKey(source.token) !== declKey(from.token))
15539
+ return { why: `${name} is set from parameters of different classes` };
15540
+ fromCtor.add(e.left);
15541
+ source = {
15542
+ token: from.token,
15543
+ detail: `${name} is set from the parameter ${p.name.getText()}, which ${from.detail.replace(/^\S+ is /, "is ")}`
15544
+ };
15545
+ }
15546
+ }
15547
+ }
15548
+ if (!source || "why" in source) return source;
15549
+ const chain = new Set([holderDecl, ...subclassesOf(holderDecl)].map(declKey));
15550
+ for (let up = graph.parentOf.get(declKey(holderDecl))?.base; up; up = graph.parentOf.get(declKey(up))?.base) {
15551
+ if (chain.has(declKey(up))) break;
15552
+ chain.add(declKey(up));
15553
+ }
15554
+ const other = (wired().writes.get(name) ?? []).find(
15555
+ (x) => (tests || !x.test) && !fromCtor.has(x.at) && mayBeIn(x, chain)
15556
+ );
15557
+ if (other) return { why: `${name} is also assigned at ${where(other.at)}, so it may hold another value` };
15558
+ const whole = writeTo(null, chain, { tests });
15559
+ if (whole)
15560
+ return { why: `${name} may be written at ${where(whole)}, which writes properties it doesn't name` };
15561
+ for (const c of [holderDecl, ...subclassesOf(holderDecl)]) {
15562
+ const node2 = classNode(c);
15563
+ const again = c !== holderDecl && node2?.members.some(
15564
+ (m) => nameOf(m.name) === name || ts.isConstructorDeclaration(m) && m.parameters.some(
15565
+ (x) => ts.isIdentifier(x.name) && x.name.text === name && ts.getModifiers(x)?.length
15566
+ )
15567
+ );
15568
+ if (again) return { why: `${c.name} declares ${name} again` };
15569
+ }
15570
+ return source;
15571
+ };
15572
+ const providedFor = (token) => {
15573
+ const node2 = classNode(token);
15574
+ const regs = (wired().provides.get(declKey(token)) ?? []).filter(
15575
+ (r) => !(r.kind === "useClass" && r.target && declKey(r.target) === declKey(token))
15576
+ );
15577
+ const unreadable = wired().unreadable[0];
15578
+ if (unreadable)
15579
+ return {
15580
+ why: `a provider at ${where(unreadable)} registers a token that can't be told, so ${token.name} may be provided otherwise`
15581
+ };
15582
+ if (regs.length === 0) {
15583
+ if (node2 && isAbstract(node2))
15584
+ return { why: `${token.name} is abstract, and nothing provides a class for it` };
15585
+ if (!wired().listed.has(declKey(token)))
15586
+ return {
15587
+ why: `nothing in the project lists ${token.name} as a provider, so how it is provided can't be told`
15588
+ };
15589
+ return { cls: token, detail: `${token.name} is provided as itself` };
15590
+ }
15591
+ const first = regs[0];
15592
+ const targets = new Set(
15593
+ regs.map((r) => r.kind === "useClass" && r.target ? declKey(r.target) : r.kind)
15594
+ );
15595
+ if (first.kind !== "useClass" || !first.target || targets.size > 1)
15596
+ return { why: `${token.name} is provided with ${first.kind} at ${where(first.at)}` };
15597
+ if (!node2 || !isAbstract(node2))
15598
+ return {
15599
+ why: `${token.name} is provided as ${first.target.name} at ${where(first.at)}, and may be itself elsewhere`
15600
+ };
15601
+ return {
15602
+ cls: first.target,
15603
+ detail: `${token.name} is provided as ${first.target.name} (${where(first.at)})`
15604
+ };
15605
+ };
15606
+ return {
15607
+ wired,
15608
+ fromField,
15609
+ providedFor,
15610
+ subclassesOf,
15611
+ classOfObject,
15612
+ under,
15613
+ mayBeIn,
15614
+ writeTo,
15615
+ thisBorrowed,
15616
+ diDecorator,
15617
+ onlyDiDecorators,
15618
+ classNode,
15619
+ where
15620
+ };
15621
+ }
15622
+ function injectedResolutions(input2, graph, s, inj = makeInjection(graph, s)) {
15623
+ const out = { resolutions: [], edges: [] };
15624
+ if (!inj || !s?.checker) return out;
15625
+ const { ts, checker, toUtf16 } = s;
15626
+ const { fromField, providedFor } = inj;
15627
+ const open3 = input2.resolutions.filter(
15628
+ (r) => r.status === "unresolved" && r.importOutcome === null && (!r.candidates || r.exhaustive === false)
15629
+ );
15630
+ if (open3.length === 0) return out;
15631
+ const sites = new Map(input2.sites.map((x) => [x.id, x]));
15632
+ for (const r of open3) {
15633
+ const site = sites.get(r.site);
15634
+ if (!site || site.reason !== "dynamic-dispatch") continue;
15635
+ const sf = s.sourceFile(site.file);
15636
+ if (!sf) continue;
15637
+ const call = callAt(ts, sf, toUtf16(sf, site.evidence.span.start.offset), site.expression);
15638
+ if (!call || !ts.isPropertyAccessExpression(call.expression)) continue;
15639
+ const member = call.expression.name.text;
15640
+ let subject = call.expression.expression;
15641
+ while (ts.isParenthesizedExpression(subject) || ts.isNonNullExpression(subject))
15642
+ subject = subject.expression;
15643
+ if (!ts.isPropertyAccessExpression(subject) || subject.expression.kind !== ts.SyntaxKind.ThisKeyword)
15644
+ continue;
15645
+ const sym = checker.getSymbolAtLocation(subject.name);
15646
+ const tests = isTestPath(site.file.slice(site.file.indexOf(":") + 1));
15647
+ const source = sym ? fromField(sym, tests) : null;
15648
+ if (!source) continue;
15649
+ const borrowed = "why" in source ? null : inj.thisBorrowed(subject.expression, tests);
15650
+ if (borrowed) {
15651
+ if (r.candidates?.length)
15652
+ out.resolutions.push({
15653
+ ...r,
15654
+ steps: [
15655
+ ...r.steps,
15656
+ {
15657
+ kind: "borrowed",
15658
+ detail: `the method is used at ${inj.where(borrowed)} without being called, so it may run with another this`
15659
+ }
15660
+ ]
15661
+ });
15662
+ continue;
15663
+ }
15664
+ const provided = "why" in source ? source : providedFor(source.token);
15665
+ const body = "cls" in provided ? graph.bodyOf(provided.cls, member) : null;
15666
+ if ("why" in provided || !body || typeof body === "string") {
15667
+ if ("why" in provided && r.candidates?.length)
15668
+ out.resolutions.push({ ...r, steps: [...r.steps, { kind: "injection", detail: provided.why }] });
15669
+ continue;
15670
+ }
15671
+ if (body.fn.file === site.file) continue;
15672
+ const steps = [
15673
+ { kind: "injection", detail: source.detail },
15674
+ {
15675
+ kind: "provided",
15676
+ detail: `${provided.detail}: a ${provided.cls.name} runs ${body.definer.name}.${member}`
15677
+ }
15678
+ ];
15679
+ out.resolutions.push({
15680
+ type: "SiteResolution",
15681
+ id: r.id,
15682
+ site: r.site,
15683
+ file: r.file,
15684
+ status: "linked",
15685
+ target: body.fn.id,
15686
+ externalPackage: null,
15687
+ via: "injection",
15688
+ importOutcome: null,
15689
+ steps,
15690
+ evidence: r.evidence
15691
+ });
15692
+ out.edges.push({
15693
+ type: "CALLS_CROSS_FILE",
15694
+ id: ids.linkedCall(site.id),
15695
+ from: site.enclosingFn,
15696
+ to: body.fn.id,
15697
+ form: "plain",
15698
+ resolution: "static-exact",
15699
+ confidence: 1,
15700
+ evidence: site.evidence,
15701
+ via: "injection"
15702
+ });
15703
+ }
15704
+ return out;
15705
+ }
15706
+ function callAt(ts, sf, pos, expression) {
15707
+ let found;
15708
+ const visit2 = (node2) => {
15709
+ if (found || node2.end <= pos || node2.getStart(sf) > pos) return;
15710
+ if (ts.isCallExpression(node2) && node2.getStart(sf) === pos && node2.expression.getText(sf).replace(/\s+/g, "") === expression.replace(/\s+/g, "")) {
15711
+ found = node2;
15712
+ return;
15713
+ }
15714
+ ts.forEachChild(node2, visit2);
15715
+ };
15716
+ visit2(sf);
15717
+ return found;
15718
+ }
15719
+ var LIBRARY_WRITERS, FRESH_MAKERS, DI_DECORATORS, LOOKUP_DECORATORS, PROVIDER_KINDS;
15720
+ var init_di = __esm({
15721
+ "packages/stage2/src/di.ts"() {
15722
+ "use strict";
15723
+ init_src();
15724
+ init_typegraph();
15725
+ LIBRARY_WRITERS = /* @__PURE__ */ new Set([
15726
+ "assign",
15727
+ "assignIn",
15728
+ "assignWith",
15729
+ "extend",
15730
+ "merge",
15731
+ "mergeWith",
15732
+ "defaults",
15733
+ "defaultsDeep",
15734
+ "set",
15735
+ "setWith",
15736
+ "update",
15737
+ "updateWith",
15738
+ "unset"
15739
+ ]);
15740
+ FRESH_MAKERS = /* @__PURE__ */ new Set([
15741
+ "Object.fromEntries",
15742
+ "Object.create",
15743
+ "JSON.parse",
15744
+ "structuredClone",
15745
+ "Array.from",
15746
+ "Array.of"
15747
+ ]);
15748
+ DI_DECORATORS = {
15749
+ "@nestjs/common": ["Injectable", "Controller", "Module", "Catch"],
15750
+ "@nestjs/graphql": ["Resolver"],
15751
+ "@nestjs/websockets": ["WebSocketGateway"],
15752
+ "@nestjs/bull": ["Processor"],
15753
+ "@nestjs/bullmq": ["Processor"],
15754
+ "@angular/core": ["Injectable", "Component", "Directive", "Pipe", "NgModule"]
15755
+ };
15756
+ LOOKUP_DECORATORS = /* @__PURE__ */ new Set(["Optional", "Self", "SkipSelf", "Host"]);
15757
+ PROVIDER_KINDS = ["useClass", "useValue", "useFactory", "useExisting"];
15758
+ }
15759
+ });
15760
+
15761
+ // packages/stage2/src/callers.ts
15762
+ function posixJoin(dir, rel) {
15763
+ const at = dir.indexOf(":");
15764
+ const parts = dir.slice(at + 1).split("/").filter(Boolean);
15765
+ for (const r of rel.split("/")) {
15766
+ if (r === "..") parts.pop();
15767
+ else if (r !== "." && r !== "") parts.push(r);
15768
+ }
15769
+ return `${dir.slice(0, at + 1)}${parts.length ? `${parts.join("/")}/` : ""}`;
15770
+ }
15771
+ function makeCallers(s, options2) {
15772
+ const { ts, fileIdOf: fileIdOf2 } = s;
15773
+ const checker = s.checker;
15774
+ const pathOf9 = (file2) => file2.slice(file2.indexOf(":") + 1);
15775
+ const files = () => (s.program?.getSourceFiles() ?? []).filter((sf) => {
15776
+ const f = fileIdOf2(sf);
15777
+ return !!f && !isTestPath(pathOf9(f));
15778
+ });
15779
+ let byText;
15780
+ let specifiers;
15781
+ const index = () => {
15782
+ if (byText) return;
15783
+ byText = /* @__PURE__ */ new Map();
15784
+ specifiers = [];
15785
+ for (const sf of files()) {
15786
+ const visit2 = (node2) => {
15787
+ if (ts.isIdentifier(node2)) {
15788
+ const list = byText.get(node2.text);
15789
+ if (list) list.push(node2);
15790
+ else byText.set(node2.text, [node2]);
15791
+ }
15792
+ if (ts.isImportSpecifier(node2) || ts.isExportSpecifier(node2) || ts.isImportClause(node2) && node2.name || ts.isNamespaceImport(node2) || ts.isImportEqualsDeclaration(node2))
15793
+ specifiers.push(node2);
15794
+ ts.forEachChild(node2, visit2);
15795
+ };
15796
+ visit2(sf);
15797
+ }
15798
+ };
15799
+ let aliases;
15800
+ const aliasNames = () => {
15801
+ if (aliases) return aliases;
15802
+ index();
15803
+ aliases = /* @__PURE__ */ new Map();
15804
+ for (const sp of specifiers) {
15805
+ const local = ts.isImportClause(sp) ? sp.name : ts.isNamespaceImport(sp) || ts.isImportEqualsDeclaration(sp) ? void 0 : sp.name;
15806
+ const sym = local && resolve9(checker.getSymbolAtLocation(local));
15807
+ if (!local || !sym) continue;
15808
+ const list = aliases.get(sym);
15809
+ if (list) list.push(local.text);
15810
+ else aliases.set(sym, [local.text]);
15811
+ }
15812
+ return aliases;
15813
+ };
15814
+ const named = /* @__PURE__ */ new Map();
15815
+ const byName = (name) => {
15816
+ const hit = named.get(name);
15817
+ if (hit) return hit;
15818
+ index();
15819
+ const out = /* @__PURE__ */ new Map();
15820
+ for (const id of byText.get(name) ?? []) {
15821
+ const sym = ts.isShorthandPropertyAssignment(id.parent) ? checker.getShorthandAssignmentValueSymbol(id.parent) : resolve9(checker.getSymbolAtLocation(id));
15822
+ const list = out.get(sym);
15823
+ if (list) list.push(id);
15824
+ else out.set(sym, [id]);
15825
+ }
15826
+ named.set(name, out);
15827
+ return out;
15828
+ };
15829
+ const resolve9 = (sym) => sym && sym.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
15830
+ const symbolOfCallee = (c) => c.name ? checker.getSymbolAtLocation(c.name) : c.symbol;
15831
+ const exported = (c) => {
15832
+ if (!ts.isExternalModule(c.getSourceFile()) && ts.isSourceFile(ts.isVariableDeclaration(c) ? c.parent.parent.parent : c.parent))
15833
+ return true;
15834
+ const statement = ts.isVariableDeclaration(c) ? c.parent.parent : c;
15835
+ if (ts.canHaveModifiers(statement) && ts.getModifiers(statement)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword))
15836
+ return true;
15837
+ const name = c.name && ts.isIdentifier(c.name) ? c.name.text : null;
15838
+ return c.getSourceFile().statements.some(
15839
+ (st) => ts.isExportDeclaration(st) && !st.moduleSpecifier && !!st.exportClause && ts.isNamedExports(st.exportClause) && st.exportClause.elements.some((el) => (el.propertyName ?? el.name).text === name) || ts.isExportAssignment(st) && ts.isIdentifier(st.expression) && st.expression.text === name
15840
+ );
15841
+ };
15842
+ let indirect;
15843
+ let moduleObjects;
15844
+ const scanIndirect = () => {
15845
+ if (indirect) return;
15846
+ indirect = [];
15847
+ moduleObjects = [];
15848
+ for (const sf of files()) {
15849
+ const visit2 = (n2) => {
15850
+ if (ts.isNewExpression(n2)) {
15851
+ let e = n2.expression;
15852
+ while (ts.isParenthesizedExpression(e) || ts.isAsExpression(e) || ts.isNonNullExpression(e))
15853
+ e = e.expression;
15854
+ const sym = ts.isIdentifier(e) || ts.isPropertyAccessExpression(e) ? resolve9(checker.getSymbolAtLocation(e)) : void 0;
15855
+ const named2 = !!sym && !!(sym.flags & ts.SymbolFlags.Class);
15856
+ if (!named2) indirect.push({ at: n2, type: checker.getTypeAtLocation(n2) });
15857
+ }
15858
+ if (ts.isCallExpression(n2) && ts.isPropertyAccessExpression(n2.expression) && n2.expression.name.text === "construct" && ts.isIdentifier(n2.expression.expression) && n2.expression.expression.text === "Reflect" && n2.arguments[0]) {
15859
+ const made = checker.getTypeAtLocation(n2.arguments[0]).getConstructSignatures()[0]?.getReturnType();
15860
+ indirect.push({ at: n2, type: made ?? checker.getAnyType() });
15861
+ }
15862
+ if (ts.isExportDeclaration(n2) && n2.exportClause && ts.isNamespaceExport(n2.exportClause) && n2.moduleSpecifier) {
15863
+ const mod = checker.getSymbolAtLocation(n2.moduleSpecifier);
15864
+ moduleObjects.push({ at: n2, module: mod, plain: false });
15865
+ }
15866
+ if (ts.isNamespaceImport(n2)) {
15867
+ const mod = resolve9(checker.getSymbolAtLocation(n2.name));
15868
+ if (mod) {
15869
+ const sym = checker.getSymbolAtLocation(n2.name);
15870
+ let plain2 = true;
15871
+ for (const id of byName(n2.name.text).get(resolve9(sym)) ?? byName(n2.name.text).get(sym) ?? [])
15872
+ if (id !== n2.name && !(ts.isPropertyAccessExpression(id.parent) && id.parent.expression === id) && !ts.isQualifiedName(id.parent) && !ts.findAncestor(id, ts.isTypeNode) && // Another import of the module names it; it isn't a use.
15873
+ !ts.isImportClause(id.parent) && !ts.isNamespaceImport(id.parent) && !ts.isImportSpecifier(id.parent) && !ts.isExportSpecifier(id.parent) && !ts.isImportEqualsDeclaration(id.parent))
15874
+ plain2 = false;
15875
+ moduleObjects.push({ at: n2, module: mod, plain: plain2 });
15876
+ }
15877
+ }
15878
+ if (ts.isCallExpression(n2) && n2.expression.kind === ts.SyntaxKind.ImportKeyword) {
15879
+ const arg = n2.arguments[0];
15880
+ const mod = arg && ts.isStringLiteralLike(arg) ? checker.getSymbolAtLocation(arg) : void 0;
15881
+ let up = n2.parent;
15882
+ let inner = n2;
15883
+ while (ts.isAwaitExpression(up) || ts.isParenthesizedExpression(up)) {
15884
+ inner = up;
15885
+ up = up.parent;
15886
+ }
15887
+ const member = ts.isPropertyAccessExpression(up) && up.expression === inner && !!mod && checker.getExportsOfModule(mod).some((x) => x.name === up.name.text);
15888
+ const plain2 = ts.isVariableDeclaration(up) && ts.isObjectBindingPattern(up.name) && !up.name.elements.some(
15889
+ (e) => e.dotDotDotToken || e.propertyName && ts.isComputedPropertyName(e.propertyName)
15890
+ );
15891
+ let folder;
15892
+ if (!mod && arg && !ts.isStringLiteralLike(arg)) {
15893
+ let left = arg;
15894
+ while (ts.isBinaryExpression(left) && left.operatorToken.kind === ts.SyntaxKind.PlusToken)
15895
+ left = left.left;
15896
+ const head = ts.isTemplateExpression(left) ? left.head.text : ts.isStringLiteralLike(left) && left !== arg ? left.text : "";
15897
+ const from = fileIdOf2(sf);
15898
+ const dir = from.slice(0, from.lastIndexOf("/") + 1);
15899
+ folder = head === "" ? null : head.startsWith(".") ? posixJoin(dir, head.slice(0, head.lastIndexOf("/") + 1)) : void 0;
15900
+ }
15901
+ moduleObjects.push({
15902
+ at: n2,
15903
+ module: mod,
15904
+ plain: (plain2 || member) && (!!mod || !!arg && ts.isStringLiteralLike(arg)),
15905
+ ...folder !== void 0 ? { folder } : {}
15906
+ });
15907
+ }
15908
+ ts.forEachChild(n2, visit2);
15909
+ };
15910
+ visit2(sf);
15911
+ }
15912
+ };
15913
+ const madeIndirectly = (c) => {
15914
+ scanIndirect();
15915
+ const sym = c.name ? checker.getSymbolAtLocation(c.name) : void 0;
15916
+ const own2 = sym ? checker.getDeclaredTypeOfSymbol(sym) : void 0;
15917
+ if (!own2) return null;
15918
+ return indirect.find(
15919
+ (x) => x.type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown) || x.type === own2 || checker.isTypeAssignableTo(x.type, own2)
15920
+ )?.at ?? null;
15921
+ };
15922
+ const exportsOf = /* @__PURE__ */ new Map();
15923
+ const moduleObjectEscapes = (c, target2) => {
15924
+ scanIndirect();
15925
+ for (const m of moduleObjects) {
15926
+ if (m.plain) continue;
15927
+ if (!m.module) {
15928
+ const file2 = fileIdOf2(c.getSourceFile()) ?? "";
15929
+ if (m.folder === null || m.folder !== void 0 && file2.startsWith(m.folder)) return m.at;
15930
+ continue;
15931
+ }
15932
+ let set2 = exportsOf.get(m.module);
15933
+ if (!set2) {
15934
+ set2 = new Set(
15935
+ checker.getExportsOfModule(m.module).map((e) => resolve9(e)).filter(Boolean)
15936
+ );
15937
+ exportsOf.set(m.module, set2);
15938
+ }
15939
+ if (set2.has(target2)) return m.at;
15940
+ }
15941
+ void c;
15942
+ return null;
15943
+ };
15944
+ const cache = /* @__PURE__ */ new Map();
15945
+ const callersOf = (c, seen = /* @__PURE__ */ new Set()) => {
15946
+ const hit = cache.get(c);
15947
+ if (hit) return hit;
15948
+ if (seen.has(c)) return { why: "its classes extend each other in a cycle" };
15949
+ seen.add(c);
15950
+ const found = find2(c, seen);
15951
+ cache.set(c, found);
15952
+ return found;
15953
+ };
15954
+ const find2 = (c, seen) => {
15955
+ const label = c.name && ts.isIdentifier(c.name) ? c.name.text : "the default export";
15956
+ const target2 = symbolOfCallee(c);
15957
+ if (!target2) return { why: `${label} can't be followed` };
15958
+ const isExported = exported(c);
15959
+ const file2 = fileIdOf2(c.getSourceFile());
15960
+ if (isExported && !options2.closedWorld)
15961
+ return { why: `${label} is exported, so code outside the analysis may call it` };
15962
+ if (isExported && !ts.isExternalModule(c.getSourceFile()))
15963
+ return { why: `${label} is a global of a script, which the page may call` };
15964
+ if (isExported && file2 && options2.importedFromOutside(file2))
15965
+ return { why: `${label}'s module is imported by a file whose code isn't typed here` };
15966
+ index();
15967
+ if (ts.isClassDeclaration(c)) {
15968
+ const made = madeIndirectly(c);
15969
+ if (made)
15970
+ return {
15971
+ why: `${label} may be constructed at ${options2.where(made)}, by a value that isn't its name`
15972
+ };
15973
+ }
15974
+ if (isExported) {
15975
+ const through = moduleObjectEscapes(c, target2);
15976
+ if (through)
15977
+ return {
15978
+ why: `${label}'s module is used as an object at ${options2.where(through)}, which may call it`
15979
+ };
15980
+ }
15981
+ const names = new Set(c.name && ts.isIdentifier(c.name) ? [c.name.text] : []);
15982
+ for (const n2 of aliasNames().get(target2) ?? []) names.add(n2);
15983
+ const calls = [];
15984
+ for (const name of names)
15985
+ for (const [sym, ids2] of byName(name))
15986
+ for (const id of ids2) {
15987
+ if (id === c.name) continue;
15988
+ const p = id.parent;
15989
+ if (sym !== target2) {
15990
+ if (!isExported || sym) break;
15991
+ if (isExported && !sym && ts.isPropertyAccessExpression(p) && p.name === id && checker.getTypeAtLocation(p.expression).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown))
15992
+ return {
15993
+ why: `${p.getText()} at ${options2.where(p)} may be ${label}, on a value whose type isn't known`
15994
+ };
15995
+ continue;
15996
+ }
15997
+ if (ts.isImportSpecifier(p) || ts.isExportSpecifier(p) || ts.isImportClause(p) || ts.findAncestor(id, (n2) => ts.isTypeNode(n2) || ts.isTypeQueryNode(n2)))
15998
+ continue;
15999
+ const called = ts.isPropertyAccessExpression(p) && p.name === id ? p : id;
16000
+ const user = called.parent;
16001
+ if ((ts.isCallExpression(user) || ts.isNewExpression(user)) && user.expression === called) {
16002
+ if (ts.isClassDeclaration(c) !== ts.isNewExpression(user))
16003
+ return {
16004
+ why: `${label} is ${ts.isNewExpression(user) ? "constructed" : "called"} at ${options2.where(user)}`
16005
+ };
16006
+ calls.push({ call: user, args: user.arguments ?? [] });
16007
+ continue;
16008
+ }
16009
+ if (ts.isClassDeclaration(c)) {
16010
+ const heritage = ts.findAncestor(id, ts.isHeritageClause);
16011
+ const sub = heritage?.parent;
16012
+ if (heritage?.token === ts.SyntaxKind.ExtendsKeyword && sub && ts.isClassDeclaration(sub) && ts.isExpressionWithTypeArguments(called.parent) && called.parent.parent === heritage) {
16013
+ const ctor = sub.members.find(
16014
+ (m) => ts.isConstructorDeclaration(m) && !!m.body
16015
+ );
16016
+ if (ctor) {
16017
+ const sups = [];
16018
+ const look = (n2) => {
16019
+ if (n2 !== ctor.body && ts.isFunctionLike(n2)) return;
16020
+ if (ts.isCallExpression(n2) && n2.expression.kind === ts.SyntaxKind.SuperKeyword)
16021
+ sups.push(n2);
16022
+ else ts.forEachChild(n2, look);
16023
+ };
16024
+ look(ctor.body);
16025
+ if (!sups.length) return { why: `${sub.name?.text ?? "a subclass"} never calls super` };
16026
+ for (const sup of sups) calls.push({ call: sup, args: sup.arguments });
16027
+ } else {
16028
+ const through = callersOf(sub, seen);
16029
+ if ("why" in through) return through;
16030
+ calls.push(...through.calls);
16031
+ }
16032
+ continue;
16033
+ }
16034
+ if (ts.isPropertyAccessExpression(p) && p.expression === id && p.name.text !== "prototype")
16035
+ continue;
16036
+ if (ts.isBinaryExpression(p) && p.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword)
16037
+ continue;
16038
+ }
16039
+ return {
16040
+ why: `${label} is used as a value at ${options2.where(id)}, so what calls it can't all be seen`
16041
+ };
16042
+ }
16043
+ return { calls, closedWorld: isExported };
16044
+ };
16045
+ return { callersOf };
16046
+ }
16047
+ var init_callers = __esm({
16048
+ "packages/stage2/src/callers.ts"() {
16049
+ "use strict";
16050
+ init_src();
16051
+ }
16052
+ });
16053
+
16054
+ // packages/stage2/src/returns.ts
16055
+ function returnedResolutions(input2, graph, s, inj = null) {
16056
+ const out = { resolutions: [], edges: [] };
16057
+ if (!s?.checker) return out;
16058
+ const { ts, checker, fileIdOf: fileIdOf2, toByte, toUtf16 } = s;
16059
+ const open3 = input2.resolutions.filter(
16060
+ (r) => r.status === "unresolved" && r.importOutcome === null && (!r.candidates || r.exhaustive === false)
16061
+ );
16062
+ if (open3.length === 0) return out;
16063
+ const sites = new Map(input2.sites.map((x) => [x.id, x]));
16064
+ const pathOf9 = (file2) => file2.slice(file2.indexOf(":") + 1);
16065
+ const where = (node2) => {
16066
+ const sf = node2.getSourceFile();
16067
+ const file2 = fileIdOf2(sf);
16068
+ return `${file2 ? pathOf9(file2) : sf.fileName}:${sf.getLineAndCharacterOfPosition(node2.getStart(sf)).line + 1}`;
16069
+ };
16070
+ const evidenceOf2 = (node2) => {
16071
+ const sf = node2.getSourceFile();
16072
+ const file2 = fileIdOf2(sf);
16073
+ if (!file2) return null;
16074
+ const pos = (p) => {
16075
+ const lc = sf.getLineAndCharacterOfPosition(p);
16076
+ return { line: lc.line + 1, column: lc.character + 1, offset: toByte(sf, p) };
16077
+ };
16078
+ return {
16079
+ file: file2,
16080
+ span: { start: pos(node2.getStart(sf)), end: pos(node2.end) },
16081
+ commit: input2.revisions.get(file2.slice(0, file2.indexOf(":"))) ?? ""
16082
+ };
16083
+ };
16084
+ const fnByEnd = /* @__PURE__ */ new Map();
16085
+ for (const fn of input2.functions) {
16086
+ const k = `${fn.file}\0${fn.evidence.span.end.offset}`;
16087
+ const list = fnByEnd.get(k);
16088
+ if (list) list.push(fn);
16089
+ else fnByEnd.set(k, [fn]);
16090
+ }
16091
+ const functionOf = (node2) => {
16092
+ const sf = node2.getSourceFile();
16093
+ const file2 = fileIdOf2(sf);
16094
+ if (!file2) return void 0;
16095
+ const start = toByte(sf, node2.getStart(sf));
16096
+ return (fnByEnd.get(`${file2}\0${toByte(sf, node2.end)}`) ?? []).filter((f) => f.evidence.span.start.offset >= start).sort((a, b) => a.evidence.span.start.offset - b.evidence.span.start.offset)[0];
16097
+ };
16098
+ const unwrap = (e) => {
16099
+ while (ts.isParenthesizedExpression(e) || ts.isAsExpression(e) || ts.isSatisfiesExpression(e) || ts.isNonNullExpression(e) || ts.isTypeAssertionExpression(e))
16100
+ e = e.expression;
16101
+ return e;
16102
+ };
16103
+ const symbolOf = (node2) => {
16104
+ const sym = checker.getSymbolAtLocation(node2);
16105
+ return sym && sym.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
16106
+ };
16107
+ const isConst = (d) => ts.isVariableDeclaration(d) && (ts.getCombinedNodeFlags(d) & ts.NodeFlags.Const) !== 0 && ts.isVariableDeclarationList(d.parent);
16108
+ const isFunctionNode = (n2) => ts.isArrowFunction(n2) || ts.isFunctionExpression(n2) || ts.isFunctionDeclaration(n2);
16109
+ const classOf = (e) => {
16110
+ const d = symbolOf(unwrap(e))?.valueDeclaration;
16111
+ if (!d || !ts.isClassDeclaration(d) || !d.name || !ts.isSourceFile(d.parent)) return null;
16112
+ const file2 = fileIdOf2(d.getSourceFile());
16113
+ const decl = file2 ? { file: file2, name: d.name.text } : null;
16114
+ return decl && graph.declared(decl) ? decl : null;
16115
+ };
16116
+ const importedAs = (callee) => {
16117
+ const e = unwrap(callee);
16118
+ if (ts.isPropertyAccessExpression(e) && ts.isIdentifier(e.expression)) {
16119
+ const d = checker.getSymbolAtLocation(e.expression)?.declarations?.[0];
16120
+ const imp = d && ts.findAncestor(d, ts.isImportDeclaration);
16121
+ return imp && ts.isStringLiteral(imp.moduleSpecifier) ? { pkg: imp.moduleSpecifier.text, name: e.name.text } : null;
16122
+ }
16123
+ if (!ts.isIdentifier(e)) return null;
16124
+ const spec = checker.getSymbolAtLocation(e)?.declarations?.[0];
16125
+ if (!spec || !ts.isImportSpecifier(spec)) return null;
16126
+ const decl = spec.parent.parent.parent;
16127
+ return ts.isImportDeclaration(decl) && ts.isStringLiteral(decl.moduleSpecifier) ? { pkg: decl.moduleSpecifier.text, name: (spec.propertyName ?? spec.name).text } : null;
16128
+ };
16129
+ const badUses = /* @__PURE__ */ new Map();
16130
+ const onlyRead = (name, scope2, except) => {
16131
+ const sym = checker.getSymbolAtLocation(name);
16132
+ if (!sym) return false;
16133
+ let byScope = badUses.get(sym);
16134
+ if (!byScope) badUses.set(sym, byScope = /* @__PURE__ */ new Map());
16135
+ let bad = byScope.get(scope2);
16136
+ if (!bad) {
16137
+ work += 10;
16138
+ const found = [];
16139
+ const visit2 = (node2) => {
16140
+ if (ts.isIdentifier(node2) && node2 !== name && checker.getSymbolAtLocation(node2) === sym) {
16141
+ const p = node2.parent;
16142
+ const member = (ts.isPropertyAccessExpression(p) || ts.isElementAccessExpression(p)) && p.expression === node2;
16143
+ if (!member || written2(p)) found.push(node2);
16144
+ return;
16145
+ }
16146
+ if (ts.isShorthandPropertyAssignment(node2) && checker.getShorthandAssignmentValueSymbol(node2) === sym) {
16147
+ found.push(node2);
16148
+ return;
16149
+ }
16150
+ ts.forEachChild(node2, visit2);
16151
+ };
16152
+ visit2(scope2);
16153
+ byScope.set(scope2, bad = found);
16154
+ }
16155
+ return bad.every(
16156
+ (b) => !!except && (b === except || b.parent === except || ts.isShorthandPropertyAssignment(b) && b.name === except)
16157
+ );
16158
+ };
16159
+ const written2 = (node2) => {
16160
+ let at = node2;
16161
+ while (ts.isParenthesizedExpression(at.parent) || ts.isPropertyAssignment(at.parent) || ts.isShorthandPropertyAssignment(at.parent) || ts.isObjectLiteralExpression(at.parent) || ts.isArrayLiteralExpression(at.parent) || ts.isSpreadElement(at.parent) || ts.isSpreadAssignment(at.parent)) {
16162
+ if (ts.isPropertyAssignment(at.parent) && at.parent.initializer !== at) return false;
16163
+ at = at.parent;
16164
+ }
16165
+ const p = at.parent;
16166
+ if (ts.isDeleteExpression(p)) return true;
16167
+ if (ts.isBinaryExpression(p))
16168
+ return p.left === at && p.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && p.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
16169
+ if (ts.isPrefixUnaryExpression(p) || ts.isPostfixUnaryExpression(p)) return true;
16170
+ return (ts.isForOfStatement(p) || ts.isForInStatement(p)) && p.initializer === at;
16171
+ };
16172
+ const thisEscapes = (fn, writes) => {
16173
+ let escapes = false;
16174
+ const visit2 = (node2) => {
16175
+ if (escapes) return;
16176
+ if (node2 !== fn && (ts.isFunctionDeclaration(node2) || ts.isFunctionExpression(node2) || ts.isClassLike(node2)))
16177
+ return;
16178
+ if (node2.kind === ts.SyntaxKind.ThisKeyword) {
16179
+ const p = node2.parent;
16180
+ const member = (ts.isPropertyAccessExpression(p) || ts.isElementAccessExpression(p)) && p.expression === node2;
16181
+ if (!member || writes && written2(p)) escapes = true;
16182
+ return;
16183
+ }
16184
+ ts.forEachChild(node2, visit2);
16185
+ };
16186
+ visit2(fn);
16187
+ return escapes;
16188
+ };
16189
+ const thisSafe = (v) => {
16190
+ if (ts.isMethodDeclaration(v)) return !thisEscapes(v, true);
16191
+ if (ts.isShorthandPropertyAssignment(v.parent) && v.parent.name === v) {
16192
+ const d = checker.getShorthandAssignmentValueSymbol(v.parent)?.valueDeclaration;
16193
+ return d ? thisSafeDecl(d) : false;
16194
+ }
16195
+ const e = unwrap(v);
16196
+ if (ts.isArrowFunction(e) || ts.isObjectLiteralExpression(e) || ts.isArrayLiteralExpression(e))
16197
+ return true;
16198
+ if (ts.isFunctionExpression(e)) return !thisEscapes(e, true);
16199
+ if (ts.isStringLiteralLike(e) || ts.isNumericLiteral(e) || ts.isTemplateExpression(e) || e.kind === ts.SyntaxKind.TrueKeyword || e.kind === ts.SyntaxKind.FalseKeyword || e.kind === ts.SyntaxKind.NullKeyword)
16200
+ return true;
16201
+ if (ts.isIdentifier(e)) {
16202
+ const d = symbolOf(e)?.valueDeclaration;
16203
+ return d ? thisSafeDecl(d) : false;
16204
+ }
16205
+ return false;
16206
+ };
16207
+ const thisSafeDecl = (d) => {
16208
+ if (ts.isFunctionDeclaration(d)) return isFixedFunction(d) && !thisEscapes(d, true);
16209
+ if (!isConst(d)) return false;
16210
+ const init = d.initializer;
16211
+ return !!init && !ts.isIdentifier(unwrap(init)) && thisSafe(init);
16212
+ };
16213
+ const fixedName = /* @__PURE__ */ new Map();
16214
+ const isFixedFunction = (d) => {
16215
+ const name = d.name;
16216
+ if (!name) return true;
16217
+ const sym = checker.getSymbolAtLocation(name);
16218
+ if (!sym) return false;
16219
+ const hit = fixedName.get(sym);
16220
+ if (hit !== void 0) return hit;
16221
+ let fixed = (sym.declarations ?? []).filter((x) => ts.isFunctionDeclaration(x)).length === 1;
16222
+ for (const id of writtenNames(d.getSourceFile()).get(name.text) ?? []) {
16223
+ if (!fixed) break;
16224
+ if (id !== name && checker.getSymbolAtLocation(id) === sym) fixed = false;
16225
+ }
16226
+ fixedName.set(sym, fixed);
16227
+ return fixed;
16228
+ };
16229
+ const writtenByFile = /* @__PURE__ */ new Map();
16230
+ const writtenNames = (sf) => {
16231
+ const hit = writtenByFile.get(sf);
16232
+ if (hit) return hit;
16233
+ const out2 = /* @__PURE__ */ new Map();
16234
+ const visit2 = (node2) => {
16235
+ if (ts.isIdentifier(node2) && written2(node2)) {
16236
+ const list = out2.get(node2.text);
16237
+ if (list) list.push(node2);
16238
+ else out2.set(node2.text, [node2]);
16239
+ }
16240
+ ts.forEachChild(node2, visit2);
16241
+ };
16242
+ visit2(sf);
16243
+ writtenByFile.set(sf, out2);
16244
+ return out2;
16245
+ };
16246
+ const exportedSeen = /* @__PURE__ */ new Map();
16247
+ const exported = (decl) => {
16248
+ const hit = exportedSeen.get(decl);
16249
+ if (hit !== void 0) return hit;
16250
+ const is = isExported(decl);
16251
+ exportedSeen.set(decl, is);
16252
+ return is;
16253
+ };
16254
+ const isExported = (decl) => {
16255
+ const statement = decl.parent.parent;
16256
+ if (ts.canHaveModifiers(statement) && ts.getModifiers(statement)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword))
16257
+ return true;
16258
+ const name = ts.isIdentifier(decl.name) ? decl.name.text : null;
16259
+ return decl.getSourceFile().statements.some(
16260
+ (st) => ts.isExportDeclaration(st) && !st.moduleSpecifier && st.exportClause && ts.isNamedExports(st.exportClause) && st.exportClause.elements.some((el) => (el.propertyName ?? el.name).text === name) || ts.isExportAssignment(st) && ts.isIdentifier(st.expression) && st.expression.text === name
16261
+ );
16262
+ };
16263
+ const ANY = "\0any";
16264
+ const HANDED = "\0handed";
16265
+ const onlyReadProto = (p, depth = 0) => {
16266
+ let at = p;
16267
+ while (ts.isParenthesizedExpression(at.parent) || ts.isNonNullExpression(at.parent) || ts.isAsExpression(at.parent))
16268
+ at = at.parent;
16269
+ const parent = at.parent;
16270
+ if ((ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === at)
16271
+ return !written2(parent);
16272
+ if (ts.isCallExpression(parent) && parent.expression !== at) {
16273
+ const c = unwrap(parent.expression);
16274
+ if (!ts.isPropertyAccessExpression(c)) return false;
16275
+ if (ts.isIdentifier(c.expression))
16276
+ return (c.expression.text === "Object" || c.expression.text === "Reflect") && PROTOTYPE_READERS.has(c.name.text);
16277
+ const fn = unwrap(c.expression);
16278
+ return (c.name.text === "call" || c.name.text === "apply") && ts.isPropertyAccessExpression(fn) && ["hasOwnProperty", "propertyIsEnumerable", "isPrototypeOf"].includes(fn.name.text);
16279
+ }
16280
+ if (ts.isBinaryExpression(parent) && [
16281
+ ts.SyntaxKind.EqualsEqualsEqualsToken,
16282
+ ts.SyntaxKind.ExclamationEqualsEqualsToken,
16283
+ ts.SyntaxKind.EqualsEqualsToken,
16284
+ ts.SyntaxKind.ExclamationEqualsToken
16285
+ ].includes(parent.operatorToken.kind))
16286
+ return true;
16287
+ if (ts.isTypeOfExpression(parent)) return true;
16288
+ if (ts.isVariableDeclaration(parent) && parent.initializer === at && isConst(parent) && depth < 3) {
16289
+ if (!ts.isIdentifier(parent.name)) return false;
16290
+ const sym = checker.getSymbolAtLocation(parent.name);
16291
+ const scope2 = ts.findAncestor(parent, (n2) => isFunctionNode(n2) || ts.isSourceFile(n2));
16292
+ if (!sym || !scope2) return false;
16293
+ let ok = true;
16294
+ const visit2 = (node2) => {
16295
+ if (!ok) return;
16296
+ if (ts.isIdentifier(node2) && node2 !== parent.name && checker.getSymbolAtLocation(node2) === sym)
16297
+ ok = onlyReadProto(node2, depth + 1);
16298
+ else ts.forEachChild(node2, visit2);
16299
+ };
16300
+ visit2(scope2);
16301
+ return ok;
16302
+ }
16303
+ return false;
16304
+ };
16305
+ const heldClass = (e) => {
16306
+ const c = classOf(e);
16307
+ if (c) return c;
16308
+ if (!ts.isIdentifier(unwrap(e))) return "any";
16309
+ const sym = symbolOf(unwrap(e));
16310
+ const decls = sym?.declarations ?? [];
16311
+ if (decls.length && decls.every((d2) => !fileIdOf2(d2.getSourceFile())))
16312
+ return ts.isIdentifier(unwrap(e)) && unwrap(e).text === "Object" ? "Object" : "lib";
16313
+ const t = checker.getTypeAtLocation(e);
16314
+ if (t.isUnion()) return null;
16315
+ const sigs = t.getConstructSignatures();
16316
+ const made = sigs.length === 1 ? sigs[0].getReturnType().getSymbol() : void 0;
16317
+ const d = made?.valueDeclaration ?? made?.declarations?.[0];
16318
+ if (!d || !ts.isClassDeclaration(d) || !d.name || !ts.isSourceFile(d.parent)) return null;
16319
+ const file2 = fileIdOf2(d.getSourceFile());
16320
+ const decl = file2 ? { file: file2, name: d.name.text } : null;
16321
+ return decl && graph.declared(decl) ? decl : null;
16322
+ };
16323
+ let touched;
16324
+ const prototypeTouched = () => {
16325
+ if (touched) return touched;
16326
+ const found = /* @__PURE__ */ new Set();
16327
+ for (const sf of s.program?.getSourceFiles() ?? []) {
16328
+ const file2 = fileIdOf2(sf);
16329
+ if (!file2 || isTestPath(pathOf9(file2))) continue;
16330
+ const visit2 = (node2) => {
16331
+ const key = ts.isPropertyAccessExpression(node2) ? node2.name.text : ts.isElementAccessExpression(node2) && ts.isStringLiteralLike(node2.argumentExpression) ? node2.argumentExpression.text : null;
16332
+ if (key === "prototype" && !onlyReadProto(node2)) {
16333
+ const c = ts.isPropertyAccessExpression(node2) ? heldClass(node2.expression) : null;
16334
+ if (c === "Object" || c === "any") found.add(ANY);
16335
+ else if (c === "lib") {
16336
+ } else if (c) found.add(declKey(c));
16337
+ else found.add(HANDED);
16338
+ } else if (key === "__proto__" && !onlyReadProto(node2)) found.add(ANY);
16339
+ else if (ts.isCallExpression(node2) && ts.isPropertyAccessExpression(node2.expression)) {
16340
+ const name = node2.expression.name.text;
16341
+ if (name === "setPrototypeOf" || name === "getPrototypeOf" && !onlyReadProto(node2))
16342
+ found.add(ANY);
16343
+ }
16344
+ ts.forEachChild(node2, visit2);
16345
+ };
16346
+ visit2(sf);
16347
+ }
16348
+ return touched = found;
16349
+ };
16350
+ const prototypeWritten = (k) => prototypeTouched().has(ANY) || prototypeTouched().has(k) || prototypeTouched().has(HANDED) && (!inj || inj.wired().handed.has(k));
16351
+ const classDecl = (c) => s.sourceFile(c.file)?.statements.find((x) => ts.isClassDeclaration(x) && x.name?.text === c.name);
16352
+ const soundClass = /* @__PURE__ */ new Map();
16353
+ const isSoundClass = (c, strict = true) => {
16354
+ const key = `${strict ? "s" : "l"}\0${declKey(c)}`;
16355
+ const hit = soundClass.get(key);
16356
+ if (hit !== void 0) return hit;
16357
+ let ok = true;
16358
+ const seen = /* @__PURE__ */ new Set();
16359
+ for (let at = c; at && ok; at = graph.parentOf.get(`${at.file}\0${at.name}`)?.base) {
16360
+ const k = `${at.file}\0${at.name}`;
16361
+ if (seen.has(k)) break;
16362
+ seen.add(k);
16363
+ const node2 = classDecl(at);
16364
+ const parent = graph.parentOf.get(k);
16365
+ const decorated = !!node2 && !!ts.getDecorators(node2)?.length && (strict || !inj?.onlyDiDecorators(node2));
16366
+ if (!node2 || decorated || parent && !parent.base || prototypeWritten(k)) {
16367
+ ok = false;
16368
+ break;
16369
+ }
16370
+ for (const m of node2.members) {
16371
+ if (ts.isConstructorDeclaration(m) && m.body) {
16372
+ const returns = (n2) => ts.isFunctionLike(n2) && n2 !== m ? false : ts.isReturnStatement(n2) && !!n2.expression || !!ts.forEachChild(n2, (x) => returns(x) || void 0);
16373
+ if (returns(m.body)) ok = false;
16374
+ }
16375
+ if (ok && strict && thisEscapes(m, false)) ok = false;
16376
+ }
16377
+ }
16378
+ soundClass.set(key, ok);
16379
+ return ok;
16380
+ };
16381
+ const calleeOf = (call) => {
16382
+ const d = symbolOf(unwrap(call.expression))?.valueDeclaration;
16383
+ if (!d || !fileIdOf2(d.getSourceFile())) return null;
16384
+ if (ts.isFunctionDeclaration(d)) return d.body && isFixedFunction(d) ? d : null;
16385
+ if (isConst(d)) {
16386
+ const init = d.initializer;
16387
+ const f = init && unwrap(init);
16388
+ return f && (ts.isArrowFunction(f) || ts.isFunctionExpression(f)) ? f : null;
16389
+ }
16390
+ if (ts.isMethodDeclaration(d) && d.body && ts.getCombinedModifierFlags(d) & ts.ModifierFlags.Static) {
16391
+ const on = ts.isPropertyAccessExpression(unwrap(call.expression)) ? classOf(unwrap(call.expression).expression) : null;
16392
+ const own2 = d.parent && ts.isClassDeclaration(d.parent) && d.parent.name?.text;
16393
+ if (!on || on.name !== own2 || !ts.isIdentifier(d.name)) return null;
16394
+ const st = graph.staticOf(on, d.name.text);
16395
+ return typeof st !== "string" && st.fn.id === functionOf(d)?.id ? d : null;
16396
+ }
16397
+ return null;
16398
+ };
16399
+ let notes;
16400
+ let flowed;
16401
+ let work;
16402
+ let closed;
16403
+ let siteTest = false;
16404
+ const note = (kind, detail) => {
16405
+ if (!notes.some((n2) => n2.detail === detail)) notes.push({ kind, detail });
16406
+ };
16407
+ const short = (n2) => {
16408
+ const t = n2.getText(n2.getSourceFile()).replace(/\s+/g, " ");
16409
+ return t.length > 60 ? `${t.slice(0, 57)}\u2026` : t;
16410
+ };
16411
+ const keyOf2 = (n2) => n2 && (ts.isIdentifier(n2) || ts.isStringLiteralLike(n2) || ts.isPrivateIdentifier(n2)) ? n2.text : null;
16412
+ const describe4 = (v) => v.length === 0 ? "nothing that runs" : [
16413
+ ...new Set(
16414
+ v.map(
16415
+ (a) => a.kind === "fn" ? a.fn.qualifiedName : a.kind === "instance" ? `an instance of ${a.cls.name}` : "an object"
16416
+ )
16417
+ )
16418
+ ].join(" or ");
16419
+ const share = (a) => a.kind === "fn" ? a : { ...a, shared: true };
16420
+ const upChain = (c) => {
16421
+ const out2 = [];
16422
+ const seen = /* @__PURE__ */ new Set();
16423
+ for (let at = c; at && !seen.has(declKey(at)); at = graph.parentOf.get(declKey(at))?.base) {
16424
+ seen.add(declKey(at));
16425
+ out2.push(at);
16426
+ }
16427
+ return out2;
16428
+ };
16429
+ const writesSeen = /* @__PURE__ */ new Map();
16430
+ const writeOf = (name, chain, except, literal2) => {
16431
+ if (!inj) return ts.factory.createIdentifier(name);
16432
+ const types = literal2 ? [checker.getTypeAtLocation(literal2)] : void 0;
16433
+ const key = `${siteTest}\0${name}\0${[...chain].sort().join("\0")}`;
16434
+ const cacheable = !except && !literal2;
16435
+ if (cacheable && writesSeen.has(key)) return writesSeen.get(key);
16436
+ const found = inj.writeTo(name, chain, {
16437
+ tests: siteTest,
16438
+ ...literal2 ? { file: fileIdOf2(literal2.getSourceFile()) ?? "" } : {},
16439
+ ...types ? { types, literal: literal2 } : {},
16440
+ ...except ? { except: (at) => at === except } : {}
16441
+ });
16442
+ if (cacheable) writesSeen.set(key, found);
16443
+ return found;
16444
+ };
16445
+ const memberWritten = (a, name) => {
16446
+ if (a.kind === "fn" || !a.shared) return false;
16447
+ if (!inj) return true;
16448
+ return a.kind === "instance" ? writeOf(name, new Set(upChain(a.cls).map(declKey))) !== null : writeOf(name, /* @__PURE__ */ new Set(), void 0, a.at) !== null;
16449
+ };
16450
+ const thisClass = (node2) => {
16451
+ let at = node2.parent;
16452
+ while (at && !ts.isSourceFile(at)) {
16453
+ if (ts.isFunctionLike(at) && !ts.isArrowFunction(at)) break;
16454
+ if (ts.isPropertyDeclaration(at) || ts.isClassStaticBlockDeclaration(at)) break;
16455
+ at = at.parent;
16456
+ }
16457
+ if (!at || ts.isSourceFile(at) || ts.isClassStaticBlockDeclaration(at)) return null;
16458
+ const ok = ts.isMethodDeclaration(at) || ts.isConstructorDeclaration(at) || ts.isGetAccessorDeclaration(at) || ts.isSetAccessorDeclaration(at) || ts.isPropertyDeclaration(at);
16459
+ if (!ok || !at.parent || !ts.isClassDeclaration(at.parent)) return null;
16460
+ if (ts.getCombinedModifierFlags(at) & ts.ModifierFlags.Static) return null;
16461
+ return classOf(at.parent.name ?? at.parent);
16462
+ };
16463
+ const declaresField = (node2, name) => {
16464
+ for (const m of node2.members) {
16465
+ if (ts.isConstructorDeclaration(m)) {
16466
+ const p = m.parameters.find(
16467
+ (x) => ts.isIdentifier(x.name) && x.name.text === name && ts.isParameterPropertyDeclaration(x, m)
16468
+ );
16469
+ if (p) return p;
16470
+ }
16471
+ if (keyOf2(m.name) !== name) continue;
16472
+ if (ts.getCombinedModifierFlags(m) & ts.ModifierFlags.Static) continue;
16473
+ return ts.isPropertyDeclaration(m) ? m : "other";
16474
+ }
16475
+ return null;
16476
+ };
16477
+ const usesThis = (n2) => {
16478
+ let found = false;
16479
+ const visit2 = (x) => {
16480
+ if (found) return;
16481
+ if (x !== n2 && (ts.isFunctionDeclaration(x) || ts.isFunctionExpression(x) || ts.isClassLike(x))) return;
16482
+ if (x.kind === ts.SyntaxKind.ThisKeyword || x.kind === ts.SyntaxKind.SuperKeyword) {
16483
+ const p = x.parent;
16484
+ if (x.kind === ts.SyntaxKind.SuperKeyword && ts.isCallExpression(p) && p.expression === x) return;
16485
+ const member = (ts.isPropertyAccessExpression(p) || ts.isElementAccessExpression(p)) && p.expression === x;
16486
+ const called = member && (ts.isCallExpression(p.parent) && p.parent.expression === p || ts.isTaggedTemplateExpression(p.parent) && p.parent.tag === p);
16487
+ if (!member || called) found = true;
16488
+ return;
16489
+ }
16490
+ ts.forEachChild(x, visit2);
16491
+ };
16492
+ visit2(n2);
16493
+ return found;
16494
+ };
16495
+ const fieldOf = (owner, name, exact, injected, depth, made) => {
16496
+ if (!inj || depth > DEPTH) return null;
16497
+ let declaring = null;
16498
+ let member = null;
16499
+ for (const at of upChain(owner)) {
16500
+ const node2 = classDecl(at);
16501
+ if (!node2) return null;
16502
+ const found = declaresField(node2, name);
16503
+ if (found === "other") return null;
16504
+ if (found) {
16505
+ declaring = { cls: at, node: node2 };
16506
+ member = found;
16507
+ break;
16508
+ }
16509
+ }
16510
+ if (!declaring || !member) return null;
16511
+ for (const c of upChain(declaring.cls).slice(1)) {
16512
+ const node2 = classDecl(c);
16513
+ if (!node2 || declaresField(node2, name) === "other") return null;
16514
+ }
16515
+ const holders = exact ? [owner] : [owner, ...inj.subclassesOf(owner)];
16516
+ for (const h of holders) {
16517
+ if (!isSoundClass(h, false)) return null;
16518
+ const node2 = h === owner ? null : classDecl(h);
16519
+ if (h !== owner && (!node2 || declaresField(node2, name) !== null)) return null;
16520
+ }
16521
+ for (const c of upChain(declaring.cls)) {
16522
+ const node2 = classDecl(c);
16523
+ if (!node2) return null;
16524
+ for (const m of node2.members) {
16525
+ const statik = ts.getCombinedModifierFlags(m) & ts.ModifierFlags.Static;
16526
+ if (ts.isConstructorDeclaration(m) && m.body && usesThis(m.body)) return null;
16527
+ if (ts.isPropertyDeclaration(m) && !statik && m.initializer && usesThis(m.initializer)) return null;
16528
+ }
16529
+ }
16530
+ const chain = new Set(holders.flatMap((h) => upChain(h)).map(declKey));
16531
+ const label = `${declaring.cls.name}.${name}`;
16532
+ const injectedValue = (sym) => {
16533
+ if (exact && !injected) return null;
16534
+ const source = sym ? inj.fromField(sym) : null;
16535
+ if (!source || "why" in source) return null;
16536
+ const provided = inj.providedFor(source.token);
16537
+ if ("why" in provided || !isSoundClass(provided.cls, false)) return null;
16538
+ note("injection", source.detail);
16539
+ note("provided", provided.detail);
16540
+ return [{ kind: "instance", cls: provided.cls, at: member, shared: true, injected: true }];
16541
+ };
16542
+ const passedValue = (p) => {
16543
+ if (injected) return null;
16544
+ const ctor = p.parent;
16545
+ if (exact && made) {
16546
+ for (const c of upChain(owner)) {
16547
+ if (declKey(c) === declKey(declaring.cls)) break;
16548
+ if (classDecl(c)?.members.some((m) => ts.isConstructorDeclaration(m) && !!m.body)) return null;
16549
+ }
16550
+ if (reassigned(p) || usesArguments(ctor)) return null;
16551
+ const index = argIndex(ctor, p);
16552
+ const args = made.arguments ?? [];
16553
+ if (args.slice(0, index + 1).some((x) => ts.isSpreadElement(x))) return null;
16554
+ const arg = args[index] ?? p.initializer;
16555
+ if (!arg) return [];
16556
+ const v = valueOf(arg, made, depth + 1, null);
16557
+ if (v) note("parameter", `${label} is what ${short(made)} passes: ${short(arg)} (${where(arg)})`);
16558
+ return v;
16559
+ }
16560
+ return exact ? null : paramValue(p, depth + 1);
16561
+ };
16562
+ let value;
16563
+ let defining;
16564
+ if (ts.isParameter(member)) {
16565
+ value = injectedValue(checker.getSymbolsOfParameterPropertyDeclaration(member, name)[1]) ?? (inj.diDecorator(declaring.node) ? null : passedValue(member));
16566
+ } else if (member.initializer) {
16567
+ const init = unwrap(member.initializer);
16568
+ const angular = ts.isCallExpression(init) ? importedAs(init.expression) : null;
16569
+ if (angular?.pkg === "@angular/core" && angular.name === "inject")
16570
+ value = injectedValue(checker.getSymbolAtLocation(member.name));
16571
+ else {
16572
+ value = valueOf(member.initializer, member, depth + 1, null);
16573
+ if (value) note("field", `${label} is ${short(member.initializer)} (${where(member.initializer)})`);
16574
+ }
16575
+ } else {
16576
+ const ctor = declaring.node.members.find(
16577
+ (m) => ts.isConstructorDeclaration(m) && !!m.body
16578
+ );
16579
+ const sets = (ctor?.body?.statements ?? []).flatMap((st) => {
16580
+ const e = ts.isExpressionStatement(st) ? st.expression : void 0;
16581
+ return e && ts.isBinaryExpression(e) && e.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(e.left) && e.left.expression.kind === ts.SyntaxKind.ThisKeyword && e.left.name.text === name ? [e] : [];
16582
+ });
16583
+ if (sets.length !== 1) return null;
16584
+ const set2 = sets[0];
16585
+ defining = set2.left;
16586
+ const right = unwrap(set2.right);
16587
+ const param = ts.isIdentifier(right) ? symbolOf(right)?.valueDeclaration : void 0;
16588
+ if (param && ts.isParameter(param))
16589
+ value = injectedValue(checker.getSymbolAtLocation(member.name)) ?? (inj.diDecorator(declaring.node) || param.parent !== ctor ? null : passedValue(param));
16590
+ else {
16591
+ value = valueOf(set2.right, ctor, depth + 1, null);
16592
+ if (value) note("field", `${label} is set to ${short(set2.right)} (${where(set2.right)})`);
16593
+ }
16594
+ }
16595
+ if (!value) return null;
16596
+ if (writeOf(name, chain, defining)) return null;
16597
+ flowed = true;
16598
+ return value.map(share);
16599
+ };
16600
+ const callers2 = makeCallers(s, {
16601
+ closedWorld: !!input2.closedWorld,
16602
+ importedFromOutside: input2.importedFromOutside ?? (() => false),
16603
+ where
16604
+ });
16605
+ const inParam = /* @__PURE__ */ new Set();
16606
+ const argIndex = (fn, p) => fn.parameters.filter((x) => !(ts.isIdentifier(x.name) && x.name.text === "this")).indexOf(p);
16607
+ const usesArguments = (fn) => {
16608
+ let found = false;
16609
+ const visit2 = (n2) => {
16610
+ if (found) return;
16611
+ if (n2 !== fn && ts.isFunctionLike(n2) && !ts.isArrowFunction(n2)) return;
16612
+ if (ts.isIdentifier(n2) && n2.text === "arguments") found = true;
16613
+ else ts.forEachChild(n2, visit2);
16614
+ };
16615
+ const body = fn.body;
16616
+ if (body) visit2(body);
16617
+ return found;
16618
+ };
16619
+ const paramSeen = /* @__PURE__ */ new Map();
16620
+ const reassigned = (p) => {
16621
+ const sym = checker.getSymbolAtLocation(p.name);
16622
+ const body = p.parent.body;
16623
+ let found = false;
16624
+ const visit2 = (n2) => {
16625
+ if (found) return;
16626
+ if (ts.isIdentifier(n2) && n2 !== p.name && checker.getSymbolAtLocation(n2) === sym && assignedHere(n2))
16627
+ found = true;
16628
+ else ts.forEachChild(n2, visit2);
16629
+ };
16630
+ if (body) visit2(body);
16631
+ return found;
16632
+ };
16633
+ const assignedHere = (n2) => {
16634
+ let at = n2;
16635
+ while (ts.isParenthesizedExpression(at.parent) || ts.isShorthandPropertyAssignment(at.parent) || ts.isPropertyAssignment(at.parent) && at.parent.initializer === at || ts.isObjectLiteralExpression(at.parent) || ts.isArrayLiteralExpression(at.parent) || ts.isSpreadElement(at.parent))
16636
+ at = at.parent;
16637
+ const parent = at.parent;
16638
+ if (ts.isBinaryExpression(parent))
16639
+ return parent.left === at && parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
16640
+ if (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent))
16641
+ return parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken;
16642
+ return (ts.isForOfStatement(parent) || ts.isForInStatement(parent)) && parent.initializer === at;
16643
+ };
16644
+ const paramValue = (p, depth) => {
16645
+ if (siteTest || depth > DEPTH || inParam.has(p) || !ts.isIdentifier(p.name) || p.dotDotDotToken)
16646
+ return null;
16647
+ const fn = p.parent;
16648
+ let callee = null;
16649
+ let label = "";
16650
+ if (ts.isFunctionDeclaration(fn) && fn.body && isFixedFunction(fn)) {
16651
+ callee = fn;
16652
+ label = fn.name?.text ?? "the default export";
16653
+ } else if ((ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) && ts.isVariableDeclaration(fn.parent) && fn.parent.initializer === fn && isConst(fn.parent) && ts.isIdentifier(fn.parent.name)) {
16654
+ callee = fn.parent;
16655
+ label = fn.parent.name.text;
16656
+ } else if (ts.isConstructorDeclaration(fn) && ts.isClassDeclaration(fn.parent) && fn.parent.name && ts.isSourceFile(fn.parent.parent) && !inj?.diDecorator(fn.parent)) {
16657
+ callee = fn.parent;
16658
+ label = `new ${fn.parent.name.text}`;
16659
+ }
16660
+ const hit = paramSeen.get(p);
16661
+ if (hit) {
16662
+ for (const n2 of hit.notes) note(n2.kind, n2.detail);
16663
+ if (hit.closed) closed = true;
16664
+ if (hit.value) flowed = true;
16665
+ return hit.value;
16666
+ }
16667
+ const outer = { notes, closed, flowed };
16668
+ notes = [];
16669
+ closed = false;
16670
+ const value = paramOnce(p, fn, callee, label, depth);
16671
+ const said = notes;
16672
+ paramSeen.set(p, { value, notes: said, closed });
16673
+ const used = closed;
16674
+ notes = outer.notes;
16675
+ closed = outer.closed || !!value && used;
16676
+ flowed = outer.flowed;
16677
+ for (const n2 of said) note(n2.kind, n2.detail);
16678
+ if (value) flowed = true;
16679
+ return value;
16680
+ };
16681
+ const paramOnce = (p, fn, callee, label, depth) => {
16682
+ if (!callee || reassigned(p) || usesArguments(fn)) return null;
16683
+ const found = callers2.callersOf(callee);
16684
+ if ("why" in found || found.calls.length > CALLS) return null;
16685
+ const index = argIndex(fn, p);
16686
+ inParam.add(p);
16687
+ try {
16688
+ const out2 = [];
16689
+ for (const { call, args } of found.calls) {
16690
+ if (args.slice(0, index + 1).some((a) => ts.isSpreadElement(a))) return null;
16691
+ const arg = args[index];
16692
+ const passed = arg && !(ts.isIdentifier(arg) && arg.text === "undefined") ? arg : p.initializer ?? null;
16693
+ if (!passed) continue;
16694
+ const v = valueOf(passed, call, depth + 1, null);
16695
+ if (!v) return null;
16696
+ out2.push(...v);
16697
+ }
16698
+ if (found.closedWorld) {
16699
+ closed = true;
16700
+ note(
16701
+ "closed-world",
16702
+ `${label} may be called from outside its module; the project is analyzed as a closed world (analysis.closedWorld), so the calls it has here are all there are`
16703
+ );
16704
+ }
16705
+ const first = found.calls[0];
16706
+ note(
16707
+ "parameter",
16708
+ `${p.name.text} is what ${label} is passed${first ? ` (${found.calls.length} call${found.calls.length === 1 ? "" : "s"}, as at ${where(first.call)})` : " (it is never called)"}: ${describe4(out2)}`
16709
+ );
16710
+ flowed = true;
16711
+ return out2.map(share);
16712
+ } finally {
16713
+ inParam.delete(p);
16714
+ }
16715
+ };
16716
+ const memberNode = (definer, name) => {
16717
+ for (const m of classDecl(definer)?.members ?? []) {
16718
+ if (keyOf2(m.name) !== name || ts.getCombinedModifierFlags(m) & ts.ModifierFlags.Static)
16719
+ continue;
16720
+ if (ts.isMethodDeclaration(m) && m.body) return m;
16721
+ if (ts.isPropertyDeclaration(m) && m.initializer) {
16722
+ const f = unwrap(m.initializer);
16723
+ if (ts.isArrowFunction(f) || ts.isFunctionExpression(f)) return f;
16724
+ }
16725
+ }
16726
+ return null;
16727
+ };
16728
+ const methodOf = (a, name, depth) => {
16729
+ if (a.kind === "fn" || memberWritten(a, name)) return null;
16730
+ if (a.kind === "instance") {
16731
+ const body = graph.bodyOf(a.cls, name);
16732
+ if (body === "none") return "none";
16733
+ if (typeof body === "string") return null;
16734
+ const node2 = memberNode(body.definer, name);
16735
+ return node2 ? { fn: node2, self: [a] } : null;
16736
+ }
16737
+ if (a.open) return null;
16738
+ const m = a.members.get(name);
16739
+ if (!m) return OBJECT_MEMBERS.has(name) ? null : "none";
16740
+ if (ts.isMethodDeclaration(m)) return m.body ? { fn: m, self: [a] } : null;
16741
+ const v = valueOf(m, a.at, depth + 1, null);
16742
+ const f = v?.length === 1 && v[0].kind === "fn" ? v[0].at : null;
16743
+ if (!f || !isFunctionNode(f)) return null;
16744
+ return { fn: f, self: ts.isArrowFunction(f) ? null : [a] };
16745
+ };
16746
+ const returnedBy = (call, awaited, depth, self2 = null) => {
16747
+ if (depth > DEPTH || ++work > WORK) return null;
16748
+ const f = calleeOf(call);
16749
+ if (f) return returnsOf(f, awaited, depth, null);
16750
+ const callee = unwrap(call.expression);
16751
+ if (!ts.isPropertyAccessExpression(callee)) return null;
16752
+ const recv = valueOf(callee.expression, call, depth, self2);
16753
+ if (!recv) return null;
16754
+ const out2 = [];
16755
+ for (const a of recv) {
16756
+ const m = methodOf(a, callee.name.text, depth);
16757
+ if (m === null) return null;
16758
+ if (m === "none") continue;
16759
+ const v = returnsOf(m.fn, awaited, depth, m.self);
16760
+ if (!v) return null;
16761
+ out2.push(...v);
16762
+ }
16763
+ flowed = true;
16764
+ note("returned", `${short(callee.expression)}.${callee.name.text}(\u2026) returns ${describe4(out2)}`);
16765
+ return out2;
16766
+ };
16767
+ const returnsOf = (f, awaited, depth, self2) => {
16768
+ if (f.asteriskToken || !f.body) return null;
16769
+ const isAsync2 = (ts.getCombinedModifierFlags(f) & ts.ModifierFlags.Async) !== 0;
16770
+ if (isAsync2 && !awaited) return null;
16771
+ const body = f.body;
16772
+ if (!ts.isBlock(body)) {
16773
+ const v = valueOf(body, f, depth, self2);
16774
+ return v && (!awaited || !thenable(v)) ? v : null;
16775
+ }
16776
+ const alts = [];
16777
+ let known = true;
16778
+ const visit2 = (node2) => {
16779
+ if (!known || node2 !== body && (ts.isFunctionLike(node2) || ts.isClassLike(node2))) return;
16780
+ if (ts.isReturnStatement(node2)) {
16781
+ if (!node2.expression) return;
16782
+ const v = valueOf(node2.expression, f, depth, self2);
16783
+ if (v === null) known = false;
16784
+ else alts.push(...v);
16785
+ return;
16786
+ }
16787
+ ts.forEachChild(node2, visit2);
16788
+ };
16789
+ visit2(body);
16790
+ return known && (!awaited || !thenable(alts)) ? alts : null;
16791
+ };
16792
+ const thenable = (alts) => alts.some(
16793
+ (a) => a.kind === "object" ? a.open || a.members.has("then") : a.kind === "instance" && graph.inherited(a.cls, "then", false) !== "none"
16794
+ );
16795
+ const valueOf = (expr, scope2, depth, self2 = null) => {
16796
+ if (depth > DEPTH || ++work > WORK) return null;
16797
+ const e = unwrap(expr);
16798
+ if (e.kind === ts.SyntaxKind.ThisKeyword) return self2;
16799
+ if (ts.isAwaitExpression(e)) {
16800
+ const inner = unwrap(e.expression);
16801
+ return ts.isCallExpression(inner) ? returnedBy(inner, true, depth + 1, self2) : valueOf(inner, scope2, depth, self2);
16802
+ }
16803
+ if (ts.isConditionalExpression(e)) {
16804
+ const a = valueOf(e.whenTrue, scope2, depth, self2);
16805
+ const b = a && valueOf(e.whenFalse, scope2, depth, self2);
16806
+ return a && b ? [...a, ...b] : null;
16807
+ }
16808
+ if (ts.isArrowFunction(e) || ts.isFunctionExpression(e)) {
16809
+ const fn = functionOf(e);
16810
+ return fn ? [{ kind: "fn", fn, at: e }] : null;
16811
+ }
16812
+ if (ts.isNewExpression(e)) {
16813
+ const cls = classOf(e.expression);
16814
+ if (!cls) return null;
16815
+ if (isSoundClass(cls)) return [{ kind: "instance", cls, at: e, shared: false }];
16816
+ return inj && isSoundClass(cls, false) ? [{ kind: "instance", cls, at: e, shared: true }] : null;
16817
+ }
16818
+ if (ts.isPropertyAccessExpression(e)) {
16819
+ const name = e.name.text;
16820
+ const recv = unwrap(e.expression);
16821
+ if (recv.kind === ts.SyntaxKind.ThisKeyword && !self2) {
16822
+ const owner = thisClass(recv);
16823
+ if (!owner || !inj || inj.thisBorrowed(recv, siteTest)) return null;
16824
+ return fieldOf(owner, name, false, false, depth + 1);
16825
+ }
16826
+ const base2 = valueOf(recv, scope2, depth + 1, self2);
16827
+ if (!base2) return null;
16828
+ const out2 = [];
16829
+ for (const a of base2) {
16830
+ if (a.kind === "instance") {
16831
+ const v = fieldOf(
16832
+ a.cls,
16833
+ name,
16834
+ true,
16835
+ !!a.injected,
16836
+ depth + 1,
16837
+ ts.isNewExpression(a.at) ? a.at : void 0
16838
+ );
16839
+ if (!v) return null;
16840
+ out2.push(...v);
16841
+ } else if (a.kind === "object") {
16842
+ if (a.open || memberWritten(a, name)) return null;
16843
+ const m = a.members.get(name);
16844
+ if (!m) {
16845
+ if (OBJECT_MEMBERS.has(name)) return null;
16846
+ continue;
16847
+ }
16848
+ const v = ts.isMethodDeclaration(m) ? (() => {
16849
+ const fn = functionOf(m);
16850
+ return fn ? [{ kind: "fn", fn, at: m }] : null;
16851
+ })() : valueOf(m, a.at, depth + 1, null);
16852
+ if (!v) return null;
16853
+ out2.push(...v.map(share));
16854
+ } else return null;
16855
+ }
16856
+ flowed = true;
16857
+ return out2;
16858
+ }
16859
+ if (ts.isObjectLiteralExpression(e)) {
16860
+ const members2 = /* @__PURE__ */ new Map();
16861
+ let isOpen = false;
16862
+ for (const p of e.properties) {
16863
+ const key = p.name && (ts.isIdentifier(p.name) || ts.isStringLiteralLike(p.name)) ? p.name.text : null;
16864
+ if (ts.isSpreadAssignment(p) || key === null || key === "__proto__") isOpen = true;
16865
+ else if (ts.isPropertyAssignment(p)) members2.set(key, p.initializer);
16866
+ else if (ts.isShorthandPropertyAssignment(p)) members2.set(key, p.name);
16867
+ else if (ts.isMethodDeclaration(p)) members2.set(key, p);
16868
+ else isOpen = true;
16869
+ if (!isOpen && !thisSafe(ts.isMethodDeclaration(p) ? p : ts.isPropertyAssignment(p) ? p.initializer : p.name))
16870
+ isOpen = true;
16871
+ }
16872
+ return [{ kind: "object", members: members2, open: isOpen, at: e }];
16873
+ }
16874
+ if (ts.isCallExpression(e)) {
16875
+ const from = importedAs(e.expression);
16876
+ if (from?.pkg === "react" && from.name === "useCallback" && e.arguments[0])
16877
+ return valueOf(e.arguments[0], scope2, depth, self2);
16878
+ if (from?.pkg === "react" && from.name === "useMemo" && e.arguments[0]) {
16879
+ const factory = unwrap(e.arguments[0]);
16880
+ if (!ts.isArrowFunction(factory) && !ts.isFunctionExpression(factory)) return null;
16881
+ if (!ts.isBlock(factory.body)) return valueOf(factory.body, factory, depth, self2);
16882
+ const ret = factory.body.statements.length === 1 ? factory.body.statements[0] : void 0;
16883
+ return ret && ts.isReturnStatement(ret) && ret.expression ? valueOf(ret.expression, factory, depth, self2) : null;
16884
+ }
16885
+ return returnedBy(e, false, depth + 1, self2);
16886
+ }
16887
+ if (ts.isIdentifier(e)) {
16888
+ const sym = ts.isShorthandPropertyAssignment(e.parent) && e.parent.name === e ? checker.getShorthandAssignmentValueSymbol(e.parent) : symbolOf(e);
16889
+ const d = sym?.valueDeclaration;
16890
+ if (!d || !fileIdOf2(d.getSourceFile())) return null;
16891
+ if (ts.isFunctionDeclaration(d)) {
16892
+ const fn = isFixedFunction(d) ? functionOf(d) : void 0;
16893
+ return fn ? [{ kind: "fn", fn, at: d }] : null;
16894
+ }
16895
+ if (ts.isParameter(d)) return paramValue(d, depth + 1);
16896
+ if (!isConst(d)) return null;
16897
+ const v = d;
16898
+ if (!v.initializer || !ts.isIdentifier(v.name)) return null;
16899
+ const init = unwrap(v.initializer);
16900
+ if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) return valueOf(init, scope2, depth + 1);
16901
+ const val = valueOf(init, scope2, depth + 1);
16902
+ if (!val || val.every((a) => a.kind === "fn")) return val;
16903
+ const where2 = ts.findAncestor(v, (n2) => isFunctionNode(n2) || ts.isSourceFile(n2));
16904
+ if (!where2) return null;
16905
+ if (!ts.isSourceFile(where2) && onlyRead(v.name, where2, e)) return val;
16906
+ if (ts.isSourceFile(where2) && exported(v)) return null;
16907
+ return inj ? val.map(share) : null;
16908
+ }
16909
+ return null;
16910
+ };
16911
+ const runs = (value, member, depth = 0) => {
16912
+ if (!value || depth > DEPTH) return null;
16913
+ const outFns = /* @__PURE__ */ new Map();
16914
+ for (const a of value) {
16915
+ if (member === null) {
16916
+ if (a.kind !== "fn") return null;
16917
+ outFns.set(a.fn.id, { fn: a.fn, at: a.at });
16918
+ continue;
16919
+ }
16920
+ if (memberWritten(a, member)) return null;
16921
+ if (a.kind === "instance") {
16922
+ const body = graph.bodyOf(a.cls, member);
16923
+ if (body === "none") continue;
16924
+ if (typeof body === "string") return null;
16925
+ outFns.set(body.fn.id, { fn: body.fn, at: a.at });
16926
+ } else if (a.kind === "object") {
16927
+ if (a.open) return null;
16928
+ const m = a.members.get(member);
16929
+ if (!m) {
16930
+ if (OBJECT_MEMBERS.has(member)) return null;
16931
+ continue;
16932
+ }
16933
+ const inner = ts.isMethodDeclaration(m) ? (() => {
16934
+ const fn = functionOf(m);
16935
+ return fn ? [{ fn, at: m }] : null;
16936
+ })() : runs(valueOf(m, a.at, depth), null, depth + 1);
16937
+ if (!inner) return null;
16938
+ for (const x of inner) outFns.set(x.fn.id, x);
16939
+ } else return null;
16940
+ }
16941
+ return [...outFns.values()];
16942
+ };
16943
+ const subjectOf = (call) => {
16944
+ const callee = unwrap(call.expression);
16945
+ let member = null;
16946
+ let target2 = callee;
16947
+ if (ts.isPropertyAccessExpression(callee)) {
16948
+ member = callee.name.text;
16949
+ target2 = unwrap(callee.expression);
16950
+ }
16951
+ const followed = () => ({
16952
+ value: valueOf(target2, call, 0, null),
16953
+ member,
16954
+ producer: null,
16955
+ binding: null,
16956
+ target: target2
16957
+ });
16958
+ if (ts.isAwaitExpression(target2) || ts.isCallExpression(target2)) {
16959
+ const awaited2 = ts.isAwaitExpression(target2);
16960
+ const c2 = unwrap(awaited2 ? target2.expression : target2);
16961
+ if (!ts.isCallExpression(c2)) return null;
16962
+ if (!calleeOf(c2)) return followed();
16963
+ return { value: returnedBy(c2, awaited2, 0), member, producer: c2, binding: null, target: target2 };
16964
+ }
16965
+ if (!ts.isIdentifier(target2)) return followed();
16966
+ const d = checker.getSymbolAtLocation(target2)?.valueDeclaration;
16967
+ if (!d) return null;
16968
+ let decl;
16969
+ let property = null;
16970
+ if (ts.isVariableDeclaration(d) && ts.isIdentifier(d.name)) decl = d;
16971
+ else if (ts.isBindingElement(d) && ts.isObjectBindingPattern(d.parent) && !d.initializer && !d.dotDotDotToken) {
16972
+ const key = d.propertyName ?? d.name;
16973
+ if (!ts.isIdentifier(key) && !ts.isStringLiteral(key)) return null;
16974
+ if (d.parent.elements.some((x) => x.dotDotDotToken)) return null;
16975
+ const keyOfBinding = (x) => {
16976
+ const k = x.propertyName ?? x.name;
16977
+ return ts.isIdentifier(k) || ts.isStringLiteral(k) ? k.text : null;
16978
+ };
16979
+ if (d.parent.elements.some((x) => x !== d && keyOfBinding(x) === key.text)) return null;
16980
+ property = key.text;
16981
+ decl = d.parent.parent;
16982
+ if (!ts.isVariableDeclaration(decl)) return null;
16983
+ }
16984
+ if (!decl) return property === null && ts.isParameter(d) ? followed() : null;
16985
+ if (!isConst(decl) || !decl.initializer) return null;
16986
+ const init = unwrap(decl.initializer);
16987
+ const awaited = ts.isAwaitExpression(init);
16988
+ const c = unwrap(awaited ? init.expression : init);
16989
+ if (!ts.isCallExpression(c) || !calleeOf(c)) return property === null ? followed() : null;
16990
+ const binding2 = target2.text;
16991
+ let value = returnedBy(c, awaited, 0);
16992
+ if (!value) return { value, member, producer: c, binding: binding2, target: target2 };
16993
+ if (property !== null) {
16994
+ const picked = [];
16995
+ for (const a of value) {
16996
+ if (a.kind !== "object" || a.open) return { value: null, member, producer: c, binding: binding2, target: target2 };
16997
+ const m = a.members.get(property);
16998
+ if (!m) {
16999
+ if (OBJECT_MEMBERS.has(property)) return { value: null, member, producer: c, binding: binding2, target: target2 };
17000
+ continue;
17001
+ }
17002
+ const v = ts.isMethodDeclaration(m) ? (() => {
17003
+ const fn = functionOf(m);
17004
+ return fn ? [{ kind: "fn", fn, at: m }] : null;
17005
+ })() : valueOf(m, a.at, 1);
17006
+ if (!v) return { value: null, member, producer: c, binding: binding2, target: target2 };
17007
+ picked.push(...v);
17008
+ }
17009
+ value = picked;
17010
+ if (member !== null && value.some((a) => a.kind !== "fn")) {
17011
+ const scope2 = ts.findAncestor(decl, (n2) => isFunctionNode(n2) || ts.isSourceFile(n2));
17012
+ const name = d.name;
17013
+ if (!scope2 || !ts.isIdentifier(name) || ts.isSourceFile(scope2) && exported(decl) || !onlyRead(name, scope2))
17014
+ value = inj ? value.map(share) : null;
17015
+ }
17016
+ } else if (member !== null && value.some((a) => a.kind !== "fn")) {
17017
+ const scope2 = ts.findAncestor(decl, (n2) => isFunctionNode(n2) || ts.isSourceFile(n2));
17018
+ if (!scope2 || ts.isSourceFile(scope2) && exported(decl) || !onlyRead(decl.name, scope2))
17019
+ value = inj ? value.map(share) : null;
17020
+ }
17021
+ return { value, member, producer: c, binding: binding2, target: target2 };
17022
+ };
17023
+ for (const r of open3) {
17024
+ const site = sites.get(r.site);
17025
+ if (!site || site.reason !== "dynamic-dispatch" && site.reason !== "imported-symbol") continue;
17026
+ const sf = s.sourceFile(site.file);
17027
+ if (!sf) continue;
17028
+ const call = callAt2(ts, sf, toUtf16(sf, site.evidence.span.start.offset), site.expression);
17029
+ if (!call) continue;
17030
+ notes = [];
17031
+ flowed = false;
17032
+ closed = false;
17033
+ work = 0;
17034
+ siteTest = isTestPath(pathOf9(site.file));
17035
+ const subject = subjectOf(call);
17036
+ if (!subject?.value) continue;
17037
+ const fns = runs(subject.value, subject.member);
17038
+ if (!fns || fns.length === 0 || fns.some((f) => f.fn.file === site.file)) continue;
17039
+ const what = subject.member ?? subject.binding ?? "its result";
17040
+ const stop = r.steps.findIndex((x) => OPEN_STEPS.has(x.kind));
17041
+ const prior = r.steps.slice(0, stop < 0 ? r.steps.length : stop);
17042
+ const producer = subject.producer;
17043
+ const producerName = producer?.expression.getText(sf);
17044
+ const how = producer ? [
17045
+ {
17046
+ kind: "returned",
17047
+ detail: subject.binding ? `${subject.binding} holds what ${producerName} returns (${where(producer)})` : `${producerName} is called here, and what it returns is followed`
17048
+ },
17049
+ ...notes
17050
+ ] : [
17051
+ ...notes,
17052
+ {
17053
+ kind: "value",
17054
+ detail: `${short(subject.target)} is ${describe4(subject.value)}, and nothing else`
17055
+ }
17056
+ ];
17057
+ const via = closed ? "closed-world" : flowed || !producer ? "flow" : "returned";
17058
+ const names = fns.map((f) => `${f.fn.qualifiedName} (${pathOf9(f.fn.file)})`);
17059
+ if (fns.length === 1) {
17060
+ const fn = fns[0].fn;
17061
+ out.resolutions.push({
17062
+ type: "SiteResolution",
17063
+ id: r.id,
17064
+ site: r.site,
17065
+ file: r.file,
17066
+ status: "linked",
17067
+ target: fn.id,
17068
+ externalPackage: null,
17069
+ via,
17070
+ importOutcome: null,
17071
+ steps: [...prior, ...how, { kind: "returned-value", detail: `${what} is ${names[0]}` }],
17072
+ evidence: r.evidence
17073
+ });
17074
+ out.edges.push({
17075
+ type: "CALLS_CROSS_FILE",
17076
+ id: ids.linkedCall(site.id),
17077
+ from: site.enclosingFn,
17078
+ to: fn.id,
17079
+ form: "plain",
17080
+ resolution: "static-exact",
17081
+ confidence: 1,
17082
+ evidence: site.evidence,
17083
+ via
17084
+ });
17085
+ continue;
17086
+ }
17087
+ const candidates = fns.flatMap((f) => {
17088
+ const basis = evidenceOf2(f.at);
17089
+ return basis ? [{ function: f.fn.id, basis }] : [];
17090
+ });
17091
+ if (candidates.length !== fns.length) continue;
17092
+ out.resolutions.push({
17093
+ type: "SiteResolution",
17094
+ id: r.id,
17095
+ site: r.site,
17096
+ file: r.file,
17097
+ status: "unresolved",
17098
+ target: null,
17099
+ externalPackage: null,
17100
+ importOutcome: null,
17101
+ steps: [
17102
+ ...prior,
17103
+ ...how,
17104
+ {
17105
+ kind: "candidates",
17106
+ detail: `${what} is one of ${fns.length} functions, and nothing else: ${names.join(", ")}`
17107
+ }
17108
+ ],
17109
+ candidates,
17110
+ evidence: r.evidence
17111
+ });
17112
+ }
17113
+ return out;
17114
+ }
17115
+ function callAt2(ts, sf, pos, expression) {
17116
+ let found;
17117
+ const visit2 = (node2) => {
17118
+ if (found || node2.end <= pos || node2.getStart(sf) > pos) return;
17119
+ if (ts.isCallExpression(node2) && node2.getStart(sf) === pos && node2.expression.getText(sf).replace(/\s+/g, "") === expression.replace(/\s+/g, "")) {
17120
+ found = node2;
17121
+ return;
17122
+ }
17123
+ ts.forEachChild(node2, visit2);
17124
+ };
17125
+ visit2(sf);
17126
+ return found;
17127
+ }
17128
+ var DEPTH, CALLS, WORK, PROTOTYPE_READERS, OPEN_STEPS, OBJECT_MEMBERS;
17129
+ var init_returns = __esm({
17130
+ "packages/stage2/src/returns.ts"() {
17131
+ "use strict";
17132
+ init_src();
17133
+ init_callers();
17134
+ init_typegraph();
17135
+ DEPTH = 8;
17136
+ CALLS = 64;
17137
+ WORK = 4e3;
17138
+ PROTOTYPE_READERS = /* @__PURE__ */ new Set([
17139
+ "getOwnPropertyNames",
17140
+ "getOwnPropertyDescriptors",
17141
+ "getOwnPropertyDescriptor",
17142
+ "getOwnPropertySymbols",
17143
+ "getPrototypeOf",
17144
+ "keys",
17145
+ "entries",
17146
+ "values",
17147
+ "hasOwn",
17148
+ "ownKeys",
17149
+ "has",
17150
+ "getMetadata",
17151
+ "getOwnMetadata",
17152
+ "getMetadataKeys",
17153
+ "getOwnMetadataKeys",
17154
+ "hasMetadata",
17155
+ "hasOwnMetadata"
17156
+ ]);
17157
+ OPEN_STEPS = /* @__PURE__ */ new Set([
17158
+ "type",
17159
+ "candidates",
17160
+ "untyped",
17161
+ "undeclared",
17162
+ "no-body",
17163
+ "bodies-unknown",
17164
+ "default",
17165
+ "injection",
17166
+ // Where linking stopped (#237): a member of what an import gives.
17167
+ "not-a-function",
17168
+ "instance-member",
17169
+ "written",
17170
+ "unknown-wrapper",
17171
+ "member",
17172
+ "computed"
17173
+ ]);
17174
+ OBJECT_MEMBERS = new Set(Object.getOwnPropertyNames(Object.prototype));
17175
+ }
17176
+ });
17177
+
17178
+ // packages/stage2/src/closed.ts
17179
+ function closedWorldResolutions(input2, graph, s, inj = null) {
17180
+ const out = { resolutions: [], edges: [] };
17181
+ if (!s?.checker || !s.program) return out;
17182
+ const { ts, checker, program, fileIdOf: fileIdOf2, toByte, toUtf16 } = s;
17183
+ const pathOf9 = (file2) => file2.slice(file2.indexOf(":") + 1);
17184
+ const open3 = input2.resolutions.filter(
17185
+ (r) => r.status === "unresolved" && r.importOutcome === null && (!!r.candidates?.length && r.exhaustive === false || !r.candidates?.length && r.steps.at(-1)?.kind === "bodies-unknown") && !isTestPath(pathOf9(r.file))
17186
+ );
17187
+ if (open3.length === 0) return out;
17188
+ const sites = new Map(input2.sites.map((x) => [x.id, x]));
17189
+ const where = (node2) => {
17190
+ const sf = node2.getSourceFile();
17191
+ const file2 = fileIdOf2(sf);
17192
+ return `${file2 ? pathOf9(file2) : sf.fileName}:${sf.getLineAndCharacterOfPosition(node2.getStart(sf)).line + 1}`;
17193
+ };
17194
+ const evidenceOf2 = (node2) => {
17195
+ const sf = node2.getSourceFile();
17196
+ const file2 = fileIdOf2(sf);
17197
+ if (!file2) return null;
17198
+ const pos = (p) => {
17199
+ const lc = sf.getLineAndCharacterOfPosition(p);
17200
+ return { line: lc.line + 1, column: lc.character + 1, offset: toByte(sf, p) };
17201
+ };
17202
+ return {
17203
+ file: file2,
17204
+ span: { start: pos(node2.getStart(sf)), end: pos(node2.end) },
17205
+ commit: input2.revisions.get(file2.slice(0, file2.indexOf(":"))) ?? ""
17206
+ };
17207
+ };
17208
+ const fnByEnd = /* @__PURE__ */ new Map();
17209
+ for (const fn of input2.functions) {
17210
+ const k = `${fn.file}\0${fn.evidence.span.end.offset}`;
17211
+ const list = fnByEnd.get(k);
17212
+ if (list) list.push(fn);
17213
+ else fnByEnd.set(k, [fn]);
17214
+ }
17215
+ const functionOf = (node2) => {
17216
+ const sf = node2.getSourceFile();
17217
+ const file2 = fileIdOf2(sf);
17218
+ if (!file2) return void 0;
17219
+ const start = toByte(sf, node2.getStart(sf));
17220
+ return (fnByEnd.get(`${file2}\0${toByte(sf, node2.end)}`) ?? []).filter((f) => f.evidence.span.start.offset >= start).sort((a, b) => a.evidence.span.start.offset - b.evidence.span.start.offset)[0];
17221
+ };
17222
+ const keyOf2 = (n2) => n2 && (ts.isIdentifier(n2) || ts.isStringLiteralLike(n2) || ts.isPrivateIdentifier(n2)) ? n2.text : null;
17223
+ let made;
17224
+ const scan = () => {
17225
+ if (made) return made;
17226
+ const m = { classes: [], literals: [], casts: [], guards: [], generic: [] };
17227
+ for (const sf of program.getSourceFiles()) {
17228
+ const file2 = fileIdOf2(sf);
17229
+ if (!file2 || isTestPath(pathOf9(file2))) continue;
17230
+ const visit2 = (node2) => {
17231
+ if (ts.isClassDeclaration(node2) || ts.isClassExpression(node2)) {
17232
+ const abstract = (ts.getCombinedModifierFlags(node2) & ts.ModifierFlags.Abstract) !== 0;
17233
+ const sym = node2.name ? checker.getSymbolAtLocation(node2.name) : checker.getTypeAtLocation(node2).getSymbol();
17234
+ const type = sym ? checker.getDeclaredTypeOfSymbol(sym) : void 0;
17235
+ const top = ts.isClassDeclaration(node2) && !!node2.name && ts.isSourceFile(node2.parent);
17236
+ const decl = top ? { file: file2, name: node2.name.text } : null;
17237
+ if (type && !abstract)
17238
+ m.classes.push({ decl: decl && graph.declared(decl) ? decl : null, node: node2, type, file: file2 });
17239
+ } else if (ts.isObjectLiteralExpression(node2)) m.literals.push({ node: node2, file: file2 });
17240
+ else if (ts.isAsExpression(node2) || ts.isTypeAssertionExpression(node2)) {
17241
+ const type = checker.getTypeFromTypeNode(node2.type);
17242
+ const enclosing = ts.findAncestor(
17243
+ node2.parent,
17244
+ (n2) => ts.isFunctionLike(n2) && (!!n2.typeParameters?.length || !!ts.findAncestor(n2.parent, (c) => ts.isClassLike(c) && !!c.typeParameters?.length))
17245
+ );
17246
+ if (type.flags & ts.TypeFlags.Instantiable) {
17247
+ const base2 = checker.getBaseConstraintOfType(type);
17248
+ const primitive = !!base2 && !(base2.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) && (base2.isUnion() ? base2.types : [base2]).every(
17249
+ (x) => !!(x.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.ESSymbolLike | ts.TypeFlags.VoidLike | ts.TypeFlags.Null))
17250
+ );
17251
+ if (enclosing && !primitive) m.generic.push({ at: node2, fn: enclosing, guard: false, file: file2 });
17252
+ } else if (!(type.flags & ts.TypeFlags.Never))
17253
+ m.casts.push({ at: node2, type, from: checker.getTypeAtLocation(node2.expression), file: file2 });
17254
+ } else if (ts.isTypePredicateNode(node2) && node2.type) {
17255
+ const type = checker.getTypeFromTypeNode(node2.type);
17256
+ if (type.flags & ts.TypeFlags.Instantiable) {
17257
+ if (node2.parent.typeParameters?.length)
17258
+ m.generic.push({ at: node2, fn: node2.parent, guard: true, file: file2 });
17259
+ } else if (!(type.flags & ts.TypeFlags.Never)) m.guards.push({ at: node2, type, file: file2 });
17260
+ }
17261
+ ts.forEachChild(node2, visit2);
17262
+ };
17263
+ visit2(sf);
17264
+ }
17265
+ return made = m;
17266
+ };
17267
+ const fits = (from, to) => from === to || checker.isTypeAssignableTo(from, to);
17268
+ const nearSeen = /* @__PURE__ */ new Map();
17269
+ const nearFiles = (file2) => {
17270
+ let hit = nearSeen.get(file2);
17271
+ if (!hit) {
17272
+ hit = program.getSourceFiles().filter((sf) => {
17273
+ const f = fileIdOf2(sf);
17274
+ return !!f && !isTestPath(pathOf9(f)) && (!input2.together || input2.together(f, file2));
17275
+ });
17276
+ nearSeen.set(file2, hit);
17277
+ }
17278
+ return hit;
17279
+ };
17280
+ const leaves = (e) => {
17281
+ while (ts.isParenthesizedExpression(e) || ts.isAsExpression(e) || ts.isTypeAssertionExpression(e) || ts.isNonNullExpression(e) || ts.isSatisfiesExpression(e))
17282
+ e = e.expression;
17283
+ if (ts.isConditionalExpression(e)) return [...leaves(e.whenTrue), ...leaves(e.whenFalse)];
17284
+ if (ts.isBinaryExpression(e) && [
17285
+ ts.SyntaxKind.QuestionQuestionToken,
17286
+ ts.SyntaxKind.BarBarToken,
17287
+ ts.SyntaxKind.AmpersandAmpersandToken
17288
+ ].includes(e.operatorToken.kind))
17289
+ return [...leaves(e.left), ...leaves(e.right)];
17290
+ return [e];
17291
+ };
17292
+ const rootedOutside = (e) => {
17293
+ let root = e;
17294
+ for (; ; ) {
17295
+ if (ts.isAwaitExpression(root) || ts.isParenthesizedExpression(root) || ts.isNonNullExpression(root))
17296
+ root = root.expression;
17297
+ else if (ts.isCallExpression(root) || ts.isNewExpression(root)) root = root.expression;
17298
+ else if (ts.isPropertyAccessExpression(root) || ts.isElementAccessExpression(root))
17299
+ root = root.expression;
17300
+ else break;
17301
+ }
17302
+ if (!ts.isIdentifier(root)) return false;
17303
+ const decls = checker.getSymbolAtLocation(root)?.declarations ?? [];
17304
+ return decls.every((d) => !fileIdOf2(d.getSourceFile()));
17305
+ };
17306
+ const madeOutside = (type) => {
17307
+ if (type.isUnionOrIntersection()) return type.types.some(madeOutside);
17308
+ const decls = type.getSymbol()?.declarations ?? [];
17309
+ return decls.length > 0 && decls.every((d) => !fileIdOf2(d.getSourceFile()));
17310
+ };
17311
+ const outsideSeen = /* @__PURE__ */ new Map();
17312
+ const outsideIn = (sf) => {
17313
+ const hit = outsideSeen.get(sf);
17314
+ if (hit) return hit;
17315
+ const out2 = [];
17316
+ const visit2 = (node2) => {
17317
+ const p = node2.parent;
17318
+ const e = node2;
17319
+ const placed = !!p && ts.isExpression(node2) && (ts.isCallExpression(p) && p.arguments.includes(e) || ts.isNewExpression(p) && !!p.arguments?.includes(e) || ts.isArrayLiteralExpression(p) && p.elements.includes(e) || ts.isReturnStatement(p) && p.expression === node2 || ts.isArrowFunction(p) && p.body === node2 || ts.isVariableDeclaration(p) && p.initializer === node2 || ts.isPropertyAssignment(p) && p.initializer === node2 || ts.isShorthandPropertyAssignment(p) || ts.isBinaryExpression(p) && p.right === node2 && p.operatorToken.kind === ts.SyntaxKind.EqualsToken);
17320
+ if (placed) {
17321
+ const expected = () => checker.getContextualType(e);
17322
+ for (const leaf of leaves(e)) {
17323
+ if (!(ts.isIdentifier(leaf) || ts.isPropertyAccessExpression(leaf) || ts.isElementAccessExpression(leaf) || ts.isCallExpression(leaf) || ts.isNewExpression(leaf) || ts.isAwaitExpression(leaf)))
17324
+ continue;
17325
+ const proxy = ts.isNewExpression(leaf) && ts.isIdentifier(leaf.expression) && leaf.expression.text === "Proxy";
17326
+ if (!proxy && !rootedOutside(leaf)) continue;
17327
+ const type = checker.getTypeAtLocation(leaf);
17328
+ if (!anyish(type) && (proxy || madeOutside(type) && type.flags & (ts.TypeFlags.Object | ts.TypeFlags.Intersection | ts.TypeFlags.Union))) {
17329
+ const want = expected();
17330
+ if (!want || !anyish(want)) out2.push({ at: leaf, type, expected: want });
17331
+ }
17332
+ }
17333
+ }
17334
+ ts.forEachChild(node2, visit2);
17335
+ };
17336
+ visit2(sf);
17337
+ outsideSeen.set(sf, out2);
17338
+ return out2;
17339
+ };
17340
+ const chainOf = (c) => {
17341
+ const out2 = [];
17342
+ for (let at = c; at && !out2.includes(declKey(at)); at = graph.parentOf.get(declKey(at))?.base)
17343
+ out2.push(declKey(at));
17344
+ return out2;
17345
+ };
17346
+ const callers2 = makeCallers(s, {
17347
+ closedWorld: true,
17348
+ importedFromOutside: input2.importedFromOutside,
17349
+ where: (n2) => where(n2)
17350
+ });
17351
+ const genericMakes = (g, t) => {
17352
+ const calls = genericCalls(g.fn);
17353
+ if (calls === null) return true;
17354
+ return calls.some((call) => {
17355
+ const sig = checker.getResolvedSignature(call);
17356
+ if (!sig) return true;
17357
+ const made2 = g.guard ? checker.getTypePredicateOfSignature(sig)?.type : sig.getReturnType();
17358
+ return !made2 || !anyish(made2) && fits(made2, t);
17359
+ });
17360
+ };
17361
+ const callsSeen = /* @__PURE__ */ new Map();
17362
+ const genericCalls = (fn) => {
17363
+ if (!fn) return null;
17364
+ const hit = callsSeen.get(fn);
17365
+ if (hit !== void 0) return hit;
17366
+ let out2 = null;
17367
+ const callee = ts.isFunctionDeclaration(fn) ? fn : (ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) && ts.isVariableDeclaration(fn.parent) ? fn.parent : null;
17368
+ if (callee) {
17369
+ const found = callers2.callersOf(callee);
17370
+ out2 = "why" in found ? null : found.calls.flatMap(({ call }) => ts.isCallExpression(call) ? [call] : []);
17371
+ } else if (ts.isMethodDeclaration(fn) && ts.isIdentifier(fn.name)) {
17372
+ out2 = [];
17373
+ for (const id of named(fn.name.text)) {
17374
+ if (id === fn.name) continue;
17375
+ const sym = checker.getSymbolAtLocation(id);
17376
+ const decl = sym?.declarations?.includes(fn);
17377
+ const parent = id.parent;
17378
+ const call = ts.isPropertyAccessExpression(parent) && parent.name === id && ts.isCallExpression(parent.parent) && parent.parent.expression === parent ? parent.parent : null;
17379
+ if (call) {
17380
+ if (checker.getResolvedSignature(call)?.declaration === fn) out2.push(call);
17381
+ } else if (decl) {
17382
+ out2 = null;
17383
+ break;
17384
+ }
17385
+ }
17386
+ }
17387
+ callsSeen.set(fn, out2);
17388
+ return out2;
17389
+ };
17390
+ let byText;
17391
+ const named = (name) => {
17392
+ if (!byText) {
17393
+ byText = /* @__PURE__ */ new Map();
17394
+ for (const sf of program.getSourceFiles()) {
17395
+ if (!fileIdOf2(sf)) continue;
17396
+ const visit2 = (n2) => {
17397
+ if (ts.isIdentifier(n2)) {
17398
+ const list = byText.get(n2.text);
17399
+ if (list) list.push(n2);
17400
+ else byText.set(n2.text, [n2]);
17401
+ }
17402
+ ts.forEachChild(n2, visit2);
17403
+ };
17404
+ visit2(sf);
17405
+ }
17406
+ }
17407
+ return byText.get(name) ?? [];
17408
+ };
17409
+ const anyish = (t) => !!(t.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown));
17410
+ const seen = /* @__PURE__ */ new Map();
17411
+ const runsOf = (t, member) => {
17412
+ const key = `${t.id}\0${member}`;
17413
+ const hit = seen.get(key);
17414
+ if (hit) return hit;
17415
+ const found = find2(t, member);
17416
+ seen.set(key, found);
17417
+ return found;
17418
+ };
17419
+ const find2 = (t, member) => {
17420
+ const name = checker.typeToString(t);
17421
+ const decl = t.getSymbol()?.declarations?.[0];
17422
+ const file2 = decl && fileIdOf2(decl.getSourceFile());
17423
+ if (!file2) return { why: `${name} isn't the project's` };
17424
+ if (input2.importedFromOutside(file2))
17425
+ return {
17426
+ why: `${pathOf9(file2)} is imported by a file whose code isn't typed here, which may make a ${name}`
17427
+ };
17428
+ const all2 = scan();
17429
+ const near = (f) => !input2.together || input2.together(f, file2);
17430
+ const m = {
17431
+ classes: all2.classes.filter((x) => near(x.file)),
17432
+ literals: all2.literals.filter((x) => near(x.file)).map((x) => x.node),
17433
+ casts: all2.casts.filter((x) => near(x.file)),
17434
+ guards: all2.guards.filter((x) => near(x.file)),
17435
+ generic: all2.generic.filter((x) => near(x.file)),
17436
+ outside: nearFiles(file2).flatMap(outsideIn)
17437
+ };
17438
+ const outsider = m.outside.find(
17439
+ (o) => o.type.getProperty(member) && fits(o.type, t) && (!o.expected || o.expected === t || fits(t, o.expected))
17440
+ );
17441
+ if (outsider)
17442
+ return {
17443
+ why: `a value the project doesn't make (${checker.typeToString(outsider.type)}) is used as a ${name} at ${where(outsider.at)}`
17444
+ };
17445
+ const instantiated = m.generic.find((g) => genericMakes(g, t));
17446
+ if (instantiated)
17447
+ return {
17448
+ why: `a generic ${instantiated.guard ? "type guard" : "cast"} at ${where(instantiated.at)} may make a ${name}`
17449
+ };
17450
+ const cast = m.casts.find(
17451
+ (c) => fits(c.type, t) && !anyish(c.type) && (anyish(c.from) || !fits(c.from, t))
17452
+ );
17453
+ if (cast) return { why: `a value is cast to ${name} at ${where(cast.at)}` };
17454
+ const guard = m.guards.find((g) => fits(g.type, t) && !anyish(g.type));
17455
+ if (guard) return { why: `a type guard says a value is ${name} at ${where(guard.at)}` };
17456
+ const runs = /* @__PURE__ */ new Map();
17457
+ for (const c of m.classes) {
17458
+ const generic = !!c.node.typeParameters?.length;
17459
+ if (!c.type.getProperty(member) || !generic && !fits(c.type, t)) continue;
17460
+ if (!c.decl)
17461
+ return { why: `a class that isn't declared at a file's top level fits ${name} (${where(c.node)})` };
17462
+ const body = graph.bodyOf(c.decl, member);
17463
+ if (body === "none") continue;
17464
+ if (typeof body === "string")
17465
+ return { why: `${c.decl.name} fits ${name}, and what it runs for ${member} can't be told` };
17466
+ const written2 = inj?.writeTo(member, new Set(chainOf(c.decl)));
17467
+ if (written2) return { why: `${member} of a ${c.decl.name} may be written at ${where(written2)}` };
17468
+ runs.set(body.fn.id, { fn: body.fn, basis: body.fn.evidence });
17469
+ }
17470
+ for (const lit of m.literals) {
17471
+ const p = lit.properties.find((x) => keyOf2(x.name) === member);
17472
+ const spread = lit.properties.some((x) => ts.isSpreadAssignment(x));
17473
+ if (!p && !spread) continue;
17474
+ const litType = checker.getTypeAtLocation(lit);
17475
+ const inGeneric = !!ts.findAncestor(
17476
+ lit,
17477
+ (n2) => ts.isFunctionLike(n2) && !!n2.typeParameters?.length
17478
+ );
17479
+ if (anyish(litType) || (!inGeneric || !p) && !fits(litType, t)) continue;
17480
+ if (spread || !p) return { why: `an object with a spread fits ${name} (${where(lit)})` };
17481
+ const v = ts.isPropertyAssignment(p) ? p.initializer : ts.isMethodDeclaration(p) ? p : void 0;
17482
+ const fnNode = v && (ts.isMethodDeclaration(v) || ts.isArrowFunction(v) || ts.isFunctionExpression(v)) ? v : void 0;
17483
+ const fn = fnNode && functionOf(fnNode);
17484
+ if (!fn)
17485
+ return {
17486
+ why: `an object of ${name}'s shape at ${where(lit)} has a ${member} that isn't a function written there`
17487
+ };
17488
+ const written2 = inj?.writeTo(member, /* @__PURE__ */ new Set(), {
17489
+ types: [litType],
17490
+ literal: lit,
17491
+ file: fileIdOf2(lit.getSourceFile()) ?? ""
17492
+ });
17493
+ if (written2)
17494
+ return { why: `${member} of an object of ${name}'s shape may be written at ${where(written2)}` };
17495
+ runs.set(fn.id, { fn, basis: evidenceOf2(fnNode) });
17496
+ }
17497
+ return [...runs.values()];
17498
+ };
17499
+ for (const r of open3) {
17500
+ const site = sites.get(r.site);
17501
+ if (!site || site.reason !== "dynamic-dispatch") continue;
17502
+ const sf = s.sourceFile(site.file);
17503
+ if (!sf) continue;
17504
+ const call = callAt3(ts, sf, toUtf16(sf, site.evidence.span.start.offset), site.expression);
17505
+ if (!call) continue;
17506
+ let callee = call.expression;
17507
+ while (ts.isParenthesizedExpression(callee) || ts.isNonNullExpression(callee)) callee = callee.expression;
17508
+ if (!ts.isPropertyAccessExpression(callee)) continue;
17509
+ const member = callee.name.text;
17510
+ const recv = checker.getTypeAtLocation(callee.expression);
17511
+ const parts = recv.isUnion() ? recv.types.filter((x) => !(x.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null))) : [recv];
17512
+ if (parts.length === 0 || parts.some((x) => anyish(x) || !(x.flags & ts.TypeFlags.Object))) continue;
17513
+ const runs = /* @__PURE__ */ new Map();
17514
+ let why = null;
17515
+ for (const part of parts) {
17516
+ const found = runsOf(part, member);
17517
+ if ("why" in found) {
17518
+ why = found.why;
17519
+ break;
17520
+ }
17521
+ for (const x of found) runs.set(x.fn.id, x);
17522
+ }
17523
+ const typeName = checker.typeToString(recv);
17524
+ if (why !== null) {
17525
+ out.resolutions.push({ ...r, steps: [...r.steps, { kind: "closed-world", detail: why }] });
17526
+ continue;
17527
+ }
17528
+ const fns = [...runs.values()];
17529
+ if (fns.length === 0 || fns.some((f) => f.fn.file === site.file)) continue;
17530
+ const names = fns.map((f) => `${f.fn.qualifiedName} (${pathOf9(f.fn.file)})`);
17531
+ const step = {
17532
+ kind: "closed-world",
17533
+ detail: `the project is analyzed as a closed world (analysis.closedWorld): the values of ${typeName} it makes run ${fns.length === 1 ? names[0] : `one of ${names.join(", ")}`}, and nothing else`
17534
+ };
17535
+ if (fns.length === 1) {
17536
+ const fn = fns[0].fn;
17537
+ out.resolutions.push({
17538
+ type: "SiteResolution",
17539
+ id: r.id,
17540
+ site: r.site,
17541
+ file: r.file,
17542
+ status: "linked",
17543
+ target: fn.id,
17544
+ externalPackage: null,
17545
+ via: "closed-world",
17546
+ importOutcome: null,
17547
+ steps: [...r.steps, step],
17548
+ evidence: r.evidence
17549
+ });
17550
+ out.edges.push({
17551
+ type: "CALLS_CROSS_FILE",
17552
+ id: ids.linkedCall(site.id),
17553
+ from: site.enclosingFn,
17554
+ to: fn.id,
17555
+ form: "plain",
17556
+ resolution: "static-exact",
17557
+ confidence: 1,
17558
+ evidence: site.evidence,
17559
+ via: "closed-world"
17560
+ });
17561
+ continue;
17562
+ }
17563
+ const candidates = fns.flatMap((f) => f.basis ? [{ function: f.fn.id, basis: f.basis }] : []);
17564
+ if (candidates.length !== fns.length) continue;
17565
+ const { exhaustive: _open, ...rest } = r;
17566
+ void _open;
17567
+ out.resolutions.push({ ...rest, steps: [...r.steps, step], candidates });
17568
+ continue;
17569
+ }
17570
+ return out;
17571
+ }
17572
+ function callAt3(ts, sf, pos, expression) {
17573
+ let found;
17574
+ const visit2 = (node2) => {
17575
+ if (found || node2.end <= pos || node2.getStart(sf) > pos) return;
17576
+ if (ts.isCallExpression(node2) && node2.getStart(sf) === pos && node2.expression.getText(sf).replace(/\s+/g, "") === expression.replace(/\s+/g, "")) {
17577
+ found = node2;
17578
+ return;
17579
+ }
17580
+ ts.forEachChild(node2, visit2);
17581
+ };
17582
+ visit2(sf);
17583
+ return found;
17584
+ }
17585
+ var init_closed = __esm({
17586
+ "packages/stage2/src/closed.ts"() {
17587
+ "use strict";
17588
+ init_src();
17589
+ init_callers();
17590
+ init_typegraph();
17591
+ }
17592
+ });
17593
+
14694
17594
  // packages/stage2/src/components.ts
14695
17595
  import { posix as posix4 } from "node:path";
14696
17596
  function linkComponents(input2) {
@@ -17830,7 +20730,7 @@ function typedResolutions(input2, graph, s) {
17830
20730
  };
17831
20731
  return { kind: "no-body" };
17832
20732
  };
17833
- const callAt = (sf, pos, expression) => {
20733
+ const callAt4 = (sf, pos, expression) => {
17834
20734
  let found;
17835
20735
  const visit2 = (node2) => {
17836
20736
  if (found || node2.end <= pos || node2.getStart(sf) > pos) return;
@@ -17888,7 +20788,7 @@ function typedResolutions(input2, graph, s) {
17888
20788
  for (const site of asked) {
17889
20789
  const sf = s.sourceFile(site.file);
17890
20790
  if (!sf) continue;
17891
- const call = callAt(sf, toUtf16(sf, site.evidence.span.start.offset), site.expression);
20791
+ const call = callAt4(sf, toUtf16(sf, site.evidence.span.start.offset), site.expression);
17892
20792
  if (!call) continue;
17893
20793
  const callee = call.expression;
17894
20794
  const isMember = ts.isPropertyAccessExpression(callee) || ts.isElementAccessExpression(callee);
@@ -18049,6 +20949,274 @@ var init_types = __esm({
18049
20949
  }
18050
20950
  });
18051
20951
 
20952
+ // packages/stage2/src/together.ts
20953
+ function makeTogether(plans, resolved, s = null) {
20954
+ const roots = new Map(
20955
+ plans.map((p) => [
20956
+ p.sourceId,
20957
+ p.manifests.map((m) => m.path).filter((path) => path === "package.json" || path.endsWith("/package.json")).map((path) => path.slice(0, path.length - "package.json".length)).sort((a, b) => b.length - a.length)
20958
+ ])
20959
+ );
20960
+ const packages = /* @__PURE__ */ new Map();
20961
+ const packageOf = (fileId) => {
20962
+ const hit = packages.get(fileId);
20963
+ if (hit) return hit;
20964
+ const p = findPackage(fileId);
20965
+ packages.set(fileId, p);
20966
+ return p;
20967
+ };
20968
+ const findPackage = (fileId) => {
20969
+ const at = fileId.indexOf(":");
20970
+ const source = fileId.slice(0, at);
20971
+ const path = fileId.slice(at + 1);
20972
+ const dir = (roots.get(source) ?? []).find((d) => path.startsWith(d)) ?? "";
20973
+ return `${source}:${dir}`;
20974
+ };
20975
+ const importers = /* @__PURE__ */ new Map();
20976
+ const imports = (from, to) => {
20977
+ if (from === to) return;
20978
+ const set2 = importers.get(to) ?? /* @__PURE__ */ new Set();
20979
+ set2.add(from);
20980
+ importers.set(to, set2);
20981
+ };
20982
+ for (const r of resolved) if (r.target.kind === "file") imports(r.statement.fileId, r.target.file.id);
20983
+ const names = /* @__PURE__ */ new Map();
20984
+ for (const p of plans)
20985
+ for (const m of p.manifests) {
20986
+ if (m.path !== "package.json" && !m.path.endsWith("/package.json")) continue;
20987
+ let name = "";
20988
+ try {
20989
+ name = String(JSON.parse(m.content).name ?? "");
20990
+ } catch {
20991
+ }
20992
+ names.set(`${p.sourceId}:${m.path.slice(0, m.path.length - "package.json".length)}`, name);
20993
+ }
20994
+ const allPackages = plans.flatMap(
20995
+ (p) => (roots.get(p.sourceId) ?? [""]).concat("").map((d) => `${p.sourceId}:${d}`)
20996
+ );
20997
+ const loads = [];
20998
+ const link2 = (fromFile, toPackage) => loads.push([fromFile, toPackage]);
20999
+ const prefixLoads = [];
21000
+ const aliases = aliasesOf(plans);
21001
+ const linkLoad = (file2, head) => {
21002
+ const from = file2;
21003
+ const source = file2.slice(0, file2.indexOf(":"));
21004
+ const folder = (prefix) => prefixLoads.push([from, `${source}:${prefix}`]);
21005
+ const anywhere = () => {
21006
+ for (const pkg of allPackages) link2(from, pkg);
21007
+ };
21008
+ if (head.startsWith(".")) {
21009
+ const dir = folderOf(file2, head);
21010
+ return dir === null ? anywhere() : folder(dir + head.slice(head.lastIndexOf("/") + 1));
21011
+ }
21012
+ if (head.startsWith("/")) return folder(head.slice(1));
21013
+ const alias = aliases.filter(([src, key]) => src === source && head.startsWith(key)).sort((a, b) => b[1].length - a[1].length)[0];
21014
+ if (alias) {
21015
+ const rest = head.slice(alias[1].length).replace(/^\//, "");
21016
+ return folder(`${alias[2]}/${rest}`.replace(/\/+/g, "/").replace(/^\//, ""));
21017
+ }
21018
+ const named = [...names].filter(
21019
+ ([pkg, name]) => pkg.startsWith(`${source}:`) && head !== "" && name.startsWith(head)
21020
+ );
21021
+ if (named.length) for (const [pkg] of named) link2(from, pkg);
21022
+ else for (const pkg of allPackages) if (pkg.startsWith(`${source}:`)) link2(from, pkg);
21023
+ };
21024
+ const declaredHere = (e) => {
21025
+ let root = e;
21026
+ while (s?.ts.isPropertyAccessExpression(root)) root = root.expression;
21027
+ const decls = s?.checker?.getSymbolAtLocation(root)?.declarations ?? [];
21028
+ return decls.some((d) => !!s?.fileIdOf(d.getSourceFile()));
21029
+ };
21030
+ if (s?.program) {
21031
+ const t = s.ts;
21032
+ const headOf = (arg) => {
21033
+ if (!arg) return null;
21034
+ if (t.isStringLiteralLike(arg)) return arg.text.replace(/[*?{[].*$/, "");
21035
+ if (t.isTemplateExpression(arg)) return arg.head.text;
21036
+ if (t.isBinaryExpression(arg) && arg.operatorToken.kind === t.SyntaxKind.PlusToken) {
21037
+ let left = arg;
21038
+ while (t.isBinaryExpression(left) && left.operatorToken.kind === t.SyntaxKind.PlusToken)
21039
+ left = left.left;
21040
+ if (t.isStringLiteralLike(left)) return left.text;
21041
+ if (t.isTemplateExpression(left)) return left.head.text;
21042
+ }
21043
+ return "";
21044
+ };
21045
+ for (const sf of s.program.getSourceFiles()) {
21046
+ const file2 = s.fileIdOf(sf);
21047
+ if (!file2) continue;
21048
+ const requirers = /* @__PURE__ */ new Set();
21049
+ const visit2 = (node2) => {
21050
+ if (t.isVariableDeclaration(node2) && node2.initializer && t.isCallExpression(node2.initializer)) {
21051
+ const c = node2.initializer.expression;
21052
+ const name = t.isIdentifier(c) ? c.text : t.isPropertyAccessExpression(c) ? c.name.text : "";
21053
+ const sym = name === "createRequire" ? s.checker?.getSymbolAtLocation(node2.name) : void 0;
21054
+ if (sym) requirers.add(sym);
21055
+ }
21056
+ if (t.isCallExpression(node2)) {
21057
+ const c = node2.expression;
21058
+ const text = c.getText(sf).replace(/\s+/g, "");
21059
+ const arg = node2.arguments[0];
21060
+ const loader = c.kind === t.SyntaxKind.ImportKeyword || // Node's `require`, not a function of the project's by that name (an AMD bundle's own).
21061
+ (text === "require" || text === "require.context") && !declaredHere(c) || text === "module.require" || text === "import.meta.glob" || text === "import.meta.globEager" || t.isIdentifier(c) && !!s.checker && requirers.has(s.checker.getSymbolAtLocation(c));
21062
+ const literal2 = arg && t.isStringLiteralLike(arg) && !/[*?{[]/.test(arg.text) && !text.startsWith("import.meta.glob") && text !== "require.context";
21063
+ if (loader && !literal2) {
21064
+ const head = headOf(arg);
21065
+ if (head !== null) linkLoad(file2, head);
21066
+ }
21067
+ }
21068
+ t.forEachChild(node2, visit2);
21069
+ };
21070
+ visit2(sf);
21071
+ }
21072
+ }
21073
+ if (loads.length || prefixLoads.length) {
21074
+ const byPackage = /* @__PURE__ */ new Map();
21075
+ for (const p of plans)
21076
+ for (const f of p.files) {
21077
+ const id = `${p.sourceId}:${f.path}`;
21078
+ const pkg = packageOf(id);
21079
+ const list = byPackage.get(pkg);
21080
+ if (list) list.push(id);
21081
+ else byPackage.set(pkg, [id]);
21082
+ }
21083
+ for (const [from, pkg] of loads) for (const f of byPackage.get(pkg) ?? []) imports(from, f);
21084
+ if (prefixLoads.length)
21085
+ for (const p of plans)
21086
+ for (const f of p.files) {
21087
+ const id = `${p.sourceId}:${f.path}`;
21088
+ for (const [from, prefix] of prefixLoads) if (id.startsWith(prefix)) imports(from, id);
21089
+ }
21090
+ }
21091
+ const ancestors2 = /* @__PURE__ */ new Map();
21092
+ const ancestorsOf = (p) => {
21093
+ const hit = ancestors2.get(p);
21094
+ if (hit) return hit;
21095
+ const out = /* @__PURE__ */ new Set([p]);
21096
+ const queue = [p];
21097
+ while (queue.length) {
21098
+ for (const up of importers.get(queue.shift()) ?? []) {
21099
+ if (out.has(up)) continue;
21100
+ out.add(up);
21101
+ queue.push(up);
21102
+ }
21103
+ }
21104
+ ancestors2.set(p, out);
21105
+ return out;
21106
+ };
21107
+ const pairs = /* @__PURE__ */ new Map();
21108
+ const scripts2 = /* @__PURE__ */ new Set();
21109
+ if (s?.program) {
21110
+ const t = s.ts;
21111
+ const globals = /* @__PURE__ */ new Set();
21112
+ for (const sf of s.program.getSourceFiles()) {
21113
+ const id = s.fileIdOf(sf);
21114
+ if (!id || t.isExternalModule(sf)) continue;
21115
+ scripts2.add(id);
21116
+ for (const st of sf.statements) {
21117
+ if ((t.isFunctionDeclaration(st) || t.isClassDeclaration(st)) && st.name) globals.add(st.name.text);
21118
+ if (t.isVariableStatement(st)) {
21119
+ for (const d of st.declarationList.declarations)
21120
+ if (t.isIdentifier(d.name)) globals.add(d.name.text);
21121
+ }
21122
+ }
21123
+ }
21124
+ if (globals.size)
21125
+ for (const sf of s.program.getSourceFiles()) {
21126
+ const id = s.fileIdOf(sf);
21127
+ if (!id || !t.isExternalModule(sf)) continue;
21128
+ let uses = false;
21129
+ const visit2 = (n2) => {
21130
+ if (uses) return;
21131
+ if (t.isIdentifier(n2) && globals.has(n2.text)) {
21132
+ const decls = s.checker?.getSymbolAtLocation(n2)?.declarations ?? [];
21133
+ if (decls.some((d) => !t.isExternalModule(d.getSourceFile()) && !!s.fileIdOf(d.getSourceFile())))
21134
+ uses = true;
21135
+ }
21136
+ if (!uses) t.forEachChild(n2, visit2);
21137
+ };
21138
+ visit2(sf);
21139
+ if (uses) scripts2.add(id);
21140
+ }
21141
+ }
21142
+ const sourceOf7 = (f) => f.slice(0, f.indexOf(":"));
21143
+ return (a, b) => {
21144
+ if (a === b) return true;
21145
+ if (scripts2.has(a) && scripts2.has(b) && sourceOf7(a) === sourceOf7(b)) return true;
21146
+ const key = `${a}\0${b}`;
21147
+ const hit = pairs.get(key);
21148
+ if (hit !== void 0) return hit;
21149
+ const [small, large] = [ancestorsOf(a), ancestorsOf(b)].sort((x, y) => x.size - y.size);
21150
+ let found = false;
21151
+ for (const f of small)
21152
+ if (large.has(f)) {
21153
+ found = true;
21154
+ break;
21155
+ }
21156
+ pairs.set(key, found);
21157
+ return found;
21158
+ };
21159
+ }
21160
+ function folderOf(fileId, head) {
21161
+ const path = fileId.slice(fileId.indexOf(":") + 1);
21162
+ const parts = path.split("/").slice(0, -1);
21163
+ const rel = head.split("/");
21164
+ rel.pop();
21165
+ for (const r of rel) {
21166
+ if (r === "..") {
21167
+ if (parts.length === 0) return null;
21168
+ parts.pop();
21169
+ } else if (r !== "." && r !== "") parts.push(r);
21170
+ }
21171
+ return parts.length ? `${parts.join("/")}/` : "";
21172
+ }
21173
+ function aliasesOf(plans) {
21174
+ const out = [];
21175
+ const dirOf = (path) => path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";
21176
+ const under = (dir, rel) => {
21177
+ const parts = dir ? dir.split("/") : [];
21178
+ for (const r of rel.split("/")) {
21179
+ if (r === "..") parts.pop();
21180
+ else if (r !== "." && r !== "") parts.push(r);
21181
+ }
21182
+ return parts.join("/");
21183
+ };
21184
+ for (const p of plans) {
21185
+ for (const m of p.manifests) {
21186
+ if (!/(^|\/)[tj]sconfig[^/]*\.json$/.test(m.path)) continue;
21187
+ let json2;
21188
+ try {
21189
+ json2 = JSON.parse(stripJsonc(m.content));
21190
+ } catch {
21191
+ continue;
21192
+ }
21193
+ const base2 = under(dirOf(m.path), json2?.compilerOptions?.baseUrl ?? ".");
21194
+ for (const [key, targets] of Object.entries(json2?.compilerOptions?.paths ?? {}))
21195
+ for (const target2 of targets ?? [])
21196
+ out.push([p.sourceId, key.replace(/\*$/, ""), under(base2, target2.replace(/\*.*$/, ""))]);
21197
+ }
21198
+ for (const f of p.files) {
21199
+ if (f.content === void 0) continue;
21200
+ const name = f.path.slice(f.path.lastIndexOf("/") + 1);
21201
+ if (/^(vite|webpack)\.config\.[cm]?[jt]s$/.test(name))
21202
+ for (const [key, folder] of parseAliases(f.content))
21203
+ out.push([p.sourceId, key, under(dirOf(f.path), folder)]);
21204
+ else if (/^svelte\.config\.[cm]?[jt]s$/.test(name)) {
21205
+ const block = /alias\s*:\s*\{([^}]*)\}/.exec(f.content)?.[1] ?? "";
21206
+ for (const m of block.matchAll(/['"]?([$@~\w/-]+)['"]?\s*:\s*['"]([^'"*]+)\/?\*?['"]/g))
21207
+ out.push([p.sourceId, m[1].replace(/\/\*$/, ""), under(dirOf(f.path), m[2].replace(/\/$/, ""))]);
21208
+ }
21209
+ }
21210
+ }
21211
+ return out;
21212
+ }
21213
+ var init_together = __esm({
21214
+ "packages/stage2/src/together.ts"() {
21215
+ "use strict";
21216
+ init_imports();
21217
+ }
21218
+ });
21219
+
18052
21220
  // packages/stage2/src/index.ts
18053
21221
  function scopeOf2(fact) {
18054
21222
  switch (fact.type) {
@@ -18183,6 +21351,64 @@ async function runStage2(ctx, options2 = {}) {
18183
21351
  );
18184
21352
  const typedIds = new Set(typed.resolutions.map((r) => r.id));
18185
21353
  linked.resolutions = linked.resolutions.filter((r) => !typedIds.has(r.id));
21354
+ const together = makeTogether(ctx.plans, resolved, program);
21355
+ const injection = makeInjection(graph, program, together);
21356
+ const injected = injectedResolutions(
21357
+ { sites: linkInput.sites, resolutions: [...narrowed, ...typed.resolutions] },
21358
+ graph,
21359
+ program,
21360
+ injection
21361
+ );
21362
+ const injectedById = new Map(injected.resolutions.map((r) => [r.id, r]));
21363
+ const settle2 = (list) => list.map((r) => injectedById.get(r.id) ?? r);
21364
+ let settledNarrowed = settle2(narrowed);
21365
+ typed.resolutions = settle2(typed.resolutions);
21366
+ const programFiles = new Set(
21367
+ (program?.program?.getSourceFiles() ?? []).flatMap((sf) => {
21368
+ const id = program.fileIdOf(sf);
21369
+ return id ? [id] : [];
21370
+ })
21371
+ );
21372
+ const importedOutside = new Set(
21373
+ resolved.flatMap(
21374
+ (r) => r.target.kind === "file" && !programFiles.has(r.statement.fileId) ? [r.target.file.id] : []
21375
+ )
21376
+ );
21377
+ const closedWorld = ctx.settings?.closedWorld === true;
21378
+ const returned = returnedResolutions(
21379
+ {
21380
+ functions: linkInput.functions,
21381
+ sites: linkInput.sites,
21382
+ resolutions: [...linked.resolutions, ...settledNarrowed, ...typed.resolutions],
21383
+ revisions: linkInput.revisions,
21384
+ closedWorld,
21385
+ importedFromOutside: (f) => importedOutside.has(f)
21386
+ },
21387
+ graph,
21388
+ program,
21389
+ injection
21390
+ );
21391
+ const returnedById = new Map(returned.resolutions.map((r) => [r.id, r]));
21392
+ const settleReturned = (list) => list.map((r) => returnedById.get(r.id) ?? r);
21393
+ linked.resolutions = settleReturned(linked.resolutions);
21394
+ settledNarrowed = settleReturned(settledNarrowed);
21395
+ typed.resolutions = settleReturned(typed.resolutions);
21396
+ const closedOut = closedWorld ? closedWorldResolutions(
21397
+ {
21398
+ functions: linkInput.functions,
21399
+ sites: linkInput.sites,
21400
+ resolutions: [...settledNarrowed, ...typed.resolutions],
21401
+ revisions: linkInput.revisions,
21402
+ importedFromOutside: (f) => importedOutside.has(f),
21403
+ together
21404
+ },
21405
+ graph,
21406
+ program,
21407
+ injection
21408
+ ) : { resolutions: [], edges: [] };
21409
+ const closedById = new Map(closedOut.resolutions.map((r) => [r.id, r]));
21410
+ settledNarrowed = settledNarrowed.map((r) => closedById.get(r.id) ?? r);
21411
+ typed.resolutions = typed.resolutions.map((r) => closedById.get(r.id) ?? r);
18186
21412
  await step(4, "naming where paths leave the project");
18187
21413
  const fnIds = new Set(linkInput.functions.map((f) => f.id));
18188
21414
  const named = exits(
@@ -18190,7 +21416,12 @@ async function runStage2(ctx, options2 = {}) {
18190
21416
  files,
18191
21417
  functions: linkInput.functions,
18192
21418
  sites: linkInput.sites,
18193
- resolutions: [...linked.resolutions, ...narrowed, ...typed.resolutions, ...components.resolutions],
21419
+ resolutions: [
21420
+ ...linked.resolutions,
21421
+ ...settledNarrowed,
21422
+ ...typed.resolutions,
21423
+ ...components.resolutions
21424
+ ],
18194
21425
  references: references.filter((r) => fnIds.has(r.to)),
18195
21426
  results,
18196
21427
  plans: ctx.plans,
@@ -18208,6 +21439,9 @@ async function runStage2(ctx, options2 = {}) {
18208
21439
  calls: [
18209
21440
  ...linked.edges,
18210
21441
  ...typed.edges,
21442
+ ...injected.edges,
21443
+ ...returned.edges,
21444
+ ...closedOut.edges,
18211
21445
  ...keptCalls,
18212
21446
  ...components.edges,
18213
21447
  ...view.facts("CALLS_CROSS_FILE").filter((e) => e.via === "template-link")
@@ -18232,6 +21466,9 @@ async function runStage2(ctx, options2 = {}) {
18232
21466
  ...kept,
18233
21467
  ...named.resolutions,
18234
21468
  ...typed.edges,
21469
+ ...injected.edges,
21470
+ ...returned.edges,
21471
+ ...closedOut.edges,
18235
21472
  ...linked.edges,
18236
21473
  ...components.edges,
18237
21474
  ...map2.groups,
@@ -18261,6 +21498,9 @@ var init_src8 = __esm({
18261
21498
  init_src4();
18262
21499
  init_imports();
18263
21500
  init_candidates();
21501
+ init_di();
21502
+ init_returns();
21503
+ init_closed();
18264
21504
  init_components();
18265
21505
  init_exits2();
18266
21506
  init_groups();
@@ -18269,6 +21509,7 @@ var init_src8 = __esm({
18269
21509
  init_program();
18270
21510
  init_types();
18271
21511
  init_typegraph();
21512
+ init_together();
18272
21513
  init_imports();
18273
21514
  init_link();
18274
21515
  init_candidates();
@@ -18282,7 +21523,7 @@ var init_src8 = __esm({
18282
21523
  symbolsScope = (fileId) => `${STAGE23}:symbols:${fileId}`;
18283
21524
  groupSource = (groupId) => groupId.split("|")[1];
18284
21525
  STEPS = 5;
18285
- STAGE2_VERSION = 1;
21526
+ STAGE2_VERSION = 5;
18286
21527
  stage2 = createStage2();
18287
21528
  }
18288
21529
  });
@@ -56099,12 +59340,19 @@ var init_server3 = __esm({
56099
59340
  call: (e, a, cwd) => e.browse(a, cwd)
56100
59341
  },
56101
59342
  project_settings: {
56102
- description: "The project's analysis settings: maxFileMB, the per-file size limit (default 10; files over it are not analyzed unless chosen). Pass maxFileMB (up to 64) to change it; it applies at the next run.",
56103
- input: { project, maxFileMB: external_exports.number().optional().describe("New size limit in MB") },
56104
- call: (e, a, cwd) => a.maxFileMB === void 0 ? e.projectSettings(a, cwd) : e.setProjectSettings(
59343
+ description: "The project's analysis settings: maxFileMB, the per-file size limit (default 10; files over it are not analyzed unless chosen), and closedWorld (default false: the analyzed code is the whole program, so the callers and classes seen are all there are; links settled by it say so). Pass maxFileMB (up to 64) or closedWorld to change them; they apply at the next run.",
59344
+ input: {
59345
+ project,
59346
+ maxFileMB: external_exports.number().optional().describe("New size limit in MB"),
59347
+ closedWorld: external_exports.boolean().optional().describe("Analyze the project as a closed world")
59348
+ },
59349
+ call: (e, a, cwd) => a.maxFileMB === void 0 && a.closedWorld === void 0 ? e.projectSettings(a, cwd) : e.setProjectSettings(
56105
59350
  {
56106
59351
  ...a.project !== void 0 ? { project: a.project } : {},
56107
- settings: { maxFileMB: a.maxFileMB }
59352
+ settings: {
59353
+ ...a.maxFileMB !== void 0 ? { maxFileMB: a.maxFileMB } : {},
59354
+ ...a.closedWorld !== void 0 ? { closedWorld: a.closedWorld } : {}
59355
+ }
56108
59356
  },
56109
59357
  cwd
56110
59358
  )
@@ -56274,6 +59522,11 @@ var init_server3 = __esm({
56274
59522
  input: { project, run, file: external_exports.string().describe("A file id") },
56275
59523
  call: (e, a, cwd) => resolveImports(e, a, cwd)
56276
59524
  },
59525
+ file_summary: {
59526
+ description: "What cross-file analysis added to a file (#353): its call sites by outcome reading the file on its own (Stage 1: within the file, leaving the project, open) and with Stage 2 (into other files, leaving the project, candidate sets, still open), which add up to the same total; and its imports (to files, to packages, unresolved). acrossFiles is null when Stage 2 didn't run.",
59527
+ input: { project, run, file: external_exports.string().describe("A file id") },
59528
+ call: (e, a, cwd) => fileSummary(e, a, cwd)
59529
+ },
56277
59530
  symbol_imports: {
56278
59531
  description: "What files import by name (#303): each imported binding (a name, a default, a namespace) with what it is where it is defined (a function, a class, interface, type or value, a whole module, a package's export; re-export chains followed, or why it doesn't resolve) and how the file uses it (calls, JSX, types, extends, re-exports, other reads). One file's, one source's or the project's; unused: true keeps only names the file never uses.",
56279
59532
  input: {
@@ -56366,7 +59619,7 @@ var init_server3 = __esm({
56366
59619
  call: (e, a, cwd) => listStartCandidates(e, a, cwd)
56367
59620
  },
56368
59621
  reach: {
56369
- description: "Reach (#306): from a function or a file, what paths continue to (forward) or come from (backward), across files, and where they stop. Follows calls, cross-file calls, references (a function handed on, called later), inline callbacks and candidate sets (trust 'candidate', drawn dashed: never a chosen edge). Returns the functions by depth with their files and groups, each edge with its kind and evidence, gaps (call sites that go nowhere known, with why), exits (calls leaving the project, by package or runtime and member) and, backward, the start candidates reached. Bounded by depth, functions and work; a hit budget is reported in truncated.",
59622
+ description: "Reach (#306): from a function or a file, what paths continue to (forward) or come from (backward), across files, and where they stop. Follows calls, cross-file calls, references (a function handed on, called later), inline callbacks and candidate sets (trust 'candidate', drawn dashed: never a chosen edge). Returns the functions by depth with their files and groups, each edge with its kind, the analysis that found it (stage: stage1, template-link or stage2) and evidence, gaps (call sites that go nowhere known, with why), exits (calls leaving the project, by package or runtime and member) and, backward, the start candidates reached. Bounded by depth, functions and work; a hit budget is reported in truncated.",
56370
59623
  input: {
56371
59624
  project,
56372
59625
  run,
@@ -98987,7 +102240,11 @@ async function createServer(engine, options2 = {}) {
98987
102240
  {
98988
102241
  schema: {
98989
102242
  params: projectParams,
98990
- body: { type: "object", additionalProperties: false, properties: { maxFileMB: { type: "number" } } }
102243
+ body: {
102244
+ type: "object",
102245
+ additionalProperties: false,
102246
+ properties: { maxFileMB: { type: "number" }, closedWorld: { type: "boolean" } }
102247
+ }
98991
102248
  }
98992
102249
  },
98993
102250
  async (req) => engine.setProjectSettings({ ...req.params, settings: req.body })
@@ -99257,6 +102514,21 @@ async function createServer(engine, options2 = {}) {
99257
102514
  },
99258
102515
  async (req) => resolveImports(engine, { ...req.params, file: req.query.file })
99259
102516
  );
102517
+ app.get(
102518
+ "/api/projects/:project/file-summary",
102519
+ {
102520
+ schema: {
102521
+ params: projectParams,
102522
+ querystring: {
102523
+ type: "object",
102524
+ additionalProperties: false,
102525
+ required: ["file"],
102526
+ properties: { file: str2 }
102527
+ }
102528
+ }
102529
+ },
102530
+ async (req) => fileSummary(engine, { ...req.params, file: req.query.file })
102531
+ );
99260
102532
  app.get(
99261
102533
  "/api/projects/:project/findings",
99262
102534
  {
@@ -99944,7 +103216,8 @@ Usage:
99944
103216
  veoflow config [get [<key>] | set <key> <value> | test] [--project <id>]
99945
103217
  model settings: model.baseUrl, model.name, model.apiKey
99946
103218
  ("set model.apiKey -" reads the key from stdin);
99947
- project settings: analysis.maxFileMB (size limit, default 10)
103219
+ project settings: analysis.maxFileMB (size limit, default 10),
103220
+ analysis.closedWorld (true: the analyzed code is the whole program)
99948
103221
  veoflow license show|add <file|->|refresh [--json]
99949
103222
  the license in force; install a license key (from a file,
99950
103223
  or "-" for stdin); check the installed one again (offline)
@@ -100941,12 +104214,31 @@ try: ${answer.suggestions.join(" \xB7 ")}`);
100941
104214
  }
100942
104215
  const [action = "get", key, value] = rest;
100943
104216
  if (key?.startsWith("analysis.") || action === "get" && projectArg && !key) {
100944
- if (key && key !== "analysis.maxFileMB")
100945
- throw new UsageError(`unknown key ${key} (analysis.maxFileMB)`);
104217
+ if (key && key !== "analysis.maxFileMB" && key !== "analysis.closedWorld")
104218
+ throw new UsageError(`unknown key ${key} (analysis.maxFileMB, analysis.closedWorld)`);
100946
104219
  const project2 = pickProject(engine, projectArg, io.cwd);
100947
104220
  if (action === "get") {
104221
+ const { settings } = engine.projectSettings({ project: project2 });
104222
+ if (key === "analysis.closedWorld") io.out(String(settings.closedWorld));
104223
+ else if (key) io.out(String(settings.maxFileMB));
104224
+ else
104225
+ io.out(
104226
+ `analysis.maxFileMB = ${settings.maxFileMB}
104227
+ analysis.closedWorld = ${settings.closedWorld}`
104228
+ );
104229
+ return 0;
104230
+ }
104231
+ if (action === "set" && key === "analysis.closedWorld") {
104232
+ if (value !== "true" && value !== "false")
104233
+ throw new UsageError(
104234
+ "usage: veoflow config set analysis.closedWorld true|false [--project <id>]"
104235
+ );
104236
+ const { settings } = engine.setProjectSettings({
104237
+ project: project2,
104238
+ settings: { closedWorld: value === "true" }
104239
+ });
100948
104240
  io.out(
100949
- `${key ? "" : "analysis.maxFileMB = "}${engine.projectSettings({ project: project2 }).settings.maxFileMB}`
104241
+ `analysis.closedWorld = ${settings.closedWorld} (project ${project2}; takes effect at the next run${settings.closedWorld ? ': links it settles say "closed world"' : ""})`
100950
104242
  );
100951
104243
  return 0;
100952
104244
  }
@@ -100963,7 +104255,7 @@ try: ${answer.suggestions.join(" \xB7 ")}`);
100963
104255
  return 0;
100964
104256
  }
100965
104257
  throw new UsageError(
100966
- "usage: veoflow config [get|set] analysis.maxFileMB [<value>] [--project <id>]"
104258
+ "usage: veoflow config [get|set] analysis.maxFileMB|analysis.closedWorld [<value>] [--project <id>]"
100967
104259
  );
100968
104260
  }
100969
104261
  const { loadSettings: loadSettings2, publicSettings: publicSettings2, saveSettings: saveSettings2, testConnection: testConnection2 } = await Promise.resolve().then(() => (init_src10(), src_exports3));