@saifymatteo/pi-x-ide 0.0.0-stage → 1.20.1

package/dist/src/pi/index.js

@@ -0,0 +1,636 @@
+import { createRequire as __piCreateRequire } from "node:module";const require = __piCreateRequire(import.meta.url);
+import {
+  DIAGNOSTIC_CONTEXT_MARKER,
+  DIAGNOSTIC_FIX_CUSTOM_TYPE,
+  bindPiUiContext,
+  formatDiagnosticCode,
+  formatRange,
+  installPiErrorReporter,
+  runPiBoundary,
+  runPiBoundaryAsync
+} from "./chunks/chunk-4RHJAL4S.js";
+import {
+  buildWidget,
+  clearIdeUi,
+  formatEditorContextMessage,
+  formatRangeMention,
+  logExtensionError,
+  resolvePiConfigEnv,
+  toRelativeDisplayPath,
+  updateIdeUi,
+  visibleWidth
+} from "./chunks/chunk-UUXVCTOS.js";
+
+// src/pi/commands.ts
+var PI_X_IDE_ATTACH_SHORTCUT_ENV = "PI_X_IDE_ATTACH_SHORTCUT";
+var DEFAULT_ATTACH_SHORTCUT = "ctrl+alt+k";
+var DISABLED_ATTACH_SHORTCUT_VALUES = /* @__PURE__ */ new Set(["", "0", "false", "off", "none", "disabled"]);
+function registerIdeCommand(pi, runtime, actions, options = {}) {
+  const attachShortcut = resolveAttachShortcut(options.env);
+  if (attachShortcut) {
+    pi.registerShortcut(attachShortcut, {
+      description: "Attach latest IDE selection to the prompt",
+      handler: (ctx) => {
+        runPiBoundary(
+          "IDE attach shortcut",
+          runtime,
+          () => {
+            runtime.ctx = ctx;
+            attachLatest(runtime, ctx);
+          },
+          ctx
+        );
+      }
+    });
+  }
+  pi.registerCommand("ide", {
+    description: "Manage IDE connection and editor selection context",
+    getArgumentCompletions: (argumentPrefix) => {
+      const subcommands = [
+        { value: "status", label: "status", description: "Show IDE connection status" },
+        { value: "list", label: "list", description: "List available IDE connections" },
+        { value: "auto", label: "auto", description: "Auto-connect to the most recent IDE" },
+        { value: "off", label: "off", description: "Disable IDE integration" },
+        { value: "attach", label: "attach", description: "Attach latest IDE selection to the prompt" },
+        { value: "install", label: "install", description: "Install or update the IDE extension" },
+        { value: "settings", label: "settings", description: "Open IDE settings (Display, AutoInstall, ...)" }
+      ];
+      const filtered = subcommands.filter((s) => s.value.startsWith(argumentPrefix));
+      return filtered.length > 0 ? filtered : null;
+    },
+    handler: (args, ctx) => runPiBoundaryAsync(
+      "/ide command",
+      runtime,
+      async () => {
+        runtime.ctx = ctx;
+        const [subcommand] = args.trim().split(/\s+/, 1);
+        switch (subcommand || "") {
+          case "":
+            await showPicker(runtime, actions, ctx);
+            return;
+          case "status":
+            showStatus(runtime, ctx);
+            return;
+          case "list":
+            await listCandidates(actions, ctx);
+            return;
+          case "auto":
+            runtime.enabled = true;
+            await actions.connectAuto(ctx);
+            return;
+          case "off":
+            await actions.disconnect(ctx, true);
+            return;
+          case "attach":
+            attachLatest(runtime, ctx);
+            return;
+          case "install":
+            await actions.installExtension(ctx);
+            return;
+          case "settings": {
+            const { showIdeSettings } = await import("./chunks/config-ui-LO3DVQFC.js");
+            await showIdeSettings(runtime, ctx);
+            return;
+          }
+          default:
+            ctx.ui.notify("Usage: /ide [status|list|auto|off|attach|install|settings]", "warning");
+        }
+      },
+      ctx
+    )
+  });
+}
+async function showPicker(runtime, actions, ctx) {
+  const candidates = await actions.refreshCandidates(ctx);
+  if (candidates.length === 0) {
+    ctx.ui.notify("No matching IDE connections found.", "warning");
+    return;
+  }
+  const labels = candidates.map(
+    (candidate2, index2) => `${index2 + 1}. ${candidate2.lock.name} \u2014 ${candidate2.workspaceFolder}`
+  );
+  labels.push("Disable IDE integration");
+  const choice = await ctx.ui.select("Select IDE connection", labels);
+  if (!choice) return;
+  if (choice === "Disable IDE integration") {
+    await actions.disconnect(ctx, true);
+    return;
+  }
+  const index = labels.indexOf(choice);
+  const candidate = candidates[index];
+  if (candidate) {
+    runtime.enabled = true;
+    await actions.connectCandidate(candidate, ctx);
+  }
+}
+function showStatus(runtime, ctx) {
+  const lines = buildWidget(runtime, ctx.cwd) ?? ["IDE: disconnected"];
+  ctx.ui.notify(lines.join("\n"), runtime.connectionStatus === "error" ? "error" : "info");
+}
+async function listCandidates(actions, ctx) {
+  const candidates = await actions.refreshCandidates(ctx);
+  if (candidates.length === 0) {
+    ctx.ui.notify("No matching IDE lock files found.", "info");
+    return;
+  }
+  ctx.ui.notify(
+    candidates.map(
+      (candidate, index) => `${index + 1}. ${candidate.lock.name} ${candidate.lock.host}:${candidate.lock.port}
+   ${candidate.workspaceFolder}
+   ${candidate.path}`
+    ).join("\n"),
+    "info"
+  );
+}
+function resolveAttachShortcut(env = process.env) {
+  const value = resolvePiConfigEnv(env)[PI_X_IDE_ATTACH_SHORTCUT_ENV] ?? DEFAULT_ATTACH_SHORTCUT;
+  const normalized = value.trim().toLowerCase();
+  if (DISABLED_ATTACH_SHORTCUT_VALUES.has(normalized)) return void 0;
+  return normalized;
+}
+function attachLatest(runtime, ctx) {
+  if (!runtime.latestSelection) {
+    ctx.ui.notify("No IDE selection is available.", "warning");
+    return;
+  }
+  const mention = formatRangeMention(runtime.latestSelection, { cwd: ctx.cwd });
+  ctx.ui.pasteToEditor(mention + "\n");
+  runtime.attachState = "pending";
+  updateIdeUi(runtime, ctx);
+  ctx.ui.notify(`Attached ${mention}`, "info");
+}
+
+// src/pi/context.ts
+function registerContextHandlers(pi, runtime) {
+  pi.on(
+    "before_agent_start",
+    (event, ctx) => runPiBoundary(
+      "Pi before_agent_start",
+      runtime,
+      () => {
+        runtime.ctx = ctx;
+        if (!runtime.enabled || !runtime.latestSelection || runtime.attachState !== "pending") return;
+        const snapshot = runtime.latestSelection;
+        runtime.attachState = "sent";
+        updateIdeUi(runtime, ctx);
+        if (promptContainsContextMarker(event.prompt, snapshot)) return;
+        return {
+          message: {
+            customType: IDE_CONTEXT_MESSAGE_TYPE,
+            content: formatEditorContextMessage(snapshot),
+            display: true
+          }
+        };
+      },
+      ctx
+    )
+  );
+}
+var IDE_CONTEXT_MESSAGE_TYPE = "pi-x-ide/context";
+function promptContainsContextMarker(prompt, snapshot) {
+  return prompt.includes(DIAGNOSTIC_CONTEXT_MARKER) || prompt.includes("<system-reminder><selected-context>") && (prompt.includes(snapshot.filePath) || !!snapshot.workspaceFolder && prompt.includes(snapshot.workspaceFolder));
+}
+
+// src/pi/diagnostic-renderer.ts
+var DIAGNOSTIC_BOX_PADDING_X = 1;
+var DIAGNOSTIC_BOX_PADDING_Y = 1;
+var MIN_CONTENT_WIDTH = 1;
+var TAB_REPLACEMENT = "   ";
+var ESCAPE_CHARACTER = String.fromCharCode(27);
+var ANSI_SEQUENCE_AT_START = new RegExp(`^${ESCAPE_CHARACTER}\\[[0-?]*[ -/]*[@-~]`);
+var GRAPHEME_SEGMENTER = typeof Intl.Segmenter === "function" ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : void 0;
+var SGR_CODES = {
+  reset: 0,
+  bold: 1,
+  dim: 2,
+  italic: 3,
+  underline: 4,
+  slowBlink: 5,
+  rapidBlink: 6,
+  inverse: 7,
+  conceal: 8,
+  strikethrough: 9,
+  doubleUnderline: 21,
+  intensityReset: 22,
+  italicReset: 23,
+  underlineReset: 24,
+  blinkReset: 25,
+  inverseReset: 27,
+  concealReset: 28,
+  strikethroughReset: 29,
+  foregroundStart: 30,
+  foregroundEnd: 37,
+  extendedForeground: 38,
+  foregroundReset: 39,
+  backgroundStart: 40,
+  backgroundEnd: 47,
+  extendedBackground: 48,
+  backgroundReset: 49,
+  overline: 53,
+  overlineReset: 55,
+  extendedUnderlineColor: 58,
+  underlineColorReset: 59,
+  brightForegroundStart: 90,
+  brightForegroundEnd: 97,
+  brightBackgroundStart: 100,
+  brightBackgroundEnd: 107
+};
+var SGR_INDEXED_COLOR_MODE = 5;
+var SGR_TRUE_COLOR_MODE = 2;
+var SGR_INDEXED_COLOR_PARAMETER_COUNT = 2;
+var SGR_TRUE_COLOR_PARAMETER_COUNT = 4;
+var SGR_STYLE_GROUPS = /* @__PURE__ */ new Map([
+  [SGR_CODES.bold, "bold"],
+  [SGR_CODES.dim, "dim"],
+  [SGR_CODES.italic, "italic"],
+  [SGR_CODES.underline, "underline"],
+  [SGR_CODES.slowBlink, "blink"],
+  [SGR_CODES.rapidBlink, "blink"],
+  [SGR_CODES.inverse, "inverse"],
+  [SGR_CODES.conceal, "conceal"],
+  [SGR_CODES.strikethrough, "strikethrough"],
+  [SGR_CODES.doubleUnderline, "underline"],
+  [SGR_CODES.overline, "overline"]
+]);
+var SGR_STYLE_RESETS = /* @__PURE__ */ new Map([
+  [SGR_CODES.intensityReset, ["bold", "dim"]],
+  [SGR_CODES.italicReset, ["italic"]],
+  [SGR_CODES.underlineReset, ["underline"]],
+  [SGR_CODES.blinkReset, ["blink"]],
+  [SGR_CODES.inverseReset, ["inverse"]],
+  [SGR_CODES.concealReset, ["conceal"]],
+  [SGR_CODES.strikethroughReset, ["strikethrough"]],
+  [SGR_CODES.overlineReset, ["overline"]]
+]);
+function registerDiagnosticRenderer(pi) {
+  pi.registerMessageRenderer(DIAGNOSTIC_FIX_CUSTOM_TYPE, (message, { expanded }, theme) => {
+    const details = message.details;
+    if (!details) return void 0;
+    return createDiagnosticFixComponent(details, theme, expanded);
+  });
+}
+function createDiagnosticFixComponent(details, theme, expanded) {
+  return new DiagnosticMessageComponent(
+    buildText(details, theme, expanded),
+    (text) => theme.bg("customMessageBg", text)
+  );
+}
+var DiagnosticMessageComponent = class {
+  constructor(text, bgFn) {
+    this.text = text;
+    this.bgFn = bgFn;
+  }
+  text;
+  bgFn;
+  cache;
+  invalidate() {
+    this.cache = void 0;
+  }
+  render(width) {
+    if (this.cache?.width === width) return this.cache.lines;
+    const contentWidth = Math.max(MIN_CONTENT_WIDTH, width - DIAGNOSTIC_BOX_PADDING_X * 2);
+    const leftPad = " ".repeat(DIAGNOSTIC_BOX_PADDING_X);
+    const lines = [];
+    for (let index = 0; index < DIAGNOSTIC_BOX_PADDING_Y; index += 1) {
+      lines.push(this.padAndApplyBackground("", width));
+    }
+    for (const wrappedLine of wrapAnsiText(this.text, contentWidth)) {
+      lines.push(this.padAndApplyBackground(leftPad + wrappedLine, width));
+    }
+    for (let index = 0; index < DIAGNOSTIC_BOX_PADDING_Y; index += 1) {
+      lines.push(this.padAndApplyBackground("", width));
+    }
+    this.cache = { width, lines };
+    return lines;
+  }
+  padAndApplyBackground(line, width) {
+    const padNeeded = Math.max(0, width - visibleWidth(line));
+    return this.bgFn(line + " ".repeat(padNeeded));
+  }
+};
+function wrapAnsiText(text, width) {
+  const normalizedText = text.replaceAll("	", TAB_REPLACEMENT);
+  const lines = [];
+  const sgrState = new SgrState();
+  for (const logicalLine of normalizedText.split("\n")) {
+    lines.push(...wrapAnsiLine(logicalLine, width, sgrState));
+  }
+  return lines.length > 0 ? lines : [""];
+}
+function wrapAnsiLine(line, width, sgrState) {
+  const lines = [];
+  let currentLine = sgrState.toAnsi();
+  let currentWidth = 0;
+  let index = 0;
+  while (index < line.length) {
+    const ansiSequence = readAnsiSequence(line, index);
+    if (ansiSequence) {
+      currentLine += ansiSequence;
+      sgrState.process(ansiSequence);
+      index += ansiSequence.length;
+      continue;
+    }
+    if (line[index] === ESCAPE_CHARACTER) {
+      currentLine += ESCAPE_CHARACTER;
+      index += 1;
+      continue;
+    }
+    const nextEscape = line.indexOf(ESCAPE_CHARACTER, index);
+    const textEnd = nextEscape === -1 ? line.length : nextEscape;
+    const textChunk = line.slice(index, textEnd);
+    for (const grapheme of segmentGraphemes(textChunk)) {
+      const graphemeWidth = visibleWidth(grapheme);
+      if (currentWidth > 0 && currentWidth + graphemeWidth > width) {
+        lines.push(currentLine + sgrState.lineEndReset());
+        currentLine = sgrState.toAnsi();
+        currentWidth = 0;
+      }
+      currentLine += grapheme;
+      currentWidth += graphemeWidth;
+    }
+    index = textEnd;
+  }
+  lines.push(currentLine + sgrState.lineEndReset());
+  return lines;
+}
+function readAnsiSequence(text, index) {
+  if (text[index] !== ESCAPE_CHARACTER) return void 0;
+  return ANSI_SEQUENCE_AT_START.exec(text.slice(index))?.[0];
+}
+var SgrState = class {
+  activeCodes = /* @__PURE__ */ new Map();
+  process(sequence) {
+    if (!sequence.endsWith("m")) return;
+    const rawParameters = sequence.slice(2, -1);
+    const parameters = rawParameters === "" ? [SGR_CODES.reset] : rawParameters.split(";").map(Number);
+    for (let index = 0; index < parameters.length; index += 1) {
+      const code = parameters[index];
+      if (!Number.isInteger(code)) continue;
+      if (code === SGR_CODES.reset) {
+        this.activeCodes.clear();
+        continue;
+      }
+      const styleGroup = SGR_STYLE_GROUPS.get(code);
+      if (styleGroup) {
+        this.activeCodes.set(styleGroup, formatSgrSequence([code]));
+        continue;
+      }
+      const resetGroups = SGR_STYLE_RESETS.get(code);
+      if (resetGroups) {
+        for (const resetGroup of resetGroups) this.activeCodes.delete(resetGroup);
+        continue;
+      }
+      if (isStandardForegroundCode(code)) {
+        this.activeCodes.set("foreground", formatSgrSequence([code]));
+        continue;
+      }
+      if (code === SGR_CODES.foregroundReset) {
+        this.activeCodes.delete("foreground");
+        continue;
+      }
+      if (isStandardBackgroundCode(code)) {
+        this.activeCodes.set("background", formatSgrSequence([code]));
+        continue;
+      }
+      if (code === SGR_CODES.backgroundReset) {
+        this.activeCodes.delete("background");
+        continue;
+      }
+      if (code === SGR_CODES.underlineColorReset) {
+        this.activeCodes.delete("underline-color");
+        continue;
+      }
+      const extendedGroup = getExtendedColorGroup(code);
+      if (extendedGroup) {
+        const parameterCount = getExtendedColorParameterCount(parameters[index + 1]);
+        if (parameterCount === 0 || index + parameterCount >= parameters.length) continue;
+        const colorParameters = parameters.slice(index, index + parameterCount + 1);
+        this.activeCodes.set(extendedGroup, formatSgrSequence(colorParameters));
+        index += parameterCount;
+      }
+    }
+  }
+  toAnsi() {
+    return [...this.activeCodes.values()].join("");
+  }
+  lineEndReset() {
+    return this.activeCodes.has("underline") ? formatSgrSequence([SGR_CODES.underlineReset]) : "";
+  }
+};
+function isStandardForegroundCode(code) {
+  return code >= SGR_CODES.foregroundStart && code <= SGR_CODES.foregroundEnd || code >= SGR_CODES.brightForegroundStart && code <= SGR_CODES.brightForegroundEnd;
+}
+function isStandardBackgroundCode(code) {
+  return code >= SGR_CODES.backgroundStart && code <= SGR_CODES.backgroundEnd || code >= SGR_CODES.brightBackgroundStart && code <= SGR_CODES.brightBackgroundEnd;
+}
+function getExtendedColorGroup(code) {
+  if (code === SGR_CODES.extendedForeground) return "foreground";
+  if (code === SGR_CODES.extendedBackground) return "background";
+  if (code === SGR_CODES.extendedUnderlineColor) return "underline-color";
+  return void 0;
+}
+function getExtendedColorParameterCount(mode) {
+  if (mode === SGR_INDEXED_COLOR_MODE) return SGR_INDEXED_COLOR_PARAMETER_COUNT;
+  if (mode === SGR_TRUE_COLOR_MODE) return SGR_TRUE_COLOR_PARAMETER_COUNT;
+  return 0;
+}
+function formatSgrSequence(parameters) {
+  return `${ESCAPE_CHARACTER}[${parameters.join(";")}m`;
+}
+function* segmentGraphemes(text) {
+  if (GRAPHEME_SEGMENTER) {
+    for (const segment of GRAPHEME_SEGMENTER.segment(text)) yield segment.segment;
+    return;
+  }
+  yield* text;
+}
+function buildText(details, theme, expanded) {
+  const severityColor = pickSeverityColor(details.diagnostics);
+  const label = theme.fg(severityColor, theme.bold("[DIAGNOSTIC]"));
+  const sourceLabel = describeSource(details.source);
+  const relPath = toRelativeDisplayPath(details.filePath, details.workspaceFolder, details.cwd);
+  const location = theme.fg("dim", `${relPath}:${formatRange(details.triggerRange)}`);
+  const count = details.diagnostics.length;
+  const noun = count === 1 ? "diagnostic" : "diagnostics";
+  const header = `${label} Fix ${count} ${noun} from ${sourceLabel} \u2014 ${location}`;
+  if (!expanded) {
+    return `${header}
+${theme.fg("dim", "ctrl+o to expand")}`;
+  }
+  const lines = [header];
+  for (const [index, diagnostic] of details.diagnostics.entries()) {
+    lines.push("");
+    lines.push(formatDiagnostic(diagnostic, index, details, theme));
+  }
+  return lines.join("\n");
+}
+function formatDiagnostic(diagnostic, index, details, theme) {
+  const color = diagnostic.severity === "error" ? "error" : "warning";
+  const headerText = `${diagnostic.severity.toUpperCase()} #${index + 1}`;
+  const lines = [`${theme.fg(color, headerText)} ${theme.fg("dim", formatRange(diagnostic.range))}`];
+  if (diagnostic.code !== void 0) {
+    lines.push(theme.fg("dim", `  code: ${formatDiagnosticCode(diagnostic.code)}`));
+  }
+  if (diagnostic.source) {
+    lines.push(theme.fg("dim", `  source: ${diagnostic.source}`));
+  }
+  lines.push(`  ${diagnostic.message}`);
+  if (diagnostic.contextLines.length > 0) {
+    for (const contextLine of diagnostic.contextLines) {
+      const marker = contextLine.isPrimary ? theme.fg(color, ">") : " ";
+      const lineNumber = theme.fg("dim", `${contextLine.line + 1}:`.padStart(4, " "));
+      lines.push(`  ${marker} ${lineNumber} ${contextLine.text}`);
+    }
+  }
+  if (diagnostic.relatedInformation && diagnostic.relatedInformation.length > 0) {
+    lines.push(theme.fg("dim", "  related:"));
+    for (const related of diagnostic.relatedInformation) {
+      const relatedPath = toRelativeDisplayPath(related.filePath, details.workspaceFolder, details.cwd);
+      lines.push(theme.fg("dim", `    ${relatedPath} ${formatRange(related.range)}: ${related.message}`));
+    }
+  }
+  return lines.join("\n");
+}
+function pickSeverityColor(diagnostics) {
+  return diagnostics.some((diagnostic) => diagnostic.severity === "error") ? "error" : "warning";
+}
+function describeSource(source) {
+  if (source === "vscode") return "VS Code";
+  return source;
+}
+
+// src/pi/runtime-loader.ts
+var defaultImporter = () => import("./chunks/runtime-services-TUOTPMCH.js");
+var importer = defaultImporter;
+var cachedPromise;
+function preloadRuntimeServices() {
+  return loadRuntimeServices();
+}
+function loadRuntimeServices() {
+  if (!cachedPromise) {
+    cachedPromise = importer().then(
+      (module) => module,
+      (error) => {
+        cachedPromise = void 0;
+        throw error;
+      }
+    );
+  }
+  return cachedPromise;
+}
+
+// src/pi/state.ts
+function createRuntime() {
+  return {
+    enabled: true,
+    candidates: [],
+    connectionStatus: "idle",
+    attachState: "idle",
+    reconnectAttempts: 0,
+    installingIdeIds: /* @__PURE__ */ new Set(),
+    sessionGeneration: 0,
+    sessionStarting: false,
+    pendingExtensionErrors: []
+  };
+}
+
+// src/pi/index.ts
+function index_default(pi) {
+  registerPiIdeExtension(pi);
+}
+function registerPiIdeExtension(pi, options = {}) {
+  const runtime = createRuntime();
+  const loadRuntimeServices2 = options.runtimeLoader?.loadRuntimeServices ?? loadRuntimeServices;
+  const preloadRuntimeServices2 = options.runtimeLoader?.preloadRuntimeServices ?? preloadRuntimeServices;
+  installPiErrorReporter(runtime);
+  registerContextHandlers(pi, runtime);
+  registerDiagnosticRenderer(pi);
+  registerIdeCommand(pi, runtime, {
+    refreshCandidates: (ctx) => withRuntimeServices(loadRuntimeServices2, runtime, ctx, (services) => services.refreshCandidates(runtime, ctx)),
+    connectAuto: (ctx) => withRuntimeServices(loadRuntimeServices2, runtime, ctx, (services) => services.connectAuto(runtime, ctx, pi)),
+    connectCandidate: (candidate, ctx) => withRuntimeServices(
+      loadRuntimeServices2,
+      runtime,
+      ctx,
+      (services) => services.connectCandidate(runtime, candidate, ctx, {}, pi)
+    ),
+    disconnect: (ctx, disabled) => withRuntimeServices(loadRuntimeServices2, runtime, ctx, (services) => services.disconnect(runtime, ctx, disabled)),
+    installExtension: (ctx) => withRuntimeServices(loadRuntimeServices2, runtime, ctx, (services) => services.installExtension(runtime, ctx))
+  });
+  void preloadRuntimeServices2().catch((error) => {
+    logExtensionError("Pi runtime preload", error);
+  });
+  pi.on(
+    "session_start",
+    (_event, ctx) => runPiBoundaryAsync(
+      "Pi session start",
+      runtime,
+      async () => {
+        runtime.sessionGeneration += 1;
+        const generation = runtime.sessionGeneration;
+        bindPiUiContext(runtime, ctx);
+        runtime.cwd = ctx.cwd;
+        runtime.sessionStarting = true;
+        const startupTask = (async () => {
+          const services = await loadRuntimeServices2();
+          if (runtime.sessionGeneration !== generation) return;
+          await services.startSession(pi, runtime, ctx);
+        })();
+        runtime.startupTask = startupTask;
+        try {
+          await startupTask;
+        } finally {
+          if (runtime.startupTask === startupTask) {
+            runtime.startupTask = void 0;
+          }
+          if (runtime.sessionGeneration === generation) {
+            runtime.sessionStarting = false;
+          }
+        }
+      },
+      ctx
+    )
+  );
+  pi.on(
+    "session_shutdown",
+    (_event, ctx) => runPiBoundaryAsync(
+      "Pi session shutdown",
+      runtime,
+      async () => {
+        runtime.sessionGeneration += 1;
+        runtime.sessionStarting = false;
+        bindPiUiContext(runtime, ctx);
+        const pendingStartup = runtime.startupTask;
+        if (pendingStartup) {
+          await pendingStartup.catch(() => void 0);
+        }
+        const shouldLoadRuntime = !!runtime.connection || !!runtime.reconnectFiber || !!runtime.zedPollFiber || !!pendingStartup;
+        if (shouldLoadRuntime) {
+          try {
+            const services = await loadRuntimeServices2();
+            await services.shutdownSession(runtime, ctx);
+            return;
+          } catch (error) {
+            logExtensionError("Pi session shutdown runtime load", error);
+          }
+        }
+        const connection = runtime.connection;
+        runtime.connection = void 0;
+        connection?.disconnect();
+        clearIdeUi(runtime, ctx);
+        runtime.ctx = void 0;
+      },
+      ctx
+    )
+  );
+  return runtime;
+}
+async function withRuntimeServices(loadRuntimeServices2, runtime, ctx, action) {
+  const services = await loadRuntimeServices2();
+  bindPiUiContext(runtime, ctx);
+  return action(services);
+}
+export {
+  index_default as default,
+  registerPiIdeExtension
+};