@cortexkit/opencode-magic-context 0.49.16 → 0.49.17

package/src/shared/rpc-server.ts

@@ -1,7 +1,8 @@
 import { randomBytes, timingSafeEqual } from "node:crypto";
-import { readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { readdirSync, readFileSync, rmdirSync, unlinkSync } from "node:fs";
 import type { Server, ServerWebSocket } from "bun";
 import { log } from "./logger";
+import { reapDeadRpcDiscovery } from "./rpc-discovery-cleanup";
 import {
     acknowledgeNotifications,
     drainNotifications,
@@ -82,6 +83,7 @@ export class MagicContextRpcServer {
     private portFilePath: string;
     private portDir: string;
     private startedAt = Date.now();
+    private stopped = false;
     private readonly instanceId = randomBytes(8).toString("hex");
     private unregisterOwnInstance: (() => void) | null = null;
     /** Every authenticated WS socket, so dispose can close them all. */
@@ -93,7 +95,10 @@ export class MagicContextRpcServer {
     // discovers/guesses the port.
     private readonly token = randomBytes(32).toString("hex");
 
-    constructor(storageDir: string, directory: string) {
+    constructor(
+        private storageDir: string,
+        directory: string,
+    ) {
         this.portFilePath = rpcPortFilePath(storageDir, directory, process.pid, this.instanceId);
         this.portDir = rpcPortDir(storageDir, directory);
     }
@@ -131,6 +136,9 @@ export class MagicContextRpcServer {
             log("rpc server skipped: Bun runtime not available (no TUI consumer)");
             return 0;
         }
+        this.stopped = false;
+        await reapDeadRpcDiscovery(this.storageDir);
+        if (this.stopped) return 0;
         this.startedAt = Date.now();
         const self = this;
         const server = inRootAsyncContext(() =>
@@ -172,17 +180,26 @@ export class MagicContextRpcServer {
             // The discovery file carries the RPC bearer token. The shared writer
             // creates its directory and temporary file with owner-only modes.
             this.unregisterOwnInstance ??= registerOwnRpcServerInstance(this.instanceId);
-            writeStorageFileAtomicSync(
-                this.portFilePath,
-                JSON.stringify({
-                    port: this.port,
-                    pid: process.pid,
-                    started_at: this.startedAt,
-                    kind: "OpenCode server",
-                    token: this.token,
-                    instance_id: this.instanceId,
-                }),
-            );
+            const publish = () =>
+                writeStorageFileAtomicSync(
+                    this.portFilePath,
+                    JSON.stringify({
+                        port: this.port,
+                        pid: process.pid,
+                        started_at: this.startedAt,
+                        kind: "OpenCode server",
+                        token: this.token,
+                        instance_id: this.instanceId,
+                    }),
+                );
+            try {
+                publish();
+            } catch (error) {
+                // An empty-directory reaper can race the writer before its temp
+                // file exists. Recreate the directory and retry that case only.
+                if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+                publish();
+            }
             log(`[rpc] server listening on 127.0.0.1:${this.port}`);
         } catch (err) {
             log(`[rpc] failed to write port file: ${err}`);
@@ -193,6 +210,7 @@ export class MagicContextRpcServer {
 
     /** Stop the server: close every socket, stop accepting, remove port file. */
     stop(): void {
+        this.stopped = true;
         for (const ws of this.sockets) {
             try {
                 if (ws.data.authTimer) clearTimeout(ws.data.authTimer);
@@ -213,6 +231,11 @@ export class MagicContextRpcServer {
         } catch {
             // Intentional: port file may already be gone
         }
+        try {
+            rmdirSync(this.portDir);
+        } catch {
+            // Other instances' discovery records must survive this server's stop.
+        }
         this.unregisterOwnInstance?.();
         this.unregisterOwnInstance = null;
     }

package/src/shared/search-text.test.ts

@@ -0,0 +1,47 @@
+import { expect, test } from "bun:test";
+import { cleanSearchText, keywordRelevance, matchedSearchSnippet } from "./search-text";
+import { removeSystemReminders } from "./system-directive";
+
+test("nested reminder contents stay quarantined through the outer closing tag", () => {
+    expect(
+        removeSystemReminders(
+            'before <SYSTEM-REMINDER origin="host">outer <system-reminder>inner</system-reminder> leaked tail</SYSTEM-REMINDER> after',
+        ),
+    ).toBe("before  after");
+    expect(removeSystemReminders("before <system-reminder>unfinished")).toBe("before");
+    expect(removeSystemReminders("before </system-reminder> after")).toBe("before  after");
+});
+
+test("mismatched notification closes cannot release hidden content", () => {
+    expect(cleanSearchText("kept <task>hidden </task_cohort> still hidden</task> kept")).toBe(
+        "kept kept",
+    );
+    expect(cleanSearchText("kept <task id='finished'/> kept")).toBe("kept kept");
+});
+
+test("task notification trees and cut legacy XML never become hint text", () => {
+    expect(
+        cleanSearchText(
+            '<task_cohort id="parent"><task id="child">background result</task>status</task_cohort> actual answer',
+        ),
+    ).toBe("actual answer");
+    expect(cleanSearchText('<task id="truncated">background result…')).toBe("");
+});
+
+test("keyword confidence measures absolute distinct term coverage, not result rank", () => {
+    expect(keywordRelevance("explain historian cache wiring", "cache icons")).toBeCloseTo(0.2);
+    expect(
+        keywordRelevance("historian cache wiring", "historian cache wiring details"),
+    ).toBeCloseTo(0.8);
+    expect(keywordRelevance("historian cache wiring", "<task>historian cache wiring</task>")).toBe(
+        0,
+    );
+});
+
+test("matched snippets prefer a dense passage over an irrelevant first line", () => {
+    const content = `Header cache. ${"padding ".repeat(150)}Historian cache wiring uses incremental pools. ${"trailing ".repeat(100)}`;
+    const snippet = matchedSearchSnippet(content, "historian cache wiring", 80);
+    expect(snippet).toContain("Historian cache wiring");
+    expect(snippet).not.toContain("Header");
+    expect(matchedSearchSnippet(content, "unrelated deployment")).toBe("");
+});

package/src/shared/search-text.ts

@@ -0,0 +1,63 @@
+import { removeNestedBlocks } from "./system-directive";
+
+export function removeTaskNotifications(text: string): string {
+    return removeNestedBlocks(text, ["task", "task_cohort"]);
+}
+
+/** Remove injected notifications before scoring or rendering; previously saved hints replay unchanged. */
+export function cleanSearchText(text: string): string {
+    return removeNestedBlocks(text, ["system-reminder", "task", "task_cohort"])
+        .replace(/\s+/g, " ")
+        .trim();
+}
+
+const QUERY_STOP_WORDS = new Set(
+    "a an and are as at be been by can could did do does for from how i in is it me my of on or our please should that the their them there these they this to us was we were what when where which who why will with would you your".split(
+        " ",
+    ),
+);
+
+function terms(text: string): string[] {
+    return [
+        ...new Set(
+            (text.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? []).filter(
+                (term) => !QUERY_STOP_WORDS.has(term),
+            ),
+        ),
+    ];
+}
+
+/** Score the share of distinct query terms present, independently of other results. */
+export function keywordRelevance(query: string, content: string): number {
+    const needles = terms(query);
+    if (needles.length === 0) return 0;
+    const words = new Set(terms(cleanSearchText(content)));
+    return (0.8 * needles.filter((term) => words.has(term)).length) / needles.length;
+}
+
+/** Pick the densest matching passage before compression can discard the matched words. */
+export function matchedSearchSnippet(content: string, query: string, cap = 220): string {
+    const text = cleanSearchText(content);
+    const needles = new Set(terms(query));
+    const matches = [...text.matchAll(/[\p{L}\p{N}_]+/gu)].filter((match) =>
+        needles.has(match[0].toLowerCase()),
+    );
+    if (matches.length === 0) return "";
+    let bestStart = matches[0].index;
+    let bestCoverage = -1;
+    for (const match of matches) {
+        const start = Math.max(0, match.index - Math.floor(cap / 5));
+        const coverage = keywordRelevance(query, text.slice(start, start + cap));
+        if (coverage > bestCoverage) {
+            bestStart = start;
+            bestCoverage = coverage;
+        }
+    }
+    // Avoid emitting half a word at the left edge of a passage.
+    if (bestStart > 0) {
+        const boundary = text.indexOf(" ", bestStart);
+        if (boundary >= 0 && boundary < matches[matches.length - 1].index) bestStart = boundary + 1;
+    }
+    const passage = text.slice(bestStart, bestStart + cap).trim();
+    return `${bestStart > 0 ? "…" : ""}${passage}${bestStart + cap < text.length ? "…" : ""}`;
+}

package/src/shared/sqlite.test.ts

@@ -1,14 +1,40 @@
 import { describe, expect, it } from "bun:test";
 import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import {
     Database,
     detectSqliteRuntime,
     getSqliteMemoryStats,
     loadSqliteModule,
+    openImmutableDatabase,
     SqliteRuntimeUnavailableError,
 } from "./sqlite";
+import { createTestTempDir } from "./test-temp-dir";
 
 describe("SQLite runtime selector", () => {
+    it("imports the shared SQLite module in Bun without node:sqlite available", () => {
+        const sqliteUrl = new URL("./sqlite.ts", import.meta.url).href;
+        const script = `
+            const getBuiltinModule = process.getBuiltinModule;
+            process.getBuiltinModule = function (specifier) {
+                if (specifier === "node:sqlite") throw new Error("node:sqlite deliberately unavailable");
+                return getBuiltinModule.call(process, specifier);
+            };
+            await import(${JSON.stringify(sqliteUrl)});
+            console.log("shared SQLite import succeeded");
+        `;
+        const child = spawnSync(process.execPath, ["-e", script], {
+            encoding: "utf8",
+            windowsHide: true,
+        });
+
+        expect(child.error).toBeUndefined();
+        expect(child.status).toBe(0);
+        expect(child.stdout).toContain("shared SQLite import succeeded");
+    });
+
     it("suppresses only the node:sqlite experimental warning in a real Node process", () => {
         // Node 24.21 no longer emits this warning, so inject it during loading
         // to keep the suppression assertion load-bearing on newer runtimes.
@@ -80,6 +106,36 @@ describe("SQLite runtime selector", () => {
         expect(getSqliteMemoryStats().connectionCount).toBe(before);
     });
 
+    it("reads a checkpointed WAL database without creating sidecars or changing bytes", () => {
+        const { dir: directory, cleanup } = createTestTempDir(
+            "mc-plugin-test-xdg-pid-",
+            "immutable-sqlite-",
+        );
+        const path = join(directory, "context.db");
+        try {
+            const writer = new Database(path);
+            writer.exec(
+                "PRAGMA journal_mode=WAL; CREATE TABLE sample (value INTEGER); INSERT INTO sample VALUES (42); PRAGMA wal_checkpoint(TRUNCATE)",
+            );
+            writer.close();
+            expect(existsSync(`${path}-wal`)).toBe(false);
+            expect(existsSync(`${path}-shm`)).toBe(false);
+
+            const before = createHash("sha256").update(readFileSync(path)).digest("hex");
+            const reader = openImmutableDatabase(path);
+            try {
+                expect(reader.prepare("SELECT value FROM sample").get()).toEqual({ value: 42 });
+            } finally {
+                reader.close();
+            }
+            expect(createHash("sha256").update(readFileSync(path)).digest("hex")).toBe(before);
+            expect(existsSync(`${path}-wal`)).toBe(false);
+            expect(existsSync(`${path}-shm`)).toBe(false);
+        } finally {
+            cleanup();
+        }
+    });
+
     it("wraps a missing node:sqlite module with the detected runtime and cause", async () => {
         const cause = Object.assign(new Error("No such built-in module: node:sqlite"), {
             code: "ERR_UNKNOWN_BUILTIN_MODULE",

package/src/shared/sqlite.ts

@@ -8,8 +8,8 @@
  *     flag-free since Node 22.13/23.4).
  *
  * Bun has no `node:sqlite`, and Node/Electron have no `bun:sqlite`. Static
- * imports of either would crash at parse time in the wrong runtime, so we use
- * dynamic imports gated by runtime detection.
+ * imports of either would crash at parse time in the wrong runtime, so the
+ * selected backend is loaded only after runtime detection.
  *
  * Why `node:sqlite` instead of `better-sqlite3`: better-sqlite3 is a native
  * module requiring per-ABI prebuilds, and Electron's ABI never matches the npm
@@ -41,6 +41,7 @@
 
 import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
 import { statSync } from "node:fs";
+import { pathToFileURL } from "node:url";
 
 // Type import only — runtime is loaded dynamically below. @types/better-sqlite3
 // has the richest definitions and is a structural superset of the API surface
@@ -140,6 +141,13 @@ const bunSpec = "bun:" + "sqlite";
 const nodeSpec = "node:" + "sqlite";
 
 async function importSqliteModule(specifier: string): Promise<SqliteModule> {
+    if (specifier === nodeSpec && typeof process.getBuiltinModule === "function") {
+        const loaded = process.getBuiltinModule(specifier) as SqliteModule | undefined;
+        if (loaded) return loaded;
+        throw Object.assign(new Error(`No such built-in module: ${specifier}`), {
+            code: "ERR_UNKNOWN_BUILTIN_MODULE",
+        });
+    }
     // The runtime chooses this specifier; Vite must not resolve it as a
     // build-time dependency because the other runtime's backend is absent.
     return (await import(
@@ -252,6 +260,7 @@ const sqliteModule = await loadSqliteModule(detectedRuntime);
 const DatabaseImpl: typeof BetterSqlite3 = isBun
     ? (sqliteModule.Database as typeof BetterSqlite3)
     : buildNodeSqliteDatabaseClass(sqliteModule.DatabaseSync);
+let immutableDatabaseImpl: typeof BetterSqlite3 | undefined;
 
 interface TrackedSqliteConnection {
     sequence: number;
@@ -655,6 +664,46 @@ function buildNodeSqliteDatabaseClass(DatabaseSync: any): typeof BetterSqlite3 {
 
 export const Database: typeof BetterSqlite3 = TrackedDatabase;
 
+function immutableDatabaseImplementation(): typeof BetterSqlite3 {
+    if (!isBun) return DatabaseImpl;
+    if (immutableDatabaseImpl) return immutableDatabaseImpl;
+
+    const getBuiltinModule = process.getBuiltinModule;
+    if (typeof getBuiltinModule !== "function")
+        throw new SqliteRuntimeUnavailableError(
+            "Bun",
+            nodeSpec,
+            new Error("This Bun runtime does not expose process.getBuiltinModule"),
+        );
+    const nodeSqlite = getBuiltinModule.call(process, nodeSpec) as SqliteModule | undefined;
+    if (!nodeSqlite?.DatabaseSync)
+        throw new SqliteRuntimeUnavailableError(
+            "Bun",
+            nodeSpec,
+            new Error(`No such built-in module: ${nodeSpec}`),
+        );
+
+    immutableDatabaseImpl = buildNodeSqliteDatabaseClass(nodeSqlite.DatabaseSync);
+    return immutableDatabaseImpl;
+}
+
+/** Open a closed SQLite file without asking SQLite to create missing WAL sidecars. */
+export function openImmutableDatabase(path: string): BetterSqlite3.Database {
+    // Immutable mode avoids creating missing WAL sidecars; callers must first rule out writers.
+    const uri = pathToFileURL(path);
+    uri.searchParams.set("immutable", "1");
+    const target = immutableDatabaseImplementation();
+    const db = inRootAsyncContext(
+        () =>
+            Reflect.construct(
+                target,
+                [uri.href, { readonly: true }],
+                target,
+            ) as BetterSqlite3.Database,
+    );
+    return trackSqliteConnection(db, uri.href, { readonly: true });
+}
+
 /** The constructor path, without querying SQLite on the prompt thread. */
 export function getSqliteDatabasePath(db: Database): string | null {
     for (const connection of trackedSqliteConnections.values()) {

package/src/shared/storage-file-mutex-review.test.ts

@@ -1,13 +1,33 @@
-import { expect, test } from "bun:test";
+import { expect, spyOn, test } from "bun:test";
 import { spawnSync } from "node:child_process";
-import { readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readdirSync, readFileSync, rmdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { __resetRpcIdentityTestHooks, __setRpcIdentityTestHooks } from "./rpc-utils";
 import { withStorageFileMutex } from "./storage-file-mutex";
+import * as permissions from "./storage-permissions";
 import { createTestTempDir } from "./test-temp-dir";
 
 const mutex = join(import.meta.dir, "storage-file-mutex.ts");
 
+test("mutex retries ticket creation when empty-directory cleanup wins the mkdir race", () => {
+    const { dir: root, cleanup } = createTestTempDir("mc-mutex-rmdir-");
+    const directory = join(root, "locks");
+    const write = permissions.writeStorageFileSync;
+    let attempts = 0;
+    const writer = spyOn(permissions, "writeStorageFileSync").mockImplementation((...args) => {
+        if (attempts++ === 0) rmdirSync(directory);
+        return write(...args);
+    });
+    try {
+        expect(withStorageFileMutex(directory, () => "acquired")).toBe("acquired");
+        // The successful contender also rewrites its ticket atomically once.
+        expect(attempts).toBe(3);
+    } finally {
+        writer.mockRestore();
+        cleanup();
+    }
+});
+
 async function holder(root: string) {
     const script = `
 import { existsSync } from 'node:fs';

package/src/shared/storage-file-mutex.ts

@@ -68,7 +68,17 @@ export function withStorageFileMutex<T>(directory: string, work: () => T, timeou
     const ticket: Ticket = { choosing: true, number: 0, birth, checksum: "" };
     const encodedTicket = () =>
         JSON.stringify({ ...ticket, checksum: ticketChecksum(name, ticket) });
-    writeStorageFileSync(ownPath, encodedTicket(), { flag: "wx", forcePrivate: true });
+    for (let attempt = 0; ; attempt++) {
+        try {
+            writeStorageFileSync(ownPath, encodedTicket(), { flag: "wx", forcePrivate: true });
+            break;
+        } catch (error) {
+            // A session cleanup can remove an empty directory between mkdir and
+            // ticket creation. No ticket exists yet, so retry before contending.
+            if ((error as NodeJS.ErrnoException).code !== "ENOENT" || attempt >= 2) throw error;
+            ensurePrivateStorageDirectorySync(directory);
+        }
+    }
     const deadline = performance.now() + timeoutMs;
     const peers = (): [string, Ticket | null][] => {
         const found: [string, Ticket | null][] = [];

package/src/shared/subagent-runner.ts

@@ -64,6 +64,8 @@ export interface SubagentRunOptions {
     agent: string;
     systemPrompt: string;
     userMessage: string;
+    /** Hidden historian only: use `write` to retain cache markers for retries or later turns. */
+    cacheTail?: import("./historian-cache").HistorianCacheTail;
     model?: string | undefined;
     fallbackModels?: readonly ModelInput[];
     timeoutMs?: number | undefined;

package/src/shared/system-directive.ts

@@ -5,5 +5,23 @@ export function isSystemDirective(text: string): boolean {
 }
 
 export function removeSystemReminders(text: string): string {
-    return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, "").trim();
+    return removeNestedBlocks(text, ["system-reminder"]).trim();
+}
+
+/** Remove matching tagged regions, including nested regions and regions with no closing tag. */
+export function removeNestedBlocks(text: string, names: readonly string[]): string {
+    const tags = new RegExp(`<(/?)(${names.join("|")})(?:\\s[^<>]*?)?\\s*(/?)>`, "gi");
+    const stack: string[] = [];
+    let end = 0;
+    let result = "";
+    for (const match of text.matchAll(tags)) {
+        if (stack.length === 0) result += text.slice(end, match.index);
+        const name = match[2].toLowerCase();
+        if (match[1]) {
+            if (stack[stack.length - 1] === name) stack.pop();
+        } else if (!match[3]) stack.push(name);
+        end = match.index + match[0].length;
+    }
+    if (stack.length === 0) result += text.slice(end);
+    return result;
 }

package/src/shared/tag-transcript.ts

@@ -835,12 +835,17 @@ class ConversationEndGuard {
         }
     }
 
-    wouldStrand(occurrences: readonly ToolOccurrence[]): boolean {
+    wouldStrand(
+        occurrences: readonly ToolOccurrence[],
+        plannedRemovals?: ReadonlySet<unknown>,
+    ): boolean {
         const end = this.end;
         if (!end || !occurrences.some((occ) => occ.message === end)) return false;
         const leaving = new Set(occurrences.map((occ) => partKey(occ.part)));
         const survives = (part: TranscriptPart) =>
-            !leaving.has(partKey(part)) && !this.removed.has(partKey(part));
+            !leaving.has(partKey(part)) &&
+            !this.removed.has(partKey(part)) &&
+            !plannedRemovals?.has(partKey(part));
         return end.info.role === "assistant"
             ? !end.parts.some((part) => part.kind === "tool_result" && survives(part))
             : !end.parts.some((part) => partHasContent(part) && survives(part));
@@ -1380,8 +1385,11 @@ function buildAggregateTarget(
             }
             return null;
         },
-        wouldStrandConversationEnd(): boolean {
-            return conversationEnd?.wouldStrand(occurrences) ?? false;
+        wouldStrandConversationEnd(plannedRemovals): boolean {
+            return conversationEnd?.wouldStrand(occurrences, plannedRemovals) ?? false;
+        },
+        notePlannedRemoval(plannedRemovals): void {
+            for (const occ of occurrences) plannedRemovals.add(partKey(occ.part));
         },
         editMarker(): "truncated" | "absent" {
             // Edit-marker: preserve the tool_use input's filePath + a region

package/dist/v2/embedding-backfill-jyd6492b.js

@@ -1,23 +0,0 @@
-import {
-  ensureMemoryEmbeddings2
-} from "./server-aavz8pm6.js";
-import"./server-kr2kc9dz.js";
-import"./server-4dhv7mqz.js";
-import"./server-qt1qqasc.js";
-import"./server-gha9x4qq.js";
-import"./server-271qxsf5.js";
-import"./server-hgg55hde.js";
-import"./server-kqpawe1a.js";
-import"./server-rrqpvwqd.js";
-import"./server-e3ftpk7v.js";
-import"./server-785mb90s.js";
-import"./server-6714jebr.js";
-import"./server-51779zs2.js";
-import"./server-6pmqg9m4.js";
-import"./server-0ppsweh6.js";
-import"./server-wafzvyhg.js";
-import"./server-f2xf5gcb.js";
-import"./server-pavzsdc6.js";
-export {
-  ensureMemoryEmbeddings2 as ensureMemoryEmbeddings
-};

package/dist/wrapup-orchestrator-vj2tbp22.js

@@ -1,48 +0,0 @@
-import {
-  runManagedWrapup2
-} from "./index-v9asb16b.js";
-import"./index-v63beg1z.js";
-import"./index-ayym1x7f.js";
-import"./index-f71thw8j.js";
-import"./index-wv9n2zcq.js";
-import"./index-p4vde22c.js";
-import"./index-sd3egckz.js";
-import"./index-9nkg2dzk.js";
-import"./index-qrahzcqv.js";
-import"./index-n78avt2p.js";
-import"./index-4dhv7mqz.js";
-import"./index-v10f1rjv.js";
-import"./index-b17m64g9.js";
-import"./index-qt1qqasc.js";
-import"./index-j6zw70pf.js";
-import"./index-nd7m2a5a.js";
-import"./index-1zx87sdm.js";
-import"./index-mtw9e71a.js";
-import"./index-x8a7jmkh.js";
-import"./index-y9f76s3f.js";
-import"./index-7b2cfmaz.js";
-import"./index-wgypt3cs.js";
-import"./index-saews2s3.js";
-import"./index-hehkf6zm.js";
-import"./index-fkx2qnvw.js";
-import"./index-cj9g0j7a.js";
-import"./index-fb3zxn06.js";
-import"./index-wk0n1cgt.js";
-import"./index-a8bvhwqs.js";
-import"./index-dqe8pq4x.js";
-import"./index-fr0wbhdn.js";
-import"./index-nj7yykkx.js";
-import"./index-n6m03s3n.js";
-import"./index-bp5083x2.js";
-import"./index-58e3y90n.js";
-import"./index-7pa32z07.js";
-import"./index-v0p37hm2.js";
-import"./index-k29z4aqh.js";
-import"./index-hqkczed7.js";
-import"./index-wafzvyhg.js";
-import"./index-j75v2476.js";
-import"./index-g2q4htwp.js";
-import"./index-pavzsdc6.js";
-export {
-  runManagedWrapup2 as runManagedWrapup
-};