@cortexkit/opencode-magic-context 0.49.7 → 0.49.8

package/src/shared/sqlite-foreground-wait.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "bun:test";
+import { expect, spyOn, test } from "bun:test";
 import { rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -113,6 +113,220 @@ for (const holdMs of [1000, 2500]) {
     }, 30_000);
 }
 
+for (const holdMs of [1000, 2500]) {
+    test(`slow uncontended SQL preserves admission for a ${holdMs}ms autocommit lock`, async () => {
+        const { db, path, close } = fixture();
+        let locker: SqliteWriteLocker | undefined;
+        let served = false;
+        let refusals = 0;
+        const output = {
+            messages: [
+                {
+                    info: { id: "u", sessionID: "slow", role: "user" },
+                    parts: [{ type: "text", text: "raw" }],
+                },
+            ],
+        };
+        const handler = createMessagesTransformHandler({
+            onStorageBusyRefusal: async () => {
+                refusals++;
+            },
+            magicContext: {
+                "experimental.chat.messages.transform": async (_input, result) => {
+                    // Spend three seconds inside successful SQL, not between writes.
+                    // Recursive work keeps this independent of CPU speed and UDF APIs.
+                    const cte =
+                        "WITH RECURSIVE n(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM n WHERE x<1000000)";
+                    const slowWrite = db.prepare(
+                        `${cte} INSERT INTO result SELECT sum(x) FROM n RETURNING value`,
+                    );
+                    const slowRead = db.prepare(`${cte} SELECT sum(x) FROM n`);
+                    const started = performance.now();
+                    do {
+                        slowWrite.all();
+                        slowRead.all();
+                    } while (performance.now() - started < 3000);
+                    locker = await startSqliteWriteLocker(path, holdMs);
+                    db.prepare("INSERT INTO result VALUES ('managed')").run();
+                    (result.messages[0].parts[0] as { text: string }).text = "managed";
+                },
+            },
+        });
+        try {
+            const pass = handler({}, output as Parameters<typeof handler>[1]).then(() => {
+                served = true;
+            });
+            if (holdMs === 1000) {
+                await pass;
+                expect(served).toBe(true);
+                expect(refusals).toBe(0);
+                expect(output.messages[0].parts[0].text).toBe("managed");
+            } else {
+                await expect(pass).rejects.toBeInstanceOf(StorageBusyRefusalError);
+                expect(served).toBe(false);
+                expect(refusals).toBe(1);
+                expect(output.messages[0].parts[0].text).toBe("raw");
+            }
+            expect(
+                db.prepare("SELECT count(*) AS n FROM result WHERE value = 'managed'").get(),
+            ).toEqual({ n: holdMs === 1000 ? 1 : 0 });
+        } finally {
+            if (locker) expect(await locker.exited).toBe(0);
+            close();
+        }
+    }, 30_000);
+}
+
+test("BUSY autocommit probes do not double-apply INSERT OR IGNORE, UPSERT or RETURNING", async () => {
+    const { db, path, close } = fixture();
+    db.exec(
+        "CREATE TABLE counter(id INTEGER PRIMARY KEY, n INTEGER); INSERT INTO counter VALUES (1, 0)",
+    );
+    const forms = [
+        ["INSERT OR IGNORE INTO counter VALUES (2, 1)", "run"],
+        ["INSERT INTO counter VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET n = n + 1", "run"],
+        ["UPDATE counter SET n = n + 1 WHERE id = 1 RETURNING n", "get"],
+        [
+            "INSERT INTO counter VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET n = n + 1 RETURNING n",
+            "all",
+        ],
+    ] as const;
+    try {
+        for (const [sql, method] of forms) {
+            const blocker = new Database(path);
+            blocker.exec("BEGIN IMMEDIATE");
+            db.exec("PRAGMA busy_timeout=0");
+            const before = db.prepare("SELECT * FROM counter ORDER BY id").all();
+            try {
+                expect(() => db.prepare(sql)[method]()).toThrow("locked");
+                expect(db.prepare("SELECT * FROM counter ORDER BY id").all()).toEqual(before);
+                expect(db.inTransaction).toBe(false);
+            } finally {
+                blocker.exec("ROLLBACK");
+                blocker.close();
+            }
+            const locker = await startSqliteWriteLocker(path, 100);
+            try {
+                await withSqliteTransformPass(() => db.prepare(sql)[method]());
+            } finally {
+                expect(await locker.exited).toBe(0);
+            }
+        }
+        expect(db.prepare("SELECT * FROM counter ORDER BY id").all()).toEqual([
+            { id: 1, n: 3 },
+            { id: 2, n: 1 },
+        ]);
+    } finally {
+        close();
+    }
+}, 30_000);
+
+test("many contended autocommit writes share at most two seconds of lock waiting", async () => {
+    const { db, path, close } = fixture();
+    const blocker = new Database(path);
+    blocker.exec("BEGIN IMMEDIATE");
+    const timeouts: number[] = [];
+    const nativeExec = db.exec.bind(db);
+    const exec = spyOn(db, "exec").mockImplementation((sql) => {
+        const timeout = /^PRAGMA busy_timeout=(\d+)$/.exec(sql);
+        if (timeout) timeouts.push(Number(timeout[1]));
+        return nativeExec(sql);
+    });
+    try {
+        await withSqliteTransformPass(() => {
+            // Use real BUSY failures but a controlled accounting clock: each
+            // retry costs 400ms regardless of runner scheduling. The deadline
+            // keeps the real waits short without hiding lease exhaustion.
+            guardSqliteTransformPass({ assert() {}, remainingMs: () => 10 });
+            let now = 0;
+            const clock = spyOn(performance, "now").mockImplementation(() => (now += 400));
+            try {
+                for (let i = 0; i < 8; i++) {
+                    expect(() => db.prepare("INSERT INTO result VALUES ('one')").run()).toThrow(
+                        SqliteAcquisitionBusyError,
+                    );
+                }
+            } finally {
+                clock.mockRestore();
+            }
+            // Five charged retries exhaust 2000ms. All later retries must have
+            // zero timeout even though the deadline still offers another 10ms.
+            expect(timeouts).toEqual([
+                ...Array.from({ length: 5 }, () => [0, 10, 5000]).flat(),
+                ...Array.from({ length: 3 }, () => [0, 0, 5000]).flat(),
+            ]);
+            blocker.exec("ROLLBACK");
+            db.prepare("INSERT INTO result VALUES ('uncontended')").run();
+        });
+        expect(db.prepare("SELECT * FROM result").all()).toEqual([{ value: "uncontended" }]);
+    } finally {
+        exec.mockRestore();
+        if (blocker.inTransaction) blocker.exec("ROLLBACK");
+        blocker.close();
+        close();
+    }
+}, 30_000);
+
+test("an exec script charges its single attempt without a zero-wait probe", () => {
+    const { db, path, close } = fixture();
+    const blocker = new Database(path);
+    const timeouts: number[] = [];
+    const nativeExec = db.exec.bind(db);
+    const exec = spyOn(db, "exec").mockImplementation((sql) => {
+        const timeout = /^PRAGMA busy_timeout=(\d+)$/.exec(sql);
+        if (timeout) timeouts.push(Number(timeout[1]));
+        return nativeExec(sql);
+    });
+    try {
+        withSqliteTransformPass(() => {
+            let now = 0;
+            const clock = spyOn(performance, "now").mockImplementation(() => (now += 2500));
+            try {
+                db.exec(
+                    "INSERT INTO result VALUES ('prefix'); INSERT INTO result VALUES ('suffix')",
+                );
+            } finally {
+                clock.mockRestore();
+            }
+            blocker.exec("BEGIN IMMEDIATE");
+            expect(() => db.prepare("INSERT INTO result VALUES ('blocked')").run()).toThrow(
+                SqliteAcquisitionBusyError,
+            );
+        });
+        expect(timeouts).toEqual([2000, 5000, 0, 0, 5000]);
+        expect(db.prepare("SELECT * FROM result").all()).toEqual([
+            { value: "prefix" },
+            { value: "suffix" },
+        ]);
+    } finally {
+        exec.mockRestore();
+        if (blocker.inTransaction) blocker.exec("ROLLBACK");
+        blocker.close();
+        close();
+    }
+});
+
+test("an explicit transaction keeps its timeout and never probes or retries", () => {
+    const { db, path, close } = fixture();
+    const other = new Database(path);
+    db.exec("PRAGMA busy_timeout=0; BEGIN; SELECT * FROM result");
+    other.exec("INSERT INTO result VALUES ('other')");
+    const exec = spyOn(db, "exec");
+    try {
+        withSqliteTransformPass(() => {
+            expect(() => db.prepare("INSERT INTO result VALUES ('stale')").run()).toThrow("locked");
+        });
+        expect(exec).not.toHaveBeenCalled();
+        expect(db.inTransaction).toBe(true);
+        expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 0 });
+    } finally {
+        exec.mockRestore();
+        if (db.inTransaction) db.exec("ROLLBACK");
+        other.close();
+        close();
+    }
+});
+
 for (const mode of ["BEGIN", "autocommit"]) {
     test(`foreground ${mode} wait is capped by the pass deadline`, () => {
         const { db, path, close } = fixture();
@@ -138,3 +352,41 @@ for (const mode of ["BEGIN", "autocommit"]) {
         }
     });
 }
+
+test("an autocommit exec script never replays a committed prefix after BUSY", () => {
+    const main = fixture();
+    const auxiliary = fixture();
+    const free = fixture();
+    try {
+        main.db.prepare("ATTACH DATABASE ? AS aux").run(auxiliary.path);
+        main.db.prepare("ATTACH DATABASE ? AS free").run(free.path);
+        auxiliary.db.exec("BEGIN IMMEDIATE");
+        withSqliteTransformPass(() => {
+            guardSqliteTransformPass({ assert() {}, remainingMs: () => 100 });
+            expect(() =>
+                main.db.exec(
+                    "INSERT INTO main.result VALUES ('prefix'); INSERT INTO aux.result VALUES ('blocked')",
+                ),
+            ).toThrow(SqliteAcquisitionBusyError);
+            expect(() =>
+                main.db.exec(
+                    "CREATE TABLE applied_once(id); INSERT INTO aux.result VALUES ('blocked')",
+                ),
+            ).toThrow(SqliteAcquisitionBusyError);
+            expect(() =>
+                main.db.exec(
+                    "CREATE TABLE free.applied_once(id); INSERT INTO aux.result VALUES ('blocked')",
+                ),
+            ).toThrow(SqliteAcquisitionBusyError);
+        });
+        expect(main.db.prepare("SELECT * FROM main.result").all()).toEqual([{ value: "prefix" }]);
+        expect(
+            main.db.prepare("SELECT name FROM sqlite_schema WHERE name='applied_once'").all(),
+        ).toHaveLength(1);
+    } finally {
+        auxiliary.db.exec("ROLLBACK");
+        auxiliary.close();
+        main.close();
+        free.close();
+    }
+});

package/src/shared/sqlite.ts

@@ -39,7 +39,7 @@
  * `run()` → {changes,lastInsertRowid}) is identical and was verified directly.
  */
 
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
 import { statSync } from "node:fs";
 
 // Type import only — runtime is loaded dynamically below. @types/better-sqlite3
@@ -48,6 +48,16 @@ import { statSync } from "node:fs";
 // node:sqlite at runtime (both expose prepare/run/get/all/exec/close).
 import type BetterSqlite3 from "better-sqlite3";
 
+// Capture the root before creating request-local AsyncLocalStorage scopes.
+// Shared workers and timers must not inherit callbacks that reject stale
+// database writes: those callbacks can retain an obsolete request's inputs.
+const resourceRoot = new AsyncResource("magic-context:root");
+
+/** Create host-owned resources without inheriting request-local state. */
+export function inRootAsyncContext<T>(operation: () => T): T {
+    return resourceRoot.runInAsyncScope(operation);
+}
+
 /**
  * Slow-write reporting is injected rather than imported: this module is also
  * executed directly by Node (the `node:sqlite` smoke in CI, Pi, Desktop), and
@@ -420,7 +430,9 @@ function installTransactionRouting(db: BetterSqlite3.Database, readonly: boolean
                 !/^\s*(?:SELECT|EXPLAIN|PRAGMA|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(sql)
             ) {
                 try {
-                    return withAutocommitTimeout(db, () => nativeExec(sql));
+                    // exec can commit a script prefix before BUSY. Run it once;
+                    // only prepared statements are safe to probe and retry.
+                    return withAutocommitTimeout(db, () => nativeExec(sql), false);
                 } finally {
                     if (mayChangeTagIdentity(sql)) tagIdentityWriteGeneration += 1;
                 }
@@ -587,7 +599,9 @@ function trackSqliteConnection(
 
 const TrackedDatabase = new Proxy(DatabaseImpl, {
     construct(target, args) {
-        const db = Reflect.construct(target, args, target) as BetterSqlite3.Database;
+        const db = inRootAsyncContext(
+            () => Reflect.construct(target, args, target) as BetterSqlite3.Database,
+        );
         return trackSqliteConnection(db, args[0], args[1]);
     },
 }) as typeof BetterSqlite3;
@@ -1000,33 +1014,60 @@ function foregroundWaitLease() {
         : undefined;
 }
 
-/** Bound implicit writer admission too, including prepared INSERT OR IGNORE and
- * writes with RETURNING. Charge successful execution time conservatively: the
- * native API cannot separate lock waiting from statement execution. Exhaustion
- * switches to zero-wait acquisition, not a refusal when the writer is free. */
-function withAutocommitTimeout<T>(db: Database, operation: () => T): T {
+/** Probe a prepared statement's writer lock without charging uncontended work
+ * against the foreground lock-wait budget. An exec script may commit some of
+ * its statements before failing, so it cannot be retried without duplicating
+ * writes; conservatively charge its single attempt's full execution time. */
+function withAutocommitTimeout<T>(db: Database, operation: () => T, singleStatement = true): T {
     assertTransformWrite();
     const lease = foregroundWaitLease();
     if (isInTransaction(db)) return operation();
     const scoped = lease || backgroundWriterScope.getStore();
     const previous = scoped ? pragmaNumber(db, "busy_timeout") : null;
-    if (scoped)
-        db.exec(
-            `PRAGMA busy_timeout=${lease ? Math.floor(Math.min(lease.remainingWaitMs, lease.guard?.remainingMs() ?? Infinity)) : SHORT_BUSY_TIMEOUT_MS}`,
-        );
     const started = performance.now();
     let completed = false;
-    try {
+    const execute = () => {
         const result = operation();
         completed = true;
         return result;
+    };
+    try {
+        if (!scoped) return execute();
+        if (singleStatement) {
+            db.exec("PRAGMA busy_timeout=0");
+            try {
+                return execute();
+            } catch (error) {
+                if (!isTransientSqliteError(error) || isInTransaction(db)) throw error;
+            }
+            assertTransformWrite();
+        }
+        const timeout = Math.floor(
+            Math.min(
+                lease?.remainingWaitMs ?? SHORT_BUSY_TIMEOUT_MS,
+                lease?.guard?.remainingMs() ?? Infinity,
+            ),
+        );
+        db.exec(`PRAGMA busy_timeout=${timeout}`);
+        const waitStarted = performance.now();
+        try {
+            return execute();
+        } finally {
+            // Deduct the prepared statement's contended retry or the exec
+            // script's execution from the remaining foreground wait budget;
+            // the native API cannot separate lock waiting from execution.
+            if (lease)
+                lease.remainingWaitMs = Math.max(
+                    0,
+                    lease.remainingWaitMs - (performance.now() - waitStarted),
+                );
+        }
     } catch (error) {
         if (lease && isTransientSqliteError(error))
             throw new SqliteAcquisitionBusyError(error, "autocommit");
         throw error;
     } finally {
         const elapsed = performance.now() - started;
-        if (lease) lease.remainingWaitMs = Math.max(0, lease.remainingWaitMs - elapsed);
         if (previous !== null) db.exec(`PRAGMA busy_timeout=${previous}`);
         // Native autocommit does not expose the instant its lock was acquired.
         // Label the upper bound so a waiting statement is not blamed as a holder.

package/src/shared/user-facing-codes.ts

@@ -17,8 +17,8 @@ export const USER_FACING_FAILURES = {
     history_boundary_unresolved: {
         code: "MC-H04",
         sentence:
-            "This request was not sent: the message that marks where this session's history summary ends is missing from the OpenCode store, and without it the request is larger than the model's context window.",
-        action: "Run /ctx-recomp to rebuild the history summary.",
+            "This request was not sent: Magic Context could not safely place the history summary boundary in the loaded conversation, and the untrimmed request is larger than the model's context window.",
+        action: "Reopen this session in its current project directory, then run /ctx-recomp to rebuild the history summary. A model with a larger context window can also help.",
     },
     history_over_window_unmanaged: {
         code: "MC-H06",

package/dist/embedding-backfill-re16xncd.js

@@ -1,21 +0,0 @@
-import {
-  ensureMemoryEmbeddings2
-} from "./index-w6bd03dc.js";
-import"./index-sf94at64.js";
-import"./index-ax2jhztn.js";
-import"./index-4dhv7mqz.js";
-import"./index-qt1qqasc.js";
-import"./index-gbmqa9x9.js";
-import"./index-vkbqdnkj.js";
-import"./index-g8qbdb03.js";
-import"./index-rzmjkdd6.js";
-import"./index-k6xvbj2e.js";
-import"./index-4mjhqadz.js";
-import"./index-j8epsc0g.js";
-import"./index-qx53vezw.js";
-import"./index-nsjyysj0.js";
-import"./index-0sahzkwr.js";
-import"./index-pavzsdc6.js";
-export {
-  ensureMemoryEmbeddings2 as ensureMemoryEmbeddings
-};

package/dist/recomp-orchestrator-trcgmm23.js

@@ -1,60 +0,0 @@
-import {
-  isRecompFailure2,
-  isRecompSkip2,
-  extractRecompReason2,
-  setRecompStarting2,
-  setRecompNote2,
-  setRecompTerminal2,
-  buildRecompDeps2,
-  runManagedRecomp2
-} from "./index-rwmpkss5.js";
-import"./index-5tbvdff4.js";
-import"./index-sh91t19a.js";
-import"./index-sd3egckz.js";
-import"./index-n7kwfw2r.js";
-import"./index-wq16ahsn.js";
-import"./index-w6bd03dc.js";
-import"./index-9yyqq3mm.js";
-import"./index-sf94at64.js";
-import"./index-ax2jhztn.js";
-import"./index-4dhv7mqz.js";
-import"./index-w23dh319.js";
-import"./index-vt4sf4ep.js";
-import"./index-qt1qqasc.js";
-import"./index-x8a7jmkh.js";
-import"./index-tqf7yg27.js";
-import"./index-gbmqa9x9.js";
-import"./index-vkbqdnkj.js";
-import"./index-4btknbqh.js";
-import"./index-fb3zxn06.js";
-import"./index-j5hce1ab.js";
-import"./index-w4mw92w3.js";
-import"./index-fr0wbhdn.js";
-import"./index-g8qbdb03.js";
-import"./index-rzmjkdd6.js";
-import"./index-n5a170gs.js";
-import"./index-tmtty2x5.js";
-import"./index-1zx87sdm.js";
-import"./index-a8acx4gc.js";
-import"./index-37q80veb.js";
-import"./index-v0p37hm2.js";
-import"./index-k6xvbj2e.js";
-import"./index-h2wc01qk.js";
-import"./index-1bt88epp.js";
-import"./index-58e3y90n.js";
-import"./index-4mjhqadz.js";
-import"./index-j8epsc0g.js";
-import"./index-qx53vezw.js";
-import"./index-nsjyysj0.js";
-import"./index-0sahzkwr.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-xd9ygzgd.js

@@ -1,20 +0,0 @@
-import {
-  ensureMemoryEmbeddings2
-} from "./server-sy4b1sra.js";
-import"./server-fw31krgq.js";
-import"./server-fpqe39as.js";
-import"./server-4dhv7mqz.js";
-import"./server-qt1qqasc.js";
-import"./server-ras2sxnc.js";
-import"./server-hb6xhh9q.js";
-import"./server-kdrezdy0.js";
-import"./server-brhj8qtd.js";
-import"./server-cw6521wn.js";
-import"./server-3t0q2cqx.js";
-import"./server-j8epsc0g.js";
-import"./server-kzns2hbz.js";
-import"./server-t4k4qexw.js";
-import"./server-pavzsdc6.js";
-export {
-  ensureMemoryEmbeddings2 as ensureMemoryEmbeddings
-};

package/dist/v2/recomp-orchestrator-n11zv1f1.js

@@ -1,59 +0,0 @@
-import {
-  isRecompFailure2,
-  isRecompSkip2,
-  extractRecompReason2,
-  setRecompStarting2,
-  setRecompNote2,
-  setRecompTerminal2,
-  buildRecompDeps2,
-  runManagedRecomp2
-} from "./server-mv1w7t6z.js";
-import"./server-x08d1xf3.js";
-import"./server-jdwd03ep.js";
-import"./server-7srtwsa4.js";
-import"./server-sy4b1sra.js";
-import"./server-9yyqq3mm.js";
-import"./server-fw31krgq.js";
-import"./server-fpqe39as.js";
-import"./server-4dhv7mqz.js";
-import"./server-t528t8qm.js";
-import"./server-qcw43339.js";
-import"./server-qt1qqasc.js";
-import"./server-676xw7at.js";
-import"./server-d6g4whc2.js";
-import"./server-vb7pbd9p.js";
-import"./server-x8a7jmkh.js";
-import"./server-ras2sxnc.js";
-import"./server-hb6xhh9q.js";
-import"./server-v4fwha43.js";
-import"./server-fb3zxn06.js";
-import"./server-hcvcxzx7.js";
-import"./server-1rfgbjfn.js";
-import"./server-fr0wbhdn.js";
-import"./server-kdrezdy0.js";
-import"./server-brhj8qtd.js";
-import"./server-gtv9wbhq.js";
-import"./server-w3zeywp1.js";
-import"./server-1zx87sdm.js";
-import"./server-wkdgjjch.js";
-import"./server-dd0nja67.js";
-import"./server-51779zs2.js";
-import"./server-cw6521wn.js";
-import"./server-7ekna9zs.js";
-import"./server-6byqfbqf.js";
-import"./server-2ra6pwf3.js";
-import"./server-3t0q2cqx.js";
-import"./server-j8epsc0g.js";
-import"./server-kzns2hbz.js";
-import"./server-t4k4qexw.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/v2/search-mvgqtkkz.js

@@ -1,46 +0,0 @@
-import {
-  createUnifiedSearchDiagnostics2,
-  searchMessageHistory2,
-  parseIdShapedQuery2,
-  resolveMemoriesByIdsForSearch2,
-  unifiedSearch2,
-  formatSearchResults2
-} from "./server-nfan6zb6.js";
-import"./server-jdwd03ep.js";
-import"./server-7srtwsa4.js";
-import"./server-sy4b1sra.js";
-import"./server-9yyqq3mm.js";
-import"./server-fw31krgq.js";
-import"./server-fpqe39as.js";
-import"./server-4dhv7mqz.js";
-import"./server-qt1qqasc.js";
-import"./server-ras2sxnc.js";
-import"./server-hb6xhh9q.js";
-import"./server-hcvcxzx7.js";
-import"./server-1rfgbjfn.js";
-import"./server-fr0wbhdn.js";
-import"./server-kdrezdy0.js";
-import"./server-brhj8qtd.js";
-import"./server-gtv9wbhq.js";
-import"./server-w3zeywp1.js";
-import"./server-1zx87sdm.js";
-import"./server-wkdgjjch.js";
-import"./server-dd0nja67.js";
-import"./server-51779zs2.js";
-import"./server-cw6521wn.js";
-import"./server-7ekna9zs.js";
-import"./server-6byqfbqf.js";
-import"./server-2ra6pwf3.js";
-import"./server-3t0q2cqx.js";
-import"./server-j8epsc0g.js";
-import"./server-kzns2hbz.js";
-import"./server-t4k4qexw.js";
-import"./server-pavzsdc6.js";
-export {
-  createUnifiedSearchDiagnostics2 as createUnifiedSearchDiagnostics,
-  formatSearchResults2 as formatSearchResults,
-  parseIdShapedQuery2 as parseIdShapedQuery,
-  resolveMemoriesByIdsForSearch2 as resolveMemoriesByIdsForSearch,
-  searchMessageHistory2 as searchMessageHistory,
-  unifiedSearch2 as unifiedSearch
-};

package/dist/wrapup-orchestrator-df61jmz9.js

@@ -1,47 +0,0 @@
-import {
-  runManagedWrapup2
-} from "./index-w6vr754t.js";
-import"./index-rwmpkss5.js";
-import"./index-5tbvdff4.js";
-import"./index-sh91t19a.js";
-import"./index-sd3egckz.js";
-import"./index-n7kwfw2r.js";
-import"./index-wq16ahsn.js";
-import"./index-w6bd03dc.js";
-import"./index-9yyqq3mm.js";
-import"./index-sf94at64.js";
-import"./index-ax2jhztn.js";
-import"./index-4dhv7mqz.js";
-import"./index-w23dh319.js";
-import"./index-vt4sf4ep.js";
-import"./index-qt1qqasc.js";
-import"./index-x8a7jmkh.js";
-import"./index-tqf7yg27.js";
-import"./index-gbmqa9x9.js";
-import"./index-vkbqdnkj.js";
-import"./index-4btknbqh.js";
-import"./index-fb3zxn06.js";
-import"./index-j5hce1ab.js";
-import"./index-w4mw92w3.js";
-import"./index-fr0wbhdn.js";
-import"./index-g8qbdb03.js";
-import"./index-rzmjkdd6.js";
-import"./index-n5a170gs.js";
-import"./index-tmtty2x5.js";
-import"./index-1zx87sdm.js";
-import"./index-a8acx4gc.js";
-import"./index-37q80veb.js";
-import"./index-v0p37hm2.js";
-import"./index-k6xvbj2e.js";
-import"./index-h2wc01qk.js";
-import"./index-1bt88epp.js";
-import"./index-58e3y90n.js";
-import"./index-4mjhqadz.js";
-import"./index-j8epsc0g.js";
-import"./index-qx53vezw.js";
-import"./index-nsjyysj0.js";
-import"./index-0sahzkwr.js";
-import"./index-pavzsdc6.js";
-export {
-  runManagedWrapup2 as runManagedWrapup
-};