@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/adapter-AZMY335J.js

@@ -0,0 +1,279 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  CUA_VERSION,
+  installRuntime,
+  runtimeEnvironment
+} from "./chunk-JZHEUQRL.js";
+import {
+  Client,
+  StdioClientTransport
+} from "./chunk-LWJXTA6Z.js";
+import "./chunk-2IDTZAG5.js";
+import "./chunk-BI3DHYCN.js";
+import "./chunk-URD2SLIT.js";
+import "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/core/computer-use/adapter.js
+import { mkdir, mkdtemp as mkdtemp2, realpath as realpath2, rm as rm2 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join3 } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
+
+// packages/coding-agent/dist/core/computer-use/macos-runtime.js
+import { execFile, spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { mkdtemp, open, realpath, rm } from "node:fs/promises";
+import { connect } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
+var exec = promisify(execFile);
+function macLaunchArguments(app, socket, home, lifetime) {
+  let environment = {
+    HOME: home,
+    ...Object.fromEntries(Object.entries(runtimeEnvironment()).filter(([name]) => name.startsWith("CUA_")))
+  };
+  return [
+    "-n",
+    "-g",
+    "-W",
+    "-a",
+    app,
+    "--stdin",
+    lifetime,
+    ...Object.entries(environment).flatMap(([name, value]) => ["--env", `${name}=${value}`]),
+    "--args",
+    "serve",
+    "--embedded",
+    "--parent-liveness-stdio",
+    "--socket",
+    socket,
+    "--permission-mode",
+    "standard",
+    "--no-overlay"
+  ];
+}
+function request(socket, method, args) {
+  return new Promise((resolve, reject) => {
+    let stream = connect(socket), buffer = "";
+    stream.setTimeout(1e3, () => stream.destroy(new Error("Private computer endpoint timed out."))), stream.on("error", reject), stream.on("connect", () => stream.write(`${JSON.stringify({ method, args })}
+`)), stream.on("data", (chunk) => {
+      if (buffer += chunk.toString(), buffer.length > 65536) {
+        stream.destroy(new Error("Invalid private endpoint metadata."));
+        return;
+      }
+      if (buffer.includes(`
+`)) {
+        try {
+          let reply = JSON.parse(buffer.slice(0, buffer.indexOf(`
+`)));
+          if (!reply || typeof reply != "object" || !("result" in reply) || !reply.result || typeof reply.result != "object")
+            throw new Error("Private endpoint refused metadata.");
+          resolve(Object.fromEntries(Object.entries(reply.result)));
+        } catch (error) {
+          reject(error);
+        }
+        stream.destroy();
+      }
+    }), stream.on("end", () => reject(new Error("Private computer endpoint closed.")));
+  });
+}
+var MacRuntime = class {
+  directory;
+  lifetime;
+  exited;
+  pid;
+  get processId() {
+    return this.pid;
+  }
+  socket;
+  closing;
+  async start(app, signal) {
+    let directory = await mkdtemp(join(await realpath(tmpdir()), "lunr-cua-"));
+    this.directory = directory;
+    let socket = join(directory, "driver.sock");
+    this.socket = socket;
+    let lifetime = join(directory, "lifetime");
+    await exec("/usr/bin/mkfifo", ["-m", "600", lifetime], { timeout: 5e3, signal }), this.lifetime = await open(lifetime, constants.O_RDWR), signal.throwIfAborted();
+    let launcher = spawn("/usr/bin/open", macLaunchArguments(app, socket, directory, lifetime), {
+      env: runtimeEnvironment(),
+      stdio: "ignore"
+    });
+    this.exited = new Promise((resolve, reject) => {
+      launcher.once("error", reject), launcher.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`LaunchServices exited ${code}.`)));
+    }), this.exited.catch(() => {
+    });
+    let deadline = Date.now() + 15e3;
+    for (; Date.now() < deadline; ) {
+      signal.throwIfAborted();
+      try {
+        let metadata = await request(socket, "metadata");
+        if (metadata.driver_version !== CUA_VERSION || metadata.embedded !== !0 || typeof metadata.pid != "number" || metadata.pid < 1)
+          throw new Error("Private runtime has incompatible metadata.");
+        return this.pid = metadata.pid, socket;
+      } catch {
+        await Promise.race([
+          delay(100, void 0, { signal }),
+          this.exited.then(() => {
+            throw new Error("Computer app exited during startup.");
+          })
+        ]);
+      }
+    }
+    throw new Error("Private macOS runtime startup timed out. Check CuaDriver Accessibility and Screen Recording grants.");
+  }
+  close() {
+    return this.closing ??= this.stop(), this.closing;
+  }
+  async stop() {
+    if (await this.lifetime?.close(), this.lifetime = void 0, this.socket && this.pid && await request(this.socket, "shutdown_if_pid", { expected_pid: this.pid }).catch(() => {
+    }), this.exited) {
+      let timeout = new AbortController();
+      try {
+        await Promise.race([
+          this.exited,
+          delay(1e4, void 0, { signal: timeout.signal }).then(() => {
+            throw new Error("Owned macOS app shutdown is unconfirmed. Desktop lease retained.");
+          })
+        ]);
+      } finally {
+        timeout.abort();
+      }
+    }
+    this.directory && await rm(this.directory, { recursive: !0, force: !0 });
+  }
+};
+
+// packages/coding-agent/dist/core/computer-use/windows-desktop.js
+import { execFile as execFile2 } from "node:child_process";
+import { join as join2 } from "node:path";
+import { promisify as promisify2 } from "node:util";
+var exec2 = promisify2(execFile2), WINDOWS_DESKTOP_PROBE = `
+$ErrorActionPreference = 'Stop'
+Add-Type -TypeDefinition @'
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+public static class LunrDesktopProbe {
+ [DllImport("user32.dll", SetLastError=true)] static extern IntPtr OpenInputDesktop(uint flags, bool inherit, uint access);
+ [DllImport("user32.dll")] static extern bool CloseDesktop(IntPtr desktop);
+ [DllImport("user32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool GetUserObjectInformation(IntPtr handle, int index, StringBuilder info, uint length, out uint needed);
+ [DllImport("wtsapi32.dll", SetLastError=true)] static extern bool WTSQuerySessionInformation(IntPtr server, int session, int info, out IntPtr buffer, out uint bytes);
+ [DllImport("wtsapi32.dll")] static extern void WTSFreeMemory(IntPtr buffer);
+ public static bool Ready() {
+  int session = Process.GetCurrentProcess().SessionId;
+  if (session == 0) return false;
+  IntPtr buffer; uint bytes;
+  if (!WTSQuerySessionInformation(IntPtr.Zero, session, 8, out buffer, out bytes)) return false;
+  try { if (bytes < 4 || Marshal.ReadInt32(buffer) != 0) return false; }
+  finally { WTSFreeMemory(buffer); }
+  IntPtr desktop = OpenInputDesktop(0, false, 1);
+  if (desktop == IntPtr.Zero) return false;
+  try {
+   var name = new StringBuilder(256); uint needed;
+   return GetUserObjectInformation(desktop, 2, name, 512, out needed) && name.ToString() == "Default";
+  } finally { CloseDesktop(desktop); }
+ }
+}
+'@
+if ([LunrDesktopProbe]::Ready()) { 'ready' } else { 'unavailable' }
+`;
+async function assertInteractiveDesktop(signal) {
+  if (process.platform !== "win32")
+    return;
+  let command = join2(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe"), { stdout } = await exec2(command, ["-NoProfile", "-NonInteractive", "-Command", WINDOWS_DESKTOP_PROBE], {
+    timeout: 5e3,
+    windowsHide: !0,
+    signal
+  });
+  if (stdout.trim() !== "ready")
+    throw new Error("Computer use requires an active, unlocked Windows desktop. No login, unlock, or elevation is attempted.");
+}
+
+// packages/coding-agent/dist/core/computer-use/adapter.js
+var CuaAdapter = class {
+  client;
+  transport;
+  mac;
+  stateDirectory;
+  connecting;
+  closing;
+  abort = new AbortController();
+  processObserver;
+  setProcessObserver(observer) {
+    this.processObserver = observer;
+  }
+  async connect(signal) {
+    let { command, app } = await installRuntime(signal);
+    signal.throwIfAborted();
+    let args = ["mcp", "--direct", "--embedded", "--no-overlay"];
+    app && (this.mac = new MacRuntime(), args = ["mcp", "--embedded", "--socket", await this.mac.start(app, signal), "--no-overlay"]), signal.throwIfAborted();
+    let state = await mkdtemp2(join3(await realpath2(tmpdir2()), "lunr-cua-client-"));
+    this.stateDirectory = state;
+    let appData = join3(state, "AppData");
+    if (await mkdir(appData), signal.throwIfAborted(), this.transport = new StdioClientTransport({
+      command,
+      args,
+      stderr: "pipe",
+      env: {
+        ...runtimeEnvironment(),
+        HOME: state,
+        USERPROFILE: state,
+        APPDATA: appData,
+        LOCALAPPDATA: appData,
+        XDG_CONFIG_HOME: appData,
+        XDG_STATE_HOME: appData
+      }
+    }), this.transport.stderr?.on("data", () => {
+    }), this.client = new Client({ name: "lunr-computer-use", version: CUA_VERSION }), await this.client.connect(this.transport, { timeout: 15e3, signal }), signal.throwIfAborted(), this.client.getServerVersion()?.version !== CUA_VERSION)
+      throw new Error("Computer runtime version mismatch.");
+    let pids = [this.transport.pid, ...this.mac ? [this.mac.processId] : []];
+    for (let pid of pids) {
+      if (typeof pid != "number" || !Number.isInteger(pid) || pid < 1)
+        throw new Error("Computer runtime process identity is missing. Input refused.");
+      await this.processObserver?.(pid);
+    }
+  }
+  async call(name, args, signal) {
+    let combined = AbortSignal.any([this.abort.signal, ...signal ? [signal] : []]);
+    combined.throwIfAborted();
+    try {
+      if (await assertInteractiveDesktop(combined), combined.throwIfAborted(), this.connecting ??= this.connect(AbortSignal.any([combined, AbortSignal.timeout(6e4)])), await this.connecting, combined.throwIfAborted(), !this.client)
+        throw new Error("Computer connection closed.");
+      return await this.client.callTool({ name, arguments: args }, void 0, { timeout: 15e3, signal: combined });
+    } catch (error) {
+      throw await this.close(), error;
+    }
+  }
+  close() {
+    return this.abort.abort(), this.closing ??= this.stop(), this.closing;
+  }
+  async stop() {
+    await this.connecting?.catch(() => {
+    });
+    let pid = this.transport?.pid;
+    if (await this.client?.close(), await this.transport?.close(), pid) {
+      let deadline = Date.now() + 5e3;
+      for (; ; ) {
+        try {
+          process.kill(pid, 0);
+        } catch (error) {
+          if (error instanceof Error && "code" in error && error.code === "ESRCH")
+            break;
+          throw error;
+        }
+        if (Date.now() >= deadline)
+          throw new Error("Owned computer process shutdown is unconfirmed. Desktop lease retained.");
+        await delay2(50);
+      }
+    }
+    await this.mac?.close(), this.stateDirectory && await rm2(this.stateDirectory, { recursive: !0, force: !0 }), this.client = void 0, this.transport = void 0;
+  }
+};
+export {
+  CuaAdapter
+};

package/dist/node-runtime/agent-session-services-RSGP5GDN.js

@@ -0,0 +1,39 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  createAgentSessionFromServices,
+  createAgentSessionServices
+} from "./chunk-JT6YCS5B.js";
+import "./chunk-T5GM5BFH.js";
+import "./chunk-OBMWP3I5.js";
+import "./chunk-DVGWF6A2.js";
+import "./chunk-5SQDLSZJ.js";
+import "./chunk-QFWG2RVL.js";
+import "./chunk-CGBXPL3E.js";
+import "./chunk-K72NVGUB.js";
+import "./chunk-53YJI7JU.js";
+import "./chunk-GZQHMEWL.js";
+import "./chunk-ZCHMJ34K.js";
+import "./chunk-5Q45AVQG.js";
+import "./chunk-ZRDIMBEQ.js";
+import "./chunk-M3LZLQW2.js";
+import "./chunk-5NWQCSKR.js";
+import "./chunk-URD2SLIT.js";
+import "./chunk-5OLJGVCB.js";
+import "./chunk-6UB6NKA3.js";
+import "./chunk-FVDOXRUD.js";
+import "./chunk-OTT6JMPU.js";
+import "./chunk-AY6CAJSL.js";
+import "./chunk-PVCDKGR6.js";
+import "./chunk-OR4L3IB2.js";
+import "./chunk-ZSEZY3II.js";
+import "./chunk-RQ2Q5IYR.js";
+import "./chunk-DDGMHUOW.js";
+import "./chunk-C4O2RSQQ.js";
+import "./chunk-MX3GJNXJ.js";
+import "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  createAgentSessionFromServices,
+  createAgentSessionServices
+};

package/dist/node-runtime/benchmark-request-UC7PD3V3.js

@@ -0,0 +1,57 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  markStartupMilestone
+} from "./chunk-CCZJ3PYY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/startup/benchmark-request.js
+import { createHash } from "node:crypto";
+import { createFauxCore, fauxAssistantMessage, fauxToolCall } from "@ashx-j/lunr-ai";
+function prepareBenchmarkRequest(session) {
+  session.setSessionName("Startup benchmark");
+  let faux = createFauxCore({ provider: "lunr-startup-benchmark" }), toolUrl = process.env.PI_STARTUP_BENCHMARK_TOOL_URL;
+  if (toolUrl && new URL(toolUrl).hostname !== "127.0.0.1")
+    throw new Error("Startup tool fixture must be local");
+  let requestedTool = process.env.PI_STARTUP_BENCHMARK_TOOL, toolCall = toolUrl ? fauxToolCall("fetch_content", { url: toolUrl }) : void 0;
+  if (requestedTool === "mcp")
+    toolCall = fauxToolCall("mcp", {});
+  else if (requestedTool === "subagent")
+    toolCall = fauxToolCall("subagent", { action: "status", view: "fleet" });
+  else if (requestedTool === "lsp")
+    toolCall = fauxToolCall("code_overview", { path: "." });
+  else if (requestedTool)
+    throw new Error(`Unknown startup fixture tool: ${requestedTool}`);
+  return faux.setResponses([
+    (context) => {
+      markStartupMilestone("first_request_dispatched");
+      let expected = session.agent.state.tools.map((tool) => tool.name).sort(), actual = context.tools?.map((tool) => tool.name).sort() ?? [];
+      if (JSON.stringify(actual) !== JSON.stringify(expected) || !context.systemPrompt)
+        throw new Error("Startup request lost registered tools or instructions");
+      let toolSchemaHash = createHash("sha256").update(JSON.stringify(context.tools)).digest("hex");
+      return process.stderr.write(`LUNR_STARTUP_REQUEST ${JSON.stringify({ tools: actual, toolSchemaHash, hasSystemPrompt: !0 })}
+`), toolCall ? fauxAssistantMessage([toolCall], { stopReason: "toolUse" }) : fauxAssistantMessage("startup-request-ok");
+    },
+    (context) => {
+      let result = context.messages.at(-1);
+      if (result?.role !== "toolResult" || result.isError || result.toolName !== toolCall?.name || toolUrl && !JSON.stringify(result.content).includes("This local article verifies") || requestedTool === "lsp" && !JSON.stringify(result.content).includes("increment"))
+        throw new Error(`Startup tool ${toolCall?.name} did not complete its local fixture: ${JSON.stringify(result?.content)}`);
+      return markStartupMilestone("first_tool_completed"), fauxAssistantMessage("startup-request-ok");
+    }
+  ]), session.modelRuntime.registerProvider("lunr-startup-benchmark", {
+    api: faux.api,
+    apiKey: "local-benchmark-only",
+    models: faux.models,
+    streamSimple: faux.streamSimple
+  }), session.agent.state.model = faux.getModel(), async () => {
+    await session.prompt(toolCall ? "Use the local startup fixture tool." : "Reply with startup-request-ok. Do not use tools.");
+    let last = session.state.messages.at(-1);
+    if (last?.role !== "assistant" || last.stopReason === "error" || faux.state.callCount !== (toolCall ? 2 : 1)) {
+      let error = new Error(`Startup benchmark did not complete its local provider request: ${last?.role === "assistant" ? last.errorMessage ?? last.stopReason : last?.role}, calls=${faux.state.callCount}`);
+      throw console.error(error.message), error;
+    }
+    markStartupMilestone("first_response_completed");
+  };
+}
+export {
+  prepareBenchmarkRequest
+};

package/dist/node-runtime/brave-UWDA3I22.js

@@ -0,0 +1,143 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  activityMonitor
+} from "./chunk-DAPBPCBP.js";
+import {
+  getWebSearchConfigPath
+} from "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/brave.js
+import { existsSync, readFileSync } from "node:fs";
+var BRAVE_API_URL = "https://api.search.brave.com/res/v1/web/search", CONFIG_PATH = getWebSearchConfigPath(), SEARCH_TIMEOUT_MS = 3e4, cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH))
+    return cachedConfig = {}, cachedConfig;
+  let raw = readFileSync(CONFIG_PATH, "utf-8");
+  try {
+    return cachedConfig = JSON.parse(raw), cachedConfig;
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+}
+function normalizeApiKey(value) {
+  if (typeof value != "string")
+    return null;
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function getApiKey() {
+  return normalizeApiKey(process.env.BRAVE_API_KEY) ?? normalizeApiKey(loadConfig().braveApiKey);
+}
+function normalizeCount(value) {
+  return typeof value != "number" || !Number.isFinite(value) ? 5 : Math.max(1, Math.min(Math.floor(value), 20));
+}
+function normalizeDomain(value) {
+  let input = value.trim().toLowerCase();
+  if (!input || (input.startsWith("-") && (input = input.slice(1).trim()), !input))
+    return null;
+  try {
+    input = (input.includes("://") ? new URL(input) : new URL(`https://${input}`)).hostname;
+  } catch {
+    input = input.split("/")[0]?.split(":")[0] ?? "";
+  }
+  return input = input.replace(/^\.+|\.+$/g, ""), /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
+}
+function normalizeDomainFilters(domainFilter) {
+  let filters = { allowed: [], blocked: [] };
+  if (!domainFilter?.length)
+    return filters;
+  for (let raw of domainFilter) {
+    let domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    let target = raw.trim().startsWith("-") ? filters.blocked : filters.allowed;
+    target.includes(domain) || target.push(domain);
+  }
+  return filters;
+}
+function buildBraveQuery(query, domainFilter) {
+  let filters = normalizeDomainFilters(domainFilter), parts = [query];
+  filters.allowed.length === 1 ? parts.push(`site:${filters.allowed[0]}`) : filters.allowed.length > 1 && parts.push(filters.allowed.map((domain) => `site:${domain}`).join(" OR "));
+  for (let domain of filters.blocked)
+    parts.push(`NOT site:${domain}`);
+  return parts.join(" ");
+}
+function hostMatchesDomain(hostname, domain) {
+  return hostname === domain || hostname.endsWith(`.${domain}`);
+}
+function matchesDomainFilters(url, filters) {
+  if (filters.allowed.length === 0 && filters.blocked.length === 0)
+    return !0;
+  let hostname = "";
+  try {
+    hostname = new URL(url).hostname.toLowerCase();
+  } catch {
+    return !1;
+  }
+  return filters.allowed.length > 0 && !filters.allowed.some((domain) => hostMatchesDomain(hostname, domain)) ? !1 : !filters.blocked.some((domain) => hostMatchesDomain(hostname, domain));
+}
+function isBraveAvailable() {
+  return !!getApiKey();
+}
+async function searchWithBrave(query, options = {}) {
+  let apiKey = getApiKey();
+  if (!apiKey)
+    throw new Error(`Brave Search API key not found. Either:
+  1. Create ${CONFIG_PATH} with { "braveApiKey": "your-key" }
+  2. Set BRAVE_API_KEY environment variable
+Get a key at https://brave.com/search/api/`);
+  let numResults = normalizeCount(options.numResults), domainFilters = normalizeDomainFilters(options.domainFilter), searchQuery = buildBraveQuery(query, options.domainFilter), activityId = activityMonitor.logStart({ type: "api", query: searchQuery }), params = new URLSearchParams({
+    q: searchQuery,
+    count: String(options.domainFilter?.length ? 20 : numResults)
+  });
+  if (options.recencyFilter) {
+    let freshness = {
+      day: "pd",
+      week: "pw",
+      month: "pm",
+      year: "py"
+    }[options.recencyFilter];
+    freshness && params.set("freshness", freshness);
+  }
+  try {
+    let response = await fetch(`${BRAVE_API_URL}?${params.toString()}`, {
+      method: "GET",
+      headers: {
+        "X-Subscription-Token": apiKey,
+        Accept: "application/json",
+        "Accept-Encoding": "gzip"
+      },
+      signal: options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      activityMonitor.logError(activityId, `HTTP ${response.status}`);
+      let errorText = await response.text();
+      throw new Error(`Brave Search API error ${response.status}: ${errorText.slice(0, 300)}`);
+    }
+    let data = await response.json();
+    activityMonitor.logComplete(activityId, response.status);
+    let results = [];
+    for (let item of data.web?.results ?? [])
+      if (!(!item.url || !matchesDomainFilters(item.url, domainFilters)) && (results.push({
+        title: item.title || item.url,
+        url: item.url,
+        snippet: item.description || ""
+      }), results.length >= numResults))
+        break;
+    return { answer: results.map((result) => result.snippet ? `${result.snippet}
+Source: ${result.title} (${result.url})` : `Source: ${result.title} (${result.url})`).join(`
+
+`), results };
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), err;
+  }
+}
+export {
+  isBraveAvailable,
+  searchWithBrave
+};

package/dist/node-runtime/builtin-extensions-7STLFW3A.js

@@ -0,0 +1,29 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  DEFERRED_BUILTIN_EXTENSION_NAMES,
+  DEFERRED_BUILTIN_FLAGS,
+  builtinExtensions,
+  lightBuiltinExtensions,
+  loadAllBuiltinExtensions,
+  loadDeferredBuiltinExtensions
+} from "./chunk-TAP7QTUT.js";
+import "./chunk-PL6JKXWI.js";
+import "./chunk-ZRDIMBEQ.js";
+import "./chunk-M3LZLQW2.js";
+import "./chunk-5OLJGVCB.js";
+import "./chunk-JHYKXIMM.js";
+import "./chunk-H2EOZYMP.js";
+import "./chunk-PVCDKGR6.js";
+import "./chunk-C4O2RSQQ.js";
+import "./chunk-MX3GJNXJ.js";
+import "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  DEFERRED_BUILTIN_EXTENSION_NAMES,
+  DEFERRED_BUILTIN_FLAGS,
+  builtinExtensions,
+  lightBuiltinExtensions,
+  loadAllBuiltinExtensions,
+  loadDeferredBuiltinExtensions
+};