@cortexkit/opencode-magic-context 0.49.18 → 0.49.20

package/src/shared/sqlite.ts

@@ -1283,7 +1283,7 @@ export async function withAsyncPrivilegedWriter<T>(
     operation: () => T,
     options: {
         signal?: AbortSignal;
-        beforeRetry?: (error: SqliteAcquisitionBusyError) => void;
+        beforeRetry?: (error: SqliteAcquisitionBusyError) => void | Promise<void>;
         jitter?: boolean;
         budgetMs?: number;
         assertCurrentPass?: () => void;
@@ -1326,7 +1326,9 @@ export async function withAsyncPrivilegedWriter<T>(
             if (entered || !(error instanceof SqliteAcquisitionBusyError)) throw error;
             // Adapters may serve a validated saved request instead of waiting.
             // This runs only after a failed BEGIN, never after callback writes.
-            options.beforeRetry?.(error);
+            // It may read asynchronously (OpenCode 2 reads its host store to
+            // rebuild the transform input); the retry waits for it.
+            await options.beforeRetry?.(error);
             const elapsed = performance.now() - started;
             if (elapsed >= budgetMs) {
                 reportSqliteDiagnostic(

package/src/shared/subagent-runner.ts

@@ -103,6 +103,8 @@ export interface SubagentRunOptions {
 
     /** Optional token accounting metadata. When present, harness runners persist subagent_invocations. */
     accountingSessionId?: string | undefined;
+    /** Config key supplying the selected model, for host refusal diagnostics. */
+    accountingModelConfigKey?: string | undefined;
     accountingSubagent?:
         | "historian"
         | "historian_editor"

package/src/shared/worker-shutdown-fence.test.ts

@@ -0,0 +1,87 @@
+import { expect, test } from "bun:test";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import ts from "typescript";
+
+// A worker that installs exitOnWorkerClose must close its parent port only
+// through the returned closePort, which removes the close listener first. On
+// Bun 1.3.14 a worker whose port closes with that listener still attached never
+// exits, and the port's own close() cannot be wrapped there (it is read-only),
+// so this fence rejects a direct close in any such file.
+
+const root = resolve(import.meta.dir, "../../../..");
+const helper = "packages/plugin/src/shared/worker-shutdown.ts";
+
+function files(dir: string): string[] {
+    return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) return files(path);
+        return /\.tsx?$/.test(path) && !/\.test\.|\.d\.ts$/.test(path) ? [path] : [];
+    });
+}
+
+function unwrap(node: ts.Expression): ts.Expression {
+    let current = node;
+    while (ts.isParenthesizedExpression(current) || ts.isNonNullExpression(current))
+        current = current.expression;
+    return current;
+}
+
+/** Direct closes of the parent port, or of a variable holding it, in a file that installs the close listener. */
+function scan(path: string, text: string): { usesHelper: boolean; violations: string[] } {
+    const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true);
+    const ports = new Set(["parentPort"]);
+    let usesHelper = false;
+    const closes: ts.CallExpression[] = [];
+    const visit = (node: ts.Node) => {
+        if (
+            ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.initializer &&
+            ts.isIdentifier(unwrap(node.initializer)) &&
+            ports.has((unwrap(node.initializer) as ts.Identifier).text)
+        )
+            ports.add(node.name.text);
+        if (ts.isCallExpression(node)) {
+            const callee = unwrap(node.expression);
+            if (ts.isIdentifier(callee) && callee.text === "exitOnWorkerClose") usesHelper = true;
+            if (ts.isPropertyAccessExpression(callee) && callee.name.text === "close")
+                closes.push(node);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    if (!usesHelper || path === helper) return { usesHelper, violations: [] };
+    const violations = closes.flatMap((call) => {
+        const target = unwrap((unwrap(call.expression) as ts.PropertyAccessExpression).expression);
+        if (!ts.isIdentifier(target) || !ports.has(target.text)) return [];
+        const line = source.getLineAndCharacterOfPosition(call.getStart(source)).line + 1;
+        return [
+            `${path}:${line}: close the port through exitOnWorkerClose's closePort, not ${target.text}.close()`,
+        ];
+    });
+    return { usesHelper, violations };
+}
+
+test("workers with the close listener close their port only through closePort", () => {
+    const scans = ["packages/plugin/src", "packages/pi-plugin/src", "packages/cli/src"]
+        .flatMap((directory) => files(join(root, directory)))
+        .map((path) => scan(relative(root, path), readFileSync(path, "utf8")));
+    // Pi tag snapshots, raw-ordinal warm-up, auto-search, the chunk writer and the test fixture.
+    expect(scans.filter((result) => result.usesHelper).length).toBeGreaterThanOrEqual(5);
+    expect(scans.flatMap((result) => result.violations)).toEqual([]);
+});
+
+test("the fence rejects direct port closes and accepts closePort", () => {
+    const header = 'import { parentPort } from "node:worker_threads";\n';
+    const install = "const { closePort } = exitOnWorkerClose(parentPort, () => db.close());\n";
+    expect(scan("worker.ts", `${header}${install}parentPort?.close();`).violations).toHaveLength(1);
+    expect(
+        scan("worker.ts", `${header}const port = parentPort!;\n${install}port.close();`).violations,
+    ).toHaveLength(1);
+    expect(
+        scan("worker.ts", `${header}${install}db.close();\nclosePort();`).violations,
+    ).toHaveLength(0);
+    // A worker without the close listener may close its port directly.
+    expect(scan("worker.ts", `${header}parentPort?.close();`).violations).toHaveLength(0);
+});

package/src/shared/worker-shutdown.fixture.ts

@@ -0,0 +1,25 @@
+// Worker for worker-shutdown.test.ts. "cooperative" closes its connection
+// when asked; "deaf" never reads parent messages, so only terminate() stops it.
+// "finish" installs the close listener, finishes its work and closes its own
+// port through the helper's `closePort()`; the thread must then exit by itself.
+import { parentPort, workerData } from "node:worker_threads";
+import { Database } from "./sqlite";
+import { exitOnWorkerClose } from "./worker-shutdown";
+
+const { path, mode } = workerData as {
+    path: string;
+    mode: "cooperative" | "deaf" | "finish";
+};
+const db = new Database(path);
+db.prepare("SELECT 1").get();
+if (mode === "finish") {
+    const { closePort } = exitOnWorkerClose(parentPort, () => db.close());
+    db.close();
+    parentPort?.postMessage("ready");
+    closePort();
+} else {
+    if (mode === "cooperative") exitOnWorkerClose(parentPort, () => db.close());
+    // Keep the thread alive until it is asked to close or is terminated.
+    setInterval(() => {}, 1_000);
+    parentPort?.postMessage("ready");
+}

package/src/shared/worker-shutdown.test.ts

@@ -0,0 +1,127 @@
+import { Database } from "bun:sqlite";
+import { afterEach, expect, test } from "bun:test";
+import { EventEmitter } from "node:events";
+import { join } from "node:path";
+import { Worker } from "node:worker_threads";
+import { createTestTempDir } from "./test-temp-dir";
+import {
+    createWorkerShutdown,
+    exitOnWorkerClose,
+    getWorkerShutdownStats,
+    type WorkerClosePort,
+} from "./worker-shutdown";
+
+const cleanups: (() => void)[] = [];
+afterEach(() => {
+    for (const cleanup of cleanups.splice(0)) cleanup();
+});
+
+async function start(mode: "cooperative" | "deaf" | "finish") {
+    const { dir, cleanup } = createTestTempDir("mc-worker-shutdown-");
+    cleanups.push(cleanup);
+    const path = join(dir, "store.db");
+    const owner = new Database(path);
+    owner.exec("PRAGMA journal_mode=WAL");
+    cleanups.unshift(() => owner.close());
+    const worker = new Worker(new URL("./worker-shutdown.fixture.ts", import.meta.url), {
+        workerData: { path, mode },
+    });
+    const exitCode = new Promise<number>((resolve) => worker.once("exit", resolve));
+    await new Promise<void>((resolve) => worker.once("message", () => resolve()));
+    return { owner, worker, exitCode };
+}
+
+function counts(site: string) {
+    return { ...(getWorkerShutdownStats().get(site) ?? { graceful: 0, forced: 0 }) };
+}
+
+test("a worker asked to close shuts its connection and exits by itself", async () => {
+    const site = "test-cooperative";
+    const { owner, worker, exitCode } = await start("cooperative");
+    const before = counts(site);
+    const shutdown = createWorkerShutdown(worker, site, 10_000);
+    const started = performance.now();
+    await shutdown.close();
+    // Well inside the deadline: the worker exited on its own, it was not terminated.
+    expect(performance.now() - started).toBeLessThan(5_000);
+    expect(await exitCode).toBe(0);
+    expect(counts(site)).toEqual({ graceful: before.graceful + 1, forced: before.forced });
+    owner.exec("PRAGMA busy_timeout=0");
+    owner.exec("BEGIN IMMEDIATE");
+    owner.exec("ROLLBACK");
+});
+
+test("a worker that does not exit is terminated at the deadline", async () => {
+    const site = "test-deaf";
+    const { worker, exitCode } = await start("deaf");
+    const before = counts(site);
+    const shutdown = createWorkerShutdown(worker, site, 100);
+    const started = performance.now();
+    await shutdown.close();
+    expect(performance.now() - started).toBeGreaterThanOrEqual(90);
+    await exitCode;
+    expect(counts(site)).toEqual({ graceful: before.graceful, forced: before.forced + 1 });
+});
+
+test("closing twice shares one shutdown, and closing an exited worker is a no-op", async () => {
+    const site = "test-repeat";
+    const { worker, exitCode } = await start("cooperative");
+    const before = counts(site);
+    const shutdown = createWorkerShutdown(worker, site, 10_000);
+    const first = shutdown.close();
+    expect(shutdown.close()).toBe(first);
+    await first;
+    await exitCode;
+    expect(counts(site)).toEqual({ graceful: before.graceful + 1, forced: before.forced });
+
+    const exited = await start("deaf");
+    const late = createWorkerShutdown(exited.worker, site, 10_000);
+    await exited.worker.terminate();
+    await exited.exitCode;
+    await late.close();
+    expect(counts(site)).toEqual({ graceful: before.graceful + 1, forced: before.forced });
+});
+
+/** A port that records how many message listeners were attached when it closed. */
+function recordingPort() {
+    const events = new EventEmitter();
+    const closedWith: number[] = [];
+    const port = {
+        on: (event: string, listener: (...args: unknown[]) => void) => {
+            events.on(event, listener);
+            return port;
+        },
+        off: (event: string, listener: (...args: unknown[]) => void) => {
+            events.off(event, listener);
+            return port;
+        },
+        close: () => {
+            closedWith.push(events.listenerCount("message"));
+        },
+    };
+    return { port: port as unknown as WorkerClosePort, events, closedWith };
+}
+
+test("closePort removes the close listener before the port closes", async () => {
+    const { port, events, closedWith } = recordingPort();
+    const { closePort } = exitOnWorkerClose(port, () => {});
+    expect(events.listenerCount("message")).toBe(1);
+    closePort();
+    // Closing again does not close the port twice.
+    closePort();
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Bun 1.3.14 never ends a worker whose port closes with a listener attached.
+    expect(closedWith).toEqual([0]);
+});
+
+test("a worker that closes its own port through closePort exits by itself", async () => {
+    const { worker, exitCode } = await start("finish");
+    const outcome = await Promise.race([
+        exitCode,
+        new Promise<string>((resolve) => setTimeout(() => resolve("no exit"), 5_000)),
+    ]);
+    // Terminate only a worker that is still running: on Bun 1.3.14,
+    // terminate() on a worker that has already exited never settles.
+    if (outcome === "no exit") await worker.terminate();
+    expect(outcome).toBe(0);
+});

package/src/shared/worker-shutdown.ts

@@ -0,0 +1,160 @@
+import type { MessagePort, Worker } from "node:worker_threads";
+
+/**
+ * Stopping a worker thread that still has a SQLite connection open.
+ *
+ * On Bun 1.4.4, `worker.terminate()` closes the worker's open `bun:sqlite`
+ * connections while it tears the thread down, and for that whole teardown
+ * (measured from a few ms up to about 460 ms) every other connection to the same
+ * file gets SQLITE_BUSY when it asks for the writer lock. Reads keep working. A
+ * caller that terminates a worker and then writes at once, such as
+ * `clearSession()` cancelling a session's auto-search backfill, then fails its
+ * own write. Bun 1.4.3 and earlier did not do this, and a worker that closes
+ * its connection itself never causes it on any version.
+ *
+ * So an owner asks the worker to stop: it posts {@link WORKER_CLOSE_MESSAGE},
+ * the worker closes its connections and exits (see {@link exitOnWorkerClose}),
+ * and `terminate()` runs only if the worker has not exited by a deadline. The
+ * deadline is chosen per worker from the longest synchronous SQLite work it may
+ * be in the middle of, because a worker handles the message only between
+ * statements. Bun 1.3 queues parent messages until a worker's entry module has
+ * finished evaluating, so a close posted while the worker is still loading is
+ * handled as soon as it has loaded.
+ */
+export const WORKER_CLOSE_MESSAGE = { kind: "close" } as const;
+
+export function isWorkerCloseMessage(message: unknown): boolean {
+    return (
+        typeof message === "object" &&
+        message !== null &&
+        (message as { kind?: unknown }).kind === WORKER_CLOSE_MESSAGE.kind
+    );
+}
+
+/**
+ * Worker side: when the owner asks this worker to stop, close its connections
+ * and end the thread. `process.exit()` in a worker thread ends only that
+ * thread, on Node and on Bun. Other `message` listeners in the worker see the
+ * same message and must ignore its kind.
+ *
+ * On Bun 1.3.14 a worker whose parent port still has a `message` listener does
+ * not exit after `port.close()`, so this listener must never outlive the port.
+ * A worker that installs it closes its port only through the returned
+ * `closePort`, which removes the listener first (on the next timer turn). The port's own `close()`
+ * cannot be wrapped instead: on Bun 1.3.14 it is a read-only, non-configurable
+ * property. `worker-shutdown-fence.test.ts` rejects any direct port close in a
+ * file that calls this function.
+ */
+export function exitOnWorkerClose(
+    port: WorkerClosePort | null,
+    closeConnections: () => void,
+): { closePort(): void } {
+    const listener = (message: unknown) => {
+        if (!isWorkerCloseMessage(message)) return;
+        try {
+            closeConnections();
+        } finally {
+            // Exit even if a close threw: the thread is ending and a connection
+            // that could not close is released by the thread's teardown instead.
+            process.exit(0);
+        }
+    };
+    if (!port) return { closePort() {} };
+    port.on("message", listener);
+    let closed = false;
+    return {
+        closePort() {
+            if (closed) return;
+            closed = true;
+            // Close on a later timer turn, not synchronously: on Bun 1.3.14 a
+            // port closed while an entry module with a top-level await is still
+            // evaluating does not end the thread. Every current caller closes
+            // its port at the end of the module body or later, so the timer runs
+            // after evaluation has finished.
+            setTimeout(() => {
+                port.off("message", listener);
+                port.close();
+            });
+        },
+    };
+}
+
+/** The parts of a worker's parent port that {@link exitOnWorkerClose} uses. */
+export type WorkerClosePort = Pick<MessagePort, "on" | "off" | "close">;
+
+export interface WorkerShutdown {
+    /**
+     * Ask the worker to close its connections and exit; terminate it if it has
+     * not exited after the deadline. Calling it again returns the same promise.
+     * Resolves once the worker has exited.
+     */
+    close(): Promise<void>;
+}
+
+const outcomes = new Map<string, { graceful: number; forced: number }>();
+
+/** How each site's workers ended after a close, by themselves or terminated. A snapshot. */
+export function getWorkerShutdownStats(): ReadonlyMap<
+    string,
+    { readonly graceful: number; readonly forced: number }
+> {
+    return new Map([...outcomes].map(([site, counts]) => [site, { ...counts }]));
+}
+
+/**
+ * Owner side. Call right after creating the worker, so its exit is observed
+ * even when it exits before anyone asks it to close.
+ *
+ * @param site names the worker in {@link getWorkerShutdownStats}.
+ * @param deadlineMs how long the worker may take to close and exit before it
+ *   is terminated.
+ */
+export function createWorkerShutdown(
+    worker: Worker,
+    site: string,
+    deadlineMs: number,
+): WorkerShutdown {
+    let exited = false;
+    let forced = false;
+    let closing: Promise<void> | undefined;
+    const exit = new Promise<void>((resolve) => {
+        worker.once("exit", () => {
+            exited = true;
+            resolve();
+        });
+    });
+    const record = () => {
+        const counts = outcomes.get(site) ?? { graceful: 0, forced: 0 };
+        if (forced) counts.forced += 1;
+        else counts.graceful += 1;
+        outcomes.set(site, counts);
+    };
+    const terminate = () => {
+        forced = true;
+        void worker.terminate().catch(() => {});
+    };
+    return {
+        close() {
+            if (closing) return closing;
+            if (exited) {
+                closing = Promise.resolve();
+                return closing;
+            }
+            try {
+                worker.postMessage(WORKER_CLOSE_MESSAGE);
+            } catch {
+                terminate();
+            }
+            const fallback = setTimeout(() => {
+                if (!exited) terminate();
+            }, deadlineMs);
+            // A host that is exiting must not wait for this timer.
+            fallback.unref?.();
+            closing = exit.then(() => {
+                clearTimeout(fallback);
+                record();
+            });
+            return closing;
+        },
+    };
+}

package/dist/embedding-backfill-fmz50tsy.js

@@ -1,24 +0,0 @@
-import {
-  ensureMemoryEmbeddings2
-} from "./index-24fezq97.js";
-import"./index-ze7mvk54.js";
-import"./index-4dhv7mqz.js";
-import"./index-qt1qqasc.js";
-import"./index-bjcnntmz.js";
-import"./index-wgypt3cs.js";
-import"./index-rr2bb45z.js";
-import"./index-b5vqckbw.js";
-import"./index-6x57ar45.js";
-import"./index-2vxtcb95.js";
-import"./index-a6mc0v4d.js";
-import"./index-s734jcsr.js";
-import"./index-v0p37hm2.js";
-import"./index-k29z4aqh.js";
-import"./index-c5pytzne.js";
-import"./index-beht37jy.js";
-import"./index-j75v2476.js";
-import"./index-g2q4htwp.js";
-import"./index-pavzsdc6.js";
-export {
-  ensureMemoryEmbeddings2 as ensureMemoryEmbeddings
-};

package/dist/recomp-orchestrator-ghpk2dtq.js

@@ -1,61 +0,0 @@
-import {
-  isRecompFailure2,
-  isRecompSkip2,
-  extractRecompReason2,
-  setRecompStarting2,
-  setRecompNote2,
-  setRecompTerminal2,
-  buildRecompDeps2,
-  runManagedRecomp2
-} from "./index-r4nkrs05.js";
-import"./index-s1ex9y6p.js";
-import"./index-4s3t0nd0.js";
-import"./index-v8awdgvd.js";
-import"./index-x4njr8df.js";
-import"./index-sd3egckz.js";
-import"./index-24fezq97.js";
-import"./index-ze7mvk54.js";
-import"./index-n37sebck.js";
-import"./index-4dhv7mqz.js";
-import"./index-v10f1rjv.js";
-import"./index-s74zqahq.js";
-import"./index-qt1qqasc.js";
-import"./index-rmwykbbb.js";
-import"./index-cf74k5ak.js";
-import"./index-1zx87sdm.js";
-import"./index-kq82mtg0.js";
-import"./index-x8a7jmkh.js";
-import"./index-y9f76s3f.js";
-import"./index-bjcnntmz.js";
-import"./index-wgypt3cs.js";
-import"./index-rr2bb45z.js";
-import"./index-b5vqckbw.js";
-import"./index-6x57ar45.js";
-import"./index-fgncb0ng.js";
-import"./index-fb3zxn06.js";
-import"./index-qn7xstt2.js";
-import"./index-2vxtcb95.js";
-import"./index-a6mc0v4d.js";
-import"./index-fr0wbhdn.js";
-import"./index-nj7yykkx.js";
-import"./index-ke416mdc.js";
-import"./index-bp5083x2.js";
-import"./index-58e3y90n.js";
-import"./index-s734jcsr.js";
-import"./index-v0p37hm2.js";
-import"./index-k29z4aqh.js";
-import"./index-c5pytzne.js";
-import"./index-beht37jy.js";
-import"./index-j75v2476.js";
-import"./index-g2q4htwp.js";
-import"./index-pavzsdc6.js";
-export {
-  buildRecompDeps2 as buildRecompDeps,
-  extractRecompReason2 as extractRecompReason,
-  isRecompFailure2 as isRecompFailure,
-  isRecompSkip2 as isRecompSkip,
-  runManagedRecomp2 as runManagedRecomp,
-  setRecompNote2 as setRecompNote,
-  setRecompStarting2 as setRecompStarting,
-  setRecompTerminal2 as setRecompTerminal
-};

package/dist/v2/embedding-backfill-7c7yr69y.js

@@ -1,23 +0,0 @@
-import {
-  ensureMemoryEmbeddings2
-} from "./server-zzkj2fch.js";
-import"./server-8by8qfec.js";
-import"./server-4dhv7mqz.js";
-import"./server-qt1qqasc.js";
-import"./server-h1v0pyxb.js";
-import"./server-271qxsf5.js";
-import"./server-hy3d3vsx.js";
-import"./server-46neh5fa.js";
-import"./server-6tmj0s7j.js";
-import"./server-rmygf5pn.js";
-import"./server-1wy7b9de.js";
-import"./server-xj136kt8.js";
-import"./server-51779zs2.js";
-import"./server-6pmqg9m4.js";
-import"./server-tgnbmwah.js";
-import"./server-beht37jy.js";
-import"./server-f2xf5gcb.js";
-import"./server-pavzsdc6.js";
-export {
-  ensureMemoryEmbeddings2 as ensureMemoryEmbeddings
-};

package/dist/v2/recomp-orchestrator-4vfxej9t.js

@@ -1,60 +0,0 @@
-import {
-  isRecompFailure2,
-  isRecompSkip2,
-  extractRecompReason2,
-  setRecompStarting2,
-  setRecompNote2,
-  setRecompTerminal2,
-  buildRecompDeps2,
-  runManagedRecomp2
-} from "./server-bfpda1tb.js";
-import"./server-d04vrx0j.js";
-import"./server-my7k4eds.js";
-import"./server-2ehj0bw7.js";
-import"./server-zzkj2fch.js";
-import"./server-n37sebck.js";
-import"./server-8by8qfec.js";
-import"./server-4dhv7mqz.js";
-import"./server-34kwfsr4.js";
-import"./server-a9xqj88f.js";
-import"./server-qt1qqasc.js";
-import"./server-xhab8jx8.js";
-import"./server-27gq4mfz.js";
-import"./server-1zx87sdm.js";
-import"./server-n1prf1g6.js";
-import"./server-h0410h0v.js";
-import"./server-nj659894.js";
-import"./server-tbe1femw.js";
-import"./server-x8a7jmkh.js";
-import"./server-h1v0pyxb.js";
-import"./server-271qxsf5.js";
-import"./server-hy3d3vsx.js";
-import"./server-46neh5fa.js";
-import"./server-6tmj0s7j.js";
-import"./server-a2eqhkxr.js";
-import"./server-fb3zxn06.js";
-import"./server-gpvay0xz.js";
-import"./server-fr0wbhdn.js";
-import"./server-rmygf5pn.js";
-import"./server-1wy7b9de.js";
-import"./server-da07v4xp.js";
-import"./server-g3qma5c0.js";
-import"./server-pwv4ezb0.js";
-import"./server-2ra6pwf3.js";
-import"./server-xj136kt8.js";
-import"./server-51779zs2.js";
-import"./server-6pmqg9m4.js";
-import"./server-tgnbmwah.js";
-import"./server-beht37jy.js";
-import"./server-f2xf5gcb.js";
-import"./server-pavzsdc6.js";
-export {
-  buildRecompDeps2 as buildRecompDeps,
-  extractRecompReason2 as extractRecompReason,
-  isRecompFailure2 as isRecompFailure,
-  isRecompSkip2 as isRecompSkip,
-  runManagedRecomp2 as runManagedRecomp,
-  setRecompNote2 as setRecompNote,
-  setRecompStarting2 as setRecompStarting,
-  setRecompTerminal2 as setRecompTerminal
-};

package/dist/wrapup-orchestrator-s9zc5b00.js

@@ -1,48 +0,0 @@
-import {
-  runManagedWrapup2
-} from "./index-24jbw52d.js";
-import"./index-r4nkrs05.js";
-import"./index-s1ex9y6p.js";
-import"./index-4s3t0nd0.js";
-import"./index-v8awdgvd.js";
-import"./index-x4njr8df.js";
-import"./index-sd3egckz.js";
-import"./index-24fezq97.js";
-import"./index-ze7mvk54.js";
-import"./index-n37sebck.js";
-import"./index-4dhv7mqz.js";
-import"./index-v10f1rjv.js";
-import"./index-s74zqahq.js";
-import"./index-qt1qqasc.js";
-import"./index-rmwykbbb.js";
-import"./index-cf74k5ak.js";
-import"./index-1zx87sdm.js";
-import"./index-kq82mtg0.js";
-import"./index-x8a7jmkh.js";
-import"./index-y9f76s3f.js";
-import"./index-bjcnntmz.js";
-import"./index-wgypt3cs.js";
-import"./index-rr2bb45z.js";
-import"./index-b5vqckbw.js";
-import"./index-6x57ar45.js";
-import"./index-fgncb0ng.js";
-import"./index-fb3zxn06.js";
-import"./index-qn7xstt2.js";
-import"./index-2vxtcb95.js";
-import"./index-a6mc0v4d.js";
-import"./index-fr0wbhdn.js";
-import"./index-nj7yykkx.js";
-import"./index-ke416mdc.js";
-import"./index-bp5083x2.js";
-import"./index-58e3y90n.js";
-import"./index-s734jcsr.js";
-import"./index-v0p37hm2.js";
-import"./index-k29z4aqh.js";
-import"./index-c5pytzne.js";
-import"./index-beht37jy.js";
-import"./index-j75v2476.js";
-import"./index-g2q4htwp.js";
-import"./index-pavzsdc6.js";
-export {
-  runManagedWrapup2 as runManagedWrapup
-};