@absolutejs/absolute 0.20.0-beta.173 → 0.20.0-beta.175

package/dist/cli/{index-gyjxrnnz.js → index-23hvdyxf.js}

@@ -1,10 +1,12 @@
 // @bun
+import {
+  lazyTypescript
+} from "./index-4j1twret.js";
 import {
   toModuleSpecifier
-} from "./index-q3snnhyd.js";
+} from "./index-enbw9484.js";
 
 // src/cli/generate/routeWiring.ts
-import ts from "typescript";
 import { existsSync, readFileSync, readdirSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 var DEFAULT_SEPARATOR = `
@@ -19,24 +21,24 @@ var applyEdits = (text, edits) => {
   return output;
 };
 var stripExtension = (path) => path.replace(/\.[^./\\]+$/, "");
-var parse = (path, text) => ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true);
+var parse = (path, text) => lazyTypescript.createSourceFile(path, text, lazyTypescript.ScriptTarget.Latest, true);
 var findElysiaNew = (sourceFile) => {
   let found = null;
   const visit = (node) => {
     if (found)
       return;
-    if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "Elysia") {
+    if (lazyTypescript.isNewExpression(node) && lazyTypescript.isIdentifier(node.expression) && node.expression.text === "Elysia") {
       found = node;
       return;
     }
-    ts.forEachChild(node, visit);
+    lazyTypescript.forEachChild(node, visit);
   };
   visit(sourceFile);
   return found;
 };
 var climbChain = (start) => {
   let top = start;
-  while (ts.isPropertyAccessExpression(top.parent) && top.parent.expression === top && ts.isCallExpression(top.parent.parent) && top.parent.parent.expression === top.parent) {
+  while (lazyTypescript.isPropertyAccessExpression(top.parent) && top.parent.expression === top && lazyTypescript.isCallExpression(top.parent.parent) && top.parent.parent.expression === top.parent) {
     top = top.parent.parent;
   }
   return top;
@@ -44,22 +46,22 @@ var climbChain = (start) => {
 var collectCalls = (top) => {
   const calls = [];
   let node = top;
-  while (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+  while (lazyTypescript.isCallExpression(node) && lazyTypescript.isPropertyAccessExpression(node.expression)) {
     calls.push(node);
     node = node.expression.expression;
   }
   return calls.reverse();
 };
-var methodName = (call) => ts.isPropertyAccessExpression(call.expression) ? call.expression.name.text : null;
+var methodName = (call) => lazyTypescript.isPropertyAccessExpression(call.expression) ? call.expression.name.text : null;
 var isBoundary = (call) => {
   const name = methodName(call);
   const [arg] = call.arguments;
-  if (name === "use" && arg && ts.isIdentifier(arg)) {
+  if (name === "use" && arg && lazyTypescript.isIdentifier(arg)) {
     return BOUNDARY_USE.has(arg.text);
   }
-  return name === "on" && arg !== undefined && ts.isStringLiteralLike(arg);
+  return name === "on" && arg !== undefined && lazyTypescript.isStringLiteralLike(arg);
 };
-var receiverEnd = (call) => ts.isPropertyAccessExpression(call.expression) ? call.expression.expression.getEnd() : call.getEnd();
+var receiverEnd = (call) => lazyTypescript.isPropertyAccessExpression(call.expression) ? call.expression.expression.getEnd() : call.getEnd();
 var separatorBefore = (text, offset) => {
   const match = text.slice(offset).match(/^(\s*\n[ \t]*)\./);
   return match ? match[1] : DEFAULT_SEPARATOR;
@@ -76,22 +78,22 @@ var findRouteInsertion = (text, top) => {
   const sepProbe = last ? receiverEnd(last) : top.getEnd();
   return { offset, separator: separatorBefore(text, sepProbe) };
 };
-var namedImportDecl = (sourceFile, module) => sourceFile.statements.find((statement) => ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === module && statement.importClause !== undefined && !statement.importClause.isTypeOnly && statement.importClause.namedBindings !== undefined && ts.isNamedImports(statement.importClause.namedBindings));
+var namedImportDecl = (sourceFile, module) => sourceFile.statements.find((statement) => lazyTypescript.isImportDeclaration(statement) && lazyTypescript.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === module && statement.importClause !== undefined && !statement.importClause.isTypeOnly && statement.importClause.namedBindings !== undefined && lazyTypescript.isNamedImports(statement.importClause.namedBindings));
 var importedNames = (decl) => {
   const bindings = decl.importClause?.namedBindings;
-  if (!bindings || !ts.isNamedImports(bindings))
+  if (!bindings || !lazyTypescript.isNamedImports(bindings))
     return new Set;
   return new Set(bindings.elements.map((element) => (element.propertyName ?? element.name).text));
 };
 var lastImportEnd = (sourceFile) => {
   let end = 0;
   for (const statement of sourceFile.statements) {
-    if (ts.isImportDeclaration(statement))
+    if (lazyTypescript.isImportDeclaration(statement))
       end = statement.getEnd();
   }
   return end;
 };
-var hasTypeImport = (sourceFile, module, local) => sourceFile.statements.some((statement) => ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === module && statement.getText().includes(local));
+var hasTypeImport = (sourceFile, module, local) => sourceFile.statements.some((statement) => lazyTypescript.isImportDeclaration(statement) && lazyTypescript.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === module && statement.getText().includes(local));
 var renderTypeImport = (spec) => {
   if (spec.kind === "typeDefault") {
     return `import type ${spec.local} from '${spec.module}';`;
@@ -114,7 +116,7 @@ var groupNamed = (specs) => {
 };
 var mergeNamedEdit = (decl, sourceFile, missing) => {
   const bindings = decl.importClause?.namedBindings;
-  if (!bindings || !ts.isNamedImports(bindings))
+  if (!bindings || !lazyTypescript.isNamedImports(bindings))
     return null;
   const { elements } = bindings;
   const additions = missing.join(", ");

package/dist/cli/index-4j1twret.js

@@ -0,0 +1,22 @@
+// @bun
+// src/utils/lazyTypescript.ts
+import { createRequire } from "module";
+var loaded;
+var loadTypescript = () => {
+  if (loaded)
+    return loaded;
+  const requireFromHere = createRequire(import.meta.url);
+  const typescript = requireFromHere("typescript");
+  loaded = typescript;
+  return typescript;
+};
+var createLazyTypescript = () => {
+  const target = Object.create(null);
+  return new Proxy(target, {
+    get: (_target, key) => Reflect.get(loadTypescript(), key),
+    has: (_target, key) => Reflect.has(loadTypescript(), key)
+  });
+};
+var lazyTypescript = createLazyTypescript();
+
+export { lazyTypescript };

package/dist/cli/{index-z794p5qg.js → index-6522t968.js}

@@ -1,11 +1,16 @@
 // @bun
+import {
+  lazyTypescript
+} from "./index-4j1twret.js";
+
 // src/core/islandManifest.ts
 var toIslandFrameworkSegment = (framework) => framework[0]?.toUpperCase() + framework.slice(1);
 var getIslandManifestKey = (framework, component) => `Island${toIslandFrameworkSegment(framework)}${component}`;
 
 // src/build/islandEntries.ts
+import { mkdirSync, rmSync, statSync, writeFileSync } from "fs";
 import { dirname, extname, join, relative, resolve } from "path";
-import ts from "typescript";
+import { fileURLToPath } from "url";
 // src/core/islands.ts
 var isRecord = (value) => typeof value === "object" && value !== null;
 var getIslandBuildReference = (component) => {
@@ -31,12 +36,29 @@ var resolveRegistryExport = (mod) => {
 var hasSvelteImport = (source) => /from\s+['"][^'"]+\.svelte['"]/.test(source);
 var resolveIslandSourcePath = (registryPath, sourcePath) => {
   if (sourcePath.startsWith("file://")) {
-    return new URL(sourcePath).pathname;
+    return fileURLToPath(sourcePath);
   }
   return resolve(dirname(registryPath), sourcePath);
 };
+var isExistingFile = (path) => {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+};
+var resolveIslandSourceFile = (registryPath, sourcePath) => {
+  const joinedPath = resolveIslandSourcePath(registryPath, sourcePath);
+  if (isExistingFile(joinedPath))
+    return joinedPath;
+  try {
+    return Bun.resolveSync(joinedPath, dirname(registryPath));
+  } catch {
+    return joinedPath;
+  }
+};
 var getObjectPropertyName = (name) => {
-  if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
+  if (lazyTypescript.isIdentifier(name) || lazyTypescript.isStringLiteral(name)) {
     return name.text;
   }
   return null;
@@ -51,7 +73,7 @@ var collectDefaultImport = (imports, importClause, source) => {
 };
 var collectNamedImports = (imports, importClause, source) => {
   const bindings = importClause.namedBindings;
-  if (!bindings || !ts.isNamedImports(bindings))
+  if (!bindings || !lazyTypescript.isNamedImports(bindings))
     return;
   for (const element of bindings.elements) {
     imports.set(element.name.text, {
@@ -67,7 +89,7 @@ var collectRegistryHelperImports = (importClause, source, registryFactoryNames,
   const bindings = importClause.namedBindings;
   if (!bindings)
     return;
-  if (ts.isNamespaceImport(bindings)) {
+  if (lazyTypescript.isNamespaceImport(bindings)) {
     registryNamespaceNames.add(bindings.name.text);
     return;
   }
@@ -87,13 +109,13 @@ var addRegistryEntries = (frameworkNode, framework, imports, definitions, regist
   const frameworkRegistry = registry[framework] ?? {};
   registry[framework] = frameworkRegistry;
   for (const property of frameworkNode.properties) {
-    if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property))
+    if (!lazyTypescript.isPropertyAssignment(property) && !lazyTypescript.isShorthandPropertyAssignment(property))
       continue;
     const componentName = getObjectPropertyName(property.name);
     if (!componentName)
       continue;
-    const initializer = ts.isPropertyAssignment(property) ? property.initializer : property.name;
-    if (!ts.isIdentifier(initializer))
+    const initializer = lazyTypescript.isPropertyAssignment(property) ? property.initializer : property.name;
+    if (!lazyTypescript.isIdentifier(initializer))
       continue;
     const reference = imports.get(initializer.text);
     if (!reference)
@@ -108,7 +130,7 @@ var addRegistryEntries = (frameworkNode, framework, imports, definitions, regist
 };
 var processDefineIslandRegistry = (node, imports, definitions, registry) => {
   const [firstArg] = node.arguments;
-  if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+  if (!firstArg || !lazyTypescript.isObjectLiteralExpression(firstArg))
     return;
   const validFrameworks = [
     "react",
@@ -117,7 +139,7 @@ var processDefineIslandRegistry = (node, imports, definitions, registry) => {
     "angular"
   ];
   for (const property of firstArg.properties) {
-    if (!ts.isPropertyAssignment(property))
+    if (!lazyTypescript.isPropertyAssignment(property))
       continue;
     const frameworkName = getObjectPropertyName(property.name);
     if (!frameworkName)
@@ -125,31 +147,31 @@ var processDefineIslandRegistry = (node, imports, definitions, registry) => {
     const framework = validFrameworks.find((f) => f === frameworkName);
     if (!framework)
       continue;
-    if (!ts.isObjectLiteralExpression(property.initializer))
+    if (!lazyTypescript.isObjectLiteralExpression(property.initializer))
       continue;
     addRegistryEntries(property.initializer, framework, imports, definitions, registry);
   }
 };
 var walkRegistryNode = (node, imports, registryFactoryNames, registryNamespaceNames, definitions, registry) => {
-  if (ts.isCallExpression(node) && isDefineIslandRegistryCall(node.expression, registryFactoryNames, registryNamespaceNames)) {
+  if (lazyTypescript.isCallExpression(node) && isDefineIslandRegistryCall(node.expression, registryFactoryNames, registryNamespaceNames)) {
     processDefineIslandRegistry(node, imports, definitions, registry);
   }
-  ts.forEachChild(node, (child) => walkRegistryNode(child, imports, registryFactoryNames, registryNamespaceNames, definitions, registry));
+  lazyTypescript.forEachChild(node, (child) => walkRegistryNode(child, imports, registryFactoryNames, registryNamespaceNames, definitions, registry));
 };
 var isDefineIslandRegistryCall = (expression, registryFactoryNames, registryNamespaceNames) => {
-  if (ts.isIdentifier(expression)) {
+  if (lazyTypescript.isIdentifier(expression)) {
     return registryFactoryNames.has(expression.text);
   }
-  return ts.isPropertyAccessExpression(expression) && expression.name.text === "defineIslandRegistry" && ts.isIdentifier(expression.expression) && registryNamespaceNames.has(expression.expression.text);
+  return lazyTypescript.isPropertyAccessExpression(expression) && expression.name.text === "defineIslandRegistry" && lazyTypescript.isIdentifier(expression.expression) && registryNamespaceNames.has(expression.expression.text);
 };
 var hasIslandRegistryNamedExport = (sourceFile) => {
   for (const statement of sourceFile.statements) {
-    if (ts.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) && statement.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === "islandRegistry")) {
+    if (lazyTypescript.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === lazyTypescript.SyntaxKind.ExportKeyword) && statement.declarationList.declarations.some((declaration) => lazyTypescript.isIdentifier(declaration.name) && declaration.name.text === "islandRegistry")) {
       return true;
     }
-    if (!ts.isExportDeclaration(statement) || !statement.exportClause)
+    if (!lazyTypescript.isExportDeclaration(statement) || !statement.exportClause)
       continue;
-    if (!ts.isNamedExports(statement.exportClause))
+    if (!lazyTypescript.isNamedExports(statement.exportClause))
       continue;
     if (statement.exportClause.elements.some((element) => element.name.text === "islandRegistry")) {
       return true;
@@ -159,7 +181,7 @@ var hasIslandRegistryNamedExport = (sourceFile) => {
 };
 var collectImportDeclarations = (sourceFile, registryPath, imports, registryFactoryNames, registryNamespaceNames) => {
   for (const statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+    if (!lazyTypescript.isImportDeclaration(statement) || !lazyTypescript.isStringLiteral(statement.moduleSpecifier))
       continue;
     const { importClause } = statement;
     if (!importClause)
@@ -171,7 +193,7 @@ var collectImportDeclarations = (sourceFile, registryPath, imports, registryFact
   }
 };
 var parseIslandRegistryBuildInfo = (registrySource, registryPath) => {
-  const sourceFile = ts.createSourceFile(registryPath, registrySource, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const sourceFile = lazyTypescript.createSourceFile(registryPath, registrySource, lazyTypescript.ScriptTarget.Latest, true, lazyTypescript.ScriptKind.TS);
   const imports = new Map;
   const registryFactoryNames = new Set(["defineIslandRegistry"]);
   const registryNamespaceNames = new Set;
@@ -229,4 +251,4 @@ var loadIslandRegistryBuildInfo = async (registryPath) => {
   };
 };
 
-export { getIslandManifestKey, loadIslandRegistryBuildInfo };
+export { getIslandManifestKey, resolveIslandSourceFile, loadIslandRegistryBuildInfo };

package/dist/cli/{index-25e7k849.js → index-7z1hh3fg.js}

@@ -9,9 +9,6 @@ import {
   registerInstance,
   resolveProjectName
 } from "./index-71gchbzt.js";
-import {
-  loadIslandRegistryBuildInfo
-} from "./index-z794p5qg.js";
 import {
   createIslandRegistryDefinitionPlugin,
   createBunStringRawUnicodePlugin,
@@ -20,7 +17,7 @@ import {
   createElysiaOpenApiTypeboxPlugin,
   createOptionalPeerPlugin,
   resolveServerBundleExternals
-} from "./index-rervww4p.js";
+} from "./index-zyd80s3h.js";
 import {
   normalizeAbsoluteMobileConfig2
 } from "./index-t7yf3vxs.js";
@@ -30,6 +27,9 @@ import {
 import {
   loadConfig
 } from "./index-wk0pyxrg.js";
+import {
+  loadIslandRegistryBuildInfo
+} from "./index-6522t968.js";
 import {
   stripStringsAndComments
 } from "./index-prs14ys9.js";

package/dist/cli/{index-s0r5q839.js → index-cksezef8.js}

@@ -9,6 +9,9 @@ import {
   projectUsesAbsoluteSync2,
   resolveAbsoluteMobileAuthManifest2
 } from "./index-pch0v1z6.js";
+import {
+  lazyTypescript
+} from "./index-4j1twret.js";
 
 // src/mobile/expoProject.ts
 import {
@@ -544,7 +547,6 @@ var discoverAbsoluteSyncSchema = (projectRoot) => {
 import { existsSync, readFileSync as readFileSync2 } from "fs";
 import { extname, join as join3, relative, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
-import ts from "typescript";
 var DEVICES_PACKAGE = "@absolutejs/devices";
 var ABSOLUTE_MOBILE_SHELL_DEVICE_CAPABILITIES = [
   "keyboard",
@@ -749,29 +751,29 @@ var importedCapabilities = (source, file) => {
   const names = new Set;
   const namespaces = new Set;
   const visit = (node) => {
-    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && !node.importClause?.isTypeOnly) {
+    if (lazyTypescript.isImportDeclaration(node) && lazyTypescript.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && !node.importClause?.isTypeOnly) {
       const bindings = node.importClause?.namedBindings;
-      if (bindings && ts.isNamedImports(bindings)) {
+      if (bindings && lazyTypescript.isNamedImports(bindings)) {
         for (const element of bindings.elements)
           if (!element.isTypeOnly)
             names.add((element.propertyName ?? element.name).text);
       }
-      if (bindings && ts.isNamespaceImport(bindings))
+      if (bindings && lazyTypescript.isNamespaceImport(bindings))
         namespaces.add(bindings.name.text);
     }
-    if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && node.exportClause && ts.isNamedExports(node.exportClause)) {
+    if (lazyTypescript.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && lazyTypescript.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && node.exportClause && lazyTypescript.isNamedExports(node.exportClause)) {
       for (const element of node.exportClause.elements)
         if (!element.isTypeOnly)
           names.add((element.propertyName ?? element.name).text);
     }
-    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && namespaces.has(node.expression.text))
+    if (lazyTypescript.isPropertyAccessExpression(node) && lazyTypescript.isIdentifier(node.expression) && namespaces.has(node.expression.text))
       names.add(node.name.text);
-    ts.forEachChild(node, visit);
+    lazyTypescript.forEachChild(node, visit);
   };
   const extension = extname(file).toLowerCase();
   const sources = extension === ".svelte" || extension === ".vue" ? [...source.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/giu)].map((match) => match[1]).filter((value) => value !== undefined) : [source];
   for (const [index, script] of sources.entries())
-    visit(ts.createSourceFile(`${file}#script-${index}`, script, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX));
+    visit(lazyTypescript.createSourceFile(`${file}#script-${index}`, script, lazyTypescript.ScriptTarget.Latest, true, lazyTypescript.ScriptKind.TSX));
   return names;
 };
 var assertAbsoluteDeviceCapabilityPackages = (projectRoot, plan) => {

package/dist/cli/{index-q3snnhyd.js → index-enbw9484.js}

@@ -2,6 +2,9 @@
 import {
   loadConfig
 } from "./index-wk0pyxrg.js";
+import {
+  lazyTypescript
+} from "./index-4j1twret.js";
 import {
   isRecord
 } from "./index-tx0kx9zx.js";
@@ -135,12 +138,10 @@ var frameworks = {
 import { dirname, isAbsolute, join, relative, resolve as resolve3 } from "path";
 
 // src/cli/config/absolute/resolveAbsoluteConfig.ts
-import ts2 from "typescript";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { resolve as resolve2 } from "path";
 
 // src/cli/config/schema/fromType.ts
-import ts from "typescript";
 import {
   existsSync,
   mkdirSync,
@@ -160,14 +161,14 @@ var isFrameworkRepo = (cwd) => {
   }
 };
 var compilerOptionsFor = (cwd) => {
-  const tsconfigPath = ts.findConfigFile(cwd, ts.sys.fileExists, "tsconfig.json");
+  const tsconfigPath = lazyTypescript.findConfigFile(cwd, lazyTypescript.sys.fileExists, "tsconfig.json");
   const parseConfigHost = {
-    ...ts.sys,
+    ...lazyTypescript.sys,
     onUnRecoverableConfigFileDiagnostic: () => {}
   };
-  const base = tsconfigPath && ts.getParsedCommandLineOfConfigFile(tsconfigPath, {}, parseConfigHost)?.options;
+  const base = tsconfigPath && lazyTypescript.getParsedCommandLineOfConfigFile(tsconfigPath, {}, parseConfigHost)?.options;
   return {
-    ...base ?? ts.getDefaultCompilerOptions(),
+    ...base ?? lazyTypescript.getDefaultCompilerOptions(),
     noEmit: true,
     skipDefaultLibCheck: true,
     skipLibCheck: true,
@@ -223,7 +224,7 @@ var writeDiskCache = (cwd, typeName, signature, fields, specifier) => {
     writeFileSync(cacheFile(cwd, typeName, specifier), JSON.stringify({ fields, signature }));
   } catch {}
 };
-var docOf = (symbol, checker) => ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
+var docOf = (symbol, checker) => lazyTypescript.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
 var typeOfSymbol = (symbol, checker) => {
   const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
   return declaration ? checker.getTypeOfSymbolAtLocation(symbol, declaration) : checker.getDeclaredTypeOfSymbol(symbol);
@@ -244,10 +245,10 @@ var toSchema = (type, checker, depth, seen) => {
   });
   if (depth > MAX_DEPTH)
     return opaque();
-  const parts = unionParts(type).filter((part) => !hasFlag(part, ts.TypeFlags.Undefined) && !hasFlag(part, ts.TypeFlags.Null));
+  const parts = unionParts(type).filter((part) => !hasFlag(part, lazyTypescript.TypeFlags.Undefined) && !hasFlag(part, lazyTypescript.TypeFlags.Null));
   if (parts.length === 0)
     return opaque();
-  if (parts.every((part) => hasFlag(part, ts.TypeFlags.BooleanLike))) {
+  if (parts.every((part) => hasFlag(part, lazyTypescript.TypeFlags.BooleanLike))) {
     return { kind: "boolean" };
   }
   const choices = parts.map(literalChoice);
@@ -268,13 +269,13 @@ var single = (type, checker, depth, seen) => {
     kind: "opaque",
     typeText: checker.typeToString(type)
   });
-  if (hasFlag(type, ts.TypeFlags.BooleanLike))
+  if (hasFlag(type, lazyTypescript.TypeFlags.BooleanLike))
     return { kind: "boolean" };
-  if (hasFlag(type, ts.TypeFlags.NumberLike))
+  if (hasFlag(type, lazyTypescript.TypeFlags.NumberLike))
     return { kind: "number" };
-  if (hasFlag(type, ts.TypeFlags.StringLike))
+  if (hasFlag(type, lazyTypescript.TypeFlags.StringLike))
     return { kind: "string" };
-  if (!hasFlag(type, ts.TypeFlags.Object))
+  if (!hasFlag(type, lazyTypescript.TypeFlags.Object))
     return opaque();
   if (type.getCallSignatures().length > 0)
     return opaque();
@@ -295,7 +296,7 @@ var single = (type, checker, depth, seen) => {
       const fields = props.map((symbol) => ({
         description: docOf(symbol, checker),
         name: symbol.getName(),
-        optional: (symbol.flags & ts.SymbolFlags.Optional) !== 0,
+        optional: (symbol.flags & lazyTypescript.SymbolFlags.Optional) !== 0,
         schema: toSchema(typeOfSymbol(symbol, checker), checker, depth + 1, seen)
       }));
       return { fields, kind: "object" };
@@ -317,21 +318,21 @@ var introspectFrom = (cwd, specifier, typeName, options, exclude) => {
 declare const value: ${typeName};
 export { value };
 `;
-  const host = ts.createCompilerHost(options, true);
+  const host = lazyTypescript.createCompilerHost(options, true);
   const getSourceFile = host.getSourceFile.bind(host);
-  host.getSourceFile = (fileName, languageVersion, onError, shouldCreate) => fileName === virtualPath ? ts.createSourceFile(fileName, source, languageVersion, true) : getSourceFile(fileName, languageVersion, onError, shouldCreate);
+  host.getSourceFile = (fileName, languageVersion, onError, shouldCreate) => fileName === virtualPath ? lazyTypescript.createSourceFile(fileName, source, languageVersion, true) : getSourceFile(fileName, languageVersion, onError, shouldCreate);
   const fileExists = host.fileExists.bind(host);
   host.fileExists = (fileName) => fileName === virtualPath ? true : fileExists(fileName);
   const readFile = host.readFile.bind(host);
   host.readFile = (fileName) => fileName === virtualPath ? source : readFile(fileName);
-  const program = ts.createProgram([virtualPath], options, host);
+  const program = lazyTypescript.createProgram([virtualPath], options, host);
   const checker = program.getTypeChecker();
   const sourceFile = program.getSourceFile(virtualPath);
   if (!sourceFile)
     return [];
   const nodes = [];
   sourceFile.forEachChild((node) => {
-    if (!ts.isVariableStatement(node))
+    if (!lazyTypescript.isVariableStatement(node))
       return;
     const [declaration] = node.declarationList.declarations;
     if (!declaration)
@@ -344,7 +345,7 @@ export { value };
       nodes.push({
         description: docOf(symbol, checker),
         name,
-        optional: (symbol.flags & ts.SymbolFlags.Optional) !== 0,
+        optional: (symbol.flags & lazyTypescript.SymbolFlags.Optional) !== 0,
         schema: toSchema(typeOfSymbol(symbol, checker), checker, 1, new Set)
       });
     }
@@ -405,18 +406,18 @@ var findConfigPath = (cwd, override) => {
   }
   return null;
 };
-var parseSource = (configPath, text) => ts2.createSourceFile(configPath, text, ts2.ScriptTarget.Latest, true);
+var parseSource = (configPath, text) => lazyTypescript.createSourceFile(configPath, text, lazyTypescript.ScriptTarget.Latest, true);
 var findConfigObject = (sourceFile) => {
   const pending = [sourceFile];
   while (pending.length > 0) {
     const node = pending.pop();
     if (!node)
       continue;
-    const [firstArgument] = ts2.isCallExpression(node) ? node.arguments : [];
-    if (ts2.isCallExpression(node) && ts2.isIdentifier(node.expression) && node.expression.text === "defineConfig" && firstArgument && ts2.isObjectLiteralExpression(firstArgument)) {
+    const [firstArgument] = lazyTypescript.isCallExpression(node) ? node.arguments : [];
+    if (lazyTypescript.isCallExpression(node) && lazyTypescript.isIdentifier(node.expression) && node.expression.text === "defineConfig" && firstArgument && lazyTypescript.isObjectLiteralExpression(firstArgument)) {
       return firstArgument;
     }
-    if (ts2.isExportAssignment(node) && ts2.isObjectLiteralExpression(node.expression)) {
+    if (lazyTypescript.isExportAssignment(node) && lazyTypescript.isObjectLiteralExpression(node.expression)) {
       return node.expression;
     }
     node.forEachChild((child) => {
@@ -430,25 +431,25 @@ var parseConfigObject = (configPath) => {
   return { object: findConfigObject(parseSource(configPath, text)), text };
 };
 var evalLiteral = (node) => {
-  if (ts2.isStringLiteralLike(node)) {
+  if (lazyTypescript.isStringLiteralLike(node)) {
     return { opaque: false, value: node.text };
   }
-  if (node.kind === ts2.SyntaxKind.TrueKeyword) {
+  if (node.kind === lazyTypescript.SyntaxKind.TrueKeyword) {
     return { opaque: false, value: true };
   }
-  if (node.kind === ts2.SyntaxKind.FalseKeyword) {
+  if (node.kind === lazyTypescript.SyntaxKind.FalseKeyword) {
     return { opaque: false, value: false };
   }
-  if (node.kind === ts2.SyntaxKind.NullKeyword) {
+  if (node.kind === lazyTypescript.SyntaxKind.NullKeyword) {
     return { opaque: false, value: null };
   }
-  if (ts2.isNumericLiteral(node)) {
+  if (lazyTypescript.isNumericLiteral(node)) {
     return { opaque: false, value: Number(node.text) };
   }
-  if (ts2.isPrefixUnaryExpression(node) && node.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(node.operand)) {
+  if (lazyTypescript.isPrefixUnaryExpression(node) && node.operator === lazyTypescript.SyntaxKind.MinusToken && lazyTypescript.isNumericLiteral(node.operand)) {
     return { opaque: false, value: -Number(node.operand.text) };
   }
-  if (ts2.isArrayLiteralExpression(node)) {
+  if (lazyTypescript.isArrayLiteralExpression(node)) {
     const items = [];
     for (const element of node.elements) {
       const result = evalLiteral(element);
@@ -458,10 +459,10 @@ var evalLiteral = (node) => {
     }
     return { opaque: false, value: items };
   }
-  if (ts2.isObjectLiteralExpression(node)) {
+  if (lazyTypescript.isObjectLiteralExpression(node)) {
     const object = {};
     for (const property of node.properties) {
-      if (!ts2.isPropertyAssignment(property) || !(ts2.isIdentifier(property.name) || ts2.isStringLiteral(property.name))) {
+      if (!lazyTypescript.isPropertyAssignment(property) || !(lazyTypescript.isIdentifier(property.name) || lazyTypescript.isStringLiteral(property.name))) {
         return { opaque: true, value: undefined };
       }
       const result = evalLiteral(property.initializer);
@@ -480,7 +481,7 @@ var readCurrent = (configPath) => {
   if (!object)
     return { current, opaqueKeys };
   for (const property of object.properties) {
-    if (!ts2.isPropertyAssignment(property) || !(ts2.isIdentifier(property.name) || ts2.isStringLiteral(property.name))) {
+    if (!lazyTypescript.isPropertyAssignment(property) || !(lazyTypescript.isIdentifier(property.name) || lazyTypescript.isStringLiteral(property.name))) {
       continue;
     }
     const name = property.name.text;

package/dist/cli/{index-b1wht4q5.js → index-kes8he5s.js}

@@ -1,13 +1,15 @@
 // @bun
+import {
+  lazyTypescript
+} from "./index-4j1twret.js";
 import {
   findConfigObject
-} from "./index-q3snnhyd.js";
+} from "./index-enbw9484.js";
 import {
   isRecord
 } from "./index-tx0kx9zx.js";
 
 // src/cli/config/absolute/editAbsoluteConfig.ts
-import ts from "typescript";
 import { readFileSync, writeFileSync } from "fs";
 
 // src/cli/config/schema/serialize.ts
@@ -55,11 +57,11 @@ var lineStartOffset = (text, position) => {
   return index;
 };
 var indentBefore = (text, position) => text.slice(lineStartOffset(text, position), position);
-var findProperty = (object, name) => object.properties.find((property) => ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) && property.name.text === name);
+var findProperty = (object, name) => object.properties.find((property) => lazyTypescript.isPropertyAssignment(property) && (lazyTypescript.isIdentifier(property.name) || lazyTypescript.isStringLiteral(property.name)) && property.name.text === name);
 var applyAbsoluteConfigEdit = (configPath, request) => {
   try {
     const text = readFileSync(configPath, "utf-8");
-    const sourceFile = ts.createSourceFile(configPath, text, ts.ScriptTarget.Latest, true);
+    const sourceFile = lazyTypescript.createSourceFile(configPath, text, lazyTypescript.ScriptTarget.Latest, true);
     const object = findConfigObject(sourceFile);
     if (!object) {
       return {