@llblab/pi-kit 0.1.0

package/node_modules/@llblab/pi-actors/lib/extension-runtime.ts

@@ -0,0 +1,181 @@
+/**
+ * Pi actor extension runtime coordinator.
+ * Zones: extension session lifecycle, host tool adaptation, runtime service composition
+ * Owns low-level Pi lifecycle effects and tool wrapping without owning event registration.
+ */
+
+import * as AutomaticReviewRuntime from "./automatic-review-runtime.ts";
+import * as CommandTemplates from "./command-templates.ts";
+import * as Paths from "./paths.ts";
+import * as Pi from "./pi.ts";
+import * as Prompts from "./prompts.ts";
+import * as RecipeResolution from "./recipes-context.ts";
+import * as RecipesReferences from "./recipes-references.ts";
+import * as RunUiRuntime from "./run-ui-runtime.ts";
+import * as Runtime from "./runtime.ts";
+import * as Temp from "./temp.ts";
+import * as Tools from "./tools.ts";
+import * as ToolsResponse from "./tools-response.ts";
+
+export interface ActorExtensionRuntime {
+  beforeAgentStart(
+    systemPrompt: string,
+    skills: RecipesReferences.ActiveSkillRecipeSource[],
+    ctx: Pi.ExtensionContext,
+  ): { systemPrompt: string };
+  discoverResources(metaUrl: string): { skillPaths: string[] } | undefined;
+  getRunOwnerId(ctx: Pi.ExtensionContext): string;
+  onAgentEnd(ctx: Pi.ExtensionContext): void;
+  onSessionShutdown(reason: string, ctx: Pi.ExtensionContext): void;
+  onSessionStart(ctx: Pi.ExtensionContext): Promise<void>;
+  registerCoreTools(): void;
+}
+
+export function createActorExtensionRuntime(
+  pi: Pi.ExtensionAPI,
+): ActorExtensionRuntime {
+  let activeRunContext: Pi.ExtensionContext | undefined;
+  const recipeResolutionContextsBySession = new Map<
+    string,
+    RecipeResolution.RecipeResolutionContext
+  >();
+  const getRunOwnerId = Pi.getSessionId;
+  const getRecipeResolutionContext = (ctx: Pi.ExtensionContext) => {
+    const sessionId = getRunOwnerId(ctx);
+    const resolutionContext = recipeResolutionContextsBySession.get(sessionId);
+    if (!resolutionContext) {
+      throw new Error(
+        `Recipe resolution context is unavailable for session ${sessionId}.`,
+      );
+    }
+    return resolutionContext;
+  };
+  const automaticReview = AutomaticReviewRuntime.createAutomaticReviewRuntime({
+    getActiveContext: () => activeRunContext,
+    getRunOwnerId,
+    getThinkingLevel: () => pi.getThinkingLevel(),
+  });
+  const runUiRuntime = RunUiRuntime.createRunUiRuntime({
+    getActiveContext: () => activeRunContext,
+    getRunOwnerId,
+    onRunEvent: automaticReview.schedule,
+    pi,
+  });
+  const actorToolDefinitions = new Map<string, Tools.ActorToolDefinition>();
+  const withCurrentThinkingContext = <T extends Tools.ActorToolDefinition>(
+    definition: T,
+  ): T => {
+    if (typeof definition.execute !== "function") return definition;
+    const execute = definition.execute as (...args: unknown[]) => unknown;
+    return {
+      ...definition,
+      execute: async (...args: unknown[]) => {
+        const nextArgs = [...args];
+        const ctx = nextArgs[4];
+        if (ctx && typeof ctx === "object") {
+          nextArgs[4] = {
+            ...(ctx as Record<string, unknown>),
+            recipeResolutionContext: getRecipeResolutionContext(
+              ctx as Pi.ExtensionContext,
+            ),
+            getThinkingLevel: () => pi.getThinkingLevel(),
+          };
+        }
+        try {
+          return ToolsResponse.spaceToolResult(await execute(...nextArgs));
+        } catch (error) {
+          throw ToolsResponse.spaceToolError(error);
+        }
+      },
+    } as T;
+  };
+  const runtime = Runtime.createAutoToolsRuntime({
+    configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
+    exec: CommandTemplates.execCommandTemplate,
+    getActiveTools: () => pi.getActiveTools(),
+    getAllTools: () => pi.getAllTools(),
+    registerTool: (definition) => {
+      const wrapped = withCurrentThinkingContext(definition);
+      actorToolDefinitions.set(wrapped.name, wrapped);
+      pi.registerTool(wrapped);
+    },
+    reservedToolNames: Tools.RESERVED_TOOL_NAMES,
+    setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
+  });
+  const recipeReload = Runtime.createRecipeToolReloadWatcher(runtime, {
+    getResolutionContext: () =>
+      activeRunContext
+        ? getRecipeResolutionContext(activeRunContext)
+        : undefined,
+  });
+  return {
+    beforeAgentStart(systemPrompt, skills, ctx) {
+      const sessionId = getRunOwnerId(ctx);
+      const resolutionContext = RecipeResolution.createRecipeResolutionContext(
+        sessionId,
+        ctx.cwd,
+        RecipesReferences.createActiveSkillRecipeContext(skills),
+      );
+      recipeResolutionContextsBySession.set(sessionId, resolutionContext);
+      runtime.loadTools(ctx, resolutionContext);
+      return {
+        systemPrompt: `${systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,
+      };
+    },
+    discoverResources(metaUrl) {
+      const skillPaths = Paths.getExistingExtensionSkillPaths(metaUrl);
+      return skillPaths.length > 0 ? { skillPaths } : undefined;
+    },
+    getRunOwnerId,
+    onAgentEnd(ctx) {
+      if (activeRunContext === ctx) automaticReview.schedule();
+    },
+    onSessionShutdown(reason, ctx) {
+      recipeResolutionContextsBySession.delete(getRunOwnerId(ctx));
+      activeRunContext = undefined;
+      automaticReview.close();
+      recipeReload.close();
+      runUiRuntime.shutdown(reason, ctx);
+    },
+    async onSessionStart(ctx) {
+      const sessionId = getRunOwnerId(ctx);
+      recipeResolutionContextsBySession.set(
+        sessionId,
+        RecipeResolution.createEmptyRecipeResolutionContext(sessionId, ctx.cwd),
+      );
+      ctx.ui.setWidget("zz-pi-actors-comms", undefined);
+      activeRunContext = ctx;
+      runUiRuntime.close();
+      automaticReview.close();
+      recipeReload.close();
+      await Temp.prepareExtensionTempDir(Paths.EXTENSION_RUNTIME_PATHS.tempDir);
+      if (activeRunContext !== ctx) return;
+      automaticReview.start(ctx);
+      runUiRuntime.start(ctx);
+      recipeReload.watch(ctx);
+    },
+    registerCoreTools() {
+      Pi.registerToolDefinitions(
+        pi,
+        Tools.createCoreActorToolDefinitions<Pi.ExtensionContext>({
+          configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
+          getActiveTools: () => pi.getActiveTools(),
+          getRecipeResolutionContext: () =>
+            activeRunContext
+              ? getRecipeResolutionContext(activeRunContext)
+              : undefined,
+          getRuntimeTool: (name) =>
+            Tools.resolveActiveRuntimeTool(
+              name,
+              runtime.getTools(),
+              (activeName) => actorToolDefinitions.get(activeName),
+            ),
+          getRuntimeToolStatus: runtime.getToolStatus,
+          handleRuntimeControl: automaticReview.handleControl,
+          registryRuntime: runtime,
+          setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
+        }).map(withCurrentThinkingContext),
+      );
+    },
+  };
+}

package/node_modules/@llblab/pi-actors/lib/file-state.ts

@@ -0,0 +1,306 @@
+/**
+ * File state persistence helpers
+ * Zones: file persistence, atomic writes, runtime state support
+ * Owns generic durable JSON file writes shared by registry config and async run state.
+ */
+
+import { spawnSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, parse, resolve } from "node:path";
+
+const FILE_MUTATION_LOCK_TIMEOUT_MS = process.platform === "win32" ? 30000 : 15000;
+const FILE_MUTATION_LOCK_STALE_MS = 30000;
+const FILE_MUTATION_LOCK_RECLAIM_POLL_MS = 100;
+const FILE_MUTATION_LOCK_REMOVAL_GRACE_MS = 250;
+const FILE_MUTATION_LOCK_MAX_WAIT_MS = 50;
+const FILE_MUTATION_LOCK_ROOT = join(tmpdir(), "pi-actors-file-locks");
+
+function canonicalMutationPath(path: string): string {
+  const absolute = resolve(path);
+  try {
+    if (lstatSync(absolute).isSymbolicLink()) {
+      const target = realpathSync.native(absolute);
+      return process.platform === "win32" ? target.toLowerCase() : target;
+    }
+  } catch {
+    /* Materialization may race lock-key derivation; canonicalize through the parent. */
+  }
+  const suffix: string[] = [basename(absolute)];
+  let existing = dirname(absolute);
+  while (!existsSync(existing)) {
+    const parent = dirname(existing);
+    if (parent === existing || existing === parse(existing).root) break;
+    suffix.unshift(basename(existing));
+    existing = parent;
+  }
+  const canonicalAncestor = existsSync(existing)
+    ? realpathSync.native(existing)
+    : existing;
+  const canonical = resolve(canonicalAncestor, ...suffix);
+  return process.platform === "win32" ? canonical.toLowerCase() : canonical;
+}
+
+export function mutationLockPath(path: string): string {
+  const key = createHash("sha256")
+    .update(canonicalMutationPath(path))
+    .digest("hex");
+  return join(FILE_MUTATION_LOCK_ROOT, `${key}.lock`);
+}
+
+function isZombieProcess(pid: number): boolean {
+  if (process.platform === "linux") try {
+    const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+    return stat.slice(stat.lastIndexOf(")") + 2).startsWith("Z ");
+  } catch { return false; }
+  if (process.platform !== "darwin") return false;
+  const result = spawnSync("ps", ["-p", String(pid), "-o", "stat="], { encoding: "utf8" });
+  return result.status === 0 && result.stdout.trim().startsWith("Z");
+}
+
+function lockOwnerStatus(lockPath: string): "alive" | "dead" | "unknown" {
+  try {
+    const owner = JSON.parse(
+      readFileSync(join(lockPath, "owner.json"), "utf8"),
+    ) as { pid?: unknown };
+    const pid = Number(owner.pid);
+    if (!Number.isInteger(pid) || pid <= 0) return "unknown";
+    try {
+      process.kill(pid, 0);
+      if (Date.now() - statSync(lockPath).mtimeMs > FILE_MUTATION_LOCK_REMOVAL_GRACE_MS &&
+          isZombieProcess(pid)) return "dead";
+      return "alive";
+    } catch (error) {
+      return (error as NodeJS.ErrnoException).code === "ESRCH"
+        ? "dead"
+        : "unknown";
+    }
+  } catch {
+    return "unknown";
+  }
+}
+
+export interface FileMutationLockOptions {
+  onBeforeLockPublish?(): void;
+  onBeforeReclaimRemove?(): void;
+  onContention?(): void;
+  onRemovalContention?(): void;
+}
+
+function readLockToken(lockPath: string): string | undefined {
+  try {
+    const owner = JSON.parse(
+      readFileSync(join(lockPath, "owner.json"), "utf8"),
+    ) as { token?: unknown };
+    return typeof owner.token === "string" ? owner.token : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function prepareLockBoundary(lockPath: string, token: string, onBeforePublish?: () => void): string {
+  const pendingPath = `${lockPath}.${process.pid}.${token}.pending`;
+  try {
+    mkdirSync(pendingPath);
+    writeFileSync(join(pendingPath, "owner.json"), `${JSON.stringify({ pid: process.pid, token, acquired_at: new Date().toISOString() })}\n`, "utf8");
+    onBeforePublish?.();
+    return pendingPath;
+  } catch (error) {
+    try { rmSync(pendingPath, { recursive: true, force: true }); } catch {}
+    throw error;
+  }
+}
+
+function removeLockBoundary(lockPath: string, token: string | undefined): boolean {
+  if (readLockToken(lockPath) !== token) return false;
+  if (process.platform === "win32") try { rmSync(lockPath, { recursive: true, force: true, maxRetries: 20, retryDelay: 5 }); return true; } catch { return false; }
+  const removingPath = `${lockPath}.${process.pid}.${randomUUID()}.removing`;
+  try { renameSync(lockPath, removingPath); } catch { return false; }
+  try { rmSync(removingPath, { recursive: true, force: true }); } catch {}
+  return true;
+}
+
+function tryReclaimRemovalBoundary(reclaimPath: string): void {
+  if (!existsSync(reclaimPath)) return;
+  try {
+    const age = Date.now() - statSync(reclaimPath).mtimeMs;
+    if (age <= FILE_MUTATION_LOCK_REMOVAL_GRACE_MS) return;
+    const inspectedToken = readLockToken(reclaimPath);
+    const ownerStatus = lockOwnerStatus(reclaimPath);
+    if (
+      (ownerStatus === "dead" ||
+        (ownerStatus === "unknown" && age > FILE_MUTATION_LOCK_STALE_MS)) &&
+      readLockToken(reclaimPath) === inspectedToken
+    ) {
+      removeLockBoundary(reclaimPath, inspectedToken);
+    }
+  } catch {
+    /* another contender changed the boundary */
+  }
+}
+
+function withRemovalBoundary(
+  lockPath: string,
+  action: () => void,
+): boolean {
+  const reclaimPath = `${lockPath}.reclaim`;
+  const token = randomUUID();
+  const pendingPath = prepareLockBoundary(reclaimPath, token);
+  try {
+    try { renameSync(pendingPath, reclaimPath); } catch {
+      tryReclaimRemovalBoundary(reclaimPath);
+      return false;
+    }
+    try {
+      action();
+      return true;
+    } finally {
+      removeLockBoundary(reclaimPath, token);
+    }
+  } finally {
+    try { rmSync(pendingPath, { recursive: true, force: true }); } catch {}
+  }
+}
+
+function tryReclaimMutationLock(
+  lockPath: string,
+  options: FileMutationLockOptions,
+): boolean {
+  let reclaimed = false;
+  if (!withRemovalBoundary(lockPath, () => {
+    if (!existsSync(lockPath)) {
+      reclaimed = true;
+      return;
+    }
+    const inspectedToken = readLockToken(lockPath);
+    const age = Date.now() - statSync(lockPath).mtimeMs;
+    const ownerStatus = lockOwnerStatus(lockPath);
+    if (
+      (ownerStatus === "dead" ||
+        (ownerStatus === "unknown" && age > FILE_MUTATION_LOCK_STALE_MS)) &&
+      readLockToken(lockPath) === inspectedToken
+    ) {
+      options.onBeforeReclaimRemove?.();
+      reclaimed = removeLockBoundary(lockPath, inspectedToken);
+    }
+  })) {
+    return false;
+  }
+  return reclaimed;
+}
+
+export function acquireFileMutationLock(
+  path: string,
+  options: FileMutationLockOptions = {},
+): () => void {
+  mkdirSync(FILE_MUTATION_LOCK_ROOT, { recursive: true });
+  const lockPath = mutationLockPath(path);
+  const deadline = Date.now() + FILE_MUTATION_LOCK_TIMEOUT_MS;
+  const token = randomUUID();
+  const pendingPath = prepareLockBoundary(lockPath, token, options.onBeforeLockPublish);
+  let contentionReported = false;
+  let nextReclaimAt = 0;
+  let waitMs = 10;
+  try {
+    for (;;) {
+      try {
+        renameSync(pendingPath, lockPath);
+        break;
+      } catch (error) {
+        if (!contentionReported) {
+          contentionReported = true;
+          options.onContention?.();
+        }
+        const now = Date.now();
+        if (now >= nextReclaimAt) {
+          nextReclaimAt = now + FILE_MUTATION_LOCK_RECLAIM_POLL_MS;
+          if (tryReclaimMutationLock(lockPath, options)) {
+            waitMs = 10;
+            continue;
+          }
+        }
+        if (now >= deadline) {
+          throw new Error(`Timed out waiting for file mutation lock: ${canonicalMutationPath(path)}`, {
+            cause: error,
+          });
+        }
+        const jitter = Math.floor(Math.random() * Math.max(1, Math.floor(waitMs / 2)));
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitMs + jitter);
+        waitMs = Math.min(FILE_MUTATION_LOCK_MAX_WAIT_MS, waitMs + 5);
+      }
+    }
+  } finally {
+    try { rmSync(pendingPath, { recursive: true, force: true }); } catch {}
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const deadline = Date.now() + FILE_MUTATION_LOCK_TIMEOUT_MS;
+    let removalContentionReported = false;
+    while (
+      !withRemovalBoundary(lockPath, () => {
+        removeLockBoundary(lockPath, token);
+      })
+    ) {
+      if (!removalContentionReported) {
+        removalContentionReported = true;
+        options.onRemovalContention?.();
+      }
+      if (Date.now() >= deadline) return;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  };
+}
+
+export function withFileMutationLock<T>(
+  path: string,
+  mutate: () => T,
+  options: FileMutationLockOptions = {},
+): T {
+  const release = acquireFileMutationLock(path, options);
+  try {
+    return mutate();
+  } finally {
+    release();
+  }
+}
+
+function replaceFileWithRetry(source: string, target: string): void {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      renameSync(source, target);
+      return;
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if ((code !== "EPERM" && code !== "EBUSY") || attempt >= 19) throw error;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+    }
+  }
+}
+
+export function writeTextAtomic(
+  path: string,
+  content: string,
+  options: { onBeforeReplace?(): void } = {},
+): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tempPath = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tempPath, content, "utf8");
+    options.onBeforeReplace?.();
+    replaceFileWithRetry(tempPath, path);
+  } catch (error) {
+    try {
+      unlinkSync(tempPath);
+    } catch {
+      /* best effort */
+    }
+    throw error;
+  }
+}
+
+export function writeJsonAtomic(path: string, value: unknown): void {
+  writeTextAtomic(path, `${JSON.stringify(value, null, 2)}\n`);
+}

package/node_modules/@llblab/pi-actors/lib/identity.ts

@@ -0,0 +1,29 @@
+/**
+ * Identifier normalization helpers
+ * Zones: registry identity, shared validation
+ * Owns stable tool, argument, and file-label identifier normalization
+ */
+
+export function normalizeIdentifier(value: string, prefix: string): string {
+  let name = value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_]/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "");
+  if (!name) return "";
+  if (/^[0-9]/.test(name)) name = `${prefix}_${name}`;
+  return name.slice(0, 64).replace(/_+$/g, "");
+}
+
+export function normalizeToolName(value: string): string {
+  return normalizeIdentifier(value, "tool");
+}
+
+export function normalizeArgName(value: string): string {
+  return normalizeIdentifier(value, "arg");
+}
+
+export function sanitizeFilePart(value: string): string {
+  return normalizeIdentifier(value, "tool") || "tool";
+}

package/node_modules/@llblab/pi-actors/lib/inspector-actions.ts

@@ -0,0 +1,79 @@
+/**
+ * Actor Inspector actions for concrete Run instances.
+ * Owns: exact-session run-action authorization, canonical kill routing, and bounded operator feedback.
+ */
+
+import { join } from "node:path";
+
+import { safeRunId } from "./runs-identity.ts";
+
+const FEEDBACK_LIMIT = 180;
+
+export interface ActorInspectorKillResult {
+  ok: boolean;
+  message: string;
+}
+
+export interface ActorInspectorKillDeps {
+  getRunStatus: (runOrDir: string) => Record<string, unknown>;
+  killRun: (
+    runOrDir: string,
+    expected: { ownerId: string; runInstanceId: string },
+  ) => Record<string, unknown>;
+}
+
+function bounded(value: unknown): string {
+  const text = String(value ?? "").replaceAll(/\s+/g, " ").trim();
+  return text.length <= FEEDBACK_LIMIT
+    ? text
+    : `${text.slice(0, FEEDBACK_LIMIT - 1)}…`;
+}
+
+export function killOwnedRunFromInspector(
+  ownerId: string,
+  run: string,
+  stateRoot: string,
+  expectedRunInstanceId: string,
+  deps: ActorInspectorKillDeps,
+): ActorInspectorKillResult {
+  let stateDir: string;
+  try {
+    stateDir = join(stateRoot, safeRunId(run));
+  } catch (error) {
+    return {
+      ok: false,
+      message: `Kill rejected: ${bounded(error instanceof Error ? error.message : error)}`,
+    };
+  }
+  try {
+    const status = deps.getRunStatus(stateDir);
+    if (status.ownerId !== ownerId) {
+      return { ok: false, message: "Kill rejected: run ownership changed." };
+    }
+    if (status.status !== "running") {
+      return {
+        ok: false,
+        message: `Kill unavailable: run is ${bounded(status.status || "terminal")}.`,
+      };
+    }
+    if (status.run_instance_id !== expectedRunInstanceId) {
+      return { ok: false, message: "Kill rejected: run generation changed." };
+    }
+    const result = deps.killRun(stateDir, {
+      ownerId,
+      runInstanceId: expectedRunInstanceId,
+    });
+    if (result.killed === true) {
+      return { ok: true, message: `Killed run:${run}.` };
+    }
+    return {
+      ok: false,
+      message: `Kill failed: ${bounded(result.reason || "control rejected")}.`,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      message: `Kill failed: ${bounded(error instanceof Error ? error.message : error)}.`,
+    };
+  }
+}

package/node_modules/@llblab/pi-actors/lib/inspector-command.ts

@@ -0,0 +1,54 @@
+/**
+ * Actor Inspector command adapter.
+ * Zones: Pi command registration, overlay construction, owned-run control ports
+ * Owns host-facing Inspector launch wiring without owning Inspector state or actions.
+ */
+
+import * as AsyncRuns from "./async-runs.ts";
+import * as InspectorActions from "./inspector-actions.ts";
+import * as InspectorOverlay from "./inspector-overlay.ts";
+import * as Paths from "./paths.ts";
+import type * as Pi from "./pi.ts";
+
+export function registerActorInspectorCommand(
+  pi: Pi.ExtensionAPI,
+  getRunOwnerId: (ctx: Pi.ExtensionContext) => string,
+): void {
+  pi.registerCommand("actor-inspector", {
+    description: "Open the keyboard-driven Actor Inspector",
+    handler: async (_args, ctx) => {
+      ctx.ui.setWidget("zz-pi-actors-comms", undefined);
+      await ctx.ui.custom<void>(
+        (tui, theme, _keybindings, done) =>
+          new InspectorOverlay.ActorInspectorOverlay({
+            done,
+            killRun: (run, runInstanceId) =>
+              InspectorActions.killOwnedRunFromInspector(
+                getRunOwnerId(ctx),
+                run,
+                Paths.EXTENSION_RUNTIME_PATHS.runStateRoot,
+                runInstanceId,
+                {
+                  getRunStatus: AsyncRuns.getRunStatus,
+                  killRun: AsyncRuns.killRun,
+                },
+              ),
+            ownerId: getRunOwnerId(ctx),
+            stateRoot: Paths.EXTENSION_RUNTIME_PATHS.runStateRoot,
+            theme,
+            tui,
+          }),
+        {
+          overlay: true,
+          overlayOptions: {
+            anchor: "center",
+            width: "94%",
+            minWidth: 72,
+            maxHeight: "94%",
+            margin: 1,
+          },
+        },
+      );
+    },
+  });
+}