@typed/virtual-modules-ts-plugin 1.0.0-beta.1

package/dist/plugin.js

@@ -0,0 +1,2475 @@
+"use strict";
+
+// ../virtual-modules/dist/types.js
+function isVirtualModuleBuildError(result) {
+  return typeof result === "object" && result !== null && "errors" in result && Array.isArray(result.errors) && result.errors.length > 0;
+}
+function isVirtualModuleBuildSuccess(result) {
+  return typeof result === "object" && result !== null && "sourceText" in result && typeof result.sourceText === "string";
+}
+
+// ../virtual-modules/dist/internal/sanitize.js
+function sanitizeErrorMessage(message) {
+  const withoutStack = message.split(/\r?\n/).filter((line) => !/^\s*at\s+/.test(line.trim())).join("\n").trim();
+  const unixPath = /\/[\w./-]+\/[\w./-]+(?:\/[\w./-]*)*/g;
+  const winPath = /[A-Za-z]:[\\/][\w.-]+(?:[\\/][\w.-]+)*/g;
+  let out = withoutStack.replace(unixPath, "[path]").replace(winPath, "[path]");
+  return out.replace(/\s{2,}/g, " ").trim();
+}
+
+// ../virtual-modules/dist/internal/validation.js
+var DEFAULT_MAX_LENGTH = 4096;
+function validateNonEmptyString(value, name, maxLength = DEFAULT_MAX_LENGTH) {
+  if (typeof value !== "string") {
+    return { ok: false, reason: `${name} must be a string` };
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return { ok: false, reason: `${name} must be non-empty` };
+  }
+  if (value.includes("\0")) {
+    return { ok: false, reason: `${name} must not contain null bytes` };
+  }
+  if (value.length > maxLength) {
+    return { ok: false, reason: `${name} exceeds max length ${maxLength}` };
+  }
+  return { ok: true, value: trimmed };
+}
+function validatePathSegment(value, name, maxLength = DEFAULT_MAX_LENGTH) {
+  if (typeof value !== "string") {
+    return { ok: false, reason: `${name} must be a string` };
+  }
+  if (value.length === 0 || value.trim() === "") {
+    return { ok: false, reason: `${name} must be non-empty` };
+  }
+  if (value.includes("\0")) {
+    return { ok: false, reason: `${name} must not contain null bytes` };
+  }
+  if (value.length > maxLength) {
+    return { ok: false, reason: `${name} exceeds max length ${maxLength}` };
+  }
+  return { ok: true, value };
+}
+function validateRelativeGlobs(value, name, maxLength = DEFAULT_MAX_LENGTH) {
+  const arr = Array.isArray(value) ? value : value === void 0 || value === null ? [] : [value];
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    const v = arr[i];
+    const r = validatePathSegment(v, `${name}[${i}]`, maxLength);
+    if (!r.ok)
+      return r;
+    const normalized = r.value.replaceAll("\\", "/");
+    if (normalized.includes("..")) {
+      return { ok: false, reason: `${name}[${i}] must not contain parent path segments (..)` };
+    }
+    if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized)) {
+      return { ok: false, reason: `${name}[${i}] must be a relative glob, not absolute` };
+    }
+    result.push(r.value);
+  }
+  return { ok: true, value: result };
+}
+
+// ../virtual-modules/dist/PluginManager.js
+var noopTypeInfoApi = {
+  file: () => ({ ok: false, error: "invalid-input" }),
+  directory: () => [],
+  resolveExport: () => void 0,
+  isAssignableTo: () => false
+};
+var noopSession = {
+  api: noopTypeInfoApi,
+  consumeDependencies: () => []
+};
+var toMessage = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+var createDiagnostic = (code, pluginName, message) => ({
+  code,
+  pluginName,
+  message
+});
+var PluginManager = class {
+  #plugins;
+  constructor(plugins = []) {
+    this.#plugins = [...plugins];
+  }
+  get plugins() {
+    return this.#plugins;
+  }
+  register(plugin) {
+    this.#plugins.push(plugin);
+  }
+  registerMany(plugins) {
+    for (const plugin of plugins) {
+      this.register(plugin);
+    }
+  }
+  resolveModule(options) {
+    const idResult = validateNonEmptyString(options.id, "options.id");
+    if (!idResult.ok) {
+      return {
+        status: "error",
+        diagnostic: createDiagnostic("invalid-options", "", idResult.reason)
+      };
+    }
+    const importerResult = validateNonEmptyString(options.importer, "options.importer");
+    if (!importerResult.ok) {
+      return {
+        status: "error",
+        diagnostic: createDiagnostic("invalid-options", "", importerResult.reason)
+      };
+    }
+    const createSession = options.createTypeInfoApiSession;
+    for (const plugin of this.#plugins) {
+      const nameResult = validateNonEmptyString(plugin.name, "Plugin name");
+      if (!nameResult.ok) {
+        return {
+          status: "error",
+          diagnostic: createDiagnostic("invalid-options", "", nameResult.reason)
+        };
+      }
+      const shouldResolve = this.#safeShouldResolve(plugin, options.id, options.importer);
+      if (shouldResolve.status === "error") {
+        return shouldResolve;
+      }
+      if (!shouldResolve.value) {
+        continue;
+      }
+      let session;
+      try {
+        session = createSession?.({ id: options.id, importer: options.importer }) ?? noopSession;
+      } catch (error) {
+        const msg = toMessage(error);
+        if (msg.includes("Program not yet available") || msg.includes("TypeInfo session creation failed")) {
+          continue;
+        }
+        return {
+          status: "error",
+          diagnostic: createDiagnostic("session-creation-failed", plugin.name, `Session creation failed: ${sanitizeErrorMessage(msg)}`)
+        };
+      }
+      try {
+        const result = plugin.build(options.id, options.importer, session.api);
+        if (typeof result === "string") {
+          return {
+            status: "resolved",
+            pluginName: plugin.name,
+            sourceText: result,
+            dependencies: session.consumeDependencies()
+          };
+        }
+        if (isVirtualModuleBuildError(result)) {
+          const first = result.errors[0];
+          const diagnostic = first && typeof first === "object" && typeof first.code === "string" && typeof first.message === "string" && typeof first.pluginName === "string" ? first : createDiagnostic("invalid-build-output", plugin.name, `Plugin "${plugin.name}" returned errors with invalid diagnostic shape`);
+          return { status: "error", diagnostic };
+        }
+        if (isVirtualModuleBuildSuccess(result)) {
+          return {
+            status: "resolved",
+            pluginName: plugin.name,
+            sourceText: result.sourceText,
+            dependencies: session.consumeDependencies(),
+            ...result.warnings?.length ? { warnings: result.warnings } : {}
+          };
+        }
+        return {
+          status: "error",
+          diagnostic: createDiagnostic("invalid-build-output", plugin.name, `Plugin "${plugin.name}" returned a non-string build result`)
+        };
+      } catch (error) {
+        return {
+          status: "error",
+          diagnostic: createDiagnostic("plugin-build-threw", plugin.name, `Plugin "${plugin.name}" build failed: ${sanitizeErrorMessage(toMessage(error))}`)
+        };
+      }
+    }
+    return { status: "unresolved" };
+  }
+  #safeShouldResolve(plugin, id, importer) {
+    try {
+      return {
+        status: "ok",
+        value: plugin.shouldResolve(id, importer)
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        diagnostic: createDiagnostic("plugin-should-resolve-threw", plugin.name, `Plugin "${plugin.name}" shouldResolve failed: ${sanitizeErrorMessage(toMessage(error))}`)
+      };
+    }
+  }
+};
+
+// ../virtual-modules/dist/collectTypeTargetSpecs.js
+function collectTypeTargetSpecsFromPlugins(plugins) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const plugin of plugins) {
+    const specs = plugin.typeTargetSpecs;
+    if (!specs?.length)
+      continue;
+    for (const spec of specs) {
+      if (!seen.has(spec.id)) {
+        seen.add(spec.id);
+        result.push(spec);
+      }
+    }
+  }
+  return result;
+}
+
+// ../virtual-modules/dist/TypeInfoApi.js
+var import_node_path2 = require("path");
+
+// ../virtual-modules/dist/internal/tsInternal.js
+function getIndexInfosOfType(type, checker) {
+  try {
+    const fn = checker.getIndexInfosOfType;
+    return fn?.(type);
+  } catch {
+    return void 0;
+  }
+}
+function getAliasedSymbol(symbol, checker, tsMod) {
+  if ((symbol.flags & tsMod.SymbolFlags.Alias) === 0)
+    return symbol;
+  try {
+    const aliased = checker.getAliasedSymbol(symbol);
+    return aliased ?? symbol;
+  } catch {
+    return symbol;
+  }
+}
+function getTypeReferenceTarget(type, checker) {
+  try {
+    const args = checker.getTypeArguments(type);
+    if (args.length > 0) {
+      const target = type.target;
+      return target;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getTypeSymbol(type) {
+  return type.symbol;
+}
+function getSymbolExports(symbol) {
+  return symbol.exports;
+}
+function getBaseTypes(type, checker) {
+  try {
+    const fn = checker.getBaseTypes;
+    return fn?.(type);
+  } catch {
+    return void 0;
+  }
+}
+var FALLBACK_OBJECT_FLAGS_MAPPED = 32;
+
+// ../virtual-modules/dist/internal/path.js
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var VIRTUAL_NODE_MODULES_RELATIVE = "node_modules/.typed/virtual";
+var toPosixPath = (path) => path.replaceAll("\\", "/");
+var resolveRelativePath = (baseDir, relativePath) => toPosixPath((0, import_node_path.resolve)(baseDir, relativePath));
+function resolvePathUnderBase(baseDir, relativePath) {
+  const baseAbs = (0, import_node_path.resolve)(baseDir);
+  const resolved = (0, import_node_path.resolve)(baseDir, relativePath);
+  const rel = (0, import_node_path.relative)(baseAbs, resolved);
+  if (rel.startsWith("..") || (0, import_node_path.isAbsolute)(rel)) {
+    return { ok: false, error: "path-escapes-base" };
+  }
+  return { ok: true, path: toPosixPath(resolved) };
+}
+function pathIsUnderBase(baseDir, absolutePath) {
+  let baseAbs;
+  let resolvedAbs;
+  try {
+    baseAbs = (0, import_node_fs.realpathSync)((0, import_node_path.resolve)(baseDir));
+    resolvedAbs = (0, import_node_fs.realpathSync)((0, import_node_path.resolve)(absolutePath));
+  } catch {
+    baseAbs = (0, import_node_path.resolve)(baseDir);
+    resolvedAbs = (0, import_node_path.resolve)(absolutePath);
+  }
+  const rel = (0, import_node_path.relative)(baseAbs, resolvedAbs);
+  if (rel.startsWith("..") || (0, import_node_path.isAbsolute)(rel)) {
+    return false;
+  }
+  return true;
+}
+var stableHash = (input) => (0, import_node_crypto.createHash)("sha1").update(input).digest("hex").slice(0, 16);
+var sanitizeSegment = (value) => value.replaceAll(/[^a-zA-Z0-9._-]/g, "-");
+var VIRTUAL_MODULE_URI_SCHEME = "typed-virtual";
+var createVirtualKey = (id, importer) => `${importer}::${id}`;
+var createVirtualFileName = (pluginName, virtualKey, params, options) => {
+  const safePluginName = sanitizeSegment(pluginName);
+  const hash = stableHash(virtualKey);
+  const basename = `__virtual_${safePluginName}_${hash}.ts`;
+  if (params) {
+    const projectRoot = options?.projectRoot;
+    if (typeof projectRoot === "string" && projectRoot.trim().length > 0) {
+      return toPosixPath((0, import_node_path.join)((0, import_node_path.resolve)(projectRoot), VIRTUAL_NODE_MODULES_RELATIVE, basename));
+    }
+    const importerDir = (0, import_node_path.dirname)(toPosixPath(params.importer));
+    return `${importerDir}/${basename}`;
+  }
+  return `${VIRTUAL_MODULE_URI_SCHEME}://0/${safePluginName}/${hash}.ts`;
+};
+var createWatchDescriptorKey = (descriptor) => {
+  if (descriptor.type === "file") {
+    return `file:${toPosixPath(descriptor.path)}`;
+  }
+  const globs = [...descriptor.relativeGlobs].sort().join("|");
+  return `glob:${toPosixPath(descriptor.baseDir)}:${descriptor.recursive ? "r" : "nr"}:${globs}`;
+};
+var dedupeSorted = (values) => [...new Set(values.map(toPosixPath))].sort();
+
+// ../virtual-modules/dist/TypeInfoApi.js
+var TYPE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".d.ts"];
+var DEFAULT_MAX_DEPTH = 6;
+var compareByName = (a, b) => a.name.localeCompare(b.name);
+var toOptionalFlag = (symbol, tsMod) => (symbol.flags & tsMod.SymbolFlags.Optional) !== 0;
+var hasReadonlyModifier = (declaration, tsMod) => {
+  if (!declaration || !tsMod.canHaveModifiers(declaration)) {
+    return false;
+  }
+  const modifiers = tsMod.getModifiers(declaration);
+  return modifiers?.some((modifier) => modifier.kind === tsMod.SyntaxKind.ReadonlyKeyword) ?? false;
+};
+var asLiteral = (type, checker, tsMod) => {
+  const text = checker.typeToString(type);
+  if ((type.flags & tsMod.TypeFlags.StringLiteral) !== 0 || (type.flags & tsMod.TypeFlags.NumberLiteral) !== 0 || (type.flags & tsMod.TypeFlags.BooleanLiteral) !== 0 || (type.flags & tsMod.TypeFlags.BigIntLiteral) !== 0) {
+    return { kind: "literal", text };
+  }
+  return void 0;
+};
+var serializeFunctionSignature = (signature, checker, tsMod, depth, maxDepth, visited, onInternalError, registry) => {
+  const parameters = signature.getParameters().map((parameter) => {
+    const declaration = parameter.valueDeclaration ?? parameter.declarations?.[0];
+    const parameterType = declaration ? checker.getTypeOfSymbolAtLocation(parameter, declaration) : checker.getDeclaredTypeOfSymbol(parameter);
+    return {
+      name: parameter.getName(),
+      optional: toOptionalFlag(parameter, tsMod),
+      type: serializeTypeNode(parameterType, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry)
+    };
+  });
+  const returnType = serializeTypeNode(checker.getReturnTypeOfSignature(signature), checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry);
+  return {
+    parameters: parameters.sort(compareByName),
+    returnType
+  };
+};
+var serializeObjectProperties = (type, checker, tsMod, depth, maxDepth, visited, onInternalError, registry) => {
+  const properties = checker.getPropertiesOfType(type);
+  const snapshots = properties.map((property) => {
+    const declaration = property.valueDeclaration ?? property.declarations?.[0];
+    const propertyType = declaration ? checker.getTypeOfSymbolAtLocation(property, declaration) : checker.getDeclaredTypeOfSymbol(property);
+    return {
+      name: property.getName(),
+      optional: toOptionalFlag(property, tsMod),
+      readonly: hasReadonlyModifier(declaration, tsMod),
+      type: serializeTypeNode(propertyType, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry)
+    };
+  });
+  return snapshots.sort(compareByName);
+};
+var serializeIndexSignature = (type, checker, tsMod, depth, maxDepth, visited, onInternalError, registry) => {
+  const infos = getIndexInfosOfType(type, checker);
+  if (!infos || infos.length === 0)
+    return void 0;
+  const first = infos[0];
+  if (!first)
+    return void 0;
+  return {
+    keyType: serializeTypeNode(first.keyType, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry),
+    valueType: serializeTypeNode(first.type, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry),
+    readonly: first.isReadonly ?? false
+  };
+};
+var primitiveTypeNode = (type, checker, tsMod) => {
+  const text = checker.typeToString(type);
+  if ((type.flags & tsMod.TypeFlags.Any) !== 0) {
+    return { kind: "any", text };
+  }
+  if ((type.flags & tsMod.TypeFlags.Unknown) !== 0) {
+    return { kind: "unknown", text };
+  }
+  if ((type.flags & tsMod.TypeFlags.Never) !== 0) {
+    return { kind: "never", text };
+  }
+  if ((type.flags & tsMod.TypeFlags.StringLike) !== 0 || (type.flags & tsMod.TypeFlags.NumberLike) !== 0 || (type.flags & tsMod.TypeFlags.BooleanLike) !== 0 || (type.flags & tsMod.TypeFlags.BigIntLike) !== 0 || (type.flags & tsMod.TypeFlags.ESSymbolLike) !== 0 || (type.flags & tsMod.TypeFlags.Null) !== 0 || (type.flags & tsMod.TypeFlags.Undefined) !== 0 || (type.flags & tsMod.TypeFlags.Void) !== 0) {
+    return { kind: "primitive", text };
+  }
+  return void 0;
+};
+var UNKNOWN_NODE = { kind: "unknown", text: "unknown" };
+var serializeTypeNode = (type, checker, tsMod, depth, maxDepth, visited, onInternalError, registry) => {
+  const text = checker.typeToString(type);
+  const reg = (node) => {
+    registry?.set(node, type);
+    return node;
+  };
+  const typeId = `${type.id ?? "anon"}:${text}`;
+  if (depth > maxDepth || visited.has(typeId)) {
+    return reg({ kind: "reference", text });
+  }
+  visited.add(typeId);
+  const literal = asLiteral(type, checker, tsMod);
+  if (literal) {
+    return reg(literal);
+  }
+  if (type.isUnion()) {
+    const union = {
+      kind: "union",
+      text,
+      elements: type.types.map((value) => serializeTypeNode(value, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry))
+    };
+    return reg(union);
+  }
+  if (type.isIntersection()) {
+    const intersection = {
+      kind: "intersection",
+      text,
+      elements: type.types.map((value) => serializeTypeNode(value, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry))
+    };
+    return reg(intersection);
+  }
+  const primitive = primitiveTypeNode(type, checker, tsMod);
+  if (primitive) {
+    return reg(primitive);
+  }
+  if ((type.flags & tsMod.TypeFlags.Enum) !== 0) {
+    const members = [];
+    try {
+      const props = checker.getPropertiesOfType(type);
+      for (const sym of props) {
+        const name = sym.name;
+        let value;
+        const decl = sym.valueDeclaration;
+        if (decl && tsMod.isEnumMember?.(decl) && decl.initializer) {
+          const init2 = decl.initializer;
+          if (tsMod.isNumericLiteral?.(init2)) {
+            value = parseInt(init2.text, 10);
+          } else if (tsMod.isStringLiteral?.(init2) || tsMod.isNoSubstitutionTemplateLiteral?.(init2)) {
+            value = init2.text;
+          } else {
+            const cv = checker.getConstantValue?.(init2);
+            if (cv !== void 0)
+              value = cv;
+          }
+        }
+        members.push(value !== void 0 ? { name, value } : { name });
+      }
+    } catch (err) {
+      onInternalError?.(err, "enum-members");
+    }
+    const enumNode = {
+      kind: "enum",
+      text,
+      members: members.length > 0 ? members : void 0
+    };
+    return reg(enumNode);
+  }
+  if ((type.flags & tsMod.TypeFlags.Conditional) !== 0) {
+    const ct = type;
+    const trueType = ct.resolvedTrueType ?? (ct.root?.node?.trueType ? checker.getTypeFromTypeNode?.(ct.root.node.trueType) : void 0);
+    const falseType = ct.resolvedFalseType ?? (ct.root?.node?.falseType ? checker.getTypeFromTypeNode?.(ct.root.node.falseType) : void 0);
+    const conditional = {
+      kind: "conditional",
+      text,
+      checkType: serializeTypeNode(ct.checkType, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry),
+      extendsType: serializeTypeNode(ct.extendsType, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry),
+      trueType: trueType ? serializeTypeNode(trueType, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry) : UNKNOWN_NODE,
+      falseType: falseType ? serializeTypeNode(falseType, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry) : UNKNOWN_NODE
+    };
+    return reg(conditional);
+  }
+  if ((type.flags & tsMod.TypeFlags.IndexedAccess) !== 0) {
+    const iat = type;
+    const indexed = {
+      kind: "indexedAccess",
+      text,
+      objectType: serializeTypeNode(iat.objectType, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry),
+      indexType: serializeTypeNode(iat.indexType, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry)
+    };
+    return reg(indexed);
+  }
+  if ((type.flags & tsMod.TypeFlags.TemplateLiteral) !== 0) {
+    const tlt = type;
+    const texts = tlt.texts ?? [];
+    const types = tlt.types ?? [];
+    const template = {
+      kind: "templateLiteral",
+      text,
+      texts,
+      types: types.map((t) => serializeTypeNode(t, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry))
+    };
+    return reg(template);
+  }
+  const objType = type;
+  const mappedFlag = tsMod.ObjectFlags?.Mapped ?? FALLBACK_OBJECT_FLAGS_MAPPED;
+  if (objType.objectFlags !== void 0 && (objType.objectFlags & mappedFlag) !== 0) {
+    const mt = type;
+    const constraintType = mt.constraint ?? mt.typeParameter?.constraint;
+    const mappedType = mt.templateType ?? mt.mappedType;
+    const mapped = {
+      kind: "mapped",
+      text,
+      constraintType: constraintType ? serializeTypeNode(constraintType, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry) : UNKNOWN_NODE,
+      mappedType: mappedType ? serializeTypeNode(mappedType, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry) : UNKNOWN_NODE
+    };
+    return reg(mapped);
+  }
+  if ((type.flags & tsMod.TypeFlags.Index) !== 0) {
+    const idxType = type;
+    const typeOperator = {
+      kind: "typeOperator",
+      text,
+      operator: "keyof",
+      type: serializeTypeNode(idxType.type, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry)
+    };
+    return reg(typeOperator);
+  }
+  if (checker.isTupleType(type)) {
+    const typeArguments = checker.getTypeArguments(type);
+    const tuple = {
+      kind: "tuple",
+      text,
+      elements: typeArguments.map((value) => serializeTypeNode(value, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry))
+    };
+    return reg(tuple);
+  }
+  if (checker.isArrayType(type)) {
+    const typeArguments = checker.getTypeArguments(type);
+    const element = typeArguments[0];
+    const array = {
+      kind: "array",
+      text,
+      elements: element ? [serializeTypeNode(element, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry)] : [UNKNOWN_NODE]
+    };
+    return reg(array);
+  }
+  const referenceArguments = checker.getTypeArguments(type);
+  if (referenceArguments.length > 0) {
+    const ref = {
+      kind: "reference",
+      text,
+      typeArguments: referenceArguments.map((value) => serializeTypeNode(value, checker, tsMod, depth + 1, maxDepth, visited, onInternalError, registry))
+    };
+    return reg(ref);
+  }
+  const constructSignatures = checker.getSignaturesOfType(type, tsMod.SignatureKind.Construct);
+  if (constructSignatures.length > 0) {
+    const sig = serializeFunctionSignature(constructSignatures[0], checker, tsMod, depth, maxDepth, visited, onInternalError, registry);
+    const ctor = {
+      kind: "constructor",
+      text,
+      parameters: sig.parameters,
+      returnType: sig.returnType
+    };
+    return reg(ctor);
+  }
+  const callSignatures = checker.getSignaturesOfType(type, tsMod.SignatureKind.Call);
+  if (callSignatures.length > 0) {
+    if (callSignatures.length > 1) {
+      const signatures = callSignatures.map((s) => {
+        const serialized = serializeFunctionSignature(s, checker, tsMod, depth, maxDepth, visited, onInternalError, registry);
+        return { parameters: serialized.parameters, returnType: serialized.returnType };
+      });
+      const overload = { kind: "overloadSet", text, signatures };
+      return reg(overload);
+    }
+    const signature = serializeFunctionSignature(callSignatures[0], checker, tsMod, depth, maxDepth, visited, onInternalError, registry);
+    const fn = {
+      kind: "function",
+      text,
+      parameters: signature.parameters,
+      returnType: signature.returnType
+    };
+    return reg(fn);
+  }
+  const indexSig = serializeIndexSignature(type, checker, tsMod, depth, maxDepth, visited, onInternalError, registry);
+  const object = {
+    kind: "object",
+    text,
+    properties: serializeObjectProperties(type, checker, tsMod, depth, maxDepth, visited, onInternalError, registry),
+    ...indexSig !== void 0 && { indexSignature: indexSig }
+  };
+  return reg(object);
+};
+function createTypeTargetBootstrapContent(specs) {
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [
+    "/**",
+    " * Auto-generated bootstrap for type target resolution.",
+    " * Imports canonical modules so resolveTypeTargetsFromSpecs can find types.",
+    " * Include in program rootNames when using typeTargetSpecs without user imports.",
+    " */"
+  ];
+  for (const spec of specs) {
+    if (seen.has(spec.module))
+      continue;
+    seen.add(spec.module);
+    const id = spec.module.replace(/\W+/g, "_").replace(/_+/g, "_") || "m";
+    lines.push(`import * as _${id} from "${spec.module}";`);
+    lines.push(`void _${id};`);
+  }
+  lines.push("export {};");
+  return lines.join("\n");
+}
+function resolveTypeTargetsFromSpecs(program, tsMod, specs) {
+  const checker = program.getTypeChecker();
+  const found = /* @__PURE__ */ new Map();
+  const getTypeFromSymbol = (symbol) => {
+    const aliased = getAliasedSymbol(symbol, checker, tsMod);
+    const decls = aliased.declarations ?? (aliased.valueDeclaration ? [aliased.valueDeclaration] : []);
+    const typeDecl = decls.find((d) => tsMod.isTypeAliasDeclaration(d) || tsMod.isInterfaceDeclaration(d) || tsMod.isTypeParameterDeclaration(d));
+    const decl = typeDecl ?? decls[0];
+    const useDeclaredType = decl && (tsMod.isTypeAliasDeclaration(decl) || tsMod.isInterfaceDeclaration(decl) || tsMod.isTypeParameterDeclaration(decl));
+    const type = useDeclaredType ? checker.getDeclaredTypeOfSymbol(aliased) : decl ? checker.getTypeOfSymbolAtLocation(aliased, decl) : checker.getDeclaredTypeOfSymbol(aliased);
+    if (!type || (type.flags & tsMod.TypeFlags.Any) !== 0)
+      return void 0;
+    return type;
+  };
+  const getTypeFromSpec = (symbol, spec) => {
+    const primaryType = getTypeFromSymbol(symbol);
+    if (!primaryType || !spec.typeMember)
+      return primaryType;
+    const aliased = getAliasedSymbol(symbol, checker, tsMod);
+    const exports2 = getSymbolExports(aliased);
+    if (!exports2)
+      return primaryType;
+    const memberSymbol = Array.from(exports2.values()).find((s) => s.getName() === spec.typeMember);
+    if (!memberSymbol)
+      return primaryType;
+    const memberType = checker.getDeclaredTypeOfSymbol(memberSymbol);
+    if (!memberType || (memberType.flags & tsMod.TypeFlags.Any) !== 0)
+      return primaryType;
+    return memberType;
+  };
+  const addFromModuleSymbol = (moduleSymbol, moduleSpec) => {
+    if (!moduleSymbol)
+      return;
+    const exportsByName = new Map(checker.getExportsOfModule(moduleSymbol).map((moduleExport) => [
+      moduleExport.getName(),
+      moduleExport
+    ]));
+    for (const spec of specs) {
+      if (spec.module !== moduleSpec || found.has(spec.id))
+        continue;
+      const moduleExport = exportsByName.get(spec.exportName);
+      if (!moduleExport)
+        continue;
+      const type = getTypeFromSpec(moduleExport, spec);
+      if (type)
+        found.set(spec.id, type);
+    }
+  };
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile)
+      continue;
+    tsMod.forEachChild(sourceFile, (node) => {
+      if (!tsMod.isImportDeclaration(node))
+        return;
+      const moduleSpecifier = node.moduleSpecifier;
+      if (!tsMod.isStringLiteral(moduleSpecifier))
+        return;
+      const moduleSpec = moduleSpecifier.text;
+      const binding = node.importClause;
+      if (!binding)
+        return;
+      const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier);
+      const addNamed = (name) => {
+        const exportName = (name.propertyName ?? name.name).getText(sourceFile);
+        const spec = specs.find((s) => s.module === moduleSpec && s.exportName === exportName);
+        if (!spec || found.has(spec.id))
+          return;
+        const symbol = checker.getSymbolAtLocation(name.name);
+        if (!symbol)
+          return;
+        const type = getTypeFromSpec(symbol, spec);
+        if (type)
+          found.set(spec.id, type);
+      };
+      if (binding.namedBindings) {
+        if (tsMod.isNamedImports(binding.namedBindings)) {
+          for (const elem of binding.namedBindings.elements) {
+            addNamed(elem);
+          }
+        } else if (tsMod.isNamespaceImport(binding.namedBindings)) {
+          const nsName = binding.namedBindings.name;
+          const symbol = checker.getSymbolAtLocation(nsName);
+          const nsType = symbol ? checker.getTypeOfSymbolAtLocation(symbol, nsName) : void 0;
+          for (const spec of specs) {
+            if (spec.module !== moduleSpec || found.has(spec.id))
+              continue;
+            const prop = nsType?.getProperty?.(spec.exportName);
+            if (!prop)
+              continue;
+            const type = getTypeFromSpec(prop, spec);
+            if (type)
+              found.set(spec.id, type);
+          }
+          addFromModuleSymbol(moduleSymbol, moduleSpec);
+        }
+      } else if (binding.name) {
+        const symbol = checker.getSymbolAtLocation(binding.name);
+        const nsType = symbol ? checker.getTypeOfSymbolAtLocation(symbol, binding.name) : void 0;
+        for (const spec of specs) {
+          if (spec.module !== moduleSpec || found.has(spec.id))
+            continue;
+          const prop = nsType?.getProperty?.(spec.exportName);
+          if (!prop)
+            continue;
+          const type = getTypeFromSpec(prop, spec);
+          if (type)
+            found.set(spec.id, type);
+        }
+        addFromModuleSymbol(moduleSymbol, moduleSpec);
+      }
+    });
+  }
+  return specs.filter((s) => found.has(s.id)).map((s) => ({ id: s.id, type: found.get(s.id) }));
+}
+var resolveExportSymbol = (symbol, checker, tsMod) => getAliasedSymbol(symbol, checker, tsMod);
+var getGenericBase = (type, checker) => getTypeReferenceTarget(type, checker);
+var getComparisonSymbol = (type, checker) => {
+  const base = getGenericBase(type, checker);
+  if (base?.symbol)
+    return base.symbol;
+  return getTypeSymbol(type);
+};
+var isAssignableTo = (source, target, checker, tsMod, mode) => {
+  if (checker.isTypeAssignableTo(source, target))
+    return true;
+  if (mode === "strict")
+    return false;
+  const tgtBase = getGenericBase(target, checker);
+  const tgtSymbol = tgtBase?.symbol ?? getTypeSymbol(target);
+  const matchSymbol = (sym) => sym && tgtSymbol && sym === tgtSymbol;
+  if (source.isUnion()) {
+    const constituents = source.types;
+    if (!constituents.every((t) => isAssignableTo(t, target, checker, tsMod, mode)))
+      return false;
+    return true;
+  }
+  const srcBase = getGenericBase(source, checker);
+  if (srcBase?.symbol && matchSymbol(srcBase.symbol))
+    return true;
+  const tgtTarget = getTypeReferenceTarget(target, checker);
+  if (srcBase?.symbol && tgtTarget?.symbol && srcBase.symbol === tgtTarget.symbol)
+    return true;
+  const srcSymbol = getComparisonSymbol(source, checker);
+  if (matchSymbol(srcSymbol))
+    return true;
+  if ((source.flags & tsMod.TypeFlags.Object) !== 0) {
+    const srcSym = source.symbol;
+    const isClassOrInterface = srcSym && (srcSym.flags & (tsMod.SymbolFlags.Class | tsMod.SymbolFlags.Interface)) !== 0;
+    if (isClassOrInterface) {
+      const bases = getBaseTypes(source, checker);
+      const hasMatchingBase = (bases ?? []).some((b) => {
+        const bSym = getTypeSymbol(b);
+        return bSym && matchSymbol(bSym);
+      });
+      if (hasMatchingBase)
+        return true;
+    }
+  }
+  const tgtName = tgtSymbol?.getName();
+  if (tgtName && srcBase?.symbol?.getName() === tgtName)
+    return true;
+  if (tgtName && srcSymbol?.getName() === tgtName)
+    return true;
+  return false;
+};
+var serializeExport = (symbol, checker, tsMod, maxDepth, onInternalError, registry) => {
+  const resolved = resolveExportSymbol(symbol, checker, tsMod);
+  const declaration = resolved.valueDeclaration ?? resolved.declarations?.[0];
+  const useDeclaredType = declaration && (tsMod.isTypeAliasDeclaration(declaration) || tsMod.isInterfaceDeclaration(declaration));
+  const exportedType = useDeclaredType ? checker.getDeclaredTypeOfSymbol(resolved) : declaration ? checker.getTypeOfSymbolAtLocation(resolved, declaration) : checker.getDeclaredTypeOfSymbol(resolved);
+  return {
+    name: symbol.getName(),
+    declarationKind: declaration ? tsMod.SyntaxKind[declaration.kind] : void 0,
+    declarationText: declaration ? declaration.getText() : void 0,
+    docs: tsMod.displayPartsToString(symbol.getDocumentationComment(checker)) || void 0,
+    type: serializeTypeNode(exportedType, checker, tsMod, 0, maxDepth, /* @__PURE__ */ new Set(), onInternalError, registry)
+  };
+};
+var collectImports = (sourceFile, program, tsMod) => {
+  const imports = [];
+  tsMod.forEachChild(sourceFile, (node) => {
+    if (!tsMod.isImportDeclaration(node))
+      return;
+    const moduleSpecifier = node.moduleSpecifier;
+    if (!tsMod.isStringLiteral(moduleSpecifier))
+      return;
+    const spec = moduleSpecifier.text;
+    const binding = node.importClause;
+    let info = { moduleSpecifier: spec };
+    if (binding) {
+      if (binding.namedBindings) {
+        if (tsMod.isNamedImports(binding.namedBindings)) {
+          info = {
+            ...info,
+            importedNames: binding.namedBindings.elements.map((el) => (el.propertyName ?? el.name).getText(sourceFile))
+          };
+        } else if (tsMod.isNamespaceImport(binding.namedBindings)) {
+          info = {
+            ...info,
+            namespaceImport: binding.namedBindings.name.getText(sourceFile)
+          };
+        }
+      }
+      if (binding.name) {
+        info = { ...info, defaultImport: binding.name.getText(sourceFile) };
+      }
+    }
+    imports.push(info);
+  });
+  return imports;
+};
+var createFileSnapshot = (sourceFile, checker, program, tsMod, maxDepth, includeImports, onInternalError, registry) => {
+  const filePath = sourceFile.fileName;
+  const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+  const exports2 = moduleSymbol ? checker.getExportsOfModule(moduleSymbol).map((value) => serializeExport(value, checker, tsMod, maxDepth, onInternalError, registry)).sort(compareByName) : [];
+  const imports = includeImports ? collectImports(sourceFile, program, tsMod) : void 0;
+  return {
+    filePath,
+    exports: exports2,
+    ...imports !== void 0 && imports.length > 0 ? { imports } : {}
+  };
+};
+var applyProjection = (type, steps, checker, tsMod, opts) => {
+  const { onInternalError, targetsByIdMap, assignabilityMode, maxDepth } = opts;
+  let current = type;
+  for (const step of steps) {
+    try {
+      switch (step.kind) {
+        case "returnType": {
+          const sigs = checker.getSignaturesOfType(current, tsMod.SignatureKind.Call);
+          if (sigs.length === 0)
+            return void 0;
+          current = checker.getReturnTypeOfSignature(sigs[0]);
+          break;
+        }
+        case "param": {
+          const sigs = checker.getSignaturesOfType(current, tsMod.SignatureKind.Call);
+          if (sigs.length === 0)
+            return void 0;
+          const params = sigs[0].getParameters();
+          if (step.index < 0 || step.index >= params.length)
+            return void 0;
+          const param = params[step.index];
+          const decl = param.valueDeclaration ?? param.declarations?.[0];
+          current = decl ? checker.getTypeOfSymbolAtLocation(param, decl) : checker.getDeclaredTypeOfSymbol(param);
+          break;
+        }
+        case "typeArg": {
+          const args = checker.getTypeArguments(current);
+          if (step.index < 0 || step.index >= args.length)
+            return void 0;
+          current = args[step.index];
+          break;
+        }
+        case "property": {
+          const prop = current.getProperty(step.name);
+          if (!prop)
+            return void 0;
+          const decl = prop.valueDeclaration ?? prop.declarations?.[0];
+          current = decl ? checker.getTypeOfSymbolAtLocation(prop, decl) : checker.getDeclaredTypeOfSymbol(prop);
+          break;
+        }
+        case "ensure": {
+          const target = targetsByIdMap.get(step.targetId);
+          if (!target)
+            return void 0;
+          if (!isAssignableTo(current, target, checker, tsMod, assignabilityMode))
+            return void 0;
+          break;
+        }
+        case "predicate": {
+          const serialized = serializeTypeNode(current, checker, tsMod, 0, maxDepth, /* @__PURE__ */ new Set(), onInternalError);
+          if (!step.fn(serialized))
+            return void 0;
+          break;
+        }
+        default:
+          return void 0;
+      }
+    } catch (err) {
+      onInternalError?.(err, `applyProjection:${step.kind}`);
+      return void 0;
+    }
+  }
+  return current;
+};
+var createTypeInfoApiSession = (options) => {
+  let effectiveTypeTargets = options.typeTargets ?? (options.typeTargetSpecs?.length ? resolveTypeTargetsFromSpecs(options.program, options.ts, options.typeTargetSpecs) : void 0);
+  const failWhenNoTargets = options.failWhenNoTargetsResolved !== false;
+  if (failWhenNoTargets && options.typeTargetSpecs && options.typeTargetSpecs.length > 0 && (!effectiveTypeTargets || effectiveTypeTargets.length === 0)) {
+    const modules = [...new Set(options.typeTargetSpecs.map((s) => s.module))].join(", ");
+    throw new Error(`type targets could not be resolved; ensure program includes imports from: ${modules}. Use createTypeTargetBootstrapContent(typeTargetSpecs) to generate a bootstrap file and add it to program rootNames.`);
+  }
+  const checker = options.program.getTypeChecker();
+  const descriptors = /* @__PURE__ */ new Map();
+  const snapshotCache = /* @__PURE__ */ new Map();
+  const directoryCache = /* @__PURE__ */ new Map();
+  const maxDepth = options.maxTypeDepth ?? DEFAULT_MAX_DEPTH;
+  const assignabilityMode = options.assignabilityMode ?? "compatibility";
+  const typeNodeRegistry = /* @__PURE__ */ new WeakMap();
+  const targetsByIdMap = new Map((effectiveTypeTargets ?? []).map((t) => [t.id, t.type]));
+  const registerDescriptor = (descriptor) => {
+    if (descriptor.type === "file") {
+      descriptors.set(`file:${descriptor.path}`, descriptor);
+      return;
+    }
+    const globs = descriptor.relativeGlobs.join("|");
+    descriptors.set(`glob:${descriptor.baseDir}:${descriptor.recursive ? "r" : "nr"}:${globs}`, descriptor);
+  };
+  const file = (relativePath, queryOptions) => {
+    const baseDirResult = validatePathSegment(queryOptions.baseDir, "baseDir");
+    if (!baseDirResult.ok)
+      return { ok: false, error: "invalid-input" };
+    const relativePathResult = validatePathSegment(relativePath, "relativePath");
+    if (!relativePathResult.ok)
+      return { ok: false, error: "invalid-input" };
+    const baseDir = baseDirResult.value;
+    const normalizedRelativePath = relativePathResult.value;
+    const pathResult = resolvePathUnderBase(baseDir, normalizedRelativePath);
+    if (!pathResult.ok) {
+      return {
+        ok: false,
+        error: "path-escapes-base",
+        path: resolveRelativePath(baseDir, normalizedRelativePath)
+      };
+    }
+    const absolutePath = pathResult.path;
+    try {
+      if (!pathIsUnderBase(baseDir, absolutePath)) {
+        return { ok: false, error: "path-escapes-base", path: absolutePath };
+      }
+    } catch {
+      return { ok: false, error: "path-escapes-base", path: absolutePath };
+    }
+    if (queryOptions.watch) {
+      registerDescriptor({
+        type: "file",
+        path: absolutePath
+      });
+    }
+    const sourceFile = options.program.getSourceFile(absolutePath);
+    if (!sourceFile) {
+      return { ok: false, error: "file-not-in-program", path: absolutePath };
+    }
+    const cached = snapshotCache.get(absolutePath);
+    if (cached !== void 0) {
+      return { ok: true, snapshot: cached };
+    }
+    const snapshot = createFileSnapshot(sourceFile, checker, options.program, options.ts, maxDepth, true, options.onInternalError, typeNodeRegistry);
+    snapshotCache.set(absolutePath, snapshot);
+    return { ok: true, snapshot };
+  };
+  const directoryCacheKey = (baseDir, normalizedGlobs, recursive) => `${baseDir}\0${normalizedGlobs.join("\0")}\0${recursive ? "r" : "nr"}`;
+  const directory = (relativeGlobs, queryOptions) => {
+    const baseDirResult = validatePathSegment(queryOptions.baseDir, "baseDir");
+    if (!baseDirResult.ok)
+      return [];
+    const baseDir = baseDirResult.value;
+    const globsResult = validateRelativeGlobs(relativeGlobs, "relativeGlobs");
+    if (!globsResult.ok)
+      return [];
+    const normalizedGlobs = dedupeSorted(globsResult.value);
+    const cacheKey = directoryCacheKey(baseDir, normalizedGlobs, queryOptions.recursive ?? false);
+    const cached = directoryCache.get(cacheKey);
+    if (cached !== void 0)
+      return cached;
+    if (queryOptions.watch) {
+      registerDescriptor({
+        type: "glob",
+        baseDir: toPosixPath(baseDir),
+        relativeGlobs: normalizedGlobs,
+        recursive: queryOptions.recursive
+      });
+    }
+    const depth = queryOptions.recursive ? void 0 : 1;
+    const includes = queryOptions.recursive && normalizedGlobs.every((g) => !g.includes("**")) ? [...normalizedGlobs, ...normalizedGlobs.map((g) => `**/${g}`)] : normalizedGlobs;
+    const matchedPaths = options.ts.sys.readDirectory(baseDir, TYPE_EXTENSIONS, void 0, includes, depth);
+    const normalizedMatches = dedupeSorted(matchedPaths.map((value) => resolveRelativePath(baseDir, value)));
+    const underBase = normalizedMatches.filter((filePath) => pathIsUnderBase(baseDir, filePath));
+    const filteredMatches = queryOptions.recursive ? underBase : underBase.filter((filePath) => {
+      const relativePath = toPosixPath((0, import_node_path2.relative)(baseDir, filePath));
+      return !relativePath.includes("/");
+    });
+    const program = options.program;
+    const tsMod = options.ts;
+    const snapshots = filteredMatches.flatMap((filePath) => {
+      const sf = program.getSourceFile(filePath);
+      if (!sf)
+        return [];
+      try {
+        return [
+          createFileSnapshot(sf, checker, program, tsMod, maxDepth, true, options.onInternalError, typeNodeRegistry)
+        ];
+      } catch (err) {
+        options.onInternalError?.(err, `directory() serialization for ${filePath}`);
+        return [];
+      }
+    });
+    directoryCache.set(cacheKey, snapshots);
+    return snapshots;
+  };
+  const resolveExport = (baseDir, filePath, exportName) => {
+    const result = file(filePath, { baseDir });
+    if (!result.ok)
+      return void 0;
+    return result.snapshot.exports.find((e) => e.name === exportName);
+  };
+  const apiIsAssignableTo = (node, targetId, projection) => {
+    const sourceType = typeNodeRegistry.get(node);
+    if (!sourceType)
+      return false;
+    const targetType = targetsByIdMap.get(targetId);
+    if (!targetType)
+      return false;
+    const projected = projection?.length ? applyProjection(sourceType, projection, checker, options.ts, {
+      onInternalError: options.onInternalError,
+      targetsByIdMap,
+      assignabilityMode,
+      maxDepth
+    }) : sourceType;
+    if (!projected)
+      return false;
+    return isAssignableTo(projected, targetType, checker, options.ts, assignabilityMode);
+  };
+  return {
+    api: {
+      file,
+      directory,
+      resolveExport,
+      isAssignableTo: apiIsAssignableTo
+    },
+    consumeDependencies: () => [...descriptors.values()]
+  };
+};
+
+// ../virtual-modules/dist/NodeModulePluginLoader.js
+var import_node_fs2 = require("fs");
+var import_node_module = require("module");
+var import_node_path3 = require("path");
+var import_node_vm = require("vm");
+var toMessage2 = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+var isPluginLike = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.name === "string" && typeof candidate.shouldResolve === "function" && typeof candidate.build === "function";
+};
+var invalidPluginError = (request, message) => ({
+  status: "error",
+  specifier: request.specifier,
+  baseDir: request.baseDir,
+  code: "invalid-plugin-export",
+  message
+});
+var loadFailedError = (request, message) => ({
+  status: "error",
+  specifier: request.specifier,
+  baseDir: request.baseDir,
+  code: "module-load-failed",
+  message
+});
+var notFoundError = (request, message) => ({
+  status: "error",
+  specifier: request.specifier,
+  baseDir: request.baseDir,
+  code: "module-not-found",
+  message
+});
+var pathEscapesError = (request, message) => ({
+  status: "error",
+  specifier: request.specifier,
+  baseDir: request.baseDir,
+  code: "path-escapes-base",
+  message
+});
+var MAX_PATH_LENGTH = 4096;
+var invalidRequestError = (message) => ({
+  status: "error",
+  specifier: "",
+  baseDir: "",
+  code: "invalid-request",
+  message
+});
+var getErrorCode = (error) => typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+var NodeModulePluginLoader = class {
+  load(input) {
+    if (isPluginLike(input)) {
+      return {
+        status: "loaded",
+        plugin: input,
+        resolvedPath: "<preloaded>"
+      };
+    }
+    const request = input;
+    if (typeof request.baseDir !== "string" || request.baseDir.trim() === "") {
+      return invalidRequestError("baseDir must be a non-empty string");
+    }
+    if (typeof request.specifier !== "string" || request.specifier.trim() === "") {
+      return invalidRequestError("specifier must be a non-empty string");
+    }
+    if (request.baseDir.length > MAX_PATH_LENGTH || request.specifier.length > MAX_PATH_LENGTH) {
+      return invalidRequestError(`baseDir and specifier must be at most ${MAX_PATH_LENGTH} characters`);
+    }
+    const require2 = (0, import_node_module.createRequire)((0, import_node_path3.resolve)(request.baseDir, "__typed_virtual_modules_loader__.cjs"));
+    let resolvedPath;
+    try {
+      resolvedPath = require2.resolve(request.specifier, { paths: [request.baseDir] });
+    } catch (error) {
+      return notFoundError(request, `Could not resolve plugin "${request.specifier}" from "${request.baseDir}": ${sanitizeErrorMessage(toMessage2(error))}`);
+    }
+    if (!pathIsUnderBase(request.baseDir, resolvedPath)) {
+      return pathEscapesError(request, sanitizeErrorMessage(`Resolved plugin path "${resolvedPath}" is not under baseDir "${request.baseDir}"`));
+    }
+    let mod;
+    try {
+      mod = require2(resolvedPath);
+    } catch (error) {
+      const errorCode = getErrorCode(error);
+      if (errorCode === "ERR_REQUIRE_ASYNC_MODULE") {
+        return loadFailedError(request, sanitizeErrorMessage(`Could not load plugin module "${resolvedPath}": plugin module uses top-level await and cannot be loaded synchronously`));
+      }
+      if (errorCode === "ERR_REQUIRE_ESM") {
+        const esmFallback = this.#loadSyncEsmModule(resolvedPath, require2);
+        if (esmFallback.status === "loaded") {
+          mod = esmFallback.moduleExport;
+        } else {
+          return loadFailedError(request, esmFallback.message);
+        }
+      } else {
+        return loadFailedError(request, `Could not load plugin module "${resolvedPath}": ${sanitizeErrorMessage(toMessage2(error))}`);
+      }
+    }
+    const normalizedPlugin = this.#normalizeModuleExport(mod);
+    if (!normalizedPlugin) {
+      return invalidPluginError(request, sanitizeErrorMessage(`Resolved module "${resolvedPath}" does not export a valid VirtualModulePlugin`));
+    }
+    return {
+      status: "loaded",
+      plugin: normalizedPlugin,
+      resolvedPath
+    };
+  }
+  loadMany(inputs) {
+    return inputs.map((input) => this.load(input));
+  }
+  #loadSyncEsmModule(resolvedPath, localRequire) {
+    let tsMod;
+    try {
+      tsMod = localRequire("typescript");
+    } catch (error) {
+      return loadFailedError({ specifier: resolvedPath, baseDir: (0, import_node_path3.dirname)(resolvedPath) }, sanitizeErrorMessage(`Could not load sync ESM plugin "${resolvedPath}": failed to load TypeScript for transpilation: ${toMessage2(error)}`));
+    }
+    try {
+      const sourceText = (0, import_node_fs2.readFileSync)(resolvedPath, "utf8");
+      const transpiled = tsMod.transpileModule(sourceText, {
+        fileName: resolvedPath,
+        compilerOptions: {
+          module: tsMod.ModuleKind.CommonJS,
+          target: tsMod.ScriptTarget.ES2020,
+          moduleResolution: tsMod.ModuleResolutionKind.NodeNext,
+          esModuleInterop: true,
+          allowSyntheticDefaultImports: true
+        },
+        reportDiagnostics: false
+      }).outputText;
+      const module2 = { exports: {} };
+      const evaluate = (0, import_node_vm.runInThisContext)(`(function (exports, require, module, __filename, __dirname) {${transpiled}
+})`, { filename: resolvedPath });
+      evaluate(module2.exports, localRequire, module2, resolvedPath, (0, import_node_path3.dirname)(resolvedPath));
+      return { status: "loaded", moduleExport: module2.exports };
+    } catch (error) {
+      return {
+        status: "error",
+        message: sanitizeErrorMessage(`Could not load sync ESM plugin "${resolvedPath}": ${toMessage2(error)}`)
+      };
+    }
+  }
+  #normalizeModuleExport(mod) {
+    if (isPluginLike(mod)) {
+      return mod;
+    }
+    if (!mod || typeof mod !== "object") {
+      return void 0;
+    }
+    const candidate = mod;
+    if (isPluginLike(candidate.default)) {
+      return candidate.default;
+    }
+    if (isPluginLike(candidate.plugin)) {
+      return candidate.plugin;
+    }
+    return void 0;
+  }
+};
+
+// ../virtual-modules/dist/LanguageServiceAdapter.js
+var import_node_url = require("url");
+var import_node_fs4 = require("fs");
+
+// ../virtual-modules/dist/internal/materializeVirtualFile.js
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
+function rewriteSourceForPreviewLocation(sourceText, importer, virtualFilePath) {
+  const importerDir = (0, import_node_path4.dirname)((0, import_node_path4.resolve)(importer));
+  const previewDir = (0, import_node_path4.dirname)((0, import_node_path4.resolve)(virtualFilePath));
+  return sourceText.replace(/from\s+['"](\.\.?\/[^'"]+)['"]/g, (match, spec) => {
+    const absoluteTarget = (0, import_node_path4.resolve)(importerDir, spec);
+    const newRel = toPosixPath((0, import_node_path4.relative)(previewDir, absoluteTarget));
+    const newSpec = newRel.startsWith(".") ? newRel : `./${newRel}`;
+    const quote = match.includes('"') ? '"' : "'";
+    return `from ${quote}${newSpec}${quote}`;
+  });
+}
+function materializeVirtualFile(virtualFilePath, importer, sourceText) {
+  const rewritten = rewriteSourceForPreviewLocation(sourceText, importer, virtualFilePath);
+  (0, import_node_fs3.mkdirSync)((0, import_node_path4.dirname)((0, import_node_path4.resolve)(virtualFilePath)), { recursive: true });
+  (0, import_node_fs3.writeFileSync)(virtualFilePath, rewritten, "utf8");
+}
+
+// ../virtual-modules/dist/internal/VirtualRecordStore.js
+function toResolvedModule(tsMod, fileName) {
+  return {
+    resolvedFileName: fileName,
+    extension: tsMod.Extension.Ts,
+    isExternalLibraryImport: false
+  };
+}
+function createVirtualRecordStore(options) {
+  const recordsByKey = /* @__PURE__ */ new Map();
+  const recordsByVirtualFile = /* @__PURE__ */ new Map();
+  const descriptorToVirtualKeys = /* @__PURE__ */ new Map();
+  const watcherByDescriptor = /* @__PURE__ */ new Map();
+  let debounceTimer;
+  const pendingStaleKeys = /* @__PURE__ */ new Set();
+  const { debounceMs, watchHost, shouldEvictRecord, onFlushStale, onMarkStale, onBeforeResolve, onAfterResolve, onRecordResolved, onEvictRecord } = options;
+  const evictRecord = (record) => {
+    onEvictRecord?.(record);
+    recordsByKey.delete(record.key);
+    recordsByVirtualFile.delete(record.virtualFileName);
+    for (const descriptor of record.dependencies) {
+      const descriptorKey = createWatchDescriptorKey(descriptor);
+      const dependents = descriptorToVirtualKeys.get(descriptorKey);
+      if (dependents) {
+        dependents.delete(record.key);
+        if (dependents.size === 0) {
+          descriptorToVirtualKeys.delete(descriptorKey);
+          const watcher = watcherByDescriptor.get(descriptorKey);
+          if (watcher) {
+            watcher.close();
+            watcherByDescriptor.delete(descriptorKey);
+          }
+        }
+      }
+    }
+  };
+  const evictStaleImporters = () => {
+    const toEvict = [];
+    for (const record of recordsByKey.values()) {
+      if (shouldEvictRecord(record)) {
+        toEvict.push(record);
+      }
+    }
+    for (const record of toEvict) {
+      evictRecord(record);
+    }
+  };
+  const registerWatchers = (record) => {
+    for (const descriptor of record.dependencies) {
+      const descriptorKey = createWatchDescriptorKey(descriptor);
+      const dependents = descriptorToVirtualKeys.get(descriptorKey) ?? /* @__PURE__ */ new Set();
+      dependents.add(record.key);
+      descriptorToVirtualKeys.set(descriptorKey, dependents);
+      if (watcherByDescriptor.has(descriptorKey)) {
+        continue;
+      }
+      if (descriptor.type === "file" && watchHost?.watchFile) {
+        const watcher = watchHost.watchFile(descriptor.path, () => {
+          markStale(descriptorKey);
+        });
+        watcherByDescriptor.set(descriptorKey, watcher);
+      } else if (descriptor.type === "glob" && watchHost?.watchDirectory) {
+        const watcher = watchHost.watchDirectory(descriptor.baseDir, () => {
+          markStale(descriptorKey);
+        }, descriptor.recursive);
+        watcherByDescriptor.set(descriptorKey, watcher);
+      }
+    }
+  };
+  const flushPendingStale = () => {
+    if (pendingStaleKeys.size === 0) {
+      return;
+    }
+    onFlushStale?.();
+    for (const descriptorKey of pendingStaleKeys) {
+      const keys = descriptorToVirtualKeys.get(descriptorKey);
+      if (!keys || keys.size === 0) {
+        continue;
+      }
+      for (const key of keys) {
+        const record = recordsByKey.get(key);
+        if (record) {
+          record.stale = true;
+          onMarkStale?.(record);
+        }
+      }
+    }
+    pendingStaleKeys.clear();
+    debounceTimer = void 0;
+  };
+  const markStale = (descriptorKey) => {
+    if (debounceMs !== void 0 && debounceMs > 0) {
+      pendingStaleKeys.add(descriptorKey);
+      if (debounceTimer === void 0) {
+        debounceTimer = setTimeout(() => {
+          flushPendingStale();
+        }, debounceMs);
+      }
+      return;
+    }
+    const keys = descriptorToVirtualKeys.get(descriptorKey);
+    if (!keys || keys.size === 0) {
+      return;
+    }
+    for (const key of keys) {
+      const record = recordsByKey.get(key);
+      if (record) {
+        record.stale = true;
+        onMarkStale?.(record);
+      }
+    }
+  };
+  const resolveRecord = (id, importer, previous) => {
+    onBeforeResolve?.();
+    try {
+      const resolveOptions = {
+        id,
+        importer,
+        createTypeInfoApiSession: options.createTypeInfoApiSession
+      };
+      const resolution = options.resolver.resolveModule(resolveOptions);
+      if (resolution.status === "unresolved") {
+        return { status: "unresolved" };
+      }
+      if (resolution.status === "error") {
+        return {
+          status: "error",
+          diagnostic: resolution.diagnostic
+        };
+      }
+      const key = createVirtualKey(id, importer);
+      const virtualFileName = createVirtualFileName(resolution.pluginName, key, { id, importer }, { projectRoot: options.projectRoot });
+      const record = {
+        key,
+        id,
+        importer,
+        pluginName: resolution.pluginName,
+        virtualFileName,
+        sourceText: resolution.sourceText,
+        dependencies: resolution.dependencies,
+        ...resolution.warnings?.length ? { warnings: resolution.warnings } : {},
+        version: previous ? previous.version + 1 : 1,
+        stale: false
+      };
+      recordsByKey.set(key, record);
+      recordsByVirtualFile.set(virtualFileName, record);
+      registerWatchers(record);
+      onRecordResolved?.(record);
+      return {
+        status: "resolved",
+        record
+      };
+    } finally {
+      onAfterResolve?.();
+    }
+  };
+  const getOrBuildRecord = (id, importer) => {
+    evictStaleImporters();
+    const key = createVirtualKey(id, importer);
+    const existing = recordsByKey.get(key);
+    if (existing && !existing.stale) {
+      return {
+        status: "resolved",
+        record: existing
+      };
+    }
+    return resolveRecord(id, importer, existing);
+  };
+  const dispose = () => {
+    if (debounceTimer !== void 0) {
+      clearTimeout(debounceTimer);
+      debounceTimer = void 0;
+    }
+    pendingStaleKeys.clear();
+    for (const watcher of watcherByDescriptor.values()) {
+      watcher.close();
+    }
+    watcherByDescriptor.clear();
+    descriptorToVirtualKeys.clear();
+    recordsByKey.clear();
+    recordsByVirtualFile.clear();
+  };
+  return {
+    recordsByKey,
+    recordsByVirtualFile,
+    descriptorToVirtualKeys,
+    watcherByDescriptor,
+    evictRecord,
+    evictStaleImporters,
+    registerWatchers,
+    markStale,
+    flushPendingStale,
+    resolveRecord,
+    getOrBuildRecord,
+    dispose
+  };
+}
+
+// ../virtual-modules/dist/LanguageServiceAdapter.js
+var IN_MEMORY_RESOURCE_PREFIX = "^";
+var PREVIEW_SCHEMES = ["virtual-module", VIRTUAL_MODULE_URI_SCHEME];
+function parsePreviewUri(fileName) {
+  const pathBased = tryParsePathBasedFromTsServer(fileName);
+  if (pathBased)
+    return pathBased;
+  if (!fileName.includes("://"))
+    return void 0;
+  try {
+    const url = new URL(fileName);
+    if (!PREVIEW_SCHEMES.includes(url.protocol.replace(":", "")))
+      return void 0;
+    const id = url.searchParams.get("id");
+    const importerRaw = url.searchParams.get("importer");
+    if (!id || !importerRaw)
+      return void 0;
+    const importer = importerRaw.startsWith("file:") ? (() => {
+      try {
+        return (0, import_node_url.fileURLToPath)(importerRaw);
+      } catch {
+        return importerRaw;
+      }
+    })() : importerRaw;
+    return { id, importer };
+  } catch {
+    return void 0;
+  }
+}
+function tryParsePathBasedFromTsServer(fileName) {
+  if (!fileName.startsWith(IN_MEMORY_RESOURCE_PREFIX + "/"))
+    return void 0;
+  const rest = fileName.slice(IN_MEMORY_RESOURCE_PREFIX.length);
+  const parts = rest.split("/");
+  if (parts.length < 4)
+    return void 0;
+  const [scheme] = [parts[1], parts[2]];
+  if (!PREVIEW_SCHEMES.includes(scheme))
+    return void 0;
+  const path = "/" + parts.slice(3).join("/");
+  if (!path.includes("__virtual_"))
+    return void 0;
+  return { virtualPath: path };
+}
+var ADAPTER_DIAGNOSTIC_CODE = 99001;
+var toTsDiagnostic = (tsMod, message, file) => ({
+  category: tsMod.DiagnosticCategory.Error,
+  code: ADAPTER_DIAGNOSTIC_CODE,
+  file,
+  start: 0,
+  length: 0,
+  messageText: message
+});
+var attachLanguageServiceAdapter = (options) => {
+  if (typeof options.projectRoot !== "string" || options.projectRoot.trim() === "") {
+    throw new Error("projectRoot must be a non-empty string");
+  }
+  const host = options.languageServiceHost;
+  const watchHost = options.watchHost ?? options.languageServiceHost;
+  const diagnosticsByFile = /* @__PURE__ */ new Map();
+  let epoch = 0;
+  let inResolution = false;
+  let inResolveRecord = false;
+  let pendingRetry = false;
+  const originalGetScriptFileNames = host.getScriptFileNames?.bind(host);
+  const originalResolveModuleNameLiterals = host.resolveModuleNameLiterals?.bind(host);
+  const originalResolveModuleNames = host.resolveModuleNames?.bind(host);
+  const originalGetScriptSnapshot = host.getScriptSnapshot?.bind(host);
+  const originalGetScriptVersion = host.getScriptVersion?.bind(host);
+  const originalGetProjectVersion = host.getProjectVersion?.bind(host);
+  const originalFileExists = host.fileExists?.bind(host);
+  const originalReadFile = host.readFile?.bind(host);
+  const originalGetSemanticDiagnostics = options.languageService.getSemanticDiagnostics.bind(options.languageService);
+  const originalGetSyntacticDiagnostics = options.languageService.getSyntacticDiagnostics.bind(options.languageService);
+  const addDiagnosticForFile = (filePath, message) => {
+    const diagnostic = toTsDiagnostic(options.ts, message);
+    const diagnostics = diagnosticsByFile.get(filePath) ?? [];
+    diagnostics.push(diagnostic);
+    diagnosticsByFile.set(filePath, diagnostics);
+  };
+  const clearDiagnosticsForFile = (filePath) => {
+    diagnosticsByFile.delete(filePath);
+  };
+  const store = createVirtualRecordStore({
+    projectRoot: options.projectRoot,
+    resolver: options.resolver,
+    createTypeInfoApiSession: options.createTypeInfoApiSession,
+    debounceMs: options.debounceMs,
+    watchHost,
+    shouldEvictRecord: (record) => {
+      const currentFiles = new Set(originalGetScriptFileNames ? originalGetScriptFileNames() : []);
+      return !currentFiles.has(record.importer);
+    },
+    onFlushStale: () => {
+      epoch += 1;
+    },
+    onBeforeResolve: () => {
+      inResolveRecord = true;
+    },
+    onAfterResolve: () => {
+      inResolveRecord = false;
+    },
+    onRecordResolved: (record) => {
+      clearDiagnosticsForFile(record.importer);
+    },
+    onEvictRecord: (record) => {
+      clearDiagnosticsForFile(record.importer);
+      if (record.virtualFileName.includes(VIRTUAL_NODE_MODULES_RELATIVE)) {
+        try {
+          (0, import_node_fs4.unlinkSync)(record.virtualFileName);
+        } catch {
+        }
+      }
+    }
+  });
+  const { recordsByVirtualFile } = store;
+  const getOrBuildRecord = (id, importer) => {
+    store.evictStaleImporters();
+    if (inResolveRecord) {
+      return {
+        status: "error",
+        diagnostic: {
+          code: "re-entrant-resolution",
+          pluginName: "",
+          message: "Re-entrant resolution not allowed; plugins must not trigger module resolution during build()"
+        }
+      };
+    }
+    return store.getOrBuildRecord(id, importer);
+  };
+  const rebuildRecordIfNeeded = (record) => {
+    if (!record.stale) {
+      return record;
+    }
+    const rebuilt = store.resolveRecord(record.id, record.importer, record);
+    if (rebuilt.status === "resolved") {
+      clearDiagnosticsForFile(record.importer);
+      return rebuilt.record;
+    }
+    if (rebuilt.status === "error") {
+      const diagnostic = toTsDiagnostic(options.ts, `Virtual module rebuild failed: ${rebuilt.diagnostic.message}`);
+      const diagnostics = diagnosticsByFile.get(record.importer) ?? [];
+      diagnostics.push(diagnostic);
+      diagnosticsByFile.set(record.importer, diagnostics);
+    }
+    return record;
+  };
+  const fallbackResolveModule = (moduleName, containingFile, compilerOptions) => {
+    const result = options.ts.resolveModuleName(moduleName, containingFile, compilerOptions ?? {}, {
+      fileExists: (path) => host.fileExists?.(path) ?? false,
+      readFile: (path) => host.readFile?.(path),
+      directoryExists: (path) => host.directoryExists?.(path) ?? options.ts.sys.directoryExists(path),
+      getCurrentDirectory: () => host.getCurrentDirectory?.() ?? options.ts.sys.getCurrentDirectory(),
+      getDirectories: (path) => {
+        const fromHost = host.getDirectories?.(path);
+        if (fromHost !== void 0)
+          return [...fromHost];
+        const fromSys = options.ts.sys.getDirectories?.(path);
+        return fromSys !== void 0 ? [...fromSys] : [];
+      },
+      realpath: (path) => host.realpath?.(path) ?? options.ts.sys.realpath?.(path) ?? path,
+      useCaseSensitiveFileNames: host.useCaseSensitiveFileNames?.() ?? options.ts.sys.useCaseSensitiveFileNames
+    });
+    return result.resolvedModule;
+  };
+  host.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile) => {
+    if (inResolution) {
+      if (inResolveRecord) {
+        const diagnostic = toTsDiagnostic(options.ts, "Re-entrant resolution not allowed; plugins must not trigger module resolution during build()");
+        const diagnostics = diagnosticsByFile.get(containingFile) ?? [];
+        diagnostics.push(diagnostic);
+        diagnosticsByFile.set(containingFile, diagnostics);
+      }
+      return moduleNames.map(() => void 0);
+    }
+    inResolution = true;
+    try {
+      const parsed = parsePreviewUri(containingFile);
+      let effectiveContainingFile = containingFile;
+      let importerForVirtual = containingFile;
+      if (parsed) {
+        if ("virtualPath" in parsed) {
+          const r = recordsByVirtualFile.get(parsed.virtualPath);
+          if (r) {
+            effectiveContainingFile = r.virtualFileName;
+            importerForVirtual = r.importer;
+          }
+        } else {
+          const r = getOrBuildRecord(parsed.id, parsed.importer);
+          if (r.status === "resolved") {
+            effectiveContainingFile = r.record.virtualFileName;
+            importerForVirtual = r.record.importer;
+          }
+        }
+      }
+      const fallback = originalResolveModuleNames ? originalResolveModuleNames(moduleNames, effectiveContainingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile) : moduleNames.map((moduleName) => fallbackResolveModule(moduleName, effectiveContainingFile, compilerOptions));
+      let hadVirtualError = false;
+      let hadUnresolvedVirtual = false;
+      const results = moduleNames.map((moduleName, index) => {
+        const resolved = getOrBuildRecord(moduleName, importerForVirtual);
+        if (resolved.status === "resolved") {
+          pendingRetry = false;
+          return toResolvedModule(options.ts, resolved.record.virtualFileName);
+        }
+        if (resolved.status === "error") {
+          hadVirtualError = true;
+          addDiagnosticForFile(containingFile, resolved.diagnostic.message);
+          if (resolved.diagnostic.code === "re-entrant-resolution") {
+            return void 0;
+          }
+        }
+        if (resolved.status === "unresolved" && moduleName.includes(":")) {
+          hadUnresolvedVirtual = true;
+        }
+        return fallback[index];
+      });
+      if ((hadVirtualError || hadUnresolvedVirtual) && !pendingRetry) {
+        pendingRetry = true;
+        epoch += 1;
+      }
+      return results;
+    } finally {
+      inResolution = false;
+    }
+  };
+  const assignResolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, compilerOptions, containingSourceFile, reusedNames) => {
+    if (inResolution) {
+      if (inResolveRecord) {
+        const diagnostic = toTsDiagnostic(options.ts, "Re-entrant resolution not allowed; plugins must not trigger module resolution during build()");
+        const diagnostics = diagnosticsByFile.get(containingFile) ?? [];
+        diagnostics.push(diagnostic);
+        diagnosticsByFile.set(containingFile, diagnostics);
+      }
+      return moduleLiterals.map(() => ({ resolvedModule: void 0 }));
+    }
+    inResolution = true;
+    try {
+      const parsed = parsePreviewUri(containingFile);
+      let effectiveContainingFile = containingFile;
+      let importerForVirtual = containingFile;
+      if (parsed) {
+        if ("virtualPath" in parsed) {
+          const r = recordsByVirtualFile.get(parsed.virtualPath);
+          if (r) {
+            effectiveContainingFile = r.virtualFileName;
+            importerForVirtual = r.importer;
+          }
+        } else {
+          const r = getOrBuildRecord(parsed.id, parsed.importer);
+          if (r.status === "resolved") {
+            effectiveContainingFile = r.record.virtualFileName;
+            importerForVirtual = r.record.importer;
+          }
+        }
+      }
+      const fallback = originalResolveModuleNameLiterals ? originalResolveModuleNameLiterals(moduleLiterals, effectiveContainingFile, redirectedReference, compilerOptions, containingSourceFile, reusedNames) : moduleLiterals.map((moduleLiteral) => ({
+        resolvedModule: fallbackResolveModule(moduleLiteral.text, effectiveContainingFile, compilerOptions)
+      }));
+      let hadVirtualError = false;
+      let hadUnresolvedVirtual = false;
+      const results = moduleLiterals.map((moduleLiteral, index) => {
+        const resolved = getOrBuildRecord(moduleLiteral.text, importerForVirtual);
+        if (moduleLiteral.text.includes(":")) {
+          try {
+            require("fs").appendFileSync("/tmp/vm-ts-plugin-debug.log", JSON.stringify({
+              tag: "LS:resolveLiterals",
+              id: moduleLiteral.text,
+              status: resolved.status,
+              err: resolved.status === "error" ? resolved.diagnostic?.message : void 0,
+              t: Date.now()
+            }) + "\n", { flag: "a" });
+          } catch {
+          }
+        }
+        if (resolved.status === "resolved") {
+          pendingRetry = false;
+          return {
+            resolvedModule: toResolvedModule(options.ts, resolved.record.virtualFileName)
+          };
+        }
+        if (resolved.status === "error") {
+          hadVirtualError = true;
+          addDiagnosticForFile(containingFile, resolved.diagnostic.message);
+          if (resolved.diagnostic.code === "re-entrant-resolution") {
+            return fallback[index];
+          }
+        }
+        if (resolved.status === "unresolved" && moduleLiteral.text.includes(":")) {
+          hadUnresolvedVirtual = true;
+        }
+        return fallback[index];
+      });
+      if ((hadVirtualError || hadUnresolvedVirtual) && !pendingRetry) {
+        pendingRetry = true;
+        epoch += 1;
+      }
+      return results;
+    } finally {
+      inResolution = false;
+    }
+  };
+  host.resolveModuleNameLiterals = assignResolveModuleNameLiterals;
+  const projectService = host.projectService;
+  host.getScriptSnapshot = (fileName) => {
+    let record = recordsByVirtualFile.get(fileName);
+    if (!record) {
+      const parsed = parsePreviewUri(fileName);
+      if (parsed) {
+        if ("virtualPath" in parsed) {
+          record = recordsByVirtualFile.get(parsed.virtualPath) ?? void 0;
+        } else {
+          const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+          if (resolved.status === "resolved")
+            record = resolved.record;
+        }
+      }
+    }
+    if (!record) {
+      return originalGetScriptSnapshot?.(fileName);
+    }
+    const freshRecord = rebuildRecordIfNeeded(record);
+    let sourceToServe = freshRecord.sourceText;
+    const isNodeModulesPath = fileName.includes(VIRTUAL_NODE_MODULES_RELATIVE);
+    if (isNodeModulesPath) {
+      sourceToServe = rewriteSourceForPreviewLocation(freshRecord.sourceText, freshRecord.importer, fileName);
+      materializeVirtualFile(fileName, freshRecord.importer, freshRecord.sourceText);
+    }
+    if (projectService?.getOrCreateOpenScriptInfo) {
+      projectService.getOrCreateOpenScriptInfo(fileName, sourceToServe, options.ts.ScriptKind.TS, false, options.projectRoot);
+    }
+    return options.ts.ScriptSnapshot.fromString(sourceToServe);
+  };
+  if (originalGetScriptVersion) {
+    host.getScriptVersion = (fileName) => {
+      let record = recordsByVirtualFile.get(fileName);
+      if (!record) {
+        const parsed = parsePreviewUri(fileName);
+        if (parsed) {
+          if ("virtualPath" in parsed) {
+            record = recordsByVirtualFile.get(parsed.virtualPath) ?? void 0;
+          } else {
+            const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+            if (resolved.status === "resolved")
+              record = resolved.record;
+          }
+        }
+      }
+      if (!record)
+        return originalGetScriptVersion(fileName);
+      return String(record.version);
+    };
+  }
+  if (originalGetProjectVersion) {
+    host.getProjectVersion = () => `${originalGetProjectVersion()}:vm:${epoch}`;
+  }
+  if (originalGetScriptFileNames) {
+    host.getScriptFileNames = () => {
+      const files = originalGetScriptFileNames();
+      const virtualFiles = [...recordsByVirtualFile.keys()];
+      return [.../* @__PURE__ */ new Set([...files, ...virtualFiles])];
+    };
+  }
+  host.fileExists = (path) => {
+    if (recordsByVirtualFile.has(path))
+      return true;
+    const parsed = parsePreviewUri(path);
+    if (parsed) {
+      if ("virtualPath" in parsed) {
+        if (recordsByVirtualFile.has(parsed.virtualPath))
+          return true;
+      } else {
+        const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+        if (resolved.status === "resolved")
+          return true;
+      }
+    }
+    return originalFileExists ? originalFileExists(path) : false;
+  };
+  host.readFile = (path) => {
+    let record = recordsByVirtualFile.get(path);
+    if (!record) {
+      const parsed = parsePreviewUri(path);
+      if (parsed) {
+        if ("virtualPath" in parsed) {
+          record = recordsByVirtualFile.get(parsed.virtualPath) ?? void 0;
+        } else {
+          const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+          if (resolved.status === "resolved")
+            record = resolved.record;
+        }
+      }
+    }
+    if (record)
+      return rebuildRecordIfNeeded(record).sourceText;
+    return originalReadFile?.(path);
+  };
+  options.languageService.getSemanticDiagnostics = (fileName) => {
+    const diagnostics = originalGetSemanticDiagnostics(fileName);
+    const adapterDiagnostics = diagnosticsByFile.get(fileName);
+    if (!adapterDiagnostics || adapterDiagnostics.length === 0) {
+      return [...diagnostics];
+    }
+    return [...diagnostics, ...adapterDiagnostics];
+  };
+  options.languageService.getSyntacticDiagnostics = (fileName) => {
+    const diagnostics = originalGetSyntacticDiagnostics(fileName);
+    const adapterDiagnostics = diagnosticsByFile.get(fileName);
+    if (!adapterDiagnostics || adapterDiagnostics.length === 0) {
+      return [...diagnostics];
+    }
+    const withLocation = adapterDiagnostics.filter((d) => d.file !== void 0);
+    return [...diagnostics, ...withLocation];
+  };
+  return {
+    dispose() {
+      for (const [virtualPath] of recordsByVirtualFile) {
+        if (virtualPath.includes(VIRTUAL_NODE_MODULES_RELATIVE)) {
+          try {
+            (0, import_node_fs4.unlinkSync)(virtualPath);
+          } catch {
+          }
+        }
+      }
+      host.resolveModuleNameLiterals = originalResolveModuleNameLiterals;
+      host.resolveModuleNames = originalResolveModuleNames;
+      if (originalGetScriptSnapshot) {
+        host.getScriptSnapshot = originalGetScriptSnapshot;
+      }
+      if (originalGetScriptVersion) {
+        host.getScriptVersion = originalGetScriptVersion;
+      }
+      if (originalGetProjectVersion) {
+        host.getProjectVersion = originalGetProjectVersion;
+      }
+      if (originalGetScriptFileNames) {
+        host.getScriptFileNames = originalGetScriptFileNames;
+      }
+      if (originalFileExists) {
+        host.fileExists = originalFileExists;
+      }
+      if (originalReadFile) {
+        host.readFile = originalReadFile;
+      }
+      options.languageService.getSemanticDiagnostics = originalGetSemanticDiagnostics;
+      options.languageService.getSyntacticDiagnostics = originalGetSyntacticDiagnostics;
+      store.dispose();
+      diagnosticsByFile.clear();
+    }
+  };
+};
+
+// ../virtual-modules/dist/VmcConfigLoader.js
+var import_node_fs5 = require("fs");
+var import_node_module2 = require("module");
+var import_node_path5 = require("path");
+var import_node_vm2 = require("vm");
+var VMC_CONFIG_NAMES = ["vmc.config.ts"];
+var toMessage3 = (error) => {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+};
+var isPluginLike2 = (value) => {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  return typeof candidate.name === "string" && typeof candidate.shouldResolve === "function" && typeof candidate.build === "function";
+};
+var isResolverLike = (value) => {
+  if (!value || typeof value !== "object")
+    return false;
+  return typeof value.resolveModule === "function";
+};
+var normalizePluginEntries = (value) => {
+  if (value === void 0)
+    return { ok: true, plugins: [] };
+  if (!Array.isArray(value))
+    return { ok: false };
+  const plugins = [];
+  for (const entry of value) {
+    if (typeof entry === "string" && entry.trim().length > 0) {
+      plugins.push(entry.trim());
+      continue;
+    }
+    if (isPluginLike2(entry)) {
+      plugins.push(entry);
+      continue;
+    }
+    return { ok: false };
+  }
+  return { ok: true, plugins };
+};
+function validateProjectRoot(projectRoot) {
+  const projectRootResult = validatePathSegment(projectRoot, "projectRoot");
+  if (!projectRootResult.ok) {
+    return {
+      status: "error",
+      message: projectRootResult.reason
+    };
+  }
+  const resolvedProjectRoot = (0, import_node_path5.resolve)(projectRootResult.value);
+  if (!(0, import_node_fs5.existsSync)(resolvedProjectRoot)) {
+    return {
+      status: "error",
+      path: resolvedProjectRoot,
+      message: `projectRoot does not exist: ${resolvedProjectRoot}`
+    };
+  }
+  if (!(0, import_node_fs5.statSync)(resolvedProjectRoot).isDirectory()) {
+    return {
+      status: "error",
+      path: resolvedProjectRoot,
+      message: `projectRoot must be a directory: ${resolvedProjectRoot}`
+    };
+  }
+  return resolvedProjectRoot;
+}
+function resolveConfigPath(projectRoot, configPath) {
+  if (configPath !== void 0) {
+    const configPathResult = validatePathSegment(configPath, "configPath");
+    if (!configPathResult.ok) {
+      return {
+        status: "error",
+        message: configPathResult.reason
+      };
+    }
+    const configPathValue = configPathResult.value;
+    if (!configPathValue.endsWith(".ts")) {
+      return {
+        status: "error",
+        message: `configPath must point to a .ts file: ${configPathValue}`
+      };
+    }
+    const resolvedPath = (0, import_node_path5.resolve)(projectRoot, configPathValue);
+    const underBase = resolvePathUnderBase(projectRoot, configPathValue);
+    if (!underBase.ok || (0, import_node_path5.resolve)(underBase.path) !== resolvedPath) {
+      return {
+        status: "error",
+        message: `vmc config path escapes project root: ${configPathValue}`
+      };
+    }
+    if (!(0, import_node_fs5.existsSync)(resolvedPath)) {
+      return {
+        status: "error",
+        path: resolvedPath,
+        message: `vmc config not found: ${resolvedPath}`
+      };
+    }
+    if (!(0, import_node_fs5.statSync)(resolvedPath).isFile()) {
+      return {
+        status: "error",
+        path: resolvedPath,
+        message: `vmc config path must point to a file: ${resolvedPath}`
+      };
+    }
+    if (!pathIsUnderBase(projectRoot, resolvedPath)) {
+      return {
+        status: "error",
+        path: resolvedPath,
+        message: `vmc config path is outside project root after resolving symlinks: ${resolvedPath}`
+      };
+    }
+    return resolvedPath;
+  }
+  for (const name of VMC_CONFIG_NAMES) {
+    const candidate = (0, import_node_path5.join)(projectRoot, name);
+    if (!(0, import_node_fs5.existsSync)(candidate))
+      continue;
+    if (!(0, import_node_fs5.statSync)(candidate).isFile())
+      continue;
+    if (!pathIsUnderBase(projectRoot, candidate)) {
+      return {
+        status: "error",
+        path: candidate,
+        message: `vmc config is outside project root after resolving symlinks: ${candidate}`
+      };
+    }
+    return candidate;
+  }
+  return { status: "not-found" };
+}
+function loadTsConfigModule(tsMod, configPath) {
+  const sourceText = (0, import_node_fs5.readFileSync)(configPath, "utf8");
+  const transpiled = tsMod.transpileModule(sourceText, {
+    fileName: configPath,
+    compilerOptions: {
+      module: tsMod.ModuleKind.CommonJS,
+      target: tsMod.ScriptTarget.ES2020,
+      moduleResolution: tsMod.ModuleResolutionKind.NodeNext,
+      esModuleInterop: true
+    },
+    reportDiagnostics: false
+  }).outputText;
+  const localRequire = (0, import_node_module2.createRequire)(configPath);
+  const module2 = { exports: {} };
+  const evaluate = (0, import_node_vm2.runInThisContext)(`(function (exports, require, module, __filename, __dirname) {${transpiled}
+})`, { filename: configPath });
+  evaluate(module2.exports, localRequire, module2, configPath, (0, import_node_path5.dirname)(configPath));
+  return module2.exports;
+}
+function normalizeConfigModule(loadedModule) {
+  const withDefault = loadedModule && typeof loadedModule === "object" && "default" in loadedModule ? loadedModule.default : loadedModule;
+  if (!withDefault || typeof withDefault !== "object") {
+    return { ok: false };
+  }
+  const candidate = withDefault;
+  if (candidate.resolver !== void 0 && !isResolverLike(candidate.resolver)) {
+    return { ok: false };
+  }
+  const normalizedPlugins = normalizePluginEntries(candidate.plugins);
+  if (!normalizedPlugins.ok) {
+    return { ok: false };
+  }
+  return {
+    ok: true,
+    config: {
+      ...candidate.resolver !== void 0 ? { resolver: candidate.resolver } : {},
+      ...normalizedPlugins.plugins.length > 0 ? { plugins: normalizedPlugins.plugins } : {}
+    }
+  };
+}
+function loadVmcConfig(options) {
+  let attemptedPath;
+  try {
+    const projectRootOrStatus = validateProjectRoot(options.projectRoot);
+    if (typeof projectRootOrStatus !== "string")
+      return projectRootOrStatus;
+    const projectRoot = projectRootOrStatus;
+    const resolvedPathOrStatus = resolveConfigPath(projectRoot, options.configPath);
+    if (typeof resolvedPathOrStatus !== "string")
+      return resolvedPathOrStatus;
+    const resolvedPath = resolvedPathOrStatus;
+    attemptedPath = resolvedPath;
+    const loadedModule = resolvedPath.endsWith(".ts") ? (() => {
+      if (!options.ts) {
+        return {
+          __vmcConfigLoaderError: "TypeScript module is required to load vmc.config.ts"
+        };
+      }
+      return loadTsConfigModule(options.ts, resolvedPath);
+    })() : (0, import_node_module2.createRequire)(resolvedPath)(resolvedPath);
+    if (loadedModule && typeof loadedModule === "object" && "__vmcConfigLoaderError" in loadedModule) {
+      return {
+        status: "error",
+        path: resolvedPath,
+        message: loadedModule.__vmcConfigLoaderError
+      };
+    }
+    const normalized = normalizeConfigModule(loadedModule);
+    if (!normalized.ok) {
+      return {
+        status: "error",
+        path: resolvedPath,
+        message: `Invalid vmc config export in ${resolvedPath}`
+      };
+    }
+    return {
+      status: "loaded",
+      path: resolvedPath,
+      config: normalized.config
+    };
+  } catch (error) {
+    return {
+      status: "error",
+      ...attemptedPath ? { path: attemptedPath } : {},
+      message: sanitizeErrorMessage(`Failed to load vmc config${attemptedPath ? ` "${attemptedPath}"` : ""}: ${toMessage3(error)}`)
+    };
+  }
+}
+
+// ../virtual-modules/dist/VmcResolverLoader.js
+var import_node_path6 = require("path");
+function collectFromResolver(resolver) {
+  const pm = resolver;
+  if (!Array.isArray(pm.plugins) || pm.plugins.length === 0)
+    return void 0;
+  const merged = collectTypeTargetSpecsFromPlugins(pm.plugins);
+  return merged.length > 0 ? merged : void 0;
+}
+function loadPluginsFromEntries(entries, baseDir) {
+  const loader = new NodeModulePluginLoader();
+  const plugins = [];
+  const pluginSpecifiers = [];
+  const errors = [];
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      pluginSpecifiers.push(entry);
+      const loaded = loader.load({ specifier: entry, baseDir });
+      if (loaded.status === "loaded") {
+        plugins.push(loaded.plugin);
+      } else {
+        errors.push(loaded);
+      }
+      continue;
+    }
+    plugins.push(entry);
+  }
+  return {
+    plugins,
+    pluginSpecifiers,
+    errors
+  };
+}
+function loadResolverFromVmcConfig(options) {
+  const loadedVmcConfig = loadVmcConfig(options);
+  if (loadedVmcConfig.status === "not-found") {
+    return loadedVmcConfig;
+  }
+  if (loadedVmcConfig.status === "error") {
+    return loadedVmcConfig;
+  }
+  const vmcPlugins = loadedVmcConfig.config.plugins ?? [];
+  const pluginSpecifiers = vmcPlugins.filter((entry) => typeof entry === "string");
+  if (loadedVmcConfig.config.resolver) {
+    const resolver2 = loadedVmcConfig.config.resolver;
+    const typeTargetSpecs2 = collectFromResolver(resolver2);
+    return {
+      status: "loaded",
+      path: loadedVmcConfig.path,
+      resolver: resolver2,
+      pluginSpecifiers,
+      pluginLoadErrors: [],
+      ...typeTargetSpecs2 ? { typeTargetSpecs: typeTargetSpecs2 } : {}
+    };
+  }
+  const loadedPlugins = loadPluginsFromEntries(vmcPlugins, (0, import_node_path6.dirname)(loadedVmcConfig.path));
+  const resolver = loadedPlugins.plugins.length > 0 ? new PluginManager(loadedPlugins.plugins) : void 0;
+  const typeTargetSpecs = resolver ? collectFromResolver(resolver) : void 0;
+  return {
+    status: "loaded",
+    path: loadedVmcConfig.path,
+    ...resolver ? { resolver } : {},
+    pluginSpecifiers: loadedPlugins.pluginSpecifiers,
+    pluginLoadErrors: loadedPlugins.errors,
+    ...typeTargetSpecs ? { typeTargetSpecs } : {}
+  };
+}
+
+// ../virtual-modules/dist/typeTargetBootstrap.js
+var import_node_fs6 = require("fs");
+var import_node_path7 = require("path");
+function getTypeTargetBootstrapPath(projectRoot) {
+  return (0, import_node_path7.join)(projectRoot, "node_modules", ".typed", "type-target-bootstrap.ts");
+}
+var defaultFs = {
+  mkdirSync(path, options) {
+    (0, import_node_fs6.mkdirSync)(path, options);
+  },
+  writeFile(path, content) {
+    (0, import_node_fs6.writeFileSync)(path, content, "utf8");
+  }
+};
+function ensureTypeTargetBootstrapFile(projectRoot, typeTargetSpecs, fs = defaultFs) {
+  const bootstrapPath = getTypeTargetBootstrapPath(projectRoot);
+  if (typeTargetSpecs.length === 0)
+    return bootstrapPath;
+  const dir = (0, import_node_path7.dirname)(bootstrapPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFile(bootstrapPath, createTypeTargetBootstrapContent(typeTargetSpecs));
+  return bootstrapPath;
+}
+function getProgramWithTypeTargetBootstrap(tsMod, program, projectRoot, typeTargetSpecs) {
+  if (!typeTargetSpecs?.length)
+    return program;
+  const bootstrapPath = ensureTypeTargetBootstrapFile(projectRoot, typeTargetSpecs);
+  const rootNames = program.getRootFileNames();
+  const canonicalBootstrap = (0, import_node_path7.resolve)(bootstrapPath);
+  const alreadyHasBootstrap = rootNames.some((p) => (0, import_node_path7.resolve)(p) === canonicalBootstrap);
+  if (alreadyHasBootstrap)
+    return program;
+  const opts = program.getCompilerOptions();
+  const host = tsMod.createCompilerHost(opts, true);
+  return tsMod.createProgram([...rootNames, bootstrapPath], opts, host);
+}
+
+// ../virtual-modules/dist/LanguageServiceSession.js
+var import_node_fs7 = require("fs");
+var import_node_path8 = require("path");
+
+// src/plugin.ts
+var import_node_fs8 = require("fs");
+var import_node_path9 = require("path");
+function findTsconfig(fromDir) {
+  let dir = (0, import_node_path9.resolve)(fromDir);
+  const root = (0, import_node_path9.resolve)(dir, "/");
+  while (dir !== root) {
+    const candidate = (0, import_node_path9.join)(dir, "tsconfig.json");
+    if ((0, import_node_fs8.existsSync)(candidate)) return candidate;
+    const parent = (0, import_node_path9.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+function createFallbackProgram(tsMod, projectRoot, log, tsconfigPath, typeTargetSpecs) {
+  const configPath = tsconfigPath ?? findTsconfig(projectRoot);
+  if (!configPath) {
+    log(`fallback program: no tsconfig found from ${projectRoot}`);
+    return void 0;
+  }
+  try {
+    const configFile = tsMod.readConfigFile(configPath, tsMod.sys.readFile);
+    if (configFile.error) {
+      log(`fallback program: tsconfig read error: ${configFile.error.messageText}`);
+      return void 0;
+    }
+    const configDir = (0, import_node_path9.dirname)(configPath);
+    const parsed = tsMod.parseJsonConfigFileContent(
+      configFile.config,
+      tsMod.sys,
+      configDir,
+      void 0,
+      configPath
+    );
+    if (parsed.errors.length > 0) {
+      log(`fallback program: tsconfig parse errors: ${parsed.errors.map((e) => e.messageText).join(", ")}`);
+      return void 0;
+    }
+    let rootNames = parsed.fileNames;
+    if (typeTargetSpecs && typeTargetSpecs.length > 0) {
+      ensureTypeTargetBootstrapFile(projectRoot, typeTargetSpecs);
+      const bootstrapPath = getTypeTargetBootstrapPath(projectRoot);
+      rootNames = [...rootNames, bootstrapPath];
+      log(`fallback program: added bootstrap ${bootstrapPath}`);
+    }
+    const program = tsMod.createProgram(
+      rootNames,
+      parsed.options,
+      tsMod.createCompilerHost(parsed.options)
+    );
+    log(`fallback program: created with ${rootNames.length} root files`);
+    return program;
+  } catch (err) {
+    log(`fallback program: exception: ${err instanceof Error ? err.message : String(err)}`);
+    return void 0;
+  }
+}
+function init(modules) {
+  const ts = modules.typescript;
+  function create(info) {
+    const config = info.config ?? {};
+    const logger = info.project?.projectService?.logger;
+    const log = (msg) => logger?.info?.(`[@typed/virtual-modules-ts-plugin] ${msg}`);
+    const project = info.project;
+    const projectRoot = typeof project.configFilePath === "string" && project.configFilePath.length > 0 ? (0, import_node_path9.dirname)(project.configFilePath) : typeof project.getCurrentDirectory === "function" ? project.getCurrentDirectory() : process.cwd();
+    log(`create: projectRoot=${projectRoot}`);
+    const debounceMs = typeof config.debounceMs === "number" && Number.isFinite(config.debounceMs) && config.debounceMs >= 0 ? config.debounceMs : 50;
+    if (config.debounceMs !== void 0 && (typeof config.debounceMs !== "number" || !Number.isFinite(config.debounceMs))) {
+      log("Ignoring invalid debounceMs; expected finite number");
+    }
+    const vmcConfigPath = typeof config.vmcConfigPath === "string" && config.vmcConfigPath.trim().length > 0 ? config.vmcConfigPath : void 0;
+    if (config.vmcConfigPath !== void 0 && vmcConfigPath === void 0) {
+      log("Ignoring invalid vmcConfigPath; expected non-empty string");
+    }
+    let resolver;
+    const loadedResolver = loadResolverFromVmcConfig({
+      projectRoot,
+      ts,
+      ...vmcConfigPath ? { configPath: vmcConfigPath } : {}
+    });
+    log(`vmc: status=${loadedResolver.status}`);
+    if (loadedResolver.status === "error") {
+      log(`vmc error: ${loadedResolver.message}`);
+      return info.languageService;
+    }
+    if (loadedResolver.status === "loaded") {
+      for (const pluginLoadError of loadedResolver.pluginLoadErrors) {
+        log(`plugin load error: "${pluginLoadError.specifier}": ${pluginLoadError.message}`);
+      }
+      resolver = loadedResolver.resolver;
+      if (!resolver) {
+        log(`${loadedResolver.path} has no resolver/plugins`);
+        return info.languageService;
+      }
+    }
+    if (!resolver || loadedResolver.status === "not-found") {
+      log("vmc.config.ts not found; virtual module resolution disabled");
+      return info.languageService;
+    }
+    log("Virtual module resolver initialized");
+    const typeTargetSpecs = loadedResolver.typeTargetSpecs ?? [];
+    log(`typeTargetSpecs: ${typeTargetSpecs.length} specs`);
+    const projectConfigPath = info.project.configFilePath;
+    const tsconfigPath = typeof projectConfigPath === "string" && projectConfigPath.length > 0 ? projectConfigPath : void 0;
+    let cachedFallbackProgram = createFallbackProgram(
+      ts,
+      projectRoot,
+      log,
+      tsconfigPath,
+      typeTargetSpecs
+    );
+    let preCreatedSession;
+    if (cachedFallbackProgram) {
+      try {
+        const programWithBootstrap = getProgramWithTypeTargetBootstrap(
+          ts,
+          cachedFallbackProgram,
+          projectRoot,
+          typeTargetSpecs
+        );
+        preCreatedSession = createTypeInfoApiSession({
+          ts,
+          program: programWithBootstrap,
+          ...typeTargetSpecs.length > 0 ? { typeTargetSpecs, failWhenNoTargetsResolved: false } : {}
+        });
+        log("pre-created TypeInfoApiSession OK");
+      } catch (err) {
+        log(`pre-created TypeInfoApiSession failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    const getProgramForTypeInfo = () => {
+      const fromLS = info.languageService.getProgram();
+      if (fromLS !== void 0) return fromLS;
+      const projectLike = info.project;
+      const fromProject = projectLike.getProgram?.();
+      if (fromProject !== void 0) return fromProject;
+      if (cachedFallbackProgram !== void 0) return cachedFallbackProgram;
+      const fallback = createFallbackProgram(ts, projectRoot, log, tsconfigPath, typeTargetSpecs);
+      if (fallback !== void 0) cachedFallbackProgram = fallback;
+      return fallback;
+    };
+    const createTypeInfoApiSessionFactory2 = ({
+      id: _id,
+      importer: _importer
+    }) => {
+      let session = null;
+      let apiUsed = false;
+      const getSession = () => {
+        if (session) return session;
+        const program = getProgramForTypeInfo();
+        if (program === void 0) {
+          if (preCreatedSession) {
+            session = preCreatedSession;
+            return session;
+          }
+          log(`getSession: no program available for ${_id}`);
+          throw new Error(
+            "TypeInfo session creation failed: Program not yet available. Retry when project is loaded."
+          );
+        }
+        try {
+          const programWithBootstrap = getProgramWithTypeTargetBootstrap(
+            ts,
+            program,
+            projectRoot,
+            typeTargetSpecs
+          );
+          session = createTypeInfoApiSession({
+            ts,
+            program: programWithBootstrap,
+            ...typeTargetSpecs.length > 0 ? { typeTargetSpecs, failWhenNoTargetsResolved: false } : {}
+          });
+        } catch (err) {
+          if (preCreatedSession) {
+            log(`getSession: real program session failed, using pre-created session: ${err instanceof Error ? err.message : String(err)}`);
+            session = preCreatedSession;
+            return session;
+          }
+          throw err;
+        }
+        return session;
+      };
+      return {
+        api: {
+          file: (path, opts) => {
+            apiUsed = true;
+            return getSession().api.file(path, opts);
+          },
+          directory: (glob, opts) => {
+            apiUsed = true;
+            return getSession().api.directory(glob, opts);
+          },
+          resolveExport: (baseDir, filePath, exportName) => {
+            apiUsed = true;
+            return getSession().api.resolveExport(baseDir, filePath, exportName);
+          },
+          isAssignableTo: (node, targetId, projection) => {
+            apiUsed = true;
+            return getSession().api.isAssignableTo(node, targetId, projection);
+          }
+        },
+        consumeDependencies: () => apiUsed ? getSession().consumeDependencies() : []
+      };
+    };
+    const projectWithWatch = info.project;
+    const sys = ts.sys;
+    const projectWatchFile = projectWithWatch.watchFile;
+    const projectWatchDirectory = projectWithWatch.watchDirectory;
+    const sysWatchFile = sys?.watchFile;
+    const sysWatchDirectory = sys?.watchDirectory;
+    const watchHost = typeof projectWatchFile === "function" ? {
+      watchFile: (path, callback) => projectWatchFile(path, callback),
+      watchDirectory: typeof projectWatchDirectory === "function" ? (path, callback, recursive) => projectWatchDirectory(path, callback, recursive) : void 0
+    } : typeof sysWatchFile === "function" ? {
+      watchFile: (path, callback) => sysWatchFile(path, callback),
+      watchDirectory: typeof sysWatchDirectory === "function" ? (path, callback, recursive) => sysWatchDirectory(path, callback, recursive) : void 0
+    } : void 0;
+    attachLanguageServiceAdapter({
+      ts,
+      languageService: info.languageService,
+      languageServiceHost: info.project,
+      resolver,
+      projectRoot,
+      createTypeInfoApiSession: createTypeInfoApiSessionFactory2,
+      watchHost,
+      debounceMs
+    });
+    const projectWithDirty = info.project;
+    if (typeof projectWithDirty.invalidateResolutionsOfFailedLookupLocations === "function") {
+      projectWithDirty.invalidateResolutionsOfFailedLookupLocations();
+    } else if (typeof projectWithDirty.markAsDirty === "function") {
+      projectWithDirty.markAsDirty();
+    }
+    setTimeout(() => {
+      log("deferred retry: invalidating failed lookups");
+      if (typeof projectWithDirty.invalidateResolutionsOfFailedLookupLocations === "function") {
+        projectWithDirty.invalidateResolutionsOfFailedLookupLocations();
+      }
+      if (typeof projectWithDirty.markAsDirty === "function") {
+        projectWithDirty.markAsDirty();
+      }
+    }, 200);
+    return info.languageService;
+  }
+  return { create };
+}
+module.exports = init;