@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-powershell-analyzer-XRSNQERV.js

@@ -0,0 +1,2915 @@
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-powershell-analyzer.ts
+var AUTOMATIC_VARIABLES = /* @__PURE__ */ new Set([
+  "this",
+  "_",
+  "psitem",
+  "args",
+  "input",
+  "psscriptroot",
+  "pscommandpath",
+  // `psmodulepath` IS NOT IN THIS SET, and its absence is a measured correction: the
+  // automatic variable is `$env:PSModulePath`, which the scope-prefix guard already keeps
+  // out of the declaration space, while `$PSModulePath` is not on
+  // about_Automatic_Variables at all. The list carried the bare spelling, so
+  // `ConsoleHost.Tests.ps1:403`'s `$psModulePath = & $powershell …` — a real local — declared
+  // nothing and every read of it was suppressed. Two rows over the whole admitted
+  // population, both real declarations.
+  "psversiontable",
+  "host",
+  "pid",
+  "lastexitcode",
+  "error",
+  "home",
+  "pwd",
+  "myinvocation",
+  "matches",
+  "null",
+  "true",
+  "false",
+  "ofs",
+  "shellid",
+  "stacktrace",
+  "executioncontext",
+  "psculture",
+  "psuiculture",
+  "psdebugcontext",
+  "psedition",
+  "iscoreclr",
+  "islinux",
+  "ismacos",
+  "iswindows",
+  "consolefilename",
+  "consoleverbosity",
+  "enabledexperimentalfeatures",
+  "errorview",
+  "maximumhistorycount",
+  "nestedpromptlevel",
+  "outputencoding",
+  // M60 #278 / ontology review 2026-10-27: `$PSHOME` and `$PROFILE` are on the SAME
+  // documented page (about_Automatic_Variables) as `$PWD` and `$SHELLID`, which this
+  // list already carries — and they were missing. `& "$PSHOME/pwsh"` therefore
+  // published `uses -> PSHOME` for an engine binding while `$PID` in the same file
+  // was suppressed, and F5 scored the row as an unexplained read against an oracle
+  // that had correctly refused it. The set is the documentation's, so the fix is to
+  // finish reading it rather than to invent a rule: these are bindings the engine
+  // supplies, not names the file declares or reads from program data.
+  "pshome",
+  "profile",
+  // The call-site family: `$PSCmdlet` is the cmdlet instance, `$PSBoundParameters`
+  // its bound arguments, and the invocation-info/event members are all documented on
+  // about_Automatic_Variables beside the ones above. Measured on OutErrorVariable.
+  // Tests.ps1: `$PSCmdlet.writeobject("foo")` published `uses -> PSCmdlet` — an
+  // engine binding read as program data — on three lines, after the pipeline-read
+  // case started reading `$PSCmdlet.Member(...)` receivers.
+  "pscmdlet",
+  "psboundparameters",
+  "pscommandline",
+  "pscmdletbindingmetadata",
+  "senderinfo",
+  "event",
+  "eventargs",
+  "eventsubscriber",
+  "sourceeventargs",
+  "sender",
+  "invocationinfo",
+  "psinvocationinfo",
+  "scriptstacktrace"
+]);
+var FLOW_KEYWORDS = /* @__PURE__ */ new Set([
+  "break",
+  "continue",
+  "return",
+  "exit",
+  "throw",
+  "else",
+  "elseif",
+  "finally",
+  "trap",
+  "try",
+  "catch",
+  "in",
+  "notin",
+  "as",
+  "is",
+  "and",
+  "or",
+  "xor",
+  "not",
+  "band",
+  "bor",
+  "bxor",
+  "bnot",
+  "shl",
+  "shr",
+  "eq",
+  "ne",
+  "gt",
+  "ge",
+  "lt",
+  "le",
+  "like",
+  "notlike",
+  "match",
+  "notmatch",
+  "contains",
+  "notcontains",
+  "replace",
+  "split",
+  "join",
+  "f",
+  "r",
+  // A class member's accessor keyword: `set { … }` is not a cmdlet.
+  "get",
+  "set"
+]);
+var isSpaceCode = (code) => code === 32 || code >= 9 && code <= 13 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288 || code === 65279;
+var isAsciiLetter = (c) => {
+  if (c === void 0) return false;
+  const code = c.charCodeAt(0);
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+};
+var isPlausibleSymbolName = (name) => {
+  if (name.length === 0) return false;
+  for (let i = 0; i < name.length; i++) {
+    const c = name.charCodeAt(i);
+    const ok = c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95 || c === 46 || c === 58 || c === 45;
+    if (!ok) return false;
+  }
+  return true;
+};
+var isNewSpelling = (name) => {
+  if (name.length !== 3) return false;
+  return (name.charCodeAt(0) | 32) === 110 && (name.charCodeAt(1) | 32) === 101 && (name.charCodeAt(2) | 32) === 119;
+};
+var stripLeadingDash = (text) => text.length > 0 && text.charCodeAt(0) === 45 ? text.slice(1) : text;
+var stripTypeSuffixBrackets = (text) => {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text.charCodeAt(i) === 91) {
+      let j = i + 1;
+      while (j < text.length && isSpaceCode(text.charCodeAt(j))) j++;
+      if (j < text.length && text.charCodeAt(j) === 93) {
+        i = j + 1;
+        continue;
+      }
+    }
+    out += text[i];
+    i++;
+  }
+  return out;
+};
+var hasTrailingExtension = (text) => {
+  const dot = text.lastIndexOf(".");
+  if (dot < 0 || dot === text.length - 1) return false;
+  for (let i = dot + 1; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    const alnum = c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122;
+    if (!alnum) return false;
+  }
+  return true;
+};
+var sourcedPartName = (target) => {
+  const normalized = target.split("\\").join("/");
+  const base = normalized.slice(normalized.lastIndexOf("/") + 1);
+  if (base.length === 0) return null;
+  return isPlausibleSymbolName(base) ? base : null;
+};
+var stripOpenCommentDelim = (line) => {
+  let i = 0;
+  while (i < line.length && isSpaceCode(line.charCodeAt(i))) i++;
+  if (line.charCodeAt(i) === 60 && line.charCodeAt(i + 1) === 35) return line.slice(i + 2);
+  return line;
+};
+var stripCloseCommentDelim = (line) => {
+  let end = line.length;
+  while (end > 0 && isSpaceCode(line.charCodeAt(end - 1))) end--;
+  if (end >= 2 && line.charCodeAt(end - 1) === 62 && line.charCodeAt(end - 2) === 35) {
+    return line.slice(0, end - 2);
+  }
+  return line;
+};
+var stripCommentMarkerRun = (text) => {
+  let i = 0;
+  while (i < text.length && text.charCodeAt(i) === 35) i++;
+  if (i > 0 && i < text.length && isSpaceCode(text.charCodeAt(i))) i++;
+  return text.slice(i);
+};
+var NAMED_BLOCK_KEYWORDS = /* @__PURE__ */ new Set(["begin", "process", "end", "clean", "dynamicparam"]);
+var LANGUAGE_KEYWORD_COMMANDS = /* @__PURE__ */ new Set([
+  "inlinescript",
+  "parallel",
+  "sequence",
+  "workflow",
+  "param",
+  "function",
+  "class",
+  "enum",
+  "filter",
+  "data",
+  "default",
+  "hidden",
+  "static",
+  "type",
+  "namespace",
+  "module",
+  "export"
+]);
+var DSC_KEYWORDS = /* @__PURE__ */ new Set(["configuration", "node"]);
+var SWITCH_ARGUMENT_VALUES = /* @__PURE__ */ new Set([
+  "stop",
+  "silentlycontinue",
+  "continue",
+  "inquire",
+  "yes",
+  "no",
+  "none",
+  "ignore",
+  "true",
+  "false",
+  "0",
+  "1",
+  "pass",
+  "fail"
+]);
+var IMPORT_MODULE_MODULE_PARAMETERS = /* @__PURE__ */ new Set(["name", "assembly"]);
+var QUALIFIED_PREFIXES = ["$global:", "$script:", "$env:", "$using:", "$local:", "$private:", "$variable:"];
+var carriesQualifierByte = (t) => {
+  for (let i = 0; i < t.length; i++) {
+    const c = t.charCodeAt(i);
+    if (c === 46 || c === 92 || c === 47 || c === 58) return true;
+  }
+  return false;
+};
+var FILE_DEFINABLE_SCOPE_PREFIXES = ["global", "script", "local", "private", "function"];
+var hasScopePrefix = (t, prefixes) => {
+  for (const p of prefixes) {
+    if (t.length <= p.length + 1) continue;
+    if (t.charCodeAt(p.length) !== 58) continue;
+    let eq = true;
+    for (let i = 0; i < p.length; i++) {
+      let c = t.charCodeAt(i);
+      if (c >= 65 && c <= 90) c += 32;
+      if (c !== p.charCodeAt(i)) {
+        eq = false;
+        break;
+      }
+    }
+    if (eq) return true;
+  }
+  return false;
+};
+var hasFileDefinableScopePrefix = (t) => hasScopePrefix(t, FILE_DEFINABLE_SCOPE_PREFIXES);
+var definableScopeOf = (name) => {
+  for (const p of FILE_DEFINABLE_SCOPE_PREFIXES) {
+    if (name.length <= p.length + 1) continue;
+    if (name.charCodeAt(p.length) !== 58) continue;
+    let eq = true;
+    for (let i = 0; i < p.length; i++) {
+      let c = name.charCodeAt(i);
+      if (c >= 65 && c <= 90) c += 32;
+      if (c !== p.charCodeAt(i)) {
+        eq = false;
+        break;
+      }
+    }
+    if (!eq) continue;
+    const bare = name.slice(p.length + 1);
+    if (bare.length === 0) return null;
+    return { scope: p, bare };
+  }
+  return null;
+};
+var isAsciiUpper = (c) => c >= 65 && c <= 90;
+var isRelativeProjectFilePath = (t) => {
+  const n = t.length;
+  if (n < 4) return false;
+  const isPs = (i) => {
+    const c = t.charCodeAt(i);
+    return c === 112 || c === 80;
+  };
+  const isS = (i) => {
+    const c = t.charCodeAt(i);
+    return c === 115 || c === 83;
+  };
+  const isDot = (i) => t.charCodeAt(i) === 46;
+  const isOne = (i) => t.charCodeAt(i) === 49;
+  let endsAdmitted = isDot(n - 4) && isPs(n - 3) && isS(n - 2) && isOne(n - 1);
+  if (!endsAdmitted && n >= 5 && isDot(n - 5) && isPs(n - 4) && isS(n - 3) && isOne(n - 1)) {
+    const c = t.charCodeAt(n - 2);
+    endsAdmitted = c === 109 || c === 77 || c === 100 || c === 68;
+  }
+  if (!endsAdmitted) {
+    const dot = t.lastIndexOf(".");
+    if (dot > 0 && dot < t.length - 1) {
+      let ext = "";
+      for (let i = dot + 1; i < t.length; i++) {
+        const c = t.charCodeAt(i);
+        if (c >= 65 && c <= 90) {
+          ext += String.fromCharCode(c + 32);
+          continue;
+        }
+        if (c >= 97 && c <= 122) {
+          ext += String.fromCharCode(c);
+          continue;
+        }
+        ext = "";
+        break;
+      }
+      if (ext.length > 0 && (PROGRAM_EXTENSIONS.has(ext) || ext === "dll" || ext === "nupkg" || ext === "zip")) {
+        endsAdmitted = true;
+      }
+    }
+  }
+  if (!endsAdmitted) return false;
+  if (t.charCodeAt(0) === 47) return false;
+  if (t.charCodeAt(0) === 92) return false;
+  const colon = t.indexOf(":");
+  if (colon > 0) {
+    if (colon === 1) return false;
+    for (let i = 0; i < colon; i++) {
+      const c = t.charCodeAt(i);
+      const legal = c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 43 || c === 45 || c === 46;
+      if (!legal) return true;
+    }
+    return false;
+  }
+  return true;
+};
+var runtimeVariableTarget = (t) => {
+  if (t.length < 2) return null;
+  if (t.charCodeAt(0) !== 36) return null;
+  let i = 1;
+  while (i < t.length) {
+    const c = t.charCodeAt(i);
+    const isWord = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95;
+    if (!isWord) break;
+    i++;
+  }
+  if (i === 1) return null;
+  const name = t.slice(1, i);
+  const sep = t.charCodeAt(i);
+  if (sep === 58) return { name, isPath: false };
+  if (sep === 47 || sep === 92) return { name, isPath: true };
+  return null;
+};
+var PROGRAM_EXTENSIONS = /* @__PURE__ */ new Set(["exe", "cmd", "bat", "com", "msi"]);
+var programNameOf = (t) => {
+  for (let i = 0; i < t.length; i++) {
+    const c = t.charCodeAt(i);
+    if (c === 47 || c === 92 || c === 36) return null;
+  }
+  const dot = t.lastIndexOf(".");
+  if (dot <= 0 || dot === t.length - 1) return null;
+  const ext = t.slice(dot + 1).toLowerCase();
+  return PROGRAM_EXTENSIONS.has(ext) ? t : null;
+};
+var isWordCode = (code) => code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95 || code === 46;
+var addTypeNamesIn = (text, roots, types) => {
+  const keywords = ["namespace", "class", "struct", "interface", "enum"];
+  let currentNamespace = "";
+  for (let i = 0; i < text.length; i++) {
+    for (const kw of keywords) {
+      if (i + kw.length > text.length) continue;
+      let ok = true;
+      for (let j = 0; j < kw.length; j++) {
+        if ((text.charCodeAt(i + j) | 32) !== kw.charCodeAt(j)) {
+          ok = false;
+          break;
+        }
+      }
+      if (!ok) continue;
+      if (i > 0 && isWordCode(text.charCodeAt(i - 1))) continue;
+      let k = i + kw.length;
+      if (k < text.length && isWordCode(text.charCodeAt(k))) continue;
+      while (k < text.length && isSpaceCode(text.charCodeAt(k))) k++;
+      const start = k;
+      while (k < text.length && isWordCode(text.charCodeAt(k))) k++;
+      if (k === start) continue;
+      const name = text.slice(start, k);
+      const dot = name.indexOf(".");
+      roots.add((dot > 0 ? name.slice(0, dot) : name).toLowerCase());
+      if (kw === "namespace") currentNamespace = name;
+      else if (types !== null && currentNamespace.length > 0) {
+        types.set(`${currentNamespace}.${name}`.toLowerCase(), `${currentNamespace}.${name}`);
+      }
+      i = k - 1;
+      break;
+    }
+  }
+};
+var externalReadingOf = (t) => {
+  if (t.charCodeAt(0) === 34 || t.charCodeAt(0) === 39) return null;
+  if (isRelativeProjectFilePath(t)) return null;
+  for (let i = 1; i < t.length; i++) {
+    if (t.charCodeAt(i) !== 45) continue;
+    if (isAsciiUpper(t.charCodeAt(0)) && isAsciiUpper(t.charCodeAt(i + 1))) return "cmdlet";
+  }
+  if (!carriesQualifierByte(t)) return null;
+  if (hasFileDefinableScopePrefix(t)) return null;
+  return "qualified";
+};
+var arbiterOwnerOf = (t) => {
+  const dot = t.lastIndexOf(".");
+  if (dot <= 0) return null;
+  return t.slice(0, dot);
+};
+var arbiterCanCheckOwner = (t) => {
+  const owner = arbiterOwnerOf(t);
+  if (owner === null) return true;
+  for (let i = 0; i < owner.length; i++) {
+    if (owner.charCodeAt(i) === 46) return true;
+  }
+  for (let i = 0; i < owner.length; i++) {
+    const c = owner.charCodeAt(i);
+    if (c === 58 || c === 47 || c === 32 || c === 9 || c === 10 || c === 13) return true;
+  }
+  return false;
+};
+var DOTNET_SYSTEM_NAMESPACES = /* @__PURE__ */ new Set([
+  "accessibility",
+  "buffers",
+  "codedom",
+  "collections",
+  "componentmodel",
+  "configuration",
+  "data",
+  "deployment",
+  "diagnostics",
+  "directoryservices",
+  "drawing",
+  "dynamic",
+  "formats",
+  "globalization",
+  "io",
+  "linq",
+  "management",
+  "media",
+  "net",
+  "numerics",
+  "printing",
+  "reflection",
+  "resources",
+  "runtime",
+  "security",
+  "servicemodel",
+  "serviceprocess",
+  "text",
+  "threading",
+  "transactions",
+  "web",
+  "windows",
+  "xml"
+]);
+var FRAMEWORK_NESTED_NAMESPACES = /* @__PURE__ */ new Set([
+  "system.management.automation.language",
+  "system.management.automation.runspaces",
+  "system.management.automation.provider",
+  "system.management.automation.security",
+  "system.management.automation.remoting",
+  "system.management.automation.host",
+  "system.management.automation.moduleanalysis",
+  "system.management.automation.debugging",
+  "system.io.compression",
+  "system.io.isolatedstorage",
+  "system.io.memorymappedfiles",
+  "system.io.packaging",
+  "system.io.pipes",
+  "system.io.enumeration",
+  "system.collections.generic",
+  "system.collections.concurrent",
+  "system.collections.specialized",
+  "system.collections.objectmodel",
+  "system.collections.immutable",
+  "system.collections.frozen",
+  "system.security.cryptography.x509certificates",
+  "system.security.cryptography.certificates",
+  "system.text.json",
+  "system.text.regularexpressions",
+  "system.text.unicode",
+  "system.text.encodings.web",
+  "system.diagnostics.codeanalysis",
+  "system.diagnostics.tracing",
+  "system.diagnostics.eventlog",
+  "system.diagnostics.metrics",
+  "system.diagnostics.symbolstore"
+]);
+var RESOLVED_FRAMEWORK_TYPES = /* @__PURE__ */ new Map([
+  // ── the documented TYPE ACCELERATORS (about_Type_Accelerators) ────────────────────────────────
+  ["adsi", "System.DirectoryServices.DirectoryEntry"],
+  ["adsisearcher", "System.DirectoryServices.DirectorySearcher"],
+  ["alias", "System.Management.Automation.AliasAttribute"],
+  ["allowemptycollection", "System.Management.Automation.AllowEmptyCollectionAttribute"],
+  ["allowemptystring", "System.Management.Automation.AllowEmptyStringAttribute"],
+  ["allow_null", "System.Management.Automation.AllowNullAttribute"],
+  ["array", "System.Array"],
+  ["bigint", "System.Numerics.BigInteger"],
+  ["bool", "System.Boolean"],
+  ["byte", "System.Byte"],
+  ["char", "System.Char"],
+  ["cimclass", "Microsoft.Management.Infrastructure.CimClass"],
+  ["cimconverter", "Microsoft.Management.Infrastructure.CimConverter"],
+  ["ciminstance", "Microsoft.Management.Infrastructure.CimInstance"],
+  ["cimtype", "Microsoft.Management.Infrastructure.CimType"],
+  ["cmdletbinding", "System.Management.Automation.CmdletBindingAttribute"],
+  ["cultureinfo", "System.Globalization.CultureInfo"],
+  ["datetime", "System.DateTime"],
+  ["decimal", "System.Decimal"],
+  ["double", "System.Double"],
+  ["dsclocalconfigurationmanager", "Microsoft.PowerShell.DesiredStateConfiguration.LocalConfigurationManager"],
+  ["dscproperty", "System.Management.Automation.DscPropertyAttribute"],
+  ["dscresource", "System.Management.Automation.DscResourceAttribute"],
+  ["float", "System.Single"],
+  ["guid", "System.Guid"],
+  ["hashtable", "System.Collections.Hashtable"],
+  ["initialsessionstate", "System.Management.Automation.Runspaces.InitialSessionState"],
+  ["int", "System.Int32"],
+  ["int16", "System.Int16"],
+  ["int32", "System.Int32"],
+  ["int64", "System.Int64"],
+  ["ipaddress", "System.Net.IPAddress"],
+  ["ipendpoint", "System.Net.IPEndPoint"],
+  ["long", "System.Int64"],
+  ["mailaddress", "System.Net.Mail.MailAddress"],
+  ["moduleinfo", "System.Management.Automation.PSModuleInfo"],
+  ["nullable", "System.Nullable"],
+  ["object", "System.Object"],
+  ["objectsecurity", "System.Security.AccessControl.ObjectSecurity"],
+  ["ordered", "System.Collections.Specialized.OrderedDictionary"],
+  ["outputtype", "System.Management.Automation.OutputTypeAttribute"],
+  ["parameter", "System.Management.Automation.ParameterAttribute"],
+  ["physicaladdress", "System.Net.NetworkInformation.PhysicalAddress"],
+  ["psobject", "System.Management.Automation.PSObject"],
+  ["pscredential", "System.Management.Automation.PSCredential"],
+  ["pscustomobject", "System.Management.Automation.PSCustomObject"],
+  ["pslistmodifier", "System.Management.Automation.PSListModifier"],
+  ["psprimitivedictionary", "System.Management.Automation.PSPrimitiveDictionary"],
+  ["pstypenameattribute", "System.Management.Automation.PSTypeNameAttribute"],
+  ["psvariable", "System.Management.Automation.PSVariable"],
+  ["ref", "System.Management.Automation.PSReference"],
+  ["regex", "System.Text.RegularExpressions.Regex"],
+  ["runspace", "System.Management.Automation.Runspaces.Runspace"],
+  ["runspacefactory", "System.Management.Automation.Runspaces.RunspaceFactory"],
+  ["sbyte", "System.SByte"],
+  ["scriptblock", "System.Management.Automation.ScriptBlock"],
+  ["securestring", "System.Security.SecureString"],
+  ["semver", "System.Management.Automation.SemanticVersion"],
+  ["short", "System.Int16"],
+  ["single", "System.Single"],
+  ["string", "System.String"],
+  ["switch", "System.Management.Automation.SwitchParameter"],
+  ["timespan", "System.TimeSpan"],
+  ["type", "System.Type"],
+  ["uint", "System.UInt32"],
+  ["uint16", "System.UInt16"],
+  ["uint32", "System.UInt32"],
+  ["uint64", "System.UInt64"],
+  ["ulong", "System.UInt64"],
+  ["uri", "System.Uri"],
+  ["ushort", "System.UInt16"],
+  ["validatecount", "System.Management.Automation.ValidateCountAttribute"],
+  ["validatedrive", "System.Management.Automation.ValidateDriveAttribute"],
+  ["validatelength", "System.Management.Automation.ValidateLengthAttribute"],
+  ["validatenotnull", "System.Management.Automation.ValidateNotNullAttribute"],
+  ["validatenotnullorempty", "System.Management.Automation.ValidateNotNullOrEmptyAttribute"],
+  ["validatepattern", "System.Management.Automation.ValidatePatternAttribute"],
+  ["validaterange", "System.Management.Automation.ValidateRangeAttribute"],
+  ["validatescript", "System.Management.Automation.ValidateScriptAttribute"],
+  ["validateset", "System.Management.Automation.ValidateSetAttribute"],
+  ["version", "System.Version"],
+  ["void", "System.Void"],
+  ["wildcardpattern", "System.Management.Automation.WildcardPattern"],
+  ["wmi", "System.Management.ManagementObject"],
+  ["wmiclass", "System.Management.ManagementClass"],
+  ["wmisearcher", "System.Management.ManagementObjectSearcher"],
+  ["xml", "System.Xml.XmlDocument"],
+  // ── NOT accelerators: resolved by the implicit-`System.` attempt, or by the loaded-assembly
+  //    search, to the framework type of that name. Cited per line, and only where the resolution is
+  //    a documented fact rather than a coin toss (see the block comment's "deliberately not" list).
+  ["bitconverter", "System.BitConverter"],
+  // System.BitConverter
+  ["console", "System.Console"],
+  // System.Console (implicit `System.`)
+  ["convert", "System.Convert"],
+  // System.Convert (implicit `System.`)
+  ["datetimeoffset", "System.DateTimeOffset"],
+  // System.DateTimeOffset
+  ["enum", "System.Enum"],
+  // System.Enum (implicit `System.`)
+  ["environment", "System.Environment"],
+  // System.Environment (implicit `System.`)
+  ["experimentalfeature", "System.Management.Automation.ExperimentalFeature"],
+  ["gc", "System.GC"],
+  // System.GC (implicit `System.`)
+  ["linebreakpoint", "System.Management.Automation.LineBreakpoint"],
+  ["math", "System.Math"],
+  // System.Math (implicit `System.`)
+  ["powershell", "System.Management.Automation.PowerShell"],
+  // assembly search: the PS host object
+  ["proxycommand", "System.Management.Automation.ProxyCommand"],
+  ["psserializer", "System.Management.Automation.PSSerializer"],
+  ["securityprotocoltype", "System.Net.SecurityProtocolType"],
+  ["servicepointmanager", "System.Net.ServicePointManager"],
+  ["tuple", "System.Tuple"],
+  // System.Tuple (implicit `System.`)
+  ["waithandle", "System.Threading.WaitHandle"]
+]);
+var classMembersOf = (map, literal) => {
+  const exact = map.get(literal);
+  if (exact !== void 0) return { name: literal, members: exact };
+  const folded = literal.toLowerCase();
+  for (const [name, members] of map) if (name.toLowerCase() === folded) return { name, members };
+  return void 0;
+};
+var usingScopeRootOf = (t) => {
+  if (t.length <= 6) return null;
+  if (t.charCodeAt(5) !== 58) return null;
+  for (let i = 0; i < 5; i++) {
+    const c = t.charCodeAt(i) | 32;
+    if (c !== "using".charCodeAt(i)) return null;
+  }
+  return t.slice(0, 5);
+};
+var moduleQualifiedCommandOf = (t) => {
+  const at = t.indexOf("\\");
+  if (at <= 0) return null;
+  if (t.indexOf("\\", at + 1) >= 0) return null;
+  for (let i = 0; i < t.length; i++) if (t.charCodeAt(i) === 58) return null;
+  const leaf = t.slice(at + 1);
+  if (leaf.length === 0) return null;
+  const dot = leaf.lastIndexOf(".");
+  if (dot > 0) {
+    let ext = leaf.slice(dot + 1).toLowerCase();
+    if (ext === "exe" || ext === "ps1" || ext === "psm1" || ext === "psd1" || ext === "dll" || ext === "cmd" || ext === "bat" || ext === "com" || ext === "msi") return null;
+  }
+  return t.slice(0, at);
+};
+var envProviderRootOf = (t) => {
+  if (t.length <= 4) return null;
+  if (t.charCodeAt(3) !== 58) return null;
+  const a = t.charCodeAt(0) | 32, b = t.charCodeAt(1) | 32, c = t.charCodeAt(2) | 32;
+  if (!(a === 101 && b === 110 && c === 118)) return null;
+  return t.slice(0, 3);
+};
+var dotNetShorthandRootOf = (t) => {
+  const dot = t.indexOf(".");
+  if (dot <= 0) return null;
+  const root = t.slice(0, dot);
+  let folded = "";
+  for (let i = 0; i < root.length; i++) {
+    const c = root.charCodeAt(i);
+    folded += String.fromCharCode(c >= 65 && c <= 90 ? c + 32 : c);
+  }
+  return DOTNET_SYSTEM_NAMESPACES.has(folded) ? root : null;
+};
+var isCommandPositionCall = (rel) => {
+  if (rel.type !== ASTEngine.RelationshipType.Calls) return false;
+  const md = rel.metadata ?? {};
+  if (md.methodCall === true) return false;
+  if (md.staticMemberCall === true) return false;
+  return true;
+};
+var commandReadingOf = (t) => {
+  if (t.charCodeAt(0) === 34 || t.charCodeAt(0) === 39) return null;
+  if (isRelativeProjectFilePath(t)) return null;
+  if (hasFileDefinableScopePrefix(t)) return null;
+  return "command";
+};
+var isTypeAccelerator = (declared) => {
+  const bare = stripTypeSuffixBrackets(declared).trim();
+  return TYPE_ACCELERATORS.has(bare.toLowerCase()) || TYPE_ACCELERATORS.has(bare);
+};
+var TYPE_ACCELERATORS = /* @__PURE__ */ new Set([
+  // the primitives and their aliases
+  "bool",
+  "byte",
+  "char",
+  "datetime",
+  "decimal",
+  "double",
+  "float",
+  "int",
+  "int16",
+  "int32",
+  "int64",
+  "long",
+  "sbyte",
+  "short",
+  "single",
+  "string",
+  "uint",
+  "uint16",
+  "uint32",
+  "uint64",
+  "ulong",
+  "ushort",
+  "void",
+  "bigint",
+  // collections and the object model
+  "array",
+  "hashtable",
+  "ordered",
+  "object",
+  "psobject",
+  "pscustomobject",
+  "pslistmodifier",
+  "psprimitivedictionary",
+  "pscredential",
+  "scriptblock",
+  "switch",
+  "type",
+  "ref",
+  "reftype",
+  "void",
+  "xml",
+  "regex",
+  "wildcardpattern",
+  // values the engine names
+  "cultureinfo",
+  "guid",
+  "ipaddress",
+  "mailaddress",
+  "semver",
+  "timespan",
+  "uri",
+  "version",
+  "nullstring",
+  // CIM / WMI
+  "cimclass",
+  "cimconverter",
+  "ciminstance",
+  "cimsession",
+  "cimtype",
+  "wmi",
+  "wmiclass",
+  "wmisearcher",
+  // attributes (metadata, skipped before this set, listed for completeness)
+  "alias",
+  "allowemptycollection",
+  "allowemptystring",
+  "allownull",
+  "argumentcompleter",
+  "argumentcompletions",
+  "cmdletbinding",
+  "dscresource",
+  "experimentaction",
+  "experimental",
+  "experimentalfeature",
+  "feature",
+  "flags",
+  "nocompatiblecommand",
+  "norunspaceaffinity",
+  "parameter",
+  "psdefaultvalue",
+  "pstypenameattribute",
+  "supportswildcards",
+  "validatecount",
+  "validatedrive",
+  "validatelength",
+  "validatenotnull",
+  "validatenotnullorempty",
+  "validatepattern",
+  "validaterange",
+  "validatescript",
+  "validateset",
+  "validatetrusteddata",
+  "validateuserdrive"
+]);
+var memberOverrides = (derived, base) => {
+  if (base.isHidden) return false;
+  if (base.isStatic) return false;
+  return derived.kind === base.kind;
+};
+var memberHeaderFacts = (node, nameNode) => {
+  const named = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const c = node.child(i);
+    if (!c || !c.isNamed) continue;
+    named.push({ type: c.type, text: c.text });
+  }
+  const modifiers = [];
+  let prefix = "";
+  for (let i = 0; i < named.length; i++) {
+    if (named[i].type !== "class_attribute") continue;
+    const prevType = i > 0 ? named[i - 1].type : "";
+    const nextType = named[i + 1]?.type ?? "";
+    const isNamePrefix = (prevType === "attribute" || prevType === "type_literal") && nextType === "simple_name";
+    if (isNamePrefix) prefix = named[i].text;
+    else modifiers.push(named[i].text.toLowerCase());
+  }
+  const name = prefix ? prefix + nameNode.text : nameNode.text;
+  return { name, modifiers: modifiers.join(" ") };
+};
+var RealPowershellAnalyzer = class {
+  analyze(rootNode, content, filePath) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const exportedNames = /* @__PURE__ */ new Set();
+    const relKeys = /* @__PURE__ */ new Set();
+    const frameworks = /* @__PURE__ */ new Set(["PowerShell"]);
+    const patterns = /* @__PURE__ */ new Set();
+    const fileName = this.basenameOf(filePath);
+    const lines = content.split("\n");
+    symbols.push({
+      name: fileName,
+      kind: ASTEngine.SymbolKind.Module,
+      range: this.nodeToRange(rootNode),
+      visibility: "public",
+      metadata: { powershellSpecific: true, isScript: true, scriptPath: filePath }
+    });
+    let cyclomaticComplexity = 1;
+    let dscDepth = 0;
+    const dscBlocks = /* @__PURE__ */ new Set();
+    const interfaceBlocks = /* @__PURE__ */ new Set();
+    const nodeKey = (n) => `${n.startIndex}:${n.endIndex}`;
+    const dscOwner = /* @__PURE__ */ new Map();
+    const frames = [{ owner: fileName, scope: fileName, containerLine: 1 }];
+    const top = () => frames[frames.length - 1];
+    const atFileScope = () => frames.length === 1;
+    const baseClassByClass = /* @__PURE__ */ new Map();
+    const classDeclaredSpelling = /* @__PURE__ */ new Map();
+    const classMembers = /* @__PURE__ */ new Map();
+    const overrideCandidates = [];
+    const evidenceClassFor = (type, isImport = false) => {
+      if (isImport) return "import_based";
+      switch (type) {
+        case ASTEngine.RelationshipType.Contains:
+        case ASTEngine.RelationshipType.Extends:
+        case ASTEngine.RelationshipType.Implements:
+        case ASTEngine.RelationshipType.Exports:
+          return "structural";
+        case ASTEngine.RelationshipType.References:
+        // `part_of` is read from a DIRECTIVE — the dot-source operator is syntax that
+        // names the part, and the edge exists because the directive exists. That is
+        // the fleet's `import_based` class (erlang ER-D46: "both are directives"), and
+        // it is the class css's plain-file `@import` relabel carries. The branch is
+        // LIVE rather than dead: the `isImport` short-circuit above fires only for
+        // rows that pass `import: true`, which a `part_of` row does not.
+        case ASTEngine.RelationshipType.PartOf:
+          return "import_based";
+        default:
+          return "usage_contextual";
+      }
+    };
+    const addRel = (source, target, type, confidence, line, metadata = {}) => {
+      if (!source || !target) return;
+      const key = `${source}\0${type}\0${target}\0${line}`;
+      if (relKeys.has(key)) return;
+      relKeys.add(key);
+      const isImport = metadata.import === true;
+      relationships.push({
+        source,
+        target,
+        type,
+        confidence,
+        line_number: line,
+        // The caller's metadata comes LAST so an explicit `evidenceClass` at a call
+        // site wins over the default — that is how the `overrides` edges say `inferred`
+        // without every other call site having to repeat the reasoning.
+        metadata: { evidenceClass: evidenceClassFor(type, isImport), ...metadata }
+      });
+    };
+    const stripDollar = (text) => {
+      if (text.length < 2 || text.charCodeAt(0) !== 36) return text;
+      if (text.charCodeAt(1) === 123 && text.charCodeAt(text.length - 1) === 125) {
+        return text.slice(2, -1);
+      }
+      return text.slice(1);
+    };
+    const unquoteTarget = (text) => {
+      if (text.length < 2) return text;
+      const first = text.charCodeAt(0);
+      if (first !== 34 && first !== 39) return text;
+      if (text.charCodeAt(text.length - 1) !== first) return text;
+      return text.slice(1, -1);
+    };
+    const isQualified = (raw) => {
+      const lower = raw.toLowerCase();
+      return QUALIFIED_PREFIXES.some((p) => lower.startsWith(p));
+    };
+    const isDeclarableVariable = (text) => !isQualified(text) || definableScopeOf(stripDollar(text.trim())) !== null;
+    const isAutomatic = (name) => AUTOMATIC_VARIABLES.has(name.toLowerCase());
+    const symbolMap = /* @__PURE__ */ new Map();
+    const pushSymbol = (name, kind, node, line, meta = {}, parameters, ownerOverride) => {
+      const raw = name.trim();
+      if (raw === "") return null;
+      if (isQualified(raw)) return null;
+      const owner = ownerOverride ?? top().owner;
+      const clean = stripDollar(raw);
+      if (clean === "") return null;
+      if (kind === ASTEngine.SymbolKind.Variable && isAutomatic(clean)) return null;
+      const key = `${owner}\0${clean.toLowerCase()}\0${kind}`;
+      const existing = symbolMap.get(key);
+      if (existing) return existing;
+      const sym = {
+        name: clean,
+        kind,
+        range: this.nodeToRange(node),
+        scope: owner,
+        ownerName: owner,
+        visibility: "public",
+        parameters,
+        metadata: { powershellSpecific: true, ...meta }
+      };
+      if (typeof meta.isStatic === "boolean") sym.isStatic = meta.isStatic;
+      if (typeof meta.isAbstract === "boolean") sym.isAbstract = meta.isAbstract;
+      if (Array.isArray(meta.annotations)) sym.decorators = meta.annotations;
+      if (typeof meta.returnType === "string" && meta.returnType) sym.returnType = meta.returnType;
+      if (typeof meta.docstring === "string" && meta.docstring) sym.docstring = meta.docstring;
+      symbols.push(sym);
+      symbolMap.set(key, sym);
+      return sym;
+    };
+    const addContains = (target, line, kind) => {
+      const owner = top().owner;
+      if (!owner || owner === target) return;
+      if ((kind === void 0 || kind === ASTEngine.SymbolKind.Variable) && isAutomatic(target)) return;
+      addRel(owner, target, ASTEngine.RelationshipType.Contains, 1, line ?? top().containerLine, {});
+    };
+    const declareSymbol = (rawName, kind, node, line, meta = {}, parameters, containsLine = line) => {
+      const name = stripDollar(rawName);
+      if (name === "") return;
+      const scoped = kind === ASTEngine.SymbolKind.Variable ? definableScopeOf(name) : null;
+      const bare = scoped === null ? name : scoped.bare;
+      const scopeOwner = scoped !== null && (scoped.scope === "script" || scoped.scope === "global") ? fileName : void 0;
+      if (kind === ASTEngine.SymbolKind.Variable && isAutomatic(bare)) return;
+      if (kind === ASTEngine.SymbolKind.Variable && scoped === null && isQualified(rawName)) return;
+      const key = `${scopeOwner ?? top().owner}\0${bare.toLowerCase()}\0${kind}`;
+      if (symbolMap.has(key)) return;
+      pushSymbol(
+        bare,
+        kind,
+        node,
+        line,
+        scoped === null ? meta : { ...meta, scopeQualifier: scoped.scope },
+        parameters,
+        scopeOwner
+      );
+      addContains(bare, containsLine, kind);
+    };
+    const emitMemberUses = (node, kind) => {
+      const member = this.findChildByType(node, "member_name");
+      if (!member) return;
+      let leaf = member.text;
+      if (!leaf) return;
+      let quotedMemberName = false;
+      if (leaf.length >= 2) {
+        const q = leaf.charCodeAt(0);
+        if ((q === 34 || q === 39) && leaf.charCodeAt(leaf.length - 1) === q) {
+          const inner = leaf.slice(1, -1);
+          if (inner.length > 0 && inner.indexOf("$") < 0) {
+            leaf = inner;
+            quotedMemberName = true;
+          }
+        }
+      }
+      if (leaf.charCodeAt(0) === 36) {
+        const raw = stripDollar(leaf.trim());
+        const name = raw.length > 1 && raw.charCodeAt(0) === 64 ? raw.slice(1) : raw;
+        if (!name || isAutomatic(name) || !isPlausibleSymbolName(name)) return;
+        addRel(
+          top().scope,
+          name,
+          ASTEngine.RelationshipType.Uses,
+          0.9,
+          member.startPosition.row + 1,
+          {
+            powershellSpecific: true,
+            isMemberAccess: true,
+            isVariableReference: true,
+            isDynamicMemberName: true,
+            ...kind === "write" ? { isMemberWrite: true } : { isMemberReference: true }
+          }
+        );
+        return;
+      }
+      let hasNameChar = false;
+      for (let i = 0; i < leaf.length; i++) {
+        const c = leaf.charCodeAt(i);
+        if (c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95) {
+          hasNameChar = true;
+          break;
+        }
+      }
+      if (!hasNameChar || !isPlausibleSymbolName(leaf)) return;
+      addRel(
+        top().scope,
+        leaf,
+        ASTEngine.RelationshipType.Uses,
+        kind === "write" ? 0.9 : 0.8,
+        member.startPosition.row + 1,
+        {
+          powershellSpecific: true,
+          isMemberAccess: true,
+          // PSD14 — THE MEMBER'S NAME WAS WRITTEN IN QUOTES, so its punctuation is DATA. A quoted
+          // name is how PowerShell spells a property whose name no identifier can carry
+          // (`$build.triggerInfo.'pr.number'` is ONE property called `pr.number`), and the dot in
+          // it is not a qualifier. The externality pass asks the arbiter's OWNER question about the
+          // text before that dot — `pr` — which the project answers with a VARIABLE, so the row was
+          // REFUTED for a claim the source never made. MEASURED: 2 whole-population rows. The row
+          // and its `noDeclarationInFile` fact stay; only the name claim is withheld.
+          ...quotedMemberName ? { isQuotedMemberName: true } : {},
+          ...kind === "write" ? { isMemberWrite: true } : { isMemberReference: true }
+        }
+      );
+    };
+    const emitParameterDefaultReads = (sp) => {
+      const def = findFirstChild(sp, "script_parameter_default");
+      if (def) emitVariableReads(def, true, "isParameterDefault");
+    };
+    const emitVariableReads = (node, skipBlocks = false, marker) => {
+      const work2 = [node];
+      const seen = /* @__PURE__ */ new Set();
+      while (work2.length > 0) {
+        const n = work2.pop();
+        if (n.type === "comment") continue;
+        if (skipBlocks && (n.type === "script_block_expression" || n.type === "named_block")) continue;
+        if (skipBlocks && n.type === "element_access") continue;
+        if (n.type === "expandable_here_string_literal" && marker !== "isHereStringInterpolation") continue;
+        if (n.type === "variable" || n.type === "braced_variable") {
+          if (seen.has(n.startIndex)) continue;
+          seen.add(n.startIndex);
+          const trimmed = n.text.trim();
+          const rawName = stripDollar(trimmed);
+          const name = rawName.length > 1 && rawName.charCodeAt(0) === 64 ? rawName.slice(1) : rawName;
+          const isScopedName = isQualified(n.text) || isQualified(`$${name}`);
+          if (!isScopedName && !isPlausibleSymbolName(name)) continue;
+          if (!name || isAutomatic(name)) continue;
+          const isScoped = isScopedName;
+          if (isScoped && name.indexOf(":") < 0) continue;
+          const scopedRead = isScoped ? definableScopeOf(name) : null;
+          const scopedOwner = scopedRead === null ? null : scopedRead.scope === "script" || scopedRead.scope === "global" ? fileName : top().owner;
+          const publishedName = scopedRead === null ? name : `${scopedOwner}.${scopedRead.bare}`;
+          const lead = n.text.length - n.text.trimStart().length;
+          let skippedLines = 0;
+          for (let i = 0; i < lead; i++) {
+            if (n.text.charCodeAt(i) === 10) skippedLines++;
+          }
+          addRel(
+            top().scope,
+            publishedName,
+            ASTEngine.RelationshipType.Uses,
+            0.9,
+            n.startPosition.row + 1 + skippedLines,
+            {
+              powershellSpecific: true,
+              isVariableReference: true,
+              ...marker ? { [marker]: true } : {},
+              ...scopedRead !== null ? { isScopedVariableRead: true, scopeQualifier: scopedRead.scope } : isScoped ? { isScopedEnvironmentRead: true } : {},
+              // A read written in the BRACED spelling. The marker's job is to make the
+              // normalization independently revertible: once `${a}` and `$a` are the
+              // same string in the result, nothing distinguishes them, so a mutant for
+              // "the braces come back" has nothing to key on and would be a no-op — a
+              // mutant that cannot fail is decoration.
+              ...trimmed.charCodeAt(0) === 36 && trimmed.charCodeAt(1) === 123 ? { isBracedVariable: true } : {}
+            }
+          );
+          continue;
+        }
+        if (n.type === "member_access") {
+          emitMemberUses(n, "read");
+          continue;
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const c = n.namedChild(i);
+          if (c) work2.push(c);
+        }
+      }
+    };
+    const emitAssignmentReads = (node) => {
+      const work2 = [node];
+      while (work2.length > 0) {
+        const n = work2.pop();
+        if (n.type === "command") continue;
+        if (n.type === "element_access") continue;
+        if (n.type === "expandable_here_string_literal") continue;
+        if (n.type === "variable" || n.type === "braced_variable" || n.type === "member_access") {
+          emitVariableReads(n, true, "isAssignmentRead");
+          continue;
+        }
+        if (n.type === "script_block_expression" || n.type === "named_block") continue;
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const c = n.namedChild(i);
+          if (c) work2.push(c);
+        }
+      }
+    };
+    const isBranch = (type) => type === "if_statement" || type === "elseif_clause" || type === "while_statement" || type === "do_statement" || type === "for_statement" || type === "foreach_statement" || type === "switch_statement" || type === "try_statement" || type === "catch_clause" || type === "trap_statement" || // A `switch` CASE is a decision point. `switch_clause` was never named by
+    // this lane, so a 10-case switch measured a cyclomatic complexity of 1
+    // (measured: 174 `switch_clause` nodes in the production draw, all
+    // uncounted).
+    type === "switch_clause";
+    const findFirstChild = (node, type) => {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === type) return child;
+      }
+      return null;
+    };
+    const findDescendant = (node, type, maxDepth = 6) => {
+      let frontier = [node];
+      for (let d = 0; d < maxDepth && frontier.length > 0; d++) {
+        const next = [];
+        for (const n of frontier) {
+          if (n.type === type) return n;
+          for (let i = n.namedChildCount - 1; i >= 0; i--) {
+            const child = n.namedChild(i);
+            if (child) next.push(child);
+          }
+        }
+        frontier = next;
+      }
+      return null;
+    };
+    const findDescendantVariable = (node) => findDescendant(node, "variable", 12);
+    const nodeIsAVariableReference = (node) => node.type === "variable";
+    const typeSpecText = (node) => {
+      const specTextOf = (literal) => {
+        const spec = findFirstChild(literal, "type_spec");
+        if (spec) return spec.text;
+        return this.stripBrackets(literal.text);
+      };
+      const direct = node.type === "type_literal" ? node : findFirstChild(node, "type_literal");
+      if (direct) return specTextOf(direct);
+      for (const list of this.collectChildrenByType(node, "attribute_list")) {
+        for (const attr of this.collectChildrenByType(list, "attribute")) {
+          const literal = findFirstChild(attr, "type_literal");
+          if (literal) return specTextOf(literal);
+        }
+      }
+      return "";
+    };
+    const collectParameters = (list) => {
+      const params = [];
+      if (!list) return params;
+      for (let i = 0; i < list.namedChildCount; i++) {
+        const p = list.namedChild(i);
+        if (!p) continue;
+        if (p.type !== "script_parameter" && p.type !== "class_method_parameter") continue;
+        const varNode = findFirstChild(p, "variable");
+        if (!varNode) continue;
+        const declared = typeSpecText(p);
+        const def = findFirstChild(p, "script_parameter_default");
+        const entry = {
+          name: stripDollar(varNode.text),
+          // An untyped parameter is not `any` by declaration — it is untyped.
+          // `[int]$Default = 0` and `$Default = 0` are different contracts and
+          // the store's `parameters` JSON is the only place either survives.
+          type: declared || "untyped",
+          isOptional: def !== null
+        };
+        if (def) {
+          const val = def.namedChildCount > 1 ? def.namedChild(1) : null;
+          if (val) entry.defaultValue = val.text;
+        }
+        params.push(entry);
+      }
+      return params;
+    };
+    const commandNameOf = (node) => {
+      const field = node.childForFieldName?.("command_name");
+      const fieldNode = field ?? null;
+      const nameNode = fieldNode ?? findFirstChild(node, "command_name");
+      if (nameNode) return unquoteTarget(nameNode.text);
+      const expr = findFirstChild(node, "command_name_expr");
+      if (expr) {
+        const inner = findFirstChild(expr, "command_name");
+        if (inner) return inner.text;
+        return unquoteTarget(expr.text);
+      }
+      return "";
+    };
+    const commandArgs = (node, sourceNodes, onlyParameters) => {
+      const out = [];
+      const elements = findFirstChild(node, "command_elements");
+      if (!elements) return out;
+      const isValueToken = (c) => !!c && (c.type === "generic_token" || c.type === "string_literal" || c.type === "expandable_string_literal");
+      for (let i = 0; i < elements.namedChildCount; i++) {
+        const c = elements.namedChild(i);
+        if (!c) continue;
+        if (c.type === "command_parameter") {
+          const next = elements.namedChild(i + 1);
+          let flag = "";
+          {
+            const raw = this.stripQuotes(c.text).trim();
+            let s = raw.length > 0 && raw.charCodeAt(0) === 45 ? raw.slice(1) : raw;
+            const colon = s.indexOf(":");
+            if (colon >= 0) s = s.slice(0, colon);
+            flag = s.toLowerCase();
+          }
+          if (next && isValueToken(next) && !SWITCH_ARGUMENT_VALUES.has(next.text.toLowerCase()) && (!onlyParameters || onlyParameters.has(flag))) {
+            out.push(this.stripQuotes(next.text));
+            sourceNodes?.push(next);
+          }
+          continue;
+        }
+        if (isValueToken(c)) {
+          out.push(this.stripQuotes(c.text));
+          sourceNodes?.push(c);
+          continue;
+        }
+        if (c.type === "array_literal_expression" || c.type === "unary_expression") {
+          const lit = this.findQuoted(c);
+          if (lit) {
+            const value = this.stripQuotes(lit.text);
+            const v2 = findDescendantVariable(c);
+            if (v2 && value.trim() === v2.text) {
+              out.push(stripDollar(v2.text));
+              sourceNodes?.push(v2);
+            } else {
+              out.push(value);
+              sourceNodes?.push(lit);
+            }
+            continue;
+          }
+          const v = findDescendantVariable(c);
+          if (v) {
+            out.push(stripDollar(v.text));
+            sourceNodes?.push(v);
+            continue;
+          }
+        }
+      }
+      return out;
+    };
+    const looksLikeModulePath = (text) => text.length > 0 && (text.includes("/") || text.includes("\\") || hasTrailingExtension(text));
+    const addImport = (moduleName, via, line, node) => {
+      if (!moduleName) return;
+      imports.push({
+        module: moduleName,
+        items: ["*"],
+        isDefault: true,
+        range: this.nodeToRange(node),
+        metadata: { powershellSpecific: true, via }
+      });
+      const meta = { powershellSpecific: true, import: true, via, fileLevel: atFileScope() };
+      addRel(top().scope, moduleName, ASTEngine.RelationshipType.Imports, 0.9, line, { ...meta });
+      addRel(top().scope, moduleName, ASTEngine.RelationshipType.References, 0.9, line, { ...meta });
+    };
+    const isExportWildcard = (name) => {
+      for (let i = 0; i < name.length; i++) {
+        const code = name.charCodeAt(i);
+        if (code === 42 || code === 63) return true;
+      }
+      return false;
+    };
+    const addExport = (name, via, line) => {
+      if (!name || isExportWildcard(name)) return;
+      if (exportedNames.has(name.toLowerCase())) return;
+      exportedNames.add(name.toLowerCase());
+      exports.push({ name, range: this.lineRange(line), metadata: { powershellSpecific: true, via } });
+      addRel(top().scope, name, ASTEngine.RelationshipType.Exports, 1, line, {
+        powershellSpecific: true,
+        viaExportModuleMember: true,
+        via,
+        fileLevel: atFileScope()
+      });
+    };
+    const detectFrameworks = (cmdName) => {
+      const lower = cmdName.toLowerCase();
+      if (lower.startsWith("get-az") || lower.startsWith("new-az") || lower.startsWith("set-az") || lower.startsWith("remove-az") || lower.startsWith("connect-az") || lower === "az" || lower.startsWith("az_")) frameworks.add("Azure Az Module");
+      if (lower.startsWith("get-msol") || lower.startsWith("set-msol") || lower.startsWith("connect-msol"))
+        frameworks.add("Azure AD / MSOnline");
+      if (lower.startsWith("get-exo") || lower.startsWith("set-exo") || lower.startsWith("new-exo") || lower.startsWith("get-mailbox") || lower.startsWith("set-mailbox") || lower.startsWith("enable-mailbox")) frameworks.add("Exchange Online");
+      if (lower.startsWith("get-sp") || lower.startsWith("set-sp") || lower.startsWith("new-sp") || lower.startsWith("connect-pnp") || lower.startsWith("get-pnp")) frameworks.add("SharePoint PnP");
+      if (lower.startsWith("get-ad") || lower.startsWith("set-ad") || lower.startsWith("new-ad") || lower.startsWith("remove-ad"))
+        frameworks.add("Active Directory");
+      if (lower.startsWith("get-vm") || lower.startsWith("new-vm") || lower.startsWith("start-vm") || lower.startsWith("stop-vm"))
+        frameworks.add("VMware / Hyper-V");
+      if (lower.startsWith("invoke-rest") || lower.startsWith("invoke-web") || lower === "irm" || lower === "iwr")
+        patterns.add("REST API Calls");
+      if (lower.startsWith("write-") || lower.startsWith("read-")) patterns.add("I/O Operations");
+      if (lower === "get-service" || lower === "stop-service" || lower === "start-service" || lower === "restart-service")
+        patterns.add("Service Management");
+    };
+    const usingNamespacePrefixes = [];
+    const typeNamesInFile = /* @__PURE__ */ new Set();
+    const addTypeCreatedNames = /* @__PURE__ */ new Set();
+    const addTypeDeclarations = /* @__PURE__ */ new Map();
+    const recordAddTypeDeclaration = (full) => {
+      if (full.length === 0) return;
+      const key = full.toLowerCase();
+      if (!addTypeDeclarations.has(key)) addTypeDeclarations.set(key, full);
+    };
+    {
+      const stack = [rootNode];
+      const hereStringBodies = [];
+      let addTypeSeen = false;
+      const valueNodeText = (n) => this.stripQuotes(n.text).trim();
+      while (stack.length > 0) {
+        const n = stack.pop();
+        if (n.type === "class_statement" || n.type === "enum_statement") {
+          const nameNode = findFirstChild(n, n.type === "class_statement" ? "class_name" : "enum_name");
+          if (nameNode && nameNode.text) typeNamesInFile.add(nameNode.text.toLowerCase());
+        }
+        if (n.type === "string_literal" && n.text.length > 2 && n.text.charCodeAt(0) === 64) {
+          hereStringBodies.push(n.text);
+        }
+        if (n.type === "command") {
+          const nameNode = findFirstChild(n, "command_name");
+          const leaf = nameNode ? nameNode.text.toLowerCase() : "";
+          if (leaf === "using" || leaf === "add-type") {
+            const elements = findFirstChild(n, "command_elements");
+            const values = [];
+            let addNamespace = "";
+            let addName = "";
+            if (elements) {
+              for (let i = 0; i < elements.namedChildCount; i++) {
+                const c = elements.namedChild(i);
+                if (!c) continue;
+                if (c.type === "command_parameter") {
+                  const next = elements.namedChild(i + 1);
+                  if (!next) continue;
+                  const flag = stripLeadingDash(this.stripQuotes(c.text)).toLowerCase();
+                  if (leaf === "add-type" && (flag === "namespace" || flag === "name")) {
+                    const spelled = valueNodeText(next);
+                    if (spelled.length > 0) addTypeCreatedNames.add(spelled.toLowerCase());
+                    if (spelled.length > 0) {
+                      if (flag === "namespace") addNamespace = spelled;
+                      else addName = spelled;
+                    }
+                  }
+                  continue;
+                }
+                if (c.type === "generic_token" || c.type === "string_literal" || c.type === "expandable_string_literal" || c.type === "array_literal_expression" || c.type === "unary_expression") values.push(c);
+              }
+            }
+            if (leaf === "using") {
+              if (values.length >= 2) {
+                const directive = valueNodeText(values[0]).toLowerCase();
+                const target = valueNodeText(values[1]);
+                if (directive === "namespace" && target.length > 0) usingNamespacePrefixes.push(target);
+              }
+            } else {
+              addTypeSeen = true;
+              if (addNamespace.length > 0 && addName.length > 0) {
+                recordAddTypeDeclaration(`${addNamespace}.${addName}`);
+              }
+            }
+          }
+        }
+        for (let i = n.childCount - 1; i >= 0; i--) {
+          const child = n.child(i);
+          if (child) stack.push(child);
+        }
+      }
+      if (addTypeSeen) {
+        for (const body of hereStringBodies) {
+          addTypeNamesIn(body, addTypeCreatedNames, addTypeDeclarations);
+        }
+      }
+    }
+    const work = [{ node: rootNode, exit: false }];
+    while (work.length > 0) {
+      const { node, exit } = work.pop();
+      if (!node) continue;
+      if (exit) {
+        if (dscBlocks.has(nodeKey(node))) {
+          dscBlocks.delete(nodeKey(node));
+          const declared = dscOwner.get(nodeKey(node));
+          dscOwner.delete(nodeKey(node));
+          if (declared !== void 0) frames.pop();
+          dscDepth--;
+        }
+        if (interfaceBlocks.has(nodeKey(node))) {
+          interfaceBlocks.delete(nodeKey(node));
+          frames.pop();
+        }
+        if (node.type === "function_statement" || node.type === "class_statement" || node.type === "enum_statement" || node.type === "class_method_definition") {
+          frames.pop();
+        }
+        continue;
+      }
+      work.push({ node, exit: true });
+      if (isBranch(node.type)) cyclomaticComplexity++;
+      switch (node.type) {
+        // ------------------------------------------------------- functions
+        case "function_statement": {
+          const nameNode = findFirstChild(node, "function_name");
+          if (!nameNode) break;
+          const fnName = nameNode.text;
+          const inline = findFirstChild(node, "function_parameter_declaration");
+          const inlineList = inline ? findFirstChild(inline, "parameter_list") : null;
+          const direct = findFirstChild(node, "parameter_list");
+          const blockList = this.findParamList(node);
+          const params = collectParameters(inlineList ?? direct ?? blockList);
+          const parameterForm = inlineList ? "inline" : direct ?? blockList ? "paramBlock" : "none";
+          const annotations = [];
+          annotations.push(...this.allAttributeTexts(node));
+          for (const attr of annotations) {
+            if (attr.includes("CmdletBinding")) patterns.add("Advanced Functions");
+            if (attr.includes("Parameter")) patterns.add("Parameter Attributes");
+            if (attr.includes("ValidateSet") || attr.includes("ValidateRange") || attr.includes("ValidatePattern"))
+              patterns.add("Input Validation");
+          }
+          const line = nameNode.startPosition.row + 1;
+          declareSymbol(fnName, ASTEngine.SymbolKind.Function, node, line, {
+            ...annotations.length > 0 ? { annotations } : {},
+            docstring: this.docstringAbove(nameNode.startPosition.row, lines),
+            returnType: "any",
+            parameterForm
+          }, params);
+          frames.push({ owner: fnName, scope: fnName, containerLine: line });
+          {
+            const paramList = inlineList ?? direct ?? blockList;
+            if (paramList) {
+              for (const sp of this.collectChildrenByType(paramList, "script_parameter")) {
+                const v = findFirstChild(sp, "variable");
+                if (!v) continue;
+                if (isQualified(v.text)) continue;
+                declareSymbol(stripDollar(v.text), ASTEngine.SymbolKind.Variable, v, v.startPosition.row + 1, {
+                  isParameter: true,
+                  type: typeSpecText(sp) || "untyped"
+                });
+                emitParameterDefaultReads(sp);
+              }
+            }
+          }
+          break;
+        }
+        // ------------------------------------------------- script parameters
+        case "param_block": {
+          if (!atFileScope()) break;
+          const list = findFirstChild(node, "parameter_list");
+          if (!list) break;
+          for (const p of this.collectChildrenByType(list, "script_parameter")) {
+            const varNode = findFirstChild(p, "variable");
+            if (!varNode || isQualified(varNode.text)) continue;
+            const vline = varNode.startPosition.row + 1;
+            const declared = typeSpecText(p);
+            const attrs = this.attributeTexts(p);
+            declareSymbol(varNode.text, ASTEngine.SymbolKind.Variable, varNode, vline, {
+              isScriptParameter: true,
+              type: declared || "untyped",
+              ...attrs ? { annotations: attrs } : {}
+            });
+            emitParameterDefaultReads(p);
+          }
+          break;
+        }
+        // ---------------------------------------------------------- classes
+        case "class_statement": {
+          const names = this.collectChildrenByType(node, "simple_name");
+          if (names.length === 0) break;
+          const className = names[0].text;
+          if (!classDeclaredSpelling.has(className.toLowerCase())) classDeclaredSpelling.set(className.toLowerCase(), className);
+          const baseClass = names.length > 1 ? names[1].text : "";
+          const interfaces = names.slice(2).map((n) => n.text);
+          const declLine = names[0].startPosition.row + 1;
+          if (baseClass) {
+            baseClassByClass.set(className, baseClass);
+            addRel(className, baseClass, ASTEngine.RelationshipType.Extends, 1, declLine, {
+              powershellSpecific: true
+            });
+          }
+          for (const iface of interfaces) {
+            addRel(className, iface, ASTEngine.RelationshipType.Implements, 0.85, declLine, {
+              powershellSpecific: true
+            });
+          }
+          if (!classMembers.has(className)) classMembers.set(className, /* @__PURE__ */ new Set());
+          declareSymbol(className, ASTEngine.SymbolKind.Class, node, declLine, {
+            ...baseClass ? { baseClass } : {},
+            docstring: this.docstringAbove(names[0].startPosition.row, lines)
+          });
+          frames.push({ owner: className, scope: className, containerLine: declLine });
+          break;
+        }
+        // ------------------------------------------------------------ enums
+        case "enum_statement": {
+          const nameNode = findFirstChild(node, "simple_name");
+          if (!nameNode) break;
+          const line = nameNode.startPosition.row + 1;
+          declareSymbol(nameNode.text, ASTEngine.SymbolKind.Enum, node, line, {
+            docstring: this.docstringAbove(nameNode.startPosition.row, lines)
+          });
+          frames.push({ owner: nameNode.text, scope: nameNode.text, containerLine: line });
+          break;
+        }
+        case "enum_member": {
+          const nameNode = findFirstChild(node, "simple_name");
+          if (!nameNode) break;
+          const line = nameNode.startPosition.row + 1;
+          declareSymbol(nameNode.text, ASTEngine.SymbolKind.EnumMember, node, line, {});
+          break;
+        }
+        // -------------------------------------------------- class members
+        case "class_method_definition": {
+          const nameNode = findFirstChild(node, "simple_name");
+          if (!nameNode) break;
+          const hdr = memberHeaderFacts(node, nameNode);
+          const memberName = hdr.name;
+          const className = top().owner;
+          const isCtor = memberName === className;
+          const line = nameNode.startPosition.row + 1;
+          const params = collectParameters(this.findMethodParamList(node));
+          const attrText = hdr.modifiers;
+          const symName = isCtor ? "constructor" : memberName;
+          const returnType = typeSpecText(node) || (isCtor ? "void" : "any");
+          declareSymbol(symName, isCtor ? ASTEngine.SymbolKind.Constructor : ASTEngine.SymbolKind.Method, node, line, {
+            isStatic: attrText.includes("static"),
+            isHidden: attrText.includes("hidden"),
+            returnType,
+            ...this.allAttributeTexts(node).length > 0 ? { annotations: this.allAttributeTexts(node) } : {},
+            docstring: this.docstringAbove(nameNode.startPosition.row, lines)
+          }, params);
+          if (!isCtor) {
+            if (classMembers.has(className)) {
+              classMembers.get(className).add({
+                name: memberName,
+                kind: "method",
+                isStatic: attrText.includes("static"),
+                isHidden: attrText.includes("hidden")
+              });
+            }
+            overrideCandidates.push({
+              className,
+              memberName,
+              line,
+              fact: {
+                name: memberName,
+                kind: "method",
+                isStatic: attrText.includes("static"),
+                isHidden: attrText.includes("hidden")
+              }
+            });
+          }
+          frames.push({ owner: className, scope: symName, containerLine: line });
+          break;
+        }
+        case "class_property_definition": {
+          const varNode = findFirstChild(node, "variable");
+          if (!varNode) break;
+          const line = varNode.startPosition.row + 1;
+          const attrText = memberHeaderFacts(node, varNode).modifiers;
+          const className = top().owner;
+          const name = stripDollar(varNode.text);
+          const declared = typeSpecText(node);
+          declareSymbol(name, ASTEngine.SymbolKind.Property, varNode, line, {
+            isStatic: attrText.includes("static"),
+            isHidden: attrText.includes("hidden"),
+            type: declared || "untyped",
+            docstring: this.docstringAbove(varNode.startPosition.row, lines)
+          });
+          if (classMembers.has(className)) {
+            classMembers.get(className).add({
+              name,
+              kind: "property",
+              isStatic: attrText.includes("static"),
+              isHidden: attrText.includes("hidden")
+            });
+          }
+          if (declared && !isTypeAccelerator(declared)) {
+            addRel(className, declared, ASTEngine.RelationshipType.Uses, 0.8, line, {
+              powershellSpecific: true,
+              isTypeReference: true,
+              viaMemberType: name
+            });
+          }
+          break;
+        }
+        // ----------------------------------------------------- assignments
+        case "assignment_expression": {
+          const left = findFirstChild(node, "left_assignment_expression");
+          if (left) {
+            const op = findFirstChild(node, "assignement_operator");
+            const opText = op ? op.text.trim() : "=";
+            if (opText.length > 1) {
+              const lhsVar = findDescendantVariable(left);
+              if (lhsVar) {
+                const lname = stripDollar(lhsVar.text.trim());
+                if (isPlausibleSymbolName(lname) && !isQualified(lhsVar.text) && !isAutomatic(lname)) {
+                  addRel(top().scope, lname, ASTEngine.RelationshipType.Uses, 0.9, lhsVar.startPosition.row + 1, {
+                    powershellSpecific: true,
+                    isVariableReference: true,
+                    isCompoundAssignmentRead: true,
+                    assignmentOperator: opText
+                  });
+                }
+              }
+            }
+          }
+          if (left) {
+            const memberAccess = findDescendant(left, "member_access", 14);
+            const elementAccess = findDescendant(left, "element_access", 14);
+            if (memberAccess || elementAccess) {
+              if (memberAccess) emitMemberUses(memberAccess, "write");
+            } else {
+              const varNode = findDescendantVariable(left);
+              if (varNode && isDeclarableVariable(varNode.text)) {
+                const line = varNode.startPosition.row + 1;
+                declareSymbol(varNode.text, ASTEngine.SymbolKind.Variable, varNode, line, { isVariable: true });
+              }
+            }
+          }
+          const operator = findFirstChild(node, "assignement_operator");
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (!child || child.type === "assignement_operator") continue;
+            if (child.type === "left_assignment_expression") continue;
+            if (child.type !== "pipeline") continue;
+            emitAssignmentReads(child);
+          }
+          break;
+        }
+        // --------------------------------------------------------- foreach
+        case "foreach_statement": {
+          const varNode = findFirstChild(node, "variable");
+          if (varNode && isDeclarableVariable(varNode.text)) {
+            const line = varNode.startPosition.row + 1;
+            declareSymbol(varNode.text, ASTEngine.SymbolKind.Variable, varNode, line, { isLoopVariable: true });
+          }
+          break;
+        }
+        // --------------------------- expression reads (conditions, return/throw)
+        //
+        // A VARIABLE READ IS A READ WHEREVER IT APPEARS, and this lane was reading only
+        // five contexts: assignment right-hand sides, command arguments, string
+        // interpolation, member/element access and the ++/-- family. Conditions and
+        // flow-control statements were not among them, so `if ($x)`, `while ($y)`,
+        // `for (…; $i -lt $n; …)`, `switch ($x)`, `return $z` and `throw $e` published NO
+        // `uses` edge at all. MEASURED on a six-shape reproduction: analyzer 0 reads,
+        // independent oracle 5 (`$x`, `$y`, `$n`, `$z`, `$e`). Over the primary corpus
+        // this is the residue the F5 sample kept naming — `uses -> PID` in a condition, a
+        // `$null` check, a `return $result` — and it is a drop, not a modelling choice:
+        // the same variable in the same position is read whether the statement around it
+        // is an assignment or an `if`.
+        //
+        // Read from the CONDITION WRAPPERS only, and never the statement block: the body
+        // is visited by this same switch, so descending into it here would double-read
+        // every command argument and every interpolated string with a different marker
+        // and lose their per-site attribution (the argument reader's own comment records
+        // what that costs). `for_initializer` and `for_iterator` are deliberately NOT in
+        // the list: the assignment case owns the initializer (and the `$i` there is a
+        // DECLARATION, not a read), and the ++/-- case owns the iterator.
+        // A PIPELINE HEAD IS A READ. `$result4 | Should -Be "x"` reads `$result4`, and
+        // a bare `$Value` statement (`function f { $Value }`, which is how a PowerShell
+        // function RETURNS the parameter) reads it too. Neither is a command: the
+        // `command` branch reads only the ARGUMENTS of a command, so the variable at the
+        // HEAD of a pipeline had no owner in this switch at all. MEASURED on the
+        // ParameterBinding corpus file: nine `$resultN | Should` pipelines plus two bare
+        // `$Value` bodies, 15 MISSING `uses` rows on one file; over the primary corpus
+        // this was the second-largest recipe in the residue (`uses result` 73,
+        // `uses actual` 19, `uses results` 14). A chain that CONTAINS a command is read
+        // by the command branch and is skipped here.
+        case "pipeline_chain": {
+          const hasOwnReader = (n) => {
+            if (n.type === "invokation_expression" || n.type === "post_increment_expression" || n.type === "pre_increment_expression" || n.type === "post_decrement_expression" || n.type === "pre_decrement_expression" || n.type === "sub_expression" || n.type === "expandable_string_literal" || n.type === "expandable_here_string_literal" || n.type === "command") return true;
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c && hasOwnReader(c)) return true;
+            }
+            return false;
+          };
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (!c || c.type === "command" || hasOwnReader(c)) continue;
+            emitVariableReads(c, true, "isPipelineRead");
+          }
+          break;
+        }
+        case "if_statement":
+        case "elseif_clause":
+        case "while_statement":
+        case "do_statement":
+        case "for_statement":
+        case "switch_statement":
+        case "flow_control_statement": {
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (!c) continue;
+            if (c.type === "pipeline" || c.type === "switch_condition" || c.type === "while_condition" || c.type === "for_condition") {
+              emitVariableReads(c, true, "isExpressionRead");
+            }
+          }
+          break;
+        }
+        // ----------------------------- a type literal is a TYPE REFERENCE
+        //
+        // A type named anywhere in an expression is a dependency on that type, and this
+        // analyzer only published one when it happened to sit on a DECLARATION: PS12's
+        // cast branch and the class-property branch. Everything else was invisible —
+        // `$Node -is [Markdig.Syntax.Inlines.LinkInline]`, `@{ Alias = [System.Management.
+        // Automation.AliasAttribute] }`, `[int[]]@(1,2)` in an argument, a type table
+        // written as a hashtable of accelerator -> full type. MEASURED on the primary
+        // corpus: 99 of the 126 truth edges in TypeAccelerator.Tests.ps1 (a file that IS
+        // a table of types) and the single largest MISSING class after the oracle fixes
+        // — 556 `uses string` and 151 `uses System` were the FRAGMENTED spellings of the
+        // same rule, but the whole-name rows were still dropped.
+        //
+        // The exclusions are the positions where the type is DECLARATION METADATA rather
+        // than a reference, and each is a lane rule that already exists:
+        //   · a parameter's type and a class method's RETURN type are stored on the
+        //     symbol (`type:`) and are not separate edges;
+        //   · an ATTRIBUTE's type names the attribute, which the attribute list already
+        //     records as annotations;
+        //   · a cast or class-property type is published by its own branch (above/below),
+        //     at the DECLARATION's site, so reading it here would double the row with a
+        //     different line;
+        //   · the object of `::` is a static call/member, and that edge already names the
+        //     type in full (`System.IO.Path::GetFullPath`), so a second `uses System.IO.
+        //     Path` is the same fact twice — the F5 oracle states the identical rule.
+        case "type_literal": {
+          if (this.withinRecovery(node)) break;
+          let p = node.parent;
+          let metadata = false;
+          for (let d = 0; p && d < 10; d++) {
+            if (p.type === "attribute" || p.type === "script_parameter" || p.type === "class_method_parameter" || p.type === "param_block" || p.type === "class_method_definition") {
+              metadata = true;
+              break;
+            }
+            if (p.type === "statement_list" || p.type === "script_block" || p.type === "program") break;
+            p = p.parent;
+          }
+          if (metadata) break;
+          const parent = node.parent;
+          if (!parent) break;
+          if (parent.type === "cast_expression" || parent.type === "class_property_definition") break;
+          let isStaticObject = false;
+          for (let i = 0; i < parent.childCount; i++) {
+            const c = parent.child(i);
+            if (c && c.startIndex === node.endIndex) {
+              if (c.type === "::" || c.text === "::") isStaticObject = true;
+              break;
+            }
+          }
+          if (isStaticObject) break;
+          const typeName = typeSpecText(node) || this.stripBrackets(node.text);
+          if (!typeName || isTypeAccelerator(typeName)) break;
+          let publishedType = typeName;
+          let viaUsingNamespace = null;
+          if (usingNamespacePrefixes.length > 0 && typeName.indexOf("[") < 0 && typeName.indexOf("]") < 0 && typeName.indexOf(",") < 0) {
+            const dot = typeName.indexOf(".");
+            if (dot > 0) {
+              const rootText = typeName.slice(0, dot);
+              const rootFolded = rootText.toLowerCase();
+              if (rootFolded !== "system" && !typeNamesInFile.has(rootFolded) && !RESOLVED_FRAMEWORK_TYPES.has(rootFolded) && !DOTNET_SYSTEM_NAMESPACES.has(rootFolded)) {
+                for (const prefix of usingNamespacePrefixes) {
+                  const prefixIsSystemRooted = prefix.length > 6 && prefix.charAt(prefix.length - 1) !== "." && (prefix.charCodeAt(0) | 32) === 115 && (prefix.charCodeAt(1) | 32) === 121 && (prefix.charCodeAt(2) | 32) === 115 && (prefix.charCodeAt(3) | 32) === 116 && (prefix.charCodeAt(4) | 32) === 101 && (prefix.charCodeAt(5) | 32) === 109 && prefix.charCodeAt(6) === 46;
+                  if (!prefixIsSystemRooted) continue;
+                  if (!FRAMEWORK_NESTED_NAMESPACES.has(`${prefix}.${rootText}`.toLowerCase())) continue;
+                  publishedType = `${prefix}.${typeName}`;
+                  viaUsingNamespace = prefix;
+                  break;
+                }
+              }
+            }
+          }
+          addRel(top().scope, publishedType, ASTEngine.RelationshipType.Uses, 0.8, node.startPosition.row + 1, {
+            powershellSpecific: true,
+            isTypeReference: true,
+            ...viaUsingNamespace === null ? {} : {
+              viaUsingNamespace,
+              typeSpellingAsWritten: typeName
+            }
+          });
+          break;
+        }
+        // ------------------------------------------- typed declarations (PS12)
+        case "cast_expression": {
+          const typeLit = findFirstChild(node, "type_literal");
+          const target = findFirstChild(node, "unary_expression");
+          const varNode = target ? findFirstChild(target, "variable") : null;
+          if (!varNode) {
+            const castType = typeLit ? typeSpecText(node) : "";
+            if (castType && !isTypeAccelerator(castType)) {
+              addRel(top().scope, castType, ASTEngine.RelationshipType.Uses, 0.8, typeLit.startPosition.row + 1, {
+                powershellSpecific: true,
+                isTypeReference: true,
+                isCastExpression: true
+              });
+            }
+            break;
+          }
+          if (!isDeclarableVariable(varNode.text)) break;
+          const line = varNode.startPosition.row + 1;
+          const declared = typeSpecText(node);
+          declareSymbol(varNode.text, ASTEngine.SymbolKind.Variable, varNode, line, {
+            isVariable: true,
+            isTypedDeclaration: true,
+            type: declared || "untyped",
+            ...this.allAttributeTexts(node).length > 0 ? { annotations: this.allAttributeTexts(node) } : {}
+          });
+          if (declared && !isTypeAccelerator(declared)) {
+            addRel(top().scope, declared, ASTEngine.RelationshipType.Uses, 0.8, line, {
+              powershellSpecific: true,
+              isTypeReference: true
+            });
+          }
+          break;
+        }
+        case "unary_expression":
+        case "expression_with_unary_operator": {
+          const typeLit = findFirstChild(node, "type_literal");
+          const varNode = findFirstChild(node, "variable");
+          if (!typeLit || !varNode || !isDeclarableVariable(varNode.text)) break;
+          const line = varNode.startPosition.row + 1;
+          const declared = typeSpecText(node);
+          declareSymbol(varNode.text, ASTEngine.SymbolKind.Variable, varNode, line, {
+            isVariable: true,
+            type: declared || "untyped"
+          });
+          if (declared && !TYPE_ACCELERATORS.has(declared)) {
+            addRel(top().scope, declared, ASTEngine.RelationshipType.Uses, 0.8, line, {
+              powershellSpecific: true,
+              isTypeReference: true
+            });
+          }
+          break;
+        }
+        // ------------------------------------------------- hashtable (PS15)
+        case "hash_entry": {
+          const keyNode = findFirstChild(node, "key_expression");
+          if (!keyNode) break;
+          const keyName = keyNode.text;
+          if (!keyName) break;
+          let quoted = false;
+          let interpolating = false;
+          if (keyName.length >= 2) {
+            const q = keyName.charCodeAt(0);
+            if ((q === 34 || q === 39) && keyName.charCodeAt(keyName.length - 1) === q) {
+              quoted = true;
+              const inner = keyName.slice(1, -1);
+              if (q === 34 && inner.includes("$")) interpolating = true;
+            }
+          }
+          if (quoted) {
+            if (interpolating) break;
+          } else if (keyName.includes("$") || keyName.includes(" ")) break;
+          const line = keyNode.startPosition.row + 1;
+          declareSymbol(keyName, ASTEngine.SymbolKind.Property, keyNode, line, {
+            isHashtableKey: true,
+            type: "untyped"
+          });
+          break;
+        }
+        // ------------------------------------------------ member reads (PS9)
+        case "member_access": {
+          emitMemberUses(node, "read");
+          break;
+        }
+        case "element_access": {
+          const keyRoot = node.namedChildCount > 1 ? node.namedChild(1) : null;
+          if (!keyRoot) break;
+          const idx = findDescendant(keyRoot, "string_literal", 12) ?? findDescendant(keyRoot, "variable", 12) ?? findDescendant(keyRoot, "integer_literal", 12) ?? findDescendant(keyRoot, "real_literal", 12);
+          if (!idx) break;
+          const idxLine = idx.startPosition.row + 1;
+          if (idx.type === "string_literal") {
+            const key = this.stripQuotes(idx.text);
+            if (key && !key.includes("$")) {
+              addRel(top().scope, key, ASTEngine.RelationshipType.Uses, 0.8, idxLine, {
+                powershellSpecific: true,
+                isElementAccess: true,
+                isConstantKey: true
+              });
+            }
+          } else if (idx.type === "variable") {
+            addRel(top().scope, stripDollar(idx.text), ASTEngine.RelationshipType.Uses, 0.9, idxLine, {
+              powershellSpecific: true,
+              isElementAccess: true,
+              isVariableReference: true
+            });
+          }
+          break;
+        }
+        // ------------------------------- interpolation (PS16, the groovy G7)
+        case "sub_expression": {
+          const inner = node.namedChildCount > 0 ? node.namedChild(0) : null;
+          if (inner) emitVariableReads(inner);
+          break;
+        }
+        case "expandable_string_literal": {
+          emitVariableReads(node);
+          break;
+        }
+        // F9: an INCREMENT or DECREMENT reads its operand. `$n++` / `++$n` are the
+        // one remaining place a variable is read and nothing was published — the F9
+        // audit found these four types in the "the analyzer never names it" set, and
+        // probing them confirmed all four emit nothing at all, so `$n++` left the
+        // graph with `contains -> n` and no read.
+        //
+        // A `uses` is the right edge and not a weaker one: the operand is genuinely
+        // read, and the WRITE half has no edge in this lane's model because a write to
+        // a local is not a fact the graph can express (a member write can, which is
+        // what `isMemberWrite` is for). The metadata says which operation it was so a
+        // reader is not left guessing, and so a fixture can pin the distinction.
+        case "post_increment_expression":
+        case "post_decrement_expression":
+        case "pre_increment_expression":
+        case "pre_decrement_expression": {
+          const operand = findDescendant(node, "variable", 6);
+          if (operand) {
+            const name = stripDollar(operand.text.trim());
+            if (isPlausibleSymbolName(name) && !isQualified(operand.text) && !isAutomatic(name)) {
+              addRel(top().scope, name, ASTEngine.RelationshipType.Uses, 0.9, operand.startPosition.row + 1, {
+                powershellSpecific: true,
+                isVariableReference: true,
+                isCounterUpdate: true,
+                isPostfix: node.type.startsWith("post_")
+              });
+            }
+          }
+          break;
+        }
+        case "expandable_here_string_literal": {
+          emitVariableReads(node, false, "isHereStringInterpolation");
+          break;
+        }
+        // ---------------------------------------- invocation (PS17/PS18/PS19)
+        case "invokation_expression": {
+          const typeLit = findFirstChild(node, "type_literal");
+          const member = findFirstChild(node, "member_name");
+          const line = (member ?? typeLit ?? node).startPosition.row + 1;
+          const argList = findFirstChild(node, "argument_list");
+          if (argList) emitVariableReads(argList, true, "isArgumentReference");
+          if (typeLit) {
+            const typeName = typeSpecText(node) || this.stripBrackets(typeLit.text);
+            if (!typeName) break;
+            const memberName = member?.text ?? "";
+            if (isNewSpelling(memberName)) {
+              addRel(top().scope, typeName, ASTEngine.RelationshipType.Instantiates, 0.9, line, {
+                powershellSpecific: true,
+                dotNetNew: true
+              });
+            } else if (memberName) {
+              addRel(top().scope, `${typeName}.${memberName}`, ASTEngine.RelationshipType.Calls, 0.8, line, {
+                powershellSpecific: true,
+                staticMemberCall: true,
+                staticType: typeName
+              });
+            }
+            break;
+          }
+          const receiver = findFirstChild(node, "variable");
+          if (member) {
+            const dynamicTarget = member.text.length > 0 && member.text.charCodeAt(0) === 36;
+            if (dynamicTarget) {
+              const dynName = stripDollar(member.text);
+              if (isPlausibleSymbolName(dynName)) {
+                addRel(top().scope, dynName, ASTEngine.RelationshipType.Uses, 0.9, member.startPosition.row + 1, {
+                  powershellSpecific: true,
+                  isDynamicMethodTarget: true,
+                  isVariableReference: true
+                });
+              }
+              break;
+            }
+            addRel(top().scope, member.text, ASTEngine.RelationshipType.Calls, 0.6, line, {
+              powershellSpecific: true,
+              methodCall: true,
+              on: receiver ? stripDollar(receiver.text) : ""
+            });
+            if (receiver) {
+              const name = stripDollar(receiver.text);
+              if (name && !isQualified(receiver.text) && !isAutomatic(name)) {
+                addRel(top().scope, name, ASTEngine.RelationshipType.Uses, 0.9, receiver.startPosition.row + 1, {
+                  powershellSpecific: true,
+                  isReceiverReference: true,
+                  isVariableReference: true
+                });
+              }
+            }
+          }
+          break;
+        }
+        // ------------------------------------------------------- commands
+        case "command": {
+          const cmdNameNode = findFirstChild(node, "command_name");
+          if (cmdNameNode && this.nameWithinRecovery(cmdNameNode)) break;
+          const cmdName = commandNameOf(node);
+          if (!cmdName) break;
+          const leaf = cmdName.includes("::") ? cmdName.slice(cmdName.lastIndexOf("::") + 2) : cmdName;
+          const lowerLeaf = leaf.toLowerCase();
+          const nameLine = (findFirstChild(node, "command_name") ?? node).startPosition.row + 1;
+          if (lowerLeaf === "interface") {
+            const ifaceElements = findFirstChild(node, "command_elements");
+            const ifaceBlock = ifaceElements ? findDescendant(ifaceElements, "script_block_expression") : null;
+            const ifaceName = ifaceElements ? this.collectChildrenByType(ifaceElements, "generic_token")[0] ?? null : null;
+            if (ifaceBlock && ifaceName) {
+              const ifaceLine = ifaceName.startPosition.row + 1;
+              declareSymbol(ifaceName.text, ASTEngine.SymbolKind.Interface, ifaceName, ifaceLine, {
+                powershellSpecific: true,
+                docstring: this.docstringAbove(ifaceName.startPosition.row, lines)
+              });
+              interfaceBlocks.add(nodeKey(node));
+              frames.push({ owner: ifaceName.text, scope: ifaceName.text, containerLine: ifaceLine });
+            }
+            break;
+          }
+          if (NAMED_BLOCK_KEYWORDS.has(lowerLeaf)) break;
+          if (FLOW_KEYWORDS.has(lowerLeaf)) break;
+          if (LANGUAGE_KEYWORD_COMMANDS.has(lowerLeaf)) break;
+          const elements = findFirstChild(node, "command_elements");
+          const blockArg = elements ? findDescendant(elements, "script_block_expression") : null;
+          const firstToken = elements ? this.collectChildrenByType(elements, "generic_token")[0] ?? null : null;
+          const isAssignmentForm = !!firstToken && firstToken.text === "=";
+          if (DSC_KEYWORDS.has(lowerLeaf) && blockArg) {
+            const declared = elements && elements.namedChildCount > 1 ? elements.namedChild(1) : null;
+            if (lowerLeaf === "configuration" && declared && declared.type === "generic_token") {
+              const line = declared.startPosition.row + 1;
+              declareSymbol(declared.text, ASTEngine.SymbolKind.Class, declared, line, { isDscConfiguration: true });
+              dscDepth++;
+              dscBlocks.add(nodeKey(node));
+              dscOwner.set(nodeKey(node), declared.text);
+              frames.push({ owner: declared.text, scope: declared.text, containerLine: line });
+            }
+            break;
+          }
+          if (dscDepth > 0) {
+            if (blockArg && firstToken && firstToken.type === "generic_token") {
+              const line = firstToken.startPosition.row + 1;
+              declareSymbol(firstToken.text, ASTEngine.SymbolKind.Class, firstToken, line, {
+                isDscResource: true,
+                dscResourceType: leaf
+              });
+              dscDepth++;
+              dscBlocks.add(nodeKey(node));
+              dscOwner.set(nodeKey(node), firstToken.text);
+              frames.push({ owner: firstToken.text, scope: firstToken.text, containerLine: line });
+              break;
+            }
+            if (isAssignmentForm) {
+              declareSymbol(leaf, ASTEngine.SymbolKind.Property, node, nameLine, { isDscProperty: true });
+              break;
+            }
+            break;
+          }
+          const op = findFirstChild(node, "command_invokation_operator");
+          if (op) {
+            const target = unquoteTarget(leaf);
+            if (looksLikeModulePath(target)) {
+              const part = sourcedPartName(target);
+              if (op.text === "." && part !== null) {
+                addRel(top().scope, part, ASTEngine.RelationshipType.PartOf, 0.9, nameLine, {
+                  powershellSpecific: true,
+                  invokationOperator: op.text,
+                  // MANDATORY on every `part_of` row (src/ast/types.ts:170-183): this
+                  // file carries the directive and names the part, so it is the
+                  // library side of the pair. A dot-sourced file does not know it is
+                  // being sourced, so PowerShell has only the one role.
+                  partRole: "library",
+                  partPath: target
+                });
+              } else {
+                addRel(top().scope, target, ASTEngine.RelationshipType.Calls, 0.9, nameLine, {
+                  powershellSpecific: true,
+                  invokationOperator: op.text
+                });
+              }
+            } else if (target.startsWith("$")) {
+              const invoked = stripDollar(target);
+              if (isPlausibleSymbolName(invoked)) {
+                addRel(top().scope, invoked, ASTEngine.RelationshipType.Uses, 0.9, nameLine, {
+                  powershellSpecific: true,
+                  isInvokedVariable: true,
+                  isVariableReference: true
+                });
+              }
+            } else if (target.length > 0 && isPlausibleSymbolName(target)) {
+              addRel(top().scope, target, ASTEngine.RelationshipType.Calls, 0.9, nameLine, {
+                powershellSpecific: true,
+                invokationOperator: op.text
+              });
+            }
+            break;
+          }
+          detectFrameworks(leaf);
+          if (leaf === "Import-Module" || leaf === "ipmo") {
+            const argNodes = [];
+            const args = commandArgs(node, argNodes, IMPORT_MODULE_MODULE_PARAMETERS);
+            for (let ai = 0; ai < args.length; ai++) {
+              const arg = args[ai];
+              if (SWITCH_ARGUMENT_VALUES.has(arg.toLowerCase())) continue;
+              const argNode = argNodes[ai];
+              if (argNode && nodeIsAVariableReference(argNode)) continue;
+              addImport(arg, leaf, nameLine, node);
+            }
+            const argElementsRead = findFirstChild(node, "command_elements");
+            if (argElementsRead) emitVariableReads(argElementsRead, true, "isArgumentReference");
+            break;
+          }
+          if (leaf === "New-Object") {
+            const comObjectOut = { node: null };
+            const typeNameOut = { node: null };
+            const comObject = this.parameterValue(node, "ComObject", comObjectOut) ?? this.parameterValue(node, "comobject", comObjectOut);
+            const typeName = this.parameterValue(node, "TypeName", typeNameOut) ?? this.parameterValue(node, "typename", typeNameOut);
+            const positionalNodes = [];
+            const positional = commandArgs(node, positionalNodes)[0];
+            const constructed = comObject ?? typeName ?? positional;
+            const constructedFrom = comObject ? comObjectOut.node : typeName ? typeNameOut.node : positionalNodes[0] ?? null;
+            if (constructed && !isTypeAccelerator(constructed)) {
+              if (constructedFrom && nodeIsAVariableReference(constructedFrom)) {
+                addRel(top().scope, constructed, ASTEngine.RelationshipType.Uses, 0.9, nameLine, {
+                  powershellSpecific: true,
+                  viaNewObject: true,
+                  isDynamicTypeName: true,
+                  isVariableReference: true
+                });
+              } else {
+                addRel(top().scope, constructed, ASTEngine.RelationshipType.Instantiates, 0.9, nameLine, {
+                  powershellSpecific: true,
+                  viaNewObject: true,
+                  ...comObject ? { isComObject: true } : {}
+                });
+              }
+            }
+            break;
+          }
+          if (leaf === "Export-ModuleMember") {
+            const elements2 = findFirstChild(node, "command_elements");
+            if (elements2) {
+              const isFlag = (t) => t === "function" || t === "cmdlet" || t === "variable" || t === "alias";
+              for (let i = 0; i < elements2.namedChildCount; i++) {
+                const c = elements2.namedChild(i);
+                if (!c) continue;
+                if (c.type === "command_parameter") {
+                  const flag = stripLeadingDash(stripDollar(c.text)).toLowerCase();
+                  if (!isFlag(flag)) continue;
+                  const via = `-${flag}`;
+                  for (let j = i + 1; j < elements2.namedChildCount; j++) {
+                    const v = elements2.namedChild(j);
+                    if (!v) break;
+                    if (v.type === "command_parameter") break;
+                    if (v.type === "command_argument_sep") continue;
+                    if (v.type === "generic_token" || v.type === "string_literal" || v.type === "expandable_string_literal") {
+                      addExport(this.stripQuotes(v.text), via, v.startPosition.row + 1);
+                    } else {
+                      for (const t of this.literalTokens(v)) addExport(t, via, v.startPosition.row + 1);
+                    }
+                  }
+                  continue;
+                }
+                if (c.type === "array_literal_expression" || c.type === "unary_expression" || c.type === "command_argument_sep" || c.type === "string_literal" || c.type === "generic_token") {
+                  for (const t of this.literalTokens(c)) addExport(t, leaf, c.startPosition.row + 1);
+                }
+              }
+            }
+            break;
+          }
+          if (lowerLeaf === "using") {
+            const args = commandArgs(node);
+            if (args.length >= 2) {
+              const directive = args[0].toLowerCase();
+              addImport(args[1], directive === "namespace" ? "using namespace" : "using module", nameLine, node);
+            }
+            break;
+          }
+          const argElements = findFirstChild(node, "command_elements");
+          if (argElements) emitVariableReads(argElements, true, "isArgumentReference");
+          addRel(top().scope, leaf, ASTEngine.RelationshipType.Calls, leaf.includes("-") ? 0.9 : 0.6, nameLine, {
+            powershellSpecific: true
+          });
+          break;
+        }
+        // ------------------------------------------------------- comments
+        case "comment": {
+          const text = node.text;
+          if (text.startsWith("#requires") || text.startsWith("#Requires")) {
+            const line = node.startPosition.row + 1;
+            const moduleNames = this.extractRequiresModules(text);
+            for (const m of moduleNames) addImport(m.name, m.via, line, node);
+            const version = this.extractRequiresValue(text, "version");
+            let versionShaped = !!version;
+            let versionDots = 0;
+            for (let vi = 0; versionShaped && vi < version.length; vi++) {
+              const ch = version.charCodeAt(vi);
+              if (ch === 46) {
+                versionDots++;
+                continue;
+              }
+              if (ch < 48 || ch > 57) versionShaped = false;
+            }
+            if (version && versionShaped && versionDots >= 1) {
+              addRel(top().scope, version, ASTEngine.RelationshipType.References, 0.9, line, {
+                powershellSpecific: true,
+                requiresVersion: true,
+                fileLevel: atFileScope()
+              });
+            }
+          }
+          break;
+        }
+      }
+      for (let i = node.childCount - 1; i >= 0; i--) {
+        const child = node.child(i);
+        if (child) work.push({ node: child, exit: false });
+      }
+    }
+    for (const cand of overrideCandidates) {
+      let baseWritten = baseClassByClass.get(cand.className);
+      let guard = 0;
+      while (baseWritten && guard++ < 8) {
+        const base = classDeclaredSpelling.get(baseWritten.toLowerCase()) ?? baseWritten;
+        const inherited = classMembers.get(base);
+        const wanted = cand.memberName.toLowerCase();
+        const inheritedFact = inherited ? [...inherited].find((m) => m.name.toLowerCase() === wanted) : void 0;
+        if (inheritedFact && memberOverrides(cand.fact, inheritedFact)) {
+          addRel(cand.className, base, ASTEngine.RelationshipType.Overrides, 0.9, cand.line, {
+            powershellSpecific: true,
+            overridesMember: cand.memberName,
+            // The one edge in this lane that is INFERRED rather than read: PowerShell
+            // has no `override` keyword, so this is a name match between a subclass
+            // member and the base's declared member set. Calling it `structural` would
+            // overstate the evidence, and the tier is the whole point of emitting one.
+            evidenceClass: "inferred"
+          });
+          break;
+        }
+        baseWritten = baseClassByClass.get(base) ?? baseClassByClass.get(baseWritten);
+      }
+    }
+    const declaredFolded = /* @__PURE__ */ new Set();
+    const declaredQualified = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      declaredFolded.add(s.name.toLowerCase());
+      const sc = s.scope;
+      if (typeof sc === "string" && sc.length > 0) declaredQualified.add(`${sc}.${s.name}`.toLowerCase());
+    }
+    const declaredInFile = (name) => declaredFolded.has(name.toLowerCase()) || declaredQualified.has(name.toLowerCase());
+    const foldedValueSpellings = /* @__PURE__ */ new Map();
+    for (const sym of symbols) {
+      const kind = String(sym.kind ?? "");
+      if (kind !== "variable" && kind !== "property" && kind !== "parameter") continue;
+      if (!sym.name) continue;
+      const key = sym.name.toLowerCase();
+      let set = foldedValueSpellings.get(key);
+      if (!set) foldedValueSpellings.set(key, set = /* @__PURE__ */ new Set());
+      set.add(sym.name);
+    }
+    for (const rel of relationships) {
+      if (rel.type !== ASTEngine.RelationshipType.Uses) continue;
+      const md = rel.metadata;
+      if (!md) continue;
+      if (md.isVariableReference !== true && md.isMemberAccess !== true && md.isMemberReference !== true) continue;
+      const t = String(rel.target ?? "");
+      if (t.length === 0 || t.indexOf(".") >= 0 || t.indexOf(":") >= 0) continue;
+      if (declaredFolded.has(t.toLowerCase()) && symbols.some((sym) => sym.name === t)) continue;
+      const spellings = foldedValueSpellings.get(t.toLowerCase());
+      if (spellings === void 0 || spellings.size !== 1) continue;
+      const declared = [...spellings][0];
+      if (declared === t) continue;
+      rel.target = declared;
+      md.caseFoldedTo = declared;
+      md.powershellCaseFolded = true;
+    }
+    const ownedByThisFile = (name) => {
+      const dot = name.lastIndexOf(".");
+      if (dot <= 0) return false;
+      return declaredInFile(name.slice(0, dot));
+    };
+    {
+      const variablesByName = /* @__PURE__ */ new Map();
+      const qnOccurrences = /* @__PURE__ */ new Map();
+      for (const s of symbols) {
+        const scope = String(s.scope ?? "");
+        const qn = scope.length > 0 ? `${scope}.${s.name}` : String(s.name);
+        qnOccurrences.set(qn, (qnOccurrences.get(qn) ?? 0) + 1);
+        if (s.kind !== ASTEngine.SymbolKind.Variable) continue;
+        const key = String(s.name).toLowerCase();
+        const list = variablesByName.get(key) ?? [];
+        list.push({ qn, scope, name: String(s.name) });
+        variablesByName.set(key, list);
+      }
+      for (const rel of relationships) {
+        if (rel.type !== ASTEngine.RelationshipType.Uses) continue;
+        if (rel.metadata?.isVariableReference !== true) continue;
+        const target = String(rel.target ?? "");
+        if (target.length === 0) continue;
+        let isBareIdentifier = true;
+        for (let i = 0; i < target.length; i++) {
+          const c = target.charCodeAt(i);
+          if (c === 46 || c === 58 || c === 36 || c === 91 || c === 93 || c === 40 || c === 41) {
+            isBareIdentifier = false;
+            break;
+          }
+        }
+        if (!isBareIdentifier) continue;
+        const source = String(rel.source ?? "");
+        const visible = (variablesByName.get(target.toLowerCase()) ?? []).filter(
+          (c) => c.scope.length === 0 || source === c.scope || source.startsWith(`${c.scope}.`)
+        );
+        if (visible.length !== 1) continue;
+        const hit = visible[0];
+        if ((qnOccurrences.get(hit.qn) ?? 0) !== 1) continue;
+        rel.target = hit.qn;
+        const md = rel.metadata ?? (rel.metadata = {});
+        md.referencedName = target;
+        md.boundToVariable = true;
+      }
+    }
+    for (const rel of relationships) {
+      const target = rel.target;
+      if (target == null || target.length === 0) continue;
+      if (rel.metadata?.boundToVariable === true) continue;
+      const staticMeta = rel.metadata ?? {};
+      if (staticMeta.staticMemberCall === true && typeof staticMeta.staticType === "string") {
+        const declaredOwner = classMembersOf(classMembers, staticMeta.staticType);
+        const memberLeafRaw = target.slice(target.lastIndexOf(".") + 1);
+        const memberLeaf = memberLeafRaw.toLowerCase();
+        if (declaredOwner) {
+          const declaredMember = [...declaredOwner.members].find((m) => m.name.toLowerCase() === memberLeaf);
+          if (declaredMember) {
+            rel.target = `${declaredOwner.name}.${declaredMember.name}`;
+            continue;
+          }
+          rel.metadata.ownerMemberAbsent = { owner: declaredOwner.name, member: memberLeafRaw };
+          continue;
+        }
+        const resolvedType = RESOLVED_FRAMEWORK_TYPES.get(staticMeta.staticType.toLowerCase());
+        if (resolvedType !== void 0) {
+          rel.target = `${resolvedType}.${memberLeafRaw}`;
+          const resolvedMeta = rel.metadata ?? (rel.metadata = {});
+          resolvedMeta.staticTypeResolved = resolvedType;
+          resolvedMeta.typeAccelerator = staticMeta.staticType;
+          continue;
+        }
+        if (staticMeta.staticType.indexOf(".") > 0) {
+        } else {
+          rel.metadata.ownerMemberAbsent = { owner: staticMeta.staticType, member: memberLeafRaw };
+          continue;
+        }
+      }
+      const type = rel.type;
+      if (declaredInFile(target)) continue;
+      if (ownedByThisFile(target)) {
+        if (type === ASTEngine.RelationshipType.Calls || type === ASTEngine.RelationshipType.Uses) {
+          rel.metadata.noDeclarationInFile = true;
+        }
+        continue;
+      }
+      const runtime = runtimeVariableTarget(target);
+      let hasLetter = false;
+      for (let i = 0; i < target.length; i++) {
+        const c = target.charCodeAt(i);
+        if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
+          hasLetter = true;
+          break;
+        }
+      }
+      let keyHasPathByte = false;
+      for (let i = 0; i < target.length; i++) {
+        const c = target.charCodeAt(i);
+        if (c === 47 || c === 92) {
+          keyHasPathByte = true;
+          break;
+        }
+      }
+      const isQuotedMemberNameWithDot = rel.metadata?.isQuotedMemberName === true && target.indexOf(".") > 0;
+      const isDataNameKey = rel.metadata?.isConstantKey === true && !keyHasPathByte || isQuotedMemberNameWithDot;
+      const programName = rel.type === ASTEngine.RelationshipType.Calls && isCommandPositionCall(rel) ? programNameOf(target) : null;
+      if (programName !== null) {
+        rel.metadata.sourcePathClaim = [programName];
+        continue;
+      }
+      let runtimeCreatedType = false;
+      if (addTypeCreatedNames.size > 0 && (rel.type === ASTEngine.RelationshipType.Instantiates || rel.type === ASTEngine.RelationshipType.Uses)) {
+        const typeDot = target.indexOf(".");
+        const typeRoot = (typeDot > 0 ? target.slice(0, typeDot) : target).toLowerCase();
+        runtimeCreatedType = addTypeCreatedNames.has(typeRoot) || addTypeCreatedNames.has(target.toLowerCase());
+      }
+      let callIntoCompiledType = false;
+      if (addTypeDeclarations.size > 0 && rel.type === ASTEngine.RelationshipType.Calls) {
+        const callDot = target.lastIndexOf(".");
+        if (callDot > 0) {
+          callIntoCompiledType = addTypeDeclarations.has(target.slice(0, callDot).toLowerCase());
+        }
+      }
+      let runtimeBindingRead = false;
+      if (rel.type === ASTEngine.RelationshipType.Uses && rel.metadata?.isVariableReference === true) {
+        if (target.length > 0 && target.indexOf(".") < 0 && target.indexOf(":") < 0 && target.charCodeAt(0) !== 36) {
+          runtimeBindingRead = true;
+        }
+      }
+      const via = isDataNameKey || runtime !== null || runtimeCreatedType || callIntoCompiledType || !hasLetter ? null : externalReadingOf(target) ?? (isCommandPositionCall(rel) ? commandReadingOf(target) : null) ?? (runtimeBindingRead ? "runtime-binding" : null);
+      if (via) {
+        rel.metadata.externalTarget = true;
+        rel.metadata.externalVia = via;
+        if (via === "runtime-binding") rel.metadata.noDeclarationInFile = true;
+        const moduleName = moduleQualifiedCommandOf(target);
+        if (moduleName !== null) {
+          rel.metadata.externalReason = "module-namespace";
+          rel.metadata.externalSpecifier = moduleName;
+        }
+        if (arbiterCanCheckOwner(target)) rel.metadata.isExternalTarget = true;
+        continue;
+      }
+      if (type === ASTEngine.RelationshipType.Calls || type === ASTEngine.RelationshipType.Uses) {
+        rel.metadata.noDeclarationInFile = true;
+      }
+    }
+    const detectedPatterns = [...patterns];
+    const detectedFrameworks = [...frameworks];
+    const psDeclaredHere = /* @__PURE__ */ new Set();
+    for (const sym of symbols) {
+      if (sym.name) psDeclaredHere.add(sym.name);
+      const q = sym.qualifiedName;
+      if (typeof q === "string" && q.length > 0) psDeclaredHere.add(q);
+    }
+    let psNamespaceClaims = 0;
+    let psShorthandClaims = 0;
+    for (const rel of relationships) {
+      if (rel.type !== ASTEngine.RelationshipType.Uses && rel.type !== ASTEngine.RelationshipType.Calls && rel.type !== ASTEngine.RelationshipType.Instantiates) continue;
+      const tgt = String(rel.target ?? "");
+      const md = rel.metadata;
+      if (!md || typeof md !== "object") continue;
+      if (md.isExternal === true) continue;
+      let roots = null;
+      const envRoot = envProviderRootOf(tgt);
+      const usingRoot = usingScopeRootOf(tgt);
+      if (tgt === "System" || tgt.startsWith("System.")) roots = ["System"];
+      else if (envRoot !== null) roots = [envRoot];
+      else if (usingRoot !== null) roots = [usingRoot];
+      else if (md.dotNetNew === true) {
+        const shorthand = dotNetShorthandRootOf(tgt);
+        if (shorthand !== null) {
+          roots = [shorthand];
+          if (psDeclaredHere.has(tgt)) roots = null;
+        }
+      }
+      if (roots === null) continue;
+      if (psDeclaredHere.has(tgt)) continue;
+      md.languageNamespace = roots;
+      if (roots[0] === "System") psNamespaceClaims++;
+      else psShorthandClaims++;
+    }
+    return {
+      language: "powershell",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors: [],
+      // engine-owned syntax errors (engine.ts merges treeErrors)
+      metadata: {
+        complexity: symbols.length + relationships.length,
+        linesOfCode: lines.length,
+        cyclomaticComplexity,
+        framework: detectedFrameworks[0],
+        patterns: detectedPatterns,
+        detectedFrameworks,
+        frameworkPatterns: detectedPatterns.map((p) => ({
+          framework: "PowerShell",
+          patterns: [{ type: "usage", detected: true, description: p }]
+        })),
+        architecturalInsights: [],
+        architecturalScore: Math.min(100, 60 + relationships.length),
+        codeQuality: "Excellent",
+        hasTypeInference: false,
+        hasFrameworkIntelligence: true,
+        analysisVersion: "6.0-ps-file-owner-lines-scope-reads"
+      }
+    };
+  }
+  // ------------------------------------------------------------- helpers
+  /** PS1 — the file's own basename, extension included. */
+  basenameOf(filePath) {
+    const normalized = filePath.split("\\").join("/");
+    const base = normalized.slice(normalized.lastIndexOf("/") + 1);
+    return base.length > 0 ? base : "script.ps1";
+  }
+  lineRange(line) {
+    return {
+      startLine: line,
+      startColumn: 1,
+      endLine: line,
+      endColumn: 1,
+      startIndex: 0,
+      endIndex: 0
+    };
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+  collectChildrenByType(node, type) {
+    const results = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === type) results.push(child);
+    }
+    return results;
+  }
+  stripQuotes(text) {
+    if (text.length >= 2) {
+      const first = text.charCodeAt(0);
+      const last = text.charCodeAt(text.length - 1);
+      if ((first === 34 || first === 39) && last === first) return text.slice(1, -1);
+    }
+    return text;
+  }
+  stripBrackets(text) {
+    if (text.length >= 2 && text.charCodeAt(0) === 91 && text.charCodeAt(text.length - 1) === 93) {
+      return text.slice(1, -1);
+    }
+    return text;
+  }
+  findQuoted(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      if (child.type === "string_literal" || child.type === "expandable_string_literal") return child;
+      const nested = this.findQuoted(child);
+      if (nested) return nested;
+    }
+    return null;
+  }
+  /**
+   * PS6 — is this node inside a recovery region? A `command` whose name lives
+   * under an ERROR/MISSING node is recovery noise, not a call. bash BD5
+   * established the rule; this lane needed it because its own
+   * `if`-as-expression shape manufactures `command` nodes out of an ERROR
+   * region with `hasError = false`.
+   */
+  withinRecovery(node) {
+    const st = [node];
+    while (st.length > 0) {
+      const x = st.pop();
+      if (x.type === "ERROR" || x.isMissing) return true;
+      for (let i = 0; i < x.childCount; i++) {
+        const c = x.child(i);
+        if (c) st.push(c);
+      }
+    }
+    return false;
+  }
+  /**
+   * PS6 — does this NAME live inside a recovery region?
+   *
+   * The command branch needs the ANCESTOR question, not the subtree one, because
+   * PS6's wording is about where the name sits: a `command` reconstructed from a
+   * broken line keeps a clean name token and a clean subtree, accompanied by an
+   * ERROR sibling, so a subtree test passes it. The one exemption is the
+   * whole-file wrapper: the grammar wraps a CmdletBinding function's body in one
+   * ERROR node covering the entire file, and the commands inside it are real
+   * (MethodInvocation.Tests.ps1; the oracle expects them).
+   */
+  nameWithinRecovery(node) {
+    let top = node;
+    while (top.parent) top = top.parent;
+    const topEnd = top.endIndex;
+    let n = node.parent;
+    let d = 0;
+    while (n && d < 24) {
+      if (n.type === "ERROR" || n.isMissing) {
+        const wholeFile = n.startIndex === 0 && n.endIndex === topEnd;
+        if (!wholeFile) return true;
+      }
+      n = n.parent;
+      d++;
+    }
+    return false;
+  }
+  /** The value of a two-token parameter (`-TypeName Foo`) or `-Name:Foo`. */
+  parameterValue(node, flag, out) {
+    const elements = this.findChildByType(node, "command_elements");
+    if (!elements) return null;
+    const wanted = stripLeadingDash(flag).toLowerCase();
+    for (let i = 0; i < elements.namedChildCount; i++) {
+      const c = elements.namedChild(i);
+      if (!c || c.type !== "command_parameter") continue;
+      if (stripLeadingDash(this.stripQuotes(c.text)).toLowerCase() !== wanted) continue;
+      const next = this.valueAfterNode(elements, i);
+      if (next && (next.type === "generic_token" || next.type === "string_literal" || next.type === "expandable_string_literal")) {
+        if (out) out.node = next;
+        return this.stripQuotes(next.text);
+      }
+    }
+    return null;
+  }
+  /**
+   * The value token that FOLLOWS the named child at `fromIndex`, skipping the
+   * grammar's `command_argument_sep` separators.
+   *
+   * This is the whole of the two-token parameter form, and reading
+   * `namedChild(i + 1)` instead is the whole bug: measured shape for
+   * `Import-Module -Name SqlServer -ErrorAction SilentlyContinue` is
+   * `[sep, command_parameter(-Name), sep, generic_token(SqlServer), sep,
+   * command_parameter(-ErrorAction), sep, generic_token(SilentlyContinue)]`, so
+   * the value sits at `i + 3`. Every `i + 1` read found a separator, matched no
+   * branch, and read NO two-token parameter value anywhere in the language.
+   * Also worth recording: this grammar gives `command_parameter` NO `argument`
+   * field, so a probe for one could only ever return null.
+   */
+  valueAfterNode(elements, fromIndex) {
+    for (let i = fromIndex + 1; i < elements.namedChildCount; i++) {
+      const c = elements.namedChild(i);
+      if (!c) continue;
+      if (c.type === "command_argument_sep") continue;
+      return c;
+    }
+    return null;
+  }
+  /** Every bare string/number token under a node, in source order. */
+  literalTokens(node) {
+    const out = [];
+    const work = [node];
+    while (work.length > 0) {
+      const n = work.pop();
+      if (n.type === "string_literal" || n.type === "expandable_string_literal" || n.type === "generic_token") {
+        out.push(this.stripQuotes(n.text));
+        continue;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) work.push(c);
+      }
+    }
+    return out.reverse();
+  }
+  findChildByType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === type) return child;
+    }
+    return null;
+  }
+  findParamList(node) {
+    const block = this.findChildByType(node, "script_block");
+    if (block) {
+      const paramBlock = this.findChildByType(block, "param_block");
+      if (paramBlock) return this.findChildByType(paramBlock, "parameter_list");
+    }
+    return null;
+  }
+  findMethodParamList(node) {
+    const paramDecl = this.findChildByType(node, "class_method_parameter_list");
+    if (!paramDecl) return null;
+    return this.findChildByType(paramDecl, "parameter_list") ?? paramDecl;
+  }
+  // PS27 REMOVED: `classAttributeTexts` had no callers left. It collected EVERY
+  // `class_attribute` on a class member, which is correct for a member and wrong
+  // for the pinned wasm's split — where one of those nodes is the front of the
+  // NAME — and `memberHeaderFacts` replaces it with the position scan. It is
+  // deleted rather than left in place because a private method that reads a
+  // member's modifiers the wrong way is a trap for whoever calls it next, and
+  // `class-inherit-psa2` will not catch a re-introduction: no fixture reads
+  // `isStatic` off a split-shaped member.
+  /**
+   * PS11 — every attribute attached to a declaration, from BOTH places
+   * PowerShell allows one: directly on the declaration, and on its `param_block`
+   * (which is where `[CmdletBinding()]` and `[OutputType()]` actually sit).
+   * Scoped to a parameter/attribute-list chain, so the `path` of a
+   * `command_parameter` is never mistaken for a declaration attribute.
+   */
+  allAttributeTexts(node) {
+    const out = [];
+    for (const direct of this.collectChildrenByType(node, "attribute")) out.push(direct.text);
+    const blocks = this.collectChildrenByType(node, "param_block");
+    for (const sb of this.collectChildrenByType(node, "script_block")) {
+      blocks.push(...this.collectChildrenByType(sb, "param_block"));
+    }
+    for (const block of blocks) {
+      for (const list of this.collectChildrenByType(block, "attribute_list")) {
+        for (const attr of this.collectChildrenByType(list, "attribute")) out.push(attr.text);
+      }
+    }
+    for (const list of this.collectChildrenByType(node, "attribute_list")) {
+      for (const attr of this.collectChildrenByType(list, "attribute")) out.push(attr.text);
+    }
+    return out;
+  }
+  /** An `attribute_list`'s `attribute` children, as raw text. */
+  attributeTexts(node) {
+    const lists = this.collectChildrenByType(node, "attribute_list");
+    if (lists.length === 0) return void 0;
+    const texts = [];
+    for (const list of lists) {
+      for (const attr of this.collectChildrenByType(list, "attribute")) texts.push(attr.text);
+    }
+    return texts.length > 0 ? texts : void 0;
+  }
+  /**
+   * PS23 — the comment-based help block immediately above a declaration. A
+   * PowerShell function's documentation IS its `.SYNOPSIS`/`.DESCRIPTION`
+   * comment block (`about_Comment_Based_Help`), and the pre-wave lane read no
+   * comment but `#requires`, so `docstring` was `null` for every symbol in the
+   * language. `row` is the 0-based row of the declaration's NAME.
+   */
+  docstringAbove(row, lines) {
+    let i = row - 1;
+    if (i < 0 || lines[i] === void 0 || lines[i].trim() === "") return void 0;
+    if (lines[i].trim().endsWith("#>")) {
+      let open = -1;
+      for (let k = i; k >= 0; k--) {
+        if (lines[k].includes("<#")) {
+          open = k;
+          break;
+        }
+      }
+      if (open < 0) return void 0;
+      const last = i;
+      const body = lines.slice(open, last + 1).map((l, k) => k === 0 ? stripOpenCommentDelim(l) : k === last - open ? stripCloseCommentDelim(l) : l).join("\n").trim();
+      return body.length > 0 ? body : void 0;
+    }
+    const collected = [];
+    while (i >= 0) {
+      const raw = lines[i];
+      if (raw === void 0) break;
+      const trimmed = raw.trim();
+      if (trimmed === "" || !trimmed.startsWith("#") || trimmed.startsWith("#>")) break;
+      collected.unshift(trimmed);
+      i--;
+    }
+    if (collected.length === 0) return void 0;
+    const text = stripCommentMarkerRun(collected.join("\n")).trim();
+    return text.length > 0 ? text : void 0;
+  }
+  /**
+   * PS24 — EVERY module name a `#requires -Module[s]` declares, which is not the
+   * same question `extractRequiresValue` answers.
+   *
+   * The reader above stops at the first space, tab or comma, which is right for
+   * `-Version 7.0` and wrong twice for a module list. Measured on the corpus's own
+   * two files that use the hashtable form
+   * (`ansible/.../win_app_control/files/{New-AnsiblePowerShellSignature,
+   * Set-ManifestSignature}.ps1`, both carrying
+   * `#Requires -Modules @{ ModuleName = 'OpenAuthenticode'; ModuleVersion = '0.5.0' }`):
+   * the old reader returned the literal `@{` as the module name, so `imports[]` stored
+   * a row whose `path` was `@{` and `addImport` published `imports`/`references` edges
+   * to `@{`. Those edges died one stage later — `filterNoiseRelationships` in
+   * `src/ast/pool-worker.ts` drops any target whose leaf contains `{` — which is why
+   * the census reads `imports[] 552` against `imports 550`, and the two rows that
+   * vanish are exactly these two files. A garbage edge killed by shared machinery is
+   * still a garbage row already written, and the module it should have named
+   * (`OpenAuthenticode`) is a dependency the file genuinely declares.
+   *
+   * The comma list is the second miss, and rarer than the hashtable:
+   * `#requires -Modules Pester, PoshRSJob` names two modules and the old reader
+   * returned `Pester` alone, because the loop stopped at the comma. Measured over the
+   * 1,092-file admitted corpus: ONE occurrence of a comma-separated `#requires` module
+   * list — `#Requires -Modules PSScriptAnalyzer, PSSA-PSCustomUseLiteralPath` at
+   * `ansible/test/lib/ansible_test/_util/controller/sanity/pslint/pslint.ps1:2` — so
+   * `PSSA-PSCustomUseLiteralPath` was a declared dependency this lane read and dropped.
+   *
+   * MEASURED DELTA, and the population it is measured over. Only a file carrying a
+   * `#requires -Module(s)` directive can be affected, and 59 of the 1,092 admitted files
+   * do, so those 59 are the whole population and the delta is exact rather than
+   * sampled. Through production `parseFile`, before -> after: `imports[]` records
+   * 101 -> 102, `imports` edges 99 -> 102, `references` edges 105 -> 108. The records /
+   * edges gap of 2 that exists BEFORE the fix is the two `@{` rows: they were written
+   * and then dropped by the pool-worker's brace rule, which is why the whole-corpus
+   * census reads `imports[] 552` against `imports 550`.
+   *
+   * Zero regex, like the reader above, for the reason recorded there. Three shapes are
+   * recognized and nothing else: a bare list, a comma-continued bare list, and a
+   * hashtable whose `ModuleName` key names the module. A hashtable with no
+   * `ModuleName` names no module and yields nothing — `@{ ModuleVersion = '1.0' }` is
+   * not a module declaration, and returning the flag's value for it is how `@{`
+   * reached `imports[]` in the first place.
+   */
+  extractRequiresModules(text) {
+    const names = [];
+    const seen = /* @__PURE__ */ new Set();
+    let via = "requires_list";
+    const lower = text.toLowerCase();
+    const add = (raw) => {
+      const v = this.stripQuotes(raw.trim());
+      if (v.length === 0 || seen.has(v)) return;
+      seen.add(v);
+      names.push({ name: v, via });
+    };
+    for (let i = 0; i < text.length; i++) {
+      if (text[i] !== "-") continue;
+      let j = i + 1;
+      while (isAsciiLetter(lower[j])) j++;
+      const flag = lower.slice(i + 1, j);
+      if (flag !== "module" && flag !== "modules") continue;
+      while (text[j] === " " || text[j] === "	") j++;
+      if (j >= text.length) break;
+      for (; ; ) {
+        if (text[j] === "@" && text[j + 1] === "{") {
+          const ht = this.readHashtableModuleName(text, j + 1);
+          via = "requires_hashtable";
+          if (ht) add(ht);
+          while (text[j] !== void 0 && text[j] !== "}") j++;
+          if (text[j] === "}") j++;
+        } else {
+          let end = j;
+          while (text[end] !== void 0 && text[end] !== " " && text[end] !== "	" && text[end] !== "," && text[end] !== ";") end++;
+          if (end > j) add(text.slice(j, end));
+          j = end;
+        }
+        while (text[j] === " " || text[j] === "	") j++;
+        if (text[j] !== ",") break;
+        j++;
+        while (text[j] === " " || text[j] === "	") j++;
+        if (j >= text.length) break;
+      }
+      i = j - 1;
+    }
+    return names;
+  }
+  /**
+   * PS24 — the `ModuleName` value inside a `#requires -Modules @{ … }` hashtable,
+   * starting at the `{`. Char-scanned and brace-balanced with quote awareness, because
+   * a `}` inside a quoted `ModuleVersion` must not close the hashtable.
+   *
+   * Returns null when the hashtable carries no `ModuleName` key. PowerShell's module
+   * hashtable is `{ ModuleName = 'X'; ModuleVersion | RequiredVersion | GUID = … }`, so
+   * the key is the only thing in it that names a module.
+   */
+  readHashtableModuleName(text, openBrace) {
+    const lower = text.toLowerCase();
+    let depth = 0;
+    let quote = "";
+    for (let i = openBrace; i < text.length; i++) {
+      const c = text[i];
+      if (quote) {
+        if (c === quote) quote = "";
+        continue;
+      }
+      if (c === "'" || c === '"' || c === "`") {
+        quote = c;
+        continue;
+      }
+      if (c === "{") {
+        depth++;
+        continue;
+      }
+      if (c === "}") {
+        depth--;
+        if (depth === 0) return null;
+        continue;
+      }
+      if (depth !== 1) continue;
+      if (!isAsciiLetter(c) && c !== "_") continue;
+      let e = i;
+      while (isAsciiLetter(lower[e]) || lower[e] === "_") e++;
+      const key = lower.slice(i, e);
+      let v = e;
+      while (text[v] === " " || text[v] === "	") v++;
+      if (text[v] !== "=") {
+        i = e - 1;
+        continue;
+      }
+      v++;
+      while (text[v] === " " || text[v] === "	") v++;
+      let vend = v;
+      let vq = "";
+      while (vend < text.length) {
+        const vc = text[vend];
+        if (vq) {
+          if (vc === vq) vq = "";
+          vend++;
+          continue;
+        }
+        if (vc === "'" || vc === '"' || vc === "`") {
+          vq = vc;
+          vend++;
+          continue;
+        }
+        if (vc === ";" || vc === "}" || vc === " " || vc === "	") break;
+        vend++;
+      }
+      if (key === "modulename") {
+        const val = this.stripQuotes(text.slice(v, vend));
+        return val.length > 0 ? val : null;
+      }
+      i = vend - 1;
+    }
+    return null;
+  }
+  /**
+   * PS22 — a `#requires` value by name, char/index scanned. Comments are opaque
+   * to the grammar, so this one place is text by necessity, and it is declared
+   * as such here and in the M12 regex census (which records zero regex
+   * usages for this lane: no `/…/` literal is used).
+   */
+  extractRequiresValue(text, name) {
+    const lower = text.toLowerCase();
+    const key = name.toLowerCase();
+    for (let i = 0; i < text.length; i++) {
+      if (text[i] !== "-") continue;
+      if (!lower.slice(i + 1).startsWith(key)) continue;
+      let j = i + 1 + name.length;
+      while (j < text.length && (text[j] === " " || text[j] === "	")) j++;
+      if (j >= text.length) return null;
+      let end = j;
+      while (end < text.length && text[end] !== " " && text[end] !== "	" && text[end] !== ",") end++;
+      const value = this.stripQuotes(text.slice(j, end));
+      return value.length > 0 ? value : null;
+    }
+    return null;
+  }
+};
+export {
+  RealPowershellAnalyzer
+};