@ttsc/lint 0.30.4 → 0.31.0

package/go.mod

@@ -21,19 +21,21 @@ require (
 	github.com/microsoft/typescript-go/shim/diagnosticwriter v0.0.0
 	github.com/microsoft/typescript-go/shim/parser v0.0.0
 	github.com/microsoft/typescript-go/shim/scanner v0.0.0
+	github.com/microsoft/typescript-go/shim/stringutil v0.0.0
 	github.com/microsoft/typescript-go/shim/tsoptions v0.0.0
 	github.com/microsoft/typescript-go/shim/tspath v0.0.0
 	github.com/microsoft/typescript-go/shim/vfs v0.0.0
 	github.com/microsoft/typescript-go/shim/vfs/cachedvfs v0.0.0
 	github.com/microsoft/typescript-go/shim/vfs/osvfs v0.0.0
-	golang.org/x/text v0.35.0
+	github.com/yuin/goldmark/v2 v2.1.6
+	golang.org/x/text v0.38.0
 )
 
 require (
-	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
+	github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
-	github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157 // indirect
+	github.com/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063 // indirect
 	github.com/zeebo/xxh3 v1.1.0 // indirect
-	golang.org/x/sync v0.20.0 // indirect
-	golang.org/x/sys v0.42.0 // indirect
+	golang.org/x/sync v0.21.0 // indirect
+	golang.org/x/sys v0.46.0 // indirect
 )

package/internal/rulecode/rule_code_allocator_is_order_independent_and_append_only_test.go

@@ -0,0 +1,119 @@
+package rulecode_test
+
+import (
+  "fmt"
+  "hash/fnv"
+  "math/rand"
+  "reflect"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/lint/internal/rulecode"
+)
+
+// TestRuleCodeAllocatorIsOrderIndependentAndAppendOnly verifies allocation is
+// a function of the complete name set and frozen ledger, never insertion order.
+//
+// A new rule that hashes onto an existing assignment must move without changing
+// the existing rule. Randomized permutations guard against accidentally using
+// map or registration order in either the primary reservation or probe phases.
+//
+//  1. Discover two synthetic names with the same legacy code.
+//  2. Freeze the first assignment and require the second to probe elsewhere.
+//  3. Shuffle a larger name set repeatedly and require byte-for-byte mappings.
+//
+// @evidence contracts/testing.md#behavioral-verification rulecode.Allocate preserves frozen assignments and allocates distinct codes for colliding names independent of 32 input permutations; Legacy preferences also match Go's standard FNV-1a reference for the complete authored name population.
+// @evidence contracts/testing.md#independent-expectations Frozen literal assignments and collision uniqueness define append-only correctness independently of either allocation. Standard hash/fnv plus the documented [9000,18000) band supplies a separate preferred-code oracle; comparing two allocations alone establishes ordering, not the preferred assignment.
+// @evidence contracts/testing.md#distinguishing-cases A new collision, a lexically earlier newcomer versus a later frozen incumbent, an unchanged input map and 130 names under 32 permutations distinguish compatibility precedence, uniqueness, input ownership and insertion-order dependence.
+// @evidence contracts/testing.md#execution-ownership The public allocator and hashing operation run directly in the owning rulecode Go test process with authored maps and names; synthesized collision names are inputs, not expected outputs, and no generator, native artifact or committed-file comparison executes.
+func TestRuleCodeAllocatorIsOrderIndependentAndAppendOnly(t *testing.T) {
+  left, right := findSyntheticRuleCodeCollision(t)
+  frozen := map[string]int32{"frozen/existing": rulecode.Minimum}
+  base, err := rulecode.Allocate(frozen, []string{left})
+  if err != nil {
+    t.Fatalf("allocate base ledger: %v", err)
+  }
+  expanded, err := rulecode.Allocate(base, []string{left, right})
+  if err != nil {
+    t.Fatalf("allocate colliding rule: %v", err)
+  }
+  if expanded[left] != base[left] {
+    t.Fatalf("existing rule %q changed from %d to %d", left, base[left], expanded[left])
+  }
+  if expanded[right] == expanded[left] {
+    t.Fatalf("colliding rules %q and %q share code %d", left, right, expanded[left])
+  }
+  if len(frozen) != 1 || frozen["frozen/existing"] != rulecode.Minimum {
+    t.Fatalf("allocator mutated frozen input: %#v", frozen)
+  }
+
+  // A later rule may sort before the historical incumbent. Append-only
+  // compatibility still wins over lexical order once the incumbent is frozen.
+  earlier, later := left, right
+  if earlier > later {
+    earlier, later = later, earlier
+  }
+  laterIncumbent := map[string]int32{later: rulecode.Legacy(later)}
+  earlierNewcomer, err := rulecode.Allocate(laterIncumbent, []string{earlier})
+  if err != nil {
+    t.Fatalf("allocate alphabetically earlier collision: %v", err)
+  }
+  if earlierNewcomer[later] != laterIncumbent[later] {
+    t.Fatalf("later-sorting incumbent %q changed from %d to %d", later, laterIncumbent[later], earlierNewcomer[later])
+  }
+  if earlierNewcomer[earlier] == earlierNewcomer[later] {
+    t.Fatalf("alphabetically earlier newcomer %q displaced incumbent %q", earlier, later)
+  }
+
+  names := []string{left, right}
+  for index := 0; index < 128; index++ {
+    names = append(names, fmt.Sprintf("contributor/order-shield-%03d", index))
+  }
+  for _, name := range names {
+    reference := fnv.New32a()
+    _, _ = reference.Write([]byte(name))
+    preferred := int32(9000 + reference.Sum32()%9000)
+    if got := rulecode.Legacy(name); got != preferred {
+      t.Fatalf("legacy preference for %q differs from standard FNV-1a: %d != %d", name, got, preferred)
+    }
+  }
+  reference := fnv.New32a()
+  _, _ = reference.Write([]byte(left))
+  if got, preferred := base[left], int32(9000+reference.Sum32()%9000); got != preferred {
+    t.Fatalf("unoccupied preference changed: %d != %d", got, preferred)
+  }
+  want, err := rulecode.Allocate(frozen, names)
+  if err != nil {
+    t.Fatalf("allocate reference mapping: %v", err)
+  }
+  for seed := int64(0); seed < 32; seed++ {
+    shuffled := append([]string(nil), names...)
+    rand.New(rand.NewSource(seed)).Shuffle(len(shuffled), func(i, j int) {
+      shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
+    })
+    got, allocationErr := rulecode.Allocate(frozen, shuffled)
+    if allocationErr != nil {
+      t.Fatalf("allocate shuffled mapping for seed %d: %v", seed, allocationErr)
+    }
+    if !reflect.DeepEqual(got, want) {
+      t.Fatalf("allocation changed with input order for seed %d", seed)
+    }
+  }
+}
+
+func findSyntheticRuleCodeCollision(t *testing.T) (string, string) {
+  t.Helper()
+  seen := make(map[int32]string)
+  for index := 0; index < 20000; index++ {
+    name := fmt.Sprintf("contributor/collision-shield-%05d", index)
+    code := rulecode.Legacy(name)
+    if code == rulecode.Minimum {
+      continue
+    }
+    if previous, exists := seen[code]; exists {
+      return previous, name
+    }
+    seen[code] = name
+  }
+  t.Fatal("failed to find a synthetic legacy-code collision")
+  return "", ""
+}

package/internal/rulecode/rule_code_allocator_rejects_invalid_or_exhausted_ledgers_test.go

@@ -0,0 +1,60 @@
+package rulecode_test
+
+import (
+  "fmt"
+  "reflect"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/lint/internal/rulecode"
+)
+
+// TestRuleCodeAllocatorRejectsInvalidOrExhaustedLedgers verifies allocation
+// fails closed when the compatibility ledger cannot support unique codes.
+//
+// Accepting an out-of-band or duplicate frozen entry would publish ambiguous
+// diagnostics. Silently wrapping after all 9,000 slots are occupied would do
+// the same, so exhaustion must be an explicit error rather than code reuse.
+//
+//  1. Reject frozen entries below and above the reserved band.
+//  2. Reject two frozen names sharing one code.
+//  3. Fill every slot and require allocation of one more rule to fail.
+//
+// @evidence contracts/testing.md#behavioral-verification rulecode.Allocate rejects both out-of-range endpoints, duplicate frozen codes and a completely occupied band, while accepting empty allocation and both valid band endpoints without mutating the caller's map.
+// @evidence contracts/testing.md#independent-expectations The published reserved interval is [9000,18000), frozen names must have unique codes, and no further assignment exists when all 9000 slots are occupied. Literal error classes and valid endpoint assignments distinguish those failures from arbitrary errors.
+// @evidence contracts/testing.md#distinguishing-cases Below minimum, exclusive maximum, duplicate minimum and full-band overflow retain all original failures; empty and inclusive endpoint controls prove the allocator does not reject valid ledgers, and result mutation checks caller ownership.
+// @evidence contracts/testing.md#execution-ownership Direct public Allocate calls consume authored in-memory ledgers in the owning rulecode Go test process, including the complete exhaustion input; no file layout, generated snapshot or native host is used as an oracle.
+func TestRuleCodeAllocatorRejectsInvalidOrExhaustedLedgers(t *testing.T) {
+  invalidLedgers := []map[string]int32{
+    {"below": rulecode.Minimum - 1},
+    {"above": rulecode.MaximumExclusive},
+    {"left": rulecode.Minimum, "right": rulecode.Minimum},
+  }
+  errorClasses := []string{"out-of-range diagnostic code", "out-of-range diagnostic code", "share diagnostic code"}
+  for index, ledger := range invalidLedgers {
+    if _, err := rulecode.Allocate(ledger, nil); err == nil || !strings.Contains(err.Error(), errorClasses[index]) {
+      t.Fatalf("invalid ledger %d: expected %q, got %v; input %#v", index, errorClasses[index], err, ledger)
+    }
+  }
+
+  full := make(map[string]int32, rulecode.MaximumExclusive-rulecode.Minimum)
+  for code := rulecode.Minimum; code < rulecode.MaximumExclusive; code++ {
+    full[fmt.Sprintf("frozen/%d", code)] = code
+  }
+  if _, err := rulecode.Allocate(full, []string{"contributor/overflow"}); err == nil || err.Error() != "lint diagnostic code range [9000, 18000) is exhausted" {
+    t.Fatalf("expected reserved-band exhaustion error, got %v", err)
+  }
+  empty, err := rulecode.Allocate(nil, nil)
+  if err != nil || len(empty) != 0 {
+    t.Fatalf("empty allocation rejected: %v %v", empty, err)
+  }
+  valid := map[string]int32{"minimum": 9000, "maximum": 17999}
+  assigned, err := rulecode.Allocate(valid, nil)
+  if err != nil || !reflect.DeepEqual(assigned, valid) {
+    t.Fatalf("valid endpoint ledger rejected: %v %v", assigned, err)
+  }
+  assigned["minimum"] = 9001
+  if valid["minimum"] != 9000 {
+    t.Fatalf("result mutation changed frozen input: %v", valid)
+  }
+}

package/internal/rulecode/rulecode.go

@@ -16,6 +16,15 @@ const (
 
 // Legacy returns the historical FNV-1a code for name. Allocate uses this as
 // the preferred code so rules without a collision retain their original code.
+//
+// @evidence contracts/common.md#principled-implementation Unsigned FNV-1a wraparound followed by range reduction preserves the historical preferred code for each byte name.
+// @evidence contracts/common.md#clear-and-simple-design One hashing helper owns the legacy preference independently from collision allocation.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Hash constants and the reserved code interval define the algorithm and protocol, not fixture answers.
+// @evidence contracts/common.md#meaningful-documentation The native comment distinguishes preference from unique assignment; the tag boundary follows documentation guidance.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation Legacy hashes a rule name into an integer and touches no filesystem path or process.
+// @evidence contracts/performance.md#efficient-algorithms One FNV-1a pass over the name bytes, O(len(name)) time and O(1) space.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work Legacy computes one hash per call; the callers that need reuse own it.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Legacy keeps no state and acquires no handle or task.
 func Legacy(name string) int32 {
   const prime = 16777619
   var hash uint32 = 2166136261
@@ -32,6 +41,15 @@ func Legacy(name string) int32 {
 // Missing names are sorted before allocation, making the result independent of
 // registration order. Their legacy codes are reserved as a group before any
 // collision is probed so a collision loser cannot displace an unrelated rule.
+//
+// @evidence contracts/common.md#principled-implementation Validating frozen codes, sorting unique missing names and reserving their unoccupied preferences before probing gives stable collision-free allocation or an explicit exhaustion error.
+// @evidence contracts/common.md#clear-and-simple-design Separate frozen validation, preference reservation and collision probing keep the allocation policy visible.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The same allocation procedure applies to all names; frozen assignments are supported compatibility data rather than guessed expected results.
+// @evidence contracts/common.md#meaningful-documentation Native prose explains removed-rule reservations and order independence; paragraphs and tag separation follow documentation guidance.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation Allocate maps rule names to integer codes and touches no filesystem path or process.
+// @evidence contracts/performance.md#efficient-algorithms With f frozen entries, n requested names and p examined probe slots, allocation validates f entries, sorts n names and reserves preferences before probing, O(f+n log n+p) map/comparison operations plus name hashing bytes. Collision probing may examine up to band-width minus one slots per missing name, not a guaranteed constant count. Temporary maps/slices and the returned assignment occupy O(f+n) entries.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work Allocate returns a fresh assignment on every call; its caller owns any caching of the result.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The assigned and used maps are local to the call; only the returned assignment is handed to the caller.
 func Allocate(frozen map[string]int32, names []string) (map[string]int32, error) {
   assigned := make(map[string]int32, len(frozen)+len(names))
   used := make(map[int32]string, len(frozen)+len(names))

package/lib/createTtscPlugin.d.ts

@@ -0,0 +1,84 @@
+import type { ITtscLintPluginConfig } from "./structures";
+/** A resolved contributor: Go sub-package name + absolute source directory. */
+type TtscPluginContributor = {
+    name: string;
+    source: string;
+};
+/** Descriptor shape returned to ttsc's plugin builder by the factory. */
+type TtscPluginDescriptor = {
+    capabilities?: {
+        checkObservations?: true;
+        compilerArgsCwd?: true;
+        diagnosticsTiming?: boolean;
+        graphNodes?: boolean;
+        lsp?: boolean;
+        projectContextArgs?: boolean;
+        projectDiagnostics?: boolean;
+        projectInputs?: boolean;
+        residentCheck?: boolean;
+        threadingArgs?: boolean;
+    };
+    contributors?: TtscPluginContributor[];
+    hostInputHashes?: Record<string, string | null>;
+    hostInputRealpaths?: Record<string, string | null>;
+    hostInputs?: string[];
+    name: string;
+    reportsTypeScriptDiagnostics?: boolean;
+    source: string;
+    stage?: "check" | "transform";
+};
+/**
+ * Context object injected by ttsc into every plugin factory call. The generic
+ * `TConfig` is the tsconfig plugin entry shape.
+ */
+type TtscPluginFactoryContext<TConfig> = {
+    binary: string;
+    cwd: string;
+    /** This descriptor's own directory — the ESM-safe replacement for `__dirname`. */
+    dirname: string;
+    /** This descriptor's own path — the ESM-safe replacement for `__filename`. */
+    filename: string;
+    plugin: TConfig;
+    /**
+     * Caller-declared anchor for plugin config-file discovery, present when the
+     * embedder compiles through a generated tsconfig outside the project (see
+     * `ITtscPluginFactoryContext.pluginConfigDir`).
+     */
+    pluginConfigDir?: string;
+    projectRoot: string;
+    tsconfig: string;
+};
+/**
+ * Plugin descriptor factory consumed by ttsc package discovery.
+ *
+ * Contributor lint plugins come from one place: the project's lint config file
+ * (`lint.config.{ts,cts,mts,js,cjs,mjs,json}` or `ttsc-lint.config.*`). The
+ * tsconfig plugin entry carries no rule or plugin surface — it optionally names
+ * the config file via `configFile`, otherwise the file is discovered by walking
+ * upward from the tsconfig directory (or from the caller-declared
+ * `pluginConfigDir` when the resolved tsconfig is a generated wrapper in a temp
+ * directory).
+ *
+ * The factory locates the config file and evaluates contributor-bearing configs
+ * in an isolated ttsx process. JSON without plugins or an extends chain needs
+ * no evaluator. The extractor reads plugin maps from the resolved config and
+ * its bases and forwards contributor Go sources to the descriptor's
+ * `contributors` field. Its dependency envelope owns config observations; the
+ * child's bootstrap does not inherit the parent descriptor's observation
+ * channel.
+ *
+ * @evidence contracts/common.md#principled-implementation Entry validation and config-origin discovery resolve registered contributor sources and observed inputs before constructing the check-stage descriptor with supported capabilities.
+ * @evidence contracts/common.md#clear-and-simple-design The exported factory composes validation, discovery and descriptor construction; helpers own module loading and dependency fingerprints separately.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Contributors use the supported Go-source extension boundary and config-file schema; no foreign method replacement or fixture-specific descriptor is installed.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain config origins, evaluator formats and contributor forwarding; separated prose and tags follow documentation guidance.
+ */
+export default function createTtscPlugin(context: TtscPluginFactoryContext<ITtscLintPluginConfig>): TtscPluginDescriptor;
+/**
+ * The descriptor extractor's emitted source.
+ *
+ * Exported so a regression can inspect the same bytes the loader executes. The
+ * template consumes its own escapes, so reading this file's text instead would
+ * check characters no consumer ever sees.
+ */
+export declare const TTSX_EXTRACTOR_SCRIPT = "// @ts-ignore -- internal loader must not require user-installed Node typings.\nimport * as fs from \"node:fs\";\n// @ts-ignore -- internal loader must not require user-installed Node typings.\nimport { Buffer } from \"node:buffer\";\n// @ts-ignore -- internal loader must not require user-installed Node typings.\nimport { createHash } from \"node:crypto\";\n// @ts-ignore -- internal loader must not require user-installed Node typings.\nimport { createRequire, registerHooks } from \"node:module\";\n// @ts-ignore -- internal loader must not require user-installed Node typings.\nimport * as path from \"node:path\";\n// @ts-ignore -- internal loader must not require user-installed Node typings.\nimport { fileURLToPath, pathToFileURL } from \"node:url\";\n\nconst configUrl = %CONFIG_IMPORT%;\nconst outputPath = %CONFIG_OUTPUT%;\nconst resolutionRoot = path.resolve(%CONFIG_ROOT%);\nconst CONFIG_KEYS = new Set<string>([\n  \"files\",\n  \"ignores\",\n  \"extends\",\n  \"plugins\",\n  \"rules\",\n  \"format\",\n]);\nconst dependencies = new Map<string, {\n  digest: string;\n  identityStable: boolean;\n  kind: \"directory\" | \"file\" | \"optional-file\";\n  path: string;\n  owners: Set<string>;\n  realpath: string | null;\n}>();\nconst graphNodes = new Map<string, string>();\nconst graphEdges: Array<{\n  child: string;\n  packageBoundary: boolean;\n  parent: string;\n}> = [];\nconst configLocation = fileURLToPath(configUrl);\n// Every spelling of this config the module system might key an edge under.\n//\n// Which one it uses is not knowable from here, and guessing has failed in both\n// directions. A path handed in by another producer can be escaped by a rule\n// Node does not share. Node respells a resolved file module through its real\n// path unless \"--preserve-symlinks\" is set, so a config reached through a\n// symlinked directory is keyed by its target. And a Windows 8.3 short name is\n// not a symlink: fs.realpathSync expands it, the module resolver does not, so\n// asking the volume there produces a spelling no edge carries.\n//\n// A seed that names a URL no edge was keyed under sits on a node with no\n// outgoing edges, the walk ends immediately, and every dependency recorded\n// after the first import is demoted from watch to cache. That failure is\n// silent: the build still succeeds and simply stops reacting. Seeding every\n// spelling costs one extra queue entry and cannot be wrong.\nconst configUrlSpellings = [\n  ...new Set([\n    configUrl,\n    pathToFileURL(configLocation).href,\n    pathToFileURL(realConfigLocation()).href,\n  ]),\n];\nconst configEntryUrls = new Set(configUrlSpellings);\nconst moduleProbeExtensions = [\n  \".ts\",\n  \".tsx\",\n  \".mts\",\n  \".cts\",\n  \".js\",\n  \".mjs\",\n  \".cjs\",\n  \".json\",\n  \".node\",\n] as const;\nconst jsToTsProbeExtensions = new Map<string, readonly string[]>([\n  [\".js\", [\".ts\", \".tsx\"]],\n  [\".jsx\", [\".tsx\"]],\n  [\".mjs\", [\".mts\"]],\n  [\".cjs\", [\".cts\"]],\n]);\nfor (const spelling of configUrlSpellings) {\n  graphNodes.set(spelling, configLocation);\n}\nrecordDependency(\n  \"file\",\n  configLocation,\n  createHash(\"sha256\").update(fs.readFileSync(configLocation)).digest(\"hex\"),\n  configUrlSpellings,\n);\nrecordPackageManifests(configLocation, configUrlSpellings);\n\ndeclare const process: {\n  cwd(): string;\n  platform: string;\n  stdout: { write(value: string): void };\n  stderr: { write(value: string): void };\n  exit(code?: number): never;\n};\n\nconst hooks = registerHooks({\n  resolve(specifier, context, nextResolve) {\n    const requestedParent =\n      context.parentURL && new URL(context.parentURL).href;\n    if (requestedParent !== undefined && graphNodes.has(requestedParent)) {\n      recordLocalResolutionCandidates(specifier, requestedParent);\n    }\n    const resolved = nextResolve(specifier, context);\n    if (typeof resolved.url !== \"string\" || !resolved.url.startsWith(\"file:\")) {\n      return resolved;\n    }\n    const url = new URL(resolved.url).href;\n    const parent = context.parentURL && new URL(context.parentURL).href;\n    const location = fileURLToPath(url);\n    // The entry is recognized by what was asked for, not only by what came\n    // back. A module URL is assigned by whoever loaded it: a compiling loader\n    // can serve the config from its emitted output, and a platform can hand\n    // back a different spelling of the same file. Either way the URL bears no\n    // resemblance to the one this process was given, so the config's own\n    // imports would be rejected here \u2014 their parent is a URL no node was\n    // recorded under \u2014 and the graph would collapse to the records made before\n    // the first import. The request itself is unambiguous, so it decides.\n    const entry =\n      configEntryUrls.has(specifier) ||\n      url === new URL(configUrl).href ||\n      samePhysicalPath(location, configLocation);\n    if (!entry && (parent === undefined || !graphNodes.has(parent))) {\n      return resolved;\n    }\n    graphNodes.set(url, location);\n    if (entry && configEntryUrls.has(specifier) && specifier !== url) {\n      graphEdges.push({ child: url, packageBoundary: false, parent: specifier });\n    }\n    if (parent !== undefined) {\n      graphEdges.push({\n        child: url,\n        packageBoundary:\n          pathHasNodeModules(location) && !isLocalModuleSpecifier(specifier),\n        parent,\n      });\n      recordResolutionTopology(\n        specifier,\n        parent,\n        url,\n        location,\n        context.conditions,\n      );\n    }\n    try {\n      recordDependency(\n        \"file\",\n        location,\n        createHash(\"sha256\").update(fs.readFileSync(location)).digest(\"hex\"),\n        [url],\n      );\n    } catch {\n      // The evaluator remains authoritative for the load error. An unreadable\n      // dependency simply makes this result non-cacheable in the parent.\n      recordDependency(\"file\", location, \"\", [url]);\n    }\n    return resolved;\n  },\n});\n\n// Wrapped and settled explicitly rather than written as a top-level await.\n// The loader tsconfig's \"module\" now follows the config's own package, and\n// TS1378 rejects top-level await under a CommonJS module option however this\n// .mts file emits. The trailing catch is what a top-level await gave for\n// free: without it a throw from the finally would leave the promise\n// unsettled instead of failing the load.\n(async () => {\n  try {\n    const importedConfig = configLocation.toLowerCase().endsWith(\".json\")\n      ? JSON.parse(fs.readFileSync(configLocation, \"utf8\").replace(/^\uFEFF/, \"\"))\n      : await import(configUrl);\n    const current = await resolveConfig(importedConfig, true);\n    const entries = await collectPluginEntries(current, configLocation, %CONFIG_CHAIN%);\n    fs.writeFileSync(outputPath, JSON.stringify({\n      dependencies: finalizeDependencies(),\n      entries,\n    }), \"utf8\");\n  } catch (error) {\n    reportLoaderFailure(error);\n  } finally {\n    hooks.deregister();\n  }\n})().catch((error) => {\n  // Reached only when the finally above throws: the catch already ends the\n  // process, so this is the deregistration's own failure, not the config's.\n  reportLoaderFailure(error);\n});\n\n// reportLoaderFailure ends this loader on an error it can name, on both of the\n// channels the parent uses.\n//\n// The stack is for a reader and streams to stderr as it is written. The reason\n// is a fact about the user's config that a caller has to act on, so it travels\n// as data through the result file the parent already reads. Only a well-formed\n// envelope is honoured there, so a partially written or unrelated file leaves\n// the process status to speak for itself.\nfunction reportLoaderFailure(error: unknown): never {\n  // The trailing newline ends the stack as a line of its own. Without it the\n  // parent's own message, written to this same stream, starts mid-line.\n  process.stderr.write((error instanceof Error && error.stack ? error.stack : String(error)) + \"\\n\");\n  try {\n    fs.writeFileSync(\n      outputPath,\n      JSON.stringify({ __ttscLoaderError: error instanceof Error ? error.message : String(error) }),\n      \"utf8\",\n    );\n  } catch {\n    // A reason that cannot be written leaves the exit status as the report.\n  }\n  return process.exit(1);\n}\n\nfunction isObject(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === \"object\";\n}\n\nfunction recordDependency(\n  kind: \"directory\" | \"file\" | \"optional-file\",\n  location: string,\n  digest: string,\n  owners: readonly string[],\n): void {\n  const key = kind + \"\\0\" + location;\n  const previous = dependencies.get(key);\n  const mergedOwners = previous?.owners ?? new Set<string>();\n  for (const owner of owners) mergedOwners.add(owner);\n  const realpath = dependencyRealpath(location);\n  const identityStable =\n    previous?.identityStable !== false &&\n    (previous === undefined || previous.realpath === realpath);\n  dependencies.set(key, {\n    digest:\n      !identityStable ||\n      (previous !== undefined && previous.digest !== digest)\n        ? \"\"\n        : digest,\n    identityStable,\n    kind,\n    owners: mergedOwners,\n    path: location,\n    realpath,\n  });\n}\n\nfunction dependencyRealpath(location: string): string | null {\n  try {\n    return realPath(location);\n  } catch {\n    return null;\n  }\n}\n\nfunction isLocalModuleSpecifier(specifier: string): boolean {\n  return specifier.startsWith(\".\") ||\n    specifier.startsWith(\"/\") ||\n    specifier.startsWith(\"file:\") ||\n    /^[A-Za-z]:[\\\\/]/.test(specifier);\n}\n\nfunction pathHasNodeModules(location: string): boolean {\n  return location.replaceAll(\"\\\\\", \"/\").split(\"/\").includes(\"node_modules\");\n}\n\nfunction recordResolutionTopology(\n  specifier: string,\n  parentUrl: string,\n  childUrl: string,\n  childLocation: string,\n  conditions: readonly string[],\n): void {\n  const owners = [parentUrl, childUrl];\n  const parentLocation = graphNodes.get(parentUrl);\n  if (parentLocation !== undefined && isLocalModuleSpecifier(specifier)) {\n    recordDirectoryDependency(path.dirname(parentLocation), owners);\n  }\n  recordDirectoryDependency(path.dirname(childLocation), owners);\n  recordPackageManifests(childLocation, owners);\n  if (parentLocation !== undefined && !isLocalModuleSpecifier(specifier)) {\n    recordNodeModulesSearchDirectories(\n      parentLocation,\n      specifier,\n      childLocation,\n      owners,\n      conditions,\n    );\n  }\n}\n\nfunction recordDirectoryDependency(\n  location: string,\n  owners: readonly string[],\n): void {\n  try {\n    recordDependency(\"directory\", location, directoryDigest(location), owners);\n  } catch {\n    recordDependency(\"directory\", location, \"\", owners);\n  }\n}\n\nfunction directoryDigest(location: string): string {\n  const entries: Buffer[] = [];\n  if (process.platform === \"win32\") {\n    for (const entry of fs.readdirSync(location, { withFileTypes: true })) {\n      let target = Buffer.alloc(0);\n      if (entry.isSymbolicLink()) {\n        try {\n          target = Buffer.from(\n            fs.readlinkSync(path.join(location, entry.name)),\n            \"utf8\",\n          );\n        } catch {\n          target = Buffer.from(\"<unreadable>\");\n        }\n      }\n      entries.push(directoryDigestRecord(Buffer.from(entry.name), entry, target));\n    }\n  } else {\n    for (const entry of fs.readdirSync(location, {\n      encoding: \"buffer\",\n      withFileTypes: true,\n    })) {\n      let target = Buffer.alloc(0);\n      if (entry.isSymbolicLink()) {\n        try {\n          target = fs.readlinkSync(\n            Buffer.concat([\n              Buffer.from(location),\n              Buffer.from(path.sep),\n              entry.name,\n            ]),\n            { encoding: \"buffer\" },\n          );\n        } catch {\n          target = Buffer.from(\"<unreadable>\");\n        }\n      }\n      entries.push(directoryDigestRecord(entry.name, entry, target));\n    }\n  }\n  entries.sort(Buffer.compare);\n  const serialized = Buffer.concat(\n    entries.flatMap((entry, index) =>\n      index === 0 ? [entry] : [Buffer.from([0]), entry],\n    ),\n  );\n  return createHash(\"sha256\").update(serialized).digest(\"hex\");\n}\n\nfunction directoryDigestRecord(\n  name: Buffer,\n  entry: {\n    isDirectory(): boolean;\n    isFile(): boolean;\n    isSymbolicLink(): boolean;\n  },\n  target: Buffer,\n): Buffer {\n  const kind = entry.isDirectory()\n    ? \"directory\"\n    : entry.isFile()\n      ? \"file\"\n      : entry.isSymbolicLink()\n        ? \"symlink\"\n        : \"other\";\n  return Buffer.concat([name, Buffer.from(\"\\0\" + kind + \"\\0\"), target]);\n}\n\nfunction optionalFileDigest(location: string): string {\n  try {\n    const entry = fs.statSync(location);\n    if (entry.isFile()) {\n      return createHash(\"sha256\")\n        .update(Buffer.concat([Buffer.from(\"file\\0\"), fs.readFileSync(location)]))\n        .digest(\"hex\");\n    }\n    if (entry.isDirectory()) {\n      return createHash(\"sha256\")\n        .update(\"ttsc:host-input:directory\\0\")\n        .digest(\"hex\");\n    }\n  } catch {\n    // Missing and unreadable candidates share the absent state.\n  }\n  return createHash(\"sha256\").update(\"missing\\0\").digest(\"hex\");\n}\n\nfunction recordOptionalFileDependency(\n  location: string,\n  owners: readonly string[],\n): boolean {\n  try {\n    if (fs.statSync(location).isFile()) {\n      recordDependency(\n        \"file\",\n        location,\n        createHash(\"sha256\").update(fs.readFileSync(location)).digest(\"hex\"),\n        owners,\n      );\n      return true;\n    }\n  } catch {\n    // The exact missing path remains a dependency of the resolution result.\n  }\n  recordDependency(\"optional-file\", location, optionalFileDigest(location), owners);\n  return false;\n}\n\nfunction moduleResolutionCandidates(base: string): string[] {\n  const extension = path.extname(base).toLowerCase();\n  const substitutions = jsToTsProbeExtensions.get(extension) ?? [];\n  const stem = base.slice(0, base.length - extension.length);\n  return [\n    base,\n    ...substitutions.map((candidate) => stem + candidate),\n    ...moduleProbeExtensions.map((candidate) => base + candidate),\n    path.join(base, \"package.json\"),\n    ...moduleProbeExtensions.map((candidate) =>\n      path.join(base, \"index\" + candidate),\n    ),\n  ];\n}\n\n/** Record exact local probes before the runtime resolver chooses one. */\nfunction recordLocalResolutionCandidates(\n  specifier: string,\n  parentUrl: string,\n): void {\n  if (!isLocalModuleSpecifier(specifier)) return;\n  let bases: string[];\n  try {\n    if (specifier.startsWith(\"file:\")) {\n      bases = [fileURLToPath(specifier)];\n    } else {\n      const directory = path.dirname(fileURLToPath(parentUrl));\n      const raw = path.resolve(directory, specifier);\n      const suffixStart = specifier.search(/[?#]/);\n      const pathname =\n        suffixStart === -1 ? specifier : specifier.slice(0, suffixStart);\n      bases = pathname === \"\"\n        ? [raw]\n        : [...new Set([raw, path.resolve(directory, pathname)])];\n    }\n  } catch {\n    return;\n  }\n  const owners = [parentUrl];\n  for (const base of bases) {\n    try {\n      if (fs.statSync(base).isFile()) {\n        recordOptionalFileDependency(base, owners);\n        continue;\n      }\n    } catch {\n      // A missing exact spelling falls through to source/extension/directory\n      // probes, all of which can redirect a later evaluation.\n    }\n    for (const candidate of moduleResolutionCandidates(base)) {\n      recordOptionalFileDependency(candidate, owners);\n    }\n  }\n}\n\n/** CommonJS LOAD_AS_FILE / LOAD_AS_DIRECTORY candidates for one legacy path. */\nfunction recordLegacyPackagePathCandidates(\n  candidate: string,\n  owners: readonly string[],\n): void {\n  for (const file of [\n    candidate,\n    candidate + \".js\",\n    candidate + \".json\",\n    candidate + \".node\",\n    path.join(candidate, \"package.json\"),\n    path.join(candidate, \"index.js\"),\n    path.join(candidate, \"index.json\"),\n    path.join(candidate, \"index.node\"),\n  ]) {\n    recordOptionalFileDependency(file, owners);\n  }\n}\n\nfunction recordPackageManifests(\n  location: string,\n  owners: readonly string[],\n): void {\n  let current = path.dirname(location);\n  while (true) {\n    const manifest = path.join(current, \"package.json\");\n    if (recordOptionalFileDependency(manifest, owners)) return;\n    const parent = path.dirname(current);\n    if (parent === current || path.basename(current) === \"node_modules\") return;\n    current = parent;\n  }\n}\n\nfunction recordNodeModulesSearchDirectories(\n  parentLocation: string,\n  specifier: string,\n  childLocation: string,\n  owners: readonly string[],\n  conditions: readonly string[],\n): void {\n  const packageName = modulePackageName(specifier);\n  const scope =\n    specifier.startsWith(\"@\") && specifier.includes(\"/\")\n      ? specifier.slice(0, specifier.indexOf(\"/\"))\n      : undefined;\n  let current = path.dirname(parentLocation);\n  while (true) {\n    // A newly created nearer node_modules directory can shadow the package\n    // selected by this evaluation, so missing search levels are dependencies.\n    recordDirectoryDependency(current, owners);\n    const modules = path.join(current, \"node_modules\");\n    try {\n      if (fs.statSync(modules).isDirectory()) {\n        recordDirectoryDependency(modules, owners);\n        if (scope !== undefined) {\n          const scoped = path.join(modules, scope);\n          try {\n            if (fs.statSync(scoped).isDirectory()) {\n              recordDirectoryDependency(scoped, owners);\n            }\n          } catch {\n            // The directory digest of node_modules records a missing scope.\n          }\n        }\n      }\n    } catch {\n      // Missing search levels do not participate in the current resolution.\n    }\n    if (packageName !== undefined) {\n      const selected = recordPackageCandidateTopology(\n        modules,\n        packageName,\n        specifier,\n        childLocation,\n        owners,\n        conditions,\n      );\n      if (\n        selected ||\n        resolvedPackageContains(modules, packageName, childLocation)\n      ) {\n        return;\n      }\n    }\n    if (\n      packageName === undefined &&\n      samePhysicalPath(current, resolutionRoot)\n    ) {\n      return;\n    }\n    const parent = path.dirname(current);\n    if (parent === current) return;\n    current = parent;\n  }\n}\n\nfunction recordPackageCandidateTopology(\n  modules: string,\n  packageName: string,\n  specifier: string,\n  childLocation: string,\n  owners: readonly string[],\n  conditions: readonly string[],\n): boolean {\n  const packageRoot = path.join(modules, packageName);\n  const subpath = specifier\n    .slice(packageName.length)\n    .replace(/^[/\\\\]+/, \"\");\n  try {\n    if (!fs.statSync(packageRoot).isDirectory()) {\n      recordOptionalFileDependency(\n        path.join(packageRoot, \"package.json\"),\n        owners,\n      );\n      recordLegacyPackagePathCandidates(\n        subpath === \"\" ? packageRoot : path.join(packageRoot, subpath),\n        owners,\n      );\n      return false;\n    }\n  } catch {\n    recordOptionalFileDependency(\n      path.join(packageRoot, \"package.json\"),\n      owners,\n    );\n    recordLegacyPackagePathCandidates(\n      subpath === \"\" ? packageRoot : path.join(packageRoot, subpath),\n      owners,\n    );\n    return false;\n  }\n  const rootTopology = recordPackageRootTopology(\n    packageRoot,\n    owners,\n    subpath === \"\",\n    subpath === \"\" ? \".\" : \"./\" + subpath.replaceAll(\"\\\\\", \"/\"),\n    childLocation,\n    conditions,\n  );\n  if (subpath !== \"\" && !rootTopology.hasExports) {\n    return (\n      recordPackageSubpathTopology(\n        packageRoot,\n        subpath,\n        childLocation,\n        owners,\n      ) || rootTopology.selected\n    );\n  }\n  return rootTopology.selected;\n}\n\nfunction recordPackageRootTopology(\n  packageRoot: string,\n  owners: readonly string[],\n  useMain: boolean,\n  packageSubpath: string,\n  childLocation: string,\n  conditions: readonly string[],\n): { hasExports: boolean; selected: boolean } {\n  const normalizedRoot = path.resolve(packageRoot);\n  const manifest = path.join(normalizedRoot, \"package.json\");\n  const legacySelected = (): boolean =>\n    useMain &&\n    packagePathCandidateMatchesChild(normalizedRoot, childLocation, true);\n  if (useMain) recordLegacyPackagePathCandidates(normalizedRoot, owners);\n  if (!recordOptionalFileDependency(manifest, owners)) {\n    const selected = legacySelected();\n    if (!selected) {\n      recordPackageIndexCandidates(normalizedRoot, useMain, owners);\n    }\n    return { hasExports: false, selected };\n  }\n  try {\n    const value = JSON.parse(fs.readFileSync(manifest, \"utf8\"));\n    if (value !== null && typeof value === \"object\") {\n      const metadata = value as Record<string, unknown>;\n      const hasExports =\n        metadata.exports !== undefined && metadata.exports !== null;\n      if (hasExports) {\n        const target = selectPackageExportsTarget(\n          metadata.exports,\n          packageSubpath,\n          new Set(conditions),\n        );\n        const candidate =\n          typeof target === \"string\"\n            ? packageExportsTarget(normalizedRoot, target)\n            : undefined;\n        const selected =\n          candidate !== undefined &&\n          packagePathCandidateMatchesChild(\n            candidate,\n            childLocation,\n            false,\n          );\n        if (selected) {\n          recordPackagePathCandidate(candidate, owners);\n        } else if (candidate !== undefined) {\n          // A nearer package the search skipped starts winning the moment its\n          // own active target appears, and neither the parent node_modules\n          // listing nor the manifest changes when only that file is created.\n          recordOptionalFileDependency(candidate, owners);\n        }\n        return { hasExports: true, selected };\n      }\n      let selected = legacySelected();\n      if (useMain && typeof metadata.main === \"string\") {\n        // CommonJS main is a legacy path, not an exports target. Node resolves\n        // it literally and permits absolute paths and paths outside the package.\n        const main = path.resolve(normalizedRoot, metadata.main);\n        recordPackagePathCandidate(main, owners);\n        recordLegacyPackagePathCandidates(main, owners);\n        selected =\n          packagePathCandidateMatchesChild(main, childLocation, true) ||\n          selected;\n      }\n      if (!selected) {\n        recordPackageIndexCandidates(normalizedRoot, useMain, owners);\n      }\n      return {\n        hasExports: false,\n        selected,\n      };\n    }\n  } catch {\n    // Node owns malformed-manifest diagnostics; the manifest digest is enough\n    // to invalidate this evaluation when its contents change.\n  }\n  const selected = legacySelected();\n  if (!selected) {\n    recordPackageIndexCandidates(normalizedRoot, useMain, owners);\n  }\n  return { hasExports: false, selected };\n}\n\n// recordPackageIndexCandidates pins the LOAD_INDEX fallbacks of a package root\n// this resolution walked past without selecting. An empty package directory, or\n// one whose manifest declares no usable entry, becomes resolvable as soon as one\n// of these files exists, and that creation changes neither the parent directory\n// listing nor the manifest digest already recorded for the candidate.\nfunction recordPackageIndexCandidates(\n  packageRoot: string,\n  useMain: boolean,\n  owners: readonly string[],\n): void {\n  if (!useMain) return;\n  for (const name of [\"index.js\", \"index.json\", \"index.node\"]) {\n    recordOptionalFileDependency(path.join(packageRoot, name), owners);\n  }\n}\n\nfunction selectPackageExportsTarget(\n  exportsValue: unknown,\n  packageSubpath: string,\n  conditions: ReadonlySet<string>,\n): string | null | undefined {\n  let mappings: unknown = exportsValue;\n  if (\n    typeof mappings === \"string\" ||\n    Array.isArray(mappings) ||\n    (isObject(mappings) &&\n      Object.keys(mappings).every((key) => !key.startsWith(\".\")))\n  ) {\n    if (packageSubpath !== \".\") return undefined;\n    return selectPackageTarget(mappings, \"\", false, conditions);\n  }\n  if (!isObject(mappings)) return undefined;\n  if (\n    Object.prototype.hasOwnProperty.call(mappings, packageSubpath) &&\n    !packageSubpath.includes(\"*\") &&\n    !packageSubpath.endsWith(\"/\")\n  ) {\n    return selectPackageTarget(\n      mappings[packageSubpath],\n      \"\",\n      false,\n      conditions,\n    );\n  }\n  let bestMatch = \"\";\n  let bestSubpath = \"\";\n  for (const key of Object.keys(mappings)) {\n    const wildcard = key.indexOf(\"*\");\n    if (\n      wildcard === -1 ||\n      key.lastIndexOf(\"*\") !== wildcard ||\n      !packageSubpath.startsWith(key.slice(0, wildcard))\n    ) {\n      continue;\n    }\n    const trailer = key.slice(wildcard + 1);\n    if (\n      packageSubpath.length < key.length ||\n      !packageSubpath.endsWith(trailer) ||\n      packagePatternKeyCompare(bestMatch, key) !== 1\n    ) {\n      continue;\n    }\n    bestMatch = key;\n    bestSubpath = packageSubpath.slice(\n      wildcard,\n      packageSubpath.length - trailer.length,\n    );\n  }\n  return bestMatch === \"\"\n    ? undefined\n    : selectPackageTarget(\n        mappings[bestMatch],\n        bestSubpath,\n        true,\n        conditions,\n      );\n}\n\nfunction selectPackageTarget(\n  target: unknown,\n  subpath: string,\n  pattern: boolean,\n  conditions: ReadonlySet<string>,\n): string | null | undefined {\n  if (typeof target === \"string\") {\n    const selected = pattern ? target.replaceAll(\"*\", subpath) : target;\n    return validPackageExportsTarget(selected) ? selected : undefined;\n  }\n  if (Array.isArray(target)) {\n    for (const item of target) {\n      const selected = selectPackageTarget(\n        item,\n        subpath,\n        pattern,\n        conditions,\n      );\n      if (selected !== undefined && selected !== null) return selected;\n    }\n    return null;\n  }\n  if (isObject(target)) {\n    for (const [condition, value] of Object.entries(target)) {\n      if (condition !== \"default\" && !conditions.has(condition)) continue;\n      const selected = selectPackageTarget(\n        value,\n        subpath,\n        pattern,\n        conditions,\n      );\n      if (selected !== undefined) return selected;\n    }\n    return undefined;\n  }\n  return target === null ? null : undefined;\n}\n\nfunction packagePatternKeyCompare(left: string, right: string): number {\n  const leftWildcard = left.indexOf(\"*\");\n  const rightWildcard = right.indexOf(\"*\");\n  const leftBase =\n    leftWildcard === -1 ? left.length : leftWildcard + 1;\n  const rightBase =\n    rightWildcard === -1 ? right.length : rightWildcard + 1;\n  if (leftBase > rightBase) return -1;\n  if (rightBase > leftBase) return 1;\n  if (leftWildcard === -1) return 1;\n  if (rightWildcard === -1) return -1;\n  if (left.length > right.length) return -1;\n  if (right.length > left.length) return 1;\n  return 0;\n}\n\nfunction packageExportsTarget(\n  packageRoot: string,\n  target: string,\n): string | undefined {\n  if (!validPackageExportsTarget(target)) return undefined;\n  try {\n    // Node resolves an exports target as a URL against the package manifest,\n    // so percent escapes, query strings, and fragments all take part in the\n    // path it finally loads. Joining the raw target by hand diverges from that\n    // whenever the target is anything but a plain relative path, and a target\n    // Node resolves while this model rejects loses the selected file's\n    // fingerprint, leaving a retargeted symlink cached as fresh.\n    const packageUrl = pathToFileURL(path.join(packageRoot, \"package.json\"));\n    const resolved = new URL(target, packageUrl);\n    const packagePath = new URL(\".\", packageUrl).pathname;\n    if (!resolved.pathname.startsWith(packagePath)) return undefined;\n    return fileURLToPath(resolved);\n  } catch {\n    return undefined;\n  }\n}\n\nfunction validPackageExportsTarget(target: string): boolean {\n  if (!target.startsWith(\"./\") || /%2f|%5c/i.test(target)) return false;\n  const components = target\n    .slice(2)\n    .replaceAll(\"\\\\\", \"/\")\n    .split(\"/\");\n  if (\n    components.some(\n      (component) => {\n        try {\n          const decoded = decodeURIComponent(component);\n          return (\n            decoded === \".\" ||\n            decoded === \"..\" ||\n            decoded.includes(\"/\") ||\n            decoded.includes(\"\\\\\") ||\n            decoded.toLowerCase() === \"node_modules\"\n          );\n        } catch {\n          return true;\n        }\n      },\n    )\n  ) {\n    return false;\n  }\n  return true;\n}\n\nfunction packagePathCandidateMatchesChild(\n  candidate: string,\n  childLocation: string,\n  legacy: boolean,\n): boolean {\n  let child: string;\n  try {\n    child = fs.realpathSync.native(childLocation);\n  } catch {\n    child = path.resolve(childLocation);\n  }\n  const candidates = legacy\n    ? [\n        candidate,\n        candidate + \".js\",\n        candidate + \".json\",\n        candidate + \".node\",\n        path.join(candidate, \"index.js\"),\n        path.join(candidate, \"index.json\"),\n        path.join(candidate, \"index.node\"),\n      ]\n    : [candidate];\n  return candidates.some((location) => {\n    try {\n      return sameResolutionPath(fs.realpathSync.native(location), child);\n    } catch {\n      return false;\n    }\n  });\n}\n\nfunction recordPackageSubpathTopology(\n  packageRoot: string,\n  subpath: string,\n  childLocation: string,\n  owners: readonly string[],\n): boolean {\n  const candidate = boundedPackageTarget(packageRoot, subpath);\n  if (candidate === undefined) return false;\n  recordPackagePathCandidate(candidate, owners);\n  recordLegacyPackagePathCandidates(candidate, owners);\n  let selected = packagePathCandidateMatchesChild(\n    candidate,\n    childLocation,\n    true,\n  );\n  try {\n    if (!fs.statSync(candidate).isDirectory()) return selected;\n  } catch {\n    return selected;\n  }\n  const manifest = path.join(candidate, \"package.json\");\n  if (!recordOptionalFileDependency(manifest, owners)) return selected;\n  try {\n    const value = JSON.parse(fs.readFileSync(manifest, \"utf8\"));\n    if (value !== null && typeof value === \"object\") {\n      const metadata = value as Record<string, unknown>;\n      if (typeof metadata.main === \"string\") {\n        const main = path.resolve(candidate, metadata.main);\n        recordPackagePathCandidate(main, owners);\n        recordLegacyPackagePathCandidates(main, owners);\n        selected =\n          packagePathCandidateMatchesChild(main, childLocation, true) ||\n          selected;\n      }\n    }\n  } catch {\n    // Node owns malformed nested-package diagnostics.\n  }\n  return selected;\n}\n\nfunction boundedPackageTarget(\n  packageRoot: string,\n  target: string,\n): string | undefined {\n  const candidate = path.resolve(packageRoot, target);\n  const relative = path.relative(packageRoot, candidate);\n  if (\n    relative === \"..\" ||\n    relative.startsWith(\"..\" + path.sep) ||\n    path.isAbsolute(relative)\n  ) {\n    return undefined;\n  }\n  return candidate;\n}\n\nfunction recordPackagePathCandidate(\n  candidate: string,\n  owners: readonly string[],\n  visited: Set<string> = new Set(),\n  depth = 0,\n): void {\n  const normalized = path.resolve(candidate);\n  // The depth bound owns termination. A platform-wide case fold would merge\n  // paths that differ only by case, which a per-directory case-sensitive\n  // Windows tree keeps distinct, and would truncate a valid symlink chain.\n  if (depth >= 64 || visited.has(normalized)) return;\n  visited.add(normalized);\n  const parsed = path.parse(normalized);\n  const components = normalized\n    .slice(parsed.root.length)\n    .split(path.sep)\n    .filter(Boolean);\n  let current = parsed.root;\n  for (let index = 0; index < components.length; index++) {\n    const component = components[index];\n    const next = path.join(current, component);\n    let entry: ReturnType<typeof fs.lstatSync>;\n    try {\n      entry = fs.lstatSync(next);\n    } catch {\n      recordDirectoryDependency(current, owners);\n      return;\n    }\n    if (entry.isSymbolicLink()) {\n      // The containing directory digest carries the raw link target.\n      recordDirectoryDependency(current, owners);\n      try {\n        const target = fs.readlinkSync(next);\n        const remainder = components.slice(index + 1);\n        recordPackagePathCandidate(\n          path.join(\n            path.resolve(current, target),\n            ...remainder,\n          ),\n          owners,\n          visited,\n          depth + 1,\n        );\n      } catch {\n        // The lexical link record already carries the unreadable state.\n      }\n    }\n    let isDirectory = entry.isDirectory();\n    if (entry.isSymbolicLink()) {\n      try {\n        isDirectory = fs.statSync(next).isDirectory();\n      } catch {\n        return;\n      }\n    }\n    if (index === components.length - 1) {\n      recordDirectoryDependency(isDirectory ? next : current, owners);\n      return;\n    }\n    if (!isDirectory) {\n      recordDirectoryDependency(current, owners);\n      return;\n    }\n    current = next;\n  }\n  recordDirectoryDependency(current, owners);\n}\n\nfunction modulePackageName(specifier: string): string | undefined {\n  if (specifier.startsWith(\"@\")) {\n    const components = specifier.split(\"/\");\n    return components.length >= 2\n      ? components[0] + \"/\" + components[1]\n      : undefined;\n  }\n  const [name] = specifier.split(\"/\");\n  return name && !name.startsWith(\"#\") ? name : undefined;\n}\n\nfunction resolvedPackageContains(\n  modules: string,\n  packageName: string,\n  childLocation: string,\n): boolean {\n  try {\n    const packageRoot = fs.realpathSync(path.join(modules, packageName));\n    const child = fs.realpathSync(childLocation);\n    const relative = path.relative(packageRoot, child);\n    if (relative === \"..\" || relative.startsWith(\"..\" + path.sep) || path.isAbsolute(relative)) {\n      return false;\n    }\n    let ancestor = child;\n    const depth = relative === \"\" ? 0 : relative.split(path.sep).length;\n    for (let i = 0; i < depth; i++) ancestor = path.dirname(ancestor);\n    return sameResolutionPath(packageRoot, ancestor);\n  } catch {\n    return false;\n  }\n}\n\nfunction sameResolutionPath(left: string, right: string): boolean {\n  const leftPath = path.resolve(left);\n  const rightPath = path.resolve(right);\n  if (leftPath === rightPath) return true;\n  if (path.relative(leftPath, rightPath) !== \"\") return false;\n  // A native lexical case fold does not establish filesystem identity.\n  // Verify case aliases without merging differently located hard links.\n  try {\n    const leftInfo = fs.statSync(leftPath, { bigint: true });\n    const rightInfo = fs.statSync(rightPath, { bigint: true });\n    return leftInfo.ino !== 0n && leftInfo.dev === rightInfo.dev && leftInfo.ino === rightInfo.ino;\n  } catch {\n    return false;\n  }\n}\n\nfunction samePhysicalPath(left: string, right: string): boolean {\n  try {\n    return sameResolutionPath(realPath(left), realPath(right));\n  } catch {\n    // Exact lexical spelling is still usable when a file disappears. A case\n    // alias remains unproven until the filesystem identifies both paths.\n    return sameResolutionPath(left, right);\n  }\n}\n\n/**\n * The config's real path, or its declared one when the volume will not say.\n *\n * A config can disappear between the host reading it and this loader starting,\n * and a throw here would replace a precise report from the import below with a\n * crash in bookkeeping. Seeding lexically instead only risks the demotion this\n * value exists to prevent, on a file that is already gone.\n */\nfunction realConfigLocation(): string {\n  try {\n    return realPath(configLocation);\n  } catch {\n    return configLocation;\n  }\n}\n\nfunction realPath(location: string): string {\n  return fs.realpathSync.native\n    ? fs.realpathSync.native(location)\n    : fs.realpathSync(location);\n}\n\nfunction finalizeDependencies(): Array<{\n  digest: string;\n  identityStable: boolean;\n  kind: \"directory\" | \"file\" | \"optional-file\";\n  path: string;\n  realpath: string | null;\n  scope: \"cache\" | \"watch\";\n}> {\n  // The evaluator may have observed a dependency, run arbitrary config code,\n  // and then serialize after that path changed again. Re-read every recorded\n  // dependency under its original ownership set. Differences between recorded\n  // observations invalidate reuse; identical digest and realpath observations\n  // do not establish that no transient replacement occurred between them.\n  for (const dependency of [...dependencies.values()]) {\n    recordDependency(\n      dependency.kind,\n      dependency.path,\n      currentDependencyDigest(dependency.kind, dependency.path),\n      [...dependency.owners],\n    );\n  }\n  const watched = graphWatchReachability();\n  return [...dependencies.values()].map(({ owners, ...dependency }) => ({\n    ...dependency,\n    scope: [...owners].some((owner) => watched.has(owner))\n      ? \"watch\"\n      : \"cache\",\n  }));\n}\n\nfunction currentDependencyDigest(\n  kind: \"directory\" | \"file\" | \"optional-file\",\n  location: string,\n): string {\n  try {\n    if (kind === \"directory\") return directoryDigest(location);\n    if (kind === \"optional-file\") return optionalFileDigest(location);\n    return createHash(\"sha256\")\n      .update(fs.readFileSync(location))\n      .digest(\"hex\");\n  } catch {\n    return \"\";\n  }\n}\n\nfunction graphWatchReachability(): Set<string> {\n  const adjacency = new Map<string, typeof graphEdges>();\n  for (const edge of graphEdges) {\n    const outgoing = adjacency.get(edge.parent) ?? [];\n    outgoing.push(edge);\n    adjacency.set(edge.parent, outgoing);\n  }\n  const queue: Array<{ url: string; watched: boolean }> =\n    configUrlSpellings.map((url) => ({ url, watched: true }));\n  const visited = new Set<string>();\n  const watched = new Set<string>();\n  for (let head = 0; head < queue.length; head++) {\n    const state = queue[head]!;\n    const key = state.url + \"\\0\" + (state.watched ? \"1\" : \"0\");\n    if (visited.has(key)) continue;\n    visited.add(key);\n    if (state.watched) watched.add(state.url);\n    for (const edge of adjacency.get(state.url) ?? []) {\n      const childLocation = graphNodes.get(edge.child);\n      const childWatched = edge.packageBoundary\n        ? false\n        : childLocation !== undefined && !pathHasNodeModules(childLocation)\n          ? true\n          : state.watched;\n      queue.push({ url: edge.child, watched: childWatched });\n    }\n  }\n  return watched;\n}\n\nfunction hasOwn(value: Record<string, unknown>, key: string): boolean {\n  return Object.prototype.hasOwnProperty.call(value, key);\n}\n\nasync function resolveConfig(value: unknown, allowNamedConfig: boolean): Promise<unknown> {\n  let current = value;\n  for (let i = 0; i < 8; i++) {\n    if (typeof current === \"function\") {\n      current = await (current as () => unknown | Promise<unknown>)();\n      allowNamedConfig = false;\n      continue;\n    }\n    if (isObject(current) && !Array.isArray(current)) {\n      if (hasOwn(current, \"default\")) {\n        const defaultValue = current.default;\n        if (isModuleNamespace(current) || !hasConfigKey(current)) {\n          current = defaultValue;\n          allowNamedConfig = false;\n          continue;\n        }\n        const normalizedDefault = await resolveConfig(defaultValue, false);\n        if (isObject(normalizedDefault) && !Array.isArray(normalizedDefault)) {\n          current = mergeConfigObjects(normalizedDefault, current);\n          allowNamedConfig = false;\n          continue;\n        }\n      }\n      if (allowNamedConfig && hasOwn(current, \"config\")) {\n        current = current.config;\n        allowNamedConfig = false;\n        continue;\n      }\n    }\n    break;\n  }\n  return current;\n}\n\nfunction isModuleNamespace(value: Record<string, unknown>): boolean {\n  return Object.prototype.toString.call(value) === \"[object Module]\";\n}\n\nfunction hasConfigKey(value: Record<string, unknown>): boolean {\n  for (const key of CONFIG_KEYS) {\n    if (hasOwn(value, key)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction mergeConfigObjects(\n  base: Record<string, unknown>,\n  override: Record<string, unknown>,\n): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  for (const key of CONFIG_KEYS) {\n    if (hasOwn(base, key)) {\n      out[key] = base[key];\n    }\n  }\n  for (const key of CONFIG_KEYS) {\n    if (hasOwn(override, key)) {\n      out[key] = override[key];\n    }\n  }\n  return out;\n}\n\n// Follow the same containing-file-relative, base-first extends chain as the\n// native config reader. Each explicit base is a watch input even when it lives\n// in node_modules; imports made by that base retain ordinary package boundaries.\nasync function collectPluginEntries(\n  value: unknown,\n  location: string,\n  chain: readonly string[],\n): Promise<Array<{ namespace: string; source: string } | { configFile: string; chain: readonly string[] }>> {\n  const out: Array<{ namespace: string; source: string } | { configFile: string; chain: readonly string[] }> = [];\n  if (Array.isArray(value)) {\n    for (const item of value) out.push(...await collectPluginEntries(item, location, chain));\n    return out;\n  }\n  if (!isObject(value)) return out;\n  if (value.extends !== undefined && value.extends !== null) {\n    if (typeof value.extends !== \"string\" || value.extends.trim() === \"\") {\n      throw new Error(\"extends must be a non-empty string path to another config file\");\n    }\n    const next = path.resolve(path.dirname(location), value.extends);\n    if (chain.includes(next)) {\n      throw new Error(\"extends cycle detected: \" + [...chain, next].join(\" -> \"));\n    }\n    if (chain.length >= 32) {\n      throw new Error(\"extends chain exceeds the depth limit of 32: \" + chain.join(\" -> \"));\n    }\n    const nextUrl = pathToFileURL(next).href;\n    const parentUrl = pathToFileURL(location).href;\n    configEntryUrls.add(nextUrl);\n    graphNodes.set(nextUrl, next);\n    graphEdges.push({ child: nextUrl, packageBoundary: false, parent: parentUrl });\n    recordDependency(\"file\", next, createHash(\"sha256\").update(fs.readFileSync(next)).digest(\"hex\"), [nextUrl]);\n    recordPackageManifests(next, [nextUrl]);\n    // The owning parent evaluates typed bases under their own synthetic project.\n    // A dynamic import here would give a typed base the consumer's tsconfig\n    // when it falls outside this evaluator's entry manifest.\n    if ([\".ts\", \".cts\", \".mts\"].includes(path.extname(next).toLowerCase())) {\n      out.push({ configFile: next, chain: [...chain, next] });\n    } else {\n      const imported = next.toLowerCase().endsWith(\".json\")\n        ? JSON.parse(fs.readFileSync(next, \"utf8\").replace(/^\uFEFF/, \"\"))\n        : await import(nextUrl);\n      const base = await resolveConfig(imported, true);\n      out.push(...await collectPluginEntries(base, next, [...chain, next]));\n    }\n  }\n  if (hasOwn(value, \"plugins\") && isObject(value.plugins)) {\n    for (const [namespace, plugin] of Object.entries(value.plugins)) {\n      const source = extractPluginSource(plugin, location);\n      if (source === undefined || source.length === 0) {\n        throw new Error(\"contributor \" + JSON.stringify(namespace) + \" must resolve to an object with a non-empty source string\");\n      }\n      out.push({ namespace, source });\n    }\n  }\n  return out;\n}\n\nfunction extractPluginSource(value: unknown, location: string): string | undefined {\n  if (typeof value === \"string\") {\n    value = createRequire(pathToFileURL(location))(value);\n  }\n  if (!isObject(value)) return undefined;\n  // ESM-from-CJS interop wraps CJS modules' `exports.default` so the\n  // plugin object can land under a `.default` indirection. Walk a few\n  // hops so contributors authored as `export default plugin` and\n  // contributors authored as plain `module.exports = plugin` both\n  // resolve identically.\n  let current: Record<string, unknown> = value;\n  // Bound default-wrapper traversal so a cyclic descriptor cannot loop.\n  for (let i = 0; i < 8; i++) {\n    if (typeof current.source === \"string\") break;\n    const next = current.default;\n    if (!isObject(next)) break;\n    current = next;\n  }\n  const source = current.source;\n  return typeof source === \"string\" ? source : undefined;\n}\n";
+export {};